test: syscmd.c File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# syscmd.c File Reference

`#include "precomp.h"`

Go to the source code of this file.

## Functions

void | xxxHandleNCMouseGuys (PWND pwnd, UINT message, int htArea, LPARAM lParam)
void | StartScreenSaver (BOOL bOnlyIfSecure)
void | xxxSysCommand (PWND pwnd, DWORD cmd, LPARAM lParam)
BOOL | _RegisterTasklist (PWND pwndTasklist)

## Function Documentation

BOOL _RegisterTasklist | ( | PWND | pwndTasklist | ) |

Definition at line 583 of file syscmd.c.

References BOOL, GETPTI, ghwndSwitch, gptiTasklist, HWq, PsGetCurrentThread, TIF_DONTATTACHQUEUE, and TRUE.

Referenced by NtUserRegisterTasklist().

    00585 {
    00586 #ifdef LATER
    00587     //
    00588     // JimA - ??? Why do this?
    00589     //
    00590     PETHREAD Thread;
    00591
    00592     Thread = PsGetCurrentThread();
    00593     pRitCSRThread->ThreadHandle = Thread->ThreadHandle;
    00594 #endif
    00595
    00596     gptiTasklist = GETPTI(pwndTasklist);
    00597     ghwndSwitch = HWq(pwndTasklist);
    00598
    00599     /*
    00600      * Don't allow an app to call AttachThreadInput() on task man -
    00601      * we want taskman to be unsynchronized at all times (so the user
    00602      * can bring it up and kill other apps).
    00603      */
    00604     GETPTI(pwndTasklist)->TIF_flags |= TIF_DONTATTACHQUEUE;
    00605
    00606     return TRUE;
    00607 }

void StartScreenSaver | ( | BOOL | bOnlyIfSecure | ) |

Definition at line 165 of file syscmd.c.

References _PostMessage(), tagPOWERSTATE::fInProgress, gPowerState, gppiScreenSaver, gspwndLogonNotify, and NULL.

Referenced by IdleTimerProc(), and xxxSysCommand().

    00167 {
    00168     /*
    00169      * If a screen saver is already running or we're in the midst of powering
    00170      * down the machine, ignore this request.
    00171      */
    00172     if (gppiScreenSaver != NULL || gPowerState.fInProgress)
    00173         return;
    00174
    00175     if (gspwndLogonNotify != NULL) {
    00176         /*
    00177          * Let the logon process take care of the screen saver
    00178          */
    00179         _PostMessage(gspwndLogonNotify,
    00180                 WM_LOGONNOTIFY, LOGON_INPUT_TIMEOUT, bOnlyIfSecure);
    00181     }
    00182 }

void xxxHandleNCMouseGuys | ( | PWND | pwnd,
|  | UINT | message,
|  | int | htArea,
|  | LPARAM | lParam
| ) |

Definition at line 23 of file syscmd.c.

References _GetMenuState(), AW_USE2, CheckLock, GetTopLevelWindow(), TestWF, ThreadLock, ThreadUnlock, UINT, WFMAXBOX, WFMAXIMIZED, WFMINIMIZED, WFSYSMENU, xxxActivateWindow(), xxxGetSysMenuHandle(), xxxSendMessage(), and xxxSetSysMenu().

