dialogs.cpp File Reference

#include "precomp.h"

Include dependency graph for dialogs.cpp:

Go to the source code of this file.

Classes
struct	RUNFILEDLGPARAMS
struct	LOGOFF_DLG_CONTEXT
struct	PICK_ICON_CONTEXT

Macros
#define	CX_ICON   GetSystemMetrics(SM_CXICON)
#define	CY_ICON   GetSystemMetrics(SM_CYICON)
#define	CX_ITEM   (CX_ICON + 4)
#define	CY_ITEM   (CY_ICON + 12)
#define	IS_PRODUCT_VERSION_WORKSTATION   0x300
#define	FRIENDLY_LOGOFF_IS_NOT_ENFORCED   0x0
#define	FONT_POINT_SIZE   13
#define	DARK_GREY_COLOR   RGB(244, 244, 244)
#define	LIGHT_GREY_COLOR   RGB(38, 38, 38)
#define	CX_BITMAP   33
#define	CY_BITMAP   33
#define	NUMBER_OF_BUTTONS   2
#define	BUTTON_SWITCH_USER   0
#define	BUTTON_SWITCH_USER_PRESSED   (CY_BITMAP + BUTTON_SWITCH_USER)
#define	BUTTON_SWITCH_USER_FOCUSED   (CY_BITMAP + BUTTON_SWITCH_USER_PRESSED)
#define	BUTTON_LOG_OFF   (CY_BITMAP + BUTTON_SWITCH_USER_FOCUSED)
#define	BUTTON_LOG_OFF_PRESSED   (CY_BITMAP + BUTTON_LOG_OFF)
#define	BUTTON_LOG_OFF_FOCUSED   (CY_BITMAP + BUTTON_LOG_OFF_PRESSED)
#define	BUTTON_SWITCH_USER_DISABLED   (CY_BITMAP + BUTTON_LOG_OFF_FOCUSED)
#define	LOG_OFF_BUTTON_HOT   0
#define	SWITCH_USER_BUTTON_HOT   1

Typedefs
typedef struct LOGOFF_DLG_CONTEXT *	PLOGOFF_DLG_CONTEXT
typedef BOOL(WINAPI *	LPFNOFN) (OPENFILENAMEW *)
typedef struct PICK_ICON_CONTEXT *	PPICK_ICON_CONTEXT
typedef HRESULT(WINAPI *	tShellDimScreen) (IUnknown **Unknown, HWND *hWindow)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
static INT_PTR CALLBACK	RunDlgProc (HWND, UINT, WPARAM, LPARAM)
static void	FillList (HWND, LPWSTR, UINT, BOOL)
BOOL CALLBACK	EnumPickIconResourceProc (HMODULE hModule, LPCWSTR lpszType, LPWSTR lpszName, LONG_PTR lParam)
static void	DestroyIconList (HWND hDlgCtrl, PPICK_ICON_CONTEXT pIconContext)
static BOOL	DoLoadIcons (HWND hwndDlg, PPICK_ICON_CONTEXT pIconContext, LPCWSTR pszFile)
static void	NoIconsInFile (HWND hwndDlg, PPICK_ICON_CONTEXT pIconContext)
INT_PTR CALLBACK	PickIconProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
BOOL WINAPI	PickIconDlg (HWND hWndOwner, LPWSTR lpstrFile, UINT nMaxFile, INT *lpdwIconIndex)
void WINAPI	RunFileDlg (HWND hWndOwner, HICON hIcon, LPCWSTR lpstrDirectory, LPCWSTR lpstrTitle, LPCWSTR lpstrDescription, UINT uFlags)
static LPWSTR	RunDlg_GetParentDir (LPCWSTR cmdline)
static void	EnableOkButtonFromEditContents (HWND hwnd)
static BOOL	ConfirmDialog (HWND hWndOwner, UINT PromptId, UINT TitleId)
BOOL	CallShellDimScreen (IUnknown **pUnknown, HWND *hWindow)
static BOOL	EnablePrivilege (LPCWSTR lpszPrivilegeName, BOOL bEnablePrivilege)
int WINAPI	RestartDialogEx (HWND hWndOwner, LPCWSTR lpwstrReason, DWORD uFlags, DWORD uReason)
BOOL	DrawIconOnOwnerDrawnButtons (DRAWITEMSTRUCT *pdis, PLOGOFF_DLG_CONTEXT pContext)
INT_PTR CALLBACK	OwnerDrawButtonSubclass (HWND hButton, UINT uMsg, WPARAM wParam, LPARAM lParam)
VOID	CreateToolTipForButtons (int controlID, int detailID, HWND hDlg, int titleID)
VOID	EndFriendlyDialog (HWND hwnd, PLOGOFF_DLG_CONTEXT pContext)
static BOOL	IsFriendlyUIActive (VOID)
static VOID	FancyLogoffOnInit (HWND hwnd, PLOGOFF_DLG_CONTEXT pContext)
INT_PTR CALLBACK	LogOffDialogProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
EXTERN_C int WINAPI	LogoffWindowsDialog (HWND hWndOwner)
int WINAPI	RestartDialog (HWND hWndOwner, LPCWSTR lpstrReason, DWORD uFlags)
VOID	ExitWindowsDialog_backup (HWND hWndOwner)
void WINAPI	ExitWindowsDialog (HWND hWndOwner)

Macro Definition Documentation

BUTTON_LOG_OFF

#define BUTTON_LOG_OFF   (CY_BITMAP + BUTTON_SWITCH_USER_FOCUSED)

Definition at line 1122 of file dialogs.cpp.

BUTTON_LOG_OFF_FOCUSED

#define BUTTON_LOG_OFF_FOCUSED   (CY_BITMAP + BUTTON_LOG_OFF_PRESSED)

Definition at line 1124 of file dialogs.cpp.

BUTTON_LOG_OFF_PRESSED

#define BUTTON_LOG_OFF_PRESSED   (CY_BITMAP + BUTTON_LOG_OFF)

Definition at line 1123 of file dialogs.cpp.

BUTTON_SWITCH_USER

#define BUTTON_SWITCH_USER   0

Definition at line 1119 of file dialogs.cpp.

BUTTON_SWITCH_USER_DISABLED

#define BUTTON_SWITCH_USER_DISABLED   (CY_BITMAP + BUTTON_LOG_OFF_FOCUSED)

Definition at line 1125 of file dialogs.cpp.

BUTTON_SWITCH_USER_FOCUSED

#define BUTTON_SWITCH_USER_FOCUSED   (CY_BITMAP + BUTTON_SWITCH_USER_PRESSED)

Definition at line 1121 of file dialogs.cpp.

BUTTON_SWITCH_USER_PRESSED

#define BUTTON_SWITCH_USER_PRESSED   (CY_BITMAP + BUTTON_SWITCH_USER)

Definition at line 1120 of file dialogs.cpp.

CX_BITMAP

#define CX_BITMAP   33

Definition at line 1113 of file dialogs.cpp.

CX_ICON

#define CX_ICON   GetSystemMetrics(SM_CXICON)

Definition at line 179 of file dialogs.cpp.

CX_ITEM

#define CX_ITEM   (CX_ICON + 4)

Definition at line 183 of file dialogs.cpp.

CY_BITMAP

#define CY_BITMAP   33

Definition at line 1114 of file dialogs.cpp.

CY_ICON

#define CY_ICON   GetSystemMetrics(SM_CYICON)

Definition at line 180 of file dialogs.cpp.

CY_ITEM

#define CY_ITEM   (CY_ICON + 12)

Definition at line 184 of file dialogs.cpp.

DARK_GREY_COLOR

#define DARK_GREY_COLOR   RGB(244, 244, 244)

Definition at line 1109 of file dialogs.cpp.

FONT_POINT_SIZE

#define FONT_POINT_SIZE   13

Definition at line 1107 of file dialogs.cpp.

FRIENDLY_LOGOFF_IS_NOT_ENFORCED

#define FRIENDLY_LOGOFF_IS_NOT_ENFORCED   0x0

Definition at line 1105 of file dialogs.cpp.

IS_PRODUCT_VERSION_WORKSTATION

#define IS_PRODUCT_VERSION_WORKSTATION   0x300

Definition at line 1104 of file dialogs.cpp.

LIGHT_GREY_COLOR

#define LIGHT_GREY_COLOR   RGB(38, 38, 38)

Definition at line 1110 of file dialogs.cpp.

LOG_OFF_BUTTON_HOT

#define LOG_OFF_BUTTON_HOT   0

Definition at line 1128 of file dialogs.cpp.

