messagebox.c File Reference

#include <user32.h>
#include <ndk/exfuncs.h>
#include <ntstrsafe.h>

Include dependency graph for messagebox.c:

Go to the source code of this file.

Classes
struct	_MSGBTNINFO

Macros
#define	MSGBOX_IDICON   (1088)
#define	MSGBOX_IDTEXT   (0xffff)
#define	IDI_HANDW   MAKEINTRESOURCEW(32513)
#define	IDI_QUESTIONW   MAKEINTRESOURCEW(32514)
#define	IDI_EXCLAMATIONW   MAKEINTRESOURCEW(32515)
#define	IDI_ASTERISKW   MAKEINTRESOURCEW(32516)
#define	IDI_WINLOGOW   MAKEINTRESOURCEW(32517)
#define	BTN_CX   (75)
#define	BTN_CY   (23)
#define	MSGBOXEX_SPACING   (16)
#define	MSGBOXEX_BUTTONSPACING   (6)
#define	MSGBOXEX_MARGIN   (12)
#define	MSGBOXEX_MAXBTNSTR   (32)
#define	MSGBOXEX_MAXBTNS   (4)
#define	RESCALE_X(_x, _units)   (((_x) * 4 + (_units).cx - 1) / (_units).cx)
#define	RESCALE_Y(_y, _units)   (((_y) * 8 + (_units).cy - 1) / (_units).cy)
#define	DECLARE_MB_1(_btn0)    { 1, { ID##_btn0, 0, 0 }, { IDS_##_btn0, 0, 0 } }
#define	DECLARE_MB_2(_btn0, _btn1)    { 2, { ID##_btn0, ID##_btn1, 0 }, { IDS_##_btn0, IDS_##_btn1, 0 } }
#define	DECLARE_MB_3(_btn0, _btn1, _btn2)    { 3, { ID##_btn0, ID##_btn1, ID##_btn2 }, { IDS_##_btn0, IDS_##_btn1, IDS_##_btn2 } }

Typedefs
typedef struct _MSGBTNINFO	MSGBTNINFO
typedef struct _MSGBTNINFO *	PMSGBTNINFO

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
static UINT	LoadAllocStringW (IN HINSTANCE hInstance OPTIONAL, IN UINT uID, OUT PWSTR *pString, IN PCWSTR pDefaultString OPTIONAL)
static VOID	MessageBoxTextToClipboard (HWND DialogWindow)
static INT_PTR CALLBACK	MessageBoxProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
static int	MessageBoxTimeoutIndirectW (CONST MSGBOXPARAMSW *lpMsgBoxParams, UINT dwTimeout)
int WINAPI	SoftModalMessageBox (IN LPMSGBOXDATA lpMsgBoxData)
int WINAPI	MessageBoxA (IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType)
int WINAPI	MessageBoxW (IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType)
int WINAPI	MessageBoxExA (IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType, IN WORD wLanguageId)
int WINAPI	MessageBoxExW (IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType, IN WORD wLanguageId)
int WINAPI	MessageBoxIndirectA (IN CONST MSGBOXPARAMSA *lpMsgBoxParams)
int WINAPI	MessageBoxIndirectW (IN CONST MSGBOXPARAMSW *lpMsgBoxParams)
int WINAPI	MessageBoxTimeoutA (IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwTimeout)
int WINAPI	MessageBoxTimeoutW (IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwTimeout)
BOOL WINAPI	MessageBeep (IN UINT uType)
LPCWSTR WINAPI	MB_GetString (IN UINT wBtn)

Variables
static const MSGBTNINFO	MsgBtnInfo []

Macro Definition Documentation

BTN_CX

#define BTN_CX   (75)

Definition at line 53 of file messagebox.c.

BTN_CY

#define BTN_CY   (23)

Definition at line 54 of file messagebox.c.

DECLARE_MB_1

#define DECLARE_MB_1

(

_btn0

)

