wined3d: Check for unread registers in a more logical way in handle_ps3_input().
[wine] / dlls / browseui / progressdlg.c
1 /*
2  *      Progress dialog
3  *
4  *      Copyright 2007  Mikolaj Zalewski
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
23 #include <stdarg.h>
24
25 #define COBJMACROS
26
27 #include "wine/debug.h"
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winreg.h"
31 #include "winuser.h"
32 #include "shlwapi.h"
33 #include "winerror.h"
34 #include "objbase.h"
35
36 #include "shlguid.h"
37 #include "shlobj.h"
38
39 #include "wine/unicode.h"
40
41 #include "browseui.h"
42 #include "resids.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(browseui);
45
46 #define CANCEL_MSG_LINE 2
47
48 /* Note: to avoid a deadlock we don't want to send messages to the dialog
49  * with the critical section held. Instead we only mark what fields should be
50  * updated and the dialog proc does the update */
51 #define UPDATE_PROGRESS         0x1
52 #define UPDATE_TITLE            0x2
53 #define UPDATE_LINE1            0x4
54 #define UPDATE_LINE2            (UPDATE_LINE1<<1)
55 #define UPDATE_LINE3            (UPDATE_LINE2<<2)
56
57
58 #define WM_DLG_UPDATE   (WM_APP+1)  /* set to the dialog when it should update */
59 #define WM_DLG_DESTROY  (WM_APP+2)  /* DestroyWindow must be called from the owning thread */
60
61 typedef struct tagProgressDialog {
62     const IProgressDialogVtbl *vtbl;
63     LONG refCount;
64     CRITICAL_SECTION cs;
65     HWND hwnd;
66     DWORD dwFlags;
67     DWORD dwUpdate;
68     LPWSTR lines[3];
69     LPWSTR cancelMsg;
70     LPWSTR title;
71     BOOL isCancelled;
72     ULONGLONG ullCompleted;
73     ULONGLONG ullTotal;
74     HWND hwndDisabledParent;    /* For modal dialog: the parent that need to be re-enabled when the dialog ends */
75 } ProgressDialog;
76
77 static void set_buffer(LPWSTR *buffer, LPCWSTR string)
78 {
79     static const WCHAR empty_string[] = {0};
80     IMalloc *malloc;
81     ULONG cb;
82
83     if (string == NULL)
84         string = empty_string;
85     CoGetMalloc(1, &malloc);
86
87     cb = (strlenW(string) + 1)*sizeof(WCHAR);
88     if (*buffer == NULL || cb > IMalloc_GetSize(malloc, *buffer))
89         *buffer = IMalloc_Realloc(malloc, *buffer, cb);
90     memcpy(*buffer, string, cb);
91 }
92
93 struct create_params
94 {
95     ProgressDialog *This;
96     HANDLE hEvent;
97     HWND hwndParent;
98 };
99
100 static LPWSTR load_string(HINSTANCE hInstance, UINT uiResourceId)
101 {
102     WCHAR string[256];
103     LPWSTR ret;
104
105     LoadStringW(hInstance, uiResourceId, string, sizeof(string)/sizeof(string[0]));
106     ret = HeapAlloc(GetProcessHeap(), 0, (strlenW(string) + 1) * sizeof(WCHAR));
107     strcpyW(ret, string);
108     return ret;
109 }
110
111 static void set_progress_marquee(ProgressDialog *This)
112 {
113     HWND hProgress = GetDlgItem(This->hwnd, IDC_PROGRESS_BAR);
114     SetWindowLongW(hProgress, GWL_STYLE,
115         GetWindowLongW(hProgress, GWL_STYLE)|PBS_MARQUEE);
116 }
117
118 static void update_dialog(ProgressDialog *This, DWORD dwUpdate)
119 {
120     WCHAR empty[] = {0};
121
122     if (dwUpdate & UPDATE_TITLE)
123         SetWindowTextW(This->hwnd, This->title);
124
125     if (dwUpdate & UPDATE_LINE1)
126         SetDlgItemTextW(This->hwnd, IDC_TEXT_LINE, (This->isCancelled ? empty : This->lines[0]));
127     if (dwUpdate & UPDATE_LINE2)
128         SetDlgItemTextW(This->hwnd, IDC_TEXT_LINE+1, (This->isCancelled ? empty : This->lines[1]));
129     if (dwUpdate & UPDATE_LINE3)
130         SetDlgItemTextW(This->hwnd, IDC_TEXT_LINE+2, (This->isCancelled ? This->cancelMsg : This->lines[2]));
131
132     if (dwUpdate & UPDATE_PROGRESS)
133     {
134         ULONGLONG ullTotal = This->ullTotal;
135         ULONGLONG ullCompleted = This->ullCompleted;
136
137         /* progress bar requires 32-bit coordinates */
138         while (ullTotal >> 32)
139         {
140             ullTotal >>= 1;
141             ullCompleted >>= 1;
142         }
143
144         SendDlgItemMessageW(This->hwnd, IDC_PROGRESS_BAR, PBM_SETRANGE32, 0, (DWORD)ullTotal);
145         SendDlgItemMessageW(This->hwnd, IDC_PROGRESS_BAR, PBM_SETPOS, (DWORD)ullCompleted, 0);
146     }
147 }
148
149 static void end_dialog(ProgressDialog *This)
150 {
151     SendMessageW(This->hwnd, WM_DLG_DESTROY, 0, 0);
152     /* native doesn't reenable the window? */
153     if (This->hwndDisabledParent)
154         EnableWindow(This->hwndDisabledParent, TRUE);
155     This->hwnd = NULL;
156 }
157
158 static INT_PTR CALLBACK dialog_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
159 {
160     ProgressDialog *This = (ProgressDialog *)GetWindowLongPtrW(hwnd, DWLP_USER);
161
162     switch (msg)
163     {
164         case WM_INITDIALOG:
165         {
166             struct create_params *params = (struct create_params *)lParam;
167
168             /* Note: until we set the hEvent, the object is protected by
169              * the critical section held by StartProgress */
170             SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR)params->This);
171             This = params->This;
172             This->hwnd = hwnd;
173
174             if (This->dwFlags & PROGDLG_NOPROGRESSBAR)
175                 ShowWindow(GetDlgItem(hwnd, IDC_PROGRESS_BAR), SW_HIDE);
176             if (This->dwFlags & PROGDLG_NOCANCEL)
177                 ShowWindow(GetDlgItem(hwnd, IDCANCEL), SW_HIDE);
178             if (This->dwFlags & PROGDLG_MARQUEEPROGRESS)
179                 set_progress_marquee(This);
180             if (This->dwFlags & PROGDLG_NOMINIMIZE)
181                 SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) & (~WS_MINIMIZEBOX));
182
183             update_dialog(This, 0xffffffff);
184             This->dwUpdate = 0;
185             This->isCancelled = FALSE;
186             SetEvent(params->hEvent);
187             return TRUE;
188         }
189
190         case WM_DLG_UPDATE:
191             EnterCriticalSection(&This->cs);
192             update_dialog(This, This->dwUpdate);
193             This->dwUpdate = 0;
194             LeaveCriticalSection(&This->cs);
195             return TRUE;
196
197         case WM_DLG_DESTROY:
198             DestroyWindow(hwnd);
199             PostThreadMessageW(GetCurrentThreadId(), WM_NULL, 0, 0); /* wake up the GetMessage */
200             return TRUE;
201
202         case WM_CLOSE:
203         case WM_COMMAND:
204             if (msg == WM_CLOSE || wParam == IDCANCEL)
205             {
206                 EnterCriticalSection(&This->cs);
207                 This->isCancelled = TRUE;
208
209                 if (!This->cancelMsg)
210                     This->cancelMsg = load_string(BROWSEUI_hinstance, IDS_CANCELLING);
211
212                 set_progress_marquee(This);
213                 EnableWindow(GetDlgItem(This->hwnd, IDCANCEL), FALSE);
214                 update_dialog(This, UPDATE_LINE1|UPDATE_LINE2|UPDATE_LINE3);
215                 LeaveCriticalSection(&This->cs);
216             }
217             return TRUE;
218     }
219     return FALSE;
220 }
221
222 static DWORD WINAPI dialog_thread(LPVOID lpParameter)
223 {
224     /* Note: until we set the hEvent in WM_INITDIALOG, the ProgressDialog object
225      * is protected by the critical section held by StartProgress */
226     struct create_params *params = lpParameter;
227     HWND hwnd;
228     MSG msg;
229
230     hwnd = CreateDialogParamW(BROWSEUI_hinstance, MAKEINTRESOURCEW(IDD_PROGRESS_DLG),
231         params->hwndParent, dialog_proc, (LPARAM)params);
232
233     while (GetMessageW(&msg, NULL, 0, 0) > 0)
234     {
235         if (!IsWindow(hwnd))
236             break;
237         if(!IsDialogMessageW(hwnd, &msg))
238         {
239             TranslateMessage(&msg);
240             DispatchMessageW(&msg);
241         }
242     }
243
244     return 0;
245 }
246
247 static void ProgressDialog_Destructor(ProgressDialog *This)
248 {
249     TRACE("destroying %p\n", This);
250     if (This->hwnd)
251         end_dialog(This);
252     heap_free(This->lines[0]);
253     heap_free(This->lines[1]);
254     heap_free(This->lines[2]);
255     heap_free(This->cancelMsg);
256     heap_free(This->title);
257     heap_free(This);
258     BROWSEUI_refCount--;
259 }
260
261 static HRESULT WINAPI ProgressDialog_QueryInterface(IProgressDialog *iface, REFIID iid, LPVOID *ppvOut)
262 {
263     ProgressDialog *This = (ProgressDialog *)iface;
264     *ppvOut = NULL;
265
266     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IProgressDialog))
267     {
268         *ppvOut = This;
269     }
270
271     if (*ppvOut)
272     {
273         IUnknown_AddRef(iface);
274         return S_OK;
275     }
276
277     WARN("unsupported interface: %s\n", debugstr_guid(iid));
278     return E_NOINTERFACE;
279 }
280
281 static ULONG WINAPI ProgressDialog_AddRef(IProgressDialog *iface)
282 {
283     ProgressDialog *This = (ProgressDialog *)iface;
284     return InterlockedIncrement(&This->refCount);
285 }
286
287 static ULONG WINAPI ProgressDialog_Release(IProgressDialog *iface)
288 {
289     ProgressDialog *This = (ProgressDialog *)iface;
290     ULONG ret;
291
292     ret = InterlockedDecrement(&This->refCount);
293     if (ret == 0)
294         ProgressDialog_Destructor(This);
295     return ret;
296 }
297
298 static HRESULT WINAPI ProgressDialog_StartProgressDialog(IProgressDialog *iface, HWND hwndParent, IUnknown *punkEnableModeless, DWORD dwFlags, LPCVOID reserved)
299 {
300     ProgressDialog *This = (ProgressDialog *)iface;
301     struct create_params params;
302     HANDLE hThread;
303
304     TRACE("(%p, %p, %x, %p)\n", iface, punkEnableModeless, dwFlags, reserved);
305     if (punkEnableModeless || reserved)
306         FIXME("Reserved parameters not null (%p, %p)\n", punkEnableModeless, reserved);
307     if (dwFlags & PROGDLG_AUTOTIME)
308         FIXME("Flags PROGDLG_AUTOTIME not supported\n");
309     if (dwFlags & PROGDLG_NOTIME)
310         FIXME("Flags PROGDLG_NOTIME not supported\n");
311
312     EnterCriticalSection(&This->cs);
313
314     if (This->hwnd)
315     {
316         LeaveCriticalSection(&This->cs);
317         return S_OK;  /* as on XP */
318     }
319     This->dwFlags = dwFlags;
320     params.This = This;
321     params.hwndParent = hwndParent;
322     params.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
323
324     hThread = CreateThread(NULL, 0, dialog_thread, &params, 0, NULL);
325     WaitForSingleObject(params.hEvent, INFINITE);
326     CloseHandle(params.hEvent);
327     CloseHandle(hThread);
328
329     This->hwndDisabledParent = NULL;
330     if (hwndParent && (dwFlags & PROGDLG_MODAL))
331     {
332         HWND hwndDisable = GetAncestor(hwndParent, GA_ROOT);
333         if (EnableWindow(hwndDisable, FALSE))
334             This->hwndDisabledParent = hwndDisable;
335     }
336
337     LeaveCriticalSection(&This->cs);
338
339     return S_OK;
340 }
341
342 static HRESULT WINAPI ProgressDialog_StopProgressDialog(IProgressDialog *iface)
343 {
344     ProgressDialog *This = (ProgressDialog *)iface;
345
346     EnterCriticalSection(&This->cs);
347     if (This->hwnd)
348         end_dialog(This);
349     LeaveCriticalSection(&This->cs);
350
351     return S_OK;
352 }
353
354 static HRESULT WINAPI ProgressDialog_SetTitle(IProgressDialog *iface, LPCWSTR pwzTitle)
355 {
356     ProgressDialog *This = (ProgressDialog *)iface;
357     HWND hwnd;
358
359     TRACE("(%p, %s)\n", This, wine_dbgstr_w(pwzTitle));
360
361     EnterCriticalSection(&This->cs);
362     set_buffer(&This->title, pwzTitle);
363     This->dwUpdate |= UPDATE_TITLE;
364     hwnd = This->hwnd;
365     LeaveCriticalSection(&This->cs);
366
367     if (hwnd)
368         SendMessageW(hwnd, WM_DLG_UPDATE, 0, 0);
369
370     return S_OK;
371 }
372
373 static HRESULT WINAPI ProgressDialog_SetAnimation(IProgressDialog *iface, HINSTANCE hInstance, UINT uiResourceId)
374 {
375     FIXME("(%p, %p, %d) - stub\n", iface, hInstance, uiResourceId);
376     return S_OK;
377 }
378
379 static BOOL WINAPI ProgressDialog_HasUserCancelled(IProgressDialog *iface)
380 {
381     ProgressDialog *This = (ProgressDialog *)iface;
382     return This->isCancelled;
383 }
384
385 static HRESULT WINAPI ProgressDialog_SetProgress64(IProgressDialog *iface, ULONGLONG ullCompleted, ULONGLONG ullTotal)
386 {
387     ProgressDialog *This = (ProgressDialog *)iface;
388     HWND hwnd;
389
390     TRACE("(%p, 0x%s, 0x%s)\n", This, wine_dbgstr_longlong(ullCompleted), wine_dbgstr_longlong(ullTotal));
391
392     EnterCriticalSection(&This->cs);
393     This->ullTotal = ullTotal;
394     This->ullCompleted = ullCompleted;
395     This->dwUpdate |= UPDATE_PROGRESS;
396     hwnd = This->hwnd;
397     LeaveCriticalSection(&This->cs);
398
399     if (hwnd)
400         SendMessageW(hwnd, WM_DLG_UPDATE, 0, 0);
401
402     return S_OK;  /* Windows sometimes returns S_FALSE */
403 }
404
405 static HRESULT WINAPI ProgressDialog_SetProgress(IProgressDialog *iface, DWORD dwCompleted, DWORD dwTotal)
406 {
407     return IProgressDialog_SetProgress64(iface, dwCompleted, dwTotal);
408 }
409
410 static HRESULT WINAPI ProgressDialog_SetLine(IProgressDialog *iface, DWORD dwLineNum, LPCWSTR pwzLine, BOOL bPath, LPCVOID reserved)
411 {
412     ProgressDialog *This = (ProgressDialog *)iface;
413     HWND hwnd;
414
415     TRACE("(%p, %d, %s, %d)\n", This, dwLineNum, wine_dbgstr_w(pwzLine), bPath);
416
417     if (reserved)
418         FIXME("reserved pointer not null (%p)\n", reserved);
419
420     dwLineNum--;
421     if (dwLineNum >= 3)  /* Windows seems to do something like that */
422         dwLineNum = 0;
423
424     EnterCriticalSection(&This->cs);
425     set_buffer(&This->lines[dwLineNum], pwzLine);
426     This->dwUpdate |= UPDATE_LINE1 << dwLineNum;
427     hwnd = (This->isCancelled ? NULL : This->hwnd); /* no sense to send the message if window cancelled */
428     LeaveCriticalSection(&This->cs);
429
430     if (hwnd)
431         SendMessageW(hwnd, WM_DLG_UPDATE, 0, 0);
432
433     return S_OK;
434 }
435
436 static HRESULT WINAPI ProgressDialog_SetCancelMsg(IProgressDialog *iface, LPCWSTR pwzMsg, LPCVOID reserved)
437 {
438     ProgressDialog *This = (ProgressDialog *)iface;
439     HWND hwnd;
440
441     TRACE("(%p, %s)\n", This, wine_dbgstr_w(pwzMsg));
442
443     if (reserved)
444         FIXME("reserved pointer not null (%p)\n", reserved);
445
446     EnterCriticalSection(&This->cs);
447     set_buffer(&This->cancelMsg, pwzMsg);
448     This->dwUpdate |= UPDATE_LINE1 << CANCEL_MSG_LINE;
449     hwnd = (This->isCancelled ? This->hwnd : NULL); /* no sense to send the message if window not cancelled */
450     LeaveCriticalSection(&This->cs);
451
452     if (hwnd)
453         SendMessageW(hwnd, WM_DLG_UPDATE, 0, 0);
454
455     return S_OK;
456 }
457
458 static HRESULT WINAPI ProgressDialog_Timer(IProgressDialog *iface, DWORD dwTimerAction, LPCVOID reserved)
459 {
460     ProgressDialog *This = (ProgressDialog *)iface;
461
462     FIXME("(%p, %d, %p) - stub\n", This, dwTimerAction, reserved);
463
464     if (reserved)
465         FIXME("Reserved field not NULL but %p\n", reserved);
466
467     return S_OK;
468 }
469
470 static const IProgressDialogVtbl ProgressDialogVtbl =
471 {
472     ProgressDialog_QueryInterface,
473     ProgressDialog_AddRef,
474     ProgressDialog_Release,
475
476     ProgressDialog_StartProgressDialog,
477     ProgressDialog_StopProgressDialog,
478     ProgressDialog_SetTitle,
479     ProgressDialog_SetAnimation,
480     ProgressDialog_HasUserCancelled,
481     ProgressDialog_SetProgress,
482     ProgressDialog_SetProgress64,
483     ProgressDialog_SetLine,
484     ProgressDialog_SetCancelMsg,
485     ProgressDialog_Timer
486 };
487
488 HRESULT ProgressDialog_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
489 {
490     ProgressDialog *This;
491     if (pUnkOuter)
492         return CLASS_E_NOAGGREGATION;
493
494     This = heap_alloc_zero(sizeof(ProgressDialog));
495     if (This == NULL)
496         return E_OUTOFMEMORY;
497
498     This->vtbl = &ProgressDialogVtbl;
499     This->refCount = 1;
500     InitializeCriticalSection(&This->cs);
501
502     TRACE("returning %p\n", This);
503     *ppOut = (IUnknown *)This;
504     BROWSEUI_refCount++;
505     return S_OK;
506 }