sys/arch/hpc/stand/hpcboot/menu/rootwindow.cpp

   1 /* -*-C++-*-    $NetBSD: rootwindow.cpp,v 1.21 2005/12/11 12:17:28 christos Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2001, 2004 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  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <hpcmenu.h>
  33 #include <menu/window.h>
  34 #include <menu/tabwindow.h>
  35 #include <menu/rootwindow.h>
  36 #include <res/resource.h>
  37 #include "../binary/build_number.h"
  38 #include <console.h>
  39
  40 //
  41 // root window
  42 //
  43 RootWindow::RootWindow(HpcBootApp &app)
  44         : Window(app)
  45 {
  46         _boot_button    = 0;
  47         _base           = 0;
  48         _main           = 0;
  49         _option = 0;
  50         _console        = 0;
  51 }
  52
  53 RootWindow::~RootWindow()
  54 {
  55         if (_boot_button)
  56                 delete _boot_button;
  57         if (_cancel_button)
  58                 delete _cancel_button;
  59         if (_progress_bar)
  60                 delete _progress_bar;
  61         if (_main)
  62                 delete _main;
  63         if (_option)
  64                 delete _option;
  65         if (_console)
  66                 delete _console;
  67         if (_base)
  68                 delete _base;
  69 }
  70
  71 BOOL
  72 RootWindow::create(LPCREATESTRUCT aux)
  73 {
  74         TCHAR app_name[32];
  75         // Root window's create don't called by Window Procedure.
  76         // so aux is NULL
  77         HINSTANCE inst = _app._instance;
  78         TCHAR *wc_name = reinterpret_cast <TCHAR *>
  79             (LoadString(inst, IDS_HPCMENU, 0, 0));
  80         wsprintf(app_name, TEXT("%s Build %d"), wc_name, HPCBOOT_BUILD_NUMBER);
  81
  82         _window = CreateWindow(wc_name, app_name, WS_VISIBLE,
  83             CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  84             0, 0, inst, this);
  85         if (!_window)
  86                 return FALSE;
  87
  88         HpcMenuInterface &menu = HpcMenuInterface::Instance();
  89         if (menu._pref.auto_boot > 0)
  90                 SetTimer(_window, IDD_TIMER, menu._pref.auto_boot * 1000, 0);
  91
  92         ShowWindow(_window, SW_SHOW);
  93         UpdateWindow(_window);
  94
  95         return TRUE;
  96 }
  97
  98 BOOL
  99 RootWindow::proc(HWND w, UINT msg, WPARAM wparam, LPARAM lparam)
 100 {
 101         LPCREATESTRUCT aux = reinterpret_cast <LPCREATESTRUCT>(lparam);
 102         HpcMenuInterface &menu = HpcMenuInterface::Instance();
 103
 104         switch(msg) {
 105         default: // message can't handle.
 106                 return FALSE;
 107         case WM_CREATE:
 108                 WMCreate(w, aux);
 109                 break;
 110         case WM_PAINT:
 111                 WMPaint(w, aux);
 112                 break;
 113         case WM_ENTERMENULOOP:
 114                 SaveFocus();
 115                 break;
 116         case WM_EXITMENULOOP:
 117                 RestoreFocus();
 118                 break;
 119         case WM_ACTIVATE:
 120                 if ((UINT)LOWORD(wparam) == WA_INACTIVE)
 121                         SaveFocus();
 122                 else
 123                         RestoreFocus();
 124                 break;
 125         case WM_NOTIFY:
 126         {
 127                 NMHDR *notify = reinterpret_cast <NMHDR *>(lparam);
 128                 // get current selected tab id
 129                 int tab_id = TabCtrl_GetCurSel(_base->_window);
 130                 // get context
 131                 TC_ITEM tc_item;
 132                 tc_item.mask = TCIF_PARAM;
 133                 TabCtrl_GetItem(_base->_window, tab_id, &tc_item);
 134                 TabWindow *tab = reinterpret_cast <TabWindow *>
 135                     (tc_item.lParam);
 136                 switch(notify->code) {
 137                 case TCN_SELCHANGING:
 138                         tab->hide();
 139                         break;
 140                 case TCN_SELCHANGE:
 141                         tab->show();
 142                         break;
 143                 case TCN_KEYDOWN: {
 144                         NMTCKEYDOWN *key = reinterpret_cast
 145                                 <NMTCKEYDOWN *>(lparam);
 146                         return _base->focusManagerHook(key->wVKey, key->flags,
 147                                                 _cancel_button->_window);
 148                     }
 149                 }
 150         }
 151         break;
 152         case WM_TIMER:
 153                 disableTimer();
 154                 goto boot;
 155         case WM_COMMAND:
 156                 switch(wparam)
 157                 {
 158                 case IDC_BOOTBUTTON:
 159                         // inquire current options.
 160                         menu.get_options();
 161                         if (menu._pref.safety_message) {
 162                                 UINT mb_icon = menu._pref.pause_before_boot ?
 163                                         MB_ICONQUESTION : MB_ICONWARNING;
 164                                 if (MessageBox(_window,
 165                                     TEXT("Data in memory will be lost.\nAre you sure?"),
 166                                     TEXT("WARNING"),
 167                                     mb_icon | MB_YESNO) != IDYES)
 168                                         break;
 169                                 UpdateWindow(_window);
 170                         }
 171                 boot:
 172                         SendMessage(_progress_bar->_window, PBM_SETPOS, 0, 0);
 173                         menu.print(TEXT("BOOT START\n"));
 174                         // inquire current options.
 175                         menu.get_options();
 176                         // save options to `hpcboot.cnf'
 177                         menu.save();
 178                         // start boot sequence.
 179                         menu.boot();
 180                         // NOTREACHED
 181                         break;
 182                 case IDC_PROGRESSBAR:
 183                         break;
 184                 case IDC_CANCELBUTTON:
 185                         PostQuitMessage(0);
 186                         break;
 187                 }
 188                 break;
 189         case WM_DESTROY:
 190                 PostQuitMessage(0);
 191                 break;
 192         }
 193         return TRUE;
 194 }
 195
 196 void
 197 RootWindow::SaveFocus() {
 198         _saved_focus = GetFocus();
 199 }
 200
 201 void
 202 RootWindow::RestoreFocus() {
 203         SetFocus(IsWindowEnabled(_saved_focus) ?
 204                  _saved_focus : _boot_button->_window);
 205 }
 206
 207 void
 208 RootWindow::WMPaint(HWND w, LPCREATESTRUCT aux)
 209 {
 210         PAINTSTRUCT ps;
 211         BeginPaint(w, &ps);
 212         EndPaint(w, &ps);
 213 }
 214
 215 void
 216 RootWindow::WMCreate(HWND w, LPCREATESTRUCT aux)
 217 {
 218         int cmdbar_height;
 219
 220         _window = w;
 221         // Command bar.
 222         _app._cmdbar = CommandBar_Create(aux->hInstance, w, IDC_CMDBAR);
 223         CommandBar_AddAdornments(_app._cmdbar, 0, 0);
 224         cmdbar_height = CommandBar_Height(_app._cmdbar);
 225
 226         _button_height = cmdbar_height;
 227         _button_width = BOOT_BUTTON_WIDTH;
 228
 229         HDC hdc = GetDC(0);
 230         if (GetDeviceCaps(hdc, HORZRES) > 320)
 231             _button_width += _button_width/2;
 232         ReleaseDC(0, hdc);
 233
 234         RECT rect;
 235         GetClientRect(w, &rect);
 236         rect.top += cmdbar_height;
 237
 238         // BOOT button.
 239         _boot_button = new BootButton(_app, *this, rect);
 240         _boot_button->create(aux);
 241         // CANCEL button.
 242         _cancel_button = new CancelButton(_app, *this, rect);
 243         _cancel_button->create(aux);
 244         // Progress bar
 245         _progress_bar = new ProgressBar(_app, *this, rect);
 246         _progress_bar->create(aux);
 247
 248         // regsiter myself to menu
 249         HpcMenuInterface::Instance()._root = this;
 250
 251         rect.top += _button_height;
 252         // Tab control.
 253         _base =  new TabWindowBase(_app, w, rect, IDC_BASE);
 254         _base->create(aux);
 255         // main/option/console dialog.(register to Menu)
 256         _main = _base->boot(IDC_BASE_MAIN);
 257         _option = _base->boot(IDC_BASE_OPTION);
 258         _console = _base->boot(IDC_BASE_CONSOLE);
 259
 260         _main->show();
 261         SetFocus(_boot_button->_window);
 262
 263         return;
 264 }
 265
 266 void
 267 RootWindow::disableTimer()
 268 {
 269         KillTimer(_window, IDD_TIMER);
 270 }
 271
 272 BOOL
 273 RootWindow::isDialogMessage(MSG &msg)
 274 {
 275         HWND tab_window;
 276
 277         if (_main && IsWindowVisible(_main->_window))
 278                 tab_window = _main->_window;
 279         else if (_option && IsWindowVisible(_option->_window))
 280                 tab_window = _option->_window;
 281         else if (_console && IsWindowVisible(_console->_window))
 282                 tab_window = _console->_window;
 283
 284         if (focusManagerHook(msg, tab_window))
 285                 return TRUE;
 286
 287         return IsDialogMessage(tab_window, &msg);
 288 }
 289
 290 //
 291 // XXX !!! XXX !!! XXX !!! XXX !!!
 292 //
 293 // WinCE 2.11 doesn't support keyboard focus traversal for nested
 294 // dialogs, so implement poor man focus manager for our root window.
 295 // This function handles focus transition from boot/cancel buttons.
 296 // Transition from the tab-control is done on WM_NOTIFY/TCN_KEYDOWN
 297 // above.
 298 //
 299 // XXX: This is a very smplistic implementation that doesn't handle
 300 // <TAB> auto-repeat count in LOWORD(msg.lParam), WS_GROUP, etc...
 301 //
 302 BOOL
 303 RootWindow::focusManagerHook(MSG &msg, HWND tab_window)
 304 {
 305         HWND next, prev;
 306         HWND dst = 0;
 307         LRESULT dlgcode = 0;
 308
 309         if (msg.message != WM_KEYDOWN)
 310                 return FALSE;
 311
 312         if (msg.hwnd == _boot_button->_window) {
 313                 next = _cancel_button->_window;
 314                 prev = _base->_window;
 315         } else if (msg.hwnd == _cancel_button->_window) {
 316                 next = _base->_window;
 317                 prev = _boot_button->_window;
 318         } else if (tab_window == 0) {
 319                 return FALSE;
 320         } else {
 321                 // last focusable control in the tab_window (XXX: WS_GROUP?)
 322                 HWND last = GetNextDlgTabItem(tab_window, NULL, TRUE);
 323                 if (last == NULL ||
 324                     !(last == msg.hwnd || IsChild(last, msg.hwnd)))
 325                         return FALSE;
 326                 dlgcode = SendMessage(last, WM_GETDLGCODE, NULL, (LPARAM)&msg);
 327                 next = _base->_window; // out of the tab window
 328                 prev = 0;       // let IsDialogMessage handle it
 329         }
 330
 331 #if 0 // XXX: breaks tabbing out of the console window
 332         if (dlgcode & DLGC_WANTALLKEYS)
 333                 return FALSE;
 334 #endif
 335         switch (msg.wParam) {
 336         case VK_RIGHT:
 337         case VK_DOWN:
 338                 if (dlgcode & DLGC_WANTARROWS)
 339                         return FALSE;
 340                 dst = next;
 341                 break;
 342
 343         case VK_LEFT:
 344         case VK_UP:
 345                 if (dlgcode & DLGC_WANTARROWS)
 346                         return FALSE;
 347                 dst = prev;
 348                 break;
 349
 350         case VK_TAB:
 351                 if (dlgcode & DLGC_WANTTAB)
 352                         return FALSE;
 353                 if (GetKeyState(VK_SHIFT) & 0x8000) // Shift-Tab
 354                         dst = prev;
 355                 else
 356                         dst = next;
 357                 break;
 358         }
 359
 360         if (dst == 0)
 361                 return FALSE;
 362
 363         SetFocus(dst);
 364         return TRUE;
 365 }
 366
 367 void
 368 RootWindow::progress(const char *msg)
 369 {
 370
 371         if (msg)
 372                 Console::Instance()->print(TEXT("[progress] %S\n"), msg);
 373
 374         SendMessage(_progress_bar->_window, PBM_STEPIT, 0, 0);
 375 }
 376
 377 void
 378 RootWindow::unprogress()
 379 {
 380         SendMessage(_progress_bar->_window, PBM_SETPOS, 0, 0);
 381 }
 382
 383 //
 384 // BOOT button
 385 //
 386 BOOL
 387 BootButton::create(LPCREATESTRUCT aux)
 388 {
 389         int cx = _root._button_width;
 390         int cy = _root._button_height;
 391
 392         _window = CreateWindow(TEXT("BUTTON"), TEXT("Boot"),
 393             BS_PUSHBUTTON | BS_NOTIFY |
 394             WS_VISIBLE | WS_CHILD | WS_TABSTOP,
 395             _rect.left, _rect.top, cx, cy, _parent_window,
 396             reinterpret_cast <HMENU>(IDC_BOOTBUTTON),
 397             aux->hInstance,
 398             NULL);
 399
 400         return IsWindow(_window) ? TRUE : FALSE;
 401 }
 402
 403 //
 404 // CANCEL button
 405 //
 406 BOOL
 407 CancelButton::create(LPCREATESTRUCT aux)
 408 {
 409         int cx = _root._button_width;
 410         int cy = _root._button_height;
 411         int x = _rect.right - _root._button_width;
 412
 413         _window = CreateWindow(TEXT("BUTTON"), TEXT("Cancel"),
 414             BS_PUSHBUTTON | BS_NOTIFY | WS_TABSTOP |
 415             WS_VISIBLE | WS_CHILD,
 416             x, _rect.top, cx, cy, _parent_window,
 417             reinterpret_cast <HMENU>(IDC_CANCELBUTTON),
 418             aux->hInstance,
 419             NULL);
 420
 421         return IsWindow(_window) ? TRUE : FALSE;
 422 }
 423
 424 //
 425 // PROGRESS BAR
 426 //
 427 BOOL
 428 ProgressBar::create(LPCREATESTRUCT aux)
 429 {
 430         int cx = _rect.right - _rect.left - _root._button_width * 2;
 431         int cy = _root._button_height;
 432         int x = _rect.left + _root._button_width;
 433         _window = CreateWindowEx(WS_EX_CLIENTEDGE,
 434             PROGRESS_CLASS, TEXT(""),
 435             PBS_SMOOTH | WS_VISIBLE | WS_CHILD,
 436             x, _rect.top, cx, cy, _parent_window,
 437             reinterpret_cast <HMENU>(IDC_PROGRESSBAR),
 438             aux->hInstance, NULL);
 439         SendMessage(_window, PBM_SETRANGE, 0, MAKELPARAM(0, 11));
 440         SendMessage(_window, PBM_SETSTEP, 1, 0);
 441         SendMessage(_window, PBM_SETPOS, 0, 0);
 442
 443         return IsWindow(_window) ? TRUE : FALSE;
 444 }