NUMBER_OF_BUTTONS

#define NUMBER_OF_BUTTONS   2

Definition at line 1116 of file dialogs.cpp.

SWITCH_USER_BUTTON_HOT

#define SWITCH_USER_BUTTON_HOT   1

Definition at line 1129 of file dialogs.cpp.

Typedef Documentation

LPFNOFN

typedef BOOL(WINAPI * LPFNOFN) (OPENFILENAMEW *)

Definition at line 46 of file dialogs.cpp.

PLOGOFF_DLG_CONTEXT

typedef struct LOGOFF_DLG_CONTEXT * PLOGOFF_DLG_CONTEXT

PPICK_ICON_CONTEXT

typedef struct PICK_ICON_CONTEXT * PPICK_ICON_CONTEXT

tShellDimScreen

typedef HRESULT(WINAPI * tShellDimScreen) (IUnknown **Unknown, HWND *hWindow)

Definition at line 1029 of file dialogs.cpp.

Function Documentation

CallShellDimScreen()

BOOL CallShellDimScreen	(	IUnknown **	pUnknown,
		HWND *	hWindow
	)

Definition at line 1032 of file dialogs.cpp.

{
    static tShellDimScreen ShellDimScreen;
    static BOOL Initialized = FALSE;
    if (!Initialized)
    {
        HMODULE mod = LoadLibraryW(L"msgina.dll");
        ShellDimScreen = (tShellDimScreen)GetProcAddress(mod, (LPCSTR)16);
        Initialized = TRUE;
    }
 
    HRESULT hr = E_FAIL;
    if (ShellDimScreen)
        hr = ShellDimScreen(pUnknown, hWindow);
    return SUCCEEDED(hr);
}

Referenced by ExitWindowsDialog(), LogoffWindowsDialog(), and RestartDialogEx().

ConfirmDialog()

static BOOL ConfirmDialog ( HWND  hWndOwner, UINT  PromptId, UINT  TitleId  )

static

Definition at line 1019 of file dialogs.cpp.

{
    WCHAR Prompt[256];
    WCHAR Title[256];
 
    LoadStringW(shell32_hInstance, PromptId, Prompt, _countof(Prompt));
    LoadStringW(shell32_hInstance, TitleId, Title, _countof(Title));
    return MessageBoxW(hWndOwner, Prompt, Title, MB_YESNO | MB_ICONQUESTION) == IDYES;
}

Referenced by ExitWindowsDialog_backup(), and RestartDialogEx().

CreateToolTipForButtons()

VOID CreateToolTipForButtons	(	int	controlID,
		int	detailID,
		HWND	hDlg,
		int	titleID
	)

Definition at line 1290 of file dialogs.cpp.

{
    HWND hwndTool = NULL, hwndTip = NULL;
    WCHAR szBuffer[256];
    TTTOOLINFOW tool;
 
    hwndTool = GetDlgItem(hDlg, controlID);
 
    tool.cbSize = sizeof(tool);
    tool.hwnd = hDlg;
    tool.uFlags = TTF_IDISHWND | TTF_SUBCLASS;
    tool.uId = (UINT_PTR)hwndTool;
 
    /* Create the tooltip */
    hwndTip = CreateWindowExW(0, TOOLTIPS_CLASSW, NULL,
                              WS_POPUP | TTS_ALWAYSTIP | TTS_BALLOON,
                              CW_USEDEFAULT, CW_USEDEFAULT,
                              CW_USEDEFAULT, CW_USEDEFAULT,
                              hDlg, NULL, shell32_hInstance, NULL);
 
    /* Associate the tooltip with the tool. */
    LoadStringW(shell32_hInstance, detailID, szBuffer, _countof(szBuffer));
    tool.lpszText = szBuffer;
    SendMessageW(hwndTip, TTM_ADDTOOLW, 0, (LPARAM)&tool);
    LoadStringW(shell32_hInstance, titleID, szBuffer, _countof(szBuffer));
    SendMessageW(hwndTip, TTM_SETTITLEW, TTI_NONE, (LPARAM)szBuffer);
    SendMessageW(hwndTip, TTM_SETMAXTIPWIDTH, 0, 250);
}

Referenced by FancyLogoffOnInit().

DestroyIconList()

static void DestroyIconList ( HWND  hDlgCtrl, PPICK_ICON_CONTEXT  pIconContext  )

static

Definition at line 87 of file dialogs.cpp.

{
    int count;
    int index;
 
    count = SendMessageW(hDlgCtrl, LB_GETCOUNT, 0, 0);
    if (count == LB_ERR)
        return;
 
    for(index = 0; index < count; index++)
    {
        DestroyIcon(pIconContext->phIcons[index]);
        pIconContext->phIcons[index] = NULL;
    }
}

Referenced by DoLoadIcons(), and PickIconProc().

DoLoadIcons()

static BOOL DoLoadIcons ( HWND  hwndDlg, PPICK_ICON_CONTEXT  pIconContext, LPCWSTR  pszFile  )

static

Definition at line 104 of file dialogs.cpp.

{
    WCHAR szExpandedPath[MAX_PATH];
 
    // Destroy previous icons
    DestroyIconList(pIconContext->hDlgCtrl, pIconContext);
    SendMessageW(pIconContext->hDlgCtrl, LB_RESETCONTENT, 0, 0);
    delete[] pIconContext->phIcons;
 
    // Store the path
    StringCchCopyW(pIconContext->szPath, _countof(pIconContext->szPath), pszFile);
    ExpandEnvironmentStringsW(pszFile, szExpandedPath, _countof(szExpandedPath));
 
    // Load the module if possible
    HMODULE hLibrary = LoadLibraryExW(szExpandedPath, NULL, LOAD_LIBRARY_AS_DATAFILE);
    if (pIconContext->hLibrary)
        FreeLibrary(pIconContext->hLibrary);
    pIconContext->hLibrary = hLibrary;
 
    if (pIconContext->hLibrary)
    {
        // Load the icons from the module
        pIconContext->nIcons = ExtractIconExW(szExpandedPath, -1, NULL, NULL, 0);
        pIconContext->phIcons = new HICON[pIconContext->nIcons];
 
        if (ExtractIconExW(szExpandedPath, 0, pIconContext->phIcons, NULL, pIconContext->nIcons))
        {
            EnumResourceNamesW(pIconContext->hLibrary, RT_GROUP_ICON, EnumPickIconResourceProc, (LPARAM)pIconContext);
        }
        else
        {
            pIconContext->nIcons = 0;
        }
    }
    else
    {
        // .ico file
        pIconContext->nIcons = 1;
        pIconContext->phIcons = new HICON[1];
 
        if (ExtractIconExW(szExpandedPath, 0, pIconContext->phIcons, NULL, pIconContext->nIcons))
        {
            SendMessageW(pIconContext->hDlgCtrl, LB_ADDSTRING, 0, 0);
        }
        else
        {
            pIconContext->nIcons = 0;
        }
    }
 
    // Set the text and reset the edit control's modification flag
    SetDlgItemTextW(hwndDlg, IDC_EDIT_PATH, pIconContext->szPath);
    SendDlgItemMessage(hwndDlg, IDC_EDIT_PATH, EM_SETMODIFY, FALSE, 0);
 
    if (pIconContext->nIcons == 0)
    {
        delete[] pIconContext->phIcons;
        pIconContext->phIcons = NULL;
    }
 
    return (pIconContext->nIcons > 0);
}

Referenced by NoIconsInFile(), and PickIconProc().

DrawIconOnOwnerDrawnButtons()

BOOL DrawIconOnOwnerDrawnButtons	(	DRAWITEMSTRUCT *	pdis,
		PLOGOFF_DLG_CONTEXT	pContext
	)

Definition at line 1131 of file dialogs.cpp.

