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 #include "mshtmcid.h"
  31
  32 #include "wine/debug.h"
  33
  34 #include "mshtml_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  37
  38 #define WM_PROCESSTASK 0x8008
  39
  40 void push_task(task_t *task)
  41 {
  42     thread_data_t *thread_data = get_thread_data(TRUE);
  43
  44     if(thread_data->task_queue_tail)
  45         thread_data->task_queue_tail->next = task;
  46     else
  47         thread_data->task_queue_head = task;
  48
  49     thread_data->task_queue_tail = task;
  50
  51     PostMessageW(thread_data->thread_hwnd, WM_PROCESSTASK, 0, 0);
  52 }
  53
  54 static task_t *pop_task(void)
  55 {
  56     thread_data_t *thread_data = get_thread_data(TRUE);
  57     task_t *task = thread_data->task_queue_head;
  58
  59     if(!task)
  60         return NULL;
  61
  62     thread_data->task_queue_head = task->next;
  63     if(!thread_data->task_queue_head)
  64         thread_data->task_queue_tail = NULL;
  65
  66     return task;
  67 }
  68
  69 void remove_doc_tasks(const HTMLDocument *doc)
  70 {
  71     thread_data_t *thread_data = get_thread_data(FALSE);
  72     task_t *iter, *tmp;
  73
  74     if(!thread_data)
  75         return;
  76
  77     while(thread_data->task_queue_head
  78           && thread_data->task_queue_head->doc == doc)
  79         pop_task();
  80
  81     for(iter = thread_data->task_queue_head; iter; iter = iter->next) {
  82         while(iter->next && iter->next->doc == doc) {
  83             tmp = iter->next;
  84             iter->next = tmp->next;
  85             heap_free(tmp);
  86         }
  87
  88         if(!iter->next)
  89             thread_data->task_queue_tail = iter;
  90     }
  91 }
  92
  93 static void set_downloading(HTMLDocument *doc)
  94 {
  95     IOleCommandTarget *olecmd;
  96     HRESULT hres;
  97
  98     TRACE("(%p)\n", doc);
  99
 100     if(doc->frame)
 101         IOleInPlaceFrame_SetStatusText(doc->frame, NULL /* FIXME */);
 102
 103     if(!doc->client)
 104         return;
 105
 106     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 107     if(SUCCEEDED(hres)) {
 108         VARIANT var;
 109
 110         V_VT(&var) = VT_I4;
 111         V_I4(&var) = 1;
 112
 113         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETDOWNLOADSTATE, OLECMDEXECOPT_DONTPROMPTUSER,
 114                                &var, NULL);
 115         IOleCommandTarget_Release(olecmd);
 116     }
 117
 118     if(doc->hostui) {
 119         IDropTarget *drop_target = NULL;
 120
 121         hres = IDocHostUIHandler_GetDropTarget(doc->hostui, NULL /* FIXME */, &drop_target);
 122         if(drop_target) {
 123             FIXME("Use IDropTarget\n");
 124             IDropTarget_Release(drop_target);
 125         }
 126     }
 127 }
 128
 129 static void set_parsecomplete(HTMLDocument *doc)
 130 {
 131     IOleCommandTarget *olecmd = NULL;
 132
 133     TRACE("(%p)\n", doc);
 134
 135     if(doc->usermode == EDITMODE)
 136         init_editor(doc);
 137
 138     call_property_onchanged(&doc->cp_propnotif, 1005);
 139
 140     doc->readystate = READYSTATE_INTERACTIVE;
 141     call_property_onchanged(&doc->cp_propnotif, DISPID_READYSTATE);
 142
 143     if(doc->client)
 144         IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 145
 146     if(olecmd) {
 147         VARIANT state, progress;
 148
 149         V_VT(&progress) = VT_I4;
 150         V_I4(&progress) = 0;
 151         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS, OLECMDEXECOPT_DONTPROMPTUSER,
 152                                &progress, NULL);
 153
 154         V_VT(&state) = VT_I4;
 155         V_I4(&state) = 0;
 156         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETDOWNLOADSTATE, OLECMDEXECOPT_DONTPROMPTUSER,
 157                                &state, NULL);
 158
 159         IOleCommandTarget_Exec(olecmd, &CGID_MSHTML, IDM_PARSECOMPLETE, 0, NULL, NULL);
 160         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_HTTPEQUIV_DONE, 0, NULL, NULL);
 161
 162         IOleCommandTarget_Release(olecmd);
 163     }
 164
 165     doc->readystate = READYSTATE_COMPLETE;
 166     call_property_onchanged(&doc->cp_propnotif, DISPID_READYSTATE);
 167
 168     if(doc->frame) {
 169         static const WCHAR wszDone[] = {'D','o','n','e',0};
 170         IOleInPlaceFrame_SetStatusText(doc->frame, wszDone);
 171     }
 172
 173     update_title(doc);
 174 }
 175
 176 static void set_progress(HTMLDocument *doc)
 177 {
 178     IOleCommandTarget *olecmd = NULL;
 179     HRESULT hres;
 180
 181     TRACE("(%p)\n", doc);
 182
 183     if(doc->client)
 184         IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 185
 186     if(olecmd) {
 187         VARIANT progress_max, progress;
 188
 189         V_VT(&progress_max) = VT_I4;
 190         V_I4(&progress_max) = 0; /* FIXME */
 191         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSMAX, OLECMDEXECOPT_DONTPROMPTUSER,
 192                                &progress_max, NULL);
 193
 194         V_VT(&progress) = VT_I4;
 195         V_I4(&progress) = 0; /* FIXME */
 196         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS, OLECMDEXECOPT_DONTPROMPTUSER,
 197                                &progress, NULL);
 198     }
 199
 200     if(doc->usermode == EDITMODE && doc->hostui) {
 201         DOCHOSTUIINFO hostinfo;
 202
 203         memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
 204         hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
 205         hres = IDocHostUIHandler_GetHostInfo(doc->hostui, &hostinfo);
 206         if(SUCCEEDED(hres))
 207             /* FIXME: use hostinfo */
 208             TRACE("hostinfo = {%u %08x %08x %s %s}\n",
 209                     hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
 210                     debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
 211     }
 212 }
 213
 214 static void task_start_binding(HTMLDocument *doc, BSCallback *bscallback)
 215 {
 216     if(doc)
 217         start_binding(doc, bscallback, NULL);
 218     IBindStatusCallback_Release(STATUSCLB(bscallback));
 219 }
 220
 221 static void process_task(task_t *task)
 222 {
 223     switch(task->task_id) {
 224     case TASK_SETDOWNLOADSTATE:
 225         set_downloading(task->doc);
 226         break;
 227     case TASK_PARSECOMPLETE:
 228         set_parsecomplete(task->doc);
 229         break;
 230     case TASK_SETPROGRESS:
 231         set_progress(task->doc);
 232         break;
 233     case TASK_START_BINDING:
 234         task_start_binding(task->doc, task->bscallback);
 235         break;
 236     default:
 237         ERR("Wrong task_id %d\n", task->task_id);
 238     }
 239 }
 240
 241 static LRESULT WINAPI hidden_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 242 {
 243     switch(msg) {
 244     case WM_PROCESSTASK:
 245         while(1) {
 246             task_t *task = pop_task();
 247             if(!task)
 248                 break;
 249
 250             process_task(task);
 251             heap_free(task);
 252         }
 253
 254         return 0;
 255     }
 256
 257     if(msg > WM_USER)
 258         FIXME("(%p %d %lx %lx)\n", hwnd, msg, wParam, lParam);
 259
 260     return DefWindowProcW(hwnd, msg, wParam, lParam);
 261 }
 262
 263 static HWND create_thread_hwnd(void)
 264 {
 265     static ATOM hidden_wnd_class = 0;
 266     static const WCHAR wszInternetExplorer_Hidden[] = {'I','n','t','e','r','n','e','t',
 267             ' ','E','x','p','l','o','r','e','r','_','H','i','d','d','e','n',0};
 268
 269     if(!hidden_wnd_class) {
 270         WNDCLASSEXW wndclass = {
 271             sizeof(WNDCLASSEXW), 0,
 272             hidden_proc,
 273             0, 0, hInst, NULL, NULL, NULL, NULL,
 274             wszInternetExplorer_Hidden,
 275             NULL
 276         };
 277
 278         hidden_wnd_class = RegisterClassExW(&wndclass);
 279     }
 280
 281     return CreateWindowExW(0, wszInternetExplorer_Hidden, NULL, WS_POPUP,
 282                            0, 0, 0, 0, NULL, NULL, hInst, NULL);
 283 }
 284
 285 HWND get_thread_hwnd(void)
 286 {
 287     thread_data_t *thread_data = get_thread_data(TRUE);
 288
 289     if(!thread_data->thread_hwnd)
 290         thread_data->thread_hwnd = create_thread_hwnd();
 291
 292     return thread_data->thread_hwnd;
 293 }
 294
 295 thread_data_t *get_thread_data(BOOL create)
 296 {
 297     thread_data_t *thread_data;
 298
 299     if(!mshtml_tls) {
 300         if(create)
 301             mshtml_tls = TlsAlloc();
 302         else
 303             return NULL;
 304     }
 305
 306     thread_data = TlsGetValue(mshtml_tls);
 307     if(!thread_data && create) {
 308         thread_data = heap_alloc_zero(sizeof(thread_data_t));
 309         TlsSetValue(mshtml_tls, thread_data);
 310     }
 311
 312     return thread_data;
 313 }