Referenced by xxxDWP_NCMouse().

    00028 {
    00029     UINT syscmd;
    00030     PWND pwndT;
    00031     TL tlpwndT;
    00032
    00033     CheckLock(pwnd);
    00034
    00035     syscmd = 0xFFFF;
    00036
    00037     switch (htArea) {
    00038
    00039     case HTCAPTION:
    00040         switch (message) {
    00041
    00042         case WM_NCLBUTTONDBLCLK:
    00043             if (TestWF(pwnd, WFMINIMIZED) || TestWF(pwnd, WFMAXIMIZED)) {
    00044                 syscmd = SC_RESTORE;
    00045             } else if (TestWF(pwnd, WFMAXBOX)) {
    00046                 syscmd = SC_MAXIMIZE;
    00047             }
    00048             break;
    00049
    00050         case WM_NCLBUTTONDOWN:
    00051             pwndT = GetTopLevelWindow(pwnd);
    00052             ThreadLock(pwndT, &tlpwndT);
    00053             xxxActivateWindow(pwndT, AW_USE2);
    00054             ThreadUnlock(&tlpwndT);
    00055             syscmd = SC_MOVE;
    00056             break;
    00057         }
    00058         break;
    00059
    00060     case HTSYSMENU:
    00061     case HTMENU:
    00062     case HTHSCROLL:
    00063     case HTVSCROLL:
    00064         if (message == WM_NCLBUTTONDOWN || message == WM_NCLBUTTONDBLCLK) {
    00065             switch (htArea) {
    00066             case HTSYSMENU:
    00067                 if (message == WM_NCLBUTTONDBLCLK) {
    00068                     syscmd = SC_CLOSE;
    00069                     break;
    00070                 }
    00071
    00072             /*
    00073              *** FALL THRU **
    00074              */
    00075
    00076             case HTMENU:
    00077                 syscmd = SC_MOUSEMENU;
    00078                 break;
    00079
    00080             case HTHSCROLL:
    00081                 syscmd = SC_HSCROLL;
    00082                 break;
    00083
    00084             case HTVSCROLL:
    00085                 syscmd = SC_VSCROLL;
    00086                 break;
    00087             }
    00088         }
    00089         break;
    00090     }
    00091
    00092     switch (syscmd) {
    00093
    00094     case SC_MINIMIZE:
    00095     case SC_MAXIMIZE:
    00096     case SC_CLOSE:
    00097
    00098         /*
    00099          * Only do double click commands on an upclick.
    00100          * This code is very sensitive to changes from this state.
    00101          * Eat any mouse messages.
    00102          */
    00103
    00104         /*
    00105          * Bug #152: WM_NCLBUTTONUP message missing from double click.
    00106          * This code was broken in Windows 3.x and the test for whether
    00107          * the mouse button was down always failed, so no mouse messages
    00108          * were ever eaten. We'll emulate this by not even doing the test.
    00109          *
    00110          *
    00111          * {
    00112          *     PQ pqCurrent;
    00113          *     MSG msg;
    00114          *
    00115          *     pqCurrent = PtiCurrent()->pq;
    00116          *     if (TestKeyStateDown(pqCurrent, VK_LBUTTON)) {
    00117          *         xxxCapture(PtiCurrent(), pwnd, WINDOW_CAPTURE);
    00118          *
    00119          *         while (TestKeyStateDown(pqCurrent, VK_LBUTTON)) {
    00120          *             if (!xxxPeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST,
    00121          *                     PM_REMOVE)) {
    00122          *                 if (!xxxSleepThread(QS_MOUSE, 0, TRUE))
    00123          *                     break;
    00124          *             }
    00125          *         }
    00126          *
    00127          *         xxxReleaseCapture();
    00128          *
    00129          *     }
    00130          * }
    00131          *
    00132          */
    00133
    00134         /*
    00135          ** FALL THRU **
    00136          */
    00137     case SC_SIZE:
    00138     case SC_MOVE:
    00139         /*
    00140          * For SysCommands on system menu, don't do if menu item is
    00141          * disabled.
    00142          */
    00143         if (TestWF(pwnd, WFSYSMENU)) {
    00144             xxxSetSysMenu(pwnd);
    00145             if (_GetMenuState(xxxGetSysMenuHandle(pwnd), (syscmd & 0xFFF0),
    00146                     MF_BYCOMMAND) & MFS_GRAYED) {
    00147                 return;
    00148             }
    00149         }
    00150         break;
    00151     }
    00152
    00153     if (syscmd != 0xFFFF) {
    00154         xxxSendMessage(pwnd, WM_SYSCOMMAND, syscmd | htArea, lParam);
    00155     }
    00156 }

