test: nt6/dlgmgr.c File Reference

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

# dlgmgr.c File Reference

`#include "precomp.h"`

Go to the source code of this file.

## Defines

#define | UNICODE_MINUS_SIGN 0x2212
#define | IsInForegroundQueue(hwnd) (NtUserQueryWindow(hwnd, WindowIsForegroundThread) != NULL)
#define | IsCurrentThreadForeground() ((BOOL)NtUserGetThreadState(UserThreadStateIsForeground))

## Functions

LRESULT | ResizeDlgMessage (LPVOID pObject, HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
BOOL | ValidateCallback (HANDLE h)
PWND | GetParentDialog (PWND pwndDialog)
BOOL | xxxSaveDlgFocus (PWND pwnd)
BOOL | xxxRestoreDlgFocus (PWND pwnd)
void | DlgSetFocus (HWND hwnd)
int | GetDlgCtrlID (HWND hwnd)
BOOL | ValidateDialogPwnd (PWND pwnd)
void | CvtDec (int u, LPWSTR *lplpch)
BOOL | SetDlgItemInt (HWND hwnd, int item, UINT u, BOOL fSigned)
BOOL | CheckDlgButton (HWND hwnd, int id, UINT cmdCheck)
UINT | GetDlgItemInt (HWND hwnd, int item, BOOL FAR *lpfValOK, BOOL fSigned)
BOOL | CheckRadioButton (HWND hwnd, int idFirst, int idLast, int id)
UINT | IsDlgButtonChecked (HWND hwnd, int id)
LRESULT | DefDlgProcWorker (PWND pwnd, UINT message, WPARAM wParam, LPARAM lParam, DWORD fAnsi)
LRESULT WINAPI | DefDlgProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI | DefDlgProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
int PASCAL | DialogBox2 (HWND hwnd, HWND hwndOwner, BOOL fDisabled, BOOL fOwnerIsActiveWindow)
int | InternalDialogBox (HANDLE hModule, LPDLGTEMPLATE lpdt, HWND hwndOwner, DLGPROC pfnDialog, LPARAM lParam, UINT fSCDLGFlags)
void | RepositionRect (PMONITOR pMonitor, LPRECT lprc, DWORD dwStyle, DWORD dwExStyle)
BOOL | MapDialogRect (HWND hwnd, LPRECT lprc)

## Variables

LOOKASIDE | DialogLookaside
HCURSOR | hCurCursor

## Define Documentation

#define IsCurrentThreadForeground | (

)

((BOOL)NtUserGetThreadState(UserThreadStateIsForeground))

| Definition at line 32 of file nt6/dlgmgr.c.

#define IsInForegroundQueue | ( | hwnd |  | ) | (NtUserQueryWindow(hwnd, WindowIsForegroundThread) != NULL)

| Definition at line 30 of file nt6/dlgmgr.c.

#define UNICODE_MINUS_SIGN 0x2212

| Definition at line 15 of file nt6/dlgmgr.c.

## Function Documentation

BOOL CheckDlgButton | ( | HWND | hwnd,
|  | int | id,
|  | UINT | cmdCheck
| ) |

Definition at line 306 of file nt6/dlgmgr.c.

References BOOL, FALSE, GetDlgItem(), NULL, SendMessage(), and TRUE.

Referenced by CInstallPage::OnInit(), CPrinterProfileManagement::OnInit(), and CColorMatchDialog::OnInit().

    00310 {
    00311     if ((hwnd = GetDlgItem(hwnd, id)) == NULL) {
    00312         return FALSE;
    00313     }
    00314
    00315     SendMessage(hwnd, BM_SETCHECK, cmdCheck, 0);
    00316
    00317     return TRUE;
    00318 }

BOOL CheckRadioButton | ( | HWND | hwnd,
|  | int | idFirst,
|  | int | idLast,
|  | int | id
| ) |

Definition at line 402 of file nt6/dlgmgr.c.

References BOOL, L, NULL, PtoHq, REBASE, SendMessage(), tagWND::spmenu, TRUE, and ValidateHwnd.

Referenced by ClearDlg(), and FindDialogProc().

    00407 {
    00408     PWND pwnd, pwndDialog;
    00409     BOOL    fCheckOn;
    00410
    00411     pwndDialog = ValidateHwnd(hwnd);
    00412     if (pwndDialog == NULL)
    00413         return 0;
    00414
    00415     for (pwnd = REBASE(pwndDialog, spwndChild); pwnd; pwnd = REBASE(pwnd, spwndNext)) {
    00416
    00417         if ((PtrToLong(pwnd->spmenu) >= idFirst) &&
    00418             (PtrToLong(pwnd->spmenu) <= idLast)) {
    00419
    00420             fCheckOn = (PtrToLong(pwnd->spmenu) == id);
    00421             SendMessage(PtoHq(pwnd), BM_SETCHECK, fCheckOn, 0L);
    00422         }
    00423     }
    00424
    00425     return TRUE;
    00426 }

void CvtDec | ( | int | u,
|  | LPWSTR * | lplpch
| ) |

Definition at line 252 of file nt6/dlgmgr.c.

Referenced by CvtDec(), and SetDlgItemInt().

    00255 {
    00256     if (u >= 10) {
    00257         CvtDec(u / 10, lplpch);
    00258         u %= 10;
    00259     }
    00260
    00261     *(*lplpch)++ = (WCHAR)(u + '0');
    00262 }

LRESULT WINAPI DefDlgProcA | ( | HWND | hwnd,
|  | UINT | message,
|  | WPARAM | wParam,
|  | LPARAM | lParam
| ) |

Definition at line 1021 of file nt6/dlgmgr.c.

References DefDlgProcWorker(), L, NULL, TRUE, and ValidateHwnd.

    01026 {
    01027     PWND pwnd;
    01028
    01029     if ((pwnd = ValidateHwnd(hwnd)) == NULL) {
    01030         return (0L);
    01031     }
    01032
    01033     return DefDlgProcWorker(pwnd, message, wParam, lParam, TRUE);
    01034 }

LRESULT WINAPI DefDlgProcW | ( | HWND | hwnd,
|  | UINT | message,
|  | WPARAM | wParam,
|  | LPARAM | lParam
| ) |

Definition at line 1006 of file nt6/dlgmgr.c.

References DefDlgProcWorker(), FALSE, L, NULL, and ValidateHwnd.

    01011 {
    01012     PWND pwnd;
    01013
    01014     if ((pwnd = ValidateHwnd(hwnd)) == NULL) {
    01015         return (0L);
    01016     }
    01017
    01018     return DefDlgProcWorker(pwnd, message, wParam, lParam, FALSE);
    01019 }

LRESULT DefDlgProcWorker | ( | PWND | pwnd,
|  | UINT | message,
|  | WPARAM | wParam,
|  | LPARAM | lParam,
|  | DWORD | fAnsi
| ) |

Definition at line 453 of file nt6/dlgmgr.c.