{
    BOOL bRet = FALSE;
    HDC hdcMem = NULL;
    HBITMAP hbmOld = NULL;
    int y = 0;
    RECT rect;
 
    hdcMem = CreateCompatibleDC(pdis->hDC);
    hbmOld = (HBITMAP)SelectObject(hdcMem, pContext->hImageStrip);
    rect = pdis->rcItem;
 
    /* Check the button ID for revelant bitmap to be used */
    switch (pdis->CtlID)
    {
        case IDC_LOG_OFF_BUTTON:
        {
            switch (pdis->itemAction)
            {
                case ODA_DRAWENTIRE:
                case ODA_FOCUS:
                case ODA_SELECT:
                {
                    y = BUTTON_LOG_OFF;
                    if (pdis->itemState & ODS_SELECTED)
                    {
                        y = BUTTON_LOG_OFF_PRESSED;
                    }
                    else if (pContext->bIsButtonHot[LOG_OFF_BUTTON_HOT] || (pdis->itemState & ODS_FOCUS))
                    {
                        y = BUTTON_LOG_OFF_FOCUSED;
                    }
                    break;
                }
            }
            break;
        }
 
        case IDC_SWITCH_USER_BUTTON:
        {
            switch (pdis->itemAction)
            {
                case ODA_DRAWENTIRE:
                case ODA_FOCUS:
                case ODA_SELECT:
                {
                    y = BUTTON_SWITCH_USER;
                    if (pdis->itemState & ODS_SELECTED)
                    {
                        y = BUTTON_SWITCH_USER_PRESSED;
                    }
                    else if (pContext->bIsButtonHot[SWITCH_USER_BUTTON_HOT] || (pdis->itemState & ODS_FOCUS))
                    {
                        y = BUTTON_SWITCH_USER_FOCUSED;
                    }
 
                    /*
                     * Since switch user functionality isn't implemented yet therefore the button has been disabled
                     * temporarily hence show the disabled state
                     */
                    else if (pdis->itemState & ODS_DISABLED)
                    {
                        y = BUTTON_SWITCH_USER_DISABLED;
                    }
                    break;
                }
            }
            break;
        }
    }
 
    /* Draw it on the required button */
    bRet = BitBlt(pdis->hDC,
                  (rect.right - rect.left - CX_BITMAP) / 2,
                  (rect.bottom - rect.top - CY_BITMAP) / 2,
                  CX_BITMAP, CY_BITMAP, hdcMem, 0, y, SRCCOPY);
 
    SelectObject(hdcMem, hbmOld);
    DeleteDC(hdcMem);
 
    return bRet;
}

Referenced by LogOffDialogProc().

EnableOkButtonFromEditContents()

static void EnableOkButtonFromEditContents ( HWND  hwnd )

static

Definition at line 488 of file dialogs.cpp.

{
    BOOL Enable = FALSE;
    INT Length, n;
    HWND Edit = GetDlgItem(hwnd, IDC_RUNDLG_EDITPATH);
    Length = GetWindowTextLengthW(Edit);
    if (Length > 0)
    {
        PWCHAR psz = (PWCHAR)HeapAlloc(GetProcessHeap(), 0, (Length + 1) * sizeof(WCHAR));
        if (psz)
        {
            GetWindowTextW(Edit, psz, Length + 1);
            for (n = 0; n < Length && !Enable; ++n)
                Enable = psz[n] != ' ';
            HeapFree(GetProcessHeap(), 0, psz);
        }
        else
            Enable = TRUE;
    }
    EnableWindow(GetDlgItem(hwnd, IDOK), Enable);
}

Referenced by RunDlgProc().

EnablePrivilege()

static BOOL EnablePrivilege ( LPCWSTR  lpszPrivilegeName, BOOL  bEnablePrivilege  )

static

Definition at line 1052 of file dialogs.cpp.

{
    BOOL   Success;
    HANDLE hToken;
    TOKEN_PRIVILEGES tp;
 
    Success = OpenProcessToken(GetCurrentProcess(),
                               TOKEN_ADJUST_PRIVILEGES,
                               &hToken);
    if (!Success) return Success;
 
    Success = LookupPrivilegeValueW(NULL,
                                    lpszPrivilegeName,
                                    &tp.Privileges[0].Luid);
    if (!Success) goto Quit;
 
    tp.PrivilegeCount = 1;
    tp.Privileges[0].Attributes = (bEnablePrivilege ? SE_PRIVILEGE_ENABLED : 0);
 
    Success = AdjustTokenPrivileges(hToken, FALSE, &tp, 0, NULL, NULL);
 
Quit:
    CloseHandle(hToken);
    return Success;
}

Referenced by ExitWindowsDialog(), ExitWindowsDialog_backup(), and RestartDialogEx().

EndFriendlyDialog()

VOID EndFriendlyDialog	(	HWND	hwnd,
		PLOGOFF_DLG_CONTEXT	pContext
	)

Definition at line 1319 of file dialogs.cpp.

{
    DeleteObject(pContext->hBrush);
    DeleteObject(pContext->hImageStrip);
    DeleteObject(pContext->hfFont);
 
    /* Remove the subclass from the buttons */
    for (int i = 0; i < NUMBER_OF_BUTTONS; i++)
    {
        SetWindowLongPtrW(GetDlgItem(hwnd, IDC_LOG_OFF_BUTTON + i),
                          GWLP_WNDPROC,
                          (LONG_PTR)pContext->OldButtonProc);
    }
}

Referenced by LogOffDialogProc().

EnumPickIconResourceProc()

BOOL CALLBACK EnumPickIconResourceProc	(	HMODULE	hModule,
		LPCWSTR	lpszType,
		LPWSTR	lpszName,
		LONG_PTR	lParam
	)

Definition at line 68 of file dialogs.cpp.

{
    PPICK_ICON_CONTEXT pIconContext = PPICK_ICON_CONTEXT(lParam);
    HWND hDlgCtrl = pIconContext->hDlgCtrl;
 
    if (IS_INTRESOURCE(lpszName))
        lParam = LOWORD(lpszName);
    else
        lParam = -1;
 
    SendMessageW(hDlgCtrl, LB_ADDSTRING, 0, lParam);
 
    return TRUE;
}

Referenced by DoLoadIcons().

ExitWindowsDialog()

void WINAPI ExitWindowsDialog

(

HWND

hWndOwner

)

Definition at line 1608 of file dialogs.cpp.

{
    typedef DWORD (WINAPI *ShellShFunc)(HWND hParent, WCHAR *Username, BOOL bHideLogoff);
    HINSTANCE msginaDll = LoadLibraryW(L"msgina.dll");
 
    TRACE("(%p)\n", hWndOwner);
 
    CComPtr<IUnknown> fadeHandler;
    HWND parent;
    if (!CallShellDimScreen(&fadeHandler, &parent))
        parent = hWndOwner;
 
    /* If the DLL cannot be found for any reason, then it simply uses a
       dialog box to ask if the user wants to shut down the computer. */
    if (!msginaDll)
    {
        TRACE("Unable to load msgina.dll.\n");
        ExitWindowsDialog_backup(parent);
        return;
    }
 
    ShellShFunc pShellShutdownDialog = (ShellShFunc)GetProcAddress(msginaDll, "ShellShutdownDialog");
 
    if (pShellShutdownDialog)
    {
        /* Actually call the function */
        DWORD returnValue = pShellShutdownDialog(parent, NULL, FALSE);
 
        switch (returnValue)
        {
        case 0x01: /* Log off user */
        {
            ExitWindowsEx(EWX_LOGOFF, 0);
            break;
        }
        case 0x02: /* Shut down */
        {
            EnablePrivilege(L"SeShutdownPrivilege", TRUE);
            ExitWindowsEx(EWX_SHUTDOWN, 0);
            EnablePrivilege(L"SeShutdownPrivilege", FALSE);
            break;
        }
        case 0x03: /* Install Updates/Shutdown (?) */
        {
            break;
        }
        case 0x04: /* Reboot */
        {
            EnablePrivilege(L"SeShutdownPrivilege", TRUE);
            ExitWindowsEx(EWX_REBOOT, 0);
            EnablePrivilege(L"SeShutdownPrivilege", FALSE);
            break;
        }
        case 0x10: /* Sleep */
        {
            if (IsPwrSuspendAllowed())
            {
                EnablePrivilege(L"SeShutdownPrivilege", TRUE);
                SetSuspendState(FALSE, FALSE, FALSE);
                EnablePrivilege(L"SeShutdownPrivilege", FALSE);
            }
            break;
        }
        case 0x40: /* Hibernate */
        {
            if (IsPwrHibernateAllowed())
            {
                EnablePrivilege(L"SeShutdownPrivilege", TRUE);
                SetSuspendState(TRUE, FALSE, TRUE);
                EnablePrivilege(L"SeShutdownPrivilege", FALSE);
            }
            break;
        }
        /* If the option is any other value */
        default:
            break;
        }
    }
    else
    {
        /* If the function cannot be found, then revert to using the backup solution */
        TRACE("Unable to find the 'ShellShutdownDialog' function");
        ExitWindowsDialog_backup(parent);
    }
 
    FreeLibrary(msginaDll);
}

Referenced by CTrayWindow::DoExitWindows(), ShowExitWindowsDialog(), and CShellDispatch::ShutdownWindows().

ExitWindowsDialog_backup()

VOID ExitWindowsDialog_backup