void xxxSysCommand | ( | PWND | pwnd,
|  | DWORD | cmd,
|  | LPARAM | lParam
| ) |

Definition at line 193 of file syscmd.c.

References _GetDesktopWindow(), _GetKeyState(), _GetLastActivePopup(), _GetMessagePos(), _PostMessage(), _PostThreadMessage(), CheckLock, tagLASTINPUT::dwFlags, DWORD, FALSE, FCallHookTray, FDoTray, tagPOWERSTATE::fInProgress, tagMENUSTATE::fModelessMenu, FPostTray, tagMENUSTATE::fUnderline, GETPTI, ghwndSwitch, glinp, gpDispInfo, gPowerState, gpqForeground, gpsi, gptiTasklist, gspwndFullScreen, gspwndInternalCapture, tagWND::head, HWq, IsHooked, L, LINP_LOWPOWER, LINP_POWEROFF, LINP_POWERTIMEOUTS, LOWPOWER_PHASE, MENUSYSMENU, NULL, tagMENUSTATE::pGlobalPopupMenu, PlayEventSound(), tagDISPLAYINFO::pmdev, POWEROFF_PHASE, POWERON_PHASE, tagTHREADINFO::pq, PtiCurrent, tagLASTINPUT::ptiLastWoken, tagMENUSTATE::ptiMenuStateOwner, PUDF_ANIMATE, PWND_TOP, QF_CAPTURELOCKED, RevalidateHwnd, SCROLL_DIRECT, SCROLL_NORMAL, tagQ::spwndCapture, StartScreenSaver(), TEST_PUDF, TestWF, ThreadLock, ThreadLockAlways, ThreadUnlock, TIF_16BIT, tagTHREADINFO::TIF_flags, TRUE, UINT, tagSERVERINFO::uiShellMsg, USER_SOUND_MAXIMIZE, USER_SOUND_MINIMIZE, USER_SOUND_RESTOREDOWN, USER_SOUND_RESTOREUP, ValidateHwnd, WFCHILD, WFDISABLED, WFMAXIMIZED, WFMINIMIZED, WHF_CBT, xxxCallHook(), xxxHelpLoop(), xxxIsDragging(), xxxMakeWindowForegroundWithState(), xxxMNEndMenuState(), xxxMNKeyFilter(), xxxMNLoop(), xxxMNStartMenuState(), xxxMoveSize(), xxxOldNextWindow(), xxxSBTrackInit(), xxxSendMessage(), xxxSetForegroundWindow(), xxxSetWindowPos(), and xxxShowWindow().

