push 3ea7f427b854582f33bb4f72399138cb53b12d0c
[wine/hacks.git] / dlls / mshtml / task.c
blob496b96f6bd4ff68c8f06d963b52bb7eb93f3b08f
1 /*
2 * Copyright 2006 Jacek Caban for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 #include "config.h"
21 #include <stdarg.h>
22 #include <stdio.h>
24 #define COBJMACROS
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "ole2.h"
30 #include "mshtmcid.h"
31 #include "shlguid.h"
33 #include "wine/debug.h"
35 #include "mshtml_private.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
39 #define WM_PROCESSTASK 0x8008
40 #define TIMER_ID 0x3000
42 typedef struct {
43 HTMLDocument *doc;
44 DWORD id;
45 DWORD time;
46 DWORD interval;
47 IDispatch *disp;
49 struct list entry;
50 } task_timer_t;
52 void push_task(task_t *task)
54 thread_data_t *thread_data = get_thread_data(TRUE);
56 if(thread_data->task_queue_tail)
57 thread_data->task_queue_tail->next = task;
58 else
59 thread_data->task_queue_head = task;
61 thread_data->task_queue_tail = task;
63 PostMessageW(thread_data->thread_hwnd, WM_PROCESSTASK, 0, 0);
66 static task_t *pop_task(void)
68 thread_data_t *thread_data = get_thread_data(TRUE);
69 task_t *task = thread_data->task_queue_head;
71 if(!task)
72 return NULL;
74 thread_data->task_queue_head = task->next;
75 if(!thread_data->task_queue_head)
76 thread_data->task_queue_tail = NULL;
78 return task;
81 static void release_task_timer(HWND thread_hwnd, task_timer_t *timer)
83 list_remove(&timer->entry);
85 IDispatch_Release(timer->disp);
87 heap_free(timer);
90 void remove_doc_tasks(const HTMLDocument *doc)
92 thread_data_t *thread_data = get_thread_data(FALSE);
93 struct list *liter, *ltmp;
94 task_timer_t *timer;
95 task_t *iter, *tmp;
97 LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->timer_list) {
98 timer = LIST_ENTRY(liter, task_timer_t, entry);
99 if(timer->doc == doc)
100 release_task_timer(thread_data->thread_hwnd, timer);
103 if(!list_empty(&thread_data->timer_list)) {
104 timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
105 SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time - GetTickCount(), NULL);
108 if(!thread_data)
109 return;
111 while(thread_data->task_queue_head
112 && thread_data->task_queue_head->doc == doc)
113 pop_task();
115 for(iter = thread_data->task_queue_head; iter; iter = iter->next) {
116 while(iter->next && iter->next->doc == doc) {
117 tmp = iter->next;
118 iter->next = tmp->next;
119 heap_free(tmp);
122 if(!iter->next)
123 thread_data->task_queue_tail = iter;
127 static BOOL queue_timer(thread_data_t *thread_data, task_timer_t *timer)
129 task_timer_t *iter;
131 list_remove(&timer->entry);
133 if(list_empty(&thread_data->timer_list)
134 || LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry)->time > timer->time) {
136 list_add_head(&thread_data->timer_list, &timer->entry);
137 return TRUE;
140 LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
141 if(iter->time > timer->time) {
142 list_add_tail(&iter->entry, &timer->entry);
143 return FALSE;
147 list_add_tail(&thread_data->timer_list, &timer->entry);
148 return FALSE;
151 DWORD set_task_timer(HTMLDocument *doc, DWORD msec, BOOL interval, IDispatch *disp)
153 thread_data_t *thread_data = get_thread_data(TRUE);
154 task_timer_t *timer;
155 DWORD tc = GetTickCount();
157 static DWORD id_cnt = 0x20000000;
159 timer = heap_alloc(sizeof(task_timer_t));
160 timer->id = id_cnt++;
161 timer->doc = doc;
162 timer->time = tc + msec;
163 timer->interval = interval ? msec : 0;
164 list_init(&timer->entry);
166 IDispatch_AddRef(disp);
167 timer->disp = disp;
169 if(queue_timer(thread_data, timer))
170 SetTimer(thread_data->thread_hwnd, TIMER_ID, msec, NULL);
172 return timer->id;
175 HRESULT clear_task_timer(HTMLDocument *doc, BOOL interval, DWORD id)
177 thread_data_t *thread_data = get_thread_data(FALSE);
178 task_timer_t *iter;
180 if(!thread_data)
181 return S_OK;
183 LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
184 if(iter->id == id && iter->doc == doc && (iter->interval == 0) == !interval) {
185 release_task_timer(thread_data->thread_hwnd, iter);
186 return S_OK;
190 WARN("timet not found\n");
191 return S_OK;
194 static void set_downloading(HTMLDocument *doc)
196 IOleCommandTarget *olecmd;
197 HRESULT hres;
199 TRACE("(%p)\n", doc);
201 if(doc->frame)
202 IOleInPlaceFrame_SetStatusText(doc->frame, NULL /* FIXME */);
204 if(!doc->client)
205 return;
207 hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
208 if(SUCCEEDED(hres)) {
209 VARIANT var;
211 V_VT(&var) = VT_I4;
212 V_I4(&var) = 1;
214 IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETDOWNLOADSTATE, OLECMDEXECOPT_DONTPROMPTUSER,
215 &var, NULL);
216 IOleCommandTarget_Release(olecmd);
219 if(doc->hostui) {
220 IDropTarget *drop_target = NULL;
222 hres = IDocHostUIHandler_GetDropTarget(doc->hostui, NULL /* FIXME */, &drop_target);
223 if(drop_target) {
224 FIXME("Use IDropTarget\n");
225 IDropTarget_Release(drop_target);
230 /* Calls undocumented 69 cmd of CGID_Explorer */
231 static void call_explorer_69(HTMLDocument *doc)
233 IOleCommandTarget *olecmd;
234 VARIANT var;
235 HRESULT hres;
237 if(!doc->client)
238 return;
240 hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
241 if(FAILED(hres))
242 return;
244 VariantInit(&var);
245 hres = IOleCommandTarget_Exec(olecmd, &CGID_Explorer, 69, 0, NULL, &var);
246 IOleCommandTarget_Release(olecmd);
247 if(SUCCEEDED(hres) && V_VT(&var) != VT_NULL)
248 FIXME("handle result\n");
251 static void set_parsecomplete(HTMLDocument *doc)
253 IOleCommandTarget *olecmd = NULL;
255 TRACE("(%p)\n", doc);
257 if(doc->usermode == EDITMODE)
258 init_editor(doc);
260 call_explorer_69(doc);
261 call_property_onchanged(&doc->cp_propnotif, 1005);
262 call_explorer_69(doc);
264 /* FIXME: IE7 calls EnableModelless(TRUE), EnableModelless(FALSE) and sets interactive state here */
266 doc->readystate = READYSTATE_INTERACTIVE;
267 call_property_onchanged(&doc->cp_propnotif, DISPID_READYSTATE);
269 if(doc->client)
270 IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
272 if(olecmd) {
273 VARIANT state, progress;
275 V_VT(&progress) = VT_I4;
276 V_I4(&progress) = 0;
277 IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS, OLECMDEXECOPT_DONTPROMPTUSER,
278 &progress, NULL);
280 V_VT(&state) = VT_I4;
281 V_I4(&state) = 0;
282 IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETDOWNLOADSTATE, OLECMDEXECOPT_DONTPROMPTUSER,
283 &state, NULL);
285 IOleCommandTarget_Exec(olecmd, &CGID_ShellDocView, 103, 0, NULL, NULL);
286 IOleCommandTarget_Exec(olecmd, &CGID_MSHTML, IDM_PARSECOMPLETE, 0, NULL, NULL);
287 IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_HTTPEQUIV_DONE, 0, NULL, NULL);
289 IOleCommandTarget_Release(olecmd);
292 doc->readystate = READYSTATE_COMPLETE;
293 call_property_onchanged(&doc->cp_propnotif, DISPID_READYSTATE);
295 if(doc->frame) {
296 static const WCHAR wszDone[] = {'D','o','n','e',0};
297 IOleInPlaceFrame_SetStatusText(doc->frame, wszDone);
300 update_title(doc);
303 static void set_progress(HTMLDocument *doc)
305 IOleCommandTarget *olecmd = NULL;
306 HRESULT hres;
308 TRACE("(%p)\n", doc);
310 if(doc->client)
311 IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
313 if(olecmd) {
314 VARIANT progress_max, progress;
316 V_VT(&progress_max) = VT_I4;
317 V_I4(&progress_max) = 0; /* FIXME */
318 IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSMAX, OLECMDEXECOPT_DONTPROMPTUSER,
319 &progress_max, NULL);
321 V_VT(&progress) = VT_I4;
322 V_I4(&progress) = 0; /* FIXME */
323 IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS, OLECMDEXECOPT_DONTPROMPTUSER,
324 &progress, NULL);
327 if(doc->usermode == EDITMODE && doc->hostui) {
328 DOCHOSTUIINFO hostinfo;
330 memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
331 hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
332 hres = IDocHostUIHandler_GetHostInfo(doc->hostui, &hostinfo);
333 if(SUCCEEDED(hres))
334 /* FIXME: use hostinfo */
335 TRACE("hostinfo = {%u %08x %08x %s %s}\n",
336 hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
337 debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
341 static void task_start_binding(HTMLDocument *doc, BSCallback *bscallback)
343 if(doc)
344 start_binding(doc, bscallback, NULL);
345 IUnknown_Release((IUnknown*)bscallback);
348 static void process_task(task_t *task)
350 switch(task->task_id) {
351 case TASK_SETDOWNLOADSTATE:
352 set_downloading(task->doc);
353 break;
354 case TASK_PARSECOMPLETE:
355 set_parsecomplete(task->doc);
356 break;
357 case TASK_SETPROGRESS:
358 set_progress(task->doc);
359 break;
360 case TASK_START_BINDING:
361 task_start_binding(task->doc, (BSCallback*)task->bscallback);
362 break;
363 default:
364 ERR("Wrong task_id %d\n", task->task_id);
368 static void call_timer_disp(IDispatch *disp)
370 DISPPARAMS dp = {NULL, NULL, 0, 0};
371 EXCEPINFO ei;
372 VARIANT res;
373 HRESULT hres;
375 V_VT(&res) = VT_EMPTY;
376 memset(&ei, 0, sizeof(ei));
377 hres = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
378 TRACE("ret %08x %s\n", hres, debugstr_variant(&res));
379 VariantClear(&res);
382 static LRESULT process_timer(void)
384 thread_data_t *thread_data = get_thread_data(TRUE);
385 HTMLDocument *doc;
386 IDispatch *disp;
387 DWORD tc;
388 task_timer_t *timer;
390 TRACE("\n");
392 while(!list_empty(&thread_data->timer_list)) {
393 timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
395 tc = GetTickCount();
396 if(timer->time > tc) {
397 SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time-tc, NULL);
398 return 0;
401 doc = timer->doc;
402 disp = timer->disp;
403 IDispatch_AddRef(disp);
405 if(timer->interval) {
406 timer->time += timer->interval;
407 queue_timer(thread_data, timer);
408 }else {
409 release_task_timer(thread_data->thread_hwnd, timer);
412 call_timer_disp(disp);
414 IDispatch_Release(disp);
417 KillTimer(thread_data->thread_hwnd, TIMER_ID);
418 return 0;
421 static LRESULT WINAPI hidden_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
423 switch(msg) {
424 case WM_PROCESSTASK:
425 while(1) {
426 task_t *task = pop_task();
427 if(!task)
428 break;
430 process_task(task);
431 heap_free(task);
434 return 0;
435 case WM_TIMER:
436 return process_timer();
439 if(msg > WM_USER)
440 FIXME("(%p %d %lx %lx)\n", hwnd, msg, wParam, lParam);
442 return DefWindowProcW(hwnd, msg, wParam, lParam);
445 static HWND create_thread_hwnd(void)
447 static ATOM hidden_wnd_class = 0;
448 static const WCHAR wszInternetExplorer_Hidden[] = {'I','n','t','e','r','n','e','t',
449 ' ','E','x','p','l','o','r','e','r','_','H','i','d','d','e','n',0};
451 if(!hidden_wnd_class) {
452 WNDCLASSEXW wndclass = {
453 sizeof(WNDCLASSEXW), 0,
454 hidden_proc,
455 0, 0, hInst, NULL, NULL, NULL, NULL,
456 wszInternetExplorer_Hidden,
457 NULL
460 hidden_wnd_class = RegisterClassExW(&wndclass);
463 return CreateWindowExW(0, wszInternetExplorer_Hidden, NULL, WS_POPUP,
464 0, 0, 0, 0, NULL, NULL, hInst, NULL);
467 HWND get_thread_hwnd(void)
469 thread_data_t *thread_data = get_thread_data(TRUE);
471 if(!thread_data->thread_hwnd)
472 thread_data->thread_hwnd = create_thread_hwnd();
474 return thread_data->thread_hwnd;
477 thread_data_t *get_thread_data(BOOL create)
479 thread_data_t *thread_data;
481 if(mshtml_tls == TLS_OUT_OF_INDEXES) {
482 DWORD tls;
484 if(!create)
485 return NULL;
487 tls = TlsAlloc();
488 if(tls == TLS_OUT_OF_INDEXES)
489 return NULL;
491 tls = InterlockedCompareExchange((LONG*)&mshtml_tls, tls, TLS_OUT_OF_INDEXES);
492 if(tls != mshtml_tls)
493 TlsFree(tls);
496 thread_data = TlsGetValue(mshtml_tls);
497 if(!thread_data && create) {
498 thread_data = heap_alloc_zero(sizeof(thread_data_t));
499 TlsSetValue(mshtml_tls, thread_data);
500 list_init(&thread_data->timer_list);
503 return thread_data;