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=%ld\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=%ld\n", This, ref);
  84
  85     if(!ref) {
  86         IConnectionPoint_Release(&This->cp->IConnectionPoint_iface);
  87         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)->(%ld %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)->(%ld)\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     void *new_sinks;
 220     DWORD i;
 221     HRESULT hres;
 222
 223     TRACE("(%p)->(%p %p)\n", This, pUnkSink, pdwCookie);
 224
 225     hres = IUnknown_QueryInterface(pUnkSink, This->iid, (void**)&sink);
 226     if(FAILED(hres) && !IsEqualGUID(&IID_IPropertyNotifySink, This->iid))
 227         hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&sink);
 228     if(FAILED(hres))
 229         return CONNECT_E_CANNOTCONNECT;
 230
 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         new_sinks = realloc(This->sinks, (This->sinks_size + 1) * sizeof(*This->sinks));
 238         if(!new_sinks) {
 239             IUnknown_Release(sink);
 240             return E_OUTOFMEMORY;
 241         }
 242         This->sinks = new_sinks;
 243         This->sinks_size++;
 244     }
 245
 246     This->sinks[i].unk = sink;
 247     if(pdwCookie)
 248         *pdwCookie = i+1;
 249
 250     if(!i && This->data && This->data->on_advise)
 251         This->data->on_advise(This->container->outer, This->data);
 252
 253     return S_OK;
 254 }
 255
 256 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 257 {
 258     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 259     TRACE("(%p)->(%ld)\n", This, dwCookie);
 260
 261     if(!dwCookie || dwCookie > This->sinks_size || !This->sinks[dwCookie-1].unk)
 262         return CONNECT_E_NOCONNECTION;
 263
 264     IUnknown_Release(This->sinks[dwCookie-1].unk);
 265     This->sinks[dwCookie-1].unk = NULL;
 266
 267     return S_OK;
 268 }
 269
 270 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
 271                                                       IEnumConnections **ppEnum)
 272 {
 273     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 274     EnumConnections *ret;
 275
 276     TRACE("(%p)->(%p)\n", This, ppEnum);
 277
 278     ret = malloc(sizeof(*ret));
 279     if(!ret)
 280         return E_OUTOFMEMORY;
 281
 282     ret->IEnumConnections_iface.lpVtbl = &EnumConnectionsVtbl;
 283     ret->ref = 1;
 284     ret->iter = 0;
 285
 286     IConnectionPoint_AddRef(&This->IConnectionPoint_iface);
 287     ret->cp = This;
 288
 289     *ppEnum = &ret->IEnumConnections_iface;
 290     return S_OK;
 291 }
 292
 293 static const IConnectionPointVtbl ConnectionPointVtbl =
 294 {
 295     ConnectionPoint_QueryInterface,
 296     ConnectionPoint_AddRef,
 297     ConnectionPoint_Release,
 298     ConnectionPoint_GetConnectionInterface,
 299     ConnectionPoint_GetConnectionPointContainer,
 300     ConnectionPoint_Advise,
 301     ConnectionPoint_Unadvise,
 302     ConnectionPoint_EnumConnections
 303 };
 304
 305 static void ConnectionPoint_Init(ConnectionPoint *cp, ConnectionPointContainer *container, REFIID riid, cp_static_data_t *data)
 306 {
 307     cp->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
 308     cp->container = container;
 309     cp->sinks = NULL;
 310     cp->sinks_size = 0;
 311     cp->iid = riid;
 312     cp->data = data;
 313 }
 314
 315 static void ConnectionPoint_Destroy(ConnectionPoint *This)
 316 {
 317     DWORD i;
 318
 319     for(i=0; i<This->sinks_size; i++) {
 320         if(This->sinks[i].unk)
 321             IUnknown_Release(This->sinks[i].unk);
 322     }
 323
 324     free(This->sinks);
 325 }
 326
 327 static ConnectionPoint *get_cp(ConnectionPointContainer *container, REFIID riid, BOOL do_create)
 328 {
 329     const cpc_entry_t *iter;
 330     unsigned idx, i;
 331
 332     for(iter = container->cp_entries; iter->riid; iter++) {
 333         if(IsEqualGUID(iter->riid, riid))
 334             break;
 335     }
 336     if(!iter->riid)
 337         return NULL;
 338     idx = iter - container->cp_entries;
 339
 340     if(!container->cps) {
 341         if(!do_create)
 342             return NULL;
 343
 344         while(iter->riid)
 345             iter++;
 346         container->cps = malloc((iter - container->cp_entries) * sizeof(*container->cps));
 347         if(!container->cps)
 348             return NULL;
 349
 350         for(i=0; container->cp_entries[i].riid; i++)
 351             ConnectionPoint_Init(container->cps+i, container, container->cp_entries[i].riid, container->cp_entries[i].desc);
 352     }
 353
 354     return container->cps+idx;
 355 }
 356
 357 void call_property_onchanged(ConnectionPointContainer *container, DISPID dispid)
 358 {
 359     ConnectionPoint *cp;
 360     DWORD i;
 361
 362     cp = get_cp(container, &IID_IPropertyNotifySink, FALSE);
 363     if(!cp)
 364         return;
 365
 366     for(i=0; i<cp->sinks_size; i++) {
 367         if(cp->sinks[i].propnotif)
 368             IPropertyNotifySink_OnChanged(cp->sinks[i].propnotif, dispid);
 369     }
 370 }
 371
 372 static inline ConnectionPointContainer *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
 373 {
 374     return CONTAINING_RECORD(iface, ConnectionPointContainer, IConnectionPointContainer_iface);
 375 }
 376
 377 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
 378                                                               REFIID riid, void **ppv)
 379 {
 380     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 381     return IUnknown_QueryInterface(This->outer, riid, ppv);
 382 }
 383
 384 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 385 {
 386     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 387     return IUnknown_AddRef(This->outer);
 388 }
 389
 390 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 391 {
 392     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 393     return IUnknown_Release(This->outer);
 394 }
 395
 396 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 397         IEnumConnectionPoints **ppEnum)
 398 {
 399     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 400     FIXME("(%p)->(%p)\n", This, ppEnum);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 405         REFIID riid, IConnectionPoint **ppCP)
 406 {
 407     ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface);
 408     ConnectionPoint *cp;
 409
 410     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppCP);
 411
 412     if(This->forward_container)
 413         return IConnectionPointContainer_FindConnectionPoint(&This->forward_container->IConnectionPointContainer_iface,
 414                 riid, ppCP);
 415
 416     cp = get_cp(This, riid, TRUE);
 417     if(!cp) {
 418         FIXME("unsupported riid %s\n", debugstr_mshtml_guid(riid));
 419         *ppCP = NULL;
 420         return CONNECT_E_NOCONNECTION;
 421     }
 422
 423     *ppCP = &cp->IConnectionPoint_iface;
 424     IConnectionPoint_AddRef(*ppCP);
 425     return S_OK;
 426 }
 427
 428 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
 429     ConnectionPointContainer_QueryInterface,
 430     ConnectionPointContainer_AddRef,
 431     ConnectionPointContainer_Release,
 432     ConnectionPointContainer_EnumConnectionPoints,
 433     ConnectionPointContainer_FindConnectionPoint
 434 };
 435
 436 void ConnectionPointContainer_Init(ConnectionPointContainer *This, IUnknown *outer, const cpc_entry_t *cp_entries)
 437 {
 438     This->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
 439     This->cp_entries = cp_entries;
 440     This->cps = NULL;
 441     This->outer = outer;
 442     This->forward_container = NULL;
 443 }
 444
 445 void ConnectionPointContainer_Destroy(ConnectionPointContainer *This)
 446 {
 447     unsigned i;
 448
 449     if(!This->cps)
 450         return;
 451
 452     for(i=0; This->cp_entries[i].riid; i++)
 453         ConnectionPoint_Destroy(This->cps+i);
 454     free(This->cps);
 455 }