Referenced by xxxDefWindowProc().

    00197 {
    00198     UINT        htArea;
    00199     PWND        pwndSwitch;
    00200     PMENUSTATE  pMenuState;
    00201     TL          tlpwnd;
    00202     POINT       pt;
    00203     DWORD       dw;
    00204     PWND        pwndCapture;
    00205     PTHREADINFO pti;
    00206
    00207     CheckLock(pwnd);
    00208
    00209     htArea = (UINT)(cmd & 0x0F);
    00210     cmd -= htArea;
    00211
    00212     /*
    00213      * Intense hack o' death.
    00214      */
    00215     if (lParam == 0x00010000L)
    00216         lParam = 0L;
    00217
    00218     /*
    00219      * If the system doesn't have capture (ie CLENT_CAPTURE_INTERNAL)
    00220      * do the sys command.  Also, do the sys command for the special case
    00221      * where the window receiving the sys command is a console window that
    00222      * is in full screen mode.  In this case we let the sys command through.
    00223      *
    00224      * Also if this a SC_SCREENSAVE then we handle it anyway and
    00225      * switching desktops will do the cancel.  SC_SCREENSAVER
    00226      * is special so we can start the screen saver even if we are in
    00227      * menu mode for security so NT bug 10975 Banker's Trust
    00228      */
    00229     pti = GETPTI(pwnd);
    00230
    00231     /*
    00232      * For 32bit apps (and apps on seperate queues), we need to check
    00233      * the capture in the queue.  Otherwise, on MDI child-destruction
    00234      * we would get the restore when they shouldn't.  This broke MSGOLF
    00235      * who during the restore, AV'd because they assumed this wouldn't
    00236      * happen. On 16bit shared apps, we want to check the internal
    00237      * capture.  Otherwise, when doing 16bit drag-and-drop, we would
    00238      * not restore the minimized window if we had a queue-capture-window.
    00239      */
    00240
    00241     /*
    00242      * But... it is too broad a change to just check internal capture for all WoW apps. Some
    00243      * apps depend on bailing out when they have capture set. (Adobe Persuasion, NT bug 68794,
    00244      * for SC_MOVE).  So, let's restrict the hack to SC_RESTORE to keep Ole drag-and-drop working.
    00245      * See NT bug 6109. FritzS
    00246      */
    00247
    00248     pwndCapture = ((pti->TIF_flags & TIF_16BIT) && (cmd == SC_RESTORE)) ? gspwndInternalCapture :
    00249                                                  pti->pq->spwndCapture;
    00250
    00251     if ((!pwndCapture && !TestWF(pwnd, WFDISABLED)) ||
    00252         (pwnd == gspwndFullScreen)                  ||
    00253         (cmd == SC_SCREENSAVE)                      ||
    00254         (cmd == SC_MONITORPOWER)                    ||
    00255         (cmd == SC_TASKLIST)) {
    00256
    00257         /*
    00258          * Perform the sys command
    00259          */
    00260
    00261 #ifdef SYSMODALWINDOWS
    00262         if (gspwndSysModal != NULL) {
    00263             switch (cmd) {
    00264             case SC_SIZE:
    00265             case SC_MOVE:
    00266             case SC_MINIMIZE:
    00267             case SC_MAXIMIZE:
    00268             case SC_NEXTWINDOW:
    00269             case SC_PREVWINDOW:
    00270             case SC_SCREENSAVE:
    00271                 return;
    00272             }
    00273         }
    00274 #endif
    00275
    00276         /*
    00277          * Call the CBT hook asking if it's okay to do this command.
    00278          * If not, return from here.
    00279          */
    00280         if (IsHooked(PtiCurrent(), WHF_CBT) && xxxCallHook(HCBT_SYSCOMMAND,
    00281                 (DWORD)cmd, (DWORD)lParam, WH_CBT)) {
    00282             return;
    00283         }
    00284
    00285         switch (cmd) {
    00286         case SC_RESTORE:
    00287             cmd = SW_RESTORE;
    00288             if (TestWF(pwnd, WFMINIMIZED) || !TestWF(pwnd, WFMAXIMIZED))
    00289                 PlayEventSound(USER_SOUND_RESTOREUP);
    00290             else
    00291                 PlayEventSound(USER_SOUND_RESTOREDOWN);
    00292             goto MinMax;
    00293
    00294
    00295         case SC_MINIMIZE:
    00296             cmd = SW_MINIMIZE;
    00297
    00298             /*
    00299              * Are we already minimized?
    00300              */
    00301             if (TestWF(pwnd, WFMINIMIZED))
    00302                 break;
    00303
    00304             PlayEventSound(USER_SOUND_MINIMIZE);
    00305
    00306             goto MinMax;
    00307         case SC_MAXIMIZE:
    00308             cmd = SW_SHOWMAXIMIZED;
    00309
    00310             /*
    00311              * Are we already maximized?
    00312              */
    00313             if (TestWF(pwnd, WFMAXIMIZED))
    00314                 break;
    00315
    00316             PlayEventSound(USER_SOUND_MAXIMIZE);
    00317 MinMax:
    00318             xxxShowWindow(pwnd, cmd | TEST_PUDF(PUDF_ANIMATE));
    00319             return;
    00320
    00321         case SC_SIZE:
    00322             {
    00323                 xxxMoveSize(pwnd, htArea, _GetMessagePos());
    00324             }
    00325             return;
    00326
    00327         case SC_MOVE:
    00328             //
    00329             // Don't enter movesize loop unless the user is actually
    00330             // dragging from the caption.  Otherwise, put up the system
    00331             // menu on a minimized window.
    00332             //
    00333
    00334             //
    00335             // Are we dragging with the left mouse button?
    00336             //
    00337             dw = _GetMessagePos();
    00338             POINTSTOPOINT( pt, MAKEPOINTS(dw));
    00339             if ( !htArea ||
    00340                  xxxIsDragging(pwnd, pt, WM_LBUTTONUP)) {
    00341
    00342                 /*
    00343                  * We are moving.  Enter move/size loop.
    00344                  */
    00345                 {
    00346                     xxxMoveSize(pwnd, (htArea == 0) ? WMSZ_KEYMOVE : WMSZ_MOVE, dw);
    00347                 }
    00348             } else {
    00349
    00350                 /*
    00351                  * Activate our window, just like we would have in
    00352                  * MoveSize().
    00353                  */
    00354                 xxxSetWindowPos(pwnd, PWND_TOP, 0, 0, 0, 0,
    00355                                 SWP_NOMOVE | SWP_NOSIZE);
    00356                 if (TestWF(pwnd, WFMINIMIZED)) {
    00357
    00358                     /*
    00359                      * Try to popup the system menu
    00360                      */
    00361                     xxxSendMessage(pwnd, WM_SYSCOMMAND, SC_KEYMENU,
    00362                             (DWORD) (TestWF(pwnd, WFCHILD) ? '-' : MENUSYSMENU));
    00363                 }
    00364             }
    00365             return;
    00366
    00367         case SC_CLOSE:
    00368             xxxSendMessage(pwnd, WM_CLOSE, 0L, 0L);
    00369             return;
    00370
    00371         case SC_NEXTWINDOW:
    00372         case SC_PREVWINDOW:
    00373             xxxOldNextWindow((UINT)lParam);
    00374             break;
    00375
    00376         case SC_CONTEXTHELP:
    00377             xxxHelpLoop(pwnd);
    00378             break;
    00379
    00380         case SC_KEYMENU:
    00381
    00382             /*
    00383              * A menu was selected via keyboard
    00384              */
    00385             pMenuState = xxxMNStartMenuState(pwnd, cmd, lParam);
    00386             if (pMenuState != NULL) {
    00387                 UserAssert(PtiCurrent() == pMenuState->ptiMenuStateOwner);
    00388
    00389                 /*
    00390                  * Make sure we are not fullscreen
    00391                  */
    00392                 if (gspwndFullScreen == pwnd) {
    00393                     PWND pwndT;
    00394                     TL tlpwndT;
    00395
    00396                     pwndT = _GetDesktopWindow();
    00397                     ThreadLock(pwndT, &tlpwndT);
    00398                     xxxMakeWindowForegroundWithState(pwndT, GDIFULLSCREEN);
    00399                     ThreadUnlock(&tlpwndT);
    00400                 }
    00401
    00402                 pMenuState->fUnderline = TRUE;
    00403                 xxxMNKeyFilter(pMenuState->pGlobalPopupMenu, pMenuState, (UINT)lParam);
    00404                 if (!pMenuState->fModelessMenu) {
    00405                     xxxMNEndMenuState (TRUE);
    00406                 }
    00407             }
    00408             /*
    00409              * Capture must have been unlocked
    00410              */
    00411             UserAssert(!(PtiCurrent()->pq->QF_flags & QF_CAPTURELOCKED));
    00412             return;
    00413
    00414         case SC_MOUSEMENU:
    00415         case SC_DEFAULT:
    00416
    00417             /*
    00418              * If the window is not foreground, eat the command to avoid
    00419              * wasting time flashing the system menu.
    00420              *
    00421              * We used to check if the top level window was WFFRAMEON (so a
    00422              * child window's system menu works like Win 3.1) but Excel's
    00423              * (SDM) dialogs allow you to access their menus even though
    00424              * the child and parent appear to be inactive.
    00425              */
    00426             if (!(GETPTI(pwnd)->pq == gpqForeground))
    00427                 return;
    00428
    00429             /*
    00430              * A mouse click occurred on a toplevel menu.
    00431              */
    00432             pMenuState = xxxMNStartMenuState(pwnd, cmd, lParam);
    00433             if (pMenuState != NULL) {
    00434                 UserAssert(PtiCurrent() == pMenuState->ptiMenuStateOwner);
    00435                 xxxMNLoop(pMenuState->pGlobalPopupMenu, pMenuState, lParam, (cmd==SC_DEFAULT));
    00436                 if (!pMenuState->fModelessMenu) {
    00437                     xxxMNEndMenuState (TRUE);
    00438                 }
    00439             }
    00440             /*
    00441              * Capture must have been unlocked
    00442              */
    00443             UserAssert(!(PtiCurrent()->pq->QF_flags & QF_CAPTURELOCKED));
    00444             return;
    00445
    00446         case SC_VSCROLL:
    00447         case SC_HSCROLL:
    00448             xxxSBTrackInit(pwnd, lParam, htArea, (_GetKeyState(VK_SHIFT) < 0) ? SCROLL_DIRECT : SCROLL_NORMAL);
    00449             return;
    00450
    00451         case SC_TASKLIST:
    00452 //            _PostThreadMessage(gptiTasklist, WM_SYSCOMMAND, SC_TASKLIST, 0);
    00453 //            if (!FCallTray() ||
    00454 //                !CallHook(HSHELL_TASKMAN, (WPARAM) HW16(hwnd), (LPARAM) 0, WH_SHELL))
    00455
    00456             /*
    00457              * Winlogon will set lParam to -1 to indicate that we really want a task list,
    00458              * not just the start menu.  We indicate this to the shell by passing a NULL
    00459              * window ptr
    00460              * This message is really intended for the SHELL, so give them the right
    00461              *  to set the foreground.
    00462              */
    00463             if (FDoTray() && (FCallHookTray() || FPostTray(pwnd->head.rpdesk))) {
    00464                 PWND pwndTaskman = pwnd->head.rpdesk->pDeskInfo->spwndTaskman;
    00465                 if (FCallHookTray()) {
    00466                     xxxCallHook(HSHELL_TASKMAN, (WPARAM)HWq(pwnd), (LPARAM) 0, WH_SHELL);
    00467                 }
    00468                 if ((FPostTray(pwnd->head.rpdesk)) && (pwndTaskman != NULL)) {
    00469                     glinp.ptiLastWoken = GETPTI(pwndTaskman);
    00470                     _PostMessage(pwndTaskman, gpsi->uiShellMsg, HSHELL_TASKMAN,
    00471                             lParam == (ULONG)(-1) ? (LPARAM) -1 :(LPARAM)HWq(pwnd));
    00472                 }
    00473             } else if (gptiTasklist != NULL) {
    00474                  glinp.ptiLastWoken = gptiTasklist;
    00475                 _PostThreadMessage(gptiTasklist, WM_SYSCOMMAND, SC_TASKLIST, 0);
    00476 // LATER -- FritzS
    00477 //                HCURSOR hCursorLast;
    00478 //                static char CODESEG szTask[] = " %d %d";
    00479
    00480 //                ShowCursor(TRUE);
    00481 //                hCursorLast = SetCursor32(hCursWait, TRUE);
    00482
    00483                 // Try in the windows directory first.
    00484 //                GetWindowsDirectory(szBuff, sizeof(szBuff));
    00485 //                if (szBuff[lstrlen(szBuff) - 1] != '\\')
    00486 //                    lstrcatn(szBuff, "\\", sizeof(szBuff));
    00487 //                lstrcatn(szBuff, (LPSTR)pTaskManName, sizeof(szBuff));
    00488 //                wvsprintf(szBuff+lstrlen(szBuff), (LPSTR)szTask, (LPSTR)&lParam);
    00489
    00490 //                if (WinExec((LPSTR)szBuff, SW_SHOWNORMAL) <= 32)
    00491 //                {
    00492 //                    // If it wasn't in the windows directory then try
    00493 //                    // searching the full path.
    00494 //                    lstrcpyn(szBuff, pTaskManName, sizeof(szBuff));
    00495 //                    wvsprintf(szBuff+lstrlen(szBuff), (LPSTR)szTask, (LPSTR)&lParam);
    00496 //                    WinExec((LPSTR)szBuff, SW_SHOWNORMAL);
    00497 //                }
    00498 //
    00499 //                ShowCursor(FALSE);
    00500 //                SetCursor32(hCursorLast, TRUE);
    00501             }
    00502
    00503             break;
    00504
    00505         case SC_MONITORPOWER:
    00506             /*
    00507              * If we're powering down the machine, ignore this request.
    00508              */
    00509             if (gPowerState.fInProgress) {
    00510                 break;
    00511             }
    00512
    00513             switch (lParam) {
    00514             case POWERON_PHASE:
    00515                 if (glinp.dwFlags & LINP_POWERTIMEOUTS) {
    00516                     glinp.dwFlags &= ~LINP_POWERTIMEOUTS;
    00517                     DrvSetMonitorPowerState(gpDispInfo->pmdev,
    00518                                           PowerDeviceD0);
    00519                 }
    00520                 break;
    00521             case LOWPOWER_PHASE:
    00522                 if ((glinp.dwFlags & LINP_LOWPOWER) == 0) {
    00523                     glinp.dwFlags |= LINP_LOWPOWER;
    00524                     DrvSetMonitorPowerState(gpDispInfo->pmdev,
    00525                                           PowerDeviceD1);
    00526                 }
    00527                 break;
    00528             case POWEROFF_PHASE:
    00529                 if ((glinp.dwFlags & LINP_POWEROFF) == 0) {
    00530                     glinp.dwFlags |= LINP_POWEROFF;
    00531                     DrvSetMonitorPowerState(gpDispInfo->pmdev,
    00532                                           PowerDeviceD3);
    00533                 }
    00534                 break;
    00535             default:
    00536                 break;
    00537             }
    00538             break;
    00539
    00540         case SC_SCREENSAVE:
    00541             pwndSwitch = RevalidateHwnd(ghwndSwitch);
    00542
    00543             // Lock out screen save until we get another input message.
    00544
    00545             if (pwndSwitch != NULL && pwnd != pwndSwitch) {
    00546                 _PostMessage(pwndSwitch, WM_SYSCOMMAND, SC_SCREENSAVE, 0L);
    00547             } else {
    00548                 StartScreenSaver(FALSE);
    00549             }
    00550             break;
    00551
    00552         case SC_HOTKEY:
    00553
    00554             /*
    00555              * Loword of the lparam is window to switch to
    00556              */
    00557             pwnd = ValidateHwnd((HWND)lParam);
    00558             if (pwnd != NULL) {
    00559                 pwndSwitch = _GetLastActivePopup(pwnd);
    00560
    00561                 if (pwndSwitch != NULL)
    00562                       pwnd = pwndSwitch;
    00563
    00564                 ThreadLockAlways(pwnd, &tlpwnd);
    00565                 xxxSetForegroundWindow(pwnd, FALSE);
    00566                 ThreadUnlock(&tlpwnd);
    00567
    00568                 if (TestWF(pwnd, WFMINIMIZED))
    00569                     _PostMessage(pwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
    00570             }
    00571             break;
    00572         }
    00573     }
    00574 }