References _FindDlgItem(), _GetDlgItem(), _GetNextDlgTabItem(), _IsChild(), _MonitorFromRect(), BOOL, CALLPROC_WOWCHECKPWW_DLG, CheckLock, ClearWindowState(), CopyRect, DefWindowProcWorker(), DF3DLOOK, DialogLookaside, DLGF_ANSI, DlgSetFocus(), DWORD, FALSE, FillWindow, FNID_COMBOBOX, FNID_DESKTOP, FNID_DIALOG, FNID_STATUS_BITS, FreeLookasideEntry(), FWINABLE, GetDlgItem(), GETFNID, GetFocus(), GetParentDialog(), GetWindowRect(), HW, HWq, IS_IME_ENABLED, IS_MIDEAST_ENABLED, IsInForegroundQueue, MB_DlgProcA(), MB_DlgProcW(), NotifyWinEvent(), NtUserCallHwndParam(), NtUserMessageBeep, NtUserSetCursorPos, NtUserSetThreadState(), NtUserSetWindowLongPtr, NtUserSetWindowPos(), NtUserShowCursor, NULL, PDIALOG, PDLG, PostMessage(), PUSIF_SNAPTO, QF_DIALOGACTIVE, tagWND::rcWindow, REBASEPWND, ReleaseEditDS(), RepositionRect(), ResizeDlgMessage(), RevalidateHwnd, SendMessage(), SetWindowState(), TEST_PUSIF, TestWF, ThreadLock, ThreadLockAlways, ThreadUnlock, TRUE, UINT, VALIDATECLASSANDSIZE, ValidateDialogPwnd(), ValidateHwnd, ValidateHwndNoRip(), WEFCONTROLPARENT, WFDIALOGWINDOW, WFDISABLED, WFWIN40COMPAT, xxxCheckDefPushButton(), xxxRestoreDlgFocus(), and xxxSaveDlgFocus().

