dialog.c File Reference

#include <user32.h>

Include dependency graph for dialog.c:

Go to the source code of this file.

Classes
struct	DIALOGINFO
struct	DLG_CONTROL_INFO
struct	DLG_TEMPLATE
struct	RADIOGROUP

Macros
#define	DF_END   0x0001
#define	DF_DIALOGACTIVE   0x4000
#define	GETDLGINFO(hwnd)   DIALOG_get_info(hwnd, FALSE)
#define	GET_WORD(ptr)   (*(WORD *)(ptr))
#define	GET_DWORD(ptr)   (*(DWORD *)(ptr))
#define	GET_LONG(ptr)   (*(const LONG *)(ptr))
#define	DLG_ISANSI   2
#define	SENDMSG(msg, wparam, lparam)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
DIALOGINFO *	DIALOG_get_info (HWND hWnd, BOOL create)
static const WORD *	DIALOG_GetControl32 (const WORD *p, DLG_CONTROL_INFO *info, BOOL dialogEx)
static BOOL	DIALOG_CreateControls32 (HWND hwnd, LPCSTR template, const DLG_TEMPLATE *dlgTemplate, HINSTANCE hInst, BOOL unicode)
static BOOL	DIALOG_IsAccelerator (HWND hwnd, HWND hwndDlg, WPARAM wParam)
static HWND	DIALOG_FindMsgDestination (HWND hwndDlg)
INT	DIALOG_DoDialogBox (HWND hwnd, HWND owner)
static LPCSTR	DIALOG_ParseTemplate32 (LPCSTR template, DLG_TEMPLATE *result)
static void	DEFDLG_SetFocus (HWND hwndCtrl)
static void	DEFDLG_SaveFocus (HWND hwnd)
static void	DEFDLG_RestoreFocus (HWND hwnd, BOOL justActivate)
static HWND	DIALOG_CreateIndirect (HINSTANCE hInst, LPCVOID dlgTemplate, HWND owner, DLGPROC dlgProc, LPARAM param, BOOL unicode, HWND *modal_owner)
static HWND	DEFDLG_FindDefButton (HWND hwndDlg)
static BOOL	DEFDLG_SetDefId (HWND hwndDlg, DIALOGINFO *dlgInfo, WPARAM wParam)
static BOOL	DEFDLG_SetDefButton (HWND hwndDlg, DIALOGINFO *dlgInfo, HWND hwndNew)
static LRESULT	DEFDLG_Proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, DIALOGINFO *dlgInfo)
static LRESULT	DEFDLG_Epilog (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL fResult, BOOL fAnsi)
static HWND	DIALOG_GetNextTabItem (HWND hwndMain, HWND hwndDlg, HWND hwndCtrl, BOOL fPrevious)
static INT	DIALOG_DlgDirListW (HWND hDlg, LPWSTR spec, INT idLBox, INT idStatic, UINT attrib, BOOL combo)
static INT	DIALOG_DlgDirListA (HWND hDlg, LPSTR spec, INT idLBox, INT idStatic, UINT attrib, BOOL combo)
static BOOL	DIALOG_DlgDirSelect (HWND hwnd, LPWSTR str, INT len, INT id, BOOL unicode, BOOL combo)
HWND WINAPI	CreateDialogIndirectParamAorW (HINSTANCE hInstance, LPCDLGTEMPLATE lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM lParamInit, DWORD Flags)
HWND WINAPI	CreateDialogIndirectParamA (HINSTANCE hInstance, LPCDLGTEMPLATE lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM lParamInit)
HWND WINAPI	CreateDialogIndirectParamW (HINSTANCE hInstance, LPCDLGTEMPLATE lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM lParamInit)
HWND WINAPI	CreateDialogParamA (HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam)
HWND WINAPI	CreateDialogParamW (HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam)
LRESULT WINAPI	DefDlgProcA (HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	DefDlgProcW (HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
INT_PTR WINAPI	DialogBoxIndirectParamAorW (HINSTANCE hInstance, LPCDLGTEMPLATE hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam, DWORD Flags)
INT_PTR WINAPI	DialogBoxIndirectParamA (HINSTANCE hInstance, LPCDLGTEMPLATE hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam)
INT_PTR WINAPI	DialogBoxIndirectParamW (HINSTANCE hInstance, LPCDLGTEMPLATE hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam)
INT_PTR WINAPI	DialogBoxParamA (HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam)
INT_PTR WINAPI	DialogBoxParamW (HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam)
int WINAPI	DlgDirListA (HWND hDlg, LPSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType)
int WINAPI	DlgDirListComboBoxA (HWND hDlg, LPSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype)
int WINAPI	DlgDirListComboBoxW (HWND hDlg, LPWSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT uFiletype)
int WINAPI	DlgDirListW (HWND hDlg, LPWSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT uFileType)
BOOL WINAPI	DlgDirSelectComboBoxExA (HWND hDlg, LPSTR lpString, int nCount, int nIDComboBox)
BOOL WINAPI	DlgDirSelectComboBoxExW (HWND hDlg, LPWSTR lpString, int nCount, int nIDComboBox)
BOOL WINAPI	DlgDirSelectExA (HWND hDlg, LPSTR lpString, int nCount, int nIDListBox)
BOOL WINAPI	DlgDirSelectExW (HWND hDlg, LPWSTR lpString, int nCount, int nIDListBox)
BOOL WINAPI	EndDialog (HWND hwnd, INT_PTR retval)
LONG WINAPI	GetDialogBaseUnits (VOID)
int WINAPI	GetDlgCtrlID (HWND hwndCtl)
HWND WINAPI	GetDlgItem (HWND hDlg, int nIDDlgItem)
UINT WINAPI	GetDlgItemInt (HWND hDlg, int nIDDlgItem, BOOL *lpTranslated, BOOL bSigned)
UINT WINAPI	GetDlgItemTextA (HWND hDlg, int nIDDlgItem, LPSTR lpString, int nMaxCount)
UINT WINAPI	GetDlgItemTextW (HWND hDlg, int nIDDlgItem, LPWSTR lpString, int nMaxCount)
HWND WINAPI	GetNextDlgGroupItem (HWND hDlg, HWND hCtl, BOOL bPrevious)
HWND WINAPI	GetNextDlgTabItem (HWND hDlg, HWND hCtl, BOOL bPrevious)
static BOOL CALLBACK	DIALOG_FixOneChildOnChangeFocus (HWND hwndChild, LPARAM lParam)
static void	DIALOG_FixChildrenOnChangeFocus (HWND hwndDlg, HWND hwndNext)
static HWND	DIALOG_IdToHwnd (HWND hwndDlg, INT id)
BOOL WINAPI	IsDialogMessageW (HWND hDlg, LPMSG lpMsg)
UINT WINAPI	IsDlgButtonChecked (HWND hDlg, int nIDButton)
BOOL WINAPI	MapDialogRect (HWND hDlg, LPRECT lpRect)
LRESULT WINAPI	SendDlgItemMessageA (HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT WINAPI	SendDlgItemMessageW (HWND hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL WINAPI	SetDlgItemInt (HWND hDlg, int nIDDlgItem, UINT uValue, BOOL bSigned)
BOOL WINAPI	SetDlgItemTextA (HWND hDlg, int nIDDlgItem, LPCSTR lpString)
BOOL WINAPI	SetDlgItemTextW (HWND hDlg, int nIDDlgItem, LPCWSTR lpString)
BOOL WINAPI	CheckDlgButton (HWND hDlg, int nIDButton, UINT uCheck)
static BOOL CALLBACK	CheckRB (HWND hwnd, LPARAM lParam)
BOOL WINAPI	CheckRadioButton (HWND hDlg, int nIDFirstButton, int nIDLastButton, int nIDCheckButton)

Variables
const struct builtin_class_descr	DIALOG_builtin_class

Macro Definition Documentation

DF_DIALOGACTIVE

#define DF_DIALOGACTIVE   0x4000

Definition at line 38 of file dialog.c.

DF_END

#define DF_END   0x0001

Definition at line 37 of file dialog.c.

DLG_ISANSI

#define DLG_ISANSI   2

Definition at line 43 of file dialog.c.

GET_DWORD

#define GET_DWORD

(

ptr

)

(*(DWORD *)(ptr))

Definition at line 41 of file dialog.c.

GET_LONG

#define GET_LONG

(

ptr

)

(*(const LONG *)(ptr))

Definition at line 42 of file dialog.c.

GET_WORD

#define GET_WORD

(

ptr

)

(*(WORD *)(ptr))

Definition at line 40 of file dialog.c.

GETDLGINFO

#define GETDLGINFO

(

hwnd

)

DIALOG_get_info(hwnd, FALSE)

Definition at line 39 of file dialog.c.

SENDMSG

#define SENDMSG	(		msg,
			wparam,
			lparam
	)

Value:

    ((attrib & DDL_POSTMSGS) ? PostMessageW( hwnd, msg, wparam, lparam ) \
                             : SendMessageW( hwnd, msg, wparam, lparam ))

Function Documentation

CheckDlgButton()

BOOL WINAPI CheckDlgButton	(	HWND	hDlg,
		int	nIDButton,
		UINT	uCheck
	)

Definition at line 2845 of file dialog.c.

{
    SendDlgItemMessageW( hDlg, nIDButton, BM_SETCHECK, uCheck, 0 );
    return TRUE;
}

CheckRadioButton()

BOOL WINAPI CheckRadioButton	(	HWND	hDlg,
		int	nIDFirstButton,
		int	nIDLastButton,
		int	nIDCheckButton
	)

Definition at line 2880 of file dialog.c.

{
  RADIOGROUP radioGroup;
 
  radioGroup.firstID = nIDFirstButton;
  radioGroup.lastID = nIDLastButton;
  radioGroup.checkID = nIDCheckButton;
 
  return EnumChildWindows(hDlg, CheckRB, (LPARAM)&radioGroup);
}

CheckRB()

static BOOL CALLBACK CheckRB ( HWND  hwnd, LPARAM  lParam  )

static

Definition at line 2854 of file dialog.c.

{
  LONG lChildID = GetWindowLongPtrW(hwnd, GWLP_ID);
  RADIOGROUP *lpRadioGroup = (RADIOGROUP *)lParam;
 
  if((lChildID >= lpRadioGroup->firstID) &&
     (lChildID <= lpRadioGroup->lastID))
  {
    if (lChildID == lpRadioGroup->checkID)
    {
      SendMessageW(hwnd, BM_SETCHECK, BST_CHECKED, 0);
    }
    else
    {
      SendMessageW(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
    }
  }
 
   return TRUE;
}

Referenced by CheckRadioButton().

CreateDialogIndirectParamA()

HWND WINAPI CreateDialogIndirectParamA	(	HINSTANCE	hInstance,
		LPCDLGTEMPLATE	lpTemplate,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	lParamInit
	)

Definition at line 1637 of file dialog.c.

{
  return CreateDialogIndirectParamAorW( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit, DLG_ISANSI);
}

CreateDialogIndirectParamAorW()

HWND WINAPI CreateDialogIndirectParamAorW	(	HINSTANCE	hInstance,
		LPCDLGTEMPLATE	lpTemplate,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	lParamInit,
		DWORD	Flags
	)

Definition at line 1615 of file dialog.c.

{
/* FIXME:
 *   This function might be obsolete since I don't think it is exported by NT
 *   Also wine has one more parameter identifying weather it should call
 *   the function with unicode or not
 */
  return DIALOG_CreateIndirect( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit , Flags == DLG_ISANSI ? FALSE : TRUE, NULL );
}

Referenced by CreateDialogIndirectParamA(), and CreateDialogIndirectParamW().

CreateDialogIndirectParamW()

HWND WINAPI CreateDialogIndirectParamW	(	HINSTANCE	hInstance,
		LPCDLGTEMPLATE	lpTemplate,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	lParamInit
	)

Definition at line 1653 of file dialog.c.

{
  return CreateDialogIndirectParamAorW( hInstance, lpTemplate, hWndParent, lpDialogFunc, lParamInit, 0);
}

CreateDialogParamA()

HWND WINAPI CreateDialogParamA	(	HINSTANCE	hInstance,
		LPCSTR	lpTemplateName,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	dwInitParam
	)

Definition at line 1669 of file dialog.c.

{
    HRSRC hrsrc;
    LPCDLGTEMPLATE ptr;
 
    if (!(hrsrc = FindResourceA( hInstance, lpTemplateName, (LPCSTR)RT_DIALOG ))) return 0;
    if (!(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc))) return 0;
    return CreateDialogIndirectParamA( hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam );
}

CreateDialogParamW()

HWND WINAPI CreateDialogParamW	(	HINSTANCE	hInstance,
		LPCWSTR	lpTemplateName,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	dwInitParam
	)

Definition at line 1690 of file dialog.c.

{
    HRSRC hrsrc;
    LPCDLGTEMPLATE ptr;
 
    if (!(hrsrc = FindResourceW( hInstance, lpTemplateName, (LPCWSTR)RT_DIALOG ))) return 0;
    if (!(ptr = (LPCDLGTEMPLATE)LoadResource(hInstance, hrsrc))) return 0;
    return CreateDialogIndirectParamW( hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam );
}

DEFDLG_Epilog()

static LRESULT DEFDLG_Epilog ( HWND  hwnd, UINT  msg, WPARAM  wParam, LPARAM  lParam, BOOL  fResult, BOOL  fAnsi  )

static

Definition at line 1344 of file dialog.c.

{
    if ((msg >= WM_CTLCOLORMSGBOX && msg <= WM_CTLCOLORSTATIC) ||
         msg == WM_CTLCOLOR)
       {
          if (fResult) return fResult;
 
          return fAnsi ? DefWindowProcA(hwnd, msg, wParam, lParam):
                         DefWindowProcW(hwnd, msg, wParam, lParam);
       }
    if ( msg == WM_COMPAREITEM ||
         msg == WM_VKEYTOITEM || msg == WM_CHARTOITEM ||
         msg == WM_QUERYDRAGICON || msg == WM_INITDIALOG)
        return fResult;
 
    return GetWindowLongPtrW( hwnd, DWLP_MSGRESULT );
}

Referenced by DefDlgProcA(), and DefDlgProcW().

DEFDLG_FindDefButton()

static HWND DEFDLG_FindDefButton ( HWND  hwndDlg )

static

Definition at line 1085 of file dialog.c.

{
    HWND hwndChild, hwndTmp;
 
    hwndChild = GetWindow( hwndDlg, GW_CHILD );
    while (hwndChild)
    {
        if (SendMessageW( hwndChild, WM_GETDLGCODE, 0, 0 ) & DLGC_DEFPUSHBUTTON)
            break;
 
        /* Recurse into WS_EX_CONTROLPARENT controls */
        if (GetWindowLongPtrW( hwndChild, GWL_EXSTYLE ) & WS_EX_CONTROLPARENT)
        {
            LONG dsStyle = GetWindowLongPtrW( hwndChild, GWL_STYLE );
            if ((dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED) &&
                (hwndTmp = DEFDLG_FindDefButton(hwndChild)) != NULL)
           return hwndTmp;
        }
        hwndChild = GetWindow( hwndChild, GW_HWNDNEXT );
    }
    return hwndChild;
}

Referenced by DEFDLG_FindDefButton(), DEFDLG_Proc(), DEFDLG_SetDefButton(), and DEFDLG_SetDefId().

DEFDLG_Proc()

static LRESULT DEFDLG_Proc ( HWND  hwnd, UINT  msg, WPARAM  wParam, LPARAM  lParam, DIALOGINFO *  dlgInfo  )

static

Definition at line 1232 of file dialog.c.

{
    switch(msg)
    {
        case WM_ERASEBKGND:
        {
            HBRUSH brush = GetControlColor( hwnd, hwnd, (HDC)wParam, WM_CTLCOLORDLG);
            if (brush)
            {
                RECT rect;
                HDC hdc = (HDC)wParam;
                GetClientRect( hwnd, &rect );
                DPtoLP( hdc, (LPPOINT)&rect, 2 );
                FillRect( hdc, &rect, brush );
            }
            return 1;
        }
        case WM_NCDESTROY:
            dlgInfo = DIALOG_get_info(hwnd, FALSE);
            if (dlgInfo != NULL)
            {
                if (dlgInfo->hUserFont) DeleteObject( dlgInfo->hUserFont );
                if (dlgInfo->hMenu) DestroyMenu( dlgInfo->hMenu );
                HeapFree( GetProcessHeap(), 0, dlgInfo );
                NtUserSetThreadState(0,DF_DIALOGACTIVE);
                NtUserxSetDialogPointer( hwnd, 0 );
            }
             /* Window clean-up */
            return DefWindowProcA( hwnd, msg, wParam, lParam );
 
        case WM_SHOWWINDOW:
            if (!wParam) DEFDLG_SaveFocus( hwnd );
            return DefWindowProcA( hwnd, msg, wParam, lParam );
 
        case WM_ACTIVATE:
            { // ReactOS
               DWORD dwSetFlag;
               HWND hwndparent = DIALOG_FindMsgDestination( hwnd );
               // if WA_CLICK/ACTIVE ? set dialog is active.
               dwSetFlag = wParam ? DF_DIALOGACTIVE : 0;
               if (hwndparent != hwnd) NtUserSetThreadState(dwSetFlag, DF_DIALOGACTIVE);
            }
            if (wParam) DEFDLG_RestoreFocus( hwnd, TRUE );
            else DEFDLG_SaveFocus( hwnd );
            return 0;
 
        case WM_SETFOCUS:
            DEFDLG_RestoreFocus( hwnd, FALSE );
            return 0;
 
        case DM_SETDEFID:
            if (dlgInfo && !(dlgInfo->flags & DF_END))
                DEFDLG_SetDefId( hwnd, dlgInfo, wParam );
            return 1;
 
        case DM_GETDEFID:
            if (dlgInfo && !(dlgInfo->flags & DF_END))
            {
                HWND hwndDefId;
                if (dlgInfo->idResult)
                    return MAKELONG( dlgInfo->idResult, DC_HASDEFID );
                if ((hwndDefId = DEFDLG_FindDefButton( hwnd )))
                    return MAKELONG( GetDlgCtrlID( hwndDefId ), DC_HASDEFID);
            }
            return 0;
 
#ifdef __REACTOS__
        case DM_REPOSITION:
            DEFDLG_Reposition(hwnd);
            return 0;
#endif
        case WM_NEXTDLGCTL:
            if (dlgInfo)
            {
                HWND hwndDest = (HWND)wParam;
                if (!lParam)
                    hwndDest = GetNextDlgTabItem(hwnd, GetFocus(), wParam);
                if (hwndDest) DEFDLG_SetFocus( hwndDest );
                DEFDLG_SetDefButton( hwnd, dlgInfo, hwndDest );
            }
            return 0;
 
        case WM_ENTERMENULOOP:
        case WM_LBUTTONDOWN:
        case WM_NCLBUTTONDOWN:
            {
                HWND hwndFocus = GetFocus();
                if (hwndFocus)
                {
                    /* always make combo box hide its listbox control */
                    if (!SendMessageW( hwndFocus, CB_SHOWDROPDOWN, FALSE, 0 ))
                        SendMessageW( GetParent(hwndFocus), CB_SHOWDROPDOWN, FALSE, 0 );
                }
            }
            return DefWindowProcA( hwnd, msg, wParam, lParam );
 
        case WM_GETFONT:
            return dlgInfo ? (LRESULT)dlgInfo->hUserFont : 0;
 
        case WM_CLOSE:
            PostMessageA( hwnd, WM_COMMAND, MAKEWPARAM(IDCANCEL, BN_CLICKED),
                            (LPARAM)GetDlgItem( hwnd, IDCANCEL ) );
            return 0;
    }
    return 0;
}

Referenced by DefDlgProcA(), and DefDlgProcW().

DEFDLG_RestoreFocus()

static void DEFDLG_RestoreFocus ( HWND  hwnd, BOOL  justActivate  )

static

Definition at line 731 of file dialog.c.

{
    DIALOGINFO *infoPtr;
 
    if (IsIconic( hwnd )) return;
    if (!(infoPtr = GETDLGINFO(hwnd))) return;
    /* Don't set the focus back to controls if EndDialog is already called.*/
    if (infoPtr->flags & DF_END) return;
    if (!IsWindow(infoPtr->hwndFocus) || infoPtr->hwndFocus == hwnd) {
        if (justActivate) return;
        /* If no saved focus control exists, set focus to the first visible,
           non-disabled, WS_TABSTOP control in the dialog */
        infoPtr->hwndFocus = GetNextDlgTabItem( hwnd, 0, FALSE );
        /* If there are no WS_TABSTOP controls, set focus to the first visible,
           non-disabled control in the dialog */
        if (!infoPtr->hwndFocus) infoPtr->hwndFocus = GetNextDlgGroupItem( hwnd, 0, FALSE );
        if (!IsWindow( infoPtr->hwndFocus )) return;
    }
    if (justActivate)
        SetFocus( infoPtr->hwndFocus );
    else
        DEFDLG_SetFocus( infoPtr->hwndFocus );
 
    infoPtr->hwndFocus = NULL;
}

Referenced by DEFDLG_Proc().

DEFDLG_SaveFocus()

static void DEFDLG_SaveFocus ( HWND  hwnd )

static

Definition at line 716 of file dialog.c.

{
    DIALOGINFO *infoPtr;
    HWND hwndFocus = GetFocus();
 
    if (!hwndFocus || !IsChild( hwnd, hwndFocus )) return;
    if (!(infoPtr = GETDLGINFO(hwnd))) return;
    infoPtr->hwndFocus = hwndFocus;
    /* Remove default button */
}

Referenced by DEFDLG_Proc().

DEFDLG_SetDefButton()

static BOOL DEFDLG_SetDefButton ( HWND  hwndDlg, DIALOGINFO *  dlgInfo, HWND  hwndNew  )

static

Need to draw only default push button rectangle. Since the next control is not a push button, need to draw the push button rectangle for the default control.

Definition at line 1147 of file dialog.c.

{
    DWORD dlgcode=0; /* initialize just to avoid a warning */
    HWND hwndOld = GetDlgItem( hwndDlg, dlgInfo->idResult );
 
    if (hwndNew &&
        !((dlgcode=SendMessageW(hwndNew, WM_GETDLGCODE, 0, 0 ))
            & (DLGC_UNDEFPUSHBUTTON | DLGC_DEFPUSHBUTTON)))
    {
        hwndNew = hwndOld;
        dlgcode = SendMessageW(hwndNew, WM_GETDLGCODE, 0, 0 );
    }
 
    /* Make sure the old default control is a valid push button ID */
    if (!hwndOld || !(SendMessageW( hwndOld, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
        hwndOld = DEFDLG_FindDefButton( hwndDlg );
    if (hwndOld && hwndOld != hwndNew)
        SendMessageW( hwndOld, BM_SETSTYLE, BS_PUSHBUTTON, TRUE );
 
    if (hwndNew)
    {
        if(dlgcode & DLGC_UNDEFPUSHBUTTON)
            SendMessageW( hwndNew, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE );
    }
    return TRUE;
}

Referenced by DEFDLG_Proc().

DEFDLG_SetDefId()

static BOOL DEFDLG_SetDefId ( HWND  hwndDlg, DIALOGINFO *  dlgInfo, WPARAM  wParam  )

static

Definition at line 1114 of file dialog.c.

{
    DWORD dlgcode=0; /* initialize just to avoid a warning */
    HWND hwndOld, hwndNew = GetDlgItem(hwndDlg, wParam);
    INT old_id = dlgInfo->idResult;
 
    dlgInfo->idResult = wParam;
    if (hwndNew &&
        !((dlgcode=SendMessageW(hwndNew, WM_GETDLGCODE, 0, 0 ))
            & (DLGC_UNDEFPUSHBUTTON | DLGC_BUTTON)))
        return FALSE;  /* Destination is not a push button */
 
    /* Make sure the old default control is a valid push button ID */
    hwndOld = GetDlgItem( hwndDlg, old_id );
    if (!hwndOld || !(SendMessageW( hwndOld, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
        hwndOld = DEFDLG_FindDefButton( hwndDlg );
    if (hwndOld && hwndOld != hwndNew)
        SendMessageW( hwndOld, BM_SETSTYLE, BS_PUSHBUTTON, TRUE );
 
    if (hwndNew)
    {
        if(dlgcode & DLGC_UNDEFPUSHBUTTON)
            SendMessageW( hwndNew, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE );
    }
    return TRUE;
}

Referenced by DEFDLG_Proc().

DEFDLG_SetFocus()

static void DEFDLG_SetFocus ( HWND  hwndCtrl )

static

Definition at line 705 of file dialog.c.

{
    if (SendMessageW( hwndCtrl, WM_GETDLGCODE, 0, 0 ) & DLGC_HASSETSEL)
        SendMessageW( hwndCtrl, EM_SETSEL, 0, -1 );
    SetFocus( hwndCtrl );
}

Referenced by DEFDLG_Proc(), and DEFDLG_RestoreFocus().

DefDlgProcA()

LRESULT WINAPI DefDlgProcA	(	HWND	hDlg,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1711 of file dialog.c.

{
    DIALOGINFO *dlgInfo;
    WNDPROC dlgproc;
    BOOL result = FALSE;
 
    /* Perform DIALOGINFO initialization if not done */
    if(!(dlgInfo = DIALOG_get_info( hDlg, TRUE ))) return 0; 
 
    SetWindowLongPtrW( hDlg, DWLP_MSGRESULT, 0 );
 
    if ((dlgproc = (WNDPROC)GetWindowLongPtrW( hDlg, DWLP_DLGPROC )))
    {
        /* Call dialog procedure */
        result = CallWindowProcA( dlgproc, hDlg, Msg, wParam, lParam );
    }
 
    if (!result && IsWindow(hDlg))
    {
        /* callback didn't process this message */
 
        switch(Msg)
        {
            case WM_ERASEBKGND:
            case WM_SHOWWINDOW:
            case WM_ACTIVATE:
            case WM_SETFOCUS:
            case DM_SETDEFID:
            case DM_GETDEFID:
#ifdef __REACTOS__
            case DM_REPOSITION:
#endif
            case WM_NEXTDLGCTL:
            case WM_GETFONT:
            case WM_CLOSE:
            case WM_NCDESTROY:
            case WM_ENTERMENULOOP:
            case WM_LBUTTONDOWN:
            case WM_NCLBUTTONDOWN:
                 return DEFDLG_Proc( hDlg, Msg, wParam, lParam, dlgInfo );
            case WM_INITDIALOG:
            case WM_VKEYTOITEM:
            case WM_COMPAREITEM:
            case WM_CHARTOITEM:
                 break;
 
            default:
                 return DefWindowProcA( hDlg, Msg, wParam, lParam );
        }
    }
    return DEFDLG_Epilog(hDlg, Msg, wParam, lParam, result, TRUE);
}

DefDlgProcW()

LRESULT WINAPI DefDlgProcW	(	HWND	hDlg,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1774 of file dialog.c.

{
    DIALOGINFO *dlgInfo;
    WNDPROC dlgproc;
    BOOL result = FALSE;
 
    /* Perform DIALOGINFO initialization if not done */
    if(!(dlgInfo = DIALOG_get_info( hDlg, TRUE ))) return 0; 
 
    SetWindowLongPtrW( hDlg, DWLP_MSGRESULT, 0 );
 
    if ((dlgproc = (WNDPROC)GetWindowLongPtrW( hDlg, DWLP_DLGPROC )))
    {
        /* Call dialog procedure */
        result = CallWindowProcW( dlgproc, hDlg, Msg, wParam, lParam );
    }
 
    if (!result && IsWindow(hDlg))
    {
        /* callback didn't process this message */
 
        switch(Msg)
        {
            case WM_ERASEBKGND:
            case WM_SHOWWINDOW:
            case WM_ACTIVATE:
            case WM_SETFOCUS:
            case DM_SETDEFID:
            case DM_GETDEFID:
#ifdef __REACTOS__
            case DM_REPOSITION:
#endif
            case WM_NEXTDLGCTL:
            case WM_GETFONT:
            case WM_CLOSE:
            case WM_NCDESTROY:
            case WM_ENTERMENULOOP:
            case WM_LBUTTONDOWN:
            case WM_NCLBUTTONDOWN:
                 return DEFDLG_Proc( hDlg, Msg, wParam, lParam, dlgInfo );
            case WM_INITDIALOG:
            case WM_VKEYTOITEM:
            case WM_COMPAREITEM:
            case WM_CHARTOITEM:
                 break;
 
            default:
                 return DefWindowProcW( hDlg, Msg, wParam, lParam );
        }
    }
    return DEFDLG_Epilog(hDlg, Msg, wParam, lParam, result, FALSE);
}

DIALOG_CreateControls32()

static BOOL DIALOG_CreateControls32 ( HWND  hwnd, LPCSTR  template, const DLG_TEMPLATE *  dlgTemplate, HINSTANCE  hInst, BOOL  unicode  )

static

Definition at line 278 of file dialog.c.

{
    DIALOGINFO * dlgInfo;
    DLG_CONTROL_INFO info;
    HWND hwndCtrl, hwndDefButton = 0;
    INT items = dlgTemplate->nbItems;
 
    if (!(dlgInfo = GETDLGINFO(hwnd))) return FALSE;
 
    TRACE(" BEGIN\n" );
    while (items--)
    {
        template = (LPCSTR)DIALOG_GetControl32( (const WORD *)template, &info,
                                                dlgTemplate->dialogEx );
        info.style &= ~WS_POPUP;
        info.style |= WS_CHILD;
 
        if (info.style & WS_BORDER)
        {
            info.style &= ~WS_BORDER;
            info.exStyle |= WS_EX_CLIENTEDGE;
        }
 
        if (unicode)
        {
            hwndCtrl = CreateWindowExW( info.exStyle | WS_EX_NOPARENTNOTIFY,
                                        info.className, info.windowName,
                                        info.style | WS_CHILD,
                                        MulDiv(info.x, dlgInfo->xBaseUnit, 4),
                                        MulDiv(info.y, dlgInfo->yBaseUnit, 8),
                                        MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
                                        MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
                                        hwnd, (HMENU)(ULONG_PTR)info.id,
                                        hInst, (LPVOID)info.data );
        }
        else
        {
            LPSTR class = (LPSTR)info.className;
            LPSTR caption = (LPSTR)info.windowName;
 
            if (!IS_INTRESOURCE(class))
            {
                DWORD len = WideCharToMultiByte( CP_ACP, 0, info.className, -1, NULL, 0, NULL, NULL );
                class = HeapAlloc( GetProcessHeap(), 0, len );
                if (class != NULL)
                    WideCharToMultiByte( CP_ACP, 0, info.className, -1, class, len, NULL, NULL );
            }
            if (!IS_INTRESOURCE(caption))
            {
                DWORD len = WideCharToMultiByte( CP_ACP, 0, info.windowName, -1, NULL, 0, NULL, NULL );
                caption = HeapAlloc( GetProcessHeap(), 0, len );
                if (caption != NULL)
                    WideCharToMultiByte( CP_ACP, 0, info.windowName, -1, caption, len, NULL, NULL );
            }
 
            if (class != NULL && caption != NULL)
            {
                hwndCtrl = CreateWindowExA( info.exStyle | WS_EX_NOPARENTNOTIFY,
                                            class, caption, info.style | WS_CHILD,
                                            MulDiv(info.x, dlgInfo->xBaseUnit, 4),
                                            MulDiv(info.y, dlgInfo->yBaseUnit, 8),
                                            MulDiv(info.cx, dlgInfo->xBaseUnit, 4),
                                            MulDiv(info.cy, dlgInfo->yBaseUnit, 8),
                                            hwnd, (HMENU)(ULONG_PTR)info.id,
                                            hInst, (LPVOID)info.data );
            }
            else
                hwndCtrl = NULL;
            if (!IS_INTRESOURCE(class)) HeapFree( GetProcessHeap(), 0, class );
            if (!IS_INTRESOURCE(caption)) HeapFree( GetProcessHeap(), 0, caption );
        }
 
        if (info.windowNameFree)
        {
            HeapFree( GetProcessHeap(), 0, (LPVOID)info.windowName );
        }
 
        if (!hwndCtrl)
        {
            WARN("control %s %s creation failed\n", debugstr_w(info.className),
                  debugstr_w(info.windowName));
            if (dlgTemplate->style & DS_NOFAILCREATE) continue;
            return FALSE;
        }
 
        /* Send initialisation messages to the control */
        if (dlgInfo->hUserFont) SendMessageW( hwndCtrl, WM_SETFONT,
                                             (WPARAM)dlgInfo->hUserFont, 0 );
        if (SendMessageW(hwndCtrl, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON)
        {
            /* If there's already a default push-button, set it back */
            /* to normal and use this one instead. */
            if (hwndDefButton)
                SendMessageW( hwndDefButton, BM_SETSTYLE, BS_PUSHBUTTON, FALSE );
            hwndDefButton = hwndCtrl;
            dlgInfo->idResult = GetWindowLongPtrA( hwndCtrl, GWLP_ID );
        }
    }
    TRACE(" END\n" );
    return TRUE;
}

Referenced by DIALOG_CreateIndirect().

DIALOG_CreateIndirect()

static HWND DIALOG_CreateIndirect ( HINSTANCE  hInst, LPCVOID  dlgTemplate, HWND  owner, DLGPROC  dlgProc, LPARAM  param, BOOL  unicode, HWND *  modal_owner  )

static

Definition at line 765 of file dialog.c.

{
    HWND hwnd;
    RECT rect;
    POINT pos;
    SIZE size;
    DLG_TEMPLATE template;
    DIALOGINFO * dlgInfo = NULL;
    DWORD units = GetDialogBaseUnits();
    HWND disabled_owner = NULL;
    HMENU hMenu = 0;
    HFONT hUserFont = 0;
    UINT flags = 0;
    UINT xBaseUnit = LOWORD(units);
    UINT yBaseUnit = HIWORD(units);
 
      /* Parse dialog template */
 
    if (!dlgTemplate) return 0;
    dlgTemplate = DIALOG_ParseTemplate32( dlgTemplate, &template );
 
      /* Load menu */
 
    if (template.menuName) hMenu = LoadMenuW( hInst, template.menuName );
 
      /* Create custom font if needed */
 
    if (template.style & DS_SETFONT)
    {
        HDC dc = GetDC(0);
 
        if (template.pointSize == 0x7fff)
        {
            /* We get the message font from the non-client metrics */
            NONCLIENTMETRICSW ncMetrics;
 
            ncMetrics.cbSize = sizeof(NONCLIENTMETRICSW);
            if (SystemParametersInfoW(SPI_GETNONCLIENTMETRICS,
                                      sizeof(NONCLIENTMETRICSW), &ncMetrics, 0))
            {
                hUserFont = CreateFontIndirectW( &ncMetrics.lfMessageFont );
            }
        }
        else
        {
            /* We convert the size to pixels and then make it -ve.  This works
             * for both +ve and -ve template.pointSize */
            int pixels = MulDiv(template.pointSize, GetDeviceCaps(dc , LOGPIXELSY), 72);
            hUserFont = CreateFontW( -pixels, 0, 0, 0, template.weight,
                                              template.italic, FALSE, FALSE, DEFAULT_CHARSET, 0, 0,
                                              PROOF_QUALITY, FF_DONTCARE,
                                              template.faceName );
        }
 
        if (hUserFont)
        {
            SIZE charSize;
            HFONT hOldFont = SelectObject( dc, hUserFont );
            charSize.cx = GdiGetCharDimensions( dc, NULL, &charSize.cy );
            if (charSize.cx)
            {
                xBaseUnit = charSize.cx;
                yBaseUnit = charSize.cy;
            }
            SelectObject( dc, hOldFont );
        }
        ReleaseDC(0, dc);
        TRACE("units = %d,%d\n", xBaseUnit, yBaseUnit );
    }
 
    /* Create dialog main window */
 
    SetRect(&rect, 0, 0, MulDiv(template.cx, xBaseUnit, 4), MulDiv(template.cy, yBaseUnit, 8));
    if (template.style & DS_CONTROL)
        template.style &= ~(WS_CAPTION|WS_SYSMENU);
    template.style |= DS_3DLOOK;
    if (template.style & DS_MODALFRAME)
        template.exStyle |= WS_EX_DLGMODALFRAME;
    if ((template.style & DS_CONTROL) || !(template.style & WS_CHILD))
        template.exStyle |= WS_EX_CONTROLPARENT;
    AdjustWindowRectEx( &rect, template.style, (hMenu != 0), template.exStyle );
    pos.x = rect.left;
    pos.y = rect.top;
    size.cx = rect.right - rect.left;
    size.cy = rect.bottom - rect.top;
 
    if (template.x == CW_USEDEFAULT16)
    {
        pos.x = pos.y = CW_USEDEFAULT;
    }
    else
    {
        HMONITOR monitor = 0;
        MONITORINFO mon_info;
 
        mon_info.cbSize = sizeof(mon_info);
        if (template.style & DS_CENTER)
        {
            monitor = MonitorFromWindow( owner ? owner : GetActiveWindow(), MONITOR_DEFAULTTOPRIMARY );
            GetMonitorInfoW( monitor, &mon_info );
            pos.x = (mon_info.rcWork.left + mon_info.rcWork.right - size.cx) / 2;
            pos.y = (mon_info.rcWork.top + mon_info.rcWork.bottom - size.cy) / 2;
        }
        else if (template.style & DS_CENTERMOUSE)
        {
            GetCursorPos( &pos );
            monitor = MonitorFromPoint( pos, MONITOR_DEFAULTTOPRIMARY );
            GetMonitorInfoW( monitor, &mon_info );
        }
        else
        {
            pos.x += MulDiv(template.x, xBaseUnit, 4);
            pos.y += MulDiv(template.y, yBaseUnit, 8);
            //
            // REACTOS : Need an owner to be passed!!!
            //
            if (!(template.style & (WS_CHILD|DS_ABSALIGN)) && owner ) ClientToScreen( owner, &pos );
        }
        if ( !(template.style & WS_CHILD) )
        {
            INT dX, dY;
 
            /* try to fit it into the desktop */
 
            if (!monitor)
            {
                SetRect( &rect, pos.x, pos.y, pos.x + size.cx, pos.y + size.cy );
                monitor = MonitorFromRect( &rect, MONITOR_DEFAULTTOPRIMARY );
                GetMonitorInfoW( monitor, &mon_info );
            }
            if ((dX = pos.x + size.cx + GetSystemMetrics(SM_CXDLGFRAME) - mon_info.rcWork.right) > 0)
                pos.x -= dX;
            if ((dY = pos.y + size.cy + GetSystemMetrics(SM_CYDLGFRAME) - mon_info.rcWork.bottom) > 0)
                pos.y -= dY;
            if( pos.x < mon_info.rcWork.left ) pos.x = mon_info.rcWork.left;
            if( pos.y < mon_info.rcWork.top ) pos.y = mon_info.rcWork.top;
        }
    }
 
    if (modal_owner && owner)
    {
        HWND parent = NULL;
        /*
         * Owner needs to be top level window. We need to duplicate the logic from server,
         * because we need to disable it before creating dialog window. Note that we do that
         * even if dialog has WS_CHILD, but only for modal dialogs, which matched what
         * Windows does.
         */
        while ((GetWindowLongW( owner, GWL_STYLE ) & (WS_POPUP|WS_CHILD)) == WS_CHILD)
        {
            parent = GetParent( owner );
            if (!parent || parent == GetDesktopWindow()) break;
            owner = parent;
        }
        if (!parent) parent = GetAncestor( owner, GA_ROOT );
 
        if (parent)
        {
           owner = parent;
 
           if (IsWindowEnabled( owner ))
           {
               HWND captured = NULL;
               disabled_owner = owner;
               EnableWindow( disabled_owner, FALSE );
 
               captured = GetCapture();
 
               if (captured)
                   SendMessageW(captured, WM_CANCELMODE, 0, 0);
           }
        }
        *modal_owner = owner;
    }
 
    if (unicode)
    {
        hwnd = CreateWindowExW(template.exStyle, template.className, template.caption,
                               template.style & ~WS_VISIBLE, pos.x, pos.y, size.cx, size.cy,
                               owner, hMenu, hInst, NULL );
    }
    else
    {
        LPCSTR class = (LPCSTR)template.className;
        LPCSTR caption = (LPCSTR)template.caption;
        LPSTR class_tmp = NULL;
        LPSTR caption_tmp = NULL;
 
        if (!IS_INTRESOURCE(class))
        {
            DWORD len = WideCharToMultiByte( CP_ACP, 0, template.className, -1, NULL, 0, NULL, NULL );
            class_tmp = HeapAlloc( GetProcessHeap(), 0, len );
            WideCharToMultiByte( CP_ACP, 0, template.className, -1, class_tmp, len, NULL, NULL );
            class = class_tmp;
        }
        if (!IS_INTRESOURCE(caption))
        {
            DWORD len = WideCharToMultiByte( CP_ACP, 0, template.caption, -1, NULL, 0, NULL, NULL );
            caption_tmp = HeapAlloc( GetProcessHeap(), 0, len );
            WideCharToMultiByte( CP_ACP, 0, template.caption, -1, caption_tmp, len, NULL, NULL );
            caption = caption_tmp;
        }
        hwnd = CreateWindowExA(template.exStyle, class, caption,
                               template.style & ~WS_VISIBLE, pos.x, pos.y, size.cx, size.cy,
                               owner, hMenu, hInst, NULL );
        HeapFree( GetProcessHeap(), 0, class_tmp );
        HeapFree( GetProcessHeap(), 0, caption_tmp );
    }
 
    if (!hwnd)
    {
        if (hUserFont) DeleteObject( hUserFont );
        if (hMenu) DestroyMenu( hMenu );
        if (disabled_owner) EnableWindow( disabled_owner, TRUE );
        return 0;
    }
 
    /* moved this from the top of the method to here as DIALOGINFO structure
    will be valid only after WM_CREATE message has been handled in DefDlgProc
    All the members of the structure get filled here using temp variables */
    dlgInfo = DIALOG_get_info( hwnd, TRUE );
    // ReactOS
    if (dlgInfo == NULL)
    {
        if (hUserFont) DeleteObject( hUserFont );
        if (hMenu) DestroyMenu( hMenu );
        if (disabled_owner) EnableWindow( disabled_owner, TRUE );
        return 0;
    }
    //
    dlgInfo->hwndFocus   = 0;
    dlgInfo->hUserFont   = hUserFont;
    dlgInfo->hMenu       = hMenu;
    dlgInfo->xBaseUnit   = xBaseUnit;
    dlgInfo->yBaseUnit   = yBaseUnit;
    dlgInfo->flags       = flags;
 
    if (template.helpId) SetWindowContextHelpId( hwnd, template.helpId );
 
    if (unicode) SetWindowLongPtrW( hwnd, DWLP_DLGPROC, (ULONG_PTR)dlgProc );
    else SetWindowLongPtrA( hwnd, DWLP_DLGPROC, (ULONG_PTR)dlgProc );
 
    if (dlgProc && dlgInfo->hUserFont)
        SendMessageW( hwnd, WM_SETFONT, (WPARAM)dlgInfo->hUserFont, 0 );
 
    /* Create controls */
 
    if (DIALOG_CreateControls32( hwnd, dlgTemplate, &template, hInst, unicode ))
    {
        /* Send initialisation messages and set focus */
 
        if (dlgProc)
        {
            HWND focus = GetNextDlgTabItem( hwnd, 0, FALSE );
            if (!focus) focus = GetNextDlgGroupItem( hwnd, 0, FALSE );
            if (SendMessageW( hwnd, WM_INITDIALOG, (WPARAM)focus, param ) && IsWindow( hwnd ) &&
                ((~template.style & DS_CONTROL) || (template.style & WS_VISIBLE)))
            {
                /* By returning TRUE, app has requested a default focus assignment.
                 * WM_INITDIALOG may have changed the tab order, so find the first
                 * tabstop control again. */
                focus = GetNextDlgTabItem( hwnd, 0, FALSE );
                if (!focus) focus = GetNextDlgGroupItem( hwnd, 0, FALSE );
                if (focus)
                {
                    if (SendMessageW( focus, WM_GETDLGCODE, 0, 0 ) & DLGC_HASSETSEL)
                        SendMessageW( focus, EM_SETSEL, 0, MAXLONG );
                    SetFocus( focus );
                }
                else
                {
                    if (!(template.style & WS_CHILD))
                        SetFocus( hwnd );
                }
            }
            //DEFDLG_SaveFocus( hwnd );
        }
        if (!(GetWindowLongPtrW( hwnd, GWL_STYLE ) & WS_CHILD))
            SendMessageW( hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0);
        if (template.style & WS_VISIBLE && !(GetWindowLongPtrW( hwnd, GWL_STYLE ) & WS_VISIBLE))
        {
           ShowWindow( hwnd, SW_SHOWNORMAL );   /* SW_SHOW doesn't always work */
           UpdateWindow( hwnd );
           IntNotifyWinEvent(EVENT_SYSTEM_DIALOGSTART, hwnd, OBJID_WINDOW, CHILDID_SELF, 0);
        }
        return hwnd;
    }
    if (disabled_owner) EnableWindow( disabled_owner, TRUE );
    IntNotifyWinEvent(EVENT_SYSTEM_DIALOGEND, hwnd, OBJID_WINDOW, CHILDID_SELF, 0);
    if( IsWindow(hwnd) )
    {
      DestroyWindow( hwnd );
      if (owner)
      {  ERR("DIALOG_CreateIndirect 1\n");
         if ( NtUserGetThreadState(THREADSTATE_FOREGROUNDTHREAD) && // Rule #1.
             !NtUserQueryWindow(owner, QUERY_WINDOW_FOREGROUND) )
         { ERR("DIALOG_CreateIndirect SFW\n");
            SetForegroundWindow(owner);
         }
      }
    }
    return 0;
}

Referenced by CreateDialogIndirectParamAorW(), DialogBoxIndirectParamAorW(), DialogBoxParamA(), and DialogBoxParamW().

DIALOG_DlgDirListA()

static INT DIALOG_DlgDirListA ( HWND  hDlg, LPSTR  spec, INT  idLBox, INT  idStatic, UINT  attrib, BOOL  combo  )

static

Definition at line 1527 of file dialog.c.

{
    if (spec)
    {
        INT ret, len = MultiByteToWideChar( CP_ACP, 0, spec, -1, NULL, 0 );
        LPWSTR specW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
        if (specW == NULL)
            return FALSE;
        MultiByteToWideChar( CP_ACP, 0, spec, -1, specW, len );
        ret = DIALOG_DlgDirListW( hDlg, specW, idLBox, idStatic, attrib, combo );
        WideCharToMultiByte( CP_ACP, 0, specW, -1, spec, 0x7fffffff, NULL, NULL );
        HeapFree( GetProcessHeap(), 0, specW );
        return ret;
    }
    return DIALOG_DlgDirListW( hDlg, NULL, idLBox, idStatic, attrib, combo );
}

Referenced by DlgDirListA(), and DlgDirListComboBoxA().

DIALOG_DlgDirListW()

static INT DIALOG_DlgDirListW ( HWND  hDlg, LPWSTR  spec, INT  idLBox, INT  idStatic, UINT  attrib, BOOL  combo  )

static

Definition at line 1431 of file dialog.c.

{
    HWND hwnd;
    LPWSTR orig_spec = spec;
    WCHAR any[] = {'*','.','*',0};
    WCHAR star[] = {'*',0};
 
#define SENDMSG(msg,wparam,lparam) \
    ((attrib & DDL_POSTMSGS) ? PostMessageW( hwnd, msg, wparam, lparam ) \
                             : SendMessageW( hwnd, msg, wparam, lparam ))
 
    TRACE("%p %s %d %d %04x\n", hDlg, debugstr_w(spec), idLBox, idStatic, attrib );
 
    /* If the path exists and is a directory, chdir to it */
    if (!spec || !spec[0] || SetCurrentDirectoryW( spec )) spec = star;
    else
    {
        WCHAR *p, *p2;
 
        if (!strchrW(spec, '*') && !strchrW(spec, '?'))
        {
            SetLastError(ERROR_NO_WILDCARD_CHARACTERS);
            return FALSE;
        }
        p = spec;
        if ((p2 = strchrW( p, ':' ))) p = p2 + 1;
        if ((p2 = strrchrW( p, '\\' ))) p = p2;
        if ((p2 = strrchrW( p, '/' ))) p = p2;
        if (p != spec)
        {
            WCHAR sep = *p;
            *p = 0;
            if (!SetCurrentDirectoryW( spec ))
            {
                *p = sep;  /* Restore the original spec */
                return FALSE;
            }
            spec = p + 1;
        }
    }
 
    TRACE( "mask=%s\n", spec );
 
    if (idLBox && ((hwnd = GetDlgItem( hDlg, idLBox )) != 0))
    {
        if (attrib == DDL_DRIVES) attrib |= DDL_EXCLUSIVE;
 
        SENDMSG( combo ? CB_RESETCONTENT : LB_RESETCONTENT, 0, 0 );
        if (attrib & DDL_DIRECTORY)
        {
            if (!(attrib & DDL_EXCLUSIVE))
            {
                SENDMSG( combo ? CB_DIR : LB_DIR,
                         attrib & ~(DDL_DIRECTORY | DDL_DRIVES),
                         (LPARAM)spec );
            }
            SENDMSG( combo ? CB_DIR : LB_DIR,
                   (attrib & (DDL_DIRECTORY | DDL_DRIVES)) | DDL_EXCLUSIVE,
                   (LPARAM)any );
        }
        else
        {
            SENDMSG( combo ? CB_DIR : LB_DIR, attrib, (LPARAM)spec );
        }
    }
 
    /* Convert path specification to uppercase */
    if (spec) CharUpperW(spec);
 
    if (idStatic && ((hwnd = GetDlgItem( hDlg, idStatic )) != 0))
    {
        WCHAR temp[MAX_PATH];
        GetCurrentDirectoryW( sizeof(temp)/sizeof(WCHAR), temp );
        CharLowerW( temp );
        /* Can't use PostMessage() here, because the string is on the stack */
        SetDlgItemTextW( hDlg, idStatic, temp );
    }
 
    if (orig_spec && (spec != orig_spec))
    {
        /* Update the original file spec */
        WCHAR *p = spec;
        while ((*orig_spec++ = *p++));
    }
 
    return TRUE;
#undef SENDMSG
}

Referenced by DIALOG_DlgDirListA(), DlgDirListComboBoxW(), and DlgDirListW().

DIALOG_DlgDirSelect()

static BOOL DIALOG_DlgDirSelect ( HWND  hwnd, LPWSTR  str, INT  len, INT  id, BOOL  unicode, BOOL  combo  )

static

Definition at line 1550 of file dialog.c.

{
    WCHAR *buffer, *ptr;
    INT item, size;
    BOOL ret;
    HWND listbox = GetDlgItem( hwnd, id );
 
    TRACE("%p %s %d\n", hwnd, unicode ? debugstr_w(str) : debugstr_a((LPSTR)str), id );
    if (!listbox) return FALSE;
 
    item = SendMessageW(listbox, combo ? CB_GETCURSEL : LB_GETCURSEL, 0, 0 );
    if (item == LB_ERR) return FALSE;
 
    size = SendMessageW(listbox, combo ? CB_GETLBTEXTLEN : LB_GETTEXTLEN, item, 0 );
    if (size == LB_ERR) return FALSE;
 
    if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size+2) * sizeof(WCHAR) ))) return FALSE;
 
    SendMessageW( listbox, combo ? CB_GETLBTEXT : LB_GETTEXT, item, (LPARAM)buffer );
 
    if ((ret = (buffer[0] == '[')))  /* drive or directory */
    {
        if (buffer[1] == '-')  /* drive */
        {
            buffer[3] = ':';
            buffer[4] = 0;
            ptr = buffer + 2;
        }
        else
        {
            buffer[strlenW(buffer)-1] = '\\';
            ptr = buffer + 1;
        }
    }
    else
    {
        /* Filenames without a dot extension must have one tacked at the end */
        if (strchrW(buffer, '.') == NULL)
        {
            buffer[strlenW(buffer)+1] = '\0';
            buffer[strlenW(buffer)] = '.';
        }
        ptr = buffer;
    }
 
    if (!unicode)
    {
        if (len > 0 && !WideCharToMultiByte( CP_ACP, 0, ptr, -1, (LPSTR)str, len, 0, 0 ))
            ((LPSTR)str)[len-1] = 0;
    }
    else lstrcpynW( str, ptr, len );
    HeapFree( GetProcessHeap(), 0, buffer );
    TRACE("Returning %d %s\n", ret, unicode ? debugstr_w(str) : debugstr_a((LPSTR)str) );
    return ret;
}

Referenced by DlgDirSelectComboBoxExA(), DlgDirSelectComboBoxExW(), DlgDirSelectExA(), and DlgDirSelectExW().

DIALOG_DoDialogBox()

INT DIALOG_DoDialogBox	(	HWND	hwnd,
		HWND	owner
	)

Definition at line 495 of file dialog.c.

{
    DIALOGINFO * dlgInfo;
    MSG msg;
    INT retval;
    BOOL bFirstEmpty;
    PWND pWnd;
 
    pWnd = ValidateHwnd(hwnd);
    if (!pWnd) return -1;
 
    if (!(dlgInfo = GETDLGINFO(hwnd))) return -1;
 
    bFirstEmpty = TRUE;
    if (!(dlgInfo->flags & DF_END)) /* was EndDialog called in WM_INITDIALOG ? */
    {
        for (;;)
        {
            if (!PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ))
            {
                if (bFirstEmpty)
                {
                    /* ShowWindow the first time the queue goes empty */
                    ShowWindow( hwnd, SW_SHOWNORMAL );
                    bFirstEmpty = FALSE;
                }
                if (!(GetWindowLongPtrW( hwnd, GWL_STYLE ) & DS_NOIDLEMSG))
               {
                    /* No message present -> send ENTERIDLE and wait */
                    SendMessageW( owner, WM_ENTERIDLE, MSGF_DIALOGBOX, (LPARAM)hwnd );
                }
                GetMessageW( &msg, 0, 0, 0 );
            }
 
            if (msg.message == WM_QUIT)
            {
                PostQuitMessage( msg.wParam );
                if (!IsWindow( hwnd )) return 0;
                break;
            }
 
            /*
             * If the user is pressing Ctrl+C, send a WM_COPY message.
             * Guido Pola, CORE-4829, Is there another way to check if the Dialog is a MessageBox?
             */
            if (msg.message == WM_KEYDOWN &&
                pWnd->state & WNDS_MSGBOX && // Yes!
                GetForegroundWindow() == hwnd)
            {
                if (msg.wParam == L'C' && GetKeyState(VK_CONTROL) < 0)
                    SendMessageW(hwnd, WM_COPY, 0, 0);
            }
 
            if (!IsWindow( hwnd )) return 0;
            if (!(dlgInfo->flags & DF_END) && !IsDialogMessageW( hwnd, &msg))
            {
                TranslateMessage( &msg );
                DispatchMessageW( &msg );
            }
            if (!IsWindow( hwnd )) return 0;
            if (dlgInfo->flags & DF_END) break;
 
            if (bFirstEmpty && msg.message == WM_TIMER)
            {
                ShowWindow( hwnd, SW_SHOWNORMAL );
                bFirstEmpty = FALSE;
            }
        }
    }
    retval = dlgInfo->idResult;
    DestroyWindow( hwnd );
    return retval;
}

Referenced by DialogBoxIndirectParamAorW(), DialogBoxParamA(), and DialogBoxParamW().

DIALOG_FindMsgDestination()

static HWND DIALOG_FindMsgDestination ( HWND  hwndDlg )

static

Definition at line 467 of file dialog.c.

{
    while (GetWindowLongA(hwndDlg, GWL_STYLE) & DS_CONTROL)
    {
        PWND pWnd;
        HWND hParent = GetParent(hwndDlg);
        if (!hParent) break;
// ReactOS
        if (!IsWindow(hParent)) break;
 
        pWnd = ValidateHwnd(hParent);
        // FIXME: Use pWnd->fnid == FNID_DESKTOP
        if (!pWnd || !TestWindowProcess(pWnd) || hParent == GetDesktopWindow()) break;
 
        if (!(pWnd->state & WNDS_DIALOGWINDOW))
        {
            break;
        }
 
        hwndDlg = hParent;
    }
 
    return hwndDlg;
}

Referenced by DEFDLG_Proc(), and IsDialogMessageW().

DIALOG_FixChildrenOnChangeFocus()

static void DIALOG_FixChildrenOnChangeFocus ( HWND  hwndDlg, HWND  hwndNext  )

static

Definition at line 2452 of file dialog.c.

{
    INT dlgcode_next = SendMessageW (hwndNext, WM_GETDLGCODE, 0, 0);
    /* INT dlgcode_dlg  = SendMessageW (hwndDlg, WM_GETDLGCODE, 0, 0); */
    /* Windows does ask for this.  I don't know why yet */
 
    EnumChildWindows (hwndDlg, DIALOG_FixOneChildOnChangeFocus, 0);
 
    /* If the button that is getting the focus WAS flagged as the default
     * pushbutton then ask the dialog what it thinks the default is and
     * set that in the default style.
     */
    if (dlgcode_next & DLGC_DEFPUSHBUTTON)
    {
        DWORD def_id = SendMessageW (hwndDlg, DM_GETDEFID, 0, 0);
        if (HIWORD(def_id) == DC_HASDEFID)
        {
            HWND hwndDef;
            def_id = LOWORD(def_id);
            hwndDef = GetDlgItem (hwndDlg, def_id);
            if (hwndDef)
            {
                INT dlgcode_def = SendMessageW (hwndDef, WM_GETDLGCODE, 0, 0);
                /* I know that if it is a button then it should already be a
                 * UNDEFPUSHBUTTON, since we have just told the buttons to
                 * change style.  But maybe they ignored our request
                 */
                if ((dlgcode_def & DLGC_BUTTON) &&
                        (dlgcode_def &  DLGC_UNDEFPUSHBUTTON))
                {
                    SendMessageW (hwndDef, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
                }
            }
        }
    }
    else if ((dlgcode_next & DLGC_BUTTON) && (dlgcode_next & DLGC_UNDEFPUSHBUTTON))
    {
        SendMessageW (hwndNext, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
        /* I wonder why it doesn't send a DM_SETDEFID */
    }
}

Referenced by IsDialogMessageW().

DIALOG_FixOneChildOnChangeFocus()

static BOOL CALLBACK DIALOG_FixOneChildOnChangeFocus ( HWND  hwndChild, LPARAM  lParam  )

static

Definition at line 2436 of file dialog.c.

{
    /* If a default pushbutton then no longer default */
    if (DLGC_DEFPUSHBUTTON & SendMessageW (hwndChild, WM_GETDLGCODE, 0, 0))
        SendMessageW (hwndChild, BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
    return TRUE;
}

Referenced by DIALOG_FixChildrenOnChangeFocus().

DIALOG_get_info()

DIALOGINFO * DIALOG_get_info	(	HWND	hWnd,
		BOOL	create
	)

Definition at line 131 of file dialog.c.

{
    PWND pWindow;
    DIALOGINFO* dlgInfo;
 
    pWindow = ValidateHwnd( hWnd );
    if (!pWindow)
    {
       return NULL;
    }
 
    dlgInfo = pWindow->DialogPointer;
 
    if (!dlgInfo && create)
    {
        if (pWindow && pWindow->cbwndExtra >= DLGWINDOWEXTRA)
        {
            if (!(dlgInfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dlgInfo) )))
                return NULL;
 
            dlgInfo->idResult = IDOK;
            NtUserxSetDialogPointer( hWnd, dlgInfo );
       }
       else
       {
           return NULL;
       }
    }
 
    return dlgInfo;
}

Referenced by DEFDLG_Proc(), DefDlgProcA(), DefDlgProcW(), and DIALOG_CreateIndirect().

DIALOG_GetControl32()

static const WORD * DIALOG_GetControl32 ( const WORD *  p, DLG_CONTROL_INFO *  info, BOOL  dialogEx  )

static

Definition at line 169 of file dialog.c.

{
    if (dialogEx)
    {
        info->helpId  = GET_DWORD(p); p += 2;
        info->exStyle = GET_DWORD(p); p += 2;
        info->style   = GET_DWORD(p); p += 2;
    }
    else
    {
        info->helpId  = 0;
        info->style   = GET_DWORD(p); p += 2;
        info->exStyle = GET_DWORD(p); p += 2;
    }
    info->x       = GET_WORD(p); p++;
    info->y       = GET_WORD(p); p++;
    info->cx      = GET_WORD(p); p++;
    info->cy      = GET_WORD(p); p++;
 
    if (dialogEx)
    {
        /* id is 4 bytes for DIALOGEX */
        info->id = GET_LONG(p);
        p += 2;
    }
    else
    {
        info->id = GET_WORD(p);
        p++;
    }
 
    if (GET_WORD(p) == 0xffff)
    {
        static const WCHAR class_names[6][10] =
        {
            { 'B','u','t','t','o','n', },             /* 0x80 */
            { 'E','d','i','t', },                     /* 0x81 */
            { 'S','t','a','t','i','c', },             /* 0x82 */
            { 'L','i','s','t','B','o','x', },         /* 0x83 */
            { 'S','c','r','o','l','l','B','a','r', }, /* 0x84 */
            { 'C','o','m','b','o','B','o','x', }      /* 0x85 */
        };
        WORD id = GET_WORD(p+1);
        /* Windows treats dialog control class ids 0-5 same way as 0x80-0x85 */
        if ((id >= 0x80) && (id <= 0x85)) id -= 0x80;
        if (id <= 5)
        {
            info->className = class_names[id];
        }
        else
        {
            info->className = NULL;
            /* FIXME: load other classes here? */
            ERR("Unknown built-in class id %04x\n", id );
        }
        p += 2;
    }
    else
    {
        info->className = (LPCWSTR)p;
        p += strlenW( info->className ) + 1;
    }
 
    if (GET_WORD(p) == 0xffff)  /* Is it an integer id? */
    {
        info->windowName = HeapAlloc( GetProcessHeap(), 0, sizeof(L"#65535") );
        if (info->windowName != NULL)
        {
            wsprintf((LPWSTR)info->windowName, L"#%u", GET_WORD(p + 1));
            info->windowNameFree = TRUE;
        }
        else
        {
            info->windowNameFree = FALSE;
        }
        p += 2;
    }
    else
    {
        info->windowName = (LPCWSTR)p;
        info->windowNameFree = FALSE;
        p += strlenW( info->windowName ) + 1;
    }
 
    TRACE("    %s %s %ld, %d, %d, %d, %d, %08x, %08x, %08x\n",
          debugstr_w( info->className ), debugstr_w( info->windowName ),
          info->id, info->x, info->y, info->cx, info->cy,
          info->style, info->exStyle, info->helpId );
 
    if (GET_WORD(p))
    {
        info->data = p;
        p += GET_WORD(p) / sizeof(WORD);
    }
    else info->data = NULL;
    p++;
 
    /* Next control is on dword boundary */
    return (const WORD *)(((UINT_PTR)p + 3) & ~3);
}

Referenced by DIALOG_CreateControls32().

DIALOG_GetNextTabItem()

static HWND DIALOG_GetNextTabItem ( HWND  hwndMain, HWND  hwndDlg, HWND  hwndCtrl, BOOL  fPrevious  )

static

Definition at line 1367 of file dialog.c.

{
    LONG dsStyle;
    LONG exStyle;
    UINT wndSearch = fPrevious ? GW_HWNDPREV : GW_HWNDNEXT;
    HWND retWnd = 0;
    HWND hChildFirst = 0;
 
    if(!hwndCtrl)
    {
        hChildFirst = GetWindow(hwndDlg,GW_CHILD);
        if(fPrevious) hChildFirst = GetWindow(hChildFirst,GW_HWNDLAST);
    }
    else if (IsChild( hwndMain, hwndCtrl ))
    {
        hChildFirst = GetWindow(hwndCtrl,wndSearch);
        if(!hChildFirst)
        {
            if(GetParent(hwndCtrl) != hwndMain)
                /* i.e. if we are not at the top level of the recursion */
                hChildFirst = GetWindow(GetParent(hwndCtrl),wndSearch);
            else
                hChildFirst = GetWindow(hwndCtrl, fPrevious ? GW_HWNDLAST : GW_HWNDFIRST);
        }
    }
 
    while(hChildFirst)
    {
        dsStyle = GetWindowLongPtrA(hChildFirst,GWL_STYLE);
        exStyle = GetWindowLongPtrA(hChildFirst,GWL_EXSTYLE);
        if( (exStyle & WS_EX_CONTROLPARENT) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
        {
            HWND retWnd;
            retWnd = DIALOG_GetNextTabItem(hwndMain,hChildFirst,NULL,fPrevious );
            if (retWnd) return (retWnd);
        }
        else if( (dsStyle & WS_TABSTOP) && (dsStyle & WS_VISIBLE) && !(dsStyle & WS_DISABLED))
        {
            return (hChildFirst);
        }
        hChildFirst = GetWindow(hChildFirst,wndSearch);
    }
    if(hwndCtrl)
    {
        HWND hParent = GetParent(hwndCtrl);
        while(hParent)
        {
            if(hParent == hwndMain) break;
            retWnd = DIALOG_GetNextTabItem(hwndMain,GetParent(hParent),hParent,fPrevious );
            if(retWnd) break;
            hParent = GetParent(hParent);
        }
        if(!retWnd)
            retWnd = DIALOG_GetNextTabItem(hwndMain,hwndMain,NULL,fPrevious );
    }
    return retWnd ? retWnd : hwndCtrl;
}

Referenced by DIALOG_GetNextTabItem(), and GetNextDlgTabItem().

DIALOG_IdToHwnd()

static HWND DIALOG_IdToHwnd ( HWND  hwndDlg, INT  id  )

static

Definition at line 2502 of file dialog.c.

{
    int i;
    HWND *list = WIN_ListChildren( hwndDlg );
    HWND ret = 0;
 
    if (!list) return 0;
 
    for (i = 0; list[i]; i++)
    {
        if (GetWindowLongPtrW( list[i], GWLP_ID ) == id)
        {
            ret = list[i];
            break;
        }
 
        /* Recurse into every child */
        if ((ret = DIALOG_IdToHwnd( list[i], id ))) break;
    }
 
    HeapFree( GetProcessHeap(), 0, list );
    return ret;
}

Referenced by DIALOG_IdToHwnd(), and IsDialogMessageW().

DIALOG_IsAccelerator()

static BOOL DIALOG_IsAccelerator ( HWND  hwnd, HWND  hwndDlg, WPARAM  wParam  )

static

Definition at line 385 of file dialog.c.

{
    HWND hwndControl = hwnd;
    HWND hwndNext;
    INT dlgCode;
    WCHAR buffer[128];
 
    do
    {
        DWORD style = GetWindowLongPtrW( hwndControl, GWL_STYLE );
        if ((style & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE)
        {
            dlgCode = SendMessageW( hwndControl, WM_GETDLGCODE, 0, 0 );
            if ( (dlgCode & (DLGC_BUTTON | DLGC_STATIC)) &&
                 GetWindowTextW( hwndControl, buffer, sizeof(buffer)/sizeof(WCHAR) ))
            {
                /* find the accelerator key */
                LPWSTR p = buffer - 2;
 
                do
                {
                    p = strchrW( p + 2, '&' );
                }
                while (p != NULL && p[1] == '&');
 
                /* and check if it's the one we're looking for */
                if (p != NULL && toupperW( p[1] ) == toupperW( wParam ) )
                {
                    if ((dlgCode & DLGC_STATIC) || (style & 0x0f) == BS_GROUPBOX )
                    {
                        /* set focus to the control */
                        SendMessageW( hwndDlg, WM_NEXTDLGCTL, (WPARAM)hwndControl, 1);
                        /* and bump it on to next */
                        SendMessageW( hwndDlg, WM_NEXTDLGCTL, 0, 0);
                    }
                    else if (dlgCode & DLGC_BUTTON)
                    {
                        /* send BM_CLICK message to the control */
                        SendMessageW( hwndControl, BM_CLICK, 0, 0 );
                    }
                    return TRUE;
                }
            }
            hwndNext = GetWindow( hwndControl, GW_CHILD );
        }
        else hwndNext = 0;
 
        if (!hwndNext) hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
 
        while (!hwndNext && hwndControl)
        {
            hwndControl = GetParent( hwndControl );
            if (hwndControl == hwndDlg)
            {
                if(hwnd==hwndDlg)   /* prevent endless loop */
                {
                    hwndNext=hwnd;
                    break;
                }
                hwndNext = GetWindow( hwndDlg, GW_CHILD );
            }
            else
                hwndNext = GetWindow( hwndControl, GW_HWNDNEXT );
        }
        hwndControl = hwndNext;
    }
    while (hwndControl && (hwndControl != hwnd));
 
    return FALSE;
}

Referenced by IsDialogMessageW().

DIALOG_ParseTemplate32()

static LPCSTR DIALOG_ParseTemplate32 ( LPCSTR  template, DLG_TEMPLATE *  result  )

static

Definition at line 575 of file dialog.c.

{
    const WORD *p = (const WORD *)template;
    WORD signature;
    WORD dlgver;
 
    dlgver = GET_WORD(p); p++;
    signature = GET_WORD(p); p++;
 
    if (dlgver == 1 && signature == 0xffff)  /* DIALOGEX resource */
    {
        result->dialogEx = TRUE;
        result->helpId   = GET_DWORD(p); p += 2;
        result->exStyle  = GET_DWORD(p); p += 2;
        result->style    = GET_DWORD(p); p += 2;
    }
    else
    {
        result->style = GET_DWORD(p - 2);
        result->dialogEx = FALSE;
        result->helpId   = 0;
        result->exStyle  = GET_DWORD(p); p += 2;
    }
    result->nbItems = GET_WORD(p); p++;
    result->x       = GET_WORD(p); p++;
    result->y       = GET_WORD(p); p++;
    result->cx      = GET_WORD(p); p++;
    result->cy      = GET_WORD(p); p++;
    TRACE("DIALOG%s %d, %d, %d, %d, %d\n",
           result->dialogEx ? "EX" : "", result->x, result->y,
           result->cx, result->cy, result->helpId );
    TRACE(" STYLE 0x%08x\n", result->style );
    TRACE(" EXSTYLE 0x%08x\n", result->exStyle );
 
    /* Get the menu name */
 
    switch(GET_WORD(p))
    {
        case 0x0000:
            result->menuName = NULL;
            p++;
            break;
        case 0xffff:
            result->menuName = (LPCWSTR)(UINT_PTR)GET_WORD( p + 1 );
            p += 2;
            TRACE(" MENU %04x\n", LOWORD(result->menuName) );
            break;
        default:
            result->menuName = (LPCWSTR)p;
            TRACE(" MENU %s\n", debugstr_w(result->menuName) );
            p += strlenW( result->menuName ) + 1;
            break;
    }
 
    /* Get the class name */
 
    switch(GET_WORD(p))
    {
        case 0x0000:
            result->className = WC_DIALOG;
            p++;
            break;
        case 0xffff:
            result->className = (LPCWSTR)(UINT_PTR)GET_WORD( p + 1 );
            p += 2;
            TRACE(" CLASS %04x\n", LOWORD(result->className) );
            break;
        default:
            result->className = (LPCWSTR)p;
            TRACE(" CLASS %s\n", debugstr_w( result->className ));
            p += strlenW( result->className ) + 1;
            break;
    }
 
    /* Get the window caption */
 
    result->caption = (LPCWSTR)p;
    p += strlenW( result->caption ) + 1;
    TRACE(" CAPTION %s\n", debugstr_w( result->caption ) );
 
    /* Get the font name */
 
    result->pointSize = 0;
    result->faceName = NULL;
    result->weight = FW_DONTCARE;
    result->italic = FALSE;
 
    if (result->style & DS_SETFONT)
    {
        result->pointSize = GET_WORD(p);
        p++;
 
        /* If pointSize is 0x7fff, it means that we need to use the font
         * in NONCLIENTMETRICSW.lfMessageFont, and NOT read the weight,
         * italic, and facename from the dialog template.
         */
        if (result->pointSize == 0x7fff)
        {
            /* We could call SystemParametersInfo here, but then we'd have
             * to convert from pixel size to point size (which can be
             * imprecise).
             */
            TRACE(" FONT: Using message box font\n");
        }
        else
        {
            if (result->dialogEx)
            {
                result->weight = GET_WORD(p); p++;
                result->italic = LOBYTE(GET_WORD(p)); p++;
            }
            result->faceName = (LPCWSTR)p;
            p += strlenW( result->faceName ) + 1;
 
            TRACE(" FONT %d, %s, %d, %s\n",
                  result->pointSize, debugstr_w( result->faceName ),
                  result->weight, result->italic ? "TRUE" : "FALSE" );
        }
    }
 
    /* First control is on dword boundary */
    return (LPCSTR)((((UINT_PTR)p) + 3) & ~3);
}

Referenced by DIALOG_CreateIndirect().

DialogBoxIndirectParamA()

INT_PTR WINAPI DialogBoxIndirectParamA	(	HINSTANCE	hInstance,
		LPCDLGTEMPLATE	hDialogTemplate,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	dwInitParam
	)

Definition at line 1861 of file dialog.c.

{
  return DialogBoxIndirectParamAorW( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, DLG_ISANSI);
}

DialogBoxIndirectParamAorW()

INT_PTR WINAPI DialogBoxIndirectParamAorW	(	HINSTANCE	hInstance,
		LPCDLGTEMPLATE	hDialogTemplate,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	dwInitParam,
		DWORD	Flags
	)

Definition at line 1837 of file dialog.c.

{
/* FIXME:
 *  This function might be obsolete since I don't think it is exported by NT
 *  Also wine has one more parameter identifying weather it should call
 *  the function with unicode or not
 */
  HWND hWnd = DIALOG_CreateIndirect( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, Flags == DLG_ISANSI ? FALSE : TRUE, &hWndParent );
  if (hWnd) return DIALOG_DoDialogBox( hWnd, hWndParent );
  return -1;
}

Referenced by DialogBoxIndirectParamA(), and DialogBoxIndirectParamW().

DialogBoxIndirectParamW()

INT_PTR WINAPI DialogBoxIndirectParamW	(	HINSTANCE	hInstance,
		LPCDLGTEMPLATE	hDialogTemplate,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	dwInitParam
	)

Definition at line 1877 of file dialog.c.

{
  return DialogBoxIndirectParamAorW( hInstance, hDialogTemplate, hWndParent, lpDialogFunc, dwInitParam, 0);
}

DialogBoxParamA()

INT_PTR WINAPI DialogBoxParamA	(	HINSTANCE	hInstance,
		LPCSTR	lpTemplateName,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	dwInitParam
	)

Definition at line 1893 of file dialog.c.

{
    HWND hwnd;
    HRSRC hrsrc;
    LPCDLGTEMPLATE ptr;
    if (!(hrsrc = FindResourceA( hInstance, lpTemplateName, (LPCSTR)RT_DIALOG )) ||
        !(ptr = LoadResource(hInstance, hrsrc)))
    {
        SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
        return -1;
    }
    if (hWndParent != NULL && !IsWindow(hWndParent))
    {
        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
        return 0;
    }
    hwnd = DIALOG_CreateIndirect(hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam, FALSE, &hWndParent );
    if (hwnd) return DIALOG_DoDialogBox(hwnd, hWndParent);
    return -1;
}

DialogBoxParamW()

INT_PTR WINAPI DialogBoxParamW	(	HINSTANCE	hInstance,
		LPCWSTR	lpTemplateName,
		HWND	hWndParent,
		DLGPROC	lpDialogFunc,
		LPARAM	dwInitParam
	)

Definition at line 1926 of file dialog.c.

{
    HWND hwnd;
    HRSRC hrsrc;
    LPCDLGTEMPLATE ptr;
    if (!(hrsrc = FindResourceW( hInstance, lpTemplateName, (LPCWSTR)RT_DIALOG )) ||
        !(ptr = LoadResource(hInstance, hrsrc)))
    {
        SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
        return -1;
    }
    if (hWndParent != NULL && !IsWindow(hWndParent))
    {
        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
        return 0;
    }
    hwnd = DIALOG_CreateIndirect(hInstance, ptr, hWndParent, lpDialogFunc, dwInitParam, TRUE, &hWndParent );
    if (hwnd) return DIALOG_DoDialogBox(hwnd, hWndParent);
    return -1;
}

DlgDirListA()

int WINAPI DlgDirListA	(	HWND	hDlg,
		LPSTR	lpPathSpec,
		int	nIDListBox,
		int	nIDStaticPath,
		UINT	uFileType
	)

Definition at line 1959 of file dialog.c.

{
    return DIALOG_DlgDirListA( hDlg, lpPathSpec, nIDListBox, nIDStaticPath, uFileType, FALSE );
}

DlgDirListComboBoxA()

int WINAPI DlgDirListComboBoxA	(	HWND	hDlg,
		LPSTR	lpPathSpec,
		int	nIDComboBox,
		int	nIDStaticPath,
		UINT	uFiletype
	)

Definition at line 1975 of file dialog.c.

{
  return DIALOG_DlgDirListA( hDlg, lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype, TRUE );
}

DlgDirListComboBoxW()

int WINAPI DlgDirListComboBoxW	(	HWND	hDlg,
		LPWSTR	lpPathSpec,
		int	nIDComboBox,
		int	nIDStaticPath,
		UINT	uFiletype
	)

Definition at line 1991 of file dialog.c.

{
  return DIALOG_DlgDirListW( hDlg, lpPathSpec, nIDComboBox, nIDStaticPath, uFiletype, TRUE );
}

DlgDirListW()

int WINAPI DlgDirListW	(	HWND	hDlg,
		LPWSTR	lpPathSpec,
		int	nIDListBox,
		int	nIDStaticPath,
		UINT	uFileType
	)

Definition at line 2007 of file dialog.c.

{
  return DIALOG_DlgDirListW( hDlg, lpPathSpec, nIDListBox, nIDStaticPath, uFileType, FALSE );
}

DlgDirSelectComboBoxExA()

BOOL WINAPI DlgDirSelectComboBoxExA	(	HWND	hDlg,
		LPSTR	lpString,
		int	nCount,
		int	nIDComboBox
	)

Definition at line 2023 of file dialog.c.

{
  return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDComboBox, FALSE, TRUE );
}

DlgDirSelectComboBoxExW()

BOOL WINAPI DlgDirSelectComboBoxExW	(	HWND	hDlg,
		LPWSTR	lpString,
		int	nCount,
		int	nIDComboBox
	)

Definition at line 2038 of file dialog.c.

{
  return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDComboBox, TRUE, TRUE );
}

DlgDirSelectExA()

BOOL WINAPI DlgDirSelectExA	(	HWND	hDlg,
		LPSTR	lpString,
		int	nCount,
		int	nIDListBox
	)

Definition at line 2053 of file dialog.c.

{
  return DIALOG_DlgDirSelect( hDlg, (LPWSTR)lpString, nCount, nIDListBox, FALSE, FALSE );
}

DlgDirSelectExW()

BOOL WINAPI DlgDirSelectExW	(	HWND	hDlg,
		LPWSTR	lpString,
		int	nCount,
		int	nIDListBox
	)

Definition at line 2068 of file dialog.c.

{
  return DIALOG_DlgDirSelect( hDlg, lpString, nCount, nIDListBox, TRUE, FALSE );
}

EndDialog()

BOOL WINAPI EndDialog	(	HWND	hwnd,
		INT_PTR	retval
	)

Definition at line 2083 of file dialog.c.

{
    DIALOGINFO * dlgInfo;
    HWND owner;
    BOOL wasActive;
 
    TRACE("%p %ld\n", hwnd, retval );
 
    if (!(dlgInfo = GETDLGINFO(hwnd)))
    {
        ERR("got invalid window handle (%p); buggy app !?\n", hwnd);
        return FALSE;
    }
    wasActive = (hwnd == GetActiveWindow());
    dlgInfo->idResult = retval;
    dlgInfo->flags |= DF_END;
 
    if ((GetWindowLongW( hwnd, GWL_STYLE ) & (WS_POPUP|WS_CHILD)) == WS_CHILD)
    {
       owner = GetAncestor( hwnd, GA_PARENT);
    }
    else
       owner = GetWindow( hwnd, GW_OWNER );    
 
    if (owner)
        EnableWindow( owner, TRUE );
 
    /* Windows sets the focus to the dialog itself in EndDialog */
 
    if (wasActive && IsChild(hwnd, GetFocus()))
       SetFocus( hwnd );
 
    /* Don't have to send a ShowWindow(SW_HIDE), just do
       SetWindowPos with SWP_HIDEWINDOW as done in Windows */
 
    SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE
                 | SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
 
    if (wasActive && owner)
    {
        /* If this dialog was given an owner then set the focus to that owner. */
        SetActiveWindow(owner);
    }
    else if (hwnd == GetActiveWindow()) // Check it again!
    {
        NtUserCallNoParam(NOPARAM_ROUTINE_ZAPACTIVEANDFOUS);
    }
 
    /* unblock dialog loop */
    PostMessageA(hwnd, WM_NULL, 0, 0);
    return TRUE;
}

GetDialogBaseUnits()

LONG WINAPI GetDialogBaseUnits

(

VOID

)

Definition at line 2144 of file dialog.c.

{
    static DWORD units;
 
    if (!units)
    {
        HDC hdc;
        SIZE size;
 
        if ((hdc = GetDC(0)))
        {
            size.cx = GdiGetCharDimensions( hdc, NULL, &size.cy );
            if (size.cx) units = MAKELONG( size.cx, size.cy );
            ReleaseDC( 0, hdc );
        }
    }
    return units;
}

Referenced by CC_PaintCross(), CC_PaintTriangle(), DIALOG_CreateIndirect(), LoadDialog(), SoftModalMessageBox(), test_dpi_mapping(), and test_menu_ownerdraw().

GetDlgCtrlID()

int WINAPI GetDlgCtrlID

(

HWND

hwndCtl

)

Definition at line 2169 of file dialog.c.

{
    return GetWindowLongPtrW( hwndCtl, GWLP_ID );
}

Referenced by DEFDLG_Proc(), and IsDialogMessageW().

GetDlgItem()

HWND WINAPI GetDlgItem	(	HWND	hDlg,
		int	nIDDlgItem
	)

Definition at line 2181 of file dialog.c.

{
    int i;
    HWND *list;
    HWND ret = 0;
 
    if (!hDlg) return 0; 
 
    list = WIN_ListChildren(hDlg);
    if (!list) return 0;
 
    for (i = 0; list[i]; i++) if (GetWindowLongPtrW(list[i], GWLP_ID) == nIDDlgItem) break;
    ret = list[i];
    HeapFree(GetProcessHeap(), 0, list);
//    if (!ret) SetLastError(ERROR_CONTROL_ID_NOT_FOUND);
    return ret;
}

GetDlgItemInt()

UINT WINAPI GetDlgItemInt	(	HWND	hDlg,
		int	nIDDlgItem,
		BOOL *	lpTranslated,
		BOOL	bSigned
	)

Definition at line 2207 of file dialog.c.

{
    char str[30];
    char * endptr;
    LONG_PTR result = 0;
 
    if (lpTranslated) *lpTranslated = FALSE;
    if (!SendDlgItemMessageA(hDlg, nIDDlgItem, WM_GETTEXT, sizeof(str), (LPARAM)str))
        return 0;
    if (bSigned)
    {
        result = strtol( str, &endptr, 10 );
        if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
            return 0;
        if (((result == LONG_MIN) || (result == LONG_MAX)))
            return 0;
    }
    else
    {
        result = strtoul( str, &endptr, 10 );
        if (!endptr || (endptr == str))  /* Conversion was unsuccessful */
            return 0;
        if (result == ULONG_MAX) return 0;
    }
    if (lpTranslated) *lpTranslated = TRUE;
    return (UINT)result;
}

GetDlgItemTextA()

UINT WINAPI GetDlgItemTextA	(	HWND	hDlg,
		int	nIDDlgItem,
		LPSTR	lpString,
		int	nMaxCount
	)

Definition at line 2245 of file dialog.c.

{
  HWND hWnd = GetDlgItem(hDlg, nIDDlgItem);
  if ( hWnd ) return GetWindowTextA(hWnd, lpString, nMaxCount);
  if ( nMaxCount ) lpString[0] = '\0';
  return 0;
}

Referenced by AskTagProc(), COMDLG32_FR_HandleWMCommand(), getdlgitem_test_dialog_proc(), CZipPassword::OnButton(), PRINTDLG_WMCommandA(), PRINTDLG_WMInitDialog(), and test_GetDlgItemText().

GetDlgItemTextW()

UINT WINAPI GetDlgItemTextW	(	HWND	hDlg,
		int	nIDDlgItem,
		LPWSTR	lpString,
		int	nMaxCount
	)

Definition at line 2263 of file dialog.c.

{
  HWND hWnd = GetDlgItem(hDlg, nIDDlgItem);
  if ( hWnd ) return GetWindowTextW(hWnd, lpString, nMaxCount);
  if ( nMaxCount ) lpString[0] = '\0';
  return 0;
}

Referenced by AddDlg_OnCommand(), BrFolder_OnOK(), CFn_WMCommand(), ComputerPageDlgProc(), CongratsDlgProc(), connections_on_notify(), CopyEventEntry(), CredDialogCommandOk(), BtrfsDeviceResize::DeviceResizeDlgProc(), DIALOG_EXECUTE_DlgProc(), DIALOG_GROUP_DlgProc(), DIALOG_PROGRAM_DlgProc(), DIALOG_SYMBOL_DlgProc(), dlgproc_addport(), dlgproc_lptconfig(), DNSSuffixPropDlgProc(), DoChangePassword(), EditActionDlg_OnOK(), EditDlg_OnCommand(), EditTypeDlg_OnOK(), FD31_StripEditControl(), FD31_Validate(), file_dlg_proc(), FinishDlgProc(), general_on_notify(), CDrvDefExt::GeneralPageProc(), CFileDefExt::GeneralPageProc(), get_dialog_font_point_size(), GetTextFromEdit(), GinaLoadFailedWindowProc(), COpenWithDialog::Init(), BtrfsPropSheet::init_propsheet(), CDrvDefExt::InitGeneralPage(), IsValidDomainName(), LoadHive_KeyNameInHookProc(), MainWindowProc(), margin_edit_notification(), MessageBoxTextToClipboard(), NetIDPage_OnApply(), NetworkDomainPageDlgProc(), NewActionDlg_OnOK(), NewExtDlg_OnOK(), CShellLink::OnNotify(), OwnerPageDlgProc(), PickIconProc(), PRINTDLG_WMCommandW(), PRINTDLG_WMInitDialogW(), PropSheetDlgProc(), BtrfsSend::SendDlgProc(), BtrfsPropSheet::set_size_on_disk(), BtrfsSend::StartSend(), BtrfsVolPropSheet::StatsDlgProc(), SummaryDlgProc(), BtrfsSend::Thread(), BtrfsPropSheet::update_size_details_dialog(), WelcomeDlgProc(), and WindowProc().

GetNextDlgGroupItem()

HWND WINAPI GetNextDlgGroupItem	(	HWND	hDlg,
		HWND	hCtl,
		BOOL	bPrevious
	)

Definition at line 2280 of file dialog.c.

{
    HWND hwnd, hwndNext, retvalue, hwndLastGroup = 0;
    BOOL fLooped=FALSE;
    BOOL fSkipping=FALSE;
 
    if (hDlg == hCtl) hCtl = NULL;
    if (!hCtl && bPrevious) return 0;
 
        /* if the hwndCtrl is the child of the control in the hwndDlg,
         * then the hwndDlg has to be the parent of the hwndCtrl */
 
    if (hCtl)
    {
        if (!IsChild (hDlg, hCtl)) return 0;
        /* Make sure hwndCtrl is a top-level child */
    }
    else
    {
        /* No ctrl specified -> start from the beginning */
        if (!(hCtl = GetWindow( hDlg, GW_CHILD ))) return 0;
        /* MSDN is wrong. bPrevious does not result in the last child */
 
        /* Maybe that first one is valid.  If so then we don't want to skip it*/
        if ((GetWindowLongPtrW( hCtl, GWL_STYLE ) & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE)
        {
            return hCtl;
        }
    }
 
    /* Always go forward around the group and list of controls; for the
     * previous control keep track; for the next break when you find one
     */
    retvalue = hCtl;
    hwnd = hCtl;
    while (1)
    {
        hwndNext = GetWindow (hwnd, GW_HWNDNEXT);
        while (!hwndNext)
        {
            /* Climb out until there is a next sibling of the ancestor or we
             * reach the top (in which case we loop back to the start)
             */
            if (hDlg == GetParent (hwnd))
            {
                /* Wrap around to the beginning of the list, within the same
                 * group. (Once only)
                 */
                if (fLooped) goto end;
                fLooped = TRUE;
                hwndNext = GetWindow (hDlg, GW_CHILD);
            }
            else
            {
                hwnd = GetParent (hwnd);
                hwndNext = GetWindow (hwnd, GW_HWNDNEXT);
            }
        }
        hwnd = hwndNext;
 
        /* Wander down the leading edge of controlparents */
        while ( (GetWindowLongPtrW (hwnd, GWL_EXSTYLE) & WS_EX_CONTROLPARENT) &&
                ((GetWindowLongPtrW (hwnd, GWL_STYLE) & (WS_VISIBLE | WS_DISABLED)) == WS_VISIBLE) &&
                (hwndNext = GetWindow (hwnd, GW_CHILD)))
            hwnd = hwndNext;
        /* Question.  If the control is a control parent but either has no
         * children or is not visible/enabled then if it has a WS_GROUP does
         * it count?  For that matter does it count anyway?
         * I believe it doesn't count.
         */
 
        if ((GetWindowLongPtrW (hwnd, GWL_STYLE) & WS_GROUP))
        {
            hwndLastGroup = hwnd;
            if (!fSkipping)
            {
                /* Look for the beginning of the group */
                fSkipping = TRUE;
            }
        }
 
        if (hwnd == hCtl)
        {
            if (!fSkipping) break;
            if (hwndLastGroup == hwnd) break;
            hwnd = hwndLastGroup;
            fSkipping = FALSE;
            fLooped = FALSE;
        }
 
        if (!fSkipping &&
            (GetWindowLongPtrW (hwnd, GWL_STYLE) & (WS_VISIBLE|WS_DISABLED)) ==
             WS_VISIBLE)
        {
            retvalue = hwnd;
            if (!bPrevious) break;
        }
    }
end:
    return retvalue;
}

GetNextDlgTabItem()

HWND WINAPI GetNextDlgTabItem	(	HWND	hDlg,
		HWND	hCtl,
		BOOL	bPrevious
	)

Definition at line 2391 of file dialog.c.

{
    PWND pWindow;
      
    pWindow = ValidateHwnd( hDlg );
    if (!pWindow) return NULL;
    if (hCtl)
    {
       pWindow = ValidateHwnd( hCtl );
       if (!pWindow) return NULL;
    }
 
    /* Undocumented but tested under Win2000 and WinME */
    if (hDlg == hCtl) hCtl = NULL;
 
    /* Contrary to MSDN documentation, tested under Win2000 and WinME
     * NB GetLastError returns whatever was set before the function was
     * called.
     */
    if (!hCtl && bPrevious) return 0;
 
    return DIALOG_GetNextTabItem(hDlg, hDlg, hCtl, bPrevious);
}

IsDialogMessageW()

BOOL WINAPI IsDialogMessageW	(	HWND	hDlg,
		LPMSG	lpMsg
	)

Definition at line 2532 of file dialog.c.

{
    INT dlgCode = 0;
 
    if (!IsWindow( hDlg ))
        return FALSE;
 
    if (CallMsgFilterW( lpMsg, MSGF_DIALOGBOX )) return TRUE;
 
    if (hDlg == GetDesktopWindow()) return FALSE;
    if ((hDlg != lpMsg->hwnd) && !IsChild( hDlg, lpMsg->hwnd )) return FALSE;
 
     hDlg = DIALOG_FindMsgDestination(hDlg);
 
     switch(lpMsg->message)
     {
     case WM_KEYDOWN:
        dlgCode = SendMessageW( lpMsg->hwnd, WM_GETDLGCODE, lpMsg->wParam, (LPARAM)lpMsg );
         if (dlgCode & DLGC_WANTMESSAGE) break;
 
         switch(lpMsg->wParam)
         {
         case VK_TAB:
            if (!(dlgCode & DLGC_WANTTAB))
            {
                BOOL fIsDialog = TRUE;
                WND *pWnd = ValidateHwnd(hDlg);
 
                if (pWnd && TestWindowProcess(pWnd))
                {
                    fIsDialog = (GETDLGINFO(hDlg) != NULL);
                }
  
                SendMessageW(hDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEFOCUS), 0);
 
                /* I am not sure under which circumstances the TAB is handled
                 * each way.  All I do know is that it does not always simply
                 * send WM_NEXTDLGCTL.  (Personally I have never yet seen it
                 * do so but I presume someone has)
                 */
                if (fIsDialog)
                    SendMessageW( hDlg, WM_NEXTDLGCTL, (GetKeyState(VK_SHIFT) & 0x8000), 0 );
                else
                {
                    /* It would appear that GetNextDlgTabItem can handle being
                     * passed hwndDlg rather than NULL but that is undocumented
                     * so let's do it properly
                     */
                    HWND hwndFocus = GetFocus();
                    HWND hwndNext = GetNextDlgTabItem (hDlg,
                            hwndFocus == hDlg ? NULL : hwndFocus,
                            GetKeyState (VK_SHIFT) & 0x8000);
                    if (hwndNext)
                    {
                        dlgCode = SendMessageW (hwndNext, WM_GETDLGCODE,
                                lpMsg->wParam, (LPARAM)lpMsg);
                        if (dlgCode & DLGC_HASSETSEL)
                        {
                            INT maxlen = 1 + SendMessageW (hwndNext, WM_GETTEXTLENGTH, 0, 0);
                            WCHAR *buffer = HeapAlloc (GetProcessHeap(), 0, maxlen * sizeof(WCHAR));
                            if (buffer)
                            {
                                SIZE_T length;
                                SendMessageW (hwndNext, WM_GETTEXT, maxlen, (LPARAM) buffer);
                                length = strlenW (buffer);
                                HeapFree (GetProcessHeap(), 0, buffer);
                                SendMessageW (hwndNext, EM_SETSEL, 0, length);
                            }
                        }
                        SetFocus (hwndNext);
                        DIALOG_FixChildrenOnChangeFocus (hDlg, hwndNext);
                    }
                    else
                        return FALSE;
                }
                return TRUE;
            }
            break;
 
         case VK_RIGHT:
         case VK_DOWN:
         case VK_LEFT:
         case VK_UP:
             if (!(dlgCode & DLGC_WANTARROWS))
             {
                 BOOL fPrevious = (lpMsg->wParam == VK_LEFT || lpMsg->wParam == VK_UP);
 
                 /* Skip STATIC elements when arrow-moving through a list of controls */
                 HWND hwndNext, hwndFirst = lpMsg->hwnd;
                 for (hwndNext = GetNextDlgGroupItem(hDlg, hwndFirst, fPrevious);
                      hwndNext && hwndFirst != hwndNext;
                      hwndNext = GetNextDlgGroupItem(hDlg, hwndNext, fPrevious))
                  {
                      if (!(SendMessageW(hwndNext, WM_GETDLGCODE, 0, 0) & DLGC_STATIC))
                          break;
                  }
 
                 if (hwndNext &&
                     ((SendMessageW(hwndNext, WM_GETDLGCODE, lpMsg->wParam, (LPARAM)lpMsg) &
                       (DLGC_BUTTON | DLGC_RADIOBUTTON)) == (DLGC_BUTTON | DLGC_RADIOBUTTON)))
                 {
                     SetFocus( hwndNext );
                     if ((GetWindowLongW( hwndNext, GWL_STYLE ) & BS_TYPEMASK) == BS_AUTORADIOBUTTON &&
                         SendMessageW( hwndNext, BM_GETCHECK, 0, 0 ) != BST_CHECKED)
                         SendMessageW(hwndNext, BM_CLICK, 0, 0);
                 }
                 else
                     SendMessageW( hDlg, WM_NEXTDLGCTL, (WPARAM)hwndNext, 1 );
                 return TRUE;
             }
             break;
 
         case VK_CANCEL:
         case VK_ESCAPE:
             SendMessageW( hDlg, WM_COMMAND, IDCANCEL, (LPARAM)GetDlgItem( hDlg, IDCANCEL ) );
             return TRUE;
 
         case VK_EXECUTE:
         case VK_RETURN:
              {
                 DWORD dw;
                 HWND hwndFocus = GetFocus();
                 if (IsChild( hDlg, hwndFocus ) &&
                     (SendMessageW (hwndFocus, WM_GETDLGCODE, 0, 0) & DLGC_DEFPUSHBUTTON))
                 {
                     SendMessageW( hDlg, WM_COMMAND, MAKEWPARAM( GetDlgCtrlID( hwndFocus ), BN_CLICKED ), (LPARAM)hwndFocus );
                 }
                 else if (DC_HASDEFID == HIWORD(dw = SendMessageW (hDlg, DM_GETDEFID, 0, 0)))
                 {
                    HWND hwndDef = DIALOG_IdToHwnd(hDlg, LOWORD(dw));
                    if (!hwndDef || IsWindowEnabled(hwndDef))
                        SendMessageW( hDlg, WM_COMMAND, MAKEWPARAM( LOWORD(dw), BN_CLICKED ), (LPARAM)hwndDef);
                 }
                 else
                 {
                     SendMessageW( hDlg, WM_COMMAND, IDOK, (LPARAM)GetDlgItem( hDlg, IDOK ) );
                 }
             }
             return TRUE;
         }
         break;
 
     case WM_CHAR:
         /* FIXME Under what circumstances does WM_GETDLGCODE get sent?
          * It does NOT get sent in the test program I have
          */
         dlgCode = SendMessageW( lpMsg->hwnd, WM_GETDLGCODE, lpMsg->wParam, (LPARAM)lpMsg );
         if (dlgCode & (DLGC_WANTCHARS|DLGC_WANTMESSAGE)) break;
         if (lpMsg->wParam == '\t' && (dlgCode & DLGC_WANTTAB)) break;
         /* drop through */
 
     case WM_SYSCHAR:
         if (DIALOG_IsAccelerator( lpMsg->hwnd, hDlg, lpMsg->wParam ))
         {
             /* don't translate or dispatch */
             return TRUE;
         }
         break;
     case WM_SYSKEYDOWN:
         /* If the ALT key is being pressed display the keyboard cues */
         if ( HIWORD(lpMsg->lParam) & KF_ALTDOWN &&
             !(gpsi->dwSRVIFlags & SRVINFO_KBDPREF) && !(gpsi->PUSIFlags & PUSIF_KEYBOARDCUES) )
             SendMessageW(hDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEACCEL | UISF_HIDEFOCUS), 0);
         break;
 
     case WM_SYSCOMMAND:
         /* If the ALT key is being pressed display the keyboard cues */
         if ( lpMsg->wParam == SC_KEYMENU &&
             !(gpsi->dwSRVIFlags & SRVINFO_KBDPREF) && !(gpsi->PUSIFlags & PUSIF_KEYBOARDCUES) )
         {
            SendMessageW(hDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEACCEL | UISF_HIDEFOCUS), 0);
         }
         break;
     }
 
     TranslateMessage( lpMsg );
     DispatchMessageW( lpMsg );
     return TRUE;
}

IsDlgButtonChecked()

UINT WINAPI IsDlgButtonChecked	(	HWND	hDlg,
		int	nIDButton
	)

Definition at line 2721 of file dialog.c.

{
  return (UINT)SendDlgItemMessageW( hDlg, nIDButton, BM_GETCHECK, 0, 0 );
}

MapDialogRect()

BOOL WINAPI MapDialogRect	(	HWND	hDlg,
		LPRECT	lpRect
	)

Definition at line 2734 of file dialog.c.

{
    DIALOGINFO * dlgInfo;
    if (!(dlgInfo = GETDLGINFO(hDlg))) return FALSE;
    lpRect->left   = MulDiv(lpRect->left, dlgInfo->xBaseUnit, 4);
    lpRect->right  = MulDiv(lpRect->right, dlgInfo->xBaseUnit, 4);
    lpRect->top    = MulDiv(lpRect->top, dlgInfo->yBaseUnit, 8);
    lpRect->bottom = MulDiv(lpRect->bottom, dlgInfo->yBaseUnit, 8);
    return TRUE;
}

SendDlgItemMessageA()

LRESULT WINAPI SendDlgItemMessageA	(	HWND	hDlg,
		int	nIDDlgItem,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2753 of file dialog.c.

{
    HWND hwndCtrl;
    if ( hDlg == HWND_TOPMOST || hDlg == HWND_BROADCAST ) return 0; // ReactOS
    hwndCtrl = GetDlgItem( hDlg, nIDDlgItem );
    if (hwndCtrl) return SendMessageA( hwndCtrl, Msg, wParam, lParam );
    else return 0;
}

SendDlgItemMessageW()

LRESULT WINAPI SendDlgItemMessageW	(	HWND	hDlg,
		int	nIDDlgItem,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2773 of file dialog.c.

{
    HWND hwndCtrl;
    if ( hDlg == HWND_TOPMOST || hDlg == HWND_BROADCAST ) return 0; // ReactOS
    hwndCtrl = GetDlgItem( hDlg, nIDDlgItem );
    if (hwndCtrl) return SendMessageW( hwndCtrl, Msg, wParam, lParam );
    else return 0;
}

SetDlgItemInt()

BOOL WINAPI SetDlgItemInt	(	HWND	hDlg,
		int	nIDDlgItem,
		UINT	uValue,
		BOOL	bSigned
	)

Definition at line 2793 of file dialog.c.

{
    char str[20];
 
    if (bSigned) sprintf( str, "%d", (INT)uValue );
    else sprintf( str, "%u", uValue );
    SendDlgItemMessageA( hDlg, nIDDlgItem, WM_SETTEXT, 0, (LPARAM)str );
    return TRUE;
}

SetDlgItemTextA()

BOOL WINAPI SetDlgItemTextA	(	HWND	hDlg,
		int	nIDDlgItem,
		LPCSTR	lpString
	)

Definition at line 2813 of file dialog.c.

{
  HWND hwndCtrl = GetDlgItem( hDlg, nIDDlgItem ); // ReactOS Themes
  if (hwndCtrl) return SetWindowTextA( hwndCtrl, lpString );
  return FALSE;
}

SetDlgItemTextW()

BOOL WINAPI SetDlgItemTextW	(	HWND	hDlg,
		int	nIDDlgItem,
		LPCWSTR	lpString
	)

Definition at line 2829 of file dialog.c.

{
  HWND hwndCtrl = GetDlgItem( hDlg, nIDDlgItem ); // ReactOS Themes
  if (hwndCtrl) return SetWindowTextW( hwndCtrl, lpString );
  return FALSE;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

user32

)

Variable Documentation

DIALOG_builtin_class

const struct builtin_class_descr DIALOG_builtin_class

Initial value:

=
{
    WC_DIALOG,       
    CS_SAVEBITS | CS_DBLCLKS, 
    DefDlgProcA,              
    DefDlgProcW,              
    DLGWINDOWEXTRA,           
    (LPCWSTR) IDC_ARROW,      
    0                         
}

Definition at line 109 of file dialog.c.