dlls/mshtml/conpoint.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 <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct {
  35     IEnumConnections IEnumConnections_iface;
  36
  37     LONG ref;
  38
  39     unsigned iter;
  40     ConnectionPoint *cp;
  41 } EnumConnections;
  42
  43 static inline EnumConnections *impl_from_IEnumConnections(IEnumConnections *iface)
  44 {
  45     return CONTAINING_RECORD(iface, EnumConnections, IEnumConnections_iface);
  46 }
  47
  48 static HRESULT WINAPI EnumConnections_QueryInterface(IEnumConnections *iface, REFIID riid, void **ppv)
  49 {
  50     EnumConnections *This = impl_from_IEnumConnections(iface);
  51
  52     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  53
  54     if(IsEqualGUID(riid, &IID_IUnknown)) {
  55         *ppv = &This->IEnumConnections_iface;
  56     }else if(IsEqualGUID(riid, &IID_IEnumConnections)) {
  57         *ppv = &This->IEnumConnections_iface;
  58     }else {
  59         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  60         *ppv = NULL;
  61         return E_NOINTERFACE;
  62     }
  63
  64     IUnknown_AddRef((IUnknown*)*ppv);
  65     return S_OK;
  66 }
  67
  68 static ULONG WINAPI EnumConnections_AddRef(IEnumConnections *iface)
  69 {
  70     EnumConnections *This = impl_from_IEnumConnections(iface);
  71     ULONG ref = InterlockedIncrement(&This->ref);
  72
  73     TRACE("(%p) ref=%d\n", This, ref);
  74
  75     return ref;
  76 }
  77
  78 static ULONG WINAPI EnumConnections_Release(IEnumConnections *iface)
  79 {
  80     EnumConnections *This = impl_from_IEnumConnections(iface);
  81     ULONG ref = InterlockedDecrement(&This->ref);
  82
  83     TRACE("(%p) ref=%d\n", This, ref);
  84
  85     if(!ref) {
  86         IConnectionPoint_Release(&This->cp->IConnectionPoint_iface);
  87         heap_free(This);
  88     }
  89
  90     return ref;
  91 }
  92
  93 static HRESULT WINAPI EnumConnections_Next(IEnumConnections *iface, ULONG cConnections, CONNECTDATA *rgcd, ULONG *pcFetched)
  94 {
  95     EnumConnections *This = impl_from_IEnumConnections(iface);
  96     ULONG fetched = 0;
  97
  98     TRACE("(%p)->(%d %p %p)\n", This, cConnections, rgcd, pcFetched);
  99
 100     while(fetched < cConnections && This->iter < This->cp->sinks_size) {
 101         if(!This->cp->sinks[This->iter].unk) {
 102             This->iter++;
 103             continue;
 104         }
 105
 106         rgcd[fetched].pUnk = This->cp->sinks[This->iter].unk;
 107         rgcd[fetched].dwCookie = ++This->iter;
 108         IUnknown_AddRef(rgcd[fetched].pUnk);
 109         fetched++;
 110     }
 111
 112     if(pcFetched)
 113         *pcFetched = fetched;
 114     return fetched == cConnections ? S_OK : S_FALSE;
 115 }
 116
 117 static HRESULT WINAPI EnumConnections_Skip(IEnumConnections *iface, ULONG cConnections)
 118 {
 119     EnumConnections *This = impl_from_IEnumConnections(iface);
 120     FIXME("(%p)->(%d)\n", This, cConnections);
 121     return E_NOTIMPL;
 122 }
 123
 124 static HRESULT WINAPI EnumConnections_Reset(IEnumConnections *iface)
 125 {
 126     EnumConnections *This = impl_from_IEnumConnections(iface);
 127     FIXME("(%p)\n", This);
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI EnumConnections_Clone(IEnumConnections *iface, IEnumConnections **ppEnum)
 132 {
 133     EnumConnections *This = impl_from_IEnumConnections(iface);
 134     FIXME("(%p)->(%p)\n", This, ppEnum);
 135     return E_NOTIMPL;
 136 }
 137
 138 static const IEnumConnectionsVtbl EnumConnectionsVtbl = {
 139     EnumConnections_QueryInterface,
 140     EnumConnections_AddRef,
 141     EnumConnections_Release,
 142     EnumConnections_Next,
 143     EnumConnections_Skip,
 144     EnumConnections_Reset,
 145     EnumConnections_Clone
 146 };
 147
 148 static inline ConnectionPoint *impl_from_IConnectionPoint(IConnectionPoint *iface)
 149 {
 150     return CONTAINING_RECORD(iface, ConnectionPoint, IConnectionPoint_iface);
 151 }
 152
 153 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface,
 154                                                      REFIID riid, LPVOID *ppv)
 155 {
 156     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 157
 158     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 159
 160     if(IsEqualGUID(&IID_IUnknown, riid)) {
 161         *ppv = &This->IConnectionPoint_iface;
 162     }else if(IsEqualGUID(&IID_IConnectionPoint, riid)) {
 163         *ppv = &This->IConnectionPoint_iface;
 164     }else {
 165         *ppv = NULL;
 166         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 167         return E_NOINTERFACE;
 168     }
 169
 170     IUnknown_AddRef((IUnknown*)*ppv);
 171     return S_OK;
 172 }
 173
 174 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
 175 {
 176     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 177     return IConnectionPointContainer_AddRef(&This->container->IConnectionPointContainer_iface);
 178 }
 179
 180 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
 181 {
 182     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 183     return IConnectionPointContainer_Release(&This->container->IConnectionPointContainer_iface);
 184 }
 185
 186 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
 187 {
 188     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 189
 190     TRACE("(%p)->(%p)\n", This, pIID);
 191
 192     if(!pIID)
 193         return E_POINTER;
 194
 195     *pIID = *This->iid;
 196     return S_OK;
 197 }
 198
 199 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
 200         IConnectionPointContainer **ppCPC)
 201 {
 202     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 203
 204     TRACE("(%p)->(%p)\n", This, ppCPC);
 205
 206     if(!ppCPC)
 207         return E_POINTER;
 208
 209     *ppCPC = &This->container->IConnectionPointContainer_iface;
 210     IConnectionPointContainer_AddRef(*ppCPC);
 211     return S_OK;
 212 }
 213
 214 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
 215                                              DWORD *pdwCookie)
 216 {
 217     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 218     IUnknown *sink;
 219     DWORD i;
 220     HRESULT hres;
 221
 222     TRACE("(%p)->(%p %p)\n", This, pUnkSink, pdwCookie);
 223
 224     hres = IUnknown_QueryInterface(pUnkSink, This->iid, (void**)&sink);
 225     if(FAILED(hres) && !IsEqualGUID(&IID_IPropertyNotifySink, This->iid))
 226         hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&sink);
 227     if(FAILED(hres))
 228         return CONNECT_E_CANNOTCONNECT;
 229
 230     if(This->sinks) {
 231         for(i=0; i<This->sinks_size; i++) {
 232             if(!This->sinks[i].unk)
 233                 break;
 234         }
 235
 236         if(i == This->sinks_size)
 237             This->sinks = heap_realloc(This->sinks,(++This->sinks_size)*sizeof(*This->sinks));
 238     }else {
 239         This->sinks = heap_alloc(sizeof(*This->sinks));
 240         This->sinks_size = 1;
 241         i = 0;
 242     }
 243
 244     This->sinks[i].unk = sink;
 245     if(pdwCookie)
 246         *pdwCookie = i+1;
 247
 248     if(!i && This->data && This->data->on_advise)
 249         This->data->on_advise(This->container->outer, This->data);
 250
 251     return S_OK;
 252 }
 253
 254 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 255 {
 256     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 257     TRACE("(%p)->(%d)\n", This, dwCookie);
 258
 259     if(!dwCookie || dwCookie > This->sinks_size || !This->sinks[dwCookie-1].unk)
 260         return CONNECT_E_NOCONNECTION;
 261
 262     IUnknown_Release(This->sinks[dwCookie-1].unk);
 263     This->sinks[dwCookie-1].unk = NULL;
 264
 265     return S_OK;
 266 }
 267
 268 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
 269                                                       IEnumConnections **ppEnum)
 270 {
 271     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 272     EnumConnections *ret;
 273
 274     TRACE("(%p)->(%p)\n", This, ppEnum);
 275
 276     ret = heap_alloc(sizeof(*ret));
 277     if(!ret)
 278         return E_OUTOFMEMORY;
 279
 280     ret->IEnumConnections_iface.lpVtbl = &EnumConnectionsVtbl;
 281     ret->ref = 1;
 282     ret->iter = 0;
 283
 284     IConnectionPoint_AddRef(&This->IConnectionPoint_iface);
 285     ret->cp = This;
 286
 287     *ppEnum = &ret->IEnumConnections_iface;
 288     return S_OK;
 289 }
 290
 291 static const IConnectionPointVtbl ConnectionPointVtbl =
 292 {
 293     ConnectionPoint_QueryInterface,
 294     ConnectionPoint_AddRef,
 295     ConnectionPoint_Release,
 296     ConnectionPoint_GetConnectionInterface,
 297     ConnectionPoint_GetConnectionPointContainer,
 298     ConnectionPoint_Advise,
 299     ConnectionPoint_Unadvise,
 300     ConnectionPoint_EnumConnections
 301 };
 302
 303 static void ConnectionPoint_Init(ConnectionPoint *cp, ConnectionPointContainer *container, REFIID riid, cp_static_data_t *data)
 304 {
 305     cp->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
 306     cp->container = container;
 307     cp->sinks = NULL;
 308     cp->sinks_size = 0;
 309     cp->iid = riid;
 310     cp->data = data;
 311 }
 312
 313 static void ConnectionPoint_Destroy(ConnectionPoint *This)
 314 {
 315     DWORD i;
 316
 317     for(i=0; i<This->sinks_size; i++) {
 318         if(This->sinks[i].unk)
 319             IUnknown_Release(This->sinks[i].unk);
 320     }
 321
 322     heap_free(This->sinks);
 323 }
 324
 325 static ConnectionPoint *get_cp(ConnectionPointContainer *container, REFIID riid, BOOL do_create)
 326 {
 327     const cpc_entry_t *iter;
 328     unsigned idx, i;
 329
 330     for(iter = container->cp_entries; iter->riid; iter++) {
 331         if(IsEqualGUID(iter->riid, riid))
 332             break;
 333     }
 334     if(!iter->riid)
 335         return NULL;
 336     idx = iter - container->cp_entries;
 337
 338     if(!container->cps) {
 339         if(!do_create)
 340             return NULL;
 341
 342         while(iter->riid)
 343             iter++;
 344         container->cps = heap_alloc((iter - container->cp_entries) * sizeof(*container->cps));
 345         if(!container->cps)
 346             return NULL;
 347
 348         for(i=0; container->cp_entries[i].riid; i++)
 349             ConnectionPoint_Init(container->cps+i, container, container->cp_entries[i].riid, container->cp_entries[i].desc);
 350     }
 351
 352     return container->cps+idx;
 353 }
 354
 355 void call_property_onchanged(ConnectionPointContainer *container, DISPID dispid)
 356 {
 357     ConnectionPoint *cp;
 358     DWORD i;
 359
 360     cp = get_cp(container, &IID_IPropertyNotifySink, FALSE);
 361     if(!cp)
 362         return;
 363
 364     for(i=0; i<cp->sinks_size; i++) {
 365         if(cp->sinks[i].propnotif)
 366             IPropertyNotifySink_OnChanged(cp->sinks[i].propnotif, dispid);
 367     }
 368 }
 369
 370 static inline ConnectionPointContainer *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
 371 {
 372     return CONTAINING_RECORD(iface, ConnectionPointContainer, IConnectionPointContainer_iface);
 373 }
 374
 375 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
 376                                                               REFIID riid, void **ppv)
 377 {
 378     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 379     return IUnknown_QueryInterface(This->outer, riid, ppv);
 380 }
 381
 382 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 383 {
 384     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 385     return IUnknown_AddRef(This->outer);
 386 }
 387
 388 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 389 {
 390     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 391     return IUnknown_Release(This->outer);
 392 }
 393
 394 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 395         IEnumConnectionPoints **ppEnum)
 396 {
 397     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 398     FIXME("(%p)->(%p)\n", This, ppEnum);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 403         REFIID riid, IConnectionPoint **ppCP)
 404 {
 405     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 406     ConnectionPoint *cp;
 407
 408     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppCP);
 409
 410     if(This->forward_container)
 411         return IConnectionPointContainer_FindConnectionPoint(&This->forward_container->IConnectionPointContainer_iface,
 412                 riid, ppCP);
 413
 414     cp = get_cp(This, riid, TRUE);
 415     if(!cp) {
 416         FIXME("unsupported riid %s\n", debugstr_mshtml_guid(riid));
 417         *ppCP = NULL;
 418         return CONNECT_E_NOCONNECTION;
 419     }
 420
 421     *ppCP = &cp->IConnectionPoint_iface;
 422     IConnectionPoint_AddRef(*ppCP);
 423     return S_OK;
 424 }
 425
 426 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
 427     ConnectionPointContainer_QueryInterface,
 428     ConnectionPointContainer_AddRef,
 429     ConnectionPointContainer_Release,
 430     ConnectionPointContainer_EnumConnectionPoints,
 431     ConnectionPointContainer_FindConnectionPoint
 432 };
 433
 434 void ConnectionPointContainer_Init(ConnectionPointContainer *This, IUnknown *outer, const cpc_entry_t *cp_entries)
 435 {
 436     This->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
 437     This->cp_entries = cp_entries;
 438     This->cps = NULL;
 439     This->outer = outer;
 440     This->forward_container = NULL;
 441 }
 442
 443 void ConnectionPointContainer_Destroy(ConnectionPointContainer *This)
 444 {
 445     unsigned i;
 446
 447     if(!This->cps)
 448         return;
 449
 450     for(i=0; This->cp_entries[i].riid; i++)
 451         ConnectionPoint_Destroy(This->cps+i);
 452     heap_free(This->cps);
 453 }