Referenced by DefDlgProcA(), and DefDlgProcW().

    00459 {
    00460     HWND hwnd = HWq(pwnd);
    00461     TL tlpwndT1, tlpwndT2, tlpwndT3, tlpwndTop;
    00462     PWND pwndT;
    00463     PWND pwndT1, pwndT2, pwndT3, pwndTop;
    00464     HWND hwndT1;
    00465     LRESULT result;
    00466     BOOL fSetBit;
    00467     DLGPROC pfn;
    00468
    00469     CheckLock(pwnd);
    00470
    00471     /*
    00472      * use the Win 3.1 documented size
    00473      */
    00474     VALIDATECLASSANDSIZE(pwnd, FNID_DIALOG);
    00475
    00476     /*
    00477      * Must do special validation here to make sure pwnd is a dialog window.
    00478      */
    00479     if (!ValidateDialogPwnd(pwnd))
    00480         return 0;
    00481
    00482     if (((PDIALOG)pwnd)->resultWP != 0)
    00483         NtUserSetWindowLongPtr(hwnd, DWLP_MSGRESULT, 0, FALSE);
    00484     result = 0;   // no dialog proc
    00485
    00486     if (message == WM_FINALDESTROY) {
    00487         goto DoCleanup;
    00488     }
    00489
    00490     if ((pfn = PDLG(pwnd)->lpfnDlg) != NULL) {
    00491         if (IsWOWProc(pfn)) {
    00492             result = (*pfnWowDlgProcEx)(hwnd, message, wParam, lParam, (ULONG_PTR)pfn, &(pwnd->state));
    00493         } else {
    00494             result = (pfn)(hwnd, message, wParam, lParam);
    00495         }
    00496
    00497         /*
    00498          * Get out if the window was destroyed in the dialog proc.
    00499          */
    00500         if ((RevalidateHwnd(hwnd)==NULL) || (pwnd->fnid & FNID_STATUS_BITS))
    00501             return result;
    00502     }
    00503
    00504     /*
    00505      * SPECIAL CASED ... and DOCUMENTED that way !!!
    00506      * These 6, and ONLY these 6, should be hacked in this fashion.
    00507      * Anybody who needs the REAL return value to a message should
    00508      * use SetDlgMsgResult in WINDOWSX.H
    00509      */
    00510
    00511     switch (message)
    00512     {
    00513         case WM_INITDIALOG:
    00514                         //
    00515                         // FA
    00516                         //
    00517                         if( PDLG(pwnd)->pDlgResize != NULL )
    00518                                 ResizeDlgMessage( PDLG(pwnd)->pDlgResize, hwnd, message, wParam, lParam );
    00519                         // fall through
    00520         case WM_COMPAREITEM:
    00521         case WM_VKEYTOITEM:
    00522         case WM_CHARTOITEM:
    00523         case WM_QUERYDRAGICON:
    00524             return ((LRESULT)(DWORD)result);
    00525
    00526         case WM_CTLCOLOR:
    00527         case WM_CTLCOLORMSGBOX:
    00528         case WM_CTLCOLOREDIT:
    00529         case WM_CTLCOLORLISTBOX:
    00530         case WM_CTLCOLORBTN:
    00531         case WM_CTLCOLORDLG:
    00532         case WM_CTLCOLORSCROLLBAR:
    00533         case WM_CTLCOLORSTATIC:
    00534             // QuarkXPress doesn't like finding the WM_CTLCOLOR result in
    00535             // resultWP -- we should never be setting resultWP -- that's meant
    00536             // as a pass-thru return value -- so let's go back to doing it the
    00537             // old way -- Win95B B#21269 -- 03/13/95 -- tracysh (cr: jeffbog)
    00538             if (result)
    00539                 return ((LRESULT)(DWORD)result);
    00540             break;
    00541     }
    00542
    00543     if (!result) {
    00544
    00545         /*
    00546          * Save the result value in case our private memory is freed
    00547          * before we return
    00548          */
    00549 //        result = PDLG(pwnd)->resultWP;
    00550
    00551         switch (message) {
    00552         case WM_CTLCOLOR:
    00553         case WM_CTLCOLORMSGBOX:
    00554         case WM_CTLCOLOREDIT:
    00555         case WM_CTLCOLORLISTBOX:
    00556         case WM_CTLCOLORBTN:
    00557         case WM_CTLCOLORDLG:
    00558         case WM_CTLCOLORSCROLLBAR:
    00559         case WM_CTLCOLORSTATIC:
    00560         {
    00561             //
    00562             // HACK OF DEATH:
    00563             // To get 3D colors for non 4.0 apps who use 3DLOOK,
    00564             // we temporarily add on the 4.0 compat bit, pass this
    00565             // down to DWP, and clear it.
    00566             //
    00567             // Use "result" var for bool saying we have to add/clear 4.0
    00568             // compat bit.
    00569
    00570             fSetBit = (TestWF(pwnd, DF3DLOOK)!= 0) &&
    00571                      (TestWF(pwnd, WFWIN40COMPAT) == 0);
    00572
    00573             if (fSetBit)
    00574                 SetWindowState(pwnd, WFWIN40COMPAT);
    00575
    00576             result = DefWindowProcWorker(pwnd, message,
    00577                     wParam, lParam, fAnsi);
    00578
    00579             if (fSetBit)
    00580                 ClearWindowState(pwnd, WFWIN40COMPAT);
    00581             return((LRESULT)(DWORD) result);
    00582         }
    00583
    00584         case WM_ERASEBKGND:
    00585             FillWindow(hwnd, hwnd, (HDC)wParam, (HBRUSH)CTLCOLOR_DLG);
    00586
    00587                         //
    00588                         // FA
    00589                         if( PDLG(pwnd)->pDlgResize != NULL )
    00590                                 return ResizeDlgMessage( PDLG(pwnd)->pDlgResize, hwnd, message, wParam, lParam );
    00591             return TRUE;
    00592
    00593         case WM_SHOWWINDOW:
    00594
    00595             /*
    00596              * If hiding the window, save the focus.  If showing the window
    00597              * by means of a SW_* command and the fEnd bit is set, do not
    00598              * pass to DWP so it won't get shown.
    00599              */
    00600             if (GetParentDialog(pwnd) == pwnd) {
    00601                 if (!wParam) {
    00602                     xxxSaveDlgFocus(pwnd);
    00603                 } else {
    00604
    00605                     if (LOWORD(lParam) != 0 && PDLG(pwnd)->fEnd)
    00606                         break;
    00607
    00608                     /*
    00609                      * Snap the cursor to the center of the default button.
    00610                      * Only do this if the current thread is in the foreground.
    00611                      * The _ShowCursor() code is added to work around a
    00612                      * problem with hardware cursors.  If change is done
    00613                      * in the same refresh cycle, the display of the cursor
    00614                      * would not reflect the new position.
    00615                      */
    00616                     if (TEST_PUSIF(PUSIF_SNAPTO) &&
    00617                             IsInForegroundQueue(hwnd)) {
    00618                         hwndT1 = GetDlgItem(hwnd, PDLG(pwnd)->result);
    00619                         if (hwndT1) {
    00620                             RECT rc;
    00621
    00622                             NtUserShowCursor(FALSE);
    00623
    00624                             GetWindowRect(hwndT1, &rc);
    00625                             NtUserSetCursorPos(rc.left + ((rc.right - rc.left)/2),
    00626                                          rc.top + ((rc.bottom - rc.top)/2));
    00627
    00628                             NtUserShowCursor(TRUE);
    00629                         }
    00630                     }
    00631                 }
    00632             }
    00633             goto CallDWP;
    00634
    00635         case WM_SYSCOMMAND:
    00636             if (GetParentDialog(pwnd) == pwnd) {
    00637                 /*
    00638                  * If hiding the window, save the focus.  If showing the window
    00639                  * by means of a SW_* command and the fEnd bit is set, do not
    00640                  * pass to DWP so it won't get shown.
    00641                  */
    00642                 if ((int)wParam == SC_MINIMIZE)
    00643                     xxxSaveDlgFocus(pwnd);
    00644             }
    00645             goto CallDWP;
    00646
    00647         case WM_ACTIVATE:
    00648             pwndT1 = GetParentDialog(pwnd);
    00649             if ( pwndT1 != pwnd) {
    00650
    00651                 /*
    00652                  * This random bit is used during key processing - bit
    00653                  * 08000000 of WM_CHAR messages is set if a dialog is currently
    00654                  * active.
    00655                  */
    00656                 NtUserSetThreadState(wParam ? QF_DIALOGACTIVE : 0, QF_DIALOGACTIVE);
    00657             }
    00658             ThreadLock(pwndT1, &tlpwndT1);
    00659             if (wParam != 0)
    00660                 xxxRestoreDlgFocus(pwndT1);
    00661             else
    00662                 xxxSaveDlgFocus(pwndT1);
    00663
    00664             ThreadUnlock(&tlpwndT1);
    00665             break;
    00666
    00667         case WM_SETFOCUS:
    00668             pwndT1 = GetParentDialog(pwnd);
    00669             if (!PDLG(pwndT1)->fEnd && !xxxRestoreDlgFocus(pwndT1)) {
    00670
    00671                 pwndT = _GetNextDlgTabItem(pwndT1, NULL, FALSE);
    00672                 DlgSetFocus(HW(pwndT));
    00673             }
    00674             break;
    00675
    00676         case WM_CLOSE:
    00677             /*
    00678              * Make sure cancel button is not disabled before sending the
    00679              * IDCANCEL.  Note that we need to do this as a message instead
    00680              * of directly calling the dlg proc so that any dialog box
    00681              * filters get this.
    00682              */
    00683             pwndT1 = _GetDlgItem(pwnd, IDCANCEL);
    00684             if (pwndT1 && TestWF(pwndT1, WFDISABLED))
    00685                 NtUserMessageBeep(0);
    00686             else
    00687                 PostMessage(hwnd, WM_COMMAND, MAKELONG(IDCANCEL, BN_CLICKED),
    00688                         (LPARAM)HW(pwndT1));
    00689             break;
    00690
    00691         case WM_NCDESTROY:
    00692         case WM_FINALDESTROY:
    00693 DoCleanup:
    00694             NtUserSetThreadState(0, QF_DIALOGACTIVE);
    00695             if (!(pwnd->style & DS_LOCALEDIT)) {
    00696                 if (PDLG(pwnd)->hData) {
    00697                     ReleaseEditDS(PDLG(pwnd)->hData);
    00698                     PDLG(pwnd)->hData = NULL;
    00699                 }
    00700             }
    00701
    00702             /*
    00703              * Delete the user defined font if any
    00704              */
    00705             if (PDLG(pwnd)->hUserFont) {
    00706                 DeleteObject(PDLG(pwnd)->hUserFont);
    00707                 PDLG(pwnd)->hUserFont = NULL;
    00708             }
    00709
    00710             /*
    00711              * Free the dialog memory and mark this as a non-dialog window
    00712              */
    00713             FreeLookasideEntry(&DialogLookaside, PDLG(pwnd));
    00714             NtUserCallHwndParam(hwnd, 0, SFI_SETDIALOGPOINTER);
    00715             break;
    00716
    00717         case DM_REPOSITION:
    00718             {
    00719                 RECT        rc;
    00720                 PMONITOR    pMonitor;
    00721
    00722                 // DAT recorder APP sends it's own private message 0x402
    00723                 // through and we mistake it to be DM_REPOSITION. To avoid
    00724                 // this confusion, we do the following check.
    00725                 // Fix for Bug#25747 -- 9/29/94 --
    00726                 if (!TestWF(pwnd, WEFCONTROLPARENT) ||
    00727                     (GETFNID(pwnd) != FNID_DESKTOP &&
    00728                      GETFNID(REBASEPWND(pwnd, spwndParent)) != FNID_DESKTOP)) {
    00729
    00730                     goto CallDWP;
    00731                 }
    00732
    00733                 CopyRect(&rc, &pwnd->rcWindow);
    00734                 pMonitor = _MonitorFromRect(&rc, MONITOR_DEFAULTTOPRIMARY);
    00735                 RepositionRect(pMonitor, &rc, pwnd->style, pwnd->ExStyle);
    00736                 NtUserSetWindowPos(hwnd, HWND_TOP, rc.left, rc.top,
    00737                              rc.right-rc.left, rc.bottom-rc.top,
    00738                              SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
    00739             }
    00740             break;
    00741
    00742         case DM_SETDEFID:
    00743             pwndT1 = GetParentDialog(pwnd);
    00744             ThreadLock(pwndT1, &tlpwndT1);
    00745
    00746             if (!(PDLG(pwndT1)->fEnd)) {
    00747
    00748                 pwndT2 = NULL;
    00749                 if (PDLG(pwndT1)->result != 0)
    00750                     pwndT2 = _FindDlgItem(pwndT1, PDLG(pwndT1)->result);
    00751
    00752                 pwndT3 = NULL;
    00753                 if (wParam != 0) {
    00754                     pwndT3 = _GetDlgItem(pwnd, wParam);
    00755                 }
    00756
    00757                 ThreadLock(pwndT2, &tlpwndT2);
    00758                 ThreadLock(pwndT3, &tlpwndT3);
    00759
    00760                 xxxCheckDefPushButton(pwndT1, HW(pwndT2), HW(pwndT3));
    00761
    00762                 ThreadUnlock(&tlpwndT3);
    00763                 ThreadUnlock(&tlpwndT2);
    00764
    00765                 PDLG(pwndT1)->result = wParam;
    00766 //                if (PDLG(pwnd)->spwndFocusSave) {
    00767 //                    Lock(&(PDLG(pwnd)->spwndFocusSave), pwndT2);
    00768 //                }
    00769
    00770                 if (FWINABLE()) {
    00771                     NotifyWinEvent(EVENT_OBJECT_DEFACTIONCHANGE, HW(pwndT1), OBJID_CLIENT, INDEXID_CONTAINER);
    00772                 }
    00773             }
    00774             ThreadUnlock(&tlpwndT1);
    00775             return TRUE;
    00776
    00777         case DM_GETDEFID:
    00778             pwndT1 = GetParentDialog(pwnd);
    00779
    00780             if (!PDLG(pwndT1)->fEnd && PDLG(pwndT1)->result)
    00781                 return(MAKELONG(PDLG(pwndT1)->result, DC_HASDEFID));
    00782             else
    00783                 return 0;
    00784             break;
    00785
    00786         /*
    00787          * This message was added so that user defined controls that want
    00788          * tab keys can pass the tab off to the next/previous control in the
    00789          * dialog box.  Without this, all they could do was set the focus
    00790          * which didn't do the default button stuff.
    00791          */
    00792         case WM_NEXTDLGCTL:
    00793             pwndTop = GetParentDialog(pwnd);
    00794             ThreadLock(pwndTop, &tlpwndTop);
    00795
    00796             hwndT1 = GetFocus();
    00797             pwndT2 = ValidateHwndNoRip(hwndT1);
    00798             if (LOWORD(lParam)) {
    00799                 if (pwndT2 == NULL)
    00800                     pwndT2 = pwndTop;
    00801
    00802                 /*
    00803                  * wParam contains the pwnd of the ctl to set focus to.
    00804                  */
    00805                 if ((pwndT1 = ValidateHwnd((HWND)wParam)) == NULL) {
    00806                     ThreadUnlock(&tlpwndTop);
    00807                     return TRUE;
    00808                 }
    00809             } else {
    00810                 if (pwndT2 == NULL) {
    00811
    00812                     /*
    00813                      * Set focus to the first tab item.
    00814                      */
    00815                     pwndT1 = _GetNextDlgTabItem(pwndTop, NULL, FALSE);
    00816                     pwndT2 = pwndTop;
    00817                 } else {
    00818
    00819                     /*
    00820                      * If window with focus not a dlg ctl, ignore message.
    00821                      */
    00822                     if (!_IsChild(pwndTop, pwndT2)) {
    00823                         ThreadUnlock(&tlpwndTop);
    00824                         return TRUE;
    00825                     }
    00826                     /*
    00827                      * wParam = TRUE for previous, FALSE for next
    00828                      */
    00829                     pwndT1 = _GetNextDlgTabItem(pwndTop, pwndT2, wParam);
    00830
    00831                     /*
    00832                      * If there is no next item, ignore the message.
    00833                      */
    00834                     if (pwndT1 == NULL) {
    00835                         ThreadUnlock(&tlpwndTop);
    00836                         return TRUE;
    00837                     }
    00838                 }
    00839             }
    00840
    00841             ThreadLock(pwndT1, &tlpwndT1);
    00842             ThreadLock(pwndT2, &tlpwndT2);
    00843
    00844             DlgSetFocus(HW(pwndT1));
    00845             xxxCheckDefPushButton(pwndTop, HW(pwndT2), HW(pwndT1));
    00846
    00847             ThreadUnlock(&tlpwndT2);
    00848             ThreadUnlock(&tlpwndT1);
    00849             ThreadUnlock(&tlpwndTop);
    00850
    00851             return TRUE;
    00852
    00853         case WM_ENTERMENULOOP:
    00854
    00855             /*
    00856              * We need to pop up the combo box window if the user brings
    00857              * down a menu.
    00858              *
    00859              * ...  FALL THROUGH...
    00860              */
    00861
    00862         case WM_LBUTTONDOWN:
    00863         case WM_NCLBUTTONDOWN:
    00864             hwndT1 = GetFocus();
    00865             if (hwndT1 != NULL) {
    00866                 pwndT1 = ValidateHwndNoRip(hwndT1);
    00867
    00868                 if (GETFNID(pwndT1) == FNID_COMBOBOX) {
    00869
    00870                     /*
    00871                      * If user clicks anywhere in dialog box and a combo box (or
    00872                      * the editcontrol of a combo box) has the focus, then hide
    00873                      * it's listbox.
    00874                      */
    00875                     ThreadLockAlways(pwndT1, &tlpwndT1);
    00876                     SendMessage(HWq(pwndT1), CB_SHOWDROPDOWN, FALSE, 0);
    00877                     ThreadUnlock(&tlpwndT1);
    00878
    00879                 } else {
    00880                     PWND pwndParent;
    00881
    00882                     /*
    00883                      * It's a subclassed combo box.  See if the listbox and edit
    00884                      * boxes exist (this is a very cheezy evaluation - what if
    00885                      * these controls are subclassed too? NOTE: Not checking
    00886                      * for EditWndProc: it's a client proc address.
    00887                      */
    00888                     pwndParent = REBASEPWND(pwndT1, spwndParent);
    00889                     if (GETFNID(pwndParent) == FNID_COMBOBOX) {
    00890                         pwndT1 = pwndParent;
    00891                         ThreadLock(pwndT1, &tlpwndT1);
    00892                         SendMessage(HWq(pwndT1), CB_SHOWDROPDOWN, FALSE, 0);
    00893                         ThreadUnlock(&tlpwndT1);
    00894                     }
    00895                 }
    00896             }
    00897
    00898             /*
    00899              * Always send the message off to DefWndProc
    00900              */
    00901             goto CallDWP;
    00902
    00903         case WM_GETFONT:
    00904             return (LRESULT)PDLG(pwnd)->hUserFont;
    00905
    00906         case WM_VKEYTOITEM:
    00907         case WM_COMPAREITEM:
    00908         case WM_CHARTOITEM:
    00909         case WM_INITDIALOG:
    00910
    00911             /*
    00912              * We need to return the 0 the app may have returned for these
    00913              * items instead of calling defwindow proc.
    00914              */
    00915             return result;
    00916
    00917                         // FA
    00918                         //
    00919                 case WM_NCHITTEST:
    00920                                 if( PDLG(pwnd)->pDlgResize != NULL )
    00921                                 {
    00922                                         LRESULT lres=ResizeDlgMessage( PDLG(pwnd)->pDlgResize, hwnd, message, wParam, lParam );
    00923                                         if( lres ) // && (((PDIALOG)pwnd)->resultWP != 0) )
    00924                                                 return ((PDIALOG)pwnd)->resultWP;
    00925                                         goto CallDWP;
    00926                                 }
    00927
    00928                 case WM_SIZE:
    00929                 case WM_WINDOWPOSCHANGING:
    00930                         if( PDLG(pwnd)->pDlgResize != NULL )
    00931                                 return ResizeDlgMessage( PDLG(pwnd)->pDlgResize, hwnd, message, wParam, lParam );
    00932                         goto CallDWP;
    00933                 break;
    00934                 //
    00935                 // FA
    00936
    00937         case WM_NOTIFYFORMAT:
    00938             if (lParam == NF_QUERY)
    00939                 return((PDLG(pwnd)->flags & DLGF_ANSI ) ? NFR_ANSI : NFR_UNICODE);
    00940             return result;
    00941
    00942         default:
    00943 CallDWP:
    00944             return DefWindowProcWorker(pwnd, message, wParam, lParam, fAnsi);
    00945         }
    00946     } else if ((message == WM_SHOWWINDOW) && result) {
    00947
    00948         /*
    00949          * For a visible-case we want to snap the cursor regardless of
    00950          * what was returned from the dialog-handler on the client.  If
    00951          * we're going visible, snap the cursor to the dialog-button.
    00952          */
    00953         if (GetParentDialog(pwnd) == pwnd) {
    00954
    00955             if (wParam && ((LOWORD(lParam) == 0) || !PDLG(pwnd)->fEnd)) {
    00956
    00957                 /*
    00958                  * Snap the cursor to the center of the default button.
    00959                  * Only do this if the current thread is in the foreground.
    00960                  * The _ShowCursor() code is added to work around a
    00961                  * problem with hardware cursors.  If change is done
    00962                  * in the same refresh cycle, the display of the cursor
    00963                  * would not reflect the new position.
    00964                  */
    00965                 if (TEST_PUSIF(PUSIF_SNAPTO) &&
    00966                         IsInForegroundQueue(hwnd)) {
    00967                     hwndT1 = GetDlgItem(hwnd, PDLG(pwnd)->result);
    00968                     if (hwndT1) {
    00969                         RECT rc;
    00970
    00971                         NtUserShowCursor(FALSE);
    00972
    00973                         GetWindowRect(hwndT1, &rc);
    00974                         NtUserSetCursorPos(rc.left + ((rc.right - rc.left)/2),
    00975                                      rc.top + ((rc.bottom - rc.top)/2));
    00976
    00977                         NtUserShowCursor(TRUE);
    00978                     }
    00979                 }
    00980             }
    00981         }
    00982     }
    00983
    00984
    00985     /*
    00986      * If this is still marked as a dialog window then return the real
    00987      * result. Otherwise, we've already processed the WM_NCDESTROY message
    00988      * and freed our private memory so return the stored value.
    00989      */
    00990     if (TestWF(pwnd, WFDIALOGWINDOW))
    00991         return ((PDIALOG)pwnd)->resultWP;
    00992     else
    00993         return result;
    00994 }

int PASCAL DialogBox2 | ( | HWND | hwnd,
|  | HWND | hwndOwner,
|  | BOOL | fDisabled,
|  | BOOL | fOwnerIsActiveWindow
| ) |

Definition at line 1043 of file nt6/dlgmgr.c.

References BOOL, CheckLock, DispatchMessage(), FALSE, FNID_STATUS_BITS, FWINABLE, GetCapture(), GetKeyState(), IsCurrentThreadForeground, IsDialogMessage, IsInForegroundQueue, IsWindow(), LOBYTE, msg, NotifyWinEvent(), NtUserDestroyWindow(), NtUserEnableWindow, NtUserSetFocus(), NtUserSetForegroundWindow, NtUserSetWindowPos(), NtUserShowWindow(), NtUserWaitMessage(), NULL, PDLG, PeekMessage(), PostQuitMessage(), RevalidateHwnd, SendMessage(), SYSMET, TestWF, TranslateMessage(), TRUE, UpdateWindow(), ValidateHwnd, WFMSGBOX, WFVISIBLE, and WM_SYSTIMER.

Referenced by InternalDialogBox().

    01048 {
    01049     MSG msg;
    01050     int result;
    01051     BOOL fShown;
    01052     BOOL fWantIdleMsgs;
    01053     BOOL fSentIdleMessage = FALSE;
    01054     HWND hwndCapture;
    01055     PWND pwnd;
    01056
    01057     if (hwnd) {
    01058         pwnd = ValidateHwnd(hwnd);
    01059     } else {
    01060         pwnd = NULL;
    01061     }
    01062
    01063     CheckLock(pwnd);
    01064
    01065     if (pwnd == NULL) {
    01066         if ((hwndOwner != NULL) && !fDisabled && IsWindow(hwndOwner)) {
    01067             NtUserEnableWindow(hwndOwner, TRUE);
    01068             if (fOwnerIsActiveWindow) {
    01069
    01070                 /*
    01071                  * The dialog box failed but we disabled the owner in
    01072                  * xxxDialogBoxIndirectParam and if it had the focus, the
    01073                  * focus was set to NULL.  Now, when we enable the window, it
    01074                  * doesn't get the focus back if it had it previously so we
    01075                  * need to correct this.
    01076                  */
    01077                 NtUserSetFocus(hwndOwner);
    01078             }
    01079         }
    01080         return -1;
    01081     }
    01082
    01083     hwndCapture = GetCapture();
    01084     if (hwndCapture != NULL) {
    01085         SendMessage(hwndCapture, WM_CANCELMODE, 0, 0);
    01086     }
    01087
    01088     /*
    01089      * Set the 'parent disabled' flag for EndDialog().
    01090      * convert BOOL to definite bit 0 or 1
    01091      */
    01092     PDLG(pwnd)->fDisabled = !!fDisabled;
    01093
    01094     fShown = TestWF(pwnd, WFVISIBLE);
    01095
    01096     /*
    01097      * Should the WM_ENTERIDLE messages be sent?
    01098      */
    01099     fWantIdleMsgs = !(pwnd->style & DS_NOIDLEMSG);
    01100
    01101     if ((SYSMET(SLOWMACHINE) & 1) && !fShown && !PDLG(pwnd)->fEnd)
    01102         goto ShowIt;
    01103
    01104     while (PDLG(pwnd) && (!PDLG(pwnd)->fEnd)) {
    01105         if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
    01106 ShowIt:
    01107             if (!fShown) {
    01108                 fShown = TRUE;
    01109
    01110 #ifdef SYSMODALWINDOWS
    01111                 if (pwnd == gspwndSysModal) {
    01112                     /*
    01113                      * Make this a topmost window
    01114                      */
    01115                     NtUserSetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
    01116                                SWP_NOSIZE | SWP_NOMOVE |
    01117                                SWP_NOREDRAW | SWP_NOACTIVATE);
    01118                 }
    01119 #endif
    01120
    01121                 NtUserShowWindow(hwnd, SHOW_OPENWINDOW);
    01122                 UpdateWindow(hwnd);
    01123
    01124                 if (FWINABLE()) {
    01125                     NotifyWinEvent(EVENT_SYSTEM_DIALOGSTART, hwnd, OBJID_WINDOW, INDEXID_CONTAINER);
    01126                 }
    01127             } else {
    01128                 /*
    01129                  * Make sure window still exists
    01130                  */
    01131                 if (hwndOwner && !IsWindow(hwndOwner))
    01132                     hwndOwner = NULL;
    01133
    01134                 if (hwndOwner && fWantIdleMsgs && !fSentIdleMessage) {
    01135                     fSentIdleMessage = TRUE;
    01136
    01137                     SendMessage(hwndOwner, WM_ENTERIDLE, MSGF_DIALOGBOX, (LPARAM)hwnd);
    01138                 } else {
    01139                     if ((RevalidateHwnd(hwnd)==NULL) || (pwnd->fnid & FNID_STATUS_BITS))
    01140                         break;
    01141
    01142                     NtUserWaitMessage();
    01143                 }
    01144             }
    01145
    01146         } else {
    01147             /*
    01148              * We got a real message.  Reset fSentIdleMessage so that we send
    01149              * one next time things are calm.
    01150              */
    01151             fSentIdleMessage = FALSE;
    01152
    01153             if (msg.message == WM_QUIT) {
    01154                 PostQuitMessage(msg.wParam);
    01155                 break;
    01156             }
    01157
    01158             /*
    01159              * If pwnd is a message box, allow Ctrl-C and Ctrl-Ins
    01160              * to copy its content to the clipboard.
    01161              * Fall through in case hooking apps look for these keys.
    01162              */
    01163             if (TestWF(pwnd, WFMSGBOX)) {
    01164                 if ( (msg.message == WM_CHAR && LOBYTE(msg.wParam) == 3) ||
    01165                      (msg.message == WM_KEYDOWN && LOBYTE(msg.wParam) == VK_INSERT && GetKeyState(VK_CONTROL) < 0)) {
    01166                         /*
    01167                          * Send the WM_COPY message and let the original message fall through
    01168                          * as some apps might want it
    01169                          */
    01170                         SendMessage(hwnd, WM_COPY, 0, 0);
    01171                 }
    01172             }
    01173
    01174             /*
    01175              * Moved the msg filter hook call to IsDialogMessage to allow
    01176              * messages to be hooked for both modal and modeless dialog
    01177              * boxes.
    01178              */
    01179             if (!IsDialogMessage(hwnd, &msg)) {
    01180                 TranslateMessage(&msg);
    01181                 DispatchMessage(&msg);
    01182             }
    01183
    01184             /*
    01185              * If we get a timer message, go ahead and show the window.
    01186              * We may continuously get timer msgs if there are zillions of
    01187              * apps running.
    01188              *
    01189              * If we get a syskeydown message, show the dialog box because
    01190              * the user may be bringing down a menu and we want the dialog
    01191              * box to become visible.
    01192              */
    01193             if (!fShown && (msg.message == WM_TIMER ||
    01194                     msg.message == WM_SYSTIMER || msg.message == WM_SYSKEYDOWN))
    01195                 goto ShowIt;
    01196         }
    01197
    01198 #if DBG
    01199         if (!RevalidateHwnd(hwnd)) {
    01200             /*
    01201              * Bogus case - we've already been destroyed somehow (by app,
    01202              * GP, etc.)
    01203              */
    01204             RIPMSG0(RIP_WARNING,
    01205                "Dialog should be dismissed with EndDialog, not DestroyWindow");
    01206         }
    01207 #endif
    01208     }
    01209
    01210     if (FWINABLE()) {
    01211         NotifyWinEvent(EVENT_SYSTEM_DIALOGEND, hwnd, OBJID_WINDOW, INDEXID_CONTAINER);
    01212     }
    01213
    01214     /*
    01215      * Make sure the window still exists
    01216      */
    01217     if (!RevalidateHwnd(hwnd)) {
    01218         return 0;
    01219     }
    01220
    01221     if (PDLG(pwnd))
    01222         result = PDLG(pwnd)->result;
    01223     else
    01224         result = 0;
    01225
    01226     NtUserDestroyWindow(hwnd);
    01227
    01228     /*
    01229      * If the owner window belongs to another thread, the reactivation
    01230      * of the owner may have failed within DestroyWindow().  Therefore,
    01231      * if the current thread is in the foreground and the owner is not
    01232      * in the foreground we can safely set the foreground back
    01233      * to the owner.
    01234      */
    01235     if (hwndOwner != NULL) {
    01236         if (IsCurrentThreadForeground() &&
    01237             !IsInForegroundQueue(hwndOwner)) {
    01238             NtUserSetForegroundWindow(hwndOwner);
    01239         }
    01240     }
    01241
    01242     return result;
    01243 }

