1 /* -*-C++-*- $NetBSD: rootwindow.cpp,v 1.12 2003/12/25 03:44:11 uwe Exp $ */ 2 3 /*- 4 * Copyright (c) 2001 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by UCHIYAMA Yasushi. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <hpcmenu.h> 40 #include <menu/window.h> 41 #include <menu/tabwindow.h> 42 #include <menu/rootwindow.h> 43 #include <res/resource.h> 44 #include "../binary/build_number.h" 45 46 // 47 // root window 48 // 49 RootWindow::RootWindow(HpcBootApp &app) 50 : Window(app) 51 { 52 _boot_button = 0; 53 _base = 0; 54 _main = 0; 55 _option = 0; 56 _console = 0; 57 } 58 59 RootWindow::~RootWindow() 60 { 61 if (_boot_button) 62 delete _boot_button; 63 if (_cancel_button) 64 delete _cancel_button; 65 if (_progress_bar) 66 delete _progress_bar; 67 if (_main) 68 delete _main; 69 if (_option) 70 delete _option; 71 if (_console) 72 delete _console; 73 if (_base) 74 delete _base; 75 } 76 77 BOOL 78 RootWindow::create(LPCREATESTRUCT aux) 79 { 80 TCHAR app_name[32]; 81 // Root window's create don't called by Window Procedure. 82 // so aux is NULL 83 HINSTANCE inst = _app._instance; 84 TCHAR *wc_name = reinterpret_cast <TCHAR *> 85 (LoadString(inst, IDS_HPCMENU, 0, 0)); 86 wsprintf(app_name, TEXT("%s Build %d"), wc_name, HPCBOOT_BUILD_NUMBER); 87 88 _window = CreateWindow(wc_name, app_name, WS_VISIBLE, 89 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 90 0, 0, inst, this); 91 if (!_window) 92 return FALSE; 93 94 HpcMenuInterface &menu = HpcMenuInterface::Instance(); 95 if (menu._pref.auto_boot > 0) 96 SetTimer(_window, IDD_TIMER, menu._pref.auto_boot * 1000, 0); 97 98 ShowWindow(_window, SW_SHOW); 99 UpdateWindow(_window); 100 101 return TRUE; 102 } 103 104 BOOL 105 RootWindow::proc(HWND w, UINT msg, WPARAM wparam, LPARAM lparam) 106 { 107 LPCREATESTRUCT aux = reinterpret_cast <LPCREATESTRUCT>(lparam); 108 HpcMenuInterface &menu = HpcMenuInterface::Instance(); 109 110 switch(msg) { 111 default: // message can't handle. 112 return FALSE; 113 case WM_CREATE: 114 WMCreate(w, aux); 115 break; 116 case WM_PAINT: 117 WMPaint(w, aux); 118 break; 119 case WM_NOTIFY: 120 { 121 NMHDR *notify = reinterpret_cast <NMHDR *>(lparam); 122 // get current selected tab id 123 int tab_id = TabCtrl_GetCurSel(_base->_window); 124 // get context 125 TC_ITEM tc_item; 126 tc_item.mask = TCIF_PARAM; 127 TabCtrl_GetItem(_base->_window, tab_id, &tc_item); 128 TabWindow *tab = reinterpret_cast <TabWindow *> 129 (tc_item.lParam); 130 switch(notify->code) { 131 case TCN_SELCHANGING: 132 tab->hide(); 133 break; 134 case TCN_SELCHANGE: 135 tab->show(); 136 break; 137 } 138 } 139 break; 140 case WM_TIMER: 141 disableTimer(); 142 goto boot; 143 case WM_COMMAND: 144 switch(wparam) 145 { 146 case IDC_BOOTBUTTON: 147 // inquire current options. 148 menu.get_options(); 149 if (menu._pref.safety_message) { 150 UINT mb_icon = menu._pref.pause_before_boot ? 151 MB_ICONQUESTION : MB_ICONWARNING; 152 if (MessageBox(_window, 153 TEXT("Data in memory will be lost.\nAre you sure?"), 154 TEXT("WARNING"), 155 mb_icon | MB_YESNO) != IDYES) 156 break; 157 UpdateWindow(w); 158 } 159 boot: 160 SendMessage(_progress_bar->_window, PBM_SETPOS, 0, 0); 161 menu.print(TEXT("BOOT START\n")); 162 // inquire current options. 163 menu.get_options(); 164 // save options to `hpcboot.cnf' 165 menu.save(); 166 // start boot sequence. 167 menu.boot(); 168 // NOTREACHED 169 break; 170 case IDC_PROGRESSBAR: 171 break; 172 case IDC_CANCELBUTTON: 173 PostQuitMessage(0); 174 break; 175 } 176 break; 177 case WM_DESTROY: 178 PostQuitMessage(0); 179 break; 180 } 181 return TRUE; 182 } 183 184 void 185 RootWindow::WMPaint(HWND w, LPCREATESTRUCT aux) 186 { 187 PAINTSTRUCT ps; 188 BeginPaint(w, &ps); 189 EndPaint(w, &ps); 190 } 191 192 void 193 RootWindow::WMCreate(HWND w, LPCREATESTRUCT aux) 194 { 195 int cmdbar_height; 196 197 _window = w; 198 // Command bar. 199 _app._cmdbar = CommandBar_Create(aux->hInstance, w, IDC_CMDBAR); 200 CommandBar_AddAdornments(_app._cmdbar, 0, 0); 201 cmdbar_height = CommandBar_Height(_app._cmdbar); 202 _button_height = cmdbar_height; 203 204 RECT rect; 205 GetClientRect(w, &rect); 206 rect.top += cmdbar_height; 207 208 // BOOT button. 209 _boot_button = new BootButton(_app, *this, rect); 210 _boot_button->create(aux); 211 // CANCEL button. 212 _cancel_button = new CancelButton(_app, *this, rect); 213 _cancel_button->create(aux); 214 // Progress bar 215 _progress_bar = new ProgressBar(_app, *this, rect); 216 _progress_bar->create(aux); 217 218 // regsiter myself to menu 219 HpcMenuInterface::Instance()._root = this; 220 221 rect.top += _button_height; 222 // Tab control. 223 _base = new TabWindowBase(_app, w, rect, IDC_BASE); 224 _base->create(aux); 225 // main/option/console dialog.(register to Menu) 226 _main = _base->boot(IDC_BASE_MAIN); 227 _option = _base->boot(IDC_BASE_OPTION); 228 _console = _base->boot(IDC_BASE_CONSOLE); 229 230 _main->show(); 231 232 return; 233 } 234 235 void 236 RootWindow::disableTimer() 237 { 238 KillTimer(_window, IDD_TIMER); 239 } 240 241 BOOL 242 RootWindow::isDialogMessage(MSG &msg) 243 { 244 if (_main && IsWindowVisible(_main->_window)) 245 return IsDialogMessage(_main->_window, &msg); 246 if (_option && IsWindowVisible(_option->_window)) 247 return IsDialogMessage(_option->_window, &msg); 248 if (_console && IsWindowVisible(_console->_window)) 249 return IsDialogMessage(_console->_window, &msg); 250 return FALSE; 251 } 252 253 void 254 RootWindow::progress() 255 { 256 SendMessage(_progress_bar->_window, PBM_STEPIT, 0, 0); 257 } 258 259 void 260 RootWindow::unprogress() 261 { 262 SendMessage(_progress_bar->_window, PBM_SETPOS, 0, 0); 263 } 264 265 // 266 // BOOT button 267 // 268 BOOL 269 BootButton::create(LPCREATESTRUCT aux) 270 { 271 int cx = BOOT_BUTTON_WIDTH; 272 int cy = _root._button_height; 273 274 _window = CreateWindow(TEXT("BUTTON"), TEXT("Boot"), 275 BS_PUSHBUTTON | BS_NOTIFY | 276 WS_VISIBLE | WS_CHILD | WS_TABSTOP, 277 _rect.left, _rect.top, cx, cy, _parent_window, 278 reinterpret_cast <HMENU>(IDC_BOOTBUTTON), 279 aux->hInstance, 280 NULL); 281 282 return IsWindow(_window) ? TRUE : FALSE; 283 } 284 285 // 286 // CANCEL button 287 // 288 BOOL 289 CancelButton::create(LPCREATESTRUCT aux) 290 { 291 int cx = BOOT_BUTTON_WIDTH; 292 int cy = _root._button_height; 293 int x = _rect.right - BOOT_BUTTON_WIDTH; 294 295 _window = CreateWindow(TEXT("BUTTON"), TEXT("Cancel"), 296 BS_PUSHBUTTON | BS_NOTIFY | WS_TABSTOP | 297 WS_VISIBLE | WS_CHILD, 298 x, _rect.top, cx, cy, _parent_window, 299 reinterpret_cast <HMENU>(IDC_CANCELBUTTON), 300 aux->hInstance, 301 NULL); 302 return IsWindow(_window) ? TRUE : FALSE; 303 } 304 305 // 306 // PROGRESS BAR 307 // 308 BOOL 309 ProgressBar::create(LPCREATESTRUCT aux) 310 { 311 int cx = _rect.right - _rect.left - BOOT_BUTTON_WIDTH * 2; 312 int cy = _root._button_height; 313 int x = _rect.left + BOOT_BUTTON_WIDTH; 314 _window = CreateWindowEx(WS_EX_CLIENTEDGE, 315 PROGRESS_CLASS, TEXT(""), 316 PBS_SMOOTH | WS_VISIBLE | WS_CHILD, 317 x, _rect.top, cx, cy, _parent_window, 318 reinterpret_cast <HMENU>(IDC_PROGRESSBAR), 319 aux->hInstance, NULL); 320 SendMessage(_window, PBM_SETRANGE, 0, MAKELPARAM(0, 11)); 321 SendMessage(_window, PBM_SETSTEP, 1, 0); 322 SendMessage(_window, PBM_SETPOS, 0, 0); 323 324 return IsWindow(_window) ? TRUE : FALSE; 325 } 326