1 /*
2 * common shell dialogs
3 *
4 * Copyright 2000 Juergen Schmied
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <string.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include "winerror.h"
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winreg.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "commdlg.h"
34 #include "wine/debug.h"
35
36 #include "shellapi.h"
37 #include "shlobj.h"
38 #include "shell32_main.h"
39 #include "shresdef.h"
40 #include "undocshell.h"
41
42 typedef struct
43 {
44 HWND hwndOwner ;
45 HICON hIcon ;
46 LPCWSTR lpstrDirectory ;
47 LPCWSTR lpstrTitle ;
48 LPCWSTR lpstrDescription ;
49 UINT uFlags ;
50 } RUNFILEDLGPARAMS ;
51
52 typedef BOOL (WINAPI * LPFNOFN) (OPENFILENAMEW *) ;
53
54 WINE_DEFAULT_DEBUG_CHANNEL(shell);
55 static INT_PTR CALLBACK RunDlgProc (HWND, UINT, WPARAM, LPARAM) ;
56 static void FillList (HWND, char *, BOOL) ;
57
58
59 /*************************************************************************
60 * PickIconDlg [SHELL32.62]
61 *
62 */
63 BOOL WINAPI PickIconDlg(
64 HWND hwndOwner,
65 LPSTR lpstrFile,
66 DWORD nMaxFile,
67 LPDWORD lpdwIconIndex)
68 {
69 FIXME("(%p,%s,%08x,%p):stub.\n",
70 hwndOwner, lpstrFile, nMaxFile,lpdwIconIndex);
71 return 0xffffffff;
72 }
73
74 /*************************************************************************
75 * RunFileDlgW [internal]
76 *
77 * The Unicode function that is available as ordinal 61 on Windows NT/2000/XP/...
78 *
79 * SEE ALSO
80 * RunFileDlgAW
81 */
82 static void RunFileDlgW(
83 HWND hwndOwner,
84 HICON hIcon,
85 LPCWSTR lpstrDirectory,
86 LPCWSTR lpstrTitle,
87 LPCWSTR lpstrDescription,
88 UINT uFlags)
89 {
90 static const WCHAR resnameW[] = {'S','H','E','L','L','_','R','U','N','_','D','L','G',0};
91 RUNFILEDLGPARAMS rfdp;
92 HRSRC hRes;
93 LPVOID template;
94 TRACE("\n");
95
96 rfdp.hwndOwner = hwndOwner;
97 rfdp.hIcon = hIcon;
98 rfdp.lpstrDirectory = lpstrDirectory;
99 rfdp.lpstrTitle = lpstrTitle;
100 rfdp.lpstrDescription = lpstrDescription;
101 rfdp.uFlags = uFlags;
102
103 if (!(hRes = FindResourceW(shell32_hInstance, resnameW, (LPWSTR)RT_DIALOG)) ||
104 !(template = LoadResource(shell32_hInstance, hRes)))
105 {
106 ERR("Couldn't load SHELL_RUN_DLG resource\n");
107 ShellMessageBoxW(shell32_hInstance, hwndOwner, MAKEINTRESOURCEW(IDS_RUNDLG_ERROR), NULL, MB_OK | MB_ICONERROR);
108 return;
109 }
110
111 DialogBoxIndirectParamW(shell32_hInstance,
112 template, hwndOwner, RunDlgProc, (LPARAM)&rfdp);
113
114 }
115
116 /* find the directory that contains the file being run */
117 static LPWSTR RunDlg_GetParentDir(LPCWSTR cmdline)
118 {
119 const WCHAR *src;
120 WCHAR *dest, *result, *result_end=NULL;
121 static const WCHAR dotexeW[] = {'.','e','x','e',0};
122
123 result = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(strlenW(cmdline)+5));
124
125 src = cmdline;
126 dest = result;
127
128 if (*src == '"')
129 {
130 src++;
131 while (*src && *src != '"')
132 {
133 if (*src == '\\')
134 result_end = dest;
135 *dest++ = *src++;
136 }
137 }
138 else {
139 while (*src)
140 {
141 if (isspaceW(*src))
142 {
143 *dest = 0;
144 if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
145 break;
146 strcatW(dest, dotexeW);
147 if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
148 break;
149 }
150 else if (*src == '\\')
151 result_end = dest;
152 *dest++ = *src++;
153 }
154 }
155
156 if (result_end)
157 {
158 *result_end = 0;
159 return result;
160 }
161 else
162 {
163 HeapFree(GetProcessHeap(), 0, result);
164 return NULL;
165 }
166 }
167
168 /* Dialog procedure for RunFileDlg */
169 static INT_PTR CALLBACK RunDlgProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
170 {
171 RUNFILEDLGPARAMS *prfdp = (RUNFILEDLGPARAMS *)GetWindowLongPtrW(hwnd, DWLP_USER);
172
173 switch (message)
174 {
175 case WM_INITDIALOG :
176 prfdp = (RUNFILEDLGPARAMS *)lParam ;
177 SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR)prfdp);
178
179 if (prfdp->lpstrTitle)
180 SetWindowTextW(hwnd, prfdp->lpstrTitle);
181 if (prfdp->lpstrDescription)
182 SetWindowTextW(GetDlgItem(hwnd, IDC_RUNDLG_DESCRIPTION), prfdp->lpstrDescription);
183 if (prfdp->uFlags & RFF_NOBROWSE)
184 {
185 HWND browse = GetDlgItem(hwnd, IDC_RUNDLG_BROWSE);
186 ShowWindow(browse, SW_HIDE);
187 EnableWindow(browse, FALSE);
188 }
189 if (prfdp->uFlags & RFF_NOLABEL)
190 ShowWindow(GetDlgItem(hwnd, IDC_RUNDLG_LABEL), SW_HIDE);
191 if (prfdp->uFlags & RFF_CALCDIRECTORY)
192 FIXME("RFF_CALCDIRECTORY not supported\n");
193
194 if (prfdp->hIcon == NULL)
195 prfdp->hIcon = LoadIconW(NULL, (LPCWSTR)IDI_WINLOGO);
196 SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)prfdp->hIcon);
197 SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)prfdp->hIcon);
198 SendMessageW(GetDlgItem(hwnd, IDC_RUNDLG_ICON), STM_SETICON, (WPARAM)prfdp->hIcon, 0);
199
200 FillList (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), NULL, (prfdp->uFlags & RFF_NODEFAULT) == 0) ;
201 SetFocus (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH)) ;
202 return TRUE ;
203
204 case WM_COMMAND :
205 switch (LOWORD (wParam))
206 {
207 case IDOK :
208 {
209 int ic ;
210 HWND htxt = GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH);
211 if ((ic = GetWindowTextLengthW (htxt)))
212 {
213 WCHAR *psz, *parent=NULL ;
214 SHELLEXECUTEINFOW sei ;
215
216 ZeroMemory (&sei, sizeof(sei)) ;
217 sei.cbSize = sizeof(sei) ;
218 psz = HeapAlloc( GetProcessHeap(), 0, (ic + 1)*sizeof(WCHAR) );
219 GetWindowTextW (htxt, psz, ic + 1) ;
220
221 /* according to http://www.codeproject.com/KB/shell/runfiledlg.aspx we should send a
222 * WM_NOTIFY before execution */
223
224 sei.hwnd = hwnd;
225 sei.nShow = SW_SHOWNORMAL;
226 sei.lpFile = psz;
227
228 if (prfdp->lpstrDirectory)
229 sei.lpDirectory = prfdp->lpstrDirectory;
230 else
231 sei.lpDirectory = parent = RunDlg_GetParentDir(sei.lpFile);
232
233 if (!ShellExecuteExW( &sei ))
234 {
235 HeapFree(GetProcessHeap(), 0, psz);
236 HeapFree(GetProcessHeap(), 0, parent);
237 SendMessageA (htxt, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
238 return TRUE ;
239 }
240
241 /* FillList is still ANSI */
242 GetWindowTextA (htxt, (LPSTR)psz, ic + 1) ;
243 FillList (htxt, (LPSTR)psz, FALSE) ;
244
245 HeapFree(GetProcessHeap(), 0, psz);
246 HeapFree(GetProcessHeap(), 0, parent);
247 EndDialog (hwnd, 0);
248 }
249 }
250
251 case IDCANCEL :
252 EndDialog (hwnd, 0) ;
253 return TRUE ;
254
255 case IDC_RUNDLG_BROWSE :
256 {
257 HMODULE hComdlg = NULL ;
258 LPFNOFN ofnProc = NULL ;
259 static const WCHAR comdlg32W[] = {'c','o','m','d','l','g','3','2',0};
260 WCHAR szFName[1024] = {0};
261 WCHAR *pszFilter, szCaption[MAX_PATH];
262 OPENFILENAMEW ofn;
263
264 LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_FILTER, (LPWSTR)&pszFilter, 0);
265 LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_CAPTION, szCaption, MAX_PATH);
266
267 ZeroMemory(&ofn, sizeof(ofn));
268 ofn.lStructSize = sizeof(OPENFILENAMEW);
269 ofn.hwndOwner = hwnd;
270 ofn.lpstrFilter = pszFilter;
271 ofn.lpstrFile = szFName;
272 ofn.nMaxFile = 1023;
273 ofn.lpstrTitle = szCaption;
274 ofn.Flags = OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
275 ofn.lpstrInitialDir = prfdp->lpstrDirectory;
276
277 if (NULL == (hComdlg = LoadLibraryExW (comdlg32W, NULL, 0)) ||
278 NULL == (ofnProc = (LPFNOFN)GetProcAddress (hComdlg, "GetOpenFileNameW")))
279 {
280 ERR("Couldn't get GetOpenFileName function entry (lib=%p, proc=%p)\n", hComdlg, ofnProc);
281 ShellMessageBoxW(shell32_hInstance, hwnd, MAKEINTRESOURCEW(IDS_RUNDLG_BROWSE_ERROR), NULL, MB_OK | MB_ICONERROR);
282 return TRUE ;
283 }
284
285 if (ofnProc(&ofn))
286 {
287 SetFocus (GetDlgItem (hwnd, IDOK)) ;
288 SetWindowTextW (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), szFName) ;
289 SendMessageW (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
290 SetFocus (GetDlgItem (hwnd, IDOK)) ;
291 }
292
293 FreeLibrary (hComdlg) ;
294
295 return TRUE ;
296 }
297 }
298 return TRUE ;
299 }
300 return FALSE ;
301 }
302
303 /* This grabs the MRU list from the registry and fills the combo for the "Run" dialog above */
304 /* fShowDefault ignored if pszLatest != NULL */
305 static void FillList (HWND hCb, char *pszLatest, BOOL fShowDefault)
306 {
307 HKEY hkey ;
308 /* char szDbgMsg[256] = "" ; */
309 char *pszList = NULL, *pszCmd = NULL, cMatch = 0, cMax = 0x60, szIndex[2] = "-" ;
310 DWORD icList = 0, icCmd = 0 ;
311 UINT Nix ;
312
313 SendMessageA (hCb, CB_RESETCONTENT, 0, 0) ;
314
315 if (ERROR_SUCCESS != RegCreateKeyExA (
316 HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU",
317 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL))
318 MessageBoxA (hCb, "Unable to open registry key !", "Nix", MB_OK) ;
319
320 RegQueryValueExA (hkey, "MRUList", NULL, NULL, NULL, &icList) ;
321
322 if (icList > 0)
323 {
324 pszList = HeapAlloc( GetProcessHeap(), 0, icList) ;
325 if (ERROR_SUCCESS != RegQueryValueExA (hkey, "MRUList", NULL, NULL, (LPBYTE)pszList, &icList))
326 MessageBoxA (hCb, "Unable to grab MRUList !", "Nix", MB_OK) ;
327 }
328 else
329 {
330 icList = 1 ;
331 pszList = HeapAlloc( GetProcessHeap(), 0, icList) ;
332 pszList[0] = 0 ;
333 }
334
335 for (Nix = 0 ; Nix < icList - 1 ; Nix++)
336 {
337 if (pszList[Nix] > cMax)
338 cMax = pszList[Nix] ;
339
340 szIndex[0] = pszList[Nix] ;
341
342 if (ERROR_SUCCESS != RegQueryValueExA (hkey, szIndex, NULL, NULL, NULL, &icCmd))
343 MessageBoxA (hCb, "Unable to grab size of index", "Nix", MB_OK) ;
344 if( pszCmd )
345 pszCmd = HeapReAlloc(GetProcessHeap(), 0, pszCmd, icCmd) ;
346 else
347 pszCmd = HeapAlloc(GetProcessHeap(), 0, icCmd) ;
348 if (ERROR_SUCCESS != RegQueryValueExA (hkey, szIndex, NULL, NULL, (LPBYTE)pszCmd, &icCmd))
349 MessageBoxA (hCb, "Unable to grab index", "Nix", MB_OK) ;
350
351 if (NULL != pszLatest)
352 {
353 if (!lstrcmpiA(pszCmd, pszLatest))
354 {
355 /*
356 sprintf (szDbgMsg, "Found existing (%d).\n", Nix) ;
357 MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
358 */
359 SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszCmd) ;
360 SetWindowTextA (hCb, pszCmd) ;
361 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
362
363 cMatch = pszList[Nix] ;
364 memmove (&pszList[1], pszList, Nix) ;
365 pszList[0] = cMatch ;
366 continue ;
367 }
368 }
369
370 if (26 != icList - 1 || icList - 2 != Nix || cMatch || NULL == pszLatest)
371 {
372 /*
373 sprintf (szDbgMsg, "Happily appending (%d).\n", Nix) ;
374 MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
375 */
376 SendMessageA (hCb, CB_ADDSTRING, 0, (LPARAM)pszCmd) ;
377 if (!Nix && fShowDefault)
378 {
379 SetWindowTextA (hCb, pszCmd) ;
380 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
381 }
382
383 }
384 else
385 {
386 /*
387 sprintf (szDbgMsg, "Doing loop thing.\n") ;
388 MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
389 */
390 SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest) ;
391 SetWindowTextA (hCb, pszLatest) ;
392 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
393
394 cMatch = pszList[Nix] ;
395 memmove (&pszList[1], pszList, Nix) ;
396 pszList[0] = cMatch ;
397 szIndex[0] = cMatch ;
398 RegSetValueExA (hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, strlen (pszLatest) + 1) ;
399 }
400 }
401
402 if (!cMatch && NULL != pszLatest)
403 {
404 /*
405 sprintf (szDbgMsg, "Simply inserting (increasing list).\n") ;
406 MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
407 */
408 SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest) ;
409 SetWindowTextA (hCb, pszLatest) ;
410 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
411
412 cMatch = ++cMax ;
413 if( pszList )
414 pszList = HeapReAlloc(GetProcessHeap(), 0, pszList, ++icList) ;
415 else
416 pszList = HeapAlloc(GetProcessHeap(), 0, ++icList) ;
417 memmove (&pszList[1], pszList, icList - 1) ;
418 pszList[0] = cMatch ;
419 szIndex[0] = cMatch ;
420 RegSetValueExA (hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, strlen (pszLatest) + 1) ;
421 }
422
423 RegSetValueExA (hkey, "MRUList", 0, REG_SZ, (LPBYTE)pszList, strlen (pszList) + 1) ;
424
425 HeapFree( GetProcessHeap(), 0, pszCmd) ;
426 HeapFree( GetProcessHeap(), 0, pszList) ;
427 }
428
429 /*************************************************************************
430 * RunFileDlgA [internal]
431 *
432 * The ANSI function that is available as ordinal 61 on Windows 9x/Me
433 *
434 * SEE ALSO
435 * RunFileDlgAW
436 */
437 static void RunFileDlgA(
438 HWND hwndOwner,
439 HICON hIcon,
440 LPCSTR lpstrDirectory,
441 LPCSTR lpstrTitle,
442 LPCSTR lpstrDescription,
443 UINT uFlags)
444 {
445 WCHAR title[MAX_PATH]; /* longer string wouldn't be visible in the dialog anyway */
446 WCHAR description[MAX_PATH];
447 WCHAR directory[MAX_PATH];
448
449 MultiByteToWideChar(CP_ACP, 0, lpstrTitle, -1, title, MAX_PATH);
450 title[MAX_PATH - 1] = 0;
451 MultiByteToWideChar(CP_ACP, 0, lpstrDescription, -1, description, MAX_PATH);
452 description[MAX_PATH - 1] = 0;
453 if (!MultiByteToWideChar(CP_ACP, 0, lpstrDirectory, -1, directory, MAX_PATH))
454 directory[0] = 0;
455
456 RunFileDlgW(hwndOwner, hIcon,
457 lpstrDirectory ? directory : NULL,
458 lpstrTitle ? title : NULL,
459 lpstrDescription ? description : NULL,
460 uFlags);
461 }
462
463 /*************************************************************************
464 * RunFileDlgAW [SHELL32.61]
465 *
466 * An undocumented way to open the Run File dialog. A documented way is to use
467 * CLSID_Shell, IID_IShellDispatch (as of Wine 1.0, not implemented under Wine)
468 *
469 * Exported by ordinal. ANSI on Windows 9x and Unicode on Windows NT/2000/XP/etc
470 *
471 */
472 void WINAPI RunFileDlgAW(
473 HWND hwndOwner,
474 HICON hIcon,
475 LPCVOID lpstrDirectory,
476 LPCVOID lpstrTitle,
477 LPCVOID lpstrDescription,
478 UINT uFlags)
479 {
480 if (SHELL_OsIsUnicode())
481 RunFileDlgW(hwndOwner, hIcon, lpstrDirectory, lpstrTitle, lpstrDescription, uFlags);
482 else
483 RunFileDlgA(hwndOwner, hIcon, lpstrDirectory, lpstrTitle, lpstrDescription, uFlags);
484 }
485
486
487 /*************************************************************************
488 * ConfirmDialog [internal]
489 *
490 * Put up a confirm box, return TRUE if the user confirmed
491 */
492 static BOOL ConfirmDialog(HWND hWndOwner, UINT PromptId, UINT TitleId)
493 {
494 WCHAR Prompt[256];
495 WCHAR Title[256];
496
497 LoadStringW(shell32_hInstance, PromptId, Prompt, sizeof(Prompt) / sizeof(WCHAR));
498 LoadStringW(shell32_hInstance, TitleId, Title, sizeof(Title) / sizeof(WCHAR));
499 return MessageBoxW(hWndOwner, Prompt, Title, MB_YESNO|MB_ICONQUESTION) == IDYES;
500 }
501
502
503 /*************************************************************************
504 * RestartDialogEx [SHELL32.730]
505 */
506
507 int WINAPI RestartDialogEx(HWND hWndOwner, LPCWSTR lpwstrReason, DWORD uFlags, DWORD uReason)
508 {
509 TRACE("(%p)\n", hWndOwner);
510
511 /* FIXME: use lpwstrReason */
512 if (ConfirmDialog(hWndOwner, IDS_RESTART_PROMPT, IDS_RESTART_TITLE))
513 {
514 HANDLE hToken;
515 TOKEN_PRIVILEGES npr;
516
517 /* enable the shutdown privilege for the current process */
518 if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
519 {
520 LookupPrivilegeValueA(0, "SeShutdownPrivilege", &npr.Privileges[0].Luid);
521 npr.PrivilegeCount = 1;
522 npr.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
523 AdjustTokenPrivileges(hToken, FALSE, &npr, 0, 0, 0);
524 CloseHandle(hToken);
525 }
526 ExitWindowsEx(EWX_REBOOT, uReason);
527 }
528
529 return 0;
530 }
531
532
533 /*************************************************************************
534 * RestartDialog [SHELL32.59]
535 */
536
537 int WINAPI RestartDialog(HWND hWndOwner, LPCWSTR lpstrReason, DWORD uFlags)
538 {
539 return RestartDialogEx(hWndOwner, lpstrReason, uFlags, 0);
540 }
541
542
543 /*************************************************************************
544 * ExitWindowsDialog [SHELL32.60]
545 *
546 * NOTES
547 * exported by ordinal
548 */
549 void WINAPI ExitWindowsDialog (HWND hWndOwner)
550 {
551 TRACE("(%p)\n", hWndOwner);
552
553 if (ConfirmDialog(hWndOwner, IDS_SHUTDOWN_PROMPT, IDS_SHUTDOWN_TITLE))
554 {
555 HANDLE hToken;
556 TOKEN_PRIVILEGES npr;
557
558 /* enable shutdown privilege for current process */
559 if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
560 {
561 LookupPrivilegeValueA(0, "SeShutdownPrivilege", &npr.Privileges[0].Luid);
562 npr.PrivilegeCount = 1;
563 npr.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
564 AdjustTokenPrivileges(hToken, FALSE, &npr, 0, 0, 0);
565 CloseHandle(hToken);
566 }
567 ExitWindowsEx(EWX_SHUTDOWN, 0);
568 }
569 }
570
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.