void DlgSetFocus | ( | HWND | hwnd | ) |

Definition at line 158 of file nt6/dlgmgr.c.

References NtUserSetFocus(), SendMessage(), and UINT.

Referenced by DefDlgProcWorker(), InternalCreateDialog(), IsDialogMessageW(), and xxxGotoNextMnem().

    00160 {
    00161     if (((UINT)SendMessage(hwnd, WM_GETDLGCODE, 0, 0)) & DLGC_HASSETSEL) {
    00162         SendMessage(hwnd, EM_SETSEL, 0, MAXLONG);
    00163     }
    00164
    00165     NtUserSetFocus(hwnd);
    00166 }

int GetDlgCtrlID | ( | HWND | hwnd | ) |

Definition at line 169 of file nt6/dlgmgr.c.

References NULL, tagWND::spmenu, and ValidateHwnd.

Referenced by IsDialogMessageW(), CAddDeviceDialog::OnContextMenu(), CProfileAssociationPage::OnContextMenu(), and CResizeDlg::PlaceControls().

    00171 {
    00172     PWND pwnd;
    00173
    00174     pwnd = ValidateHwnd(hwnd);
    00175     if (pwnd == NULL)
    00176         return 0;
    00177
    00178     return PtrToLong(pwnd->spmenu);
    00179 }