(

HWND

hWndOwner

)

Definition at line 1585 of file dialogs.cpp.

{
    TRACE("(%p)\n", hWndOwner);
 
    if (ConfirmDialog(hWndOwner, IDS_SHUTDOWN_PROMPT, IDS_SHUTDOWN_TITLE))
    {
        EnablePrivilege(L"SeShutdownPrivilege", TRUE);
        ExitWindowsEx(EWX_SHUTDOWN, 0);
        EnablePrivilege(L"SeShutdownPrivilege", FALSE);
    }
}

Referenced by ExitWindowsDialog().

FancyLogoffOnInit()

static VOID FancyLogoffOnInit ( HWND  hwnd, PLOGOFF_DLG_CONTEXT  pContext  )

static

Definition at line 1408 of file dialogs.cpp.

{
    HDC hdc = NULL;
    LONG lfHeight = NULL;
 
    hdc = GetDC(NULL);
    lfHeight = -MulDiv(FONT_POINT_SIZE, GetDeviceCaps(hdc, LOGPIXELSY), 72);
    ReleaseDC(NULL, hdc);
    pContext->hfFont = CreateFontW(lfHeight, 0, 0, 0, FW_MEDIUM, FALSE, 0, 0, 0, 0, 0, 0, 0, L"MS Shell Dlg");
    SendDlgItemMessageW(hwnd, IDC_LOG_OFF_TEXT_STATIC, WM_SETFONT, (WPARAM)pContext->hfFont, TRUE);
 
    pContext->hBrush = CreateSolidBrush(DARK_GREY_COLOR);
 
    pContext->hImageStrip = LoadBitmapW(shell32_hInstance, MAKEINTRESOURCEW(IDB_IMAGE_STRIP));
 
    /* Gather old button func */
    pContext->OldButtonProc = (WNDPROC)GetWindowLongPtrW(GetDlgItem(hwnd, IDC_LOG_OFF_BUTTON), GWLP_WNDPROC);
 
    /* Set bIsButtonHot to false, create tooltips for each buttons and subclass the buttons */
    for (int i = 0; i < NUMBER_OF_BUTTONS; i++)
    {
        pContext->bIsButtonHot[i] = FALSE;
        SetWindowLongPtrW(GetDlgItem(hwnd, IDC_LOG_OFF_BUTTON + i),
                          GWLP_WNDPROC,
                          (LONG_PTR)OwnerDrawButtonSubclass);
        CreateToolTipForButtons(IDC_LOG_OFF_BUTTON + i,
                                IDS_LOG_OFF_DESC + i,
                                hwnd,
                                IDS_LOG_OFF_TITLE + i);
    }
}

Referenced by LogOffDialogProc().

FillList()

static void FillList ( HWND  hCb, LPWSTR  pszLatest, UINT  cchStr, BOOL  fShowDefault  )

static

Definition at line 788 of file dialogs.cpp.

{
    HKEY hkey;
    WCHAR *pszList = NULL, *pszCmd = NULL, *pszTmp = NULL, cMatch = 0, cMax = 0x60;
    WCHAR szIndex[2] = L"-";
    UINT cchLatest;
    DWORD dwType, icList = 0, icCmd = 0;
    LRESULT lRet;
    UINT Nix;
 
    /*
     * Retrieve the string length of pszLatest and check whether its buffer size
     * (cchStr in number of characters) is large enough to add the terminating "\\1"
     * (and the NULL character).
     */
    if (pszLatest)
    {
        cchLatest = wcslen(pszLatest);
        if (cchStr < cchLatest + 2 + 1)
        {
            TRACE("pszLatest buffer is not large enough (%d) to hold the MRU terminator.\n", cchStr);
            return;
        }
    }
    else
    {
        cchStr = 0;
    }
 
    SendMessageW(hCb, CB_RESETCONTENT, 0, 0);
 
    lRet = RegCreateKeyExW(HKEY_CURRENT_USER,
                           L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU",
                           0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL);
    if (lRet != ERROR_SUCCESS)
    {
        TRACE("Unable to open or create the RunMRU key, error %d\n", GetLastError());
        return;
    }
 
    lRet = RegQueryValueExW(hkey, L"MRUList", NULL, &dwType, NULL, &icList);
    if (lRet == ERROR_SUCCESS && dwType == REG_SZ && icList > sizeof(WCHAR))
    {
        pszList = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, icList);
        if (!pszList)
        {
            TRACE("HeapAlloc failed to allocate %d bytes\n", icList);
            goto Continue;
        }
        pszList[0] = L'\0';
 
        lRet = RegQueryValueExW(hkey, L"MRUList", NULL, NULL, (LPBYTE)pszList, &icList);
        if (lRet != ERROR_SUCCESS)
        {
            TRACE("Unable to grab MRUList, error %d\n", GetLastError());
            pszList[0] = L'\0';
        }
    }
    else
    {
Continue:
        icList = sizeof(WCHAR);
        pszList = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, icList);
        if (!pszList)
        {
            TRACE("HeapAlloc failed to allocate %d bytes\n", icList);
            RegCloseKey(hkey);
            return;
        }
        pszList[0] = L'\0';
    }
 
    /* Convert the number of bytes from MRUList into number of characters (== number of indices) */
    icList /= sizeof(WCHAR);
 
    for (Nix = 0; Nix < icList - 1; Nix++)
    {
        if (pszList[Nix] > cMax)
            cMax = pszList[Nix];
 
        szIndex[0] = pszList[Nix];
 
        lRet = RegQueryValueExW(hkey, szIndex, NULL, &dwType, NULL, &icCmd);
        if (lRet != ERROR_SUCCESS || dwType != REG_SZ)
        {
            TRACE("Unable to grab size of index, error %d\n", GetLastError());
            continue;
        }
 
        if (pszCmd)
        {
            pszTmp = (WCHAR*)HeapReAlloc(GetProcessHeap(), 0, pszCmd, icCmd);
            if (!pszTmp)
            {
                TRACE("HeapReAlloc failed to reallocate %d bytes\n", icCmd);
                continue;
            }
            pszCmd = pszTmp;
        }
        else
        {
            pszCmd = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, icCmd);
            if (!pszCmd)
            {
                TRACE("HeapAlloc failed to allocate %d bytes\n", icCmd);
                continue;
            }
        }
 
        lRet = RegQueryValueExW(hkey, szIndex, NULL, NULL, (LPBYTE)pszCmd, &icCmd);
        if (lRet != ERROR_SUCCESS)
        {
            TRACE("Unable to grab index, error %d\n", GetLastError());
            continue;
        }
 
        /*
         * Generally the command string will end up with "\\1".
         * Find the last backslash in the string and NULL-terminate.
         * Windows does not seem to check for what comes next, so that
         * a command of the form:
         *     c:\\my_dir\\myfile.exe
         * will be cut just after "my_dir", whereas a command of the form:
         *     c:\\my_dir\\myfile.exe\\1
         * will be cut just after "myfile.exe".
         */
        pszTmp = wcsrchr(pszCmd, L'\\');
        if (pszTmp)
            *pszTmp = L'\0';
 
        /*
         * In the following we try to add pszLatest to the MRU list.
         * We suppose that our caller has already correctly allocated
         * the string with enough space for us to append a "\\1".
         *
         * FIXME: TODO! (At the moment we don't append it!)
         */
 
        if (pszLatest)
        {
            if (wcsicmp(pszCmd, pszLatest) == 0)
            {
                SendMessageW(hCb, CB_INSERTSTRING, 0, (LPARAM)pszCmd);
                SetWindowTextW(hCb, pszCmd);
                SendMessageW(hCb, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
 
                cMatch = pszList[Nix];
                memmove(&pszList[1], pszList, Nix * sizeof(WCHAR));
                pszList[0] = cMatch;
                continue;
            }
        }
 
        if (icList - 1 != 26 || icList - 2 != Nix || cMatch || pszLatest == NULL)
        {
            SendMessageW(hCb, CB_ADDSTRING, 0, (LPARAM)pszCmd);
            if (!Nix && fShowDefault)
            {
                SetWindowTextW(hCb, pszCmd);
                SendMessageW(hCb, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
            }
        }
        else
        {
            SendMessageW(hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest);
            SetWindowTextW(hCb, pszLatest);
            SendMessageW(hCb, CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
 
            cMatch = pszList[Nix];
            memmove(&pszList[1], pszList, Nix * sizeof(WCHAR));
            pszList[0] = cMatch;
            szIndex[0] = cMatch;
 
            wcscpy(&pszLatest[cchLatest], L"\\1");
            RegSetValueExW(hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, (cchLatest + 2 + 1) * sizeof(WCHAR));
            pszLatest[cchLatest] = L'\0';
        }
    }
 
    if (!cMatch && pszLatest != NULL)
    {
        SendMessageW(hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest);
        SetWindowTextW(hCb, pszLatest);
        SendMessageW(hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1));
 
        cMatch = ++cMax;
 
        if (pszList)
        {
            pszTmp = (WCHAR*)HeapReAlloc(GetProcessHeap(), 0, pszList, (++icList) * sizeof(WCHAR));
            if (!pszTmp)
            {
                TRACE("HeapReAlloc failed to reallocate enough bytes\n");
                goto Cleanup;
            }
            pszList = pszTmp;
        }
        else
        {
            pszList = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (++icList) * sizeof(WCHAR));
            if (!pszList)
            {
                TRACE("HeapAlloc failed to allocate enough bytes\n");
                goto Cleanup;
            }
        }
 
        memmove(&pszList[1], pszList, (icList - 1) * sizeof(WCHAR));
        pszList[0] = cMatch;
        szIndex[0] = cMatch;
 
        wcscpy(&pszLatest[cchLatest], L"\\1");
        RegSetValueExW(hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, (cchLatest + 2 + 1) * sizeof(WCHAR));
        pszLatest[cchLatest] = L'\0';
    }
 
