Wine Cross Reference
wine/dlls/mshtml/conpoint.c

   /*
    * Copyright 2006 Jacek Caban for CodeWeavers
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
    * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #include <stdarg.h>
  
  #define COBJMACROS
  
  #include "windef.h"
  #include "winbase.h"
  #include "winuser.h"
  #include "ole2.h"
  
  #include "wine/debug.h"
  
  #include "mshtml_private.h"
  
  WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  
  #define CONPOINT(x) ((IConnectionPoint*) &(x)->lpConnectionPointVtbl);
  
  static const char *debugstr_cp_guid(REFIID riid)
  {
  #define X(x) \
      if(IsEqualGUID(riid, &x)) \
          return #x
  
      X(IID_IPropertyNotifySink);
      X(DIID_HTMLDocumentEvents);
      X(DIID_HTMLDocumentEvents2);
      X(DIID_HTMLTableEvents);
      X(DIID_HTMLTextContainerEvents);
  
  #undef X
  
      return debugstr_guid(riid);
  }
  
  void call_property_onchanged(ConnectionPoint *This, DISPID dispid)
  {
      DWORD i;
  
      for(i=0; i<This->sinks_size; i++) {
          if(This->sinks[i].propnotif)
              IPropertyNotifySink_OnChanged(This->sinks[i].propnotif, dispid);
      }
  }
  
  #define CONPOINT_THIS(iface) DEFINE_THIS(ConnectionPoint, ConnectionPoint, iface)
  
  static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface,
                                                       REFIID riid, LPVOID *ppv)
  {
      ConnectionPoint *This = CONPOINT_THIS(iface);
  
      *ppv = NULL;
  
      if(IsEqualGUID(&IID_IUnknown, riid)) {
          TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
          *ppv = CONPOINT(This);
      }else if(IsEqualGUID(&IID_IConnectionPoint, riid)) {
          TRACE("(%p)->(IID_IConnectionPoint %p)\n", This, ppv);
          *ppv = CONPOINT(This);
      }
  
      if(*ppv) {
          IUnknown_AddRef((IUnknown*)*ppv);
          return S_OK;
      }
  
      WARN("Unsupported interface %s\n", debugstr_guid(riid));
      return E_NOINTERFACE;
  }
  
  static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
  {
      ConnectionPoint *This = CONPOINT_THIS(iface);
      return IConnectionPointContainer_AddRef(This->container);
  }
  
  static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
  {
      ConnectionPoint *This = CONPOINT_THIS(iface);
      return IConnectionPointContainer_Release(This->container);
  }
 
 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
 {
     ConnectionPoint *This = CONPOINT_THIS(iface);
 
     TRACE("(%p)->(%p)\n", This, pIID);
 
     if(!pIID)
         return E_POINTER;
 
     *pIID = *This->iid;
     return S_OK;
 }
 
 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
         IConnectionPointContainer **ppCPC)
 {
     ConnectionPoint *This = CONPOINT_THIS(iface);
 
     TRACE("(%p)->(%p)\n", This, ppCPC);
 
     if(!ppCPC)
         return E_POINTER;
 
     *ppCPC = This->container;
     IConnectionPointContainer_AddRef(*ppCPC);
     return S_OK;
 }
 
 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
                                              DWORD *pdwCookie)
 {
     ConnectionPoint *This = CONPOINT_THIS(iface);
     IUnknown *sink;
     DWORD i;
     HRESULT hres;
 
     TRACE("(%p)->(%p %p)\n", This, pUnkSink, pdwCookie);
 
     hres = IUnknown_QueryInterface(pUnkSink, This->iid, (void**)&sink);
     if(FAILED(hres) && !IsEqualGUID(&IID_IPropertyNotifySink, This->iid))
         hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&sink);
     if(FAILED(hres))
         return CONNECT_E_CANNOTCONNECT;
 
     if(This->sinks) {
         for(i=0; i<This->sinks_size; i++) {
             if(!This->sinks[i].unk)
                 break;
         }
 
         if(i == This->sinks_size)
             This->sinks = heap_realloc(This->sinks,(++This->sinks_size)*sizeof(*This->sinks));
     }else {
         This->sinks = heap_alloc(sizeof(*This->sinks));
         This->sinks_size = 1;
         i = 0;
     }
 
     This->sinks[i].unk = sink;
     *pdwCookie = i+1;
 
     return S_OK;
 }
 
 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 {
     ConnectionPoint *This = CONPOINT_THIS(iface);
     TRACE("(%p)->(%d)\n", This, dwCookie);
 
     if(!dwCookie || dwCookie > This->sinks_size || !This->sinks[dwCookie-1].unk)
         return CONNECT_E_NOCONNECTION;
 
     IUnknown_Release(This->sinks[dwCookie-1].unk);
     This->sinks[dwCookie-1].unk = NULL;
 
     return S_OK;
 }
 
 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
                                                       IEnumConnections **ppEnum)
 {
     ConnectionPoint *This = CONPOINT_THIS(iface);
     FIXME("(%p)->(%p)\n", This, ppEnum);
     return E_NOTIMPL;
 }
 
 #undef CONPOINT_THIS
 
 static const IConnectionPointVtbl ConnectionPointVtbl =
 {
     ConnectionPoint_QueryInterface,
     ConnectionPoint_AddRef,
     ConnectionPoint_Release,
     ConnectionPoint_GetConnectionInterface,
     ConnectionPoint_GetConnectionPointContainer,
     ConnectionPoint_Advise,
     ConnectionPoint_Unadvise,
     ConnectionPoint_EnumConnections
 };
 
 void ConnectionPoint_Init(ConnectionPoint *cp, ConnectionPointContainer *container, REFIID riid, cp_static_data_t *data)
 {
     cp->lpConnectionPointVtbl = &ConnectionPointVtbl;
     cp->container = CONPTCONT(container);
     cp->sinks = NULL;
     cp->sinks_size = 0;
     cp->iid = riid;
     cp->next = NULL;
     cp->data = data;
 
     cp->next = container->cp_list;
     container->cp_list = cp;
 }
 
 static void ConnectionPoint_Destroy(ConnectionPoint *This)
 {
     DWORD i;
 
     for(i=0; i<This->sinks_size; i++) {
         if(This->sinks[i].unk)
             IUnknown_Release(This->sinks[i].unk);
     }
 
     heap_free(This->sinks);
 }
 
 #define CONPTCONT_THIS(iface) DEFINE_THIS(ConnectionPointContainer, ConnectionPointContainer, iface)
 
 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
                                                               REFIID riid, void **ppv)
 {
     ConnectionPointContainer *This = CONPTCONT_THIS(iface);
     return IUnknown_QueryInterface(This->outer, riid, ppv);
 }
 
 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 {
     ConnectionPointContainer *This = CONPTCONT_THIS(iface);
     return IUnknown_AddRef(This->outer);
 }
 
 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 {
     ConnectionPointContainer *This = CONPTCONT_THIS(iface);
     return IUnknown_Release(This->outer);
 }
 
 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
         IEnumConnectionPoints **ppEnum)
 {
     ConnectionPointContainer *This = CONPTCONT_THIS(iface);
     FIXME("(%p)->(%p)\n", This, ppEnum);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
         REFIID riid, IConnectionPoint **ppCP)
 {
     ConnectionPointContainer *This = CONPTCONT_THIS(iface);
     ConnectionPoint *iter;
 
     TRACE("(%p)->(%s %p)\n", This, debugstr_cp_guid(riid), ppCP);
 
     if(This->forward_container)
         return IConnectionPointContainer_FindConnectionPoint(CONPTCONT(This), riid, ppCP);
 
     *ppCP = NULL;
 
     for(iter = This->cp_list; iter; iter = iter->next) {
         if(IsEqualGUID(iter->iid, riid))
             *ppCP = CONPOINT(iter);
     }
 
     if(*ppCP) {
         IConnectionPoint_AddRef(*ppCP);
         return S_OK;
     }
 
     FIXME("unsupported riid %s\n", debugstr_cp_guid(riid));
     return CONNECT_E_NOCONNECTION;
 }
 
 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
     ConnectionPointContainer_QueryInterface,
     ConnectionPointContainer_AddRef,
     ConnectionPointContainer_Release,
     ConnectionPointContainer_EnumConnectionPoints,
     ConnectionPointContainer_FindConnectionPoint
 };
 
 #undef CONPTCONT_THIS
 
 void ConnectionPointContainer_Init(ConnectionPointContainer *This, IUnknown *outer)
 {
     This->lpConnectionPointContainerVtbl = &ConnectionPointContainerVtbl;
     This->cp_list = NULL;
     This->outer = outer;
 }
 
 void ConnectionPointContainer_Destroy(ConnectionPointContainer *This)
 {
     ConnectionPoint *iter = This->cp_list;
 
     while(iter) {
         ConnectionPoint_Destroy(iter);
         iter = iter->next;
     }
 }