UINT GetDlgItemInt | ( | HWND | hwnd,
|  | int | item,
|  | BOOL FAR * | lpfValOK,
|  | BOOL | fSigned
| ) |

Definition at line 327 of file nt6/dlgmgr.c.

References BOOL, FALSE, L, NULL, TRUE, UINT, and UNICODE_MINUS_SIGN.

    00332 {
    00333     int i, digit, ch;
    00334     BOOL fOk, fNeg;
    00335     LPWSTR lpch;
    00336     WCHAR rgch[48];
    00337     WCHAR rgchDigits[48];
    00338
    00339     fOk = FALSE;
    00340     if (lpfValOK != NULL)
    00341         *lpfValOK = FALSE;
    00342
    00343     if (!GetDlgItemTextW(hwnd, item, rgch, sizeof(rgch)/sizeof(WCHAR) - 1))
    00344         return 0;
    00345
    00346     lpch = rgch;
    00347
    00348     /*
    00349      * Skip leading white space.
    00350      */
    00351     while (*lpch == TEXT(' '))
    00352         lpch++;
    00353
    00354     fNeg = FALSE;
    00355     while (fSigned && ((*lpch == L'-') || (*lpch == UNICODE_MINUS_SIGN))) {
    00356         lpch++;
    00357         fNeg ^= TRUE;
    00358     }
    00359
    00360     /*
    00361      * Convert all decimal digits to ASCII Unicode digits 0x0030 - 0x0039
    00362      */
    00363     FoldStringW(MAP_FOLDDIGITS, lpch, -1, rgchDigits,
    00364             sizeof(rgchDigits)/sizeof(rgchDigits[0]));
    00365     lpch = rgchDigits;
    00366
    00367     i = 0;
    00368     while (ch = *lpch++) {
    00369         digit = ch - TEXT('0');
    00370         if (digit < 0 || digit > 9) {
    00371             break;
    00372         }
    00373         if (fSigned) {
    00374             if (i > (INT_MAX - digit) / 10) {
    00375                 return(0);
    00376             }
    00377         } else {
    00378             if ((UINT)i > (UINT)((UINT_MAX - digit) / 10)) {
    00379                 return(0);
    00380             }
    00381         }
    00382
    00383         fOk = TRUE;
    00384         i = ((UINT)i * 10) + digit;
    00385     }
    00386
    00387     if (fNeg)
    00388         i = -i;
    00389
    00390     if (lpfValOK != NULL)
    00391         *lpfValOK = ((ch == 0) && fOk);
    00392
    00393     return (UINT)i;
    00394 }