Cleanup:
    RegSetValueExW(hkey, L"MRUList", 0, REG_SZ, (LPBYTE)pszList, (wcslen(pszList) + 1) * sizeof(WCHAR));
 
    HeapFree(GetProcessHeap(), 0, pszCmd);
    HeapFree(GetProcessHeap(), 0, pszList);
 
    RegCloseKey(hkey);
}

Referenced by RunDlgProc().

IsFriendlyUIActive()

static BOOL IsFriendlyUIActive ( VOID  )

static

Definition at line 1334 of file dialogs.cpp.

{
    DWORD dwType = 0, dwValue = 0, dwSize = 0;
    HKEY hKey = NULL;
    LONG lRet = 0;
 
    lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                         L"SYSTEM\\CurrentControlSet\\Control\\Windows",
                         0,
                         KEY_QUERY_VALUE,
                         &hKey);
    if (lRet != ERROR_SUCCESS)
        return FALSE;
 
    /* First check an optional ReactOS specific override, that Windows does not check.
       We use this to allow users pairing 'Server'-configuration with FriendlyLogoff.
       Otherwise users would have to change CSDVersion or LogonType (side-effects AppCompat) */
    dwValue = 0;
    dwSize = sizeof(dwValue);
    lRet = RegQueryValueExW(hKey,
                            L"EnforceFriendlyLogoff",
                            NULL,
                            &dwType,
                            (LPBYTE)&dwValue,
                            &dwSize);
 
    if (lRet == ERROR_SUCCESS && dwType == REG_DWORD && dwValue != FRIENDLY_LOGOFF_IS_NOT_ENFORCED)
    {
        RegCloseKey(hKey);
        return TRUE;
    }
 
    /* Check product version number */
    dwValue = 0;
    dwSize = sizeof(dwValue);
    lRet = RegQueryValueExW(hKey,
                            L"CSDVersion",
                            NULL,
                            &dwType,
                            (LPBYTE)&dwValue,
                            &dwSize);
    RegCloseKey(hKey);
 
    if (lRet != ERROR_SUCCESS || dwType != REG_DWORD || dwValue != IS_PRODUCT_VERSION_WORKSTATION)
    {
        /* Allow Friendly UI only on Workstation */
        return FALSE;
    }
 
    /* Check LogonType value */
    lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                         L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon",
                         0,
                         KEY_QUERY_VALUE,
                         &hKey);
    if (lRet != ERROR_SUCCESS)
        return FALSE;
 
    dwValue = 0;
    dwSize = sizeof(dwValue);
    lRet = RegQueryValueExW(hKey,
                            L"LogonType",
                            NULL,
                            &dwType,
                            (LPBYTE)&dwValue,
                            &dwSize);
    RegCloseKey(hKey);
 
    if (lRet != ERROR_SUCCESS || dwType != REG_DWORD)
        return FALSE;
 
    return (dwValue != 0);
}

Referenced by LogoffWindowsDialog().

LogOffDialogProc()

INT_PTR CALLBACK LogOffDialogProc	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1445 of file dialogs.cpp.

{
    DRAWITEMSTRUCT* pdis = (DRAWITEMSTRUCT*)lParam;
    PLOGOFF_DLG_CONTEXT pContext;
    pContext = (PLOGOFF_DLG_CONTEXT)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            pContext = (PLOGOFF_DLG_CONTEXT)lParam;
            SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)pContext);
 
            if (pContext->bFriendlyUI)
                FancyLogoffOnInit(hwnd, pContext);
            return TRUE;
        }
 
        case WM_CLOSE:
            EndDialog(hwnd, IDCANCEL);
            break;
 
        /*
        * If the user deactivates the log off dialog (it loses its focus
        * while the dialog is not being closed), then destroy the dialog
        * box.
        */
        case WM_ACTIVATE:
        {
            if (LOWORD(wParam) == WA_INACTIVE)
            {
                EndDialog(hwnd, IDCANCEL);
            }
            return FALSE;
        }
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_LOG_OFF_BUTTON:
                case IDOK:
                    ExitWindowsEx(EWX_LOGOFF, 0);
                    break;
 
                case IDCANCEL:
                    EndDialog(hwnd, IDCANCEL);
                    break;
            }
            break;
 
        case WM_DESTROY:
            if (pContext->bFriendlyUI)
                EndFriendlyDialog(hwnd, pContext);
            return TRUE;
 
        case WM_CTLCOLORSTATIC:
        {
            /* Either make background transparent or fill it with color for required static controls */
            HDC hdcStatic = (HDC)wParam;
            UINT StaticID = (UINT)GetWindowLongPtrW((HWND)lParam, GWL_ID);
 
            switch (StaticID)
            {
                case IDC_LOG_OFF_TEXT_STATIC:
                   SetTextColor(hdcStatic, DARK_GREY_COLOR);
                   SetBkMode(hdcStatic, TRANSPARENT);
                   return (INT_PTR)GetStockObject(HOLLOW_BRUSH);
 
                case IDC_LOG_OFF_STATIC:
                case IDC_SWITCH_USER_STATIC:
                    SetTextColor(hdcStatic, LIGHT_GREY_COLOR);
                    SetBkMode(hdcStatic, TRANSPARENT);
                    return (LONG_PTR)pContext->hBrush;
            }
            return FALSE;
        }
        break;
 
        case WM_DRAWITEM:
        {
            /* Draw bitmaps on required buttons */
            switch (pdis->CtlID)
            {
                case IDC_LOG_OFF_BUTTON:
                case IDC_SWITCH_USER_BUTTON:
                    return DrawIconOnOwnerDrawnButtons(pdis, pContext);
            }
        }
        break;
 
        default:
            break;
    }
    return FALSE;
}

Referenced by LogoffWindowsDialog().

LogoffWindowsDialog()

EXTERN_C int WINAPI LogoffWindowsDialog

(

HWND

hWndOwner

)

Definition at line 1545 of file dialogs.cpp.

{
    CComPtr<IUnknown> fadeHandler;
    HWND parent = NULL;
    DWORD LogoffDialogID = IDD_LOG_OFF;
    LOGOFF_DLG_CONTEXT Context;
 
    if (!CallShellDimScreen(&fadeHandler, &parent))
        parent = hWndOwner;
 
    Context.bFriendlyUI = IsFriendlyUIActive();
    if (Context.bFriendlyUI)
    {
        LogoffDialogID = IDD_LOG_OFF_FANCY;
    }
 
    DialogBoxParamW(shell32_hInstance,
                    MAKEINTRESOURCEW(LogoffDialogID),
                    parent,
                    LogOffDialogProc,
                    (LPARAM)&Context);
    return 0;
}

Referenced by CTrayWindow::HandleCommand(), and StartMenuHandler::ShowLogoffDialog().

NoIconsInFile()

static void NoIconsInFile ( HWND  hwndDlg, PPICK_ICON_CONTEXT  pIconContext  )

static

Definition at line 167 of file dialogs.cpp.

{
    // Show an error message
    CStringW strText, strTitle(MAKEINTRESOURCEW(IDS_PICK_ICON_TITLE));
    strText.Format(IDS_NO_ICONS, pIconContext->szPath);
    MessageBoxW(hwndDlg, strText, strTitle, MB_ICONWARNING);
 
    // Load the default icons
    DoLoadIcons(hwndDlg, pIconContext, g_pszShell32);
}

