dlls/wmp/events.c

   1 /*
   2  * Implementation of event-related interfaces for WMP control:
   3  *
   4  *  - IConnectionPointContainer
   5  *  - IConnectionPoint
   6  *
   7  * Copyright 2001 John R. Sheets (for CodeWeavers)
   8  * Copyright 2006 Jacek Caban for CodeWeavers
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "wmp_private.h"
  26 #include "olectl.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(wmp);
  30
  31 static inline WindowsMediaPlayer *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
  32 {
  33     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IConnectionPointContainer_iface);
  34 }
  35
  36 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
  37         REFIID riid, LPVOID *ppv)
  38 {
  39     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
  40     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
  41 }
  42
  43 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
  44 {
  45     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
  46     return IOleObject_AddRef(&This->IOleObject_iface);
  47 }
  48
  49 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
  50 {
  51     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
  52     return IOleObject_Release(&This->IOleObject_iface);
  53 }
  54
  55 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
  56         IEnumConnectionPoints **ppEnum)
  57 {
  58     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
  59     FIXME("(%p)->(%p)\n", This, ppEnum);
  60     return E_NOTIMPL;
  61 }
  62
  63 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
  64         REFIID riid, IConnectionPoint **ppCP){
  65     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
  66
  67     if(!ppCP) {
  68         WARN("ppCP == NULL\n");
  69         return E_POINTER;
  70     }
  71
  72     *ppCP = NULL;
  73
  74     if(IsEqualGUID(&IID__WMPOCXEvents, riid)) {
  75         TRACE("(%p)->(IID__WMPOCXEvents %p)\n", This, ppCP);
  76         *ppCP = &This->wmpocx->IConnectionPoint_iface;
  77     }
  78
  79     if(*ppCP) {
  80         IConnectionPoint_AddRef(*ppCP);
  81         return S_OK;
  82     }
  83
  84     WARN("Unsupported IID %s\n", debugstr_guid(riid));
  85     return CONNECT_E_NOCONNECTION;
  86 }
  87
  88 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
  89 {
  90     ConnectionPointContainer_QueryInterface,
  91     ConnectionPointContainer_AddRef,
  92     ConnectionPointContainer_Release,
  93     ConnectionPointContainer_EnumConnectionPoints,
  94     ConnectionPointContainer_FindConnectionPoint
  95 };
  96
  97 static inline ConnectionPoint *impl_from_IConnectionPoint(IConnectionPoint *iface)
  98 {
  99     return CONTAINING_RECORD(iface, ConnectionPoint, IConnectionPoint_iface);
 100 }
 101
 102 typedef struct {
 103     IEnumConnections IEnumConnections_iface;
 104
 105     LONG ref;
 106
 107     ConnectionPoint *cp;
 108     DWORD iter;
 109 } EnumConnections;
 110
 111 static inline EnumConnections *impl_from_IEnumConnections(IEnumConnections *iface)
 112 {
 113     return CONTAINING_RECORD(iface, EnumConnections, IEnumConnections_iface);
 114 }
 115
 116 static HRESULT WINAPI EnumConnections_QueryInterface(IEnumConnections *iface, REFIID riid, void **ppv)
 117 {
 118     EnumConnections *This = impl_from_IEnumConnections(iface);
 119
 120     if(IsEqualGUID(&IID_IUnknown, riid)) {
 121         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 122         *ppv = &This->IEnumConnections_iface;
 123     }else if(IsEqualGUID(&IID_IEnumConnections, riid)) {
 124         TRACE("(%p)->(IID_IEnumConnections %p)\n", This, ppv);
 125         *ppv = &This->IEnumConnections_iface;
 126     }else {
 127         WARN("Unsupported interface %s\n", debugstr_guid(riid));
 128         *ppv = NULL;
 129         return E_NOINTERFACE;
 130     }
 131
 132     IUnknown_AddRef((IUnknown*)*ppv);
 133     return S_OK;
 134 }
 135
 136 static ULONG WINAPI EnumConnections_AddRef(IEnumConnections *iface)
 137 {
 138     EnumConnections *This = impl_from_IEnumConnections(iface);
 139     LONG ref = InterlockedIncrement(&This->ref);
 140
 141     TRACE("(%p) ref=%d\n", This, ref);
 142
 143     return ref;
 144 }
 145
 146 static ULONG WINAPI EnumConnections_Release(IEnumConnections *iface)
 147 {
 148     EnumConnections *This = impl_from_IEnumConnections(iface);
 149     LONG ref = InterlockedDecrement(&This->ref);
 150
 151     TRACE("(%p) ref=%d\n", This, ref);
 152
 153     if(!ref) {
 154         IConnectionPoint_Release(&This->cp->IConnectionPoint_iface);
 155         heap_free(This);
 156     }
 157
 158     return ref;
 159 }
 160
 161 static HRESULT WINAPI EnumConnections_Next(IEnumConnections *iface, ULONG cConnections, CONNECTDATA *pgcd, ULONG *pcFetched)
 162 {
 163     EnumConnections *This = impl_from_IEnumConnections(iface);
 164     ULONG cnt = 0;
 165
 166     TRACE("(%p)->(%u %p %p)\n", This, cConnections, pgcd, pcFetched);
 167
 168     while(cConnections--) {
 169         while(This->iter < This->cp->sinks_size && !This->cp->sinks[This->iter])
 170             This->iter++;
 171         if(This->iter == This->cp->sinks_size)
 172             break;
 173
 174         pgcd[cnt].pUnk = (IUnknown*)This->cp->sinks[This->iter];
 175         pgcd[cnt].dwCookie = cnt+1;
 176         This->iter++;
 177         cnt++;
 178         IUnknown_AddRef(pgcd[cnt].pUnk);
 179     }
 180
 181     if(pcFetched)
 182         *pcFetched = cnt;
 183     return cnt ? S_OK : S_FALSE;
 184 }
 185
 186 static HRESULT WINAPI EnumConnections_Skip(IEnumConnections *iface, ULONG cConnections)
 187 {
 188     EnumConnections *This = impl_from_IEnumConnections(iface);
 189     FIXME("(%p)->(%u)\n", This, cConnections);
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI EnumConnections_Reset(IEnumConnections *iface)
 194 {
 195     EnumConnections *This = impl_from_IEnumConnections(iface);
 196     FIXME("(%p)\n", This);
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI EnumConnections_Clone(IEnumConnections *iface, IEnumConnections **ppEnum)
 201 {
 202     EnumConnections *This = impl_from_IEnumConnections(iface);
 203     FIXME("(%p)->(%p)\n", This, ppEnum);
 204     return E_NOTIMPL;
 205 }
 206
 207 static const IEnumConnectionsVtbl EnumConnectionsVtbl = {
 208     EnumConnections_QueryInterface,
 209     EnumConnections_AddRef,
 210     EnumConnections_Release,
 211     EnumConnections_Next,
 212     EnumConnections_Skip,
 213     EnumConnections_Reset,
 214     EnumConnections_Clone
 215 };
 216
 217 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface,
 218                                                      REFIID riid, LPVOID *ppv)
 219 {
 220     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 221
 222     *ppv = NULL;
 223
 224     if(IsEqualGUID(&IID_IUnknown, riid)) {
 225         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 226         *ppv = &This->IConnectionPoint_iface;
 227     }else if(IsEqualGUID(&IID_IConnectionPoint, riid)) {
 228         TRACE("(%p)->(IID_IConnectionPoint %p)\n", This, ppv);
 229         *ppv = &This->IConnectionPoint_iface;
 230     }
 231
 232     if(*ppv) {
 233         IConnectionPointContainer_AddRef(This->container);
 234         return S_OK;
 235     }
 236
 237     WARN("Unsupported interface %s\n", debugstr_guid(riid));
 238     return E_NOINTERFACE;
 239 }
 240
 241 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
 242 {
 243     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 244     return IConnectionPointContainer_AddRef(This->container);
 245 }
 246
 247 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
 248 {
 249     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 250     return IConnectionPointContainer_Release(This->container);
 251 }
 252
 253 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
 254 {
 255     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 256
 257     TRACE("(%p)->(%p)\n", This, pIID);
 258
 259     *pIID = This->iid;
 260     return S_OK;
 261 }
 262
 263 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
 264         IConnectionPointContainer **ppCPC)
 265 {
 266     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 267
 268     TRACE("(%p)->(%p)\n", This, ppCPC);
 269
 270     *ppCPC = This->container;
 271     IConnectionPointContainer_AddRef(This->container);
 272     return S_OK;
 273 }
 274
 275 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
 276                                              DWORD *pdwCookie)
 277 {
 278     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 279     IDispatch *disp;
 280     DWORD i;
 281     HRESULT hres;
 282
 283     TRACE("(%p)->(%p %p)\n", This, pUnkSink, pdwCookie);
 284
 285     hres = IUnknown_QueryInterface(pUnkSink, &This->iid, (void**)&disp);
 286     if(FAILED(hres)) {
 287         hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&disp);
 288         if(FAILED(hres))
 289             return CONNECT_E_CANNOTCONNECT;
 290     }
 291
 292     if(This->sinks) {
 293         for(i=0; i<This->sinks_size; i++) {
 294             if(!This->sinks[i])
 295                 break;
 296         }
 297
 298         if(i == This->sinks_size)
 299             This->sinks = heap_realloc(This->sinks,
 300                     (++This->sinks_size)*sizeof(*This->sinks));
 301     }else {
 302         This->sinks = heap_alloc(sizeof(*This->sinks));
 303         This->sinks_size = 1;
 304         i = 0;
 305     }
 306
 307     This->sinks[i] = disp;
 308     *pdwCookie = i+1;
 309
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 314 {
 315     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 316
 317     TRACE("(%p)->(%d)\n", This, dwCookie);
 318
 319     if(!dwCookie || dwCookie > This->sinks_size || !This->sinks[dwCookie-1])
 320         return CONNECT_E_NOCONNECTION;
 321
 322     IDispatch_Release(This->sinks[dwCookie-1]);
 323     This->sinks[dwCookie-1] = NULL;
 324
 325     return S_OK;
 326 }
 327
 328 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
 329                                                       IEnumConnections **ppEnum)
 330 {
 331     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 332     EnumConnections *ret;
 333
 334     TRACE("(%p)->(%p)\n", This, ppEnum);
 335
 336     ret = heap_alloc(sizeof(*ret));
 337     if(!ret)
 338         return E_OUTOFMEMORY;
 339
 340     ret->IEnumConnections_iface.lpVtbl = &EnumConnectionsVtbl;
 341     ret->ref = 1;
 342     ret->iter = 0;
 343
 344     IConnectionPoint_AddRef(&This->IConnectionPoint_iface);
 345     ret->cp = This;
 346
 347     *ppEnum = &ret->IEnumConnections_iface;
 348     return S_OK;
 349 }
 350
 351
 352 static const IConnectionPointVtbl ConnectionPointVtbl =
 353 {
 354     ConnectionPoint_QueryInterface,
 355     ConnectionPoint_AddRef,
 356     ConnectionPoint_Release,
 357     ConnectionPoint_GetConnectionInterface,
 358     ConnectionPoint_GetConnectionPointContainer,
 359     ConnectionPoint_Advise,
 360     ConnectionPoint_Unadvise,
 361     ConnectionPoint_EnumConnections
 362 };
 363
 364 static void ConnectionPoint_Destroy(ConnectionPoint *This)
 365 {
 366     DWORD i;
 367
 368     for(i=0; i<This->sinks_size; i++) {
 369         if(This->sinks[i])
 370             IDispatch_Release(This->sinks[i]);
 371     }
 372
 373     heap_free(This->sinks);
 374     heap_free(This);
 375 }
 376
 377 static void ConnectionPoint_Create(REFIID riid, ConnectionPoint **cp,
 378                                    IConnectionPointContainer *container)
 379 {
 380     ConnectionPoint *ret = heap_alloc(sizeof(ConnectionPoint));
 381
 382     ret->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
 383
 384     ret->sinks = NULL;
 385     ret->sinks_size = 0;
 386     ret->container = container;
 387
 388     ret->iid = *riid;
 389
 390     *cp = ret;
 391 }
 392
 393 void ConnectionPointContainer_Init(WindowsMediaPlayer *wmp)
 394 {
 395     wmp->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
 396     ConnectionPoint_Create(&IID__WMPOCXEvents, &wmp->wmpocx, &wmp->IConnectionPointContainer_iface);
 397 }
 398
 399 void ConnectionPointContainer_Destroy(WindowsMediaPlayer *wmp)
 400 {
 401     ConnectionPoint_Destroy(wmp->wmpocx);
 402 }
 403
 404 void call_sink(ConnectionPoint *This, DISPID dispid, DISPPARAMS *dispparams)
 405 {
 406     DWORD i;
 407
 408     for(i=0; i<This->sinks_size; i++) {
 409         if(This->sinks[i])
 410             IDispatch_Invoke(This->sinks[i], dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
 411                     DISPATCH_METHOD, dispparams, NULL, NULL, NULL);
 412     }
 413 }