PWND GetParentDialog | ( | PWND | pwndDialog | ) |

Definition at line 49 of file nt6/dlgmgr.c.

References DFCONTROL, REBASEPWND, TestWF, WEFCONTROLPARENT, WFCHILD, and WFDIALOGWINDOW.

Referenced by DefDlgProcWorker(), IsDialogMessageA(), and IsDialogMessageW().

    00050 {
    00051     PWND    pwndParent;
    00052
    00053     pwndParent = pwndDialog;
    00054
    00055     //
    00056     // Walk up the parent chain.  We're looking for the top-most dialog
    00057     // window.  Most cases, the window is a top level one.  But in case of
    00058     // backup app, the window will be a child of some other window.
    00059     //
    00060     for (; pwndDialog; pwndDialog = REBASEPWND(pwndDialog, spwndParent))
    00061     {
    00062         if (TestWF(pwndDialog, WFDIALOGWINDOW))
    00063         {
    00064             //
    00065             // For old guys:  If not DS_RECURSE, then stop here.
    00066             // that way old apps which try to do the nested dialog
    00067             // stuff in their old limited way don't die.
    00068             //
    00069             if (TestWF(pwndDialog, WEFCONTROLPARENT))
    00070                 pwndParent = pwndDialog;
    00071             else if (!TestWF(pwndDialog, DFCONTROL))
    00072                 break;
    00073         }
    00074
    00075         if (!TestWF(pwndDialog, WFCHILD))
    00076             break;
    00077     }
    00078
    00079     return(pwndParent);
    00080 }

int InternalDialogBox | ( | HANDLE | hModule,
|  | LPDLGTEMPLATE | lpdt,
|  | HWND | hwndOwner,
|  | DLGPROC | pfnDialog,
|  | LPARAM | lParam,
|  | UINT | fSCDLGFlags
| ) |