Referenced by PickIconProc().

OwnerDrawButtonSubclass()

INT_PTR CALLBACK OwnerDrawButtonSubclass	(	HWND	hButton,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1214 of file dialogs.cpp.

{
    PLOGOFF_DLG_CONTEXT pContext;
    pContext = (PLOGOFF_DLG_CONTEXT)GetWindowLongPtrW(GetParent(hButton), GWLP_USERDATA);
 
    int buttonID = GetDlgCtrlID(hButton);
 
    switch (uMsg)
    {
        case WM_MOUSEMOVE:
        {
            HWND hwndTarget = NULL;
            POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};;
 
            if (GetCapture() != hButton)
            {
                SetCapture(hButton);
 
                switch (buttonID)
                {
                    case IDC_LOG_OFF_BUTTON:
                    {
                        pContext->bIsButtonHot[LOG_OFF_BUTTON_HOT] = TRUE;
                        break;
                    }
                    case IDC_SWITCH_USER_BUTTON:
                    {
                        pContext->bIsButtonHot[SWITCH_USER_BUTTON_HOT] = TRUE;
                        break;
                    }
                }
                SetCursor(LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_HAND)));
            }
 
            ClientToScreen(hButton, &pt);
            hwndTarget = WindowFromPoint(pt);
 
            if (hwndTarget != hButton)
            {
                ReleaseCapture();
 
                switch (buttonID)
                {
                    case IDC_LOG_OFF_BUTTON:
                    {
                        pContext->bIsButtonHot[LOG_OFF_BUTTON_HOT] = FALSE;
                        break;
                    }
                    case IDC_SWITCH_USER_BUTTON:
                    {
                        pContext->bIsButtonHot[SWITCH_USER_BUTTON_HOT] = FALSE;
                        break;
                    }
                }
            }
            InvalidateRect(hButton, NULL, FALSE);
            break;
        }
 
        /* Whenever one of the buttons gets the keyboard focus, set it as default button */
        case WM_SETFOCUS:
        {
            SendMessageW(GetParent(hButton), DM_SETDEFID, buttonID, 0);
            break;
        }
 
        /* Otherwise, set IDCANCEL as default button */
        case WM_KILLFOCUS:
        {
            SendMessageW(GetParent(hButton), DM_SETDEFID, IDCANCEL, 0);
            break;
        }
    }
    return CallWindowProcW(pContext->OldButtonProc, hButton, uMsg, wParam, lParam);
}

Referenced by FancyLogoffOnInit().

PickIconDlg()

BOOL WINAPI PickIconDlg	(	HWND	hWndOwner,
		LPWSTR	lpstrFile,
		UINT	nMaxFile,
		INT *	lpdwIconIndex
	)

Definition at line 362 of file dialogs.cpp.

{
    int res;
    WCHAR szExpandedPath[MAX_PATH];
 
    // Initialize the dialog
    PICK_ICON_CONTEXT IconContext = { NULL };
    IconContext.Index = *lpdwIconIndex;
    StringCchCopyW(IconContext.szPath, _countof(IconContext.szPath), lpstrFile);
    ExpandEnvironmentStringsW(lpstrFile, szExpandedPath, _countof(szExpandedPath));
 
    if (!szExpandedPath[0] ||
        GetFileAttributesW(szExpandedPath) == INVALID_FILE_ATTRIBUTES)
    {
        if (szExpandedPath[0])
        {
            // No such file
            CStringW strText, strTitle(MAKEINTRESOURCEW(IDS_PICK_ICON_TITLE));
            strText.Format(IDS_FILE_NOT_FOUND, lpstrFile);
            MessageBoxW(hWndOwner, strText, strTitle, MB_ICONWARNING);
        }
 
        // Set the default value
        StringCchCopyW(IconContext.szPath, _countof(IconContext.szPath), g_pszShell32);
    }
 
    // Show the dialog
    res = DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_PICK_ICON), hWndOwner, PickIconProc, (LPARAM)&IconContext);
    if (res)
    {
        // Store the selected icon
        StringCchCopyW(lpstrFile, nMaxFile, IconContext.szPath);
        *lpdwIconIndex = IconContext.Index;
    }
 
    return res;
}

Referenced by DesktopPageProc(), EditTypeDlg_OnChangeIcon(), CShellLink::OnCommand(), and CFileDefExt::OnFolderCustChangeIcon().

PickIconProc()

INT_PTR CALLBACK PickIconProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 186 of file dialogs.cpp.

