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=%ld\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=%ld\n", This, ref);
 152
 153     if(!ref) {
 154         IConnectionPoint_Release(&This->cp->IConnectionPoint_iface);
 155         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)->(%lu %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)->(%lu)\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 = realloc(This->sinks, (++This->sinks_size)*sizeof(*This->sinks));
 300     }else {
 301         This->sinks = malloc(sizeof(*This->sinks));
 302         This->sinks_size = 1;
 303         i = 0;
 304     }
 305
 306     This->sinks[i] = disp;
 307     *pdwCookie = i+1;
 308
 309     return S_OK;
 310 }
 311
 312 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 313 {
 314     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 315
 316     TRACE("(%p)->(%ld)\n", This, dwCookie);
 317
 318     if(!dwCookie || dwCookie > This->sinks_size || !This->sinks[dwCookie-1])
 319         return CONNECT_E_NOCONNECTION;
 320
 321     IDispatch_Release(This->sinks[dwCookie-1]);
 322     This->sinks[dwCookie-1] = NULL;
 323
 324     return S_OK;
 325 }
 326
 327 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
 328                                                       IEnumConnections **ppEnum)
 329 {
 330     ConnectionPoint *This = impl_from_IConnectionPoint(iface);
 331     EnumConnections *ret;
 332
 333     TRACE("(%p)->(%p)\n", This, ppEnum);
 334
 335     ret = malloc(sizeof(*ret));
 336     if(!ret)
 337         return E_OUTOFMEMORY;
 338
 339     ret->IEnumConnections_iface.lpVtbl = &EnumConnectionsVtbl;
 340     ret->ref = 1;
 341     ret->iter = 0;
 342
 343     IConnectionPoint_AddRef(&This->IConnectionPoint_iface);
 344     ret->cp = This;
 345
 346     *ppEnum = &ret->IEnumConnections_iface;
 347     return S_OK;
 348 }
 349
 350
 351 static const IConnectionPointVtbl ConnectionPointVtbl =
 352 {
 353     ConnectionPoint_QueryInterface,
 354     ConnectionPoint_AddRef,
 355     ConnectionPoint_Release,
 356     ConnectionPoint_GetConnectionInterface,
 357     ConnectionPoint_GetConnectionPointContainer,
 358     ConnectionPoint_Advise,
 359     ConnectionPoint_Unadvise,
 360     ConnectionPoint_EnumConnections
 361 };
 362
 363 static void ConnectionPoint_Destroy(ConnectionPoint *This)
 364 {
 365     DWORD i;
 366
 367     for(i=0; i<This->sinks_size; i++) {
 368         if(This->sinks[i])
 369             IDispatch_Release(This->sinks[i]);
 370     }
 371
 372     free(This->sinks);
 373     free(This);
 374 }
 375
 376 static void ConnectionPoint_Create(REFIID riid, ConnectionPoint **cp,
 377                                    IConnectionPointContainer *container)
 378 {
 379     ConnectionPoint *ret = malloc(sizeof(ConnectionPoint));
 380
 381     ret->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
 382
 383     ret->sinks = NULL;
 384     ret->sinks_size = 0;
 385     ret->container = container;
 386
 387     ret->iid = *riid;
 388
 389     *cp = ret;
 390 }
 391
 392 void ConnectionPointContainer_Init(WindowsMediaPlayer *wmp)
 393 {
 394     wmp->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
 395     ConnectionPoint_Create(&IID__WMPOCXEvents, &wmp->wmpocx, &wmp->IConnectionPointContainer_iface);
 396 }
 397
 398 void ConnectionPointContainer_Destroy(WindowsMediaPlayer *wmp)
 399 {
 400     ConnectionPoint_Destroy(wmp->wmpocx);
 401 }
 402
 403 void call_sink(ConnectionPoint *This, DISPID dispid, DISPPARAMS *dispparams)
 404 {
 405     DWORD i;
 406
 407     for(i=0; i<This->sinks_size; i++) {
 408         if(This->sinks[i])
 409             IDispatch_Invoke(This->sinks[i], dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
 410                     DISPATCH_METHOD, dispparams, NULL, NULL, NULL);
 411     }
 412 }