diff --git a/reactos/include/wine/objidl.h b/reactos/include/wine/objidl.h index 4dbdf4734c4..0cca35d0162 100644 --- a/reactos/include/wine/objidl.h +++ b/reactos/include/wine/objidl.h @@ -94,10 +94,6 @@ typedef struct tagRemSTGMEDIUM { unsigned long cbData; BYTE data[1]; } RemSTGMEDIUM; -typedef struct tagHLITEM { - ULONG uHLID; - LPWSTR pwzFriendlyName; -} HLITEM; typedef struct tagSTATDATA { FORMATETC formatetc; DWORD grfAdvf; @@ -430,7 +426,6 @@ EXTERN_C const FMTID FMTID_DocSummaryInformation; EXTERN_C const FMTID FMTID_UserDefinedProperties; DECLARE_ENUMERATOR(FORMATETC); -DECLARE_ENUMERATOR(HLITEM); DECLARE_ENUMERATOR(STATDATA); DECLARE_ENUMERATOR(STATPROPSETSTG); DECLARE_ENUMERATOR(STATPROPSTG); diff --git a/reactos/lib/shdocvw/client.c b/reactos/lib/shdocvw/client.c index d616b90e47f..170a9a96d0d 100644 --- a/reactos/lib/shdocvw/client.c +++ b/reactos/lib/shdocvw/client.c @@ -47,6 +47,9 @@ static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID ri }else if(IsEqualGUID(&IID_IDocHostUIHandler2, riid)) { TRACE("(%p)->(IID_IDocHostUIHandler2 %p)\n", This, ppv); *ppv = DOCHOSTUI2(This); + }else if(IsEqualGUID(&IID_IOleDocumentSite, riid)) { + TRACE("(%p)->(IID_IOleDocumentSite %p)\n", This, ppv); + *ppv = DOCSITE(This); } if(*ppv) { @@ -168,15 +171,21 @@ static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, B static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface) { WebBrowser *This = INPLACESITE_THIS(iface); - FIXME("(%p)\n", This); - return E_NOTIMPL; + + TRACE("(%p)\n", This); + + /* Nothing to do here */ + return S_OK; } static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface) { WebBrowser *This = INPLACESITE_THIS(iface); - FIXME("(%p)\n", This); - return E_NOTIMPL; + + TRACE("(%p)\n", This); + + /* Nothing to do here */ + return S_OK; } static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface) @@ -191,9 +200,23 @@ static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo) { WebBrowser *This = INPLACESITE_THIS(iface); - FIXME("(%p)->(%p %p %p %p %p)\n", This, ppFrame, ppDoc, lprcPosRect, + + TRACE("(%p)->(%p %p %p %p %p)\n", This, ppFrame, ppDoc, lprcPosRect, lprcClipRect, lpFrameInfo); - return E_NOTIMPL; + + *ppFrame = INPLACEFRAME(This); + *ppDoc = NULL; + + GetClientRect(This->doc_view_hwnd, lprcPosRect); + memcpy(lprcClipRect, lprcPosRect, sizeof(RECT)); + + lpFrameInfo->cb = sizeof(*lpFrameInfo); + lpFrameInfo->fMDIApp = FALSE; + lpFrameInfo->hwndFrame = This->shell_embedding_hwnd; + lpFrameInfo->haccel = NULL; + lpFrameInfo->cAccelEntries = 0; /* FIXME: should be 5 */ + + return S_OK; } static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtent) @@ -259,8 +282,72 @@ static const IOleInPlaceSiteVtbl OleInPlaceSiteVtbl = { InPlaceSite_OnPosRectChange }; +#define DOCSITE_THIS(iface) DEFINE_THIS(WebBrowser, OleDocumentSite, iface) + +static HRESULT WINAPI OleDocumentSite_QueryInterface(IOleDocumentSite *iface, + REFIID riid, void **ppv) +{ + WebBrowser *This = DOCSITE_THIS(iface); + return IOleClientSite_QueryInterface(CLIENTSITE(This), riid, ppv); +} + +static ULONG WINAPI OleDocumentSite_AddRef(IOleDocumentSite *iface) +{ + WebBrowser *This = DOCSITE_THIS(iface); + return IOleClientSite_AddRef(CLIENTSITE(This)); +} + +static ULONG WINAPI OleDocumentSite_Release(IOleDocumentSite *iface) +{ + WebBrowser *This = DOCSITE_THIS(iface); + return IOleClientSite_Release(CLIENTSITE(This)); +} + +static HRESULT WINAPI OleDocumentSite_ActivateMe(IOleDocumentSite *iface, + IOleDocumentView *pViewToActivate) +{ + WebBrowser *This = DOCSITE_THIS(iface); + IOleDocument *oledoc; + RECT rect; + HRESULT hres; + + TRACE("(%p)->(%p)\n", This, pViewToActivate); + + hres = IUnknown_QueryInterface(This->document, &IID_IOleDocument, (void**)&oledoc); + if(FAILED(hres)) + return hres; + + IOleDocument_CreateView(oledoc, INPLACESITE(This), NULL, 0, &This->view); + IOleDocument_Release(oledoc); + + GetClientRect(This->doc_view_hwnd, &rect); + IOleDocumentView_SetRect(This->view, &rect); + + hres = IOleDocumentView_Show(This->view, TRUE); + + return hres; +} + +#undef DOCSITE_THIS + +static const IOleDocumentSiteVtbl OleDocumentSiteVtbl = { + OleDocumentSite_QueryInterface, + OleDocumentSite_AddRef, + OleDocumentSite_Release, + OleDocumentSite_ActivateMe +}; + void WebBrowser_ClientSite_Init(WebBrowser *This) { This->lpOleClientSiteVtbl = &OleClientSiteVtbl; This->lpOleInPlaceSiteVtbl = &OleInPlaceSiteVtbl; + This->lpOleDocumentSiteVtbl = &OleDocumentSiteVtbl; + + This->view = NULL; +} + +void WebBrowser_ClientSite_Destroy(WebBrowser *This) +{ + if(This->view) + IOleDocumentView_Release(This->view); } diff --git a/reactos/lib/shdocvw/dochost.c b/reactos/lib/shdocvw/dochost.c index c8ef021edaf..d5dc95c15e9 100644 --- a/reactos/lib/shdocvw/dochost.c +++ b/reactos/lib/shdocvw/dochost.c @@ -18,9 +18,142 @@ #include "wine/debug.h" #include "shdocvw.h" +#include "hlink.h" +#include "exdispid.h" WINE_DEFAULT_DEBUG_CHANNEL(shdocvw); +static ATOM doc_view_atom = 0; + +static void navigate_complete(WebBrowser *This) +{ + IDispatch *disp = NULL; + DISPPARAMS dispparams; + VARIANTARG params[2]; + VARIANT url; + HRESULT hres; + + hres = IUnknown_QueryInterface(This->document, &IID_IDispatch, (void**)&disp); + if(FAILED(hres)) + FIXME("Could not get IDispatch interface\n"); + + dispparams.cArgs = 2; + dispparams.cNamedArgs = 0; + dispparams.rgdispidNamedArgs = NULL; + dispparams.rgvarg = params; + + V_VT(params) = (VT_BYREF|VT_VARIANT); + V_BYREF(params) = &url; + + V_VT(params+1) = VT_DISPATCH; + V_DISPATCH(params+1) = disp; + + V_VT(&url) = VT_BSTR; + V_BSTR(&url) = This->url; + + call_sink(This->cp_wbe2, DISPID_NAVIGATECOMPLETE2, &dispparams); + call_sink(This->cp_wbe2, DISPID_DOCUMENTCOMPLETE, &dispparams); + + if(disp) + IDispatch_Release(disp); +} + +static LRESULT navigate2(WebBrowser *This) +{ + IHlinkTarget *hlink; + HRESULT hres; + + TRACE("(%p)\n", This); + + if(!This->document) { + WARN("document == NULL\n"); + return 0; + } + + hres = IUnknown_QueryInterface(This->document, &IID_IHlinkTarget, (void**)&hlink); + if(FAILED(hres)) { + FIXME("Could not get IHlinkTarget interface\n"); + return 0; + } + + hres = IHlinkTarget_Navigate(hlink, 0, NULL); + IHlinkTarget_Release(hlink); + if(FAILED(hres)) { + FIXME("Navigate failed\n"); + return 0; + } + + navigate_complete(This); + + return 0; +} + +static LRESULT resize_document(WebBrowser *This, LONG width, LONG height) +{ + RECT rect = {0, 0, width, height}; + + TRACE("(%p)->(%ld %ld)\n", This, width, height); + + if(This->view) + IOleDocumentView_SetRect(This->view, &rect); + + return 0; +} + +static LRESULT WINAPI doc_view_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + WebBrowser *This; + + static const WCHAR wszTHIS[] = {'T','H','I','S',0}; + + if(msg == WM_CREATE) { + This = *(WebBrowser**)lParam; + SetPropW(hwnd, wszTHIS, This); + }else { + This = GetPropW(hwnd, wszTHIS); + } + + switch(msg) { + case WM_SIZE: + return resize_document(This, LOWORD(lParam), HIWORD(lParam)); + case WB_WM_NAVIGATE2: + return navigate2(This); + } + + return DefWindowProcA(hwnd, msg, wParam, lParam); +} + +void create_doc_view_hwnd(WebBrowser *This) +{ + RECT rect; + + static const WCHAR wszShell_DocObject_View[] = + {'S','h','e','l','l',' ','D','o','c','O','b','j','e','c','t',' ','V','i','e','w',0}; + + if(!doc_view_atom) { + static WNDCLASSEXW wndclass = { + sizeof(wndclass), + CS_PARENTDC, + doc_view_proc, + 0, 0 /* native uses 4*/, NULL, NULL, NULL, + (HBRUSH)COLOR_WINDOWFRAME, NULL, + wszShell_DocObject_View, + NULL + }; + + wndclass.hInstance = shdocvw_hinstance; + + doc_view_atom = RegisterClassExW(&wndclass); + } + + GetWindowRect(This->shell_embedding_hwnd, &rect); + This->doc_view_hwnd = CreateWindowExW(0, wszShell_DocObject_View, + wszShell_DocObject_View, + WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_TABSTOP | WS_MAXIMIZEBOX, + rect.left, rect.top, rect.right, rect.bottom, This->shell_embedding_hwnd, + NULL, shdocvw_hinstance, This); +} + #define DOCHOSTUI_THIS(iface) DEFINE_THIS(WebBrowser, DocHostUIHandler, iface) static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, @@ -143,8 +276,23 @@ static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *ifac LPOLESTR *pchKey, DWORD dw) { WebBrowser *This = DOCHOSTUI_THIS(iface); - FIXME("(%p)->(%p %ld)\n", This, pchKey, dw); - return E_NOTIMPL; + IDocHostUIHandler *handler; + HRESULT hres; + + TRACE("(%p)->(%p %ld)\n", This, pchKey, dw); + + if(!This->client) + return S_OK; + + hres = IOleClientSite_QueryInterface(This->client, &IID_IDocHostUIHandler, + (void**)&handler); + if(SUCCEEDED(hres)) { + hres = IDocHostUIHandler_GetOptionKeyPath(handler, pchKey, dw); + IDocHostUIHandler_Release(handler); + return hres; + } + + return S_OK; } static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface, @@ -183,8 +331,23 @@ static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *if LPOLESTR *pchKey, DWORD dw) { WebBrowser *This = DOCHOSTUI_THIS(iface); - FIXME("(%p)->(%p %ld)\n", This, pchKey, dw); - return E_NOTIMPL; + IDocHostUIHandler2 *handler; + HRESULT hres; + + TRACE("(%p)->(%p %ld)\n", This, pchKey, dw); + + if(!This->client) + return S_OK; + + hres = IOleClientSite_QueryInterface(This->client, &IID_IDocHostUIHandler2, + (void**)&handler); + if(SUCCEEDED(hres)) { + hres = IDocHostUIHandler2_GetOverrideKeyPath(handler, pchKey, dw); + IDocHostUIHandler2_Release(handler); + return hres; + } + + return S_OK; } #undef DOCHOSTUI_THIS @@ -214,4 +377,6 @@ static const IDocHostUIHandler2Vtbl DocHostUIHandler2Vtbl = { void WebBrowser_DocHost_Init(WebBrowser *This) { This->lpDocHostUIHandlerVtbl = &DocHostUIHandler2Vtbl; + + This->doc_view_hwnd = NULL; } diff --git a/reactos/lib/shdocvw/events.c b/reactos/lib/shdocvw/events.c index 184b694e6b4..573344731b2 100644 --- a/reactos/lib/shdocvw/events.c +++ b/reactos/lib/shdocvw/events.c @@ -27,13 +27,16 @@ WINE_DEFAULT_DEBUG_CHANNEL(shdocvw); -typedef struct { +struct ConnectionPoint { const IConnectionPointVtbl *lpConnectionPointVtbl; WebBrowser *webbrowser; + IDispatch **sinks; + DWORD sinks_size; + IID iid; -} ConnectionPoint; +}; #define CONPOINT(x) ((IConnectionPoint*) &(x)->lpConnectionPointVtbl) @@ -84,13 +87,13 @@ static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPo if(IsEqualGUID(&DIID_DWebBrowserEvents2, riid)) { TRACE("(%p)->(DIID_DWebBrowserEvents2 %p)\n", This, ppCP); - *ppCP = This->cp_wbe2; + *ppCP = CONPOINT(This->cp_wbe2); }else if(IsEqualGUID(&DIID_DWebBrowserEvents, riid)) { TRACE("(%p)->(DIID_DWebBrowserEvents %p)\n", This, ppCP); - *ppCP = This->cp_wbe; + *ppCP = CONPOINT(This->cp_wbe); }else if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) { TRACE("(%p)->(IID_IPropertyNotifySink %p)\n", This, ppCP); - *ppCP = This->cp_pns; + *ppCP = CONPOINT(This->cp_pns); } if(*ppCP) { @@ -181,15 +184,53 @@ static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown * DWORD *pdwCookie) { ConnectionPoint *This = CONPOINT_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pUnkSink, pdwCookie); - return E_NOTIMPL; + IDispatch *disp; + DWORD i; + HRESULT hres; + + TRACE("(%p)->(%p %p)\n", This, pUnkSink, pdwCookie); + + hres = IUnknown_QueryInterface(pUnkSink, &This->iid, (void**)&disp); + if(FAILED(hres)) { + hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&disp); + if(FAILED(hres)) + return CONNECT_E_CANNOTCONNECT; + } + + if(This->sinks) { + for(i=0; isinks_size; i++) { + if(!This->sinks[i]) + break; + } + + if(i == This->sinks_size) + This->sinks = HeapReAlloc(GetProcessHeap(), 0, This->sinks, + (++This->sinks_size)*sizeof(*This->sinks)); + }else { + This->sinks = HeapAlloc(GetProcessHeap(), 0, sizeof(*This->sinks)); + This->sinks_size = 1; + i = 0; + } + + This->sinks[i] = disp; + *pdwCookie = i+1; + + return S_OK; } static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie) { ConnectionPoint *This = CONPOINT_THIS(iface); - FIXME("(%p)->(%ld)\n", This, dwCookie); - return E_NOTIMPL; + + TRACE("(%p)->(%ld)\n", This, dwCookie); + + if(!dwCookie || dwCookie > This->sinks_size || !This->sinks[dwCookie-1]) + return CONNECT_E_NOCONNECTION; + + IDispatch_Release(This->sinks[dwCookie-1]); + This->sinks[dwCookie-1] = NULL; + + return S_OK; } static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface, @@ -214,15 +255,43 @@ static const IConnectionPointVtbl ConnectionPointVtbl = ConnectionPoint_EnumConnections }; -static void ConnectionPoint_Create(WebBrowser *wb, REFIID riid, IConnectionPoint **cp) +void call_sink(ConnectionPoint *This, DISPID dispid, DISPPARAMS *dispparams) +{ + DWORD i; + + for(i=0; isinks_size; i++) { + if(This->sinks[i]) + IDispatch_Invoke(This->sinks[i], dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT, + DISPATCH_METHOD, dispparams, NULL, NULL, NULL); + } +} + +static void ConnectionPoint_Create(WebBrowser *wb, REFIID riid, ConnectionPoint **cp) { ConnectionPoint *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(ConnectionPoint)); ret->lpConnectionPointVtbl = &ConnectionPointVtbl; ret->webbrowser = wb; + + ret->sinks = NULL; + ret->sinks_size = 0; + memcpy(&ret->iid, riid, sizeof(IID)); - *cp = CONPOINT(ret); + *cp = ret; +} + +static void ConnectionPoint_Destroy(ConnectionPoint *This) +{ + int i; + + for(i=0; isinks_size; i++) { + if(This->sinks[i]) + IDispatch_Release(This->sinks[i]); + } + + HeapFree(GetProcessHeap(), 0, This->sinks); + HeapFree(GetProcessHeap(), 0, This); } void WebBrowser_Events_Init(WebBrowser *This) @@ -236,7 +305,7 @@ void WebBrowser_Events_Init(WebBrowser *This) void WebBrowser_Events_Destroy(WebBrowser *This) { - HeapFree(GetProcessHeap(), 0, This->cp_wbe2); - HeapFree(GetProcessHeap(), 0, This->cp_wbe); - HeapFree(GetProcessHeap(), 0, This->cp_pns); + ConnectionPoint_Destroy(This->cp_wbe2); + ConnectionPoint_Destroy(This->cp_wbe); + ConnectionPoint_Destroy(This->cp_pns); } diff --git a/reactos/lib/shdocvw/frame.c b/reactos/lib/shdocvw/frame.c new file mode 100644 index 00000000000..585a64deed8 --- /dev/null +++ b/reactos/lib/shdocvw/frame.c @@ -0,0 +1,180 @@ +/* + * Copyright 2005 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "wine/debug.h" +#include "shdocvw.h" + +WINE_DEFAULT_DEBUG_CHANNEL(shdocvw); + +#define INPLACEFRAME_THIS(iface) DEFINE_THIS(WebBrowser, OleInPlaceFrame, iface) + +static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, + REFIID riid, void **ppv) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + + *ppv = NULL; + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = INPLACEFRAME(This); + }else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid)) { + TRACE("(%p)->(IID_IOleInPlaceUIWindow %p)\n", This, ppv); + *ppv = INPLACEFRAME(This); + }else if(IsEqualGUID(&IID_IOleInPlaceFrame, riid)) { + TRACE("(%p)->(IID_IOleInPlaceFrame %p)\n", This, ppv); + *ppv = INPLACEFRAME(This); + } + + if(*ppv) { + IOleInPlaceFrame_AddRef(INPLACEFRAME(This)); + return S_OK; + } + + WARN("Unsopported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + return IWebBrowser2_AddRef(WEBBROWSER(This)); +} + +static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + return IWebBrowser2_Release(WEBBROWSER(This)); +} + +static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p)\n", This, phwnd); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, + BOOL fEnterMode) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%x)\n", This, fEnterMode); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p)\n", This, lprectBorder); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface, + LPCBORDERWIDTHS pborderwidths) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p)\n", This, pborderwidths); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface, + LPCBORDERWIDTHS pborderwidths) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p)\n", This, pborderwidths); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface, + IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p %s)\n", This, pActiveObject, debugstr_w(pszObjName)); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared, + LPOLEMENUGROUPWIDTHS lpMenuWidths) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p %p)\n", This, hmenuShared, lpMenuWidths); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared, + HOLEMENU holemenu, HWND hwndActiveObject) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p %p %p)\n", This, hmenuShared, holemenu, hwndActiveObject); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p)\n", This, hmenuShared); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, + LPCOLESTR pszStatusText) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p)\n", This, debugstr_w(pszStatusText)); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%x)\n", This, fEnable); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, + WORD wID) +{ + WebBrowser *This = INPLACEFRAME_THIS(iface); + FIXME("(%p)->(%p %d)\n", This, lpmsg, wID); + return E_NOTIMPL; +} + +#undef INPLACEFRAME_THIS + +static const IOleInPlaceFrameVtbl OleInPlaceFrameVtbl = { + InPlaceFrame_QueryInterface, + InPlaceFrame_AddRef, + InPlaceFrame_Release, + InPlaceFrame_GetWindow, + InPlaceFrame_ContextSensitiveHelp, + InPlaceFrame_GetBorder, + InPlaceFrame_RequestBorderSpace, + InPlaceFrame_SetBorderSpace, + InPlaceFrame_SetActiveObject, + InPlaceFrame_InsertMenus, + InPlaceFrame_SetMenu, + InPlaceFrame_RemoveMenus, + InPlaceFrame_SetStatusText, + InPlaceFrame_EnableModeless, + InPlaceFrame_TranslateAccelerator +}; + +void WebBrowser_Frame_Init(WebBrowser *This) +{ + This->lpOleInPlaceFrameVtbl = &OleInPlaceFrameVtbl; +} diff --git a/reactos/lib/shdocvw/oleobject.c b/reactos/lib/shdocvw/oleobject.c index f0dbeb39ed5..a20678a63c4 100644 --- a/reactos/lib/shdocvw/oleobject.c +++ b/reactos/lib/shdocvw/oleobject.c @@ -29,44 +29,36 @@ WINE_DEFAULT_DEBUG_CHANNEL(shdocvw); -static ATOM doc_view_atom = 0; static ATOM shell_embedding_atom = 0; -static LRESULT WINAPI doc_view_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +static LRESULT resize_window(WebBrowser *This, LONG width, LONG height) { - return DefWindowProcA(hwnd, msg, wParam, lParam); + if(This->doc_view_hwnd) + SetWindowPos(This->doc_view_hwnd, NULL, 0, 0, width, height, + SWP_NOZORDER | SWP_NOACTIVATE); + + return 0; } static LRESULT WINAPI shell_embedding_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { - return DefWindowProcA(hwnd, msg, wParam, lParam); -} + WebBrowser *This; -static void create_doc_view_hwnd(WebBrowser *This) -{ - static const WCHAR wszShell_DocObject_View[] = - {'S','h','e','l','l',' ','D','o','c','O','b','j','e','c','t',' ','V','i','e','w',0}; + static const WCHAR wszTHIS[] = {'T','H','I','S',0}; - if(!doc_view_atom) { - static WNDCLASSEXW wndclass = { - sizeof(wndclass), - CS_PARENTDC, - doc_view_proc, - 0, 0 /* native uses 4*/, NULL, NULL, NULL, - (HBRUSH)COLOR_WINDOWFRAME, NULL, - wszShell_DocObject_View, - NULL - }; - - wndclass.hInstance = shdocvw_hinstance; - - doc_view_atom = RegisterClassExW(&wndclass); + if(msg == WM_CREATE) { + This = *(WebBrowser**)lParam; + SetPropW(hwnd, wszTHIS, This); + }else { + This = GetPropW(hwnd, wszTHIS); } - This->doc_view_hwnd = CreateWindowExW(0, wszShell_DocObject_View, NULL, - WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_TABSTOP | WS_MAXIMIZEBOX, - 0, 0, 0, 0, This->shell_embedding_hwnd, - NULL, shdocvw_hinstance, This); + switch(msg) { + case WM_SIZE: + return resize_window(This, LOWORD(lParam), HIWORD(lParam)); + } + + return DefWindowProcA(hwnd, msg, wParam, lParam); } static void create_shell_embedding_hwnd(WebBrowser *This) @@ -99,12 +91,10 @@ static void create_shell_embedding_hwnd(WebBrowser *This) IOleInPlaceSite_Release(inplace); } - This->shell_embedding_hwnd = CreateWindowExW(0, wszShellEmbedding, NULL, + This->shell_embedding_hwnd = CreateWindowExW(0, wszShellEmbedding, wszShellEmbedding, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_TABSTOP | WS_MAXIMIZEBOX, 0, 0, 0, 0, parent, NULL, shdocvw_hinstance, This); - - create_doc_view_hwnd(This); } /********************************************************************** @@ -151,7 +141,7 @@ static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, LPOLECLIENTSITE This->client = pClientSite; if(!pClientSite) return S_OK; - + IOleClientSite_AddRef(pClientSite); create_shell_embedding_hwnd(This); @@ -227,11 +217,14 @@ static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, struct tag WebBrowser *This = OLEOBJ_THIS(iface); HRESULT hres; + static const WCHAR wszitem[] = {'i','t','e','m',0}; + TRACE("(%p)->(%ld %p %p %ld %p %p)\n", This, iVerb, lpmsg, pActiveSite, lindex, hwndParent, lprcPosRect); switch (iVerb) { + case OLEIVERB_SHOW: case OLEIVERB_INPLACEACTIVATE: { IOleInPlaceSite *inplace; @@ -264,7 +257,14 @@ static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, struct tag &This->frameinfo); - IOleInPlaceSite_Release(inplace); + if(iVerb == OLEIVERB_INPLACEACTIVATE) + IOleInPlaceSite_Release(inplace); + + SetWindowPos(This->shell_embedding_hwnd, NULL, + This->pos_rect.left, This->pos_rect.top, + This->pos_rect.right-This->pos_rect.left, + This->pos_rect.bottom-This->pos_rect.top, + SWP_NOZORDER | SWP_SHOWWINDOW); if(This->client) { IOleClientSite_ShowObject(This->client); @@ -274,6 +274,20 @@ static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, struct tag if(This->frame) IOleInPlaceFrame_GetWindow(This->frame, &This->frame_hwnd); + if(iVerb == OLEIVERB_INPLACEACTIVATE) + return S_OK; + + TRACE("OLEIVERB_SHOW\n"); + + IOleInPlaceSite_OnUIActivate(inplace); + IOleInPlaceSite_Release(inplace); + + IOleInPlaceFrame_SetActiveObject(This->frame, ACTIVEOBJ(This), wszitem); + + /* TODO: + * IOleInPlaceFrmae_SetMenu + */ + return S_OK; } default: @@ -482,8 +496,18 @@ static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObject *iface, LPCRECT lprcPosRect, LPCRECT lprcClipRect) { WebBrowser *This = INPLACEOBJ_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, lprcPosRect, lprcClipRect); - return E_NOTIMPL; + + TRACE("(%p)->(%p %p)\n", This, lprcPosRect, lprcClipRect); + + if(This->shell_embedding_hwnd) { + SetWindowPos(This->shell_embedding_hwnd, NULL, + lprcPosRect->left, lprcPosRect->top, + lprcPosRect->right-lprcPosRect->left, + lprcPosRect->bottom-lprcPosRect->top, + SWP_NOZORDER | SWP_NOACTIVATE); + } + + return S_OK; } static HRESULT WINAPI OleInPlaceObject_ReactivateAndUndo(IOleInPlaceObject *iface) @@ -574,11 +598,102 @@ static const IOleControlVtbl OleControlVtbl = OleControl_FreezeEvents }; +#define ACTIVEOBJ_THIS(iface) DEFINE_THIS(WebBrowser, OleInPlaceActiveObject, iface) + +static HRESULT WINAPI InPlaceActiveObject_QueryInterface(IOleInPlaceActiveObject *iface, + REFIID riid, void **ppv) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + return IWebBrowser2_QueryInterface(WEBBROWSER2(This), riid, ppv); +} + +static ULONG WINAPI InPlaceActiveObject_AddRef(IOleInPlaceActiveObject *iface) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + return IWebBrowser2_AddRef(WEBBROWSER2(This)); +} + +static ULONG WINAPI InPlaceActiveObject_Release(IOleInPlaceActiveObject *iface) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + return IWebBrowser2_Release(WEBBROWSER2(This)); +} + +static HRESULT WINAPI InPlaceActiveObject_GetWindow(IOleInPlaceActiveObject *iface, + HWND *phwnd) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + return IOleInPlaceObject_GetWindow(INPLACEOBJ(This), phwnd); +} + +static HRESULT WINAPI InPlaceActiveObject_ContextSensitiveHelp(IOleInPlaceActiveObject *iface, + BOOL fEnterMode) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + return IOleInPlaceObject_ContextSensitiveHelp(INPLACEOBJ(This), fEnterMode); +} + +static HRESULT WINAPI InPlaceActiveObject_TranslateAccelerator(IOleInPlaceActiveObject *iface, + LPMSG lpmsg) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + FIXME("(%p)->(%p)\n", This, lpmsg); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceActiveObject_OnFrameWindowActivate(IOleInPlaceActiveObject *iface, + BOOL fActivate) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + FIXME("(%p)->(%x)\n", This, fActivate); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceActiveObject_OnDocWindowActivate(IOleInPlaceActiveObject *iface, + BOOL fActivate) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + FIXME("(%p)->(%x)\n", This, fActivate); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceActiveObject_ResizeBorder(IOleInPlaceActiveObject *iface, + LPCRECT lprcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + FIXME("(%p)->(%p %p %x)\n", This, lprcBorder, pUIWindow, fFrameWindow); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceActiveObject_EnableModeless(IOleInPlaceActiveObject *iface, + BOOL fEnable) +{ + WebBrowser *This = ACTIVEOBJ_THIS(iface); + FIXME("(%p)->(%x)\n", This, fEnable); + return E_NOTIMPL; +} + +#undef ACTIVEOBJ_THIS + +static const IOleInPlaceActiveObjectVtbl OleInPlaceActiveObjectVtbl = { + InPlaceActiveObject_QueryInterface, + InPlaceActiveObject_AddRef, + InPlaceActiveObject_Release, + InPlaceActiveObject_GetWindow, + InPlaceActiveObject_ContextSensitiveHelp, + InPlaceActiveObject_TranslateAccelerator, + InPlaceActiveObject_OnFrameWindowActivate, + InPlaceActiveObject_OnDocWindowActivate, + InPlaceActiveObject_ResizeBorder, + InPlaceActiveObject_EnableModeless +}; + void WebBrowser_OleObject_Init(WebBrowser *This) { - This->lpOleObjectVtbl = &OleObjectVtbl; - This->lpOleInPlaceObjectVtbl = &OleInPlaceObjectVtbl; - This->lpOleControlVtbl = &OleControlVtbl; + This->lpOleObjectVtbl = &OleObjectVtbl; + This->lpOleInPlaceObjectVtbl = &OleInPlaceObjectVtbl; + This->lpOleControlVtbl = &OleControlVtbl; + This->lpOleInPlaceActiveObjectVtbl = &OleInPlaceActiveObjectVtbl; This->client = NULL; This->container = NULL; @@ -586,6 +701,7 @@ void WebBrowser_OleObject_Init(WebBrowser *This) This->frame_hwnd = NULL; This->frame = NULL; This->uiwindow = NULL; + This->shell_embedding_hwnd = NULL; memset(&This->pos_rect, 0, sizeof(RECT)); memset(&This->clip_rect, 0, sizeof(RECT)); diff --git a/reactos/lib/shdocvw/shdocvw.h b/reactos/lib/shdocvw/shdocvw.h index 104f978e728..735c1c469b2 100644 --- a/reactos/lib/shdocvw/shdocvw.h +++ b/reactos/lib/shdocvw/shdocvw.h @@ -58,6 +58,9 @@ extern HRESULT SHDOCVW_GetShellInstanceObjectClassObject(REFCLSID rclsid, /********************************************************************** * WebBrowser declaration for SHDOCVW.DLL */ + +typedef struct ConnectionPoint ConnectionPoint; + typedef struct { /* Interfaces available via WebBrowser object */ @@ -71,12 +74,18 @@ typedef struct { const IQuickActivateVtbl *lpQuickActivateVtbl; const IConnectionPointContainerVtbl *lpConnectionPointContainerVtbl; const IViewObject2Vtbl *lpViewObjectVtbl; + const IOleInPlaceActiveObjectVtbl *lpOleInPlaceActiveObjectVtbl; /* Interfaces available for embeded document */ const IOleClientSiteVtbl *lpOleClientSiteVtbl; const IOleInPlaceSiteVtbl *lpOleInPlaceSiteVtbl; const IDocHostUIHandler2Vtbl *lpDocHostUIHandlerVtbl; + const IOleDocumentSiteVtbl *lpOleDocumentSiteVtbl; + + /* Interfaces of InPlaceFrame object */ + + const IOleInPlaceFrameVtbl *lpOleInPlaceFrameVtbl; LONG ref; @@ -84,6 +93,9 @@ typedef struct { IOleClientSite *client; IOleContainer *container; + IOleDocumentView *view; + + LPOLESTR url; /* window context */ @@ -100,9 +112,9 @@ typedef struct { /* Connection points */ - IConnectionPoint *cp_wbe2; - IConnectionPoint *cp_wbe; - IConnectionPoint *cp_pns; + ConnectionPoint *cp_wbe2; + ConnectionPoint *cp_wbe; + ConnectionPoint *cp_pns; } WebBrowser; #define WEBBROWSER(x) ((IWebBrowser*) &(x)->lpWebBrowser2Vtbl) @@ -117,11 +129,15 @@ typedef struct { #define CONPTCONT(x) ((IConnectionPointContainer*) &(x)->lpConnectionPointContainerVtbl) #define VIEWOBJ(x) ((IViewObject*) &(x)->lpViewObjectVtbl); #define VIEWOBJ2(x) ((IViewObject2*) &(x)->lpViewObjectVtbl); +#define ACTIVEOBJ(x) ((IOleInPlaceActiveObject*) &(x)->lpOleInPlaceActiveObjectVtbl) #define CLIENTSITE(x) ((IOleClientSite*) &(x)->lpOleClientSiteVtbl) #define INPLACESITE(x) ((IOleInPlaceSite*) &(x)->lpOleInPlaceSiteVtbl) #define DOCHOSTUI(x) ((IDocHostUIHandler*) &(x)->lpDocHostUIHandlerVtbl) #define DOCHOSTUI2(x) ((IDocHostUIHandler2*) &(x)->lpDocHostUIHandlerVtbl) +#define DOCSITE(x) ((IOleDocumentSite*) &(x)->lpOleDocumentSiteVtbl) + +#define INPLACEFRAME(x) ((IOleInPlaceFrame*) &(x)->lpOleInPlaceFrameVtbl) void WebBrowser_OleObject_Init(WebBrowser*); void WebBrowser_ViewObject_Init(WebBrowser*); @@ -133,11 +149,19 @@ void WebBrowser_Events_Init(WebBrowser*); void WebBrowser_ClientSite_Init(WebBrowser*); void WebBrowser_DocHost_Init(WebBrowser*); +void WebBrowser_Frame_Init(WebBrowser*); + void WebBrowser_OleObject_Destroy(WebBrowser*); void WebBrowser_Events_Destroy(WebBrowser*); +void WebBrowser_ClientSite_Destroy(WebBrowser*); HRESULT WebBrowser_Create(IUnknown*,REFIID,void**); +void create_doc_view_hwnd(WebBrowser *This); +void call_sink(ConnectionPoint*,DISPID,DISPPARAMS*); + +#define WB_WM_NAVIGATE2 (WM_USER+100) + #define DEFINE_THIS(cls,ifc,iface) ((cls*)((BYTE*)(iface)-offsetof(cls,lp ## ifc ## Vtbl))) /********************************************************************** diff --git a/reactos/lib/shdocvw/shdocvw.xml b/reactos/lib/shdocvw/shdocvw.xml index 3635b99304e..24e45db07f7 100644 --- a/reactos/lib/shdocvw/shdocvw.xml +++ b/reactos/lib/shdocvw/shdocvw.xml @@ -23,6 +23,7 @@ dochost.c events.c factory.c + frame.c misc.c oleobject.c persist.c diff --git a/reactos/lib/shdocvw/webbrowser.c b/reactos/lib/shdocvw/webbrowser.c index 4ffb3c0a430..81109505899 100644 --- a/reactos/lib/shdocvw/webbrowser.c +++ b/reactos/lib/shdocvw/webbrowser.c @@ -94,6 +94,9 @@ static HRESULT WINAPI WebBrowser_QueryInterface(IWebBrowser2 *iface, REFIID riid }else if(IsEqualGUID(&IID_IViewObject2, riid)) { TRACE("(%p)->(IID_IViewObject2 %p)\n", This, ppv); *ppv = VIEWOBJ2(This); + }else if(IsEqualGUID(&IID_IOleInPlaceActiveObject, riid)) { + TRACE("(%p)->(IID_IOleInPlaceActiveObject %p)\n", This, ppv); + *ppv = ACTIVEOBJ(This); } if(*ppv) { @@ -126,7 +129,9 @@ static ULONG WINAPI WebBrowser_Release(IWebBrowser2 *iface) WebBrowser_OleObject_Destroy(This); WebBrowser_Events_Destroy(This); + WebBrowser_ClientSite_Destroy(This); + SysFreeString(This->url); HeapFree(GetProcessHeap(), 0, This); SHDOCVW_UnlockModule(); } @@ -255,8 +260,14 @@ static HRESULT WINAPI WebBrowser_get_Container(IWebBrowser2 *iface, IDispatch ** static HRESULT WINAPI WebBrowser_get_Document(IWebBrowser2 *iface, IDispatch **ppDisp) { WebBrowser *This = WEBBROWSER_THIS(iface); - FIXME("(%p)->(%p)\n", This, ppDisp); - return E_NOTIMPL; + + TRACE("(%p)->(%p)\n", This, ppDisp); + + *ppDisp = NULL; + if(This->document) + IUnknown_QueryInterface(This->document, &IID_IDispatch, (void**)ppDisp); + + return S_OK; } static HRESULT WINAPI WebBrowser_get_TopLevelContainer(IWebBrowser2 *iface, VARIANT_BOOL *pBool) @@ -504,12 +515,19 @@ static HRESULT WINAPI WebBrowser_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VA if(!This->client) return E_FAIL; - if(V_VT(Flags) != VT_EMPTY || V_VT(TargetFrameName) != VT_EMPTY - || V_VT(PostData) != VT_EMPTY || V_VT(Headers) != VT_EMPTY) + if((Flags && V_VT(Flags) != VT_EMPTY) + || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY) + || (PostData && V_VT(PostData) != VT_EMPTY) + || (Headers && V_VT(Headers) != VT_EMPTY)) FIXME("Unsupported arguments\n"); + if(!URL) + return S_OK; if(V_VT(URL) != VT_BSTR) - FIXME("V_VT(URL) != VT_BSTR\n"); + return E_INVALIDARG; + + if(!This->doc_view_hwnd) + create_doc_view_hwnd(This); /* * FIXME: @@ -543,6 +561,8 @@ static HRESULT WINAPI WebBrowser_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VA return hres; } + This->url = SysAllocString(V_BSTR(URL)); + hres = IUnknown_QueryInterface(This->document, &IID_IOleObject, (void**)&oleobj); if(FAILED(hres)) return hres; @@ -550,6 +570,8 @@ static HRESULT WINAPI WebBrowser_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VA hres = IOleObject_SetClientSite(oleobj, CLIENTSITE(This)); IOleObject_Release(oleobj); + PostMessageW(This->doc_view_hwnd, WB_WM_NAVIGATE2, 0, 0); + return hres; } @@ -775,6 +797,7 @@ HRESULT WebBrowser_Create(IUnknown *pOuter, REFIID riid, void **ppv) ret->ref = 0; ret->document = NULL; + ret->url = NULL; WebBrowser_OleObject_Init(ret); WebBrowser_ViewObject_Init(ret); @@ -784,6 +807,7 @@ HRESULT WebBrowser_Create(IUnknown *pOuter, REFIID riid, void **ppv) WebBrowser_Events_Init(ret); WebBrowser_ClientSite_Init(ret); WebBrowser_DocHost_Init(ret); + WebBrowser_Frame_Init(ret); hres = IWebBrowser_QueryInterface(WEBBROWSER(ret), riid, ppv); if(SUCCEEDED(hres)) { diff --git a/reactos/lib/uuid/uuid.c b/reactos/lib/uuid/uuid.c index ccf13661743..047bc5b4de8 100644 --- a/reactos/lib/uuid/uuid.c +++ b/reactos/lib/uuid/uuid.c @@ -47,6 +47,7 @@ DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0); #include "docobj.h" #include "exdisp.h" +#include "hlink.h" #include "shlguid.h" #include "shlobj.h" #include "shldisp.h" diff --git a/reactos/w32api/include/exdispid.h b/reactos/w32api/include/exdispid.h index da2b0a4f01a..a42131f8114 100644 --- a/reactos/w32api/include/exdispid.h +++ b/reactos/w32api/include/exdispid.h @@ -6,6 +6,7 @@ #define DISPID_BEFORENAVIGATE2 250 #define DISPID_NEWWINDOW2 251 +#define DISPID_NAVIGATECOMPLETE2 252 #define DISPID_PROGRESSCHANGE 108 #define DISPID_DOCUMENTCOMPLETE 259 #define DISPID_STATUSTEXTCHANGE 102 diff --git a/reactos/w32api/include/hlink.h b/reactos/w32api/include/hlink.h new file mode 100644 index 00000000000..8c2b8a955c2 --- /dev/null +++ b/reactos/w32api/include/hlink.h @@ -0,0 +1,1330 @@ +/*** Autogenerated by WIDL 0.9.3 from hlink.idl - Do not edit ***/ +#include +#include + +#ifndef __WIDL_HLINK_H +#define __WIDL_HLINK_H +#ifdef __cplusplus +extern "C" { +#endif +#include +#ifndef __IHlinkSite_FWD_DEFINED__ +#define __IHlinkSite_FWD_DEFINED__ +typedef interface IHlinkSite IHlinkSite; +#endif + +#ifndef __IHlinkBrowseContext_FWD_DEFINED__ +#define __IHlinkBrowseContext_FWD_DEFINED__ +typedef interface IHlinkBrowseContext IHlinkBrowseContext; +#endif + +#ifndef __IHlink_FWD_DEFINED__ +#define __IHlink_FWD_DEFINED__ +typedef interface IHlink IHlink; +#endif + +typedef IHlink *LPHLINK; +typedef enum { + HLNF_INTERNALJUMP = 0x1, + HLNF_OPENINNEWWINDOW = 0x2, + HLNF_NAVIGATINGBACK = 0x4, + HLNF_NAVIGATINGFORWARD = 0x8, + HLNF_NAVIGATINGTOSTACKITEM = 0x10, + HLNF_CREATENOHISTORY = 0x20 +} HLNF; +typedef enum { + HLINKGETREF_DEFAULT = 0, + HLINKGETREF_ABSOLUTE = 1, + HLINKGETREF_RELATIVE = 2 +} HLINKGETREF; +typedef enum { + HLFNAMEF_DEFAULT = 0x0, + HLFNAMEF_TRYCACHE = 0x1, + HLFNAMEF_TRYPRETTYTARGET = 0x2, + HLFNAMEF_TRYFULLTARGET = 0x4, + HLFNAMEF_TRYWIN95SHORTCUT = 0x8 +} HLFNAMEF; +typedef enum { + HLINKMISC_RELATIVE = 0x1 +} HLINKMISC; +typedef enum { + HLINKSETF_TARGET = 0x1, + HLINKSETF_LOCATION = 0x2 +} HLINKSETF; +/***************************************************************************** + * IHlink interface + */ +#ifndef __IHlink_INTERFACE_DEFINED__ +#define __IHlink_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IHlink, 0x79eac9c3, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b); +#if defined(__cplusplus) && !defined(CINTERFACE) +IHlink : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetHlinkSite( + IHlinkSite* pihlSite, + DWORD dwSiteData) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHlinkSite( + IHlinkSite** ppihlSite, + DWORD* pdwSiteData) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMonikerReference( + DWORD grfHLSETF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMonikerReference( + DWORD dwWhichRef, + IMoniker** ppimkTarget, + LPWSTR* ppwzLocation) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStringReference( + DWORD grfHLSETF, + LPCWSTR pwzTarget, + LPCWSTR pwzLocation) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStringReference( + DWORD dwWhichRef, + LPWSTR* ppwzTarget, + LPWSTR* ppwzLocation) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFriendlyName( + LPCWSTR pwzFriendlyName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFriendlyName( + DWORD grfHLFNAMEF, + LPWSTR* ppwzFriendlyName) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTargetFrameName( + LPCWSTR pwzTargetFrameName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTargetFrameName( + LPWSTR* ppwzTargetFrameName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMiscStatus( + DWORD* pdwStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE Navigate( + DWORD grfHLNF, + LPBC pibc, + IBindStatusCallback* pibsc, + IHlinkBrowseContext* pihlbc) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAdditionalParams( + LPCWSTR pwzAdditionalParams) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAdditionalParams( + LPWSTR* ppwzAdditionalParams) = 0; + +}; +#else +typedef struct IHlinkVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IHlink* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IHlink* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IHlink* This); + + /*** IHlink methods ***/ + HRESULT (STDMETHODCALLTYPE *SetHlinkSite)( + IHlink* This, + IHlinkSite* pihlSite, + DWORD dwSiteData); + + HRESULT (STDMETHODCALLTYPE *GetHlinkSite)( + IHlink* This, + IHlinkSite** ppihlSite, + DWORD* pdwSiteData); + + HRESULT (STDMETHODCALLTYPE *SetMonikerReference)( + IHlink* This, + DWORD grfHLSETF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation); + + HRESULT (STDMETHODCALLTYPE *GetMonikerReference)( + IHlink* This, + DWORD dwWhichRef, + IMoniker** ppimkTarget, + LPWSTR* ppwzLocation); + + HRESULT (STDMETHODCALLTYPE *SetStringReference)( + IHlink* This, + DWORD grfHLSETF, + LPCWSTR pwzTarget, + LPCWSTR pwzLocation); + + HRESULT (STDMETHODCALLTYPE *GetStringReference)( + IHlink* This, + DWORD dwWhichRef, + LPWSTR* ppwzTarget, + LPWSTR* ppwzLocation); + + HRESULT (STDMETHODCALLTYPE *SetFriendlyName)( + IHlink* This, + LPCWSTR pwzFriendlyName); + + HRESULT (STDMETHODCALLTYPE *GetFriendlyName)( + IHlink* This, + DWORD grfHLFNAMEF, + LPWSTR* ppwzFriendlyName); + + HRESULT (STDMETHODCALLTYPE *SetTargetFrameName)( + IHlink* This, + LPCWSTR pwzTargetFrameName); + + HRESULT (STDMETHODCALLTYPE *GetTargetFrameName)( + IHlink* This, + LPWSTR* ppwzTargetFrameName); + + HRESULT (STDMETHODCALLTYPE *GetMiscStatus)( + IHlink* This, + DWORD* pdwStatus); + + HRESULT (STDMETHODCALLTYPE *Navigate)( + IHlink* This, + DWORD grfHLNF, + LPBC pibc, + IBindStatusCallback* pibsc, + IHlinkBrowseContext* pihlbc); + + HRESULT (STDMETHODCALLTYPE *SetAdditionalParams)( + IHlink* This, + LPCWSTR pwzAdditionalParams); + + HRESULT (STDMETHODCALLTYPE *GetAdditionalParams)( + IHlink* This, + LPWSTR* ppwzAdditionalParams); + + END_INTERFACE +} IHlinkVtbl; +interface IHlink { + const IHlinkVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IHlink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IHlink_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IHlink_Release(p) (p)->lpVtbl->Release(p) +/*** IHlink methods ***/ +#define IHlink_SetHlinkSite(p,a,b) (p)->lpVtbl->SetHlinkSite(p,a,b) +#define IHlink_GetHlinkSite(p,a,b) (p)->lpVtbl->GetHlinkSite(p,a,b) +#define IHlink_SetMonikerReference(p,a,b,c) (p)->lpVtbl->SetMonikerReference(p,a,b,c) +#define IHlink_GetMonikerReference(p,a,b,c) (p)->lpVtbl->GetMonikerReference(p,a,b,c) +#define IHlink_SetStringReference(p,a,b,c) (p)->lpVtbl->SetStringReference(p,a,b,c) +#define IHlink_GetStringReference(p,a,b,c) (p)->lpVtbl->GetStringReference(p,a,b,c) +#define IHlink_SetFriendlyName(p,a) (p)->lpVtbl->SetFriendlyName(p,a) +#define IHlink_GetFriendlyName(p,a,b) (p)->lpVtbl->GetFriendlyName(p,a,b) +#define IHlink_SetTargetFrameName(p,a) (p)->lpVtbl->SetTargetFrameName(p,a) +#define IHlink_GetTargetFrameName(p,a) (p)->lpVtbl->GetTargetFrameName(p,a) +#define IHlink_GetMiscStatus(p,a) (p)->lpVtbl->GetMiscStatus(p,a) +#define IHlink_Navigate(p,a,b,c,d) (p)->lpVtbl->Navigate(p,a,b,c,d) +#define IHlink_SetAdditionalParams(p,a) (p)->lpVtbl->SetAdditionalParams(p,a) +#define IHlink_GetAdditionalParams(p,a) (p)->lpVtbl->GetAdditionalParams(p,a) +#endif + +#endif + +HRESULT CALLBACK IHlink_SetHlinkSite_Proxy( + IHlink* This, + IHlinkSite* pihlSite, + DWORD dwSiteData); +void __RPC_STUB IHlink_SetHlinkSite_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_GetHlinkSite_Proxy( + IHlink* This, + IHlinkSite** ppihlSite, + DWORD* pdwSiteData); +void __RPC_STUB IHlink_GetHlinkSite_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_SetMonikerReference_Proxy( + IHlink* This, + DWORD grfHLSETF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation); +void __RPC_STUB IHlink_SetMonikerReference_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_GetMonikerReference_Proxy( + IHlink* This, + DWORD dwWhichRef, + IMoniker** ppimkTarget, + LPWSTR* ppwzLocation); +void __RPC_STUB IHlink_GetMonikerReference_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_SetStringReference_Proxy( + IHlink* This, + DWORD grfHLSETF, + LPCWSTR pwzTarget, + LPCWSTR pwzLocation); +void __RPC_STUB IHlink_SetStringReference_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_GetStringReference_Proxy( + IHlink* This, + DWORD dwWhichRef, + LPWSTR* ppwzTarget, + LPWSTR* ppwzLocation); +void __RPC_STUB IHlink_GetStringReference_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_SetFriendlyName_Proxy( + IHlink* This, + LPCWSTR pwzFriendlyName); +void __RPC_STUB IHlink_SetFriendlyName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_GetFriendlyName_Proxy( + IHlink* This, + DWORD grfHLFNAMEF, + LPWSTR* ppwzFriendlyName); +void __RPC_STUB IHlink_GetFriendlyName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_SetTargetFrameName_Proxy( + IHlink* This, + LPCWSTR pwzTargetFrameName); +void __RPC_STUB IHlink_SetTargetFrameName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_GetTargetFrameName_Proxy( + IHlink* This, + LPWSTR* ppwzTargetFrameName); +void __RPC_STUB IHlink_GetTargetFrameName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_GetMiscStatus_Proxy( + IHlink* This, + DWORD* pdwStatus); +void __RPC_STUB IHlink_GetMiscStatus_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_Navigate_Proxy( + IHlink* This, + DWORD grfHLNF, + LPBC pibc, + IBindStatusCallback* pibsc, + IHlinkBrowseContext* pihlbc); +void __RPC_STUB IHlink_Navigate_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_SetAdditionalParams_Proxy( + IHlink* This, + LPCWSTR pwzAdditionalParams); +void __RPC_STUB IHlink_SetAdditionalParams_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlink_GetAdditionalParams_Proxy( + IHlink* This, + LPWSTR* ppwzAdditionalParams); +void __RPC_STUB IHlink_GetAdditionalParams_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IHlink_INTERFACE_DEFINED__ */ + +typedef IHlinkSite *LPHLINKSITE; +typedef enum { + HLINKWHICHMK_CONTAINER = 1, + HLINKWHICHMK_BASE = 2 +} HLINKWHICHMK; +/***************************************************************************** + * IHlinkSite interface + */ +#ifndef __IHlinkSite_INTERFACE_DEFINED__ +#define __IHlinkSite_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IHlinkSite, 0x79eac9c2, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b); +#if defined(__cplusplus) && !defined(CINTERFACE) +IHlinkSite : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE QueryService( + DWORD dwSiteData, + REFGUID guidService, + REFIID riid, + IUnknown** ppiunk) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMoniker( + DWORD dwSiteData, + DWORD dwAssign, + DWORD dwWhich, + IMoniker** ppimk) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadyToNavigate( + DWORD dwSiteData, + DWORD dwReserved) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnNavigationComplete( + DWORD dwSiteData, + DWORD dwreserved, + HRESULT hrError, + LPCWSTR pwzError) = 0; + +}; +#else +typedef struct IHlinkSiteVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IHlinkSite* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IHlinkSite* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IHlinkSite* This); + + /*** IHlinkSite methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryService)( + IHlinkSite* This, + DWORD dwSiteData, + REFGUID guidService, + REFIID riid, + IUnknown** ppiunk); + + HRESULT (STDMETHODCALLTYPE *GetMoniker)( + IHlinkSite* This, + DWORD dwSiteData, + DWORD dwAssign, + DWORD dwWhich, + IMoniker** ppimk); + + HRESULT (STDMETHODCALLTYPE *ReadyToNavigate)( + IHlinkSite* This, + DWORD dwSiteData, + DWORD dwReserved); + + HRESULT (STDMETHODCALLTYPE *OnNavigationComplete)( + IHlinkSite* This, + DWORD dwSiteData, + DWORD dwreserved, + HRESULT hrError, + LPCWSTR pwzError); + + END_INTERFACE +} IHlinkSiteVtbl; +interface IHlinkSite { + const IHlinkSiteVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IHlinkSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IHlinkSite_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IHlinkSite_Release(p) (p)->lpVtbl->Release(p) +/*** IHlinkSite methods ***/ +#define IHlinkSite_QueryService(p,a,b,c,d) (p)->lpVtbl->QueryService(p,a,b,c,d) +#define IHlinkSite_GetMoniker(p,a,b,c,d) (p)->lpVtbl->GetMoniker(p,a,b,c,d) +#define IHlinkSite_ReadyToNavigate(p,a,b) (p)->lpVtbl->ReadyToNavigate(p,a,b) +#define IHlinkSite_OnNavigationComplete(p,a,b,c,d) (p)->lpVtbl->OnNavigationComplete(p,a,b,c,d) +#endif + +#endif + +HRESULT CALLBACK IHlinkSite_QueryService_Proxy( + IHlinkSite* This, + DWORD dwSiteData, + REFGUID guidService, + REFIID riid, + IUnknown** ppiunk); +void __RPC_STUB IHlinkSite_QueryService_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkSite_GetMoniker_Proxy( + IHlinkSite* This, + DWORD dwSiteData, + DWORD dwAssign, + DWORD dwWhich, + IMoniker** ppimk); +void __RPC_STUB IHlinkSite_GetMoniker_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkSite_ReadyToNavigate_Proxy( + IHlinkSite* This, + DWORD dwSiteData, + DWORD dwReserved); +void __RPC_STUB IHlinkSite_ReadyToNavigate_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkSite_OnNavigationComplete_Proxy( + IHlinkSite* This, + DWORD dwSiteData, + DWORD dwreserved, + HRESULT hrError, + LPCWSTR pwzError); +void __RPC_STUB IHlinkSite_OnNavigationComplete_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IHlinkSite_INTERFACE_DEFINED__ */ + +#ifndef __IEnumHLITEM_FWD_DEFINED__ +#define __IEnumHLITEM_FWD_DEFINED__ +typedef interface IEnumHLITEM IEnumHLITEM; +#endif + +typedef IEnumHLITEM *LPENUMHLITEM; +typedef struct tagHLITEM { + ULONG uHLID; + LPWSTR pwzFriendlyName; +} HLITEM; +typedef HLITEM *LPHLITEM; +/***************************************************************************** + * IEnumHLITEM interface + */ +#ifndef __IEnumHLITEM_INTERFACE_DEFINED__ +#define __IEnumHLITEM_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumHLITEM, 0x79eac9c6, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b); +#if defined(__cplusplus) && !defined(CINTERFACE) +IEnumHLITEM : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + HLITEM* rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumHLITEM** ppienumhlitem) = 0; + +}; +#else +typedef struct IEnumHLITEMVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumHLITEM* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumHLITEM* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumHLITEM* This); + + /*** IEnumHLITEM methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumHLITEM* This, + ULONG celt, + HLITEM* rgelt, + ULONG* pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumHLITEM* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumHLITEM* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumHLITEM* This, + IEnumHLITEM** ppienumhlitem); + + END_INTERFACE +} IEnumHLITEMVtbl; +interface IEnumHLITEM { + const IEnumHLITEMVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumHLITEM_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumHLITEM_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumHLITEM_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumHLITEM methods ***/ +#define IEnumHLITEM_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumHLITEM_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumHLITEM_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumHLITEM_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#endif + +HRESULT CALLBACK IEnumHLITEM_Next_Proxy( + IEnumHLITEM* This, + ULONG celt, + HLITEM* rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumHLITEM_Next_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumHLITEM_Skip_Proxy( + IEnumHLITEM* This, + ULONG celt); +void __RPC_STUB IEnumHLITEM_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumHLITEM_Reset_Proxy( + IEnumHLITEM* This); +void __RPC_STUB IEnumHLITEM_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumHLITEM_Clone_Proxy( + IEnumHLITEM* This, + IEnumHLITEM** ppienumhlitem); +void __RPC_STUB IEnumHLITEM_Clone_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumHLITEM_INTERFACE_DEFINED__ */ + +typedef IHlinkBrowseContext *LPHLINKBROWSECONTEXT; +enum { + HLTB_DOCKEDLEFT = 0, + HLTB_DOCKEDTOP = 1, + HLTB_DOCKEDRIGHT = 2, + HLTB_DOCKEDBOTTOM = 3, + HLTB_FLOATING = 4 +}; + +typedef struct _tagHLTBINFO { + ULONG uDockType; + RECT rcTbPos; +} HLTBINFO; +enum { + HLBWIF_HASFRAMEWNDINFO = 0x1, + HLBWIF_HASDOCWNDINFO = 0x2, + HLBWIF_FRAMEWNDMAXIMIZED = 0x4, + HLBWIF_DOCWNDMAXIMIZED = 0x8, + HLBWIF_HASWEBTOOLBARINFO = 0x10, + HLBWIF_WEBTOOLBARHIDDEN = 0x20 +}; + +typedef struct _tagHLBWINFO { + ULONG cbSize; + DWORD grfHLBWIF; + RECT rcFramePos; + RECT rcDocPos; + HLTBINFO hltbinfo; +} HLBWINFO; +typedef HLBWINFO *LPHLBWINFO; +enum { + HLID_INVALID = 0x0, + HLID_PREVIOUS = 0xffffffff, + HLID_NEXT = 0xfffffffe, + HLID_CURRENT = 0xfffffffd, + HLID_STACKBOTTOM = 0xfffffffc, + HLID_STACKTOP = 0xfffffffb +}; + +enum { + HLQF_ISVALID = 0x1, + HLQF_ISCURRENT = 0x2 +}; + +/***************************************************************************** + * IHlinkBrowseContext interface + */ +#ifndef __IHlinkBrowseContext_INTERFACE_DEFINED__ +#define __IHlinkBrowseContext_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IHlinkBrowseContext, 0x79eac9c7, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b); +#if defined(__cplusplus) && !defined(CINTERFACE) +IHlinkBrowseContext : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Register( + DWORD reserved, + IUnknown* piunk, + IMoniker* pimk, + DWORD* pdwRegister) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetObject( + IMoniker* pimk, + BOOL fBindIfRootRegistered, + IUnknown** ppiunk) = 0; + + virtual HRESULT STDMETHODCALLTYPE Revoke( + DWORD dwRegister) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBrowseWindowInfo( + HLBWINFO* phlbwi) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBrowseWindowInfo( + HLBWINFO* phlbwi) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInitialHlink( + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnNavigateHlink( + DWORD grfHLNF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName, + ULONG* puHLID) = 0; + + virtual HRESULT STDMETHODCALLTYPE UpdateHlink( + ULONG uHLID, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumNavigationStack( + DWORD dwReserved, + DWORD grfHLFNAMEF, + IEnumHLITEM** ppienumhlitem) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryHlink( + DWORD grfHLQF, + ULONG uHLID) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHlink( + ULONG uHLID, + IHlink** ppihl) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCurrentHlink( + ULONG uHLID) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IUnknown* piunkOuter, + REFIID riid, + IUnknown** ppiunkObj) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( + DWORD reserved) = 0; + +}; +#else +typedef struct IHlinkBrowseContextVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IHlinkBrowseContext* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IHlinkBrowseContext* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IHlinkBrowseContext* This); + + /*** IHlinkBrowseContext methods ***/ + HRESULT (STDMETHODCALLTYPE *Register)( + IHlinkBrowseContext* This, + DWORD reserved, + IUnknown* piunk, + IMoniker* pimk, + DWORD* pdwRegister); + + HRESULT (STDMETHODCALLTYPE *GetObject)( + IHlinkBrowseContext* This, + IMoniker* pimk, + BOOL fBindIfRootRegistered, + IUnknown** ppiunk); + + HRESULT (STDMETHODCALLTYPE *Revoke)( + IHlinkBrowseContext* This, + DWORD dwRegister); + + HRESULT (STDMETHODCALLTYPE *SetBrowseWindowInfo)( + IHlinkBrowseContext* This, + HLBWINFO* phlbwi); + + HRESULT (STDMETHODCALLTYPE *GetBrowseWindowInfo)( + IHlinkBrowseContext* This, + HLBWINFO* phlbwi); + + HRESULT (STDMETHODCALLTYPE *SetInitialHlink)( + IHlinkBrowseContext* This, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName); + + HRESULT (STDMETHODCALLTYPE *OnNavigateHlink)( + IHlinkBrowseContext* This, + DWORD grfHLNF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName, + ULONG* puHLID); + + HRESULT (STDMETHODCALLTYPE *UpdateHlink)( + IHlinkBrowseContext* This, + ULONG uHLID, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName); + + HRESULT (STDMETHODCALLTYPE *EnumNavigationStack)( + IHlinkBrowseContext* This, + DWORD dwReserved, + DWORD grfHLFNAMEF, + IEnumHLITEM** ppienumhlitem); + + HRESULT (STDMETHODCALLTYPE *QueryHlink)( + IHlinkBrowseContext* This, + DWORD grfHLQF, + ULONG uHLID); + + HRESULT (STDMETHODCALLTYPE *GetHlink)( + IHlinkBrowseContext* This, + ULONG uHLID, + IHlink** ppihl); + + HRESULT (STDMETHODCALLTYPE *SetCurrentHlink)( + IHlinkBrowseContext* This, + ULONG uHLID); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IHlinkBrowseContext* This, + IUnknown* piunkOuter, + REFIID riid, + IUnknown** ppiunkObj); + + HRESULT (STDMETHODCALLTYPE *Close)( + IHlinkBrowseContext* This, + DWORD reserved); + + END_INTERFACE +} IHlinkBrowseContextVtbl; +interface IHlinkBrowseContext { + const IHlinkBrowseContextVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IHlinkBrowseContext_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IHlinkBrowseContext_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IHlinkBrowseContext_Release(p) (p)->lpVtbl->Release(p) +/*** IHlinkBrowseContext methods ***/ +#define IHlinkBrowseContext_Register(p,a,b,c,d) (p)->lpVtbl->Register(p,a,b,c,d) +#define IHlinkBrowseContext_GetObject(p,a,b,c) (p)->lpVtbl->GetObject(p,a,b,c) +#define IHlinkBrowseContext_Revoke(p,a) (p)->lpVtbl->Revoke(p,a) +#define IHlinkBrowseContext_SetBrowseWindowInfo(p,a) (p)->lpVtbl->SetBrowseWindowInfo(p,a) +#define IHlinkBrowseContext_GetBrowseWindowInfo(p,a) (p)->lpVtbl->GetBrowseWindowInfo(p,a) +#define IHlinkBrowseContext_SetInitialHlink(p,a,b,c) (p)->lpVtbl->SetInitialHlink(p,a,b,c) +#define IHlinkBrowseContext_OnNavigateHlink(p,a,b,c,d,e) (p)->lpVtbl->OnNavigateHlink(p,a,b,c,d,e) +#define IHlinkBrowseContext_UpdateHlink(p,a,b,c,d) (p)->lpVtbl->UpdateHlink(p,a,b,c,d) +#define IHlinkBrowseContext_EnumNavigationStack(p,a,b,c) (p)->lpVtbl->EnumNavigationStack(p,a,b,c) +#define IHlinkBrowseContext_QueryHlink(p,a,b) (p)->lpVtbl->QueryHlink(p,a,b) +#define IHlinkBrowseContext_GetHlink(p,a,b) (p)->lpVtbl->GetHlink(p,a,b) +#define IHlinkBrowseContext_SetCurrentHlink(p,a) (p)->lpVtbl->SetCurrentHlink(p,a) +#define IHlinkBrowseContext_Clone(p,a,b,c) (p)->lpVtbl->Clone(p,a,b,c) +#define IHlinkBrowseContext_Close(p,a) (p)->lpVtbl->Close(p,a) +#endif + +#endif + +HRESULT CALLBACK IHlinkBrowseContext_Register_Proxy( + IHlinkBrowseContext* This, + DWORD reserved, + IUnknown* piunk, + IMoniker* pimk, + DWORD* pdwRegister); +void __RPC_STUB IHlinkBrowseContext_Register_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_GetObject_Proxy( + IHlinkBrowseContext* This, + IMoniker* pimk, + BOOL fBindIfRootRegistered, + IUnknown** ppiunk); +void __RPC_STUB IHlinkBrowseContext_GetObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_Revoke_Proxy( + IHlinkBrowseContext* This, + DWORD dwRegister); +void __RPC_STUB IHlinkBrowseContext_Revoke_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_SetBrowseWindowInfo_Proxy( + IHlinkBrowseContext* This, + HLBWINFO* phlbwi); +void __RPC_STUB IHlinkBrowseContext_SetBrowseWindowInfo_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_GetBrowseWindowInfo_Proxy( + IHlinkBrowseContext* This, + HLBWINFO* phlbwi); +void __RPC_STUB IHlinkBrowseContext_GetBrowseWindowInfo_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_SetInitialHlink_Proxy( + IHlinkBrowseContext* This, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName); +void __RPC_STUB IHlinkBrowseContext_SetInitialHlink_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_OnNavigateHlink_Proxy( + IHlinkBrowseContext* This, + DWORD grfHLNF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName, + ULONG* puHLID); +void __RPC_STUB IHlinkBrowseContext_OnNavigateHlink_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_UpdateHlink_Proxy( + IHlinkBrowseContext* This, + ULONG uHLID, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName); +void __RPC_STUB IHlinkBrowseContext_UpdateHlink_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_EnumNavigationStack_Proxy( + IHlinkBrowseContext* This, + DWORD dwReserved, + DWORD grfHLFNAMEF, + IEnumHLITEM** ppienumhlitem); +void __RPC_STUB IHlinkBrowseContext_EnumNavigationStack_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_QueryHlink_Proxy( + IHlinkBrowseContext* This, + DWORD grfHLQF, + ULONG uHLID); +void __RPC_STUB IHlinkBrowseContext_QueryHlink_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_GetHlink_Proxy( + IHlinkBrowseContext* This, + ULONG uHLID, + IHlink** ppihl); +void __RPC_STUB IHlinkBrowseContext_GetHlink_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_SetCurrentHlink_Proxy( + IHlinkBrowseContext* This, + ULONG uHLID); +void __RPC_STUB IHlinkBrowseContext_SetCurrentHlink_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_Clone_Proxy( + IHlinkBrowseContext* This, + IUnknown* piunkOuter, + REFIID riid, + IUnknown** ppiunkObj); +void __RPC_STUB IHlinkBrowseContext_Clone_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkBrowseContext_Close_Proxy( + IHlinkBrowseContext* This, + DWORD reserved); +void __RPC_STUB IHlinkBrowseContext_Close_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IHlinkBrowseContext_INTERFACE_DEFINED__ */ + +#ifndef __IHlinkTarget_FWD_DEFINED__ +#define __IHlinkTarget_FWD_DEFINED__ +typedef interface IHlinkTarget IHlinkTarget; +#endif + +typedef IHlinkTarget *LPHLINKTARGET; +/***************************************************************************** + * IHlinkTarget interface + */ +#ifndef __IHlinkTarget_INTERFACE_DEFINED__ +#define __IHlinkTarget_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IHlinkTarget, 0x79eac9c4, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b); +#if defined(__cplusplus) && !defined(CINTERFACE) +IHlinkTarget : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetBrowseContext( + IHlinkBrowseContext* pihlbc) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBrowseContext( + IHlinkBrowseContext** ppihlbc) = 0; + + virtual HRESULT STDMETHODCALLTYPE Navigate( + DWORD grfHLNF, + LPCWSTR pwzJumpLocation) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMoniker( + LPCWSTR pwzLocation, + DWORD dwAssign, + IMoniker** ppimkLocation) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFriendlyName( + LPCWSTR pwzLocation, + LPWSTR* ppwzFriendlyName) = 0; + +}; +#else +typedef struct IHlinkTargetVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IHlinkTarget* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IHlinkTarget* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IHlinkTarget* This); + + /*** IHlinkTarget methods ***/ + HRESULT (STDMETHODCALLTYPE *SetBrowseContext)( + IHlinkTarget* This, + IHlinkBrowseContext* pihlbc); + + HRESULT (STDMETHODCALLTYPE *GetBrowseContext)( + IHlinkTarget* This, + IHlinkBrowseContext** ppihlbc); + + HRESULT (STDMETHODCALLTYPE *Navigate)( + IHlinkTarget* This, + DWORD grfHLNF, + LPCWSTR pwzJumpLocation); + + HRESULT (STDMETHODCALLTYPE *GetMoniker)( + IHlinkTarget* This, + LPCWSTR pwzLocation, + DWORD dwAssign, + IMoniker** ppimkLocation); + + HRESULT (STDMETHODCALLTYPE *GetFriendlyName)( + IHlinkTarget* This, + LPCWSTR pwzLocation, + LPWSTR* ppwzFriendlyName); + + END_INTERFACE +} IHlinkTargetVtbl; +interface IHlinkTarget { + const IHlinkTargetVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IHlinkTarget_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IHlinkTarget_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IHlinkTarget_Release(p) (p)->lpVtbl->Release(p) +/*** IHlinkTarget methods ***/ +#define IHlinkTarget_SetBrowseContext(p,a) (p)->lpVtbl->SetBrowseContext(p,a) +#define IHlinkTarget_GetBrowseContext(p,a) (p)->lpVtbl->GetBrowseContext(p,a) +#define IHlinkTarget_Navigate(p,a,b) (p)->lpVtbl->Navigate(p,a,b) +#define IHlinkTarget_GetMoniker(p,a,b,c) (p)->lpVtbl->GetMoniker(p,a,b,c) +#define IHlinkTarget_GetFriendlyName(p,a,b) (p)->lpVtbl->GetFriendlyName(p,a,b) +#endif + +#endif + +HRESULT CALLBACK IHlinkTarget_SetBrowseContext_Proxy( + IHlinkTarget* This, + IHlinkBrowseContext* pihlbc); +void __RPC_STUB IHlinkTarget_SetBrowseContext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkTarget_GetBrowseContext_Proxy( + IHlinkTarget* This, + IHlinkBrowseContext** ppihlbc); +void __RPC_STUB IHlinkTarget_GetBrowseContext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkTarget_Navigate_Proxy( + IHlinkTarget* This, + DWORD grfHLNF, + LPCWSTR pwzJumpLocation); +void __RPC_STUB IHlinkTarget_Navigate_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkTarget_GetMoniker_Proxy( + IHlinkTarget* This, + LPCWSTR pwzLocation, + DWORD dwAssign, + IMoniker** ppimkLocation); +void __RPC_STUB IHlinkTarget_GetMoniker_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkTarget_GetFriendlyName_Proxy( + IHlinkTarget* This, + LPCWSTR pwzLocation, + LPWSTR* ppwzFriendlyName); +void __RPC_STUB IHlinkTarget_GetFriendlyName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IHlinkTarget_INTERFACE_DEFINED__ */ + +#ifndef __IHlinkFrame_FWD_DEFINED__ +#define __IHlinkFrame_FWD_DEFINED__ +typedef interface IHlinkFrame IHlinkFrame; +#endif + +typedef IHlinkFrame *LPHLINKFRAME; +/***************************************************************************** + * IHlinkFrame interface + */ +#ifndef __IHlinkFrame_INTERFACE_DEFINED__ +#define __IHlinkFrame_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IHlinkFrame, 0x79eac9c5, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b); +#if defined(__cplusplus) && !defined(CINTERFACE) +IHlinkFrame : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetBrowseContext( + IHlinkBrowseContext* pihlbc) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBrowseContext( + IHlinkBrowseContext** ppihlbc) = 0; + + virtual HRESULT STDMETHODCALLTYPE Navigate( + DWORD grfHLNF, + LPBC pbc, + IBindStatusCallback* pibsc, + IHlink* pihlNavigate) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnNavigate( + DWORD grfHLNF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName, + DWORD dwreserved) = 0; + + virtual HRESULT STDMETHODCALLTYPE UpdateHlink( + ULONG uHLID, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName) = 0; + +}; +#else +typedef struct IHlinkFrameVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IHlinkFrame* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IHlinkFrame* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IHlinkFrame* This); + + /*** IHlinkFrame methods ***/ + HRESULT (STDMETHODCALLTYPE *SetBrowseContext)( + IHlinkFrame* This, + IHlinkBrowseContext* pihlbc); + + HRESULT (STDMETHODCALLTYPE *GetBrowseContext)( + IHlinkFrame* This, + IHlinkBrowseContext** ppihlbc); + + HRESULT (STDMETHODCALLTYPE *Navigate)( + IHlinkFrame* This, + DWORD grfHLNF, + LPBC pbc, + IBindStatusCallback* pibsc, + IHlink* pihlNavigate); + + HRESULT (STDMETHODCALLTYPE *OnNavigate)( + IHlinkFrame* This, + DWORD grfHLNF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName, + DWORD dwreserved); + + HRESULT (STDMETHODCALLTYPE *UpdateHlink)( + IHlinkFrame* This, + ULONG uHLID, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName); + + END_INTERFACE +} IHlinkFrameVtbl; +interface IHlinkFrame { + const IHlinkFrameVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IHlinkFrame_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IHlinkFrame_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IHlinkFrame_Release(p) (p)->lpVtbl->Release(p) +/*** IHlinkFrame methods ***/ +#define IHlinkFrame_SetBrowseContext(p,a) (p)->lpVtbl->SetBrowseContext(p,a) +#define IHlinkFrame_GetBrowseContext(p,a) (p)->lpVtbl->GetBrowseContext(p,a) +#define IHlinkFrame_Navigate(p,a,b,c,d) (p)->lpVtbl->Navigate(p,a,b,c,d) +#define IHlinkFrame_OnNavigate(p,a,b,c,d,e) (p)->lpVtbl->OnNavigate(p,a,b,c,d,e) +#define IHlinkFrame_UpdateHlink(p,a,b,c,d) (p)->lpVtbl->UpdateHlink(p,a,b,c,d) +#endif + +#endif + +HRESULT CALLBACK IHlinkFrame_SetBrowseContext_Proxy( + IHlinkFrame* This, + IHlinkBrowseContext* pihlbc); +void __RPC_STUB IHlinkFrame_SetBrowseContext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkFrame_GetBrowseContext_Proxy( + IHlinkFrame* This, + IHlinkBrowseContext** ppihlbc); +void __RPC_STUB IHlinkFrame_GetBrowseContext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkFrame_Navigate_Proxy( + IHlinkFrame* This, + DWORD grfHLNF, + LPBC pbc, + IBindStatusCallback* pibsc, + IHlink* pihlNavigate); +void __RPC_STUB IHlinkFrame_Navigate_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkFrame_OnNavigate_Proxy( + IHlinkFrame* This, + DWORD grfHLNF, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName, + DWORD dwreserved); +void __RPC_STUB IHlinkFrame_OnNavigate_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IHlinkFrame_UpdateHlink_Proxy( + IHlinkFrame* This, + ULONG uHLID, + IMoniker* pimkTarget, + LPCWSTR pwzLocation, + LPCWSTR pwzFriendlyName); +void __RPC_STUB IHlinkFrame_UpdateHlink_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IHlinkFrame_INTERFACE_DEFINED__ */ + +/* Begin additional prototypes for all interfaces */ + + +/* End additional prototypes */ + +#ifdef __cplusplus +} +#endif +#endif /* __WIDL_HLINK_H */ diff --git a/reactos/w32api/include/objidl.h b/reactos/w32api/include/objidl.h index 76b69786801..a57ac5accec 100644 --- a/reactos/w32api/include/objidl.h +++ b/reactos/w32api/include/objidl.h @@ -80,10 +80,6 @@ typedef struct tagRemSTGMEDIUM { unsigned long cbData; BYTE data[1]; } RemSTGMEDIUM; -typedef struct tagHLITEM { - ULONG uHLID; - LPWSTR pwzFriendlyName; -} HLITEM; typedef struct tagSTATDATA { FORMATETC formatetc; DWORD grfAdvf; @@ -416,7 +412,6 @@ EXTERN_C const FMTID FMTID_DocSummaryInformation; EXTERN_C const FMTID FMTID_UserDefinedProperties; DECLARE_ENUMERATOR(FORMATETC); -DECLARE_ENUMERATOR(HLITEM); DECLARE_ENUMERATOR(STATDATA); DECLARE_ENUMERATOR(STATPROPSETSTG); DECLARE_ENUMERATOR(STATPROPSTG); diff --git a/reactos/w32api/include/oleidl.h b/reactos/w32api/include/oleidl.h index 36e9f40801b..9011f71710f 100644 --- a/reactos/w32api/include/oleidl.h +++ b/reactos/w32api/include/oleidl.h @@ -318,6 +318,21 @@ DECLARE_INTERFACE_(IOleInPlaceObject,IOleWindow) }; #undef INTERFACE +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IOleInPlaceObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleInPlaceObject_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleInPlaceObject_Release(p) (p)->lpVtbl->Release(p) +/*** IOleWindow methods ***/ +#define IOleInPlaceObject_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a) +#define IOleInPlaceObject_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a) +/*** IOleInPlaceObject methods ***/ +#define IOleInPlaceObject_InPlaceDeactivate(p) (p)->lpVtbl->InPlaceDeactivate(p) +#define IOleInPlaceObject_UIDeactivate(p) (p)->lpVtbl->UIDeactivate(p) +#define IOleInPlaceObject_SetObjectRects(p,a,b) (p)->lpVtbl->SetObjectRects(p,a,b) +#define IOleInPlaceObject_ReactivateAndUndo(p) (p)->lpVtbl->ReactivateAndUndo(p) +#endif + EXTERN_C const IID IID_IOleInPlaceActiveObject; #define INTERFACE IOleInPlaceActiveObject DECLARE_INTERFACE_(IOleInPlaceActiveObject,IOleWindow)