{
    LPMEASUREITEMSTRUCT lpmis;
    LPDRAWITEMSTRUCT lpdis;
    HICON hIcon;
    INT index, count;
    WCHAR szText[MAX_PATH], szFilter[100];
    CStringW strTitle;
    OPENFILENAMEW ofn;
 
    PPICK_ICON_CONTEXT pIconContext = (PPICK_ICON_CONTEXT)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch(uMsg)
    {
        case WM_INITDIALOG:
        {
            pIconContext = (PPICK_ICON_CONTEXT)lParam;
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pIconContext);
            pIconContext->hDlgCtrl = GetDlgItem(hwndDlg, IDC_PICKICON_LIST);
 
            SendMessageW(pIconContext->hDlgCtrl, LB_SETCOLUMNWIDTH, CX_ITEM, 0);
 
            // Load the icons
            if (!DoLoadIcons(hwndDlg, pIconContext, pIconContext->szPath))
                NoIconsInFile(hwndDlg, pIconContext);
 
            // Set the selection
            count = SendMessageW(pIconContext->hDlgCtrl, LB_GETCOUNT, 0, 0);
            if (count != LB_ERR)
            {
                if (pIconContext->Index < 0)
                {
                    // A negative value will be interpreted as a negated resource ID.
                    LPARAM lParam = -pIconContext->Index;
                    pIconContext->Index = (INT)SendMessageW(pIconContext->hDlgCtrl, LB_FINDSTRINGEXACT, -1, lParam);
                }
 
                if (pIconContext->Index < 0 || count <= pIconContext->Index)
                    pIconContext->Index = 0;
 
                SendMessageW(pIconContext->hDlgCtrl, LB_SETCURSEL, pIconContext->Index, 0);
                SendMessageW(pIconContext->hDlgCtrl, LB_SETTOPINDEX, pIconContext->Index, 0);
            }
 
            SHAutoComplete(GetDlgItem(hwndDlg, IDC_EDIT_PATH), SHACF_DEFAULT);
            return TRUE;
        }
 
        case WM_DESTROY:
        {
            DestroyIconList(pIconContext->hDlgCtrl, pIconContext);
            delete[] pIconContext->phIcons;
 
            if (pIconContext->hLibrary)
                FreeLibrary(pIconContext->hLibrary);
            break;
        }
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
            case IDOK:
            {
                /* Check whether the path edit control has been modified; if so load the icons instead of validating */
                if (SendDlgItemMessage(hwndDlg, IDC_EDIT_PATH, EM_GETMODIFY, 0, 0))
                {
                    /* Reset the edit control's modification flag and retrieve the text */
                    SendDlgItemMessage(hwndDlg, IDC_EDIT_PATH, EM_SETMODIFY, FALSE, 0);
                    GetDlgItemTextW(hwndDlg, IDC_EDIT_PATH, szText, _countof(szText));
 
                    // Load the icons
                    if (!DoLoadIcons(hwndDlg, pIconContext, szText))
                        NoIconsInFile(hwndDlg, pIconContext);
 
                    // Set the selection
                    SendMessageW(pIconContext->hDlgCtrl, LB_SETCURSEL, 0, 0);
                    break;
                }
 
                /* The path edit control has not been modified, return the selection */
                pIconContext->Index = (INT)SendMessageW(pIconContext->hDlgCtrl, LB_GETCURSEL, 0, 0);
                GetDlgItemTextW(hwndDlg, IDC_EDIT_PATH, pIconContext->szPath, _countof(pIconContext->szPath));
                EndDialog(hwndDlg, 1);
                break;
            }
 
            case IDCANCEL:
                EndDialog(hwndDlg, 0);
                break;
 
            case IDC_PICKICON_LIST:
                switch (HIWORD(wParam))
                {
                    case LBN_SELCHANGE:
                        InvalidateRect((HWND)lParam, NULL, TRUE);
                        break;
 
                    case LBN_DBLCLK:
                        SendMessage(hwndDlg, WM_COMMAND, MAKEWPARAM(IDOK, 0), 0);
                        break;
                }
                break;
 
            case IDC_BUTTON_PATH:
            {
                // Choose the module path
                szText[0] = 0;
                szFilter[0] = 0;
                ZeroMemory(&ofn, sizeof(ofn));
                ofn.lStructSize = sizeof(ofn);
                ofn.hwndOwner = hwndDlg;
                ofn.lpstrFile = szText;
                ofn.nMaxFile = _countof(szText);
                strTitle.LoadString(IDS_PICK_ICON_TITLE);
                ofn.lpstrTitle = strTitle;
                LoadStringW(shell32_hInstance, IDS_PICK_ICON_FILTER, szFilter, _countof(szFilter));
                ofn.lpstrFilter = szFilter;
                if (!GetOpenFileNameW(&ofn))
                    break;
 
                // Load the icons
                if (!DoLoadIcons(hwndDlg, pIconContext, szText))
                    NoIconsInFile(hwndDlg, pIconContext);
 
                // Set the selection
                SendMessageW(pIconContext->hDlgCtrl, LB_SETCURSEL, 0, 0);
                break;
            }
 
            default:
                break;
            }
            break;
 
        case WM_MEASUREITEM:
            lpmis = (LPMEASUREITEMSTRUCT)lParam;
            lpmis->itemHeight = CY_ITEM;
            return TRUE;
 
        case WM_DRAWITEM:
        {
            lpdis = (LPDRAWITEMSTRUCT)lParam;
            if (lpdis->itemID == (UINT)-1)
                break;
            switch (lpdis->itemAction)
            {
                case ODA_SELECT:
                case ODA_DRAWENTIRE:
                {
                    index = SendMessageW(pIconContext->hDlgCtrl, LB_GETCURSEL, 0, 0);
                    hIcon = pIconContext->phIcons[lpdis->itemID];
 
                    if (lpdis->itemID == (UINT)index)
                        FillRect(lpdis->hDC, &lpdis->rcItem, (HBRUSH)(COLOR_HIGHLIGHT + 1));
                    else
                        FillRect(lpdis->hDC, &lpdis->rcItem, (HBRUSH)(COLOR_WINDOW + 1));
 
                    // Centering
                    INT x = lpdis->rcItem.left + (CX_ITEM - CX_ICON) / 2;
                    INT y = lpdis->rcItem.top + (CY_ITEM - CY_ICON) / 2;
 
                    DrawIconEx(lpdis->hDC, x, y, hIcon, 0, 0, 0, NULL, DI_NORMAL);
                    break;
                }
            }
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by PickIconDlg().

RestartDialog()

int WINAPI RestartDialog	(	HWND	hWndOwner,
		LPCWSTR	lpstrReason,
		DWORD	uFlags
	)

Definition at line 1573 of file dialogs.cpp.

{
    return RestartDialogEx(hWndOwner, lpstrReason, uFlags, 0);
}

RestartDialogEx()

int WINAPI RestartDialogEx	(	HWND	hWndOwner,
		LPCWSTR	lpwstrReason,
		DWORD	uFlags,
		DWORD	uReason
	)

Definition at line 1082 of file dialogs.cpp.

{
    TRACE("(%p)\n", hWndOwner);
 
    CComPtr<IUnknown> fadeHandler;
    HWND parent;
 
    if (!CallShellDimScreen(&fadeHandler, &parent))
        parent = hWndOwner;
 
    /* FIXME: use lpwstrReason */
    if (ConfirmDialog(parent, IDS_RESTART_PROMPT, IDS_RESTART_TITLE))
    {
        EnablePrivilege(L"SeShutdownPrivilege", TRUE);
        ExitWindowsEx(EWX_REBOOT, uReason);
        EnablePrivilege(L"SeShutdownPrivilege", FALSE);
    }
 
    return 0;
}

Referenced by RestartDialog().

RunDlg_GetParentDir()

static LPWSTR RunDlg_GetParentDir ( LPCWSTR  cmdline )

static

Definition at line 432 of file dialogs.cpp.

{
    const WCHAR *src;
    WCHAR *dest, *result, *result_end=NULL;
 
    result = (WCHAR *)HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(strlenW(cmdline)+5));
 
    if (NULL == result)
    {
        TRACE("HeapAlloc couldn't allocate %d bytes\n", sizeof(WCHAR)*(strlenW(cmdline)+5));
        return NULL;
    }
 
    src = cmdline;
    dest = result;
 
    if (*src == '"')
    {
        src++;
        while (*src && *src != '"')
        {
            if (*src == '\\')
                result_end = dest;
            *dest++ = *src++;
        }
    }
    else {
        while (*src)
        {
            if (isspaceW(*src))
            {
                *dest = 0;
                if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
                    break;
                strcatW(dest, L".exe");
                if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
                    break;
            }
            else if (*src == '\\')
                result_end = dest;
            *dest++ = *src++;
        }
    }
 
    if (result_end)
    {
        *result_end = 0;
        return result;
    }
    else
    {
        HeapFree(GetProcessHeap(), 0, result);
        return NULL;
    }
}

Referenced by RunDlgProc().

RunDlgProc()

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

static

Definition at line 511 of file dialogs.cpp.