Definition at line 1256 of file nt6/dlgmgr.c.

References BOOL, CheckLock, DialogBox2(), FALSE, GetActiveWindow(), GetDesktopWindow(), GetTopLevelWindow(), HWq, InternalCreateDialog(), L, NtUserEnableWindow, NtUserSetCursor(), NULL, PtoHq, SAMEWOWHANDLE, SYSMET, TestWF, TestwndChild, ThreadLock, ThreadUnlock, TRUE, ValidateHwnd, and WFDISABLED.

Referenced by DialogBoxIndirectParamAorW(), and SoftModalMessageBox().

    01263 {
    01264     int i;
    01265     BOOL fDisabled;
    01266     HWND hwnd;
    01267     PWND pwndOwner;
    01268     BOOL fOwnerIsActiveWindow = FALSE;
    01269     TL tlpwndOwner;
    01270     BOOL fUnlockOwner;
    01271
    01272     UserAssert(!(fSCDLGFlags & ~(SCDLG_CLIENT|SCDLG_ANSI|SCDLG_16BIT)));    // These are the only valid flags
    01273
    01274     /*
    01275      * If hwndOwner == HWNDESKTOP, change it to NULL.  This way the desktop
    01276      * (and all its children) won't be disabled if the dialog is modal.
    01277      */
    01278     if (hwndOwner && SAMEWOWHANDLE(hwndOwner, GetDesktopWindow()))
    01279         hwndOwner = NULL;
    01280
    01281     /*
    01282      * We return 0 if the ValidateHwnd fails in order to match Win 3.1
    01283      * validation layer which always returns 0 for invalid hwnds even
    01284      * if the function is spec'ed to return -1.  Autocad setup bug #3615
    01285      */
    01286     if (hwndOwner) {
    01287         if ((pwndOwner = ValidateHwnd(hwndOwner)) == NULL) {
    01288             return (0L);
    01289         }
    01290     } else {
    01291         pwndOwner = NULL;
    01292     }
    01293
    01294     CheckLock(pwndOwner);
    01295
    01296     fUnlockOwner = FALSE;
    01297     if (pwndOwner != NULL) {
    01298
    01299         /* The following fixes an AV in Corel Photo-Paint 6.0.  It passes a
    01300          * 16-bit HWND in, and croaks at some point when it gets 16-bit hwnds
    01301          * back in send messages. FritzS -- fixing bug 12531
    01302          */
    01303         hwndOwner = PtoHq(pwndOwner);
    01304
    01305         /*
    01306          * Make sure the owner is a top level window.
    01307          */
    01308         if (TestwndChild(pwndOwner)) {
    01309             pwndOwner = GetTopLevelWindow(pwndOwner);
    01310             hwndOwner = HWq(pwndOwner);
    01311             ThreadLock(pwndOwner, &tlpwndOwner);
    01312             fUnlockOwner = TRUE;
    01313         }
    01314
    01315         /*
    01316          * Remember if window was originally disabled (so we can set
    01317          * the correct state when the dialog goes away.
    01318          */
    01319         fDisabled = TestWF(pwndOwner, WFDISABLED);
    01320         fOwnerIsActiveWindow = (SAMEWOWHANDLE(hwndOwner, GetActiveWindow()));
    01321
    01322         /*
    01323          * Disable the window.
    01324          */
    01325         NtUserEnableWindow(hwndOwner, FALSE);
    01326     }
    01327
    01328     /*
    01329      * Don't show cursors on a mouseless system. Put up an hour glass while
    01330      * the dialog comes up.
    01331      */
    01332     if (SYSMET(MOUSEPRESENT)) {
    01333         NtUserSetCursor(LoadCursor(NULL, IDC_WAIT));
    01334     }
    01335
    01336     /*
    01337      * Creates the dialog.  Frees the menu if this routine fails.
    01338      */
    01339     hwnd = InternalCreateDialog(hModule, lpdt, 0, hwndOwner,
    01340             pfnDialog, lParam, fSCDLGFlags);
    01341
    01342     if (hwnd == NULL) {
    01343
    01344         /*
    01345          * The dialog creation failed.  Re-enable the window, destroy the
    01346          * menu, ie., fail gracefully.
    01347          */
    01348         if (!fDisabled && hwndOwner != NULL)
    01349             NtUserEnableWindow(hwndOwner, TRUE);
    01350
    01351         if (fUnlockOwner)
    01352             ThreadUnlock(&tlpwndOwner);
    01353         return -1;
    01354     }
    01355
    01356     i = DialogBox2(hwnd, hwndOwner, fDisabled, fOwnerIsActiveWindow);
    01357
    01358     if (fUnlockOwner)
    01359         ThreadUnlock(&tlpwndOwner);
    01360     return i;
    01361 }

UINT IsDlgButtonChecked | ( | HWND | hwnd,
|  | int | id
| ) |

Definition at line 435 of file nt6/dlgmgr.c.

References FALSE, GetDlgItem(), NULL, SendMessage(), and UINT.

Referenced by FindDialogProc(), and CInstallPage::OnCommand().

    00438 {
    00439     if ((hwnd = GetDlgItem(hwnd, id)) != NULL) {
    00440         return (UINT)SendMessage(hwnd, BM_GETCHECK, 0, 0);
    00441     }
    00442
    00443     return FALSE;
    00444 }

BOOL MapDialogRect | ( | HWND | hwnd,
|  | LPRECT | lprc
| ) |

Definition at line 1428 of file nt6/dlgmgr.c.

References BOOL, FALSE, NULL, TRUE, ValidateDialogPwnd(), ValidateHwnd, XPixFromXDU, and YPixFromYDU.

    01431 {
    01432     PWND pwnd;
    01433
    01434     if ((pwnd = ValidateHwnd(hwnd)) == NULL) {
    01435         return FALSE;
    01436     }
    01437
    01438     /*
    01439      * Must do special validation here to make sure pwnd is a dialog window.
    01440      */
    01441     if (!ValidateDialogPwnd(pwnd))
    01442         return FALSE;
    01443
    01444     lprc->left = XPixFromXDU(lprc->left, PDLG(pwnd)->cxChar);
    01445     lprc->right = XPixFromXDU(lprc->right, PDLG(pwnd)->cxChar);
    01446     lprc->top = YPixFromYDU(lprc->top, PDLG(pwnd)->cyChar);
    01447     lprc->bottom = YPixFromYDU(lprc->bottom, PDLG(pwnd)->cyChar);
    01448
    01449     return TRUE;
    01450 }

void RepositionRect | ( | PMONITOR | pMonitor,
|  | LPRECT | lprc,
|  | DWORD | dwStyle,
|  | DWORD | dwExStyle
| ) |

Definition at line 1373 of file nt6/dlgmgr.c.

References GetPrimaryMonitor(), OffsetRect(), tagMONITOR::rcMonitor, tagMONITOR::rcWork, and SYSMET.