{ 1, { ID##_btn0, 0, 0 }, { IDS_##_btn0, 0, 0 } }

Definition at line 69 of file messagebox.c.

DECLARE_MB_2

#define DECLARE_MB_2	(		_btn0,
			_btn1
	)		{ 2, { ID##_btn0, ID##_btn1, 0 }, { IDS_##_btn0, IDS_##_btn1, 0 } }

Definition at line 72 of file messagebox.c.

DECLARE_MB_3

#define DECLARE_MB_3	(		_btn0,
			_btn1,
			_btn2
	)		{ 3, { ID##_btn0, ID##_btn1, ID##_btn2 }, { IDS_##_btn0, IDS_##_btn1, IDS_##_btn2 } }

Definition at line 75 of file messagebox.c.

IDI_ASTERISKW

#define IDI_ASTERISKW   MAKEINTRESOURCEW(32516)

Definition at line 47 of file messagebox.c.

IDI_EXCLAMATIONW

#define IDI_EXCLAMATIONW   MAKEINTRESOURCEW(32515)

Definition at line 46 of file messagebox.c.

IDI_HANDW

#define IDI_HANDW   MAKEINTRESOURCEW(32513)

Definition at line 44 of file messagebox.c.

IDI_QUESTIONW

#define IDI_QUESTIONW   MAKEINTRESOURCEW(32514)

Definition at line 45 of file messagebox.c.

IDI_WINLOGOW

#define IDI_WINLOGOW   MAKEINTRESOURCEW(32517)

Definition at line 48 of file messagebox.c.

MSGBOX_IDICON

#define MSGBOX_IDICON   (1088)

Definition at line 41 of file messagebox.c.

MSGBOX_IDTEXT

#define MSGBOX_IDTEXT   (0xffff)

Definition at line 42 of file messagebox.c.

MSGBOXEX_BUTTONSPACING

#define MSGBOXEX_BUTTONSPACING   (6)

Definition at line 57 of file messagebox.c.

MSGBOXEX_MARGIN

#define MSGBOXEX_MARGIN   (12)

Definition at line 58 of file messagebox.c.

MSGBOXEX_MAXBTNS

#define MSGBOXEX_MAXBTNS   (4)

Definition at line 60 of file messagebox.c.

MSGBOXEX_MAXBTNSTR

#define MSGBOXEX_MAXBTNSTR   (32)

Definition at line 59 of file messagebox.c.

MSGBOXEX_SPACING

#define MSGBOXEX_SPACING   (16)

Definition at line 56 of file messagebox.c.

RESCALE_X

#define RESCALE_X	(		_x,
			_units
	)		(((_x) * 4 + (_units).cx - 1) / (_units).cx)

Definition at line 63 of file messagebox.c.

RESCALE_Y

#define RESCALE_Y	(		_y,
			_units
	)		(((_y) * 8 + (_units).cy - 1) / (_units).cy)

Definition at line 64 of file messagebox.c.

Typedef Documentation

MSGBTNINFO

typedef struct _MSGBTNINFO MSGBTNINFO

PMSGBTNINFO

typedef struct _MSGBTNINFO * PMSGBTNINFO

Function Documentation

LoadAllocStringW()

static UINT LoadAllocStringW ( IN HINSTANCE hInstance  OPTIONAL, IN UINT  uID, OUT PWSTR *  pString, IN PCWSTR pDefaultString  OPTIONAL  )

static

Definition at line 108 of file messagebox.c.

{
    UINT Length;
    PCWSTR pStr;
 
    /* Try to load the string from the resource */
    Length = LoadStringW(hInstance, uID, (LPWSTR)&pStr, 0);
    if (Length == 0)
    {
        /* If the resource string was not found, use the fallback default one */
 
        if (!pDefaultString)
        {
            /* None was specified, return NULL */
            *pString = NULL;
            return 0;
        }
 
        pStr = pDefaultString;
        Length = wcslen(pStr);
    }
 
    /* Allocate a new buffer, adding a NULL-terminator */
    *pString = RtlAllocateHeap(RtlGetProcessHeap(), 0, (Length + 1) * sizeof(WCHAR));
    if (!*pString)
        return 0;
 
    /* Copy the string, NULL-terminated */
    RtlStringCchCopyNW(*pString, Length + 1, pStr, Length);
    return Length;
}

Referenced by MessageBoxTimeoutIndirectW(), and SoftModalMessageBox().

MB_GetString()

LPCWSTR WINAPI MB_GetString

(

IN UINT

wBtn

)

Definition at line 1345 of file messagebox.c.

{
    static BOOL bCached = FALSE;
    static MBSTRING MBStrings[MAX_MB_STRINGS]; // FIXME: Use gpsi->MBStrings when this is loaded by Win32k!
 
    //
    // FIXME - TODO: The gpsi->MBStrings[] array should be loaded by win32k!
    //
    ASSERT(IDCONTINUE <= MAX_MB_STRINGS);
    if (!bCached)
    {
        UINT i;
        for (i = 0; i < MAX_MB_STRINGS; ++i)
        {
            /*gpsi->*/MBStrings[i].uID  = IDOK + i;
            /*gpsi->*/MBStrings[i].uStr = IDS_OK + i; // See user32/include/resource.h
            LoadStringW(User32Instance,
                        /*gpsi->*/MBStrings[i].uStr,
                        /*gpsi->*/MBStrings[i].szName,
                        ARRAYSIZE(/*gpsi->*/MBStrings[i].szName));
        }
        bCached = TRUE;
    }
 
    /*
     * The allowable IDs are between "IDOK - 1" (0) and "IDCONTINUE - 1" (10) inclusive.
     * See psdk/winuser.h and user32/include/resource.h .
     */
    if (wBtn > IDCONTINUE - 1)
        return NULL;
 
    return /*gpsi->*/MBStrings[wBtn].szName;
}

Referenced by MessageBoxTimeoutIndirectW().

MessageBeep()

BOOL WINAPI MessageBeep

(

IN UINT

uType

)

Definition at line 1329 of file messagebox.c.

{
    return NtUserxMessageBeep(uType);
}

Referenced by SoftModalMessageBox().

MessageBoxA()

int WINAPI MessageBoxA	(	IN HWND	hWnd,
		IN LPCSTR	lpText,
		IN LPCSTR	lpCaption,
		IN UINT	uType
	)

Definition at line 1074 of file messagebox.c.

{
    return MessageBoxExA(hWnd, lpText, lpCaption, uType, LANG_NEUTRAL);
}

MessageBoxExA()

int WINAPI MessageBoxExA	(	IN HWND	hWnd,
		IN LPCSTR	lpText,
		IN LPCSTR	lpCaption,
		IN UINT	uType,
		IN WORD	wLanguageId
	)

Definition at line 1103 of file messagebox.c.

{
    MSGBOXPARAMSA msgbox;
 
    msgbox.cbSize = sizeof(msgbox);
    msgbox.hwndOwner = hWnd;
    msgbox.hInstance = 0;
    msgbox.lpszText = lpText;
    msgbox.lpszCaption = lpCaption;
    msgbox.dwStyle = uType;
    msgbox.lpszIcon = NULL;
    msgbox.dwContextHelpId = 0;
    msgbox.lpfnMsgBoxCallback = NULL;
    msgbox.dwLanguageId = wLanguageId;
 
    return MessageBoxIndirectA(&msgbox);
}

Referenced by MessageBoxA().

MessageBoxExW()

int WINAPI MessageBoxExW	(	IN HWND	hWnd,
		IN LPCWSTR	lpText,
		IN LPCWSTR	lpCaption,
		IN UINT	uType,
		IN WORD	wLanguageId
	)

Definition at line 1131 of file messagebox.c.

{
    MSGBOXPARAMSW msgbox;
 
    msgbox.cbSize = sizeof(msgbox);
    msgbox.hwndOwner = hWnd;
    msgbox.hInstance = 0;
    msgbox.lpszText = lpText;
    msgbox.lpszCaption = lpCaption;
    msgbox.dwStyle = uType;
    msgbox.lpszIcon = NULL;
    msgbox.dwContextHelpId = 0;
    msgbox.lpfnMsgBoxCallback = NULL;
    msgbox.dwLanguageId = wLanguageId;
 
    return MessageBoxTimeoutIndirectW(&msgbox, (UINT)-1);
}

Referenced by MessageBoxW().

MessageBoxIndirectA()

int WINAPI MessageBoxIndirectA

(

IN CONST MSGBOXPARAMSA *

lpMsgBoxParams

)

Definition at line 1160 of file messagebox.c.

{
    MSGBOXPARAMSW msgboxW;
    UNICODE_STRING textW, captionW, iconW;
    int ret;
 
    if (!IS_INTRESOURCE(lpMsgBoxParams->lpszText))
    {
        RtlCreateUnicodeStringFromAsciiz(&textW, (PCSZ)lpMsgBoxParams->lpszText);
        /*
         * UNICODE_STRING objects are always allocated with an extra byte so you
         * can null-term if you want
         */
        textW.Buffer[textW.Length / sizeof(WCHAR)] = L'\0';
    }
    else
        textW.Buffer = (LPWSTR)lpMsgBoxParams->lpszText;
 
    if (!IS_INTRESOURCE(lpMsgBoxParams->lpszCaption))
    {
        RtlCreateUnicodeStringFromAsciiz(&captionW, (PCSZ)lpMsgBoxParams->lpszCaption);
        /*
         * UNICODE_STRING objects are always allocated with an extra byte so you
         * can null-term if you want
         */
        captionW.Buffer[captionW.Length / sizeof(WCHAR)] = L'\0';
    }
    else
        captionW.Buffer = (LPWSTR)lpMsgBoxParams->lpszCaption;
 
    if (lpMsgBoxParams->dwStyle & MB_USERICON)
    {
        if (!IS_INTRESOURCE(lpMsgBoxParams->lpszIcon))
        {
            RtlCreateUnicodeStringFromAsciiz(&iconW, (PCSZ)lpMsgBoxParams->lpszIcon);
            /*
             * UNICODE_STRING objects are always allocated with an extra byte so you
             * can null-term if you want
             */
            iconW.Buffer[iconW.Length / sizeof(WCHAR)] = L'\0';
        }
        else
            iconW.Buffer = (LPWSTR)lpMsgBoxParams->lpszIcon;
    }
    else
        iconW.Buffer = NULL;
 
    msgboxW.cbSize = sizeof(msgboxW);
    msgboxW.hwndOwner = lpMsgBoxParams->hwndOwner;
    msgboxW.hInstance = lpMsgBoxParams->hInstance;
    msgboxW.lpszText = textW.Buffer;
    msgboxW.lpszCaption = captionW.Buffer;
    msgboxW.dwStyle = lpMsgBoxParams->dwStyle;
    msgboxW.lpszIcon = iconW.Buffer;
    msgboxW.dwContextHelpId = lpMsgBoxParams->dwContextHelpId;
    msgboxW.lpfnMsgBoxCallback = lpMsgBoxParams->lpfnMsgBoxCallback;
    msgboxW.dwLanguageId = lpMsgBoxParams->dwLanguageId;
 
    ret = MessageBoxTimeoutIndirectW(&msgboxW, (UINT)-1);
 
    if (!IS_INTRESOURCE(lpMsgBoxParams->lpszText))
        RtlFreeUnicodeString(&textW);
 
    if (!IS_INTRESOURCE(lpMsgBoxParams->lpszCaption))
        RtlFreeUnicodeString(&captionW);
 
    if ((lpMsgBoxParams->dwStyle & MB_USERICON) && !IS_INTRESOURCE(iconW.Buffer))
        RtlFreeUnicodeString(&iconW);
 
    return ret;
}

Referenced by MessageBoxExA().

MessageBoxIndirectW()

int WINAPI MessageBoxIndirectW

(

IN CONST MSGBOXPARAMSW *

lpMsgBoxParams

)

Definition at line 1238 of file messagebox.c.

{
    return MessageBoxTimeoutIndirectW(lpMsgBoxParams, (UINT)-1);
}

MessageBoxProc()

static INT_PTR CALLBACK MessageBoxProc ( HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 248 of file messagebox.c.

{
    PMSGBOXDATA mbd;
 
    switch (message)
    {
    case WM_INITDIALOG:
    {
        int Alert;
 
        mbd = (PMSGBOXDATA)lParam;
 
        SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)mbd);
        NtUserxSetMessageBox(hwnd);
 
        if (!GetPropW(hwnd, L"ROS_MSGBOX"))
        {
            SetPropW(hwnd, L"ROS_MSGBOX", (HANDLE)lParam);
 
            if (mbd->mbp.dwContextHelpId)
                SetWindowContextHelpId(hwnd, mbd->mbp.dwContextHelpId);
 
            if (mbd->mbp.lpszIcon)
            {
                SendDlgItemMessageW(hwnd, MSGBOX_IDICON, STM_SETICON, (WPARAM)(HICON)mbd->mbp.lpszIcon, 0);
                Alert = ALERT_SYSTEM_WARNING;
            }
            else /* Setup the rest of the alerts */
            {
                switch (mbd->mbp.dwStyle & MB_ICONMASK)
                {
                case MB_ICONWARNING:
                    Alert = ALERT_SYSTEM_WARNING;
                    break;
                case MB_ICONERROR:
                    Alert = ALERT_SYSTEM_ERROR;
                    break;
                case MB_ICONQUESTION:
                    Alert = ALERT_SYSTEM_QUERY;
                    break;
                default:
                    Alert = ALERT_SYSTEM_INFORMATIONAL;
                    /* Fall through */
                }
            }
            /* Send out the alert notifications */
            NotifyWinEvent(EVENT_SYSTEM_ALERT, hwnd, OBJID_ALERT, Alert);
 
            /* Disable the Close menu button if no Cancel button is specified */
            if (mbd->uCancelId == 0)
            {
                HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
                if (hSysMenu)
                    DeleteMenu(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
            }
 
            /* Set the focus to the default button */
            if (mbd->dwButtons > 0)
            {
                ASSERT(mbd->uDefButton < mbd->dwButtons);
                SetFocus(GetDlgItem(hwnd, mbd->pidButton[mbd->uDefButton]));
            }
 
            /* Set up the window timer */
            if (mbd->dwTimeout && (mbd->dwTimeout != (UINT)-1))
                SetTimer(hwnd, 0, mbd->dwTimeout, NULL);
        }
        return FALSE;
    }
 
    case WM_COMMAND:
    {
        UINT i;
        INT_PTR iCtrlId = LOWORD(wParam);
 
        switch (iCtrlId)
        {
            /* Handle the default message-box buttons */
            case IDOK:
            case IDCANCEL:
                /*
                 * The dialog manager always sends IDCANCEL when the user
                 * presses ESCape. We check here whether the message box
                 * has a CANCEL button, or whether we should fall back to
                 * the OK button, by using the correct uCancelId.
                 */
                if (iCtrlId == IDCANCEL)
                {
                    mbd = (PMSGBOXDATA)GetPropW(hwnd, L"ROS_MSGBOX");
                    if (!mbd)
                        return FALSE; /* Ignore */
 
                    /* Check whether we can cancel the message box */
                    if (mbd->uCancelId == 0)
                        return TRUE; // FALSE; /* No, ignore */
                    /* Quit with the correct return value */
                    iCtrlId = mbd->uCancelId;
                }
                if (!GetDlgItem(hwnd, iCtrlId))
                    return FALSE; /* Ignore */
 
            /* Fall through */
            case IDABORT:
            case IDRETRY:
            case IDIGNORE:
            case IDYES:
            case IDNO:
            case IDTRYAGAIN:
            case IDCONTINUE:
                EndDialog(hwnd, iCtrlId);
                return TRUE;
 
            case IDCLOSE:
                return FALSE; /* Ignore */
 
            case IDHELP:
            {
                /* Send WM_HELP message to the message-box window */
                HELPINFO hi;
                hi.cbSize = sizeof(hi);
                hi.iContextType = HELPINFO_WINDOW;
                hi.iCtrlId = iCtrlId;
                hi.hItemHandle = (HANDLE)lParam;
                hi.dwContextId = 0;
                GetCursorPos(&hi.MousePos);
                SendMessageW(hwnd, WM_HELP, 0, (LPARAM)&hi);
                return TRUE;
            }
 
            default:
                break;
        }
 
        /* Check for any other user-defined buttons */
        mbd = (PMSGBOXDATA)GetPropW(hwnd, L"ROS_MSGBOX");
        if (!mbd)
            return FALSE;
 
        for (i = 0; i < mbd->dwButtons; ++i)
        {
            if (iCtrlId == mbd->pidButton[i])
            {
                EndDialog(hwnd, iCtrlId);
                return TRUE;
            }
        }
 
        return FALSE;
    }
 
    case WM_COPY:
        MessageBoxTextToClipboard(hwnd);
        return TRUE;
 
    case WM_HELP:
    {
        LPHELPINFO phi = (LPHELPINFO)lParam;
        mbd = (PMSGBOXDATA)GetPropW(hwnd, L"ROS_MSGBOX");
        if (!mbd)
            return FALSE;
        phi->dwContextId = GetWindowContextHelpId(hwnd);
 
        if (mbd->mbp.lpfnMsgBoxCallback)
        {
            mbd->mbp.lpfnMsgBoxCallback(phi);
        }
        else
        {
            HWND hwndOwner = GetWindow(hwnd, GW_OWNER);
            if (hwndOwner)
                SendMessageW(hwndOwner, WM_HELP, 0, lParam);
        }
        return TRUE;
    }
 
    case WM_CLOSE:
    {
        mbd = (PMSGBOXDATA)GetPropW(hwnd, L"ROS_MSGBOX");
        if (!mbd)
            return FALSE;
 
        /* Check whether we can cancel the message box */
        if (mbd->uCancelId == 0)
            return TRUE; /* No, ignore */
        /* Quit with the correct return value */
        EndDialog(hwnd, mbd->uCancelId);
        return TRUE;
    }
 
    case WM_TIMER:
        if (wParam == 0)
            EndDialog(hwnd, IDTIMEOUT);
        return FALSE;
    }
 
    return FALSE;
}

Referenced by SoftModalMessageBox().

MessageBoxTextToClipboard()

static VOID MessageBoxTextToClipboard ( HWND  DialogWindow )

static

Definition at line 144 of file messagebox.c.

{
    HWND hwndText;
    PMSGBOXDATA mbd;
    int cchTotal, cchTitle, cchText, cchButton, i, n, cchBuffer;
    LPWSTR pszBuffer, pszBufferPos, pMessageBoxText, pszTitle, pszText, pszButton;
    WCHAR szButton[MSGBOXEX_MAXBTNSTR];
    HGLOBAL hGlobal;
 
    static const WCHAR szLine[] = L"---------------------------\r\n";
 
    mbd = (PMSGBOXDATA)GetPropW(DialogWindow, L"ROS_MSGBOX");
    hwndText = GetDlgItem(DialogWindow, MSGBOX_IDTEXT);
    cchTitle = GetWindowTextLengthW(DialogWindow) + 1;
    cchText = GetWindowTextLengthW(hwndText) + 1;
 
    if (!mbd)
        return;
 
    pMessageBoxText = (LPWSTR)RtlAllocateHeap(GetProcessHeap(), 0, (cchTitle + cchText) * sizeof(WCHAR));
 
    if (pMessageBoxText == NULL)
    {
        RtlFreeHeap(GetProcessHeap(), 0, pMessageBoxText);
        return;
    }
 
    pszTitle = pMessageBoxText;
    pszText = pMessageBoxText + cchTitle;
 
    if (GetWindowTextW(DialogWindow, pszTitle, cchTitle) == 0 ||
        GetWindowTextW(hwndText, pszText, cchText) == 0)
    {
        RtlFreeHeap(GetProcessHeap(), 0, pMessageBoxText);
        return;
    }
 
    /*
     * Calculate the total buffer size.
     */
    cchTotal = 6 + cchTitle + cchText + (lstrlenW(szLine) * 4) + (mbd->dwButtons * MSGBOXEX_MAXBTNSTR + 3);
 
    hGlobal = GlobalAlloc(GHND, cchTotal * sizeof(WCHAR));
 
    pszBuffer = (LPWSTR)GlobalLock(hGlobal);
 
    if (pszBuffer == NULL)
    {
        RtlFreeHeap(GetProcessHeap(), 0, pMessageBoxText);
        GlobalFree(hGlobal);
        return;
    }
 
    /*
     * First format title and text.
     * ------------------
     * Title
     * ------------------
     * Text
     * ------------------
     */
    cchBuffer = wsprintfW(pszBuffer, L"%s%s\r\n%s%s\r\n%s", szLine, pszTitle, szLine, pszText, szLine);
    pszBufferPos = pszBuffer + cchBuffer;
 
    for (i = 0; i < mbd->dwButtons; i++)
    {
        GetDlgItemTextW(DialogWindow, mbd->pidButton[i], szButton, MSGBOXEX_MAXBTNSTR);
 
        cchButton = strlenW(szButton);
        pszButton = szButton;
 
        /* Skip '&' character. */
        if (szButton[0] == '&')
        {
            pszButton = pszButton + 1;
            cchButton = cchButton - 1;
        }
 
        for (n = 0; n < cchButton; n++)
            *(pszBufferPos++) = pszButton[n];
 
        /* Add spaces. */
        *(pszBufferPos++) = L' ';
        *(pszBufferPos++) = L' ';
        *(pszBufferPos++) = L' ';
    }
 
    wsprintfW(pszBufferPos, L"\r\n%s", szLine);
 
    GlobalUnlock(hGlobal);
 
    if (OpenClipboard(DialogWindow))
    {
        EmptyClipboard();
        SetClipboardData(CF_UNICODETEXT, hGlobal);
        CloseClipboard();
    }
    else
    {
        GlobalFree(hGlobal);
    }
    RtlFreeHeap(GetProcessHeap(), 0, pMessageBoxText);
}

Referenced by MessageBoxProc().

MessageBoxTimeoutA()

int WINAPI MessageBoxTimeoutA	(	IN HWND	hWnd,
		IN LPCSTR	lpText,
		IN LPCSTR	lpCaption,
		IN UINT	uType,
		IN WORD	wLanguageId,
		IN DWORD	dwTimeout
	)

Definition at line 1250 of file messagebox.c.

{
    MSGBOXPARAMSW msgboxW;
    UNICODE_STRING textW, captionW;
    int ret;
 
    if (!IS_INTRESOURCE(lpText))
        RtlCreateUnicodeStringFromAsciiz(&textW, (PCSZ)lpText);
    else
        textW.Buffer = (LPWSTR)lpText;
 
    if (!IS_INTRESOURCE(lpCaption))
        RtlCreateUnicodeStringFromAsciiz(&captionW, (PCSZ)lpCaption);
    else
        captionW.Buffer = (LPWSTR)lpCaption;
 
    msgboxW.cbSize = sizeof(msgboxW);
    msgboxW.hwndOwner = hWnd;
    msgboxW.hInstance = 0;
    msgboxW.lpszText = textW.Buffer;
    msgboxW.lpszCaption = captionW.Buffer;
    msgboxW.dwStyle = uType;
    msgboxW.lpszIcon = NULL;
    msgboxW.dwContextHelpId = 0;
    msgboxW.lpfnMsgBoxCallback = NULL;
    msgboxW.dwLanguageId = wLanguageId;
 
    ret = MessageBoxTimeoutIndirectW(&msgboxW, (UINT)dwTimeout);
 
    if (!IS_INTRESOURCE(textW.Buffer))
        RtlFreeUnicodeString(&textW);
 
    if (!IS_INTRESOURCE(captionW.Buffer))
        RtlFreeUnicodeString(&captionW);
 
    return ret;
}

MessageBoxTimeoutIndirectW()

static int MessageBoxTimeoutIndirectW ( CONST MSGBOXPARAMSW *  lpMsgBoxParams, UINT  dwTimeout  )

static

Definition at line 449 of file messagebox.c.

{
    int ret = 0;
    UINT i;
    LPWSTR defCaption = NULL;
    MSGBOXDATA mbd;
    MSGBTNINFO Buttons;
    LPCWSTR ButtonText[MSGBOXEX_MAXBTNS];
 
    // TODO: Check whether the caller is an NT 3.x app and if so, check
    // instead for the MB_SERVICE_NOTIFICATION_NT3X flag and adjust it.
    if (lpMsgBoxParams->dwStyle & MB_SERVICE_NOTIFICATION)
    {
        NTSTATUS Status;
        UNICODE_STRING CaptionU, TextU;
        ULONG Response = ResponseNotHandled; /* HARDERROR_RESPONSE */
        ULONG_PTR MsgBoxParams[4] =
        {
            (ULONG_PTR)&TextU,
            (ULONG_PTR)&CaptionU,
            /*
             * Retrieve the message box flags. Note that we filter out
             * MB_SERVICE_NOTIFICATION to not enter an infinite recursive
             * loop when we will call MessageBox() later on.
             */
            lpMsgBoxParams->dwStyle & ~MB_SERVICE_NOTIFICATION,
            dwTimeout
        };
 
        /* hwndOwner must be NULL */
        if (lpMsgBoxParams->hwndOwner != NULL)
        {
            ERR("MessageBoxTimeoutIndirectW(MB_SERVICE_NOTIFICATION): hwndOwner is not NULL!\n");
            return 0;
        }
 
        //
        // FIXME: TODO: Implement the special case for Terminal Services.
        //
 
        RtlInitUnicodeString(&CaptionU, lpMsgBoxParams->lpszCaption);
        RtlInitUnicodeString(&TextU, lpMsgBoxParams->lpszText);
 
        Status = NtRaiseHardError(STATUS_SERVICE_NOTIFICATION | HARDERROR_OVERRIDE_ERRORMODE,
                                  ARRAYSIZE(MsgBoxParams),
                                  (1 | 2),
                                  MsgBoxParams,
                                  OptionOk, /* NOTE: This parameter is ignored */
                                  &Response);
        if (!NT_SUCCESS(Status))
        {
            ERR("MessageBoxTimeoutIndirectW(MB_SERVICE_NOTIFICATION): NtRaiseHardError failed, Status = 0x%08lx\n", Status);
            return 0;
        }
 
        /* Map the returned response to the buttons */
        switch (Response)
        {
            /* Not handled */
            case ResponseReturnToCaller:
            case ResponseNotHandled:
                break;
 
            case ResponseAbort:
                return IDABORT;
            case ResponseCancel:
                return IDCANCEL;
            case ResponseIgnore:
                return IDIGNORE;
            case ResponseNo:
                return IDNO;
            case ResponseOk:
                return IDOK;
            case ResponseRetry:
                return IDRETRY;
            case ResponseYes:
                return IDYES;
            case ResponseTryAgain:
                return IDTRYAGAIN;
            case ResponseContinue:
                return IDCONTINUE;
 
            /* Not handled */
            default:
                break;
        }
        return 0;
    }
 
    ZeroMemory(&mbd, sizeof(mbd));
    memcpy(&mbd.mbp, lpMsgBoxParams, sizeof(mbd.mbp));
    mbd.wLanguageId = (WORD)lpMsgBoxParams->dwLanguageId;
    mbd.dwTimeout   = dwTimeout;
 
    if (!mbd.mbp.lpszCaption)
    {
        /* No caption, use the default one */
        LoadAllocStringW(User32Instance,
                         IDS_ERROR,
                         &defCaption,
                         L"Error");
        mbd.mbp.lpszCaption = (defCaption ? defCaption : L"Error");
    }
 
    /* Create the selected buttons; unknown types will fall back to MB_OK */
    i = (lpMsgBoxParams->dwStyle & MB_TYPEMASK);
    if (i >= ARRAYSIZE(MsgBtnInfo))
        i = MB_OK;
 
    /* Get the buttons IDs */
    Buttons = MsgBtnInfo[i];
 
    /* Add the Help button */
    if (lpMsgBoxParams->dwStyle & MB_HELP)
    {
        Buttons.btnIdx[Buttons.btnCnt] = IDHELP;
        Buttons.btnIds[Buttons.btnCnt] = IDS_HELP;
        Buttons.btnCnt++;
    }
 
    ASSERT(Buttons.btnCnt <= MSGBOXEX_MAXBTNS);
 
    /* Retrieve the pointers to the button labels and find the Cancel button */
    mbd.uCancelId = (i == MB_OK ? IDOK : 0);
    for (i = 0; i < Buttons.btnCnt; ++i)
    {
        // FIXME: Use the strings in the correct language.
        // MB_GetString gives the string in default system language.
        ButtonText[i] = MB_GetString(Buttons.btnIds[i] - IDS_OK); /* or: Buttons.btnIdx[i] - IDOK */
#if 0
        LoadAllocStringW(User32Instance,
                         Buttons.btnIds[i],
                         &ButtonText[i],
                         L"");
#endif
        if (Buttons.btnIdx[i] == IDCANCEL)
            mbd.uCancelId = IDCANCEL;
    }
 
    mbd.pidButton = Buttons.btnIdx;
    mbd.ppszButtonText = ButtonText;
    mbd.dwButtons = Buttons.btnCnt;
 
    mbd.uDefButton = ((lpMsgBoxParams->dwStyle & MB_DEFMASK) >> 8);
    /* Make the first button the default button if none other is */
    if (mbd.uDefButton >= mbd.dwButtons)
        mbd.uDefButton = 0;
 
    /* Call the helper function */
    ret = SoftModalMessageBox(&mbd);
 
#if 0
    for (i = 0; i < mbd.dwButtons; i++)
    {
        if (ButtonText[i] && *ButtonText[i])
            RtlFreeHeap(RtlGetProcessHeap(), 0, ButtonText[i]);
    }
#endif
 
    if (defCaption)
        RtlFreeHeap(RtlGetProcessHeap(), 0, defCaption);
 
    return ret;
}

Referenced by MessageBoxExW(), MessageBoxIndirectA(), MessageBoxIndirectW(), MessageBoxTimeoutA(), and MessageBoxTimeoutW().

MessageBoxTimeoutW()

int WINAPI MessageBoxTimeoutW	(	IN HWND	hWnd,
		IN LPCWSTR	lpText,
		IN LPCWSTR	lpCaption,
		IN UINT	uType,
		IN WORD	wLanguageId,
		IN DWORD	dwTimeout
	)

Definition at line 1299 of file messagebox.c.

{
    MSGBOXPARAMSW msgbox;
 
    msgbox.cbSize = sizeof(msgbox);
    msgbox.hwndOwner = hWnd;
    msgbox.hInstance = 0;
    msgbox.lpszText = lpText;
    msgbox.lpszCaption = lpCaption;
    msgbox.dwStyle = uType;
    msgbox.lpszIcon = NULL;
    msgbox.dwContextHelpId = 0;
    msgbox.lpfnMsgBoxCallback = NULL;
    msgbox.dwLanguageId = wLanguageId;
 
    return MessageBoxTimeoutIndirectW(&msgbox, (UINT)dwTimeout);
}

MessageBoxW()

int WINAPI MessageBoxW	(	IN HWND	hWnd,
		IN LPCWSTR	lpText,
		IN LPCWSTR	lpCaption,
		IN UINT	uType
	)

Definition at line 1088 of file messagebox.c.

{
    return MessageBoxExW(hWnd, lpText, lpCaption, uType, LANG_NEUTRAL);
}

SoftModalMessageBox()

int WINAPI SoftModalMessageBox

(

IN LPMSGBOXDATA

lpMsgBoxData

)

Definition at line 617 of file messagebox.c.

{
    int ret = 0;
    MSGBOXDATA mbd;
    LPMSGBOXPARAMSW lpMsgBoxParams = &mbd.mbp;
    DLGTEMPLATE *tpl;
    DLGITEMTEMPLATE *iico, *itxt, *ibtn;
    NONCLIENTMETRICSW nclm;
    LPVOID buf;
    BYTE *dest;
    LPWSTR caption, text;
    HFONT hFont, hOldFont;
    HICON hIcon;
    HWND hDCWnd;
    HDC hDC;
    SIZE units;
    int bufsize, caplen, textlen, i, btnleft, btntop;
    size_t ButtonLen;
    RECT btnrect, txtrect, rc;
    SIZE btnsize;
    POINT iconPos; SIZE iconSize;
 
    /* Capture the MsgBoxData */
    memcpy(&mbd, lpMsgBoxData, sizeof(mbd));
 
    /* Load the caption */
    caption = NULL;
    if (lpMsgBoxParams->lpszCaption && IS_INTRESOURCE(lpMsgBoxParams->lpszCaption))
    {
        /* User-defined resource string */
        caplen = LoadAllocStringW(lpMsgBoxParams->hInstance,
                                  PtrToUlong(lpMsgBoxParams->lpszCaption),
                                  &caption,
                                  NULL);
        lpMsgBoxParams->lpszCaption = caption;
    }
    else if (lpMsgBoxParams->lpszCaption)
    {
        /* UNICODE string pointer */
        caplen = wcslen(lpMsgBoxParams->lpszCaption);
    }
    if (!lpMsgBoxParams->lpszCaption)
    {
        /* No caption, use blank */
        lpMsgBoxParams->lpszCaption = L"";
        caplen = 0;
    }
 
    /* Load the text */
    text = NULL;
    if (lpMsgBoxParams->lpszText && IS_INTRESOURCE(lpMsgBoxParams->lpszText))
    {
        /* User-defined resource string */
        textlen = LoadAllocStringW(lpMsgBoxParams->hInstance,
                                   PtrToUlong(lpMsgBoxParams->lpszText),
                                   &text,
                                   NULL);
        lpMsgBoxParams->lpszText = text;
    }
    else if (lpMsgBoxParams->lpszText)
    {
        /* UNICODE string pointer */
        textlen = wcslen(lpMsgBoxParams->lpszText);
    }
    if (!lpMsgBoxParams->lpszText)
    {
        /* No text, use blank */
        lpMsgBoxParams->lpszText = L"";
        textlen = 0;
    }
 
    /* Load the icon */
    switch (lpMsgBoxParams->dwStyle & MB_ICONMASK)
    {
        case MB_ICONEXCLAMATION: // case MB_ICONWARNING:
            hIcon = LoadIconW(NULL, IDI_EXCLAMATIONW);
            MessageBeep(MB_ICONEXCLAMATION);
            break;
        case MB_ICONQUESTION:
            hIcon = LoadIconW(NULL, IDI_QUESTIONW);
            MessageBeep(MB_ICONQUESTION);
            break;
        case MB_ICONASTERISK: // case MB_ICONINFORMATION:
            hIcon = LoadIconW(NULL, IDI_ASTERISKW);
            MessageBeep(MB_ICONASTERISK);
            break;
        case MB_ICONHAND: // case MB_ICONSTOP: case MB_ICONERROR:
            hIcon = LoadIconW(NULL, IDI_HANDW);
            MessageBeep(MB_ICONHAND);
            break;
        case MB_USERICON:
            hIcon = LoadIconW(lpMsgBoxParams->hInstance, lpMsgBoxParams->lpszIcon);
            MessageBeep(MB_OK);
            break;
        default:
            /*
             * By default, Windows 95/98/NT does not associate an icon
             * to message boxes. So ReactOS should do the same.
             */
            hIcon = NULL;
            MessageBeep(MB_OK);
            break;
    }
    /* Reuse the internal pointer! */
    lpMsgBoxParams->lpszIcon = (LPCWSTR)hIcon;
 
    /* Basic space */
    bufsize = sizeof(DLGTEMPLATE) +
              2 * sizeof(WORD) +                /* menu and class */
              (caplen + 1) * sizeof(WCHAR) +    /* title */
              sizeof(WORD);                     /* font height */
 
    /* Space for the icon */
    if (hIcon)
    {
        bufsize = ALIGN_UP(bufsize, DWORD);
        bufsize += sizeof(DLGITEMTEMPLATE) +
                   4 * sizeof(WORD) +
                   sizeof(WCHAR);
    }
 
    /* Space for the text */
    bufsize = ALIGN_UP(bufsize, DWORD);
    bufsize += sizeof(DLGITEMTEMPLATE) +
               3 * sizeof(WORD) +
               (textlen + 1) * sizeof(WCHAR);
 
    /* Space for the buttons */
    for (i = 0; i < mbd.dwButtons; i++)
    {
        if (!mbd.ppszButtonText[i] || !*mbd.ppszButtonText[i])
        {
            /* No text, use blank */
            mbd.ppszButtonText[i] = L"";
            ButtonLen = 0;
        }
        else
        {
            /* UNICODE string pointer */
            ButtonLen = wcslen(mbd.ppszButtonText[i]);
        }
 
        bufsize = ALIGN_UP(bufsize, DWORD);
        bufsize += sizeof(DLGITEMTEMPLATE) +
                   3 * sizeof(WORD) +
                   (ButtonLen + 1) * sizeof(WCHAR);
    }
 
    /* Allocate the dialog template */
    buf = RtlAllocateHeap(RtlGetProcessHeap(), 0, bufsize);
    if (!buf)
        goto Quit;
 
    iico = itxt = NULL;
 
 
    nclm.cbSize = sizeof(nclm);
    SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(nclm), &nclm, 0);
    hFont = CreateFontIndirectW(&nclm.lfMessageFont);
    if (!hFont)
    {
        ERR("Cannot retrieve nclm.lfMessageFont! (error %lu)\n", GetLastError());
        goto Quit;
    }
 
    hDCWnd = NULL;
    hDC = GetDCEx(hDCWnd, NULL, DCX_WINDOW | DCX_CACHE);
    if (!hDC)
    {
        /* Retry with the DC of the owner window */
        hDCWnd = lpMsgBoxParams->hwndOwner;
        hDC = GetDCEx(hDCWnd, NULL, DCX_WINDOW | DCX_CACHE);
    }
    if (!hDC)
    {
        ERR("GetDCEx() failed, bail out! (error %lu)\n", GetLastError());
        goto Quit;
    }
    hOldFont = SelectObject(hDC, hFont);
 
    units.cx = GdiGetCharDimensions(hDC, NULL, &units.cy);
    if (!units.cx)
    {
        DWORD defUnits;
        ERR("GdiGetCharDimensions() failed, falling back to default values (error %lu)\n", GetLastError());
        defUnits = GetDialogBaseUnits();
        units.cx = LOWORD(defUnits);
        units.cy = HIWORD(defUnits);
    }
 
    /* Calculate the caption rectangle */
    txtrect.right = MulDiv(GetSystemMetrics(SM_CXSCREEN), 4, 5);
    if (hIcon)
        txtrect.right -= GetSystemMetrics(SM_CXICON) + MSGBOXEX_SPACING;
    txtrect.top = txtrect.left = txtrect.bottom = 0;
    if (textlen != 0)
    {
        DrawTextW(hDC, lpMsgBoxParams->lpszText, textlen, &txtrect,
                  DT_LEFT | DT_NOPREFIX | DT_WORDBREAK | DT_EXPANDTABS | DT_EXTERNALLEADING | DT_EDITCONTROL | DT_CALCRECT);
    }
    else
    {
        txtrect.right = txtrect.left + 1;
        txtrect.bottom = txtrect.top + 1;
    }
    txtrect.right++;
 
    /* Calculate the maximum buttons size */
    btnsize.cx = BTN_CX;
    btnsize.cy = BTN_CY;
    btnrect.left = btnrect.top = 0;
    for (i = 0; i < mbd.dwButtons; i++)
    {
        // btnrect.right = btnrect.bottom = 0; // FIXME: Is it needed??
        DrawTextW(hDC, mbd.ppszButtonText[i], wcslen(mbd.ppszButtonText[i]),
                  &btnrect, DT_LEFT | DT_SINGLELINE | DT_CALCRECT);
        btnsize.cx = max(btnsize.cx, btnrect.right);
        btnsize.cy = max(btnsize.cy, btnrect.bottom);
    }
 
    if (hOldFont)
        SelectObject(hDC, hOldFont);
 
    ReleaseDC(hDCWnd, hDC);
 
    if (hFont)
        DeleteObject(hFont);
 
 
    /* Calculate position and size of controls */
 
 
    /* Calculate position and size of the icon */
    rc.left = rc.bottom = rc.right = 0;
    btntop = 0;
    if (hIcon)
    {
        rc.right = GetSystemMetrics(SM_CXICON);
        rc.bottom = GetSystemMetrics(SM_CYICON);
#ifdef MSGBOX_ICONVCENTER
        rc.top = MSGBOXEX_MARGIN + ((max(txtrect.bottom, rc.bottom) - rc.bottom) / 2);
        rc.top = max(MSGBOXEX_SPACING, rc.top);
#else
        rc.top = MSGBOXEX_MARGIN;
#endif
        btnleft = (mbd.dwButtons * (btnsize.cx + MSGBOXEX_BUTTONSPACING)) - MSGBOXEX_BUTTONSPACING;
        if (btnleft > txtrect.right + rc.right + MSGBOXEX_SPACING)
        {
#ifdef MSGBOX_TEXTHCENTER
            rc.left = MSGBOXEX_MARGIN + ((btnleft - txtrect.right - rc.right - MSGBOXEX_SPACING) / 2);
#else
            rc.left = MSGBOXEX_MARGIN;
#endif
            btnleft = MSGBOXEX_MARGIN;
        }
        else
        {
            rc.left = MSGBOXEX_MARGIN;
            btnleft = MSGBOXEX_MARGIN + ((txtrect.right + rc.right + MSGBOXEX_SPACING - btnleft) / 2);
        }
 
        iconPos.x = RESCALE_X(rc.left, units);
        iconPos.y = RESCALE_Y(rc.top, units);
        iconSize.cx = RESCALE_X(rc.right, units);
        iconSize.cy = RESCALE_Y(rc.bottom, units);
 
        btntop = rc.top + rc.bottom + MSGBOXEX_SPACING;
        rc.left += rc.right + MSGBOXEX_SPACING;
    }
    else
    {
        btnleft = (mbd.dwButtons * (btnsize.cx + MSGBOXEX_BUTTONSPACING)) - MSGBOXEX_BUTTONSPACING;
        if (btnleft > txtrect.right)
        {
#ifdef MSGBOX_TEXTHCENTER
            rc.left = MSGBOXEX_MARGIN + ((btnleft - txtrect.right) / 2);
#else
            rc.left = MSGBOXEX_MARGIN;
#endif
            btnleft = MSGBOXEX_MARGIN;
        }
        else
        {
            rc.left = MSGBOXEX_MARGIN;
            btnleft = MSGBOXEX_MARGIN + ((txtrect.right - btnleft) / 2);
        }
    }
 
 
    /* Initialize the dialog template */
    tpl = (DLGTEMPLATE *)buf;
 
    tpl->style = WS_CAPTION | WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_SYSMENU |
                 DS_CENTER | DS_SETFONT | DS_MODALFRAME | DS_NOIDLEMSG;
    tpl->dwExtendedStyle = WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE | WS_EX_CONTROLPARENT;
    if (lpMsgBoxParams->dwStyle & MB_TOPMOST)
        tpl->dwExtendedStyle |= WS_EX_TOPMOST;
    if (lpMsgBoxParams->dwStyle & MB_RIGHT)
        tpl->dwExtendedStyle |= WS_EX_RIGHT;
    tpl->x = 100;
    tpl->y = 100;
    tpl->cdit = mbd.dwButtons + (hIcon ? 1 : 0) + 1; /* Buttons, icon and text */
 
    dest = (BYTE *)(tpl + 1);
 
    *(DWORD*)dest = 0;  /* no menu and use default window class */
    dest += 2 * sizeof(WORD);
    memcpy(dest, lpMsgBoxParams->lpszCaption, caplen * sizeof(WCHAR));
    dest += caplen * sizeof(WCHAR);
    *(WCHAR*)dest = L'\0';
    dest += sizeof(WCHAR);
 
    /*
     * A font point size (height) of 0x7FFF means that we use
     * the message box font (NONCLIENTMETRICSW.lfMessageFont).
     */
    *(WORD*)dest = 0x7FFF;
    dest += sizeof(WORD);
 
    /* Create the icon */
    if (hIcon)
    {
        dest = ALIGN_UP_POINTER(dest, DWORD);
        iico = (DLGITEMTEMPLATE *)dest;
        iico->style = WS_CHILD | WS_VISIBLE | SS_ICON;
        iico->dwExtendedStyle = 0;
        iico->id = MSGBOX_IDICON;
 
        iico->x = iconPos.x;
        iico->y = iconPos.y;
        iico->cx = iconSize.cx;
        iico->cy = iconSize.cy;
 
        dest += sizeof(DLGITEMTEMPLATE);
        *(WORD*)dest = 0xFFFF;
        dest += sizeof(WORD);
        *(WORD*)dest = 0x0082; /* static control */
        dest += sizeof(WORD);
        *(WORD*)dest = 0xFFFF;
        dest += sizeof(WORD);
        *(WCHAR*)dest = 0;
        dest += sizeof(WCHAR);
        *(WORD*)dest = 0;
        dest += sizeof(WORD);
    }
 
    /* Create static for text */
    dest = ALIGN_UP_POINTER(dest, DWORD);
    itxt = (DLGITEMTEMPLATE *)dest;
    itxt->style = WS_CHILD | WS_VISIBLE | SS_NOPREFIX;
    if (lpMsgBoxParams->dwStyle & MB_RIGHT)
        itxt->style |= SS_RIGHT;
    else
        itxt->style |= SS_LEFT;
    itxt->dwExtendedStyle = 0;
    itxt->id = MSGBOX_IDTEXT;
    dest += sizeof(DLGITEMTEMPLATE);
    *(WORD*)dest = 0xFFFF;
    dest += sizeof(WORD);
    *(WORD*)dest = 0x0082; /* static control */
    dest += sizeof(WORD);
    memcpy(dest, lpMsgBoxParams->lpszText, textlen * sizeof(WCHAR));
    dest += textlen * sizeof(WCHAR);
    *(WCHAR*)dest = 0;
    dest += sizeof(WCHAR);
    *(WORD*)dest = 0;
    dest += sizeof(WORD);
 
 
    /* Calculate position of the text */
    rc.top = MSGBOXEX_MARGIN + ((rc.bottom - txtrect.bottom) / 2);
    rc.top = max(rc.top, MSGBOXEX_MARGIN);
 
 
    /* Make the first button the default button if none other is */
    if (mbd.uDefButton >= mbd.dwButtons)
        mbd.uDefButton = 0;
 
    /* Create and calculate the position of the buttons */
    btntop = max(rc.top + txtrect.bottom + MSGBOXEX_SPACING, btntop);
    for (i = 0; i < mbd.dwButtons; i++)
    {
        ButtonLen = wcslen(mbd.ppszButtonText[i]);
 
        dest = ALIGN_UP_POINTER(dest, DWORD);
        ibtn = (DLGITEMTEMPLATE *)dest;
 
        ibtn->style = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
        if (i == mbd.uDefButton)
            ibtn->style |= BS_DEFPUSHBUTTON;
        else
            ibtn->style |= BS_PUSHBUTTON;
 
        ibtn->dwExtendedStyle = 0;
        ibtn->id = mbd.pidButton[i];
        dest += sizeof(DLGITEMTEMPLATE);
        *(WORD*)dest = 0xFFFF;
        dest += sizeof(WORD);
        *(WORD*)dest = 0x0080; /* button control */
        dest += sizeof(WORD);
        memcpy(dest, mbd.ppszButtonText[i], ButtonLen * sizeof(WCHAR));
        dest += ButtonLen * sizeof(WCHAR);
        *(WORD*)dest = 0;
        dest += sizeof(WORD);
        *(WORD*)dest = 0;
        dest += sizeof(WORD);
 
        ibtn->x = RESCALE_X(btnleft, units);
        ibtn->y = RESCALE_Y(btntop, units);
        ibtn->cx = RESCALE_X(btnsize.cx, units);
        ibtn->cy = RESCALE_Y(btnsize.cy, units);
        btnleft += btnsize.cx + MSGBOXEX_BUTTONSPACING;
    }
 
    /* Calculate the size and position of the message-box window */
    btnleft = max(btnleft - MSGBOXEX_BUTTONSPACING, rc.left + txtrect.right);
    btnleft += MSGBOXEX_MARGIN;
    if (mbd.dwButtons > 0)
        btntop += btnsize.cy + MSGBOXEX_MARGIN;
 
    /* Set the size and position of the static message */
    itxt->x = RESCALE_X(rc.left, units);
    itxt->y = RESCALE_Y(rc.top, units);
    itxt->cx = RESCALE_X(btnleft - rc.left - MSGBOXEX_MARGIN, units);
    itxt->cy = RESCALE_Y(txtrect.bottom, units);
 
    /* Set the size of the window */
    tpl->cx = RESCALE_X(btnleft, units);
    tpl->cy = RESCALE_Y(btntop, units);
 
    /* Finally show the message-box */
    ERR("MessageBox: %s\n", wine_dbgstr_wn(lpMsgBoxParams->lpszText, textlen));
    ret = DialogBoxIndirectParamW(lpMsgBoxParams->hInstance, tpl,
                                  lpMsgBoxParams->hwndOwner,
                                  MessageBoxProc, (LPARAM)&mbd);
 
Quit:
    if (buf)
        RtlFreeHeap(RtlGetProcessHeap(), 0, buf);
 
    if (text)
        RtlFreeHeap(RtlGetProcessHeap(), 0, text);
 
    if (caption)
        RtlFreeHeap(RtlGetProcessHeap(), 0, caption);
 
    return ret;
}

Referenced by MessageBoxTimeoutIndirectW(), and TestSoftModalMsgBox().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

user32

)

Variable Documentation

MsgBtnInfo

const MSGBTNINFO MsgBtnInfo[]

static

Initial value:

=
{
    
    DECLARE_MB_1(OK),
    
    DECLARE_MB_2(OK, CANCEL),
    
    DECLARE_MB_3(ABORT, RETRY, IGNORE),
    
    DECLARE_MB_3(YES, NO, CANCEL),
    
    DECLARE_MB_2(YES, NO),
    
    DECLARE_MB_2(RETRY, CANCEL),
    
 
}

Definition at line 86 of file messagebox.c.

Referenced by MessageBoxTimeoutIndirectW().