{
    RUNFILEDLGPARAMS *prfdp = (RUNFILEDLGPARAMS *)GetWindowLongPtrW(hwnd, DWLP_USER);
    HWND hwndCombo, hwndEdit;
    COMBOBOXINFO ComboInfo;
 
    switch (message)
    {
        case WM_INITDIALOG:
            prfdp = (RUNFILEDLGPARAMS *)lParam;
            SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR)prfdp);
 
            if (prfdp->lpstrTitle)
                SetWindowTextW(hwnd, prfdp->lpstrTitle);
            if (prfdp->lpstrDescription)
                SetWindowTextW(GetDlgItem(hwnd, IDC_RUNDLG_DESCRIPTION), prfdp->lpstrDescription);
            if (prfdp->uFlags & RFF_NOBROWSE)
            {
                HWND browse = GetDlgItem(hwnd, IDC_RUNDLG_BROWSE);
                ShowWindow(browse, SW_HIDE);
                EnableWindow(browse, FALSE);
            }
            if (prfdp->uFlags & RFF_NOLABEL)
                ShowWindow(GetDlgItem(hwnd, IDC_RUNDLG_LABEL), SW_HIDE);
            if (prfdp->uFlags & RFF_NOSEPARATEMEM)
            {
                FIXME("RFF_NOSEPARATEMEM not supported\n");
            }
 
            /* Use the default Shell Run icon if no one is specified */
            if (prfdp->hIcon == NULL)
                prfdp->hIcon = LoadIconW(shell32_hInstance, MAKEINTRESOURCEW(IDI_SHELL_RUN));
            /*
             * NOTE: Starting Windows Vista, the "Run File" dialog gets a
             * title icon that remains the same as the default one, even if
             * the user specifies a custom icon.
             * Since we currently imitate Windows 2003, therefore do not show
             * any title icon.
             */
            // SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)prfdp->hIcon);
            // SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)prfdp->hIcon);
            SendMessageW(GetDlgItem(hwnd, IDC_RUNDLG_ICON), STM_SETICON, (WPARAM)prfdp->hIcon, 0);
 
            hwndCombo = GetDlgItem(hwnd, IDC_RUNDLG_EDITPATH);
            FillList(hwndCombo, NULL, 0, (prfdp->uFlags & RFF_NODEFAULT) == 0);
            EnableOkButtonFromEditContents(hwnd);
 
            ComboInfo.cbSize = sizeof(ComboInfo);
            GetComboBoxInfo(hwndCombo, &ComboInfo);
            hwndEdit = ComboInfo.hwndItem;
            ASSERT(::IsWindow(hwndEdit));
 
            // SHAutoComplete needs co init
            prfdp->bCoInited = SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
 
            SHAutoComplete(hwndEdit, SHACF_FILESYSTEM | SHACF_FILESYS_ONLY | SHACF_URLALL);
 
            SetFocus(hwndCombo);
            return TRUE;
 
        case WM_DESTROY:
            if (prfdp->bCoInited)
                CoUninitialize();
            break;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDOK:
                {
                    LRESULT lRet;
                    HWND htxt = GetDlgItem(hwnd, IDC_RUNDLG_EDITPATH);
                    INT ic;
                    WCHAR *psz, *pszExpanded, *parent = NULL;
                    DWORD cchExpand;
                    SHELLEXECUTEINFOW sei;
                    NMRUNFILEDLGW nmrfd;
 
                    ic = GetWindowTextLengthW(htxt);
                    if (ic == 0)
                    {
                        EndDialog(hwnd, IDCANCEL);
                        return TRUE;
                    }
 
                    ZeroMemory(&sei, sizeof(sei));
                    sei.cbSize = sizeof(sei);
 
                    /*
                     * Allocate a new MRU entry, we need to add two characters
                     * for the terminating "\\1" part, then the NULL character.
                     */
                    psz = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (ic + 2 + 1)*sizeof(WCHAR));
                    if (!psz)
                    {
                        EndDialog(hwnd, IDCANCEL);
                        return TRUE;
                    }
 
                    GetWindowTextW(htxt, psz, ic + 1);
                    sei.hwnd = hwnd;
                    sei.nShow = SW_SHOWNORMAL;
                    sei.lpFile = psz;
                    StrTrimW(psz, L" \t");
 
                    if (wcschr(psz, L'%') != NULL)
                    {
                        cchExpand = ExpandEnvironmentStringsW(psz, NULL, 0);
                        pszExpanded = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, cchExpand * sizeof(WCHAR));
                        if (!pszExpanded)
                        {
                            HeapFree(GetProcessHeap(), 0, psz);
                            EndDialog(hwnd, IDCANCEL);
                            return TRUE;
                        }
                        ExpandEnvironmentStringsW(psz, pszExpanded, cchExpand);
                        StrTrimW(pszExpanded, L" \t");
                    }
                    else
                    {
                        pszExpanded = psz;
                    }
 
                    /*
                     * The precedence is the following: first the user-given
                     * current directory is used; if there is none, a current
                     * directory is computed if the RFF_CALCDIRECTORY is set,
                     * otherwise no current directory is defined.
                     */
                    LPCWSTR pszStartDir;
                    if (prfdp->lpstrDirectory)
                    {
                        sei.lpDirectory = prfdp->lpstrDirectory;
                        pszStartDir = prfdp->lpstrDirectory;
                    }
                    else if (prfdp->uFlags & RFF_CALCDIRECTORY)
                    {
                        sei.lpDirectory = parent = RunDlg_GetParentDir(sei.lpFile);
                        pszStartDir = parent = RunDlg_GetParentDir(pszExpanded);
                    }
                    else
                    {
                        sei.lpDirectory = NULL;
                        pszStartDir = NULL;
                    }
 
                    /* Hide the dialog for now on, we will show it up in case of retry */
                    ShowWindow(hwnd, SW_HIDE);
 
                    /*
                     * As shown by manual tests on Windows, modifying the contents
                     * of the notification structure will not modify what the
                     * Run-Dialog will use for the nShow parameter. However the
                     * lpFile and lpDirectory pointers are set to the buffers used
                     * by the Run-Dialog, as a consequence they can be modified by
                     * the notification receiver, as long as it respects the lengths
                     * of the buffers (to avoid buffer overflows).
                     */
                    nmrfd.hdr.code = RFN_VALIDATE;
                    nmrfd.hdr.hwndFrom = hwnd;
                    nmrfd.hdr.idFrom = 0;
                    nmrfd.lpFile = pszExpanded;
                    nmrfd.lpDirectory = pszStartDir;
                    nmrfd.nShow = SW_SHOWNORMAL;
 
                    lRet = SendMessageW(prfdp->hwndOwner, WM_NOTIFY, 0, (LPARAM)&nmrfd.hdr);
 
                    switch (lRet)
                    {
                        case RF_CANCEL:
                            EndDialog(hwnd, IDCANCEL);
                            break;
 
                        case RF_OK:
                            /* We use SECL_NO_UI because we don't want to see
                             * errors here, but we will try again below and
                             * there we will output our errors. */
                            if (SUCCEEDED(ShellExecCmdLine(hwnd, pszExpanded, pszStartDir, SW_SHOWNORMAL, NULL,
                                                           SECL_ALLOW_NONEXE | SECL_NO_UI)))
                            {
                                /* Call GetWindowText again in case the contents of the edit box have changed. */
                                GetWindowTextW(htxt, psz, ic + 1);
                                FillList(htxt, psz, ic + 2 + 1, FALSE);
                                EndDialog(hwnd, IDOK);
                                break;
                            }
                            else if (SUCCEEDED(ShellExecuteExW(&sei)))
                            {
                                /* Call GetWindowText again in case the contents of the edit box have changed. */
                                GetWindowTextW(htxt, psz, ic + 1);
                                FillList(htxt, psz, ic + 2 + 1, FALSE);
                                EndDialog(hwnd, IDOK);
                                break;
                            }
 
                        /* Fall-back */
                        case RF_RETRY:
                        default:
                            SendMessageW(htxt, CB_SETEDITSEL, 0, MAKELPARAM (0, -1));
                            /* Show back the dialog */
                            ShowWindow(hwnd, SW_SHOW);
                            break;
                    }
 
                    HeapFree(GetProcessHeap(), 0, parent);
                    HeapFree(GetProcessHeap(), 0, psz);
                    if (psz != pszExpanded)
                        HeapFree(GetProcessHeap(), 0, pszExpanded);
                    return TRUE;
                }
 
                case IDCANCEL:
                    EndDialog(hwnd, IDCANCEL);
                    return TRUE;
 
                case IDC_RUNDLG_BROWSE:
                {
                    HMODULE hComdlg = NULL;
                    LPFNOFN ofnProc = NULL;
                    WCHAR szFName[1024] = {0};
                    WCHAR filter[MAX_PATH], szCaption[MAX_PATH];
                    OPENFILENAMEW ofn;
 
                    LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_FILTER, filter, _countof(filter));
                    LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_CAPTION, szCaption, _countof(szCaption));
 
                    ZeroMemory(&ofn, sizeof(ofn));
                    ofn.lStructSize = sizeof(ofn);
                    ofn.hwndOwner = hwnd;
                    ofn.lpstrFilter = filter;
                    ofn.lpstrFile = szFName;
                    ofn.nMaxFile = _countof(szFName) - 1;
                    ofn.lpstrTitle = szCaption;
                    ofn.Flags = OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_EXPLORER;
                    ofn.lpstrInitialDir = prfdp->lpstrDirectory;
 
                    if (NULL == (hComdlg = LoadLibraryExW(L"comdlg32", NULL, 0)) ||
                        NULL == (ofnProc = (LPFNOFN)GetProcAddress(hComdlg, "GetOpenFileNameW")))
                    {
                        ERR("Couldn't get GetOpenFileName function entry (lib=%p, proc=%p)\n", hComdlg, ofnProc);
                        ShellMessageBoxW(shell32_hInstance, hwnd, MAKEINTRESOURCEW(IDS_RUNDLG_BROWSE_ERROR), NULL, MB_OK | MB_ICONERROR);
                        return TRUE;
                    }
 
                    if (ofnProc(&ofn))
                    {
                        SetFocus(GetDlgItem(hwnd, IDOK));
                        SetWindowTextW(GetDlgItem(hwnd, IDC_RUNDLG_EDITPATH), szFName);
                        SendMessageW(GetDlgItem(hwnd, IDC_RUNDLG_EDITPATH), CB_SETEDITSEL, 0, MAKELPARAM(0, -1));
                        EnableOkButtonFromEditContents(hwnd);
                        SetFocus(GetDlgItem(hwnd, IDOK));
                    }
 
                    FreeLibrary(hComdlg);
 
                    return TRUE;
                }
                case IDC_RUNDLG_EDITPATH:
                {
                    if (HIWORD(wParam) == CBN_EDITCHANGE)
                    {
                        EnableOkButtonFromEditContents(hwnd);
                    }
                    return TRUE;
                }
            }
            return TRUE;
    }
    return FALSE;
}

Referenced by RunFileDlg().

RunFileDlg()

void WINAPI RunFileDlg	(	HWND	hWndOwner,
		HICON	hIcon,
		LPCWSTR	lpstrDirectory,
		LPCWSTR	lpstrTitle,
		LPCWSTR	lpstrDescription,
		UINT	uFlags
	)

Definition at line 409 of file dialogs.cpp.

{
    TRACE("\n");
 
    RUNFILEDLGPARAMS rfdp;
    rfdp.hwndOwner        = hWndOwner;
    rfdp.hIcon            = hIcon;
    rfdp.lpstrDirectory   = lpstrDirectory;
    rfdp.lpstrTitle       = lpstrTitle;
    rfdp.lpstrDescription = lpstrDescription;
    rfdp.uFlags           = uFlags;
 
    DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_RUN), hWndOwner, RunDlgProc, (LPARAM)&rfdp);
}

Referenced by RunDialogThread::Run(), CTrayWindow::RunFileDlgThread(), and TaskManager_OnFileNew().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)