git.oblomov.eu Git - wine/blob - dlls/mshtml/task.c

   1 /*
   2  * Copyright 2006 Jacek Caban for CodeWeavers
   3  *
   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.
   8  *
   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.
  13  *
  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
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "ole2.h"
  30
  31 #include "wine/debug.h"
  32
  33 #include "mshtml_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  36
  37 #define WM_PROCESSTASK 0x8008
  38 #define TIMER_ID 0x3000
  39
  40 typedef struct {
  41     HTMLDocument *doc;
  42     DWORD id;
  43     DWORD time;
  44     DWORD interval;
  45     IDispatch *disp;
  46
  47     struct list entry;
  48 } task_timer_t;
  49
  50 void push_task(task_t *task, task_proc_t proc, LONG magic)
  51 {
  52     thread_data_t *thread_data = get_thread_data(TRUE);
  53
  54     task->target_magic = magic;
  55     task->proc = proc;
  56     task->next = NULL;
  57
  58     if(thread_data->task_queue_tail)
  59         thread_data->task_queue_tail->next = task;
  60     else
  61         thread_data->task_queue_head = task;
  62
  63     thread_data->task_queue_tail = task;
  64
  65     PostMessageW(thread_data->thread_hwnd, WM_PROCESSTASK, 0, 0);
  66 }
  67
  68 static task_t *pop_task(void)
  69 {
  70     thread_data_t *thread_data = get_thread_data(TRUE);
  71     task_t *task = thread_data->task_queue_head;
  72
  73     if(!task)
  74         return NULL;
  75
  76     thread_data->task_queue_head = task->next;
  77     if(!thread_data->task_queue_head)
  78         thread_data->task_queue_tail = NULL;
  79
  80     return task;
  81 }
  82
  83 static void release_task_timer(HWND thread_hwnd, task_timer_t *timer)
  84 {
  85     list_remove(&timer->entry);
  86
  87     IDispatch_Release(timer->disp);
  88
  89     heap_free(timer);
  90 }
  91
  92 void remove_target_tasks(LONG target)
  93 {
  94     thread_data_t *thread_data = get_thread_data(FALSE);
  95     struct list *liter, *ltmp;
  96     task_timer_t *timer;
  97     task_t *iter, *tmp;
  98
  99     if(!thread_data)
 100         return;
 101
 102     LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->timer_list) {
 103         timer = LIST_ENTRY(liter, task_timer_t, entry);
 104         if(timer->doc->task_magic == target)
 105             release_task_timer(thread_data->thread_hwnd, timer);
 106     }
 107
 108     if(!list_empty(&thread_data->timer_list)) {
 109         timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
 110         SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time - GetTickCount(), NULL);
 111     }
 112
 113     while(thread_data->task_queue_head
 114           && thread_data->task_queue_head->target_magic == target)
 115         pop_task();
 116
 117     for(iter = thread_data->task_queue_head; iter; iter = iter->next) {
 118         while(iter->next && iter->next->target_magic == target) {
 119             tmp = iter->next;
 120             iter->next = tmp->next;
 121             heap_free(tmp);
 122         }
 123
 124         if(!iter->next)
 125             thread_data->task_queue_tail = iter;
 126     }
 127 }
 128
 129 LONG get_task_target_magic(void)
 130 {
 131     static LONG magic = 0x10000000;
 132     return InterlockedIncrement(&magic);
 133 }
 134
 135 static BOOL queue_timer(thread_data_t *thread_data, task_timer_t *timer)
 136 {
 137     task_timer_t *iter;
 138
 139     list_remove(&timer->entry);
 140
 141     if(list_empty(&thread_data->timer_list)
 142        || LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry)->time > timer->time) {
 143
 144         list_add_head(&thread_data->timer_list, &timer->entry);
 145         return TRUE;
 146     }
 147
 148     LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
 149         if(iter->time > timer->time) {
 150             list_add_tail(&iter->entry, &timer->entry);
 151             return FALSE;
 152         }
 153     }
 154
 155     list_add_tail(&thread_data->timer_list, &timer->entry);
 156     return FALSE;
 157 }
 158
 159 DWORD set_task_timer(HTMLDocument *doc, DWORD msec, BOOL interval, IDispatch *disp)
 160 {
 161     thread_data_t *thread_data = get_thread_data(TRUE);
 162     task_timer_t *timer;
 163     DWORD tc = GetTickCount();
 164
 165     static DWORD id_cnt = 0x20000000;
 166
 167     timer = heap_alloc(sizeof(task_timer_t));
 168     timer->id = id_cnt++;
 169     timer->doc = doc;
 170     timer->time = tc + msec;
 171     timer->interval = interval ? msec : 0;
 172     list_init(&timer->entry);
 173
 174     IDispatch_AddRef(disp);
 175     timer->disp = disp;
 176
 177     if(queue_timer(thread_data, timer))
 178         SetTimer(thread_data->thread_hwnd, TIMER_ID, msec, NULL);
 179
 180     return timer->id;
 181 }
 182
 183 HRESULT clear_task_timer(HTMLDocument *doc, BOOL interval, DWORD id)
 184 {
 185     thread_data_t *thread_data = get_thread_data(FALSE);
 186     task_timer_t *iter;
 187
 188     if(!thread_data)
 189         return S_OK;
 190
 191     LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
 192         if(iter->id == id && iter->doc == doc && (iter->interval == 0) == !interval) {
 193             release_task_timer(thread_data->thread_hwnd, iter);
 194             return S_OK;
 195         }
 196     }
 197
 198     WARN("timet not found\n");
 199     return S_OK;
 200 }
 201
 202 static void call_timer_disp(IDispatch *disp)
 203 {
 204     DISPPARAMS dp = {NULL, NULL, 0, 0};
 205     EXCEPINFO ei;
 206     VARIANT res;
 207     HRESULT hres;
 208
 209     V_VT(&res) = VT_EMPTY;
 210     memset(&ei, 0, sizeof(ei));
 211
 212     TRACE(">>>\n");
 213     hres = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
 214     if(hres == S_OK)
 215         TRACE("<<<\n");
 216     else
 217         WARN("<<< %08x\n", hres);
 218
 219     VariantClear(&res);
 220 }
 221
 222 static LRESULT process_timer(void)
 223 {
 224     thread_data_t *thread_data = get_thread_data(TRUE);
 225     HTMLDocument *doc;
 226     IDispatch *disp;
 227     DWORD tc;
 228     task_timer_t *timer;
 229
 230     TRACE("\n");
 231
 232     while(!list_empty(&thread_data->timer_list)) {
 233         timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
 234
 235         tc = GetTickCount();
 236         if(timer->time > tc) {
 237             SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time-tc, NULL);
 238             return 0;
 239         }
 240
 241         doc = timer->doc;
 242         disp = timer->disp;
 243         IDispatch_AddRef(disp);
 244
 245         if(timer->interval) {
 246             timer->time += timer->interval;
 247             queue_timer(thread_data, timer);
 248         }else {
 249             release_task_timer(thread_data->thread_hwnd, timer);
 250         }
 251
 252         call_timer_disp(disp);
 253
 254         IDispatch_Release(disp);
 255     }
 256
 257     KillTimer(thread_data->thread_hwnd, TIMER_ID);
 258     return 0;
 259 }
 260
 261 static LRESULT WINAPI hidden_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 262 {
 263     switch(msg) {
 264     case WM_PROCESSTASK:
 265         while(1) {
 266             task_t *task = pop_task();
 267             if(!task)
 268                 break;
 269
 270             task->proc(task);
 271             heap_free(task);
 272         }
 273
 274         return 0;
 275     case WM_TIMER:
 276         return process_timer();
 277     }
 278
 279     if(msg > WM_USER)
 280         FIXME("(%p %d %lx %lx)\n", hwnd, msg, wParam, lParam);
 281
 282     return DefWindowProcW(hwnd, msg, wParam, lParam);
 283 }
 284
 285 static HWND create_thread_hwnd(void)
 286 {
 287     static ATOM hidden_wnd_class = 0;
 288     static const WCHAR wszInternetExplorer_Hidden[] = {'I','n','t','e','r','n','e','t',
 289             ' ','E','x','p','l','o','r','e','r','_','H','i','d','d','e','n',0};
 290
 291     if(!hidden_wnd_class) {
 292         WNDCLASSEXW wndclass = {
 293             sizeof(WNDCLASSEXW), 0,
 294             hidden_proc,
 295             0, 0, hInst, NULL, NULL, NULL, NULL,
 296             wszInternetExplorer_Hidden,
 297             NULL
 298         };
 299
 300         hidden_wnd_class = RegisterClassExW(&wndclass);
 301     }
 302
 303     return CreateWindowExW(0, wszInternetExplorer_Hidden, NULL, WS_POPUP,
 304                            0, 0, 0, 0, NULL, NULL, hInst, NULL);
 305 }
 306
 307 HWND get_thread_hwnd(void)
 308 {
 309     thread_data_t *thread_data = get_thread_data(TRUE);
 310
 311     if(!thread_data->thread_hwnd)
 312         thread_data->thread_hwnd = create_thread_hwnd();
 313
 314     return thread_data->thread_hwnd;
 315 }
 316
 317 thread_data_t *get_thread_data(BOOL create)
 318 {
 319     thread_data_t *thread_data;
 320
 321     if(mshtml_tls == TLS_OUT_OF_INDEXES) {
 322         DWORD tls;
 323
 324         if(!create)
 325             return NULL;
 326
 327         tls = TlsAlloc();
 328         if(tls == TLS_OUT_OF_INDEXES)
 329             return NULL;
 330
 331         tls = InterlockedCompareExchange((LONG*)&mshtml_tls, tls, TLS_OUT_OF_INDEXES);
 332         if(tls != mshtml_tls)
 333             TlsFree(tls);
 334     }
 335
 336     thread_data = TlsGetValue(mshtml_tls);
 337     if(!thread_data && create) {
 338         thread_data = heap_alloc_zero(sizeof(thread_data_t));
 339         TlsSetValue(mshtml_tls, thread_data);
 340         list_init(&thread_data->timer_list);
 341     }
 342
 343     return thread_data;
 344 }