Referenced by DefDlgProcWorker(), and InternalCreateDialog().

    01378 {
    01379     LPRECT      lprcClip;
    01380     int         y;
    01381
    01382     UserAssert(lprc);
    01383     UserAssert(pMonitor);
    01384
    01385     if (dwStyle & WS_CHILD) {
    01386         if (dwExStyle & WS_EX_CONTROLPARENT)
    01387             return;
    01388
    01389         /*
    01390          * Old style 3.1 child dialogs--do this nonsense anyway.  Keeps
    01391          * FedEx happy.
    01392          */
    01393         pMonitor = GetPrimaryMonitor();
    01394         lprcClip = &pMonitor->rcMonitor;
    01395     } else if (dwExStyle & WS_EX_TOOLWINDOW) {
    01396         lprcClip = &pMonitor->rcMonitor;
    01397     } else {
    01398         lprcClip = &pMonitor->rcWork;
    01399     }
    01400
    01401     UserAssert(lprc);
    01402
    01403     y = lprcClip->bottom - (SYSMET(CYEDGE) * 2 + SYSMET(CYKANJIWINDOW));
    01404
    01405     if (lprc->bottom > y) {
    01406         OffsetRect(lprc, 0, y - lprc->bottom);
    01407     }
    01408
    01409     if (lprc->top < lprcClip->top) {
    01410         OffsetRect(lprc, 0, lprcClip->top - lprc->top);
    01411     }
    01412
    01413     if (lprc->right > lprcClip->right) {
    01414         OffsetRect(lprc, lprcClip->right - lprc->right, 0);
    01415     }
    01416
    01417     if (lprc->left < lprcClip->left) {
    01418         OffsetRect(lprc, lprcClip->left - lprc->left, 0);
    01419     }
    01420 }

LRESULT ResizeDlgMessage | ( | LPVOID | pObject,
|  | HWND | hwnd,
|  | UINT | message,
|  | WPARAM | wParam,
|  | LPARAM | lParam
| ) |

Definition at line 37 of file resizedlg.cpp.

Referenced by DefDlgProcWorker().

    00042 {
    00043         return ((CResizeDlg*)pObject)->DlgProc( hwnd, message, wParam, lParam );
    00044 }

BOOL SetDlgItemInt | ( | HWND | hwnd,
|  | int | item,
|  | UINT | u,
|  | BOOL | fSigned
| ) |

Definition at line 271 of file nt6/dlgmgr.c.

References BOOL, CvtDec(), FAR, and UINT.

Referenced by ClearDlg().

    00276 {
    00277     LPWSTR lpch;
    00278     WCHAR rgch[16];
    00279
    00280     lpch = rgch;
    00281     if (fSigned) {
    00282         if ((int)u < 0) {
    00283             *lpch++ = TEXT('-');
    00284             u = (UINT)(-(int)u);
    00285         }
    00286     } else {
    00287         if (u & 0x80000000) {
    00288             CvtDec(u / 10, (LPWSTR FAR *)&lpch);
    00289             u = u % 10;
    00290         }
    00291     }
    00292
    00293     CvtDec(u, (LPWSTR FAR *)&lpch);
    00294     *lpch = 0;
    00295
    00296     return SetDlgItemTextW(hwnd, item, rgch);
    00297 }

BOOL ValidateCallback | ( | HANDLE | h | ) |

BOOL ValidateDialogPwnd | ( | PWND | pwnd | ) |

Definition at line 198 of file nt6/dlgmgr.c.

References AllocLookasideEntry(), BOOL, tagWND::cbwndExtra, DialogLookaside, DLG, FALSE, FNID_STATUS_BITS, HWq, InitLookaside(), NT_SUCCESS, NtUserCallHwndParam(), NULL, PDLG, TestWF, TRUE, and WFDIALOGWINDOW.

Referenced by DefDlgProcWorker(), EndDialog(), InternalCreateDialog(), MapDialogRect(), and xxxRestoreDlgFocus().

    00200 {
    00201     static BOOL sfInit = TRUE;
    00202     PDLG pdlg;
    00203
    00204     /*
    00205      * This bit is set if we've already run through this initialization and
    00206      * have identified this window as a dialog window (able to withstand
    00207      * peeks into window words at random moments in time).
    00208      */
    00209     if (TestWF(pwnd, WFDIALOGWINDOW))
    00210         return TRUE;
    00211
    00212     if (pwnd->cbwndExtra < DLGWINDOWEXTRA) {
    00213         RIPERR0(ERROR_WINDOW_NOT_DIALOG, RIP_VERBOSE, "");
    00214         return FALSE;
    00215     }
    00216
    00217     /*
    00218      * See if the pdlg was destroyed and this is a rogue message to be ignored
    00219      */
    00220     if (pwnd->fnid & FNID_STATUS_BITS) {
    00221         return FALSE;
    00222     }
    00223
    00224     /*
    00225      * If the lookaside buffer has not been initialized, do it now.
    00226      */
    00227     if (sfInit) {
    00228         if (!NT_SUCCESS(InitLookaside(&DialogLookaside, sizeof(DLG), 2))) {
    00229             return FALSE;
    00230         }
    00231         sfInit = FALSE;
    00232     }
    00233
    00234     if ((pdlg = (PDLG)AllocLookasideEntry(&DialogLookaside)) == NULL) {
    00235         return FALSE;
    00236     }
    00237
    00238     NtUserCallHwndParam(HWq(pwnd), (ULONG_PTR)pdlg, SFI_SETDIALOGPOINTER);
    00239
    00240     return TRUE;
    00241 }

BOOL xxxRestoreDlgFocus | ( | PWND | pwnd | ) |

Definition at line 116 of file nt6/dlgmgr.c.

References BOOL, CheckLock, FALSE, GetFocus(), IS_IME_ENABLED, IsWindow(), NtUserSetFocus(), NULL, PDLG, TestWF, ValidateDialogPwnd(), WFMINIMIZED, and xxxCheckDefPushButton().

Referenced by DefDlgProcWorker().

    00118 {
    00119     HWND hwndFocus;
    00120     HWND hwndFocusSave;
    00121     BOOL fRestored = FALSE;
    00122
    00123     CheckLock(pwnd);
    00124
    00125     if (PDLG(pwnd)->hwndFocusSave && !TestWF(pwnd, WFMINIMIZED)) {
    00126
    00127         hwndFocus = GetFocus();
    00128         hwndFocusSave = PDLG(pwnd)->hwndFocusSave;
    00129
    00130         if (IsWindow(hwndFocusSave)) {
    00131             xxxCheckDefPushButton(pwnd, hwndFocus, hwndFocusSave);
    00132             fRestored = (NtUserSetFocus(hwndFocusSave) != NULL);
    00133 #ifdef FE_IME
    00134             //
    00135             // after calling SetFocus(), we need to re-validate
    00136             // the window. PDLG(pwnd) might be NULL. This can
    00137             // be happened in FE environment where IME window
    00138             // exist. (kkntbug #12613)
    00139             //
    00140             if (IS_IME_ENABLED() && !ValidateDialogPwnd(pwnd)) {
    00141                 return fRestored;
    00142         }
    00143 #endif
    00144         }
    00145         PDLG(pwnd)->hwndFocusSave = NULL;
    00146     }
    00147
    00148     return fRestored;
    00149 }

BOOL xxxSaveDlgFocus | ( | PWND | pwnd | ) |

Definition at line 89 of file nt6/dlgmgr.c.

References BOOL, CheckLock, FALSE, GetFocus(), HWq, IsChild(), NULL, PDLG, TRUE, ValidateHwnd, and xxxRemoveDefaultButton().

Referenced by DefDlgProcWorker().

    00091 {
    00092     HWND hwndFocus = GetFocus();
    00093
    00094     CheckLock(pwnd);
    00095
    00096     if (hwndFocus != NULL && IsChild(HWq(pwnd), hwndFocus) &&
    00097             PDLG(pwnd)->hwndFocusSave == NULL) {
    00098         PDLG(pwnd)->hwndFocusSave = hwndFocus;
    00099         xxxRemoveDefaultButton(pwnd, ValidateHwnd(hwndFocus));
    00100         return TRUE;
    00101     }
    00102     return FALSE;
    00103 }

## Variable Documentation

LOOKASIDE DialogLookaside

| Definition at line 26 of file nt6/dlgmgr.c.

HCURSOR hCurCursor

| Definition at line 1254 of file nt6/dlgmgr.c.