diff --git a/reactos/dll/win32/CMakeLists.txt b/reactos/dll/win32/CMakeLists.txt index 50ce0462e55..34fca7eaa5f 100644 --- a/reactos/dll/win32/CMakeLists.txt +++ b/reactos/dll/win32/CMakeLists.txt @@ -49,6 +49,7 @@ add_subdirectory(hnetcfg) add_subdirectory(httpapi) add_subdirectory(iccvid) add_subdirectory(icmp) +add_subdirectory(ieframe) add_subdirectory(imaadp32.acm) add_subdirectory(imagehlp) add_subdirectory(imm32) diff --git a/reactos/dll/win32/ieframe/CMakeLists.txt b/reactos/dll/win32/ieframe/CMakeLists.txt new file mode 100644 index 00000000000..1c98405e4bb --- /dev/null +++ b/reactos/dll/win32/ieframe/CMakeLists.txt @@ -0,0 +1,42 @@ + +include_directories(${REACTOS_SOURCE_DIR}/include/reactos/wine) +add_definitions(-D__WINESRC__) + +spec2def(ieframe.dll ieframe.spec ADD_IMPORTLIB) + +list(APPEND SOURCE + classinfo.c + client.c + dochost.c + events.c + frame.c + ie.c + ieframe_main.c + iehtmlwnd.c + iexplore.c + intshcut.c + navigate.c + oleobject.c + persist.c + shellbrowser.c + shelluihelper.c + urlhist.c + view.c + webbrowser.c + ${CMAKE_CURRENT_BINARY_DIR}/ieframe_stubs.c + ${CMAKE_CURRENT_BINARY_DIR}/ieframe.def) + +add_library(ieframe SHARED ${SOURCE} ieframe.rc) + +if(NOT MSVC) + # FIXME: http://www.cmake.org/Bug/view.php?id=12998 + #allow_warnings(aclui) + set_source_files_properties(${SOURCE} PROPERTIES COMPILE_FLAGS "-Wno-error") +endif() + +add_typelib(ieframe_v1.idl) +set_source_files_properties(ieframe.rc PROPERTIES OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ieframe_v1.tlb) +set_module_type(ieframe win32dll) +target_link_libraries(ieframe uuid wine) +add_importlibs(ieframe urlmon shell32 comctl32 shlwapi oleaut32 ole32 user32 gdi32 advapi32 msvcrt kernel32 ntdll) +add_cd_file(TARGET ieframe DESTINATION reactos/system32 FOR all) diff --git a/reactos/dll/win32/ieframe/classinfo.c b/reactos/dll/win32/ieframe/classinfo.c new file mode 100644 index 00000000000..d73161649e7 --- /dev/null +++ b/reactos/dll/win32/ieframe/classinfo.c @@ -0,0 +1,103 @@ +/* + * Implementation of IProvideClassInfo interfaces for WebBrowser control + * + * Copyright 2001 John R. Sheets (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 "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +/********************************************************************** + * Implement the IProvideClassInfo2 interface + */ + +static inline WebBrowser *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IProvideClassInfo2_iface); +} + +static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideClassInfo2 *iface, + REFIID riid, LPVOID *ppobj) +{ + WebBrowser *This = impl_from_IProvideClassInfo2(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppobj); +} + +static ULONG WINAPI ProvideClassInfo_AddRef(IProvideClassInfo2 *iface) +{ + WebBrowser *This = impl_from_IProvideClassInfo2(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI ProvideClassInfo_Release(IProvideClassInfo2 *iface) +{ + WebBrowser *This = impl_from_IProvideClassInfo2(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI) +{ + WebBrowser *This = impl_from_IProvideClassInfo2(iface); + HRESULT hres; + + TRACE("(%p)->(%p)\n", This, ppTI); + + hres = get_typeinfo(This->version > 1 ? WebBrowser_tid : WebBrowser_V1_tid, ppTI); + if(FAILED(hres)) + return hres; + + ITypeInfo_AddRef(*ppTI); + return S_OK; +} + +static HRESULT WINAPI ProvideClassInfo_GetGUID(IProvideClassInfo2 *iface, + DWORD dwGuidKind, GUID *pGUID) +{ + WebBrowser *This = impl_from_IProvideClassInfo2(iface); + + TRACE("(%p)->(%d %p)\n", This, dwGuidKind, pGUID); + + if(!pGUID) + return E_POINTER; + + if (dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID) { + WARN("Wrong GUID type: %d\n", dwGuidKind); + *pGUID = IID_NULL; + return E_FAIL; + } + + memcpy(pGUID, This->version == 1 ? &DIID_DWebBrowserEvents : &DIID_DWebBrowserEvents2, + sizeof(GUID)); + return S_OK; +} + +static const IProvideClassInfo2Vtbl ProvideClassInfoVtbl = +{ + ProvideClassInfo_QueryInterface, + ProvideClassInfo_AddRef, + ProvideClassInfo_Release, + ProvideClassInfo_GetClassInfo, + ProvideClassInfo_GetGUID +}; + +void WebBrowser_ClassInfo_Init(WebBrowser *This) +{ + This->IProvideClassInfo2_iface.lpVtbl = &ProvideClassInfoVtbl; +} diff --git a/reactos/dll/win32/ieframe/client.c b/reactos/dll/win32/ieframe/client.c new file mode 100644 index 00000000000..08a73eaefd9 --- /dev/null +++ b/reactos/dll/win32/ieframe/client.c @@ -0,0 +1,721 @@ +/* + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include + +#include + +#include +#include + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static inline DocHost *impl_from_IOleClientSite(IOleClientSite *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IOleClientSite_iface); +} + +static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IOleClientSite(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IOleClientSite_iface; + }else if(IsEqualGUID(&IID_IOleClientSite, riid)) { + TRACE("(%p)->(IID_IOleClientSite %p)\n", This, ppv); + *ppv = &This->IOleClientSite_iface; + }else if(IsEqualGUID(&IID_IOleWindow, riid)) { + TRACE("(%p)->(IID_IOleWindow %p)\n", This, ppv); + *ppv = &This->IOleInPlaceSiteEx_iface; + }else if(IsEqualGUID(&IID_IOleInPlaceSite, riid)) { + TRACE("(%p)->(IID_IOleInPlaceSite %p)\n", This, ppv); + *ppv = &This->IOleInPlaceSiteEx_iface; + }else if(IsEqualGUID(&IID_IOleInPlaceSiteEx, riid)) { + TRACE("(%p)->(IID_IOleInPlaceSiteEx %p)\n", This, ppv); + *ppv = &This->IOleInPlaceSiteEx_iface; + }else if(IsEqualGUID(&IID_IDocHostUIHandler, riid)) { + TRACE("(%p)->(IID_IDocHostUIHandler %p)\n", This, ppv); + *ppv = &This->IDocHostUIHandler2_iface; + }else if(IsEqualGUID(&IID_IDocHostUIHandler2, riid)) { + TRACE("(%p)->(IID_IDocHostUIHandler2 %p)\n", This, ppv); + *ppv = &This->IDocHostUIHandler2_iface; + }else if(IsEqualGUID(&IID_IOleDocumentSite, riid)) { + TRACE("(%p)->(IID_IOleDocumentSite %p)\n", This, ppv); + *ppv = &This->IOleDocumentSite_iface; + }else if(IsEqualGUID(&IID_IOleControlSite, riid)) { + TRACE("(%p)->(IID_IOleControlSite %p)\n", This, ppv); + *ppv = &This->IOleControlSite_iface; + }else if(IsEqualGUID(&IID_IOleCommandTarget, riid)) { + TRACE("(%p)->(IID_IOleCommandTarget %p)\n", This, ppv); + *ppv = &This->IOleCommandTarget_iface; + }else if(IsEqualGUID(&IID_IDispatch, riid)) { + TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv); + *ppv = &This->IDispatch_iface; + }else if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) { + TRACE("(%p)->(IID_IPropertyNotifySink %p)\n", This, ppv); + *ppv = &This->IPropertyNotifySink_iface; + }else if(IsEqualGUID(&IID_IServiceProvider, riid)) { + TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv); + *ppv = &This->IServiceProvider_iface; + }else { + *ppv = NULL; + WARN("Unsupported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface) +{ + DocHost *This = impl_from_IOleClientSite(iface); + return This->container_vtbl->addref(This); +} + +static ULONG WINAPI ClientSite_Release(IOleClientSite *iface) +{ + DocHost *This = impl_from_IOleClientSite(iface); + return This->container_vtbl->release(This); +} + +static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface) +{ + DocHost *This = impl_from_IOleClientSite(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, + DWORD dwWhichMoniker, IMoniker **ppmk) +{ + DocHost *This = impl_from_IOleClientSite(iface); + FIXME("(%p)->(%d %d %p)\n", This, dwAssign, dwWhichMoniker, ppmk); + return E_NOTIMPL; +} + +static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer) +{ + DocHost *This = impl_from_IOleClientSite(iface); + FIXME("(%p)->(%p)\n", This, ppContainer); + return E_NOTIMPL; +} + +static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface) +{ + DocHost *This = impl_from_IOleClientSite(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow) +{ + DocHost *This = impl_from_IOleClientSite(iface); + FIXME("(%p)->(%x)\n", This, fShow); + return E_NOTIMPL; +} + +static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface) +{ + DocHost *This = impl_from_IOleClientSite(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static const IOleClientSiteVtbl OleClientSiteVtbl = { + ClientSite_QueryInterface, + ClientSite_AddRef, + ClientSite_Release, + ClientSite_SaveObject, + ClientSite_GetMoniker, + ClientSite_GetContainer, + ClientSite_ShowObject, + ClientSite_OnShowWindow, + ClientSite_RequestNewObjectLayout +}; + +static inline DocHost *impl_from_IOleInPlaceSiteEx(IOleInPlaceSiteEx *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IOleInPlaceSiteEx_iface); +} + +static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSiteEx *iface, REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSiteEx *iface, HWND *phwnd) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + + TRACE("(%p)->(%p)\n", This, phwnd); + + *phwnd = This->hwnd; + return S_OK; +} + +static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSiteEx *iface, BOOL fEnterMode) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + FIXME("(%p)->(%x)\n", This, fEnterMode); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + + TRACE("(%p)\n", This); + + /* Nothing to do here */ + return S_OK; +} + +static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + + TRACE("(%p)\n", This); + + /* Nothing to do here */ + return S_OK; +} + +static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSiteEx *iface, + IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect, + LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + + TRACE("(%p)->(%p %p %p %p %p)\n", This, ppFrame, ppDoc, lprcPosRect, + lprcClipRect, lpFrameInfo); + + IOleInPlaceFrame_AddRef(&This->IOleInPlaceFrame_iface); + *ppFrame = &This->IOleInPlaceFrame_iface; + *ppDoc = NULL; + + GetClientRect(This->hwnd, lprcPosRect); + *lprcClipRect = *lprcPosRect; + + lpFrameInfo->fMDIApp = FALSE; + lpFrameInfo->hwndFrame = This->frame_hwnd; + lpFrameInfo->haccel = NULL; + lpFrameInfo->cAccelEntries = 0; /* FIXME: should be 5 */ + + return S_OK; +} + +static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSiteEx *iface, SIZE scrollExtent) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + FIXME("(%p)->({%d %d})\n", This, scrollExtent.cx, scrollExtent.cy); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSiteEx *iface, BOOL fUndoable) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + FIXME("(%p)->(%x)\n", This, fUndoable); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + + TRACE("(%p)\n", This); + + /* Nothing to do here */ + return S_OK; +} + +static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSiteEx *iface, + LPCRECT lprcPosRect) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + FIXME("(%p)->(%p)\n", This, lprcPosRect); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceSite_OnInPlaceActivateEx(IOleInPlaceSiteEx *iface, + BOOL *pfNoRedraw, DWORD dwFlags) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + + TRACE("(%p)->(%p, %x)\n", This, pfNoRedraw, dwFlags); + + /* FIXME: Avoid redraw, when possible */ + pfNoRedraw = FALSE; + + if (dwFlags) { + FIXME("dwFlags not supported (%x)\n", dwFlags); + } + + /* Nothing to do here */ + return S_OK; +} + +static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivateEx(IOleInPlaceSiteEx *iface, BOOL fNoRedraw) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + + TRACE("(%p)->(%x)\n", This, fNoRedraw); + + if (fNoRedraw) { + FIXME("fNoRedraw (%x) ignored\n", fNoRedraw); + } + + /* Nothing to do here */ + return S_OK; +} + +static HRESULT WINAPI InPlaceSite_RequestUIActivate(IOleInPlaceSiteEx *iface) +{ + DocHost *This = impl_from_IOleInPlaceSiteEx(iface); + TRACE("(%p)\n", This); + + /* OnUIActivate is always possible */ + return S_OK; +} + +static const IOleInPlaceSiteExVtbl OleInPlaceSiteExVtbl = { + InPlaceSite_QueryInterface, + InPlaceSite_AddRef, + InPlaceSite_Release, + InPlaceSite_GetWindow, + InPlaceSite_ContextSensitiveHelp, + InPlaceSite_CanInPlaceActivate, + InPlaceSite_OnInPlaceActivate, + InPlaceSite_OnUIActivate, + InPlaceSite_GetWindowContext, + InPlaceSite_Scroll, + InPlaceSite_OnUIDeactivate, + InPlaceSite_OnInPlaceDeactivate, + InPlaceSite_DiscardUndoState, + InPlaceSite_DeactivateAndUndo, + InPlaceSite_OnPosRectChange, + /* OleInPlaceSiteEx */ + InPlaceSite_OnInPlaceActivateEx, + InPlaceSite_OnInPlaceDeactivateEx, + InPlaceSite_RequestUIActivate +}; + +static inline DocHost *impl_from_IOleDocumentSite(IOleDocumentSite *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IOleDocumentSite_iface); +} + +static HRESULT WINAPI OleDocumentSite_QueryInterface(IOleDocumentSite *iface, + REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IOleDocumentSite(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI OleDocumentSite_AddRef(IOleDocumentSite *iface) +{ + DocHost *This = impl_from_IOleDocumentSite(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI OleDocumentSite_Release(IOleDocumentSite *iface) +{ + DocHost *This = impl_from_IOleDocumentSite(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI OleDocumentSite_ActivateMe(IOleDocumentSite *iface, + IOleDocumentView *pViewToActivate) +{ + DocHost *This = impl_from_IOleDocumentSite(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, (IOleInPlaceSite*) &This->IOleInPlaceSiteEx_iface, NULL, 0, &This->view); + IOleDocument_Release(oledoc); + + GetClientRect(This->hwnd, &rect); + IOleDocumentView_SetRect(This->view, &rect); + + hres = IOleDocumentView_Show(This->view, TRUE); + + return hres; +} + +static const IOleDocumentSiteVtbl OleDocumentSiteVtbl = { + OleDocumentSite_QueryInterface, + OleDocumentSite_AddRef, + OleDocumentSite_Release, + OleDocumentSite_ActivateMe +}; + +static inline DocHost *impl_from_IOleControlSite(IOleControlSite *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IOleControlSite_iface); +} + +static HRESULT WINAPI ControlSite_QueryInterface(IOleControlSite *iface, REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IOleControlSite(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI ControlSite_AddRef(IOleControlSite *iface) +{ + DocHost *This = impl_from_IOleControlSite(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI ControlSite_Release(IOleControlSite *iface) +{ + DocHost *This = impl_from_IOleControlSite(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI ControlSite_OnControlInfoChanged(IOleControlSite *iface) +{ + DocHost *This = impl_from_IOleControlSite(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ControlSite_LockInPlaceActive(IOleControlSite *iface, BOOL fLock) +{ + DocHost *This = impl_from_IOleControlSite(iface); + FIXME("(%p)->(%d)\n", This, fLock); + return E_NOTIMPL; +} + +static HRESULT WINAPI ControlSite_GetExtendedControl(IOleControlSite *iface, IDispatch **ppDisp) +{ + DocHost *This = impl_from_IOleControlSite(iface); + FIXME("(%p)->(%p)\n", This, ppDisp); + return E_NOTIMPL; +} + +static HRESULT WINAPI ControlSite_TransformCoords(IOleControlSite *iface, POINTL *pPtlHimetric, + POINTF *pPtfContainer, DWORD dwFlags) +{ + DocHost *This = impl_from_IOleControlSite(iface); + FIXME("(%p)->(%p, %p, %08x)\n", This, pPtlHimetric, pPtfContainer, dwFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI ControlSite_TranslateAccelerator(IOleControlSite *iface, MSG *pMsg, + DWORD grfModifiers) +{ + DocHost *This = impl_from_IOleControlSite(iface); + IOleObject *wb_obj; + IOleClientSite *clientsite; + IOleControlSite *controlsite; + HRESULT hr; + + TRACE("(%p)->(%p, %08x)\n", This, pMsg, grfModifiers); + + hr = IWebBrowser2_QueryInterface(This->wb, &IID_IOleObject, (void**)&wb_obj); + if(SUCCEEDED(hr)) { + hr = IOleObject_GetClientSite(wb_obj, &clientsite); + if(SUCCEEDED(hr)) { + hr = IOleClientSite_QueryInterface(clientsite, &IID_IOleControlSite, (void**)&controlsite); + if(SUCCEEDED(hr)) { + hr = IOleControlSite_TranslateAccelerator(controlsite, pMsg, grfModifiers); + IOleControlSite_Release(controlsite); + } + IOleClientSite_Release(clientsite); + } + IOleObject_Release(wb_obj); + } + + if(FAILED(hr)) + return S_FALSE; + else + return hr; +} + +static HRESULT WINAPI ControlSite_OnFocus(IOleControlSite *iface, BOOL fGotFocus) +{ + DocHost *This = impl_from_IOleControlSite(iface); + FIXME("(%p)->(%d)\n", This, fGotFocus); + return E_NOTIMPL; +} + +static HRESULT WINAPI ControlSite_ShowPropertyFrame(IOleControlSite *iface) +{ + DocHost *This = impl_from_IOleControlSite(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static IOleControlSiteVtbl OleControlSiteVtbl = { + ControlSite_QueryInterface, + ControlSite_AddRef, + ControlSite_Release, + ControlSite_OnControlInfoChanged, + ControlSite_LockInPlaceActive, + ControlSite_GetExtendedControl, + ControlSite_TransformCoords, + ControlSite_TranslateAccelerator, + ControlSite_OnFocus, + ControlSite_ShowPropertyFrame +}; + +static inline DocHost *impl_from_IDispatch(IDispatch *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IDispatch_iface); +} + +static HRESULT WINAPI ClDispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IDispatch(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI ClDispatch_AddRef(IDispatch *iface) +{ + DocHost *This = impl_from_IDispatch(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI ClDispatch_Release(IDispatch *iface) +{ + DocHost *This = impl_from_IDispatch(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI ClDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo) +{ + DocHost *This = impl_from_IDispatch(iface); + + TRACE("(%p)->(%p)\n", This, pctinfo); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ClDispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid, + ITypeInfo **ppTInfo) +{ + DocHost *This = impl_from_IDispatch(iface); + + TRACE("(%p)->(%u %d %p)\n", This, iTInfo, lcid, ppTInfo); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ClDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames, + UINT cNames, LCID lcid, DISPID *rgDispId) +{ + DocHost *This = impl_from_IDispatch(iface); + + TRACE("(%p)->(%s %p %u %d %p)\n", This, debugstr_guid(riid), rgszNames, cNames, + lcid, rgDispId); + + return E_NOTIMPL; +} + +static const char *debugstr_dispid(DISPID dispid) +{ + static char buf[16]; + +#define CASE_DISPID(did) case did: return #did + switch(dispid) { + CASE_DISPID(DISPID_AMBIENT_USERMODE); + CASE_DISPID(DISPID_AMBIENT_DLCONTROL); + CASE_DISPID(DISPID_AMBIENT_USERAGENT); + CASE_DISPID(DISPID_AMBIENT_PALETTE); + CASE_DISPID(DISPID_AMBIENT_OFFLINEIFNOTCONNECTED); + CASE_DISPID(DISPID_AMBIENT_SILENT); + } +#undef CASE_DISPID + + sprintf(buf, "%d", dispid); + return buf; +} + +static HRESULT WINAPI ClDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid, + LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, + VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) +{ + DocHost *This = impl_from_IDispatch(iface); + + TRACE("(%p)->(%s %s %d %04x %p %p %p %p)\n", This, debugstr_dispid(dispIdMember), + debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + + switch(dispIdMember) { + case DISPID_AMBIENT_USERMODE: + case DISPID_AMBIENT_DLCONTROL: + case DISPID_AMBIENT_USERAGENT: + case DISPID_AMBIENT_PALETTE: + if(!This->client_disp) + return E_FAIL; + return IDispatch_Invoke(This->client_disp, dispIdMember, riid, lcid, wFlags, + pDispParams, pVarResult, pExcepInfo, puArgErr); + case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED: + V_VT(pVarResult) = VT_BOOL; + V_BOOL(pVarResult) = This->offline; + return S_OK; + case DISPID_AMBIENT_SILENT: + V_VT(pVarResult) = VT_BOOL; + V_BOOL(pVarResult) = This->offline; + return S_OK; + } + + FIXME("unhandled dispid %d\n", dispIdMember); + return E_NOTIMPL; +} + +static const IDispatchVtbl DispatchVtbl = { + ClDispatch_QueryInterface, + ClDispatch_AddRef, + ClDispatch_Release, + ClDispatch_GetTypeInfoCount, + ClDispatch_GetTypeInfo, + ClDispatch_GetIDsOfNames, + ClDispatch_Invoke +}; + +static inline DocHost *impl_from_IServiceProvider(IServiceProvider *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IServiceProvider_iface); +} + +static HRESULT WINAPI ClServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, + void **ppv) +{ + DocHost *This = impl_from_IServiceProvider(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI ClServiceProvider_AddRef(IServiceProvider *iface) +{ + DocHost *This = impl_from_IServiceProvider(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI ClServiceProvider_Release(IServiceProvider *iface) +{ + DocHost *This = impl_from_IServiceProvider(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI ClServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService, + REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IServiceProvider(iface); + + if(IsEqualGUID(&IID_IHlinkFrame, guidService)) { + TRACE("(%p)->(IID_IHlinkFrame %s %p)\n", This, debugstr_guid(riid), ppv); + return IWebBrowser2_QueryInterface(This->wb, riid, ppv); + } + + if(IsEqualGUID(&IID_IWebBrowserApp, guidService)) { + TRACE("IWebBrowserApp service\n"); + return IWebBrowser2_QueryInterface(This->wb, riid, ppv); + } + + if(IsEqualGUID(&IID_IShellBrowser, guidService)) { + TRACE("(%p)->(IID_IShellBrowser %s %p)\n", This, debugstr_guid(riid), ppv); + + if(!This->browser_service) { + HRESULT hres; + + hres = create_browser_service(This, &This->browser_service); + if(FAILED(hres)) + return hres; + } + + return IShellBrowser_QueryInterface(&This->browser_service->IShellBrowser_iface, riid, ppv); + } + + if(IsEqualGUID(&SID_SNewWindowManager, guidService)) { + TRACE("SID_SNewWindowManager service\n"); + return INewWindowManager_QueryInterface(&This->nwm.INewWindowManager_iface, riid, ppv); + } + + FIXME("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv); + + return E_NOINTERFACE; +} + +static const IServiceProviderVtbl ServiceProviderVtbl = { + ClServiceProvider_QueryInterface, + ClServiceProvider_AddRef, + ClServiceProvider_Release, + ClServiceProvider_QueryService +}; + +void DocHost_ClientSite_Init(DocHost *This) +{ + This->IOleClientSite_iface.lpVtbl = &OleClientSiteVtbl; + This->IOleInPlaceSiteEx_iface.lpVtbl = &OleInPlaceSiteExVtbl; + This->IOleDocumentSite_iface.lpVtbl = &OleDocumentSiteVtbl; + This->IOleControlSite_iface.lpVtbl = &OleControlSiteVtbl; + This->IDispatch_iface.lpVtbl = &DispatchVtbl; + This->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl; +} + +void DocHost_ClientSite_Release(DocHost *This) +{ + if(This->browser_service) + detach_browser_service(This->browser_service); + if(This->view) + IOleDocumentView_Release(This->view); +} diff --git a/reactos/dll/win32/ieframe/dochost.c b/reactos/dll/win32/ieframe/dochost.c new file mode 100644 index 00000000000..90027597bf8 --- /dev/null +++ b/reactos/dll/win32/ieframe/dochost.c @@ -0,0 +1,1002 @@ +/* + * Copyright 2005-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 "ieframe.h" + +#include +//#include "mshtml.h" +#include + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +DEFINE_OLEGUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0); + +#define DOCHOST_DOCCANNAVIGATE 0 + +/* Undocumented notification, see mshtml tests */ +#define CMDID_EXPLORER_UPDATEHISTORY 38 + +static ATOM doc_view_atom = 0; + +void push_dochost_task(DocHost *This, task_header_t *task, task_proc_t proc, task_destr_t destr, BOOL send) +{ + BOOL is_empty; + + task->proc = proc; + task->destr = destr; + + is_empty = list_empty(&This->task_queue); + list_add_tail(&This->task_queue, &task->entry); + + if(send) + SendMessageW(This->frame_hwnd, WM_DOCHOSTTASK, 0, 0); + else if(is_empty) + PostMessageW(This->frame_hwnd, WM_DOCHOSTTASK, 0, 0); +} + +LRESULT process_dochost_tasks(DocHost *This) +{ + task_header_t *task; + + while(!list_empty(&This->task_queue)) { + task = LIST_ENTRY(This->task_queue.next, task_header_t, entry); + list_remove(&task->entry); + + task->proc(This, task); + task->destr(task); + } + + return 0; +} + +void abort_dochost_tasks(DocHost *This, task_proc_t proc) +{ + task_header_t *task, *cursor; + + LIST_FOR_EACH_ENTRY_SAFE(task, cursor, &This->task_queue, task_header_t, entry) { + if(proc && proc != task->proc) + continue; + + list_remove(&task->entry); + task->destr(task); + } +} + +static void notif_complete(DocHost *This, DISPID dispid) +{ + DISPPARAMS dispparams; + VARIANTARG params[2]; + VARIANT url; + + 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) = (IDispatch*)This->wb; + + V_VT(&url) = VT_BSTR; + V_BSTR(&url) = SysAllocString(This->url); + + TRACE("%d >>>\n", dispid); + call_sink(This->cps.wbe2, dispid, &dispparams); + TRACE("%d <<<\n", dispid); + + SysFreeString(V_BSTR(&url)); + This->busy = VARIANT_FALSE; +} + +static void object_available(DocHost *This) +{ + IHlinkTarget *hlink; + HRESULT hres; + + TRACE("(%p)\n", This); + + if(!This->document) { + WARN("document == NULL\n"); + return; + } + + hres = IUnknown_QueryInterface(This->document, &IID_IHlinkTarget, (void**)&hlink); + if(FAILED(hres)) { + FIXME("Could not get IHlinkTarget interface\n"); + return; + } + + hres = IHlinkTarget_Navigate(hlink, 0, NULL); + IHlinkTarget_Release(hlink); + if(FAILED(hres)) + FIXME("Navigate failed\n"); +} + +static HRESULT get_doc_ready_state(DocHost *This, READYSTATE *ret) +{ + DISPPARAMS dp = {NULL,NULL,0,0}; + IDispatch *disp; + EXCEPINFO ei; + VARIANT var; + HRESULT hres; + + hres = IUnknown_QueryInterface(This->document, &IID_IDispatch, (void**)&disp); + if(FAILED(hres)) + return hres; + + hres = IDispatch_Invoke(disp, DISPID_READYSTATE, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, + &dp, &var, &ei, NULL); + IDispatch_Release(disp); + if(FAILED(hres)) { + WARN("Invoke(DISPID_READYSTATE failed: %08x\n", hres); + return hres; + } + + if(V_VT(&var) != VT_I4) { + WARN("V_VT(var) = %d\n", V_VT(&var)); + VariantClear(&var); + return E_FAIL; + } + + *ret = V_I4(&var); + return S_OK; +} + +static void advise_prop_notif(DocHost *This, BOOL set) +{ + IConnectionPointContainer *cp_container; + IConnectionPoint *cp; + HRESULT hres; + + hres = IUnknown_QueryInterface(This->document, &IID_IConnectionPointContainer, (void**)&cp_container); + if(FAILED(hres)) + return; + + hres = IConnectionPointContainer_FindConnectionPoint(cp_container, &IID_IPropertyNotifySink, &cp); + IConnectionPointContainer_Release(cp_container); + if(FAILED(hres)) + return; + + if(set) + hres = IConnectionPoint_Advise(cp, (IUnknown*)&This->IPropertyNotifySink_iface, &This->prop_notif_cookie); + else + hres = IConnectionPoint_Unadvise(cp, This->prop_notif_cookie); + IConnectionPoint_Release(cp); + + if(SUCCEEDED(hres)) + This->is_prop_notif = set; +} + +void set_doc_state(DocHost *This, READYSTATE doc_state) +{ + This->doc_state = doc_state; + if(doc_state > This->ready_state) + This->ready_state = doc_state; +} + +static void update_ready_state(DocHost *This, READYSTATE ready_state) +{ + if(ready_state > READYSTATE_LOADING && This->doc_state <= READYSTATE_LOADING && !This->browser_service /* FIXME */) + notif_complete(This, DISPID_NAVIGATECOMPLETE2); + + if(ready_state == READYSTATE_COMPLETE && This->doc_state < READYSTATE_COMPLETE) { + set_doc_state(This, READYSTATE_COMPLETE); + if(!This->browser_service) /* FIXME: Not fully correct */ + notif_complete(This, DISPID_DOCUMENTCOMPLETE); + }else { + set_doc_state(This, ready_state); + } +} + +typedef struct { + task_header_t header; + IUnknown *doc; + READYSTATE ready_state; +} ready_state_task_t; + +static void ready_state_task_destr(task_header_t *_task) +{ + ready_state_task_t *task = (ready_state_task_t*)_task; + + IUnknown_Release(task->doc); + heap_free(task); +} + +static void ready_state_proc(DocHost *This, task_header_t *_task) +{ + ready_state_task_t *task = (ready_state_task_t*)_task; + + if(task->doc == This->document) + update_ready_state(This, task->ready_state); +} + +static void push_ready_state_task(DocHost *This, READYSTATE ready_state) +{ + ready_state_task_t *task = heap_alloc(sizeof(ready_state_task_t)); + + IUnknown_AddRef(This->document); + task->doc = This->document; + task->ready_state = ready_state; + + push_dochost_task(This, &task->header, ready_state_proc, ready_state_task_destr, FALSE); +} + +static void object_available_task_destr(task_header_t *task) +{ + heap_free(task); +} + +static void object_available_proc(DocHost *This, task_header_t *task) +{ + object_available(This); +} + +HRESULT dochost_object_available(DocHost *This, IUnknown *doc) +{ + READYSTATE ready_state; + task_header_t *task; + IOleObject *oleobj; + HRESULT hres; + + IUnknown_AddRef(doc); + This->document = doc; + + hres = IUnknown_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj); + if(SUCCEEDED(hres)) { + CLSID clsid; + + hres = IOleObject_GetUserClassID(oleobj, &clsid); + if(SUCCEEDED(hres)) + TRACE("Got clsid %s\n", + IsEqualGUID(&clsid, &CLSID_HTMLDocument) ? "CLSID_HTMLDocument" : debugstr_guid(&clsid)); + + hres = IOleObject_SetClientSite(oleobj, &This->IOleClientSite_iface); + if(FAILED(hres)) + FIXME("SetClientSite failed: %08x\n", hres); + + IOleObject_Release(oleobj); + }else { + FIXME("Could not get IOleObject iface: %08x\n", hres); + } + + /* FIXME: Call SetAdvise */ + + task = heap_alloc(sizeof(*task)); + push_dochost_task(This, task, object_available_proc, object_available_task_destr, FALSE); + + hres = get_doc_ready_state(This, &ready_state); + if(SUCCEEDED(hres)) { + if(ready_state == READYSTATE_COMPLETE) + push_ready_state_task(This, READYSTATE_COMPLETE); + if(ready_state != READYSTATE_COMPLETE || This->doc_navigate) + advise_prop_notif(This, TRUE); + } + + return S_OK; +} + +static LRESULT resize_document(DocHost *This, LONG width, LONG height) +{ + RECT rect = {0, 0, width, height}; + + TRACE("(%p)->(%d %d)\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) +{ + DocHost *This; + + static const WCHAR wszTHIS[] = {'T','H','I','S',0}; + + if(msg == WM_CREATE) { + This = *(DocHost**)lParam; + SetPropW(hwnd, wszTHIS, This); + }else { + This = GetPropW(hwnd, wszTHIS); + } + + switch(msg) { + case WM_SIZE: + return resize_document(This, LOWORD(lParam), HIWORD(lParam)); + } + + return DefWindowProcW(hwnd, msg, wParam, lParam); +} + +static void update_travellog(DocHost *This) +{ + travellog_entry_t *new_entry; + + if(!This->travellog) { + This->travellog = heap_alloc(4 * sizeof(*This->travellog)); + if(!This->travellog) + return; + + This->travellog_size = 4; + }else if(This->travellog_size < This->travellog_position+1) { + travellog_entry_t *new_travellog; + + new_travellog = heap_realloc(This->travellog, This->travellog_size*2*sizeof(*This->travellog)); + if(!new_travellog) + return; + + This->travellog = new_travellog; + This->travellog_size *= 2; + } + + while(This->travellog_length > This->travellog_position) + heap_free(This->travellog[--This->travellog_length].url); + + new_entry = This->travellog + This->travellog_position; + + new_entry->url = heap_strdupW(This->url); + if(!new_entry->url) + return; + + This->travellog_position++; +} + +void create_doc_view_hwnd(DocHost *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_WINDOW + 1), NULL, + wszShell_DocObject_View, + NULL + }; + + wndclass.hInstance = ieframe_instance; + + doc_view_atom = RegisterClassExW(&wndclass); + } + + This->container_vtbl->GetDocObjRect(This, &rect); + This->hwnd = CreateWindowExW(0, wszShell_DocObject_View, + wszShell_DocObject_View, + WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_TABSTOP, + rect.left, rect.top, rect.right, rect.bottom, This->frame_hwnd, + NULL, ieframe_instance, This); +} + +void deactivate_document(DocHost *This) +{ + IOleInPlaceObjectWindowless *winobj; + IOleObject *oleobj = NULL; + IHlinkTarget *hlink = NULL; + HRESULT hres; + + if(!This->document) return; + + if(This->doc_navigate) { + IUnknown_Release(This->doc_navigate); + This->doc_navigate = NULL; + } + + if(This->is_prop_notif) + advise_prop_notif(This, FALSE); + + if(This->view) + IOleDocumentView_UIActivate(This->view, FALSE); + + hres = IUnknown_QueryInterface(This->document, &IID_IOleInPlaceObjectWindowless, + (void**)&winobj); + if(SUCCEEDED(hres)) { + IOleInPlaceObjectWindowless_InPlaceDeactivate(winobj); + IOleInPlaceObjectWindowless_Release(winobj); + } + + if(This->view) { + IOleDocumentView_Show(This->view, FALSE); + IOleDocumentView_CloseView(This->view, 0); + IOleDocumentView_SetInPlaceSite(This->view, NULL); + IOleDocumentView_Release(This->view); + This->view = NULL; + } + + hres = IUnknown_QueryInterface(This->document, &IID_IOleObject, (void**)&oleobj); + if(SUCCEEDED(hres)) + IOleObject_Close(oleobj, OLECLOSE_NOSAVE); + + hres = IUnknown_QueryInterface(This->document, &IID_IHlinkTarget, (void**)&hlink); + if(SUCCEEDED(hres)) { + IHlinkTarget_SetBrowseContext(hlink, NULL); + IHlinkTarget_Release(hlink); + } + + if(oleobj) { + IOleClientSite *client_site = NULL; + + IOleObject_GetClientSite(oleobj, &client_site); + if(client_site) { + if(client_site == &This->IOleClientSite_iface) + IOleObject_SetClientSite(oleobj, NULL); + IOleClientSite_Release(client_site); + } + + IOleObject_Release(oleobj); + } + + IUnknown_Release(This->document); + This->document = NULL; +} + +HRESULT refresh_document(DocHost *This) +{ + IOleCommandTarget *cmdtrg; + VARIANT vin, vout; + HRESULT hres; + + if(!This->document) { + FIXME("no document\n"); + return E_FAIL; + } + + hres = IUnknown_QueryInterface(This->document, &IID_IOleCommandTarget, (void**)&cmdtrg); + if(FAILED(hres)) + return hres; + + V_VT(&vin) = VT_EMPTY; + V_VT(&vout) = VT_EMPTY; + hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_REFRESH, OLECMDEXECOPT_PROMPTUSER, &vin, &vout); + IOleCommandTarget_Release(cmdtrg); + if(FAILED(hres)) + return hres; + + VariantClear(&vout); + return S_OK; +} + +void release_dochost_client(DocHost *This) +{ + if(This->hwnd) { + DestroyWindow(This->hwnd); + This->hwnd = NULL; + } + + if(This->hostui) { + IDocHostUIHandler_Release(This->hostui); + This->hostui = NULL; + } + + if(This->client_disp) { + IDispatch_Release(This->client_disp); + This->client_disp = NULL; + } + + if(This->frame) { + IOleInPlaceFrame_Release(This->frame); + This->frame = NULL; + } +} + +static inline DocHost *impl_from_IOleCommandTarget(IOleCommandTarget *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IOleCommandTarget_iface); +} + +static HRESULT WINAPI ClOleCommandTarget_QueryInterface(IOleCommandTarget *iface, + REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IOleCommandTarget(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI ClOleCommandTarget_AddRef(IOleCommandTarget *iface) +{ + DocHost *This = impl_from_IOleCommandTarget(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI ClOleCommandTarget_Release(IOleCommandTarget *iface) +{ + DocHost *This = impl_from_IOleCommandTarget(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI ClOleCommandTarget_QueryStatus(IOleCommandTarget *iface, + const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText) +{ + DocHost *This = impl_from_IOleCommandTarget(iface); + ULONG i= 0; + FIXME("(%p)->(%s %u %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, + pCmdText); + while (prgCmds && (cCmds > i)) { + FIXME("command_%u: %u, 0x%x\n", i, prgCmds[i].cmdID, prgCmds[i].cmdf); + i++; + } + return E_NOTIMPL; +} + +static HRESULT WINAPI ClOleCommandTarget_Exec(IOleCommandTarget *iface, + const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, + VARIANT *pvaOut) +{ + DocHost *This = impl_from_IOleCommandTarget(iface); + + TRACE("(%p)->(%s %d %d %s %s)\n", This, debugstr_guid(pguidCmdGroup), nCmdID, nCmdexecopt, + debugstr_variant(pvaIn), debugstr_variant(pvaOut)); + + if(!pguidCmdGroup) { + switch(nCmdID) { + case OLECMDID_UPDATECOMMANDS: + case OLECMDID_SETDOWNLOADSTATE: + return This->container_vtbl->exec(This, pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); + default: + FIXME("Unimplemented cmdid %d\n", nCmdID); + return E_NOTIMPL; + } + } + + if(IsEqualGUID(pguidCmdGroup, &CGID_DocHostCmdPriv)) { + switch(nCmdID) { + case DOCHOST_DOCCANNAVIGATE: + if(!pvaIn || V_VT(pvaIn) != VT_UNKNOWN) + return E_INVALIDARG; + + if(This->doc_navigate) + IUnknown_Release(This->doc_navigate); + IUnknown_AddRef(V_UNKNOWN(pvaIn)); + This->doc_navigate = V_UNKNOWN(pvaIn); + return S_OK; + + case 1: { + IHTMLWindow2 *win2; + SAFEARRAY *sa = V_ARRAY(pvaIn); + VARIANT status_code, url, htmlwindow; + LONG ind; + HRESULT hres; + + if(V_VT(pvaIn) != VT_ARRAY || !sa || (SafeArrayGetDim(sa) != 1)) + return E_INVALIDARG; + + ind = 0; + hres = SafeArrayGetElement(sa, &ind, &status_code); + if(FAILED(hres) || V_VT(&status_code)!=VT_I4) + return E_INVALIDARG; + + ind = 1; + hres = SafeArrayGetElement(sa, &ind, &url); + if(FAILED(hres) || V_VT(&url)!=VT_BSTR) + return E_INVALIDARG; + + ind = 3; + hres = SafeArrayGetElement(sa, &ind, &htmlwindow); + if(FAILED(hres) || V_VT(&htmlwindow)!=VT_UNKNOWN || !V_UNKNOWN(&htmlwindow)) + return E_INVALIDARG; + + hres = IUnknown_QueryInterface(V_UNKNOWN(&htmlwindow), &IID_IHTMLWindow2, (void**)&win2); + if(FAILED(hres)) + return E_INVALIDARG; + + handle_navigation_error(This, V_I4(&status_code), V_BSTR(&url), win2); + IHTMLWindow2_Release(win2); + return S_OK; + } + + default: + FIXME("unsupported command %d of CGID_DocHostCmdPriv\n", nCmdID); + return E_NOTIMPL; + } + } + + if(IsEqualGUID(pguidCmdGroup, &CGID_Explorer)) { + switch(nCmdID) { + case CMDID_EXPLORER_UPDATEHISTORY: + update_travellog(This); + return S_OK; + + default: + FIXME("Unimplemented cmdid %d of CGID_Explorer\n", nCmdID); + return E_NOTIMPL; + } + } + + if(IsEqualGUID(pguidCmdGroup, &CGID_ShellDocView)) { + switch(nCmdID) { + default: + FIXME("Unimplemented cmdid %d of CGID_ShellDocView\n", nCmdID); + return E_NOTIMPL; + } + } + + if(IsEqualGUID(&CGID_DocHostCommandHandler, pguidCmdGroup)) + return This->container_vtbl->exec(This, pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); + + FIXME("Unimplemented cmdid %d of group %s\n", nCmdID, debugstr_guid(pguidCmdGroup)); + return E_NOTIMPL; +} + +static const IOleCommandTargetVtbl OleCommandTargetVtbl = { + ClOleCommandTarget_QueryInterface, + ClOleCommandTarget_AddRef, + ClOleCommandTarget_Release, + ClOleCommandTarget_QueryStatus, + ClOleCommandTarget_Exec +}; + +static inline DocHost *impl_from_IDocHostUIHandler2(IDocHostUIHandler2 *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IDocHostUIHandler2_iface); +} + +static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, + REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, + DWORD dwID, POINT *ppt, IUnknown *pcmdtReserved, IDispatch *pdispReserved) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + HRESULT hres; + + TRACE("(%p)->(%d %p %p %p)\n", This, dwID, ppt, pcmdtReserved, pdispReserved); + + if(This->hostui) { + hres = IDocHostUIHandler_ShowContextMenu(This->hostui, dwID, ppt, pcmdtReserved, + pdispReserved); + if(hres == S_OK) + return S_OK; + } + + FIXME("default action not implemented\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, + DOCHOSTUIINFO *pInfo) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + HRESULT hres; + + TRACE("(%p)->(%p)\n", This, pInfo); + + if(This->hostui) { + hres = IDocHostUIHandler_GetHostInfo(This->hostui, pInfo); + if(SUCCEEDED(hres)) + return hres; + } + + pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_OPENNEWWIN + | DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8 | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION + | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION; + return S_OK; +} + +static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID, + IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget, + IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)->(%d %p %p %p %p)\n", This, dwID, pActiveObject, pCommandTarget, + pFrame, pDoc); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + + TRACE("(%p)\n", This); + + if(!This->hostui) + return S_FALSE; + + return IDocHostUIHandler_UpdateUI(This->hostui); +} + +static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, + BOOL fEnable) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)->(%x)\n", This, fEnable); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, + BOOL fActivate) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)->(%x)\n", This, fActivate); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, + BOOL fActivate) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)->(%x)\n", This, fActivate); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, + LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)->(%p %p %X)\n", This, prcBorder, pUIWindow, fRameWindow); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, + LPMSG lpMsg, const GUID *pguidCmdGroup, DWORD nCmdID) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + HRESULT hr = S_FALSE; + TRACE("(%p)->(%p %p %d)\n", This, lpMsg, pguidCmdGroup, nCmdID); + + if(This->hostui) + hr = IDocHostUIHandler_TranslateAccelerator(This->hostui, lpMsg, pguidCmdGroup, nCmdID); + + return hr; +} + +static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface, + LPOLESTR *pchKey, DWORD dw) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + + TRACE("(%p)->(%p %d)\n", This, pchKey, dw); + + if(This->hostui) + return IDocHostUIHandler_GetOptionKeyPath(This->hostui, pchKey, dw); + + return S_OK; +} + +static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface, + IDropTarget *pDropTarget, IDropTarget **ppDropTarget) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, + IDispatch **ppDispatch) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + + TRACE("(%p)->(%p)\n", This, ppDispatch); + + if(This->hostui) + return IDocHostUIHandler_GetExternal(This->hostui, ppDispatch); + + if(!This->shell_ui_helper) { + HRESULT hres; + + hres = create_shell_ui_helper(&This->shell_ui_helper); + if(FAILED(hres)) + return hres; + } + + *ppDispatch = (IDispatch*)This->shell_ui_helper; + IDispatch_AddRef(*ppDispatch); + return S_OK; +} + +static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, + DWORD dwTranslate, OLECHAR *pchURLIn, OLECHAR **ppchURLOut) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + + TRACE("(%p)->(%d %s %p)\n", This, dwTranslate, debugstr_w(pchURLIn), ppchURLOut); + + if(This->hostui) + return IDocHostUIHandler_TranslateUrl(This->hostui, dwTranslate, + pchURLIn, ppchURLOut); + + return S_FALSE; +} + +static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, + IDataObject *pDO, IDataObject **ppDORet) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + FIXME("(%p)->(%p %p)\n", This, pDO, ppDORet); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface, + LPOLESTR *pchKey, DWORD dw) +{ + DocHost *This = impl_from_IDocHostUIHandler2(iface); + IDocHostUIHandler2 *handler; + HRESULT hres; + + TRACE("(%p)->(%p %d)\n", This, pchKey, dw); + + if(!This->hostui) + return S_OK; + + hres = IDocHostUIHandler_QueryInterface(This->hostui, &IID_IDocHostUIHandler2, + (void**)&handler); + if(SUCCEEDED(hres)) { + hres = IDocHostUIHandler2_GetOverrideKeyPath(handler, pchKey, dw); + IDocHostUIHandler2_Release(handler); + return hres; + } + + return S_OK; +} + +static const IDocHostUIHandler2Vtbl DocHostUIHandler2Vtbl = { + DocHostUIHandler_QueryInterface, + DocHostUIHandler_AddRef, + DocHostUIHandler_Release, + DocHostUIHandler_ShowContextMenu, + DocHostUIHandler_GetHostInfo, + DocHostUIHandler_ShowUI, + DocHostUIHandler_HideUI, + DocHostUIHandler_UpdateUI, + DocHostUIHandler_EnableModeless, + DocHostUIHandler_OnDocWindowActivate, + DocHostUIHandler_OnFrameWindowActivate, + DocHostUIHandler_ResizeBorder, + DocHostUIHandler_TranslateAccelerator, + DocHostUIHandler_GetOptionKeyPath, + DocHostUIHandler_GetDropTarget, + DocHostUIHandler_GetExternal, + DocHostUIHandler_TranslateUrl, + DocHostUIHandler_FilterDataObject, + DocHostUIHandler_GetOverrideKeyPath +}; + +static inline DocHost *impl_from_IPropertyNotifySink(IPropertyNotifySink *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IPropertyNotifySink_iface); +} + +static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface, + REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IPropertyNotifySink(iface); + return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv); +} + +static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface) +{ + DocHost *This = impl_from_IPropertyNotifySink(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface) +{ + DocHost *This = impl_from_IPropertyNotifySink(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID) +{ + DocHost *This = impl_from_IPropertyNotifySink(iface); + + TRACE("(%p)->(%d)\n", This, dispID); + + switch(dispID) { + case DISPID_READYSTATE: { + READYSTATE ready_state; + HRESULT hres; + + hres = get_doc_ready_state(This, &ready_state); + if(FAILED(hres)) + return hres; + + if(ready_state == READYSTATE_COMPLETE && !This->doc_navigate) + advise_prop_notif(This, FALSE); + + update_ready_state(This, ready_state); + break; + } + default: + FIXME("unimplemented dispid %d\n", dispID); + return E_NOTIMPL; + } + + return S_OK; +} + +static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID) +{ + DocHost *This = impl_from_IPropertyNotifySink(iface); + FIXME("(%p)->(%d)\n", This, dispID); + return E_NOTIMPL; +} + +static const IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = { + PropertyNotifySink_QueryInterface, + PropertyNotifySink_AddRef, + PropertyNotifySink_Release, + PropertyNotifySink_OnChanged, + PropertyNotifySink_OnRequestEdit +}; + +void DocHost_Init(DocHost *This, IWebBrowser2 *wb, const IDocHostContainerVtbl* container) +{ + This->IDocHostUIHandler2_iface.lpVtbl = &DocHostUIHandler2Vtbl; + This->IOleCommandTarget_iface.lpVtbl = &OleCommandTargetVtbl; + This->IPropertyNotifySink_iface.lpVtbl = &PropertyNotifySinkVtbl; + + This->wb = wb; + This->container_vtbl = container; + + This->ready_state = READYSTATE_UNINITIALIZED; + list_init(&This->task_queue); + + DocHost_ClientSite_Init(This); + DocHost_Frame_Init(This); + + ConnectionPointContainer_Init(&This->cps, (IUnknown*)wb); + IEHTMLWindow_Init(This); + NewWindowManager_Init(This); +} + +void DocHost_Release(DocHost *This) +{ + if(This->shell_ui_helper) + IShellUIHelper2_Release(This->shell_ui_helper); + + abort_dochost_tasks(This, NULL); + release_dochost_client(This); + DocHost_ClientSite_Release(This); + + ConnectionPointContainer_Destroy(&This->cps); + + while(This->travellog_length) + heap_free(This->travellog[--This->travellog_length].url); + heap_free(This->travellog); + + heap_free(This->url); +} diff --git a/reactos/dll/win32/ieframe/events.c b/reactos/dll/win32/ieframe/events.c new file mode 100644 index 00000000000..dab3fcc6fb3 --- /dev/null +++ b/reactos/dll/win32/ieframe/events.c @@ -0,0 +1,320 @@ +/* + * Implementation of event-related interfaces for WebBrowser control: + * + * - IConnectionPointContainer + * - IConnectionPoint + * + * Copyright 2001 John R. Sheets (for CodeWeavers) + * 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 + +#include "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +struct ConnectionPoint { + IConnectionPoint IConnectionPoint_iface; + + IConnectionPointContainer *container; + + IDispatch **sinks; + DWORD sinks_size; + + IID iid; +}; + +/********************************************************************** + * Implement the IConnectionPointContainer interface + */ + +static inline ConnectionPointContainer *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface) +{ + return CONTAINING_RECORD(iface, ConnectionPointContainer, IConnectionPointContainer_iface); +} + +static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface, + REFIID riid, LPVOID *ppv) +{ + ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface); + return IUnknown_QueryInterface(This->impl, riid, ppv); +} + +static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface) +{ + ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface); + return IUnknown_AddRef(This->impl); +} + +static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface) +{ + ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface); + return IUnknown_Release(This->impl); +} + +static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface, + LPENUMCONNECTIONPOINTS *ppEnum) +{ + ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface); + FIXME("(%p)->(%p)\n", This, ppEnum); + return E_NOTIMPL; +} + +static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface, + REFIID riid, LPCONNECTIONPOINT *ppCP) +{ + ConnectionPointContainer *This = impl_from_IConnectionPointContainer(iface); + + if(!ppCP) { + WARN("ppCP == NULL\n"); + return E_POINTER; + } + + *ppCP = NULL; + + if(IsEqualGUID(&DIID_DWebBrowserEvents2, riid)) { + TRACE("(%p)->(DIID_DWebBrowserEvents2 %p)\n", This, ppCP); + *ppCP = &This->wbe2->IConnectionPoint_iface; + }else if(IsEqualGUID(&DIID_DWebBrowserEvents, riid)) { + TRACE("(%p)->(DIID_DWebBrowserEvents %p)\n", This, ppCP); + *ppCP = &This->wbe->IConnectionPoint_iface; + }else if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) { + TRACE("(%p)->(IID_IPropertyNotifySink %p)\n", This, ppCP); + *ppCP = &This->pns->IConnectionPoint_iface; + } + + if(*ppCP) { + IConnectionPoint_AddRef(*ppCP); + return S_OK; + } + + WARN("Unsupported IID %s\n", debugstr_guid(riid)); + return CONNECT_E_NOCONNECTION; +} + +#undef impl_from_IConnectionPointContainer + +static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = +{ + ConnectionPointContainer_QueryInterface, + ConnectionPointContainer_AddRef, + ConnectionPointContainer_Release, + ConnectionPointContainer_EnumConnectionPoints, + ConnectionPointContainer_FindConnectionPoint +}; + + +/********************************************************************** + * Implement the IConnectionPoint interface + */ + +static inline ConnectionPoint *impl_from_IConnectionPoint(IConnectionPoint *iface) +{ + return CONTAINING_RECORD(iface, ConnectionPoint, IConnectionPoint_iface); +} + +static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface, + REFIID riid, LPVOID *ppv) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + + *ppv = NULL; + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IConnectionPoint_iface; + }else if(IsEqualGUID(&IID_IConnectionPoint, riid)) { + TRACE("(%p)->(IID_IConnectionPoint %p)\n", This, ppv); + *ppv = &This->IConnectionPoint_iface; + } + + if(*ppv) { + IConnectionPointContainer_AddRef(This->container); + return S_OK; + } + + WARN("Unsupported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + return IConnectionPointContainer_AddRef(This->container); +} + +static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + return IConnectionPointContainer_Release(This->container); +} + +static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + + TRACE("(%p)->(%p)\n", This, pIID); + + *pIID = This->iid; + return S_OK; +} + +static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface, + IConnectionPointContainer **ppCPC) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + + TRACE("(%p)->(%p)\n", This, ppCPC); + + *ppCPC = This->container; + IConnectionPointContainer_AddRef(This->container); + return S_OK; +} + +static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink, + DWORD *pdwCookie) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + 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 = 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] = disp; + *pdwCookie = i+1; + + return S_OK; +} + +static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + + TRACE("(%p)->(%d)\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, + IEnumConnections **ppEnum) +{ + ConnectionPoint *This = impl_from_IConnectionPoint(iface); + FIXME("(%p)->(%p)\n", This, ppEnum); + return E_NOTIMPL; +} + +static const IConnectionPointVtbl ConnectionPointVtbl = +{ + ConnectionPoint_QueryInterface, + ConnectionPoint_AddRef, + ConnectionPoint_Release, + ConnectionPoint_GetConnectionInterface, + ConnectionPoint_GetConnectionPointContainer, + ConnectionPoint_Advise, + ConnectionPoint_Unadvise, + ConnectionPoint_EnumConnections +}; + +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(REFIID riid, ConnectionPoint **cp, + IConnectionPointContainer *container) +{ + ConnectionPoint *ret = heap_alloc(sizeof(ConnectionPoint)); + + ret->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl; + + ret->sinks = NULL; + ret->sinks_size = 0; + ret->container = container; + + ret->iid = *riid; + + *cp = ret; +} + +static void ConnectionPoint_Destroy(ConnectionPoint *This) +{ + DWORD i; + + for(i=0; isinks_size; i++) { + if(This->sinks[i]) + IDispatch_Release(This->sinks[i]); + } + + heap_free(This->sinks); + heap_free(This); +} + +void ConnectionPointContainer_Init(ConnectionPointContainer *This, IUnknown *impl) +{ + This->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl; + + ConnectionPoint_Create(&DIID_DWebBrowserEvents2, &This->wbe2, &This->IConnectionPointContainer_iface); + ConnectionPoint_Create(&DIID_DWebBrowserEvents, &This->wbe, &This->IConnectionPointContainer_iface); + ConnectionPoint_Create(&IID_IPropertyNotifySink, &This->pns, &This->IConnectionPointContainer_iface); + + This->impl = impl; +} + +void ConnectionPointContainer_Destroy(ConnectionPointContainer *This) +{ + ConnectionPoint_Destroy(This->wbe2); + ConnectionPoint_Destroy(This->wbe); + ConnectionPoint_Destroy(This->pns); +} diff --git a/reactos/dll/win32/ieframe/frame.c b/reactos/dll/win32/ieframe/frame.c new file mode 100644 index 00000000000..aabadeb32c3 --- /dev/null +++ b/reactos/dll/win32/ieframe/frame.c @@ -0,0 +1,185 @@ +/* + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static inline DocHost *impl_from_IOleInPlaceFrame(IOleInPlaceFrame *iface) +{ + return CONTAINING_RECORD(iface, DocHost, IOleInPlaceFrame_iface); +} + +static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, + REFIID riid, void **ppv) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IOleInPlaceFrame_iface; + }else if(IsEqualGUID(&IID_IOleWindow, riid)) { + TRACE("(%p)->(IID_IOleWindow %p)\n", This, ppv); + *ppv = &This->IOleInPlaceFrame_iface; + }else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid)) { + TRACE("(%p)->(IID_IOleInPlaceUIWindow %p)\n", This, ppv); + *ppv = &This->IOleInPlaceFrame_iface; + }else if(IsEqualGUID(&IID_IOleInPlaceFrame, riid)) { + TRACE("(%p)->(IID_IOleInPlaceFrame %p)\n", This, ppv); + *ppv = &This->IOleInPlaceFrame_iface; + }else { + *ppv = NULL; + WARN("Unsopported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; + } + + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + return IOleClientSite_AddRef(&This->IOleClientSite_iface); +} + +static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + return IOleClientSite_Release(&This->IOleClientSite_iface); +} + +static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%p)\n", This, phwnd); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, + BOOL fEnterMode) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%x)\n", This, fEnterMode); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%p)\n", This, lprectBorder); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface, + LPCBORDERWIDTHS pborderwidths) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%p)\n", This, pborderwidths); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface, + LPCBORDERWIDTHS pborderwidths) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%p)\n", This, pborderwidths); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface, + IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName) +{ + DocHost *This = impl_from_IOleInPlaceFrame(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) +{ + DocHost *This = impl_from_IOleInPlaceFrame(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) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%p %p %p)\n", This, hmenuShared, holemenu, hwndActiveObject); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%p)\n", This, hmenuShared); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, + LPCOLESTR pszStatusText) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + TRACE("(%p)->(%s)\n", This, debugstr_w(pszStatusText)); + return This->container_vtbl->SetStatusText(This, pszStatusText); +} + +static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%x)\n", This, fEnable); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, + WORD wID) +{ + DocHost *This = impl_from_IOleInPlaceFrame(iface); + FIXME("(%p)->(%p %d)\n", This, lpmsg, wID); + return E_NOTIMPL; +} + +#undef impl_from_IOleInPlaceFrame + +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 DocHost_Frame_Init(DocHost *This) +{ + This->IOleInPlaceFrame_iface.lpVtbl = &OleInPlaceFrameVtbl; +} diff --git a/reactos/dll/win32/ieframe/ie.c b/reactos/dll/win32/ieframe/ie.c new file mode 100644 index 00000000000..d8cdc63c3b6 --- /dev/null +++ b/reactos/dll/win32/ieframe/ie.c @@ -0,0 +1,759 @@ +/* + * 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 "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static inline InternetExplorer *impl_from_IWebBrowser2(IWebBrowser2 *iface) +{ + return CONTAINING_RECORD(iface, InternetExplorer, IWebBrowser2_iface); +} + +static HRESULT WINAPI InternetExplorer_QueryInterface(IWebBrowser2 *iface, REFIID riid, LPVOID *ppv) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + + *ppv = NULL; + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IDispatch, riid)) { + TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IWebBrowser, riid)) { + TRACE("(%p)->(IID_IWebBrowser %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IWebBrowserApp, riid)) { + TRACE("(%p)->(IID_IWebBrowserApp %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IWebBrowser2, riid)) { + TRACE("(%p)->(IID_IWebBrowser2 %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) { + TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv); + *ppv = &This->doc_host->doc_host.cps.IConnectionPointContainer_iface; + }else if(IsEqualGUID(&IID_IServiceProvider, riid)) { + TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv); + *ppv = &This->IServiceProvider_iface; + }else if(HlinkFrame_QI(&This->hlink_frame, riid, ppv)) { + return S_OK; + } + + if(*ppv) { + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; + } + + WARN("(%p)->(%s %p) interface not supported\n", This, debugstr_guid(riid), ppv); + return E_NOINTERFACE; +} + +static ULONG WINAPI InternetExplorer_AddRef(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + LONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p) ref=%d\n", This, ref); + return ref; +} + +static ULONG WINAPI InternetExplorer_Release(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) { + if(This->doc_host) { + deactivate_document(&This->doc_host->doc_host); + DocHost_Release(&This->doc_host->doc_host); + if(This->doc_host) { + This->doc_host->ie = NULL; + This->doc_host->doc_host.container_vtbl->release(&This->doc_host->doc_host); + } + } + + if(This->frame_hwnd) + DestroyWindow(This->frame_hwnd); + list_remove(&This->entry); + heap_free(This); + + released_obj(); + } + + return ref; +} + +static HRESULT WINAPI InternetExplorer_GetTypeInfoCount(IWebBrowser2 *iface, UINT *pctinfo) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pctinfo); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_GetTypeInfo(IWebBrowser2 *iface, UINT iTInfo, LCID lcid, + LPTYPEINFO *ppTInfo) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d %d %p)\n", This, iTInfo, lcid, ppTInfo); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_GetIDsOfNames(IWebBrowser2 *iface, REFIID riid, + LPOLESTR *rgszNames, UINT cNames, + LCID lcid, DISPID *rgDispId) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s %p %d %d %p)\n", This, debugstr_guid(riid), rgszNames, cNames, + lcid, rgDispId); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_Invoke(IWebBrowser2 *iface, DISPID dispIdMember, + REFIID riid, LCID lcid, WORD wFlags, + DISPPARAMS *pDispParams, VARIANT *pVarResult, + EXCEPINFO *pExepInfo, UINT *puArgErr) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d %s %d %08x %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid), + lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_GoBack(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + TRACE("(%p)\n", This); + return go_back(&This->doc_host->doc_host); +} + +static HRESULT WINAPI InternetExplorer_GoForward(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_GoHome(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + TRACE("(%p)\n", This); + return go_home(&This->doc_host->doc_host); +} + +static HRESULT WINAPI InternetExplorer_GoSearch(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_Navigate(IWebBrowser2 *iface, BSTR szUrl, + VARIANT *Flags, VARIANT *TargetFrameName, + VARIANT *PostData, VARIANT *Headers) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%s %p %p %p %p)\n", This, debugstr_w(szUrl), Flags, TargetFrameName, + PostData, Headers); + + return navigate_url(&This->doc_host->doc_host, szUrl, Flags, TargetFrameName, PostData, Headers); +} + +static HRESULT WINAPI InternetExplorer_Refresh(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)\n", This); + + return refresh_document(&This->doc_host->doc_host); +} + +static HRESULT WINAPI InternetExplorer_Refresh2(IWebBrowser2 *iface, VARIANT *Level) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Level); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_Stop(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Application(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, ppDisp); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Parent(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, ppDisp); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Container(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, ppDisp); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Document(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, ppDisp); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_TopLevelContainer(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pBool); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Type(IWebBrowser2 *iface, BSTR *Type) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Type); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Left(IWebBrowser2 *iface, LONG *pl) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pl); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_Left(IWebBrowser2 *iface, LONG Left) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d)\n", This, Left); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Top(IWebBrowser2 *iface, LONG *pl) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pl); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_Top(IWebBrowser2 *iface, LONG Top) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d)\n", This, Top); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Width(IWebBrowser2 *iface, LONG *pl) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pl); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_Width(IWebBrowser2 *iface, LONG Width) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d)\n", This, Width); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Height(IWebBrowser2 *iface, LONG *pl) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pl); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_Height(IWebBrowser2 *iface, LONG Height) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d)\n", This, Height); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_LocationName(IWebBrowser2 *iface, BSTR *LocationName) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, LocationName); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_LocationURL(IWebBrowser2 *iface, BSTR *LocationURL) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, LocationURL); + + return get_location_url(&This->doc_host->doc_host, LocationURL); +} + +static HRESULT WINAPI InternetExplorer_get_Busy(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pBool); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_Quit(IWebBrowser2 *iface) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_ClientToWindow(IWebBrowser2 *iface, int *pcx, int *pcy) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p %p)\n", This, pcx, pcy); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_PutProperty(IWebBrowser2 *iface, BSTR szProperty, VARIANT vtValue) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(szProperty)); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_GetProperty(IWebBrowser2 *iface, BSTR szProperty, VARIANT *pvtValue) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s %p)\n", This, debugstr_w(szProperty), pvtValue); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Name(IWebBrowser2 *iface, BSTR *Name) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Name); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_HWND(IWebBrowser2 *iface, LONG *pHWND) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pHWND); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_FullName(IWebBrowser2 *iface, BSTR *FullName) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, FullName); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Path(IWebBrowser2 *iface, BSTR *Path) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Path); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Visible(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pBool); + + *pBool = IsWindowVisible(This->frame_hwnd) ? VARIANT_TRUE : VARIANT_FALSE; + return S_OK; +} + +static HRESULT WINAPI InternetExplorer_put_Visible(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + TRACE("(%p)->(%x)\n", This, Value); + + ShowWindow(This->frame_hwnd, Value ? SW_SHOW : SW_HIDE); + + return S_OK; +} + +static HRESULT WINAPI InternetExplorer_get_StatusBar(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pBool); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_StatusBar(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, Value); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_StatusText(IWebBrowser2 *iface, BSTR *StatusText) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, StatusText); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_StatusText(IWebBrowser2 *iface, BSTR StatusText) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%s)\n", This, debugstr_w(StatusText)); + + return update_ie_statustext(This, StatusText); +} + +static HRESULT WINAPI InternetExplorer_get_ToolBar(IWebBrowser2 *iface, int *Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Value); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_ToolBar(IWebBrowser2 *iface, int Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d)\n", This, Value); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_MenuBar(IWebBrowser2 *iface, VARIANT_BOOL *Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Value); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_MenuBar(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + HMENU menu = NULL; + + TRACE("(%p)->(%x)\n", This, Value); + + if(Value) + menu = This->menu; + + if(!SetMenu(This->frame_hwnd, menu)) + return HRESULT_FROM_WIN32(GetLastError()); + + return S_OK; +} + +static HRESULT WINAPI InternetExplorer_get_FullScreen(IWebBrowser2 *iface, VARIANT_BOOL *pbFullScreen) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pbFullScreen); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_FullScreen(IWebBrowser2 *iface, VARIANT_BOOL bFullScreen) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, bFullScreen); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VARIANT *Flags, + VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p %p %p %p %p)\n", This, URL, Flags, TargetFrameName, PostData, Headers); + + if(!URL) + return S_OK; + + if(V_VT(URL) != VT_BSTR) { + FIXME("Unsupported V_VT(URL) %d\n", V_VT(URL)); + return E_INVALIDARG; + } + + return navigate_url(&This->doc_host->doc_host, V_BSTR(URL), Flags, TargetFrameName, PostData, Headers); +} + +static HRESULT WINAPI InternetExplorer_QueryStatusWB(IWebBrowser2 *iface, OLECMDID cmdID, OLECMDF *pcmdf) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d %p)\n", This, cmdID, pcmdf); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_ExecWB(IWebBrowser2 *iface, OLECMDID cmdID, + OLECMDEXECOPT cmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%d %d %p %p)\n", This, cmdID, cmdexecopt, pvaIn, pvaOut); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_ShowBrowserBar(IWebBrowser2 *iface, VARIANT *pvaClsid, + VARIANT *pvarShow, VARIANT *pvarSize) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p %p %p)\n", This, pvaClsid, pvarShow, pvarSize); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_ReadyState(IWebBrowser2 *iface, READYSTATE *lpReadyState) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, lpReadyState); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Offline(IWebBrowser2 *iface, VARIANT_BOOL *pbOffline) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pbOffline); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_Offline(IWebBrowser2 *iface, VARIANT_BOOL bOffline) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, bOffline); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Silent(IWebBrowser2 *iface, VARIANT_BOOL *pbSilent) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pbSilent); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_Silent(IWebBrowser2 *iface, VARIANT_BOOL bSilent) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, bSilent); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_RegisterAsBrowser(IWebBrowser2 *iface, + VARIANT_BOOL *pbRegister) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pbRegister); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_RegisterAsBrowser(IWebBrowser2 *iface, + VARIANT_BOOL bRegister) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, bRegister); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_RegisterAsDropTarget(IWebBrowser2 *iface, + VARIANT_BOOL *pbRegister) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pbRegister); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_RegisterAsDropTarget(IWebBrowser2 *iface, + VARIANT_BOOL bRegister) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, bRegister); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_TheaterMode(IWebBrowser2 *iface, VARIANT_BOOL *pbRegister) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pbRegister); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_TheaterMode(IWebBrowser2 *iface, VARIANT_BOOL bRegister) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, bRegister); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_AddressBar(IWebBrowser2 *iface, VARIANT_BOOL *Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Value); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_AddressBar(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, Value); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_get_Resizable(IWebBrowser2 *iface, VARIANT_BOOL *Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Value); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetExplorer_put_Resizable(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + InternetExplorer *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, Value); + return E_NOTIMPL; +} + +static const IWebBrowser2Vtbl InternetExplorerVtbl = +{ + InternetExplorer_QueryInterface, + InternetExplorer_AddRef, + InternetExplorer_Release, + InternetExplorer_GetTypeInfoCount, + InternetExplorer_GetTypeInfo, + InternetExplorer_GetIDsOfNames, + InternetExplorer_Invoke, + InternetExplorer_GoBack, + InternetExplorer_GoForward, + InternetExplorer_GoHome, + InternetExplorer_GoSearch, + InternetExplorer_Navigate, + InternetExplorer_Refresh, + InternetExplorer_Refresh2, + InternetExplorer_Stop, + InternetExplorer_get_Application, + InternetExplorer_get_Parent, + InternetExplorer_get_Container, + InternetExplorer_get_Document, + InternetExplorer_get_TopLevelContainer, + InternetExplorer_get_Type, + InternetExplorer_get_Left, + InternetExplorer_put_Left, + InternetExplorer_get_Top, + InternetExplorer_put_Top, + InternetExplorer_get_Width, + InternetExplorer_put_Width, + InternetExplorer_get_Height, + InternetExplorer_put_Height, + InternetExplorer_get_LocationName, + InternetExplorer_get_LocationURL, + InternetExplorer_get_Busy, + InternetExplorer_Quit, + InternetExplorer_ClientToWindow, + InternetExplorer_PutProperty, + InternetExplorer_GetProperty, + InternetExplorer_get_Name, + InternetExplorer_get_HWND, + InternetExplorer_get_FullName, + InternetExplorer_get_Path, + InternetExplorer_get_Visible, + InternetExplorer_put_Visible, + InternetExplorer_get_StatusBar, + InternetExplorer_put_StatusBar, + InternetExplorer_get_StatusText, + InternetExplorer_put_StatusText, + InternetExplorer_get_ToolBar, + InternetExplorer_put_ToolBar, + InternetExplorer_get_MenuBar, + InternetExplorer_put_MenuBar, + InternetExplorer_get_FullScreen, + InternetExplorer_put_FullScreen, + InternetExplorer_Navigate2, + InternetExplorer_QueryStatusWB, + InternetExplorer_ExecWB, + InternetExplorer_ShowBrowserBar, + InternetExplorer_get_ReadyState, + InternetExplorer_get_Offline, + InternetExplorer_put_Offline, + InternetExplorer_get_Silent, + InternetExplorer_put_Silent, + InternetExplorer_get_RegisterAsBrowser, + InternetExplorer_put_RegisterAsBrowser, + InternetExplorer_get_RegisterAsDropTarget, + InternetExplorer_put_RegisterAsDropTarget, + InternetExplorer_get_TheaterMode, + InternetExplorer_put_TheaterMode, + InternetExplorer_get_AddressBar, + InternetExplorer_put_AddressBar, + InternetExplorer_get_Resizable, + InternetExplorer_put_Resizable +}; + +static inline InternetExplorer *impl_from_IServiceProvider(IServiceProvider *iface) +{ + return CONTAINING_RECORD(iface, InternetExplorer, IServiceProvider_iface); +} + +static HRESULT WINAPI IEServiceProvider_QueryInterface(IServiceProvider *iface, + REFIID riid, LPVOID *ppv) +{ + InternetExplorer *This = impl_from_IServiceProvider(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppv); +} + +static ULONG WINAPI IEServiceProvider_AddRef(IServiceProvider *iface) +{ + InternetExplorer *This = impl_from_IServiceProvider(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI IEServiceProvider_Release(IServiceProvider *iface) +{ + InternetExplorer *This = impl_from_IServiceProvider(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI IEServiceProvider_QueryService(IServiceProvider *iface, + REFGUID guidService, REFIID riid, void **ppv) +{ + InternetExplorer *This = impl_from_IServiceProvider(iface); + + if(IsEqualGUID(&SID_SHTMLWindow, riid)) { + TRACE("(%p)->(SID_SHTMLWindow)\n", This); + return IHTMLWindow2_QueryInterface(&This->doc_host->doc_host.html_window.IHTMLWindow2_iface, riid, ppv); + } + + FIXME("(%p)->(%s, %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv); + *ppv = NULL; + return E_NOINTERFACE; +} + +static const IServiceProviderVtbl ServiceProviderVtbl = +{ + IEServiceProvider_QueryInterface, + IEServiceProvider_AddRef, + IEServiceProvider_Release, + IEServiceProvider_QueryService +}; + +void InternetExplorer_WebBrowser_Init(InternetExplorer *This) +{ + This->IWebBrowser2_iface.lpVtbl = &InternetExplorerVtbl; + This->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl; +} diff --git a/reactos/dll/win32/ieframe/ieframe.h b/reactos/dll/win32/ieframe/ieframe.h new file mode 100644 index 00000000000..b526130a810 --- /dev/null +++ b/reactos/dll/win32/ieframe/ieframe.h @@ -0,0 +1,393 @@ +/* + * Header includes for ieframe.dll + * + * Copyright 2011 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 + +#define WIN32_NO_STATUS +#define _INC_WINDOWS +#define COM_NO_WINDOWS_H + +#define COBJMACROS +#define NONAMELESSUNION + +#include +#include +#include +//#include "winuser.h" + +//#include "ole2.h" +//#include "olectl.h" +#include +#include +//#include "exdisp.h" +#include +#include +//#include "shdeprecated.h" +#include + +#include +#include + +typedef struct ConnectionPoint ConnectionPoint; +typedef struct DocHost DocHost; + +typedef struct { + IConnectionPointContainer IConnectionPointContainer_iface; + + ConnectionPoint *wbe2; + ConnectionPoint *wbe; + ConnectionPoint *pns; + + IUnknown *impl; +} ConnectionPointContainer; + +typedef struct { + IHlinkFrame IHlinkFrame_iface; + ITargetFrame2 ITargetFrame2_iface; + ITargetFramePriv2 ITargetFramePriv2_iface; + + IUnknown *outer; + DocHost *doc_host; +} HlinkFrame; + +struct _task_header_t; + +typedef void (*task_proc_t)(DocHost*, struct _task_header_t*); +typedef void (*task_destr_t)(struct _task_header_t*); + +typedef struct _task_header_t { + struct list entry; + task_proc_t proc; + task_destr_t destr; +} task_header_t; + +typedef struct { + IShellBrowser IShellBrowser_iface; + IBrowserService IBrowserService_iface; + IDocObjectService IDocObjectService_iface; + + LONG ref; + + DocHost *doc_host; +} ShellBrowser; + +typedef struct { + IHTMLWindow2 IHTMLWindow2_iface; + DocHost *doc_host; +} IEHTMLWindow; + +typedef struct { + INewWindowManager INewWindowManager_iface; + DocHost *doc_host; +} NewWindowManager; + +typedef struct { + WCHAR *url; +} travellog_entry_t; + +typedef struct _IDocHostContainerVtbl +{ + ULONG (*addref)(DocHost*); + ULONG (*release)(DocHost*); + void (WINAPI* GetDocObjRect)(DocHost*,RECT*); + HRESULT (WINAPI* SetStatusText)(DocHost*,LPCWSTR); + void (WINAPI* SetURL)(DocHost*,LPCWSTR); + HRESULT (*exec)(DocHost*,const GUID*,DWORD,DWORD,VARIANT*,VARIANT*); +} IDocHostContainerVtbl; + +struct DocHost { + IOleClientSite IOleClientSite_iface; + IOleInPlaceSiteEx IOleInPlaceSiteEx_iface; + IDocHostUIHandler2 IDocHostUIHandler2_iface; + IOleDocumentSite IOleDocumentSite_iface; + IOleControlSite IOleControlSite_iface; + IOleCommandTarget IOleCommandTarget_iface; + IDispatch IDispatch_iface; + IPropertyNotifySink IPropertyNotifySink_iface; + IServiceProvider IServiceProvider_iface; + + /* Interfaces of InPlaceFrame object */ + IOleInPlaceFrame IOleInPlaceFrame_iface; + + IWebBrowser2 *wb; + + IDispatch *client_disp; + IDocHostUIHandler *hostui; + IOleInPlaceFrame *frame; + + IUnknown *document; + IOleDocumentView *view; + IUnknown *doc_navigate; + + const IDocHostContainerVtbl *container_vtbl; + + HWND hwnd; + HWND frame_hwnd; + + struct list task_queue; + + LPOLESTR url; + + VARIANT_BOOL silent; + VARIANT_BOOL offline; + VARIANT_BOOL busy; + + READYSTATE ready_state; + READYSTATE doc_state; + DWORD prop_notif_cookie; + BOOL is_prop_notif; + + ShellBrowser *browser_service; + IShellUIHelper2 *shell_ui_helper; + + travellog_entry_t *travellog; + unsigned travellog_size; + unsigned travellog_length; + unsigned travellog_position; + + ConnectionPointContainer cps; + IEHTMLWindow html_window; + NewWindowManager nwm; +}; + +struct WebBrowser { + IWebBrowser2 IWebBrowser2_iface; + IOleObject IOleObject_iface; + IOleInPlaceObject IOleInPlaceObject_iface; + IOleControl IOleControl_iface; + IPersistStorage IPersistStorage_iface; + IPersistMemory IPersistMemory_iface; + IPersistStreamInit IPersistStreamInit_iface; + IProvideClassInfo2 IProvideClassInfo2_iface; + IViewObject2 IViewObject2_iface; + IOleInPlaceActiveObject IOleInPlaceActiveObject_iface; + IOleCommandTarget IOleCommandTarget_iface; + IServiceProvider IServiceProvider_iface; + IDataObject IDataObject_iface; + HlinkFrame hlink_frame; + + LONG ref; + + INT version; + + IOleClientSite *client; + IOleContainer *container; + IOleInPlaceSiteEx *inplace; + + /* window context */ + + HWND frame_hwnd; + IOleInPlaceUIWindow *uiwindow; + RECT pos_rect; + RECT clip_rect; + OLEINPLACEFRAMEINFO frameinfo; + SIZEL extent; + + HWND shell_embedding_hwnd; + + VARIANT_BOOL register_browser; + VARIANT_BOOL visible; + VARIANT_BOOL menu_bar; + VARIANT_BOOL address_bar; + VARIANT_BOOL status_bar; + VARIANT_BOOL tool_bar; + VARIANT_BOOL full_screen; + VARIANT_BOOL theater_mode; + + DocHost doc_host; +}; + +typedef struct { + DocHost doc_host; + + LONG ref; + + InternetExplorer *ie; +} IEDocHost; + +struct InternetExplorer { + IWebBrowser2 IWebBrowser2_iface; + IServiceProvider IServiceProvider_iface; + HlinkFrame hlink_frame; + + LONG ref; + + HWND frame_hwnd; + HWND status_hwnd; + HMENU menu; + BOOL nohome; + + struct list entry; + IEDocHost *doc_host; +}; + +void WebBrowser_OleObject_Init(WebBrowser*) DECLSPEC_HIDDEN; +void WebBrowser_ViewObject_Init(WebBrowser*) DECLSPEC_HIDDEN; +void WebBrowser_Persist_Init(WebBrowser*) DECLSPEC_HIDDEN; +void WebBrowser_ClassInfo_Init(WebBrowser*) DECLSPEC_HIDDEN; + +void WebBrowser_OleObject_Destroy(WebBrowser*) DECLSPEC_HIDDEN; + +void DocHost_Init(DocHost*,IWebBrowser2*,const IDocHostContainerVtbl*) DECLSPEC_HIDDEN; +void DocHost_Release(DocHost*) DECLSPEC_HIDDEN; +void DocHost_ClientSite_Init(DocHost*) DECLSPEC_HIDDEN; +void DocHost_ClientSite_Release(DocHost*) DECLSPEC_HIDDEN; +void DocHost_Frame_Init(DocHost*) DECLSPEC_HIDDEN; +void release_dochost_client(DocHost*) DECLSPEC_HIDDEN; + +void IEHTMLWindow_Init(DocHost*) DECLSPEC_HIDDEN; +void NewWindowManager_Init(DocHost*) DECLSPEC_HIDDEN; + +void HlinkFrame_Init(HlinkFrame*,IUnknown*,DocHost*) DECLSPEC_HIDDEN; +BOOL HlinkFrame_QI(HlinkFrame*,REFIID,void**) DECLSPEC_HIDDEN; + +HRESULT create_browser_service(DocHost*,ShellBrowser**) DECLSPEC_HIDDEN; +void detach_browser_service(ShellBrowser*) DECLSPEC_HIDDEN; +HRESULT create_shell_ui_helper(IShellUIHelper2**) DECLSPEC_HIDDEN; + +void ConnectionPointContainer_Init(ConnectionPointContainer*,IUnknown*) DECLSPEC_HIDDEN; +void ConnectionPointContainer_Destroy(ConnectionPointContainer*) DECLSPEC_HIDDEN; + +void call_sink(ConnectionPoint*,DISPID,DISPPARAMS*) DECLSPEC_HIDDEN; +HRESULT navigate_url(DocHost*,LPCWSTR,const VARIANT*,const VARIANT*,VARIANT*,VARIANT*) DECLSPEC_HIDDEN; +HRESULT go_home(DocHost*) DECLSPEC_HIDDEN; +HRESULT go_back(DocHost*) DECLSPEC_HIDDEN; +HRESULT refresh_document(DocHost*) DECLSPEC_HIDDEN; +HRESULT get_location_url(DocHost*,BSTR*) DECLSPEC_HIDDEN; +HRESULT set_dochost_url(DocHost*,const WCHAR*) DECLSPEC_HIDDEN; +void handle_navigation_error(DocHost*,HRESULT,BSTR,IHTMLWindow2*) DECLSPEC_HIDDEN; +HRESULT dochost_object_available(DocHost*,IUnknown*) DECLSPEC_HIDDEN; +void set_doc_state(DocHost*,READYSTATE) DECLSPEC_HIDDEN; +void deactivate_document(DocHost*) DECLSPEC_HIDDEN; +void create_doc_view_hwnd(DocHost*) DECLSPEC_HIDDEN; + +#define WM_DOCHOSTTASK (WM_USER+0x300) +void push_dochost_task(DocHost*,task_header_t*,task_proc_t,task_destr_t,BOOL) DECLSPEC_HIDDEN; +void abort_dochost_tasks(DocHost*,task_proc_t) DECLSPEC_HIDDEN; +LRESULT process_dochost_tasks(DocHost*) DECLSPEC_HIDDEN; + +void InternetExplorer_WebBrowser_Init(InternetExplorer*) DECLSPEC_HIDDEN; +HRESULT update_ie_statustext(InternetExplorer*, LPCWSTR) DECLSPEC_HIDDEN; +void released_obj(void) DECLSPEC_HIDDEN; + +void register_iewindow_class(void) DECLSPEC_HIDDEN; +void unregister_iewindow_class(void) DECLSPEC_HIDDEN; + +#define TID_LIST \ + XCLSID(WebBrowser) \ + XCLSID(WebBrowser_V1) \ + XIID(IWebBrowser2) + +typedef enum { +#define XIID(iface) iface ## _tid, +#define XCLSID(class) class ## _tid, +TID_LIST +#undef XIID +#undef XCLSID + LAST_tid +} tid_t; + +HRESULT get_typeinfo(tid_t,ITypeInfo**) DECLSPEC_HIDDEN; +HRESULT register_class_object(BOOL) DECLSPEC_HIDDEN; + +HRESULT WINAPI CUrlHistory_Create(IClassFactory*,IUnknown*,REFIID,void**) DECLSPEC_HIDDEN; +HRESULT WINAPI InternetExplorer_Create(IClassFactory*,IUnknown*,REFIID,void**) DECLSPEC_HIDDEN; +HRESULT WINAPI InternetShortcut_Create(IClassFactory*,IUnknown*,REFIID,void**) DECLSPEC_HIDDEN; +HRESULT WINAPI WebBrowser_Create(IClassFactory*,IUnknown*,REFIID,void**) DECLSPEC_HIDDEN; +HRESULT WINAPI WebBrowserV1_Create(IClassFactory*,IUnknown*,REFIID,void**) DECLSPEC_HIDDEN; + +const char *debugstr_variant(const VARIANT*) DECLSPEC_HIDDEN; + +extern LONG module_ref DECLSPEC_HIDDEN; +extern HINSTANCE ieframe_instance DECLSPEC_HIDDEN; + +static inline void lock_module(void) { + InterlockedIncrement(&module_ref); +} + +static inline void unlock_module(void) { + InterlockedDecrement(&module_ref); +} + +static inline void *heap_alloc(size_t len) +{ + return HeapAlloc(GetProcessHeap(), 0, len); +} + +static inline void *heap_alloc_zero(size_t len) +{ + return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); +} + +static inline void *heap_realloc(void *mem, size_t len) +{ + return HeapReAlloc(GetProcessHeap(), 0, mem, len); +} + +static inline BOOL heap_free(void *mem) +{ + return HeapFree(GetProcessHeap(), 0, mem); +} + +static inline LPWSTR heap_strdupW(LPCWSTR str) +{ + LPWSTR ret = NULL; + + if(str) { + DWORD size; + + size = (strlenW(str)+1)*sizeof(WCHAR); + ret = heap_alloc(size); + if(ret) + memcpy(ret, str, size); + } + + return ret; +} + +static inline LPWSTR co_strdupW(LPCWSTR str) +{ + WCHAR *ret = CoTaskMemAlloc((strlenW(str) + 1)*sizeof(WCHAR)); + if (ret) + lstrcpyW(ret, str); + return ret; +} + +static inline LPWSTR co_strdupAtoW(LPCSTR str) +{ + INT len; + WCHAR *ret; + len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0); + ret = CoTaskMemAlloc(len*sizeof(WCHAR)); + if (ret) + MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len); + return ret; +} + +static inline LPSTR co_strdupWtoA(LPCWSTR str) +{ + INT len; + CHAR *ret; + len = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, 0, 0); + ret = CoTaskMemAlloc(len); + if (ret) + WideCharToMultiByte(CP_ACP, 0, str, -1, ret, len, 0, 0); + return ret; +} diff --git a/reactos/dll/win32/ieframe/ieframe.rc b/reactos/dll/win32/ieframe/ieframe.rc new file mode 100644 index 00000000000..129a2d7540f --- /dev/null +++ b/reactos/dll/win32/ieframe/ieframe.rc @@ -0,0 +1,117 @@ +/* + * Copyright 2011 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 "resource.h" + +LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT + +IDR_BROWSE_MAIN_MENU MENU +{ + POPUP "&File" + { + POPUP "&New" + { + MENUITEM "&Window", ID_BROWSE_NEW_WINDOW + } + MENUITEM "&Open...", ID_BROWSE_OPEN + MENUITEM "&Save", ID_BROWSE_SAVE + MENUITEM "Save &as...", ID_BROWSE_SAVE_AS + MENUITEM SEPARATOR + MENUITEM "Print &format...", ID_BROWSE_PRINT_FORMAT + MENUITEM "Pr&int...", ID_BROWSE_PRINT + MENUITEM "Print previe&w", ID_BROWSE_PRINT_PREVIEW + MENUITEM SEPARATOR + MENUITEM "&Properties", ID_BROWSE_PROPERTIES + MENUITEM "&Close", ID_BROWSE_QUIT + } + POPUP "&View" + { + POPUP "&Toolbars" + { + MENUITEM "&Standard bar", ID_BROWSE_BAR_STD + MENUITEM "&Address bar", ID_BROWSE_BAR_ADDR + } + } + POPUP "&Favorites" + { + MENUITEM "&Add to Favorites...", ID_BROWSE_ADDFAV + MENUITEM SEPARATOR + } + POPUP "&Help" + { + MENUITEM "&About Internet Explorer", ID_BROWSE_ABOUT + } +} + +STRINGTABLE +{ + IDS_TB_BACK "Back" + IDS_TB_FORWARD "Forward" + IDS_TB_STOP "Stop" + IDS_TB_REFRESH "Refresh" + IDS_TB_HOME "#msgctxt#home page#Home" + IDS_TB_PRINT "Print..." +} + +STRINGTABLE +{ + IDS_ADDRESS "Address" +} + +STRINGTABLE +{ + IDS_FINDINGRESOURCE "Searching for %s" + IDS_BEGINDOWNLOADDATA "Start downloading %s" + IDS_ENDDOWNLOADDATA "Downloading %s" + IDS_SENDINGREQUEST "Asking for %s" +} + + +IDD_BROWSE_OPEN DIALOG 10, 10, 200, 70 +STYLE DS_MODALFRAME | WS_CAPTION +CAPTION "Open URL" +FONT 8, "MS Shell Dlg" +{ + LTEXT "Specify the URL you wish to open in Internet Explorer",-1, 35,5,160,25 + LTEXT "Open:", -1, 5, 32, 30, 15 + EDITTEXT IDC_BROWSE_OPEN_URL, 35, 30, 160, 13 + DEFPUSHBUTTON "OK", IDOK, 90, 50, 50, 14 + PUSHBUTTON "Cancel", IDCANCEL, 145, 50, 50, 14 +} + +LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL + +#define WINE_FILEDESCRIPTION_STR "Internet Browser" +#define WINE_FILENAME_STR "ieframe.dll" +#define WINE_FILEVERSION 8,00,7601,17601 +#define WINE_FILEVERSION_STR "8.00.7601.17601" +#define WINE_PRODUCTVERSION 8,00,7601,17601 +#define WINE_PRODUCTVERSION_STR "8.00.7601.17601" +#define WINE_EXTRAVALUES VALUE "OLESelfRegister","" + +#include "wine/wine_common_ver.rc" + +/* @makedep: ietoolbar.bmp */ +IDB_IETOOLBAR BITMAP ietoolbar.bmp + +/* @makedep: ieframe.rgs */ +2 WINE_REGISTRY ieframe.rgs + +3 WINE_REGISTRY ieframe_v1.rgs + +1 TYPELIB ieframe_v1.tlb diff --git a/reactos/dll/win32/ieframe/ieframe.rgs b/reactos/dll/win32/ieframe/ieframe.rgs new file mode 100644 index 00000000000..cf8f3b45ee0 --- /dev/null +++ b/reactos/dll/win32/ieframe/ieframe.rgs @@ -0,0 +1,73 @@ +HKLM +{ + NoRemove 'Software' + { + NoRemove 'Microsoft' + { + NoRemove 'Windows' + { + NoRemove 'CurrentVersion' + { + NoRemove 'URL' + { + DefaultPrefix = s 'http://' + Prefixes + { + val 'ftp' = s 'ftp://' + val 'gopher' = s 'gopher://' + val 'home' = s 'http://' + val 'mosaic' = s 'http://' + val 'www' = s 'http://' + } + } + } + } + } + } +} + +HKCR +{ + NoRemove CLSID + { + '{fbf23b40-e3f0-101b-8488-00aa003e56f8}' + { + shellex + { + MayChangeDefaultMenu {} + } + } + } + 'InternetShortcut' + { + val 'EditFlags' = s '2' + val 'IsShortcut' = s '' + val 'NeverShowExt' = s '' + DefaultIcon = s 'url.dll,0' + shell + { + open + { + command = s 'rundll32.exe ieframe.dll,OpenURL %%l' + } + } + } + ForceRemove '.url' = s 'InternetShortcut' + + ftp + { + val 'URL Protocol' = s '' + } + http + { + val 'URL Protocol' = s '' + } + https + { + val 'URL Protocol' = s '' + } + mailto + { + val 'URL Protocol' = s '' + } +} diff --git a/reactos/dll/win32/ieframe/ieframe.spec b/reactos/dll/win32/ieframe/ieframe.spec new file mode 100644 index 00000000000..60965dcb46d --- /dev/null +++ b/reactos/dll/win32/ieframe/ieframe.spec @@ -0,0 +1,9 @@ +# ordinal exports +101 stdcall -noname IEWinMain(str long) + +@ stdcall -private DllCanUnloadNow() +@ stdcall -private DllGetClassObject(ptr ptr ptr) +@ stdcall -private DllRegisterServer() +@ stdcall -private DllUnregisterServer() +@ stdcall IEGetWriteableHKCU(ptr) +@ stdcall OpenURL(long long str long) diff --git a/reactos/dll/win32/ieframe/ieframe_main.c b/reactos/dll/win32/ieframe/ieframe_main.c new file mode 100644 index 00000000000..7d8f0c52079 --- /dev/null +++ b/reactos/dll/win32/ieframe/ieframe_main.c @@ -0,0 +1,326 @@ +/* + * Copyright 2011 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 "ieframe.h" + +#include +//#include "shlguid.h" +//#include "isguids.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +LONG module_ref = 0; +HINSTANCE ieframe_instance; + +const char *debugstr_variant(const VARIANT *v) +{ + if(!v) + return "(null)"; + + switch(V_VT(v)) { + case VT_EMPTY: + return "{VT_EMPTY}"; + case VT_NULL: + return "{VT_NULL}"; + case VT_I4: + return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v)); + case VT_R8: + return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v)); + case VT_BSTR: + return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v))); + case VT_DISPATCH: + return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v)); + case VT_BOOL: + return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v)); + default: + return wine_dbg_sprintf("{vt %d}", V_VT(v)); + } +} + +static ITypeLib *typelib; +static ITypeInfo *typeinfos[LAST_tid]; + +static REFIID tid_ids[] = { +#define XIID(iface) &IID_ ## iface, +#define XCLSID(class) &CLSID_ ## class, +TID_LIST +#undef XIID +#undef XCLSID +}; + +static HRESULT load_typelib(void) +{ + HRESULT hres; + ITypeLib *tl; + + hres = LoadRegTypeLib(&LIBID_SHDocVw, 1, 1, LOCALE_SYSTEM_DEFAULT, &tl); + if(FAILED(hres)) { + ERR("LoadRegTypeLib failed: %08x\n", hres); + return hres; + } + + if(InterlockedCompareExchangePointer((void**)&typelib, tl, NULL)) + ITypeLib_Release(tl); + return hres; +} + +HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo) +{ + HRESULT hres; + + if(!typelib) + hres = load_typelib(); + if(!typelib) + return hres; + + if(!typeinfos[tid]) { + ITypeInfo *ti; + + hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti); + if(FAILED(hres)) { + ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres); + return hres; + } + + if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL)) + ITypeInfo_Release(ti); + } + + *typeinfo = typeinfos[tid]; + return S_OK; +} + +static void release_typelib(void) +{ + unsigned i; + + if(!typelib) + return; + + for(i=0; i < sizeof(typeinfos)/sizeof(*typeinfos); i++) { + if(typeinfos[i]) + ITypeInfo_Release(typeinfos[i]); + } + + ITypeLib_Release(typelib); +} + +static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv) +{ + *ppv = NULL; + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv); + *ppv = iface; + }else if(IsEqualGUID(&IID_IClassFactory, riid)) { + TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv); + *ppv = iface; + } + + if(*ppv) { + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; + } + + FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv); + return E_NOINTERFACE; +} + +static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface) +{ + TRACE("(%p)\n", iface); + return 2; +} + +static ULONG WINAPI ClassFactory_Release(IClassFactory *iface) +{ + TRACE("(%p)\n", iface); + return 1; +} + +static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock) +{ + TRACE("(%p)->(%x)\n", iface, fLock); + return S_OK; +} + +static const IClassFactoryVtbl WebBrowserFactoryVtbl = { + ClassFactory_QueryInterface, + ClassFactory_AddRef, + ClassFactory_Release, + WebBrowser_Create, + ClassFactory_LockServer +}; + +static IClassFactory WebBrowserFactory = { &WebBrowserFactoryVtbl }; + +static const IClassFactoryVtbl WebBrowserV1FactoryVtbl = { + ClassFactory_QueryInterface, + ClassFactory_AddRef, + ClassFactory_Release, + WebBrowserV1_Create, + ClassFactory_LockServer +}; + +static IClassFactory WebBrowserV1Factory = { &WebBrowserV1FactoryVtbl }; + +static const IClassFactoryVtbl InternetShortcutFactoryVtbl = { + ClassFactory_QueryInterface, + ClassFactory_AddRef, + ClassFactory_Release, + InternetShortcut_Create, + ClassFactory_LockServer +}; + +static IClassFactory InternetShortcutFactory = { &InternetShortcutFactoryVtbl }; + +static const IClassFactoryVtbl CUrlHistoryFactoryVtbl = { + ClassFactory_QueryInterface, + ClassFactory_AddRef, + ClassFactory_Release, + CUrlHistory_Create, + ClassFactory_LockServer +}; + +static IClassFactory CUrlHistoryFactory = { &CUrlHistoryFactoryVtbl }; + +/****************************************************************** + * DllMain (ieframe.@) + */ +BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) +{ + TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpv); + + switch(fdwReason) + { + case DLL_WINE_PREATTACH: + return FALSE; /* prefer native version */ + case DLL_PROCESS_ATTACH: + ieframe_instance = hInstDLL; + register_iewindow_class(); + DisableThreadLibraryCalls(ieframe_instance); + break; + case DLL_PROCESS_DETACH: + unregister_iewindow_class(); + release_typelib(); + } + + return TRUE; +} + +/*********************************************************************** + * DllGetClassObject (ieframe.@) + */ +HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) +{ + if(IsEqualGUID(&CLSID_WebBrowser, rclsid)) { + TRACE("(CLSID_WebBrowser %s %p)\n", debugstr_guid(riid), ppv); + return IClassFactory_QueryInterface(&WebBrowserFactory, riid, ppv); + } + + if(IsEqualGUID(&CLSID_WebBrowser_V1, rclsid)) { + TRACE("(CLSID_WebBrowser_V1 %s %p)\n", debugstr_guid(riid), ppv); + return IClassFactory_QueryInterface(&WebBrowserV1Factory, riid, ppv); + } + + if(IsEqualGUID(rclsid, &CLSID_InternetShortcut)) { + TRACE("(CLSID_InternetShortcut %s %p)\n", debugstr_guid(riid), ppv); + return IClassFactory_QueryInterface(&InternetShortcutFactory, riid, ppv); + } + + if(IsEqualGUID(&CLSID_CUrlHistory, rclsid)) { + TRACE("(CLSID_CUrlHistory %s %p)\n", debugstr_guid(riid), ppv); + return IClassFactory_QueryInterface(&CUrlHistoryFactory, riid, ppv); + } + + FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); + return CLASS_E_CLASSNOTAVAILABLE; +} + +static const IClassFactoryVtbl InternetExplorerFactoryVtbl = { + ClassFactory_QueryInterface, + ClassFactory_AddRef, + ClassFactory_Release, + InternetExplorer_Create, + ClassFactory_LockServer +}; + +static IClassFactory InternetExplorerFactory = { &InternetExplorerFactoryVtbl }; + +HRESULT register_class_object(BOOL do_reg) +{ + HRESULT hres; + + static DWORD cookie; + + if(do_reg) { + hres = CoRegisterClassObject(&CLSID_InternetExplorer, + (IUnknown*)&InternetExplorerFactory, CLSCTX_SERVER, + REGCLS_MULTIPLEUSE|REGCLS_SUSPENDED, &cookie); + if (FAILED(hres)) { + ERR("failed to register object %08x\n", hres); + return hres; + } + + hres = CoResumeClassObjects(); + if(SUCCEEDED(hres)) + return hres; + + ERR("failed to resume object %08x\n", hres); + } + + return CoRevokeClassObject(cookie); +} + +/*********************************************************************** + * DllCanUnloadNow (ieframe.@) + */ +HRESULT WINAPI DllCanUnloadNow(void) +{ + TRACE("()\n"); + return module_ref ? S_FALSE : S_OK; +} + +/*********************************************************************** + * DllRegisterServer (ieframe.@) + */ +HRESULT WINAPI DllRegisterServer(void) +{ + TRACE("()\n"); + return __wine_register_resources(ieframe_instance); +} + +/*********************************************************************** + * DllUnregisterServer (ieframe.@) + */ +HRESULT WINAPI DllUnregisterServer(void) +{ + TRACE("()\n"); + return __wine_unregister_resources(ieframe_instance); +} + +/*********************************************************************** + * IEGetWriteableHKCU (ieframe.@) + */ +HRESULT WINAPI IEGetWriteableHKCU(HKEY *pkey) +{ + FIXME("(%p) stub\n", pkey); + return E_NOTIMPL; +} diff --git a/reactos/dll/win32/ieframe/ieframe_v1.idl b/reactos/dll/win32/ieframe/ieframe_v1.idl new file mode 100644 index 00000000000..a7d3543e4ef --- /dev/null +++ b/reactos/dll/win32/ieframe/ieframe_v1.idl @@ -0,0 +1,43 @@ +/* + * 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 "exdisp.idl" + +[ + threading(apartment), + uuid(871c5380-42a0-1069-a2ea-08002b30309d) +] coclass Internet { } + +[ + helpstring("Microsoft Url History Service"), + threading(apartment), + uuid(3c374a40-bae4-11cf-bf7d-00aa006946ee) +] coclass CUrlHistory { interface IUrlHistoryStg2; } + +[ + helpstring("Internet Shortcut"), + threading(apartment), + progid("InternetShortcut"), + uuid(fbf23b40-e3f0-101b-8488-00aa003e56f8) +] coclass InternetShortcut +{ + interface IUniformResourceLocatorA; + interface IUniformResourceLocatorW; + interface IPersistFile; + interface IPropertySetStorage; +} diff --git a/reactos/dll/win32/ieframe/ieframe_v1.rgs b/reactos/dll/win32/ieframe/ieframe_v1.rgs new file mode 100644 index 00000000000..8e124912c56 --- /dev/null +++ b/reactos/dll/win32/ieframe/ieframe_v1.rgs @@ -0,0 +1,26 @@ +HKCR +{ + NoRemove Interface + { + } + NoRemove CLSID + { + '{871C5380-42A0-1069-A2EA-08002B30309D}' = s 'Internet' + { + InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Apartment' } + } + '{3C374A40-BAE4-11CF-BF7D-00AA006946EE}' = s 'Microsoft Url History Service' + { + InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Apartment' } + } + '{FBF23B40-E3F0-101B-8488-00AA003E56F8}' = s 'Internet Shortcut' + { + InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Apartment' } + ProgId = s 'InternetShortcut' + } + } + 'InternetShortcut' = s 'Internet Shortcut' + { + CLSID = s '{FBF23B40-E3F0-101B-8488-00AA003E56F8}' + } +} diff --git a/reactos/dll/win32/ieframe/iehtmlwnd.c b/reactos/dll/win32/ieframe/iehtmlwnd.c new file mode 100644 index 00000000000..249c1b500c7 --- /dev/null +++ b/reactos/dll/win32/ieframe/iehtmlwnd.c @@ -0,0 +1,695 @@ +/* + * Copyright 2012 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 "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static inline IEHTMLWindow *impl_from_IHTMLWindow2(IHTMLWindow2 *iface) +{ + return CONTAINING_RECORD(iface, IEHTMLWindow, IHTMLWindow2_iface); +} + +static HRESULT WINAPI IEHTMLWindow2_QueryInterface(IHTMLWindow2 *iface, REFIID riid, void **ppv) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IHTMLWindow2_iface; + }else if(IsEqualGUID(&IID_IDispatch, riid)) { + TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv); + *ppv = &This->IHTMLWindow2_iface; + }else if(IsEqualGUID(&IID_IHTMLFramesCollection2, riid)) { + TRACE("(%p)->(IID_IHTMLFramesCollection2 %p)\n", This, ppv); + *ppv = &This->IHTMLWindow2_iface; + }else if(IsEqualGUID(&IID_IHTMLWindow2, riid)) { + TRACE("(%p)->(IID_IHTMLWindow2 %p)\n", This, ppv); + *ppv = &This->IHTMLWindow2_iface; + }else { + WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); + *ppv = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI IEHTMLWindow2_AddRef(IHTMLWindow2 *iface) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + + TRACE("(%p)\n", This); + + return IOleClientSite_AddRef(&This->doc_host->IOleClientSite_iface); +} + +static ULONG WINAPI IEHTMLWindow2_Release(IHTMLWindow2 *iface) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + + TRACE("(%p)\n", This); + + return IOleClientSite_Release(&This->doc_host->IOleClientSite_iface); +} + +static HRESULT WINAPI IEHTMLWindow2_GetTypeInfoCount(IHTMLWindow2 *iface, UINT *pctinfo) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_GetTypeInfo(IHTMLWindow2 *iface, UINT iTInfo, + LCID lcid, ITypeInfo **ppTInfo) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_GetIDsOfNames(IHTMLWindow2 *iface, REFIID riid, + LPOLESTR *rgszNames, UINT cNames, + LCID lcid, DISPID *rgDispId) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_Invoke(IHTMLWindow2 *iface, DISPID dispIdMember, + REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, + VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_item(IHTMLWindow2 *iface, VARIANT *pvarIndex, VARIANT *pvarResult) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p %p)\n", This, pvarIndex, pvarResult); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_length(IHTMLWindow2 *iface, LONG *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_frames(IHTMLWindow2 *iface, IHTMLFramesCollection2 **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_defaultStatus(IHTMLWindow2 *iface, BSTR v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_defaultStatus(IHTMLWindow2 *iface, BSTR *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_status(IHTMLWindow2 *iface, BSTR v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_status(IHTMLWindow2 *iface, BSTR *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_setTimeout(IHTMLWindow2 *iface, BSTR expression, + LONG msec, VARIANT *language, LONG *timerID) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_clearTimeout(IHTMLWindow2 *iface, LONG timerID) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d)\n", This, timerID); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_alert(IHTMLWindow2 *iface, BSTR message) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(message)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_confirm(IHTMLWindow2 *iface, BSTR message, + VARIANT_BOOL *confirmed) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s %p)\n", This, debugstr_w(message), confirmed); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_prompt(IHTMLWindow2 *iface, BSTR message, + BSTR dststr, VARIANT *textdata) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(message), debugstr_w(dststr), textdata); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_Image(IHTMLWindow2 *iface, IHTMLImageElementFactory **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_location(IHTMLWindow2 *iface, IHTMLLocation **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_history(IHTMLWindow2 *iface, IOmHistory **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_close(IHTMLWindow2 *iface) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + + FIXME("(%p) semi-stub\n", This); + + if(!This->doc_host->wb) + return E_UNEXPECTED; + + return IWebBrowser2_put_Visible(This->doc_host->wb, VARIANT_FALSE); +} + +static HRESULT WINAPI IEHTMLWindow2_put_opener(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_opener(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_navigator(IHTMLWindow2 *iface, IOmNavigator **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_name(IHTMLWindow2 *iface, BSTR v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_name(IHTMLWindow2 *iface, BSTR *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_parent(IHTMLWindow2 *iface, IHTMLWindow2 **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name, + BSTR features, VARIANT_BOOL replace, IHTMLWindow2 **pomWindowResult) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s %s %s %x %p)\n", This, debugstr_w(url), debugstr_w(name), + debugstr_w(features), replace, pomWindowResult); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_self(IHTMLWindow2 *iface, IHTMLWindow2 **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_top(IHTMLWindow2 *iface, IHTMLWindow2 **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_window(IHTMLWindow2 *iface, IHTMLWindow2 **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_navigate(IHTMLWindow2 *iface, BSTR url) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(url)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onfocus(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onfocus(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onblur(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onblur(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onload(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_variant(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onload(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onbeforeunload(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onbeforeunload(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onunload(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onunload(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onhelp(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onhelp(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onerror(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onerror(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onresize(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_variant(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onresize(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_onscroll(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_onscroll(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_document(IHTMLWindow2 *iface, IHTMLDocument2 **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_event(IHTMLWindow2 *iface, IHTMLEventObj **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get__newEnum(IHTMLWindow2 *iface, IUnknown **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_showModalDialog(IHTMLWindow2 *iface, BSTR dialog, + VARIANT *varArgIn, VARIANT *varOptions, VARIANT *varArgOut) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(dialog), varArgIn, varOptions, varArgOut); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_showHelp(IHTMLWindow2 *iface, BSTR helpURL, VARIANT helpArg, + BSTR features) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s v(%d) %s)\n", This, debugstr_w(helpURL), V_VT(&helpArg), debugstr_w(features)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_screen(IHTMLWindow2 *iface, IHTMLScreen **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_Option(IHTMLWindow2 *iface, IHTMLOptionElementFactory **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_focus(IHTMLWindow2 *iface) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_closed(IHTMLWindow2 *iface, VARIANT_BOOL *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_blur(IHTMLWindow2 *iface) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_scroll(IHTMLWindow2 *iface, LONG x, LONG y) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d %d)\n", This, x, y); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_clientInformation(IHTMLWindow2 *iface, IOmNavigator **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_setInterval(IHTMLWindow2 *iface, BSTR expression, + LONG msec, VARIANT *language, LONG *timerID) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_clearInterval(IHTMLWindow2 *iface, LONG timerID) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d)\n", This, timerID); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_put_offscreenBuffering(IHTMLWindow2 *iface, VARIANT v) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(v(%d))\n", This, V_VT(&v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_offscreenBuffering(IHTMLWindow2 *iface, VARIANT *p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_execScript(IHTMLWindow2 *iface, BSTR scode, BSTR language, + VARIANT *pvarRet) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(scode), debugstr_w(language), pvarRet); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_toString(IHTMLWindow2 *iface, BSTR *String) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, String); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_scrollBy(IHTMLWindow2 *iface, LONG x, LONG y) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d %d)\n", This, x, y); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_scrollTo(IHTMLWindow2 *iface, LONG x, LONG y) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d %d)\n", This, x, y); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_moveTo(IHTMLWindow2 *iface, LONG x, LONG y) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d %d)\n", This, x, y); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_moveBy(IHTMLWindow2 *iface, LONG x, LONG y) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d %d)\n", This, x, y); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_resizeTo(IHTMLWindow2 *iface, LONG x, LONG y) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d %d)\n", This, x, y); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_resizeBy(IHTMLWindow2 *iface, LONG x, LONG y) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%d %d)\n", This, x, y); + return E_NOTIMPL; +} + +static HRESULT WINAPI IEHTMLWindow2_get_external(IHTMLWindow2 *iface, IDispatch **p) +{ + IEHTMLWindow *This = impl_from_IHTMLWindow2(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static const IHTMLWindow2Vtbl IEHTMLWindow2Vtbl = { + IEHTMLWindow2_QueryInterface, + IEHTMLWindow2_AddRef, + IEHTMLWindow2_Release, + IEHTMLWindow2_GetTypeInfoCount, + IEHTMLWindow2_GetTypeInfo, + IEHTMLWindow2_GetIDsOfNames, + IEHTMLWindow2_Invoke, + IEHTMLWindow2_item, + IEHTMLWindow2_get_length, + IEHTMLWindow2_get_frames, + IEHTMLWindow2_put_defaultStatus, + IEHTMLWindow2_get_defaultStatus, + IEHTMLWindow2_put_status, + IEHTMLWindow2_get_status, + IEHTMLWindow2_setTimeout, + IEHTMLWindow2_clearTimeout, + IEHTMLWindow2_alert, + IEHTMLWindow2_confirm, + IEHTMLWindow2_prompt, + IEHTMLWindow2_get_Image, + IEHTMLWindow2_get_location, + IEHTMLWindow2_get_history, + IEHTMLWindow2_close, + IEHTMLWindow2_put_opener, + IEHTMLWindow2_get_opener, + IEHTMLWindow2_get_navigator, + IEHTMLWindow2_put_name, + IEHTMLWindow2_get_name, + IEHTMLWindow2_get_parent, + IEHTMLWindow2_open, + IEHTMLWindow2_get_self, + IEHTMLWindow2_get_top, + IEHTMLWindow2_get_window, + IEHTMLWindow2_navigate, + IEHTMLWindow2_put_onfocus, + IEHTMLWindow2_get_onfocus, + IEHTMLWindow2_put_onblur, + IEHTMLWindow2_get_onblur, + IEHTMLWindow2_put_onload, + IEHTMLWindow2_get_onload, + IEHTMLWindow2_put_onbeforeunload, + IEHTMLWindow2_get_onbeforeunload, + IEHTMLWindow2_put_onunload, + IEHTMLWindow2_get_onunload, + IEHTMLWindow2_put_onhelp, + IEHTMLWindow2_get_onhelp, + IEHTMLWindow2_put_onerror, + IEHTMLWindow2_get_onerror, + IEHTMLWindow2_put_onresize, + IEHTMLWindow2_get_onresize, + IEHTMLWindow2_put_onscroll, + IEHTMLWindow2_get_onscroll, + IEHTMLWindow2_get_document, + IEHTMLWindow2_get_event, + IEHTMLWindow2_get__newEnum, + IEHTMLWindow2_showModalDialog, + IEHTMLWindow2_showHelp, + IEHTMLWindow2_get_screen, + IEHTMLWindow2_get_Option, + IEHTMLWindow2_focus, + IEHTMLWindow2_get_closed, + IEHTMLWindow2_blur, + IEHTMLWindow2_scroll, + IEHTMLWindow2_get_clientInformation, + IEHTMLWindow2_setInterval, + IEHTMLWindow2_clearInterval, + IEHTMLWindow2_put_offscreenBuffering, + IEHTMLWindow2_get_offscreenBuffering, + IEHTMLWindow2_execScript, + IEHTMLWindow2_toString, + IEHTMLWindow2_scrollBy, + IEHTMLWindow2_scrollTo, + IEHTMLWindow2_moveTo, + IEHTMLWindow2_moveBy, + IEHTMLWindow2_resizeTo, + IEHTMLWindow2_resizeBy, + IEHTMLWindow2_get_external +}; + +void IEHTMLWindow_Init(DocHost *doc_host) +{ + doc_host->html_window.IHTMLWindow2_iface.lpVtbl = &IEHTMLWindow2Vtbl; + doc_host->html_window.doc_host = doc_host; +} diff --git a/reactos/dll/win32/ieframe/ietoolbar.bmp b/reactos/dll/win32/ieframe/ietoolbar.bmp new file mode 100644 index 00000000000..cb7fd0ec8a5 Binary files /dev/null and b/reactos/dll/win32/ieframe/ietoolbar.bmp differ diff --git a/reactos/dll/win32/ieframe/iexplore.c b/reactos/dll/win32/ieframe/iexplore.c new file mode 100644 index 00000000000..ec7e278b104 --- /dev/null +++ b/reactos/dll/win32/ieframe/iexplore.c @@ -0,0 +1,1094 @@ +/* + * ieframe - Internet Explorer main frame window + * + * Copyright 2006 Mike McCormack (for CodeWeavers) + * 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 + */ + +#define COBJMACROS + +//#include + +#include "ieframe.h" +#include "resource.h" + +//#include "winuser.h" +//#include "wingdi.h" +//#include "winnls.h" +//#include "ole2.h" +//#include "exdisp.h" +//#include "oleidl.h" + +#include +#include +#include +#include +#include +#include + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +#define IDI_APPICON 1 + +#define WM_UPDATEADDRBAR (WM_APP+1) + +static const WCHAR szIEWinFrame[] = { 'I','E','F','r','a','m','e',0 }; + +/* Windows uses "Microsoft Internet Explorer" */ +static const WCHAR wszWineInternetExplorer[] = + {'W','i','n','e',' ','I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r',0}; + +static LONG obj_cnt; +static DWORD dde_inst; +static HSZ ddestr_iexplore, ddestr_openurl; +static struct list ie_list = LIST_INIT(ie_list); + +HRESULT update_ie_statustext(InternetExplorer* This, LPCWSTR text) +{ + if(!SendMessageW(This->status_hwnd, SB_SETTEXTW, MAKEWORD(SB_SIMPLEID, 0), (LPARAM)text)) + return E_FAIL; + + return S_OK; +} + +static void adjust_ie_docobj_rect(HWND frame, RECT* rc) +{ + HWND hwndRebar = GetDlgItem(frame, IDC_BROWSE_REBAR); + HWND hwndStatus = GetDlgItem(frame, IDC_BROWSE_STATUSBAR); + INT barHeight = SendMessageW(hwndRebar, RB_GETBARHEIGHT, 0, 0); + + rc->top += barHeight; + rc->bottom -= barHeight; + + if(IsWindowVisible(hwndStatus)) + { + RECT statusrc; + + GetClientRect(hwndStatus, &statusrc); + rc->bottom -= statusrc.bottom - statusrc.top; + } +} + +static HMENU get_tb_menu(HMENU menu) +{ + HMENU menu_view = GetSubMenu(menu, 1); + + return GetSubMenu(menu_view, 0); +} + +static HMENU get_fav_menu(HMENU menu) +{ + return GetSubMenu(menu, 2); +} + +static LPWSTR get_fav_url_from_id(HMENU menu, UINT id) +{ + MENUITEMINFOW item; + + item.cbSize = sizeof(item); + item.fMask = MIIM_DATA; + + if(!GetMenuItemInfoW(menu, id, FALSE, &item)) + return NULL; + + return (LPWSTR)item.dwItemData; +} + +static void free_fav_menu_data(HMENU menu) +{ + LPWSTR url; + int i; + + for(i = 0; (url = get_fav_url_from_id(menu, ID_BROWSE_GOTOFAV_FIRST + i)); i++) + heap_free( url ); +} + +static int get_menu_item_count(HMENU menu) +{ + MENUITEMINFOW item; + int count = 0; + int i; + + item.cbSize = sizeof(item); + item.fMask = MIIM_DATA | MIIM_SUBMENU; + + for(i = 0; GetMenuItemInfoW(menu, i, TRUE, &item); i++) + { + if(item.hSubMenu) + count += get_menu_item_count(item.hSubMenu); + else + count++; + } + + return count; +} + +static void add_fav_to_menu(HMENU favmenu, HMENU menu, LPWSTR title, LPCWSTR url) +{ + MENUITEMINFOW item; + /* Subtract the number of standard elements in the Favorites menu */ + int favcount = get_menu_item_count(favmenu) - 2; + LPWSTR urlbuf; + + if(favcount > (ID_BROWSE_GOTOFAV_MAX - ID_BROWSE_GOTOFAV_FIRST)) + { + FIXME("Add support for more than %d Favorites\n", favcount); + return; + } + + urlbuf = heap_alloc((lstrlenW(url) + 1) * sizeof(WCHAR)); + + if(!urlbuf) + return; + + lstrcpyW(urlbuf, url); + + item.cbSize = sizeof(item); + item.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_DATA | MIIM_ID; + item.fType = MFT_STRING; + item.dwTypeData = title; + item.wID = ID_BROWSE_GOTOFAV_FIRST + favcount; + item.dwItemData = (ULONG_PTR)urlbuf; + InsertMenuItemW(menu, -1, TRUE, &item); +} + +static void add_favs_to_menu(HMENU favmenu, HMENU menu, LPCWSTR dir) +{ + WCHAR path[MAX_PATH*2]; + const WCHAR search[] = {'*',0}; + WCHAR* filename; + HANDLE findhandle; + WIN32_FIND_DATAW finddata; + IUniformResourceLocatorW* urlobj; + IPersistFile* urlfile = NULL; + HRESULT res; + + lstrcpyW(path, dir); + PathAppendW(path, search); + + findhandle = FindFirstFileW(path, &finddata); + + if(findhandle == INVALID_HANDLE_VALUE) + return; + + res = CoCreateInstance(&CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER, &IID_IUniformResourceLocatorW, (PVOID*)&urlobj); + + if(SUCCEEDED(res)) + res = IUnknown_QueryInterface((IUnknown*)urlobj, &IID_IPersistFile, (PVOID*)&urlfile); + + if(SUCCEEDED(res)) + { + filename = path + lstrlenW(path) - lstrlenW(search); + + do + { + lstrcpyW(filename, finddata.cFileName); + + if(finddata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + { + MENUITEMINFOW item; + const WCHAR ignore1[] = {'.','.',0}; + const WCHAR ignore2[] = {'.',0}; + + if(!lstrcmpW(filename, ignore1) || !lstrcmpW(filename, ignore2)) + continue; + + item.cbSize = sizeof(item); + item.fMask = MIIM_STRING | MIIM_SUBMENU; + item.dwTypeData = filename; + item.hSubMenu = CreatePopupMenu(); + InsertMenuItemW(menu, -1, TRUE, &item); + add_favs_to_menu(favmenu, item.hSubMenu, path); + } else + { + WCHAR* fileext; + WCHAR* url = NULL; + const WCHAR urlext[] = {'.','u','r','l',0}; + + if(lstrcmpiW(PathFindExtensionW(filename), urlext)) + continue; + + if(FAILED(IPersistFile_Load(urlfile, path, 0))) + continue; + + urlobj->lpVtbl->GetURL(urlobj, &url); + + if(!url) + continue; + + fileext = filename + lstrlenW(filename) - lstrlenW(urlext); + *fileext = 0; + add_fav_to_menu(favmenu, menu, filename, url); + } + } while(FindNextFileW(findhandle, &finddata)); + } + + if(urlfile) + IPersistFile_Release(urlfile); + + if(urlobj) + IUnknown_Release((IUnknown*)urlobj); + + FindClose(findhandle); +} + +static void add_tbs_to_menu(HMENU menu) +{ + HUSKEY toolbar_handle; + WCHAR toolbar_key[] = {'S','o','f','t','w','a','r','e','\\', + 'M','i','c','r','o','s','o','f','t','\\', + 'I','n','t','e','r','n','e','t',' ', + 'E','x','p','l','o','r','e','r','\\', + 'T','o','o','l','b','a','r',0}; + + if(SHRegOpenUSKeyW(toolbar_key, KEY_READ, NULL, &toolbar_handle, TRUE) == ERROR_SUCCESS) + { + HUSKEY classes_handle; + WCHAR classes_key[] = {'S','o','f','t','w','a','r','e','\\', + 'C','l','a','s','s','e','s','\\','C','L','S','I','D',0}; + WCHAR guid[39]; + DWORD value_len = sizeof(guid)/sizeof(guid[0]); + int i; + + if(SHRegOpenUSKeyW(classes_key, KEY_READ, NULL, &classes_handle, TRUE) != ERROR_SUCCESS) + { + SHRegCloseUSKey(toolbar_handle); + ERR("Failed to open key %s\n", debugstr_w(classes_key)); + return; + } + + for(i = 0; SHRegEnumUSValueW(toolbar_handle, i, guid, &value_len, NULL, NULL, NULL, SHREGENUM_HKLM) == ERROR_SUCCESS; i++) + { + WCHAR tb_name[100]; + DWORD tb_name_len = sizeof(tb_name)/sizeof(tb_name[0]); + HUSKEY tb_class_handle; + MENUITEMINFOW item; + LSTATUS ret; + value_len = sizeof(guid)/sizeof(guid[0]); + + if(lstrlenW(guid) != 38) + { + TRACE("Found invalid IE toolbar entry: %s\n", debugstr_w(guid)); + continue; + } + + if(SHRegOpenUSKeyW(guid, KEY_READ, classes_handle, &tb_class_handle, TRUE) != ERROR_SUCCESS) + { + ERR("Failed to get class info for %s\n", debugstr_w(guid)); + continue; + } + + ret = SHRegQueryUSValueW(tb_class_handle, NULL, NULL, tb_name, &tb_name_len, TRUE, NULL, 0); + + SHRegCloseUSKey(tb_class_handle); + + if(ret != ERROR_SUCCESS) + { + ERR("Failed to get toolbar name for %s\n", debugstr_w(guid)); + continue; + } + + item.cbSize = sizeof(item); + item.fMask = MIIM_STRING; + item.dwTypeData = tb_name; + InsertMenuItemW(menu, GetMenuItemCount(menu), TRUE, &item); + } + + SHRegCloseUSKey(classes_handle); + SHRegCloseUSKey(toolbar_handle); + } +} + +static HMENU create_ie_menu(void) +{ + HMENU menu = LoadMenuW(ieframe_instance, MAKEINTRESOURCEW(IDR_BROWSE_MAIN_MENU)); + HMENU favmenu = get_fav_menu(menu); + WCHAR path[MAX_PATH]; + + add_tbs_to_menu(get_tb_menu(menu)); + + if(SHGetFolderPathW(NULL, CSIDL_COMMON_FAVORITES, NULL, SHGFP_TYPE_CURRENT, path) == S_OK) + add_favs_to_menu(favmenu, favmenu, path); + + if(SHGetFolderPathW(NULL, CSIDL_FAVORITES, NULL, SHGFP_TYPE_CURRENT, path) == S_OK) + add_favs_to_menu(favmenu, favmenu, path); + + return menu; +} + +static void ie_navigate(InternetExplorer* This, LPCWSTR url) +{ + VARIANT variant; + + V_VT(&variant) = VT_BSTR; + V_BSTR(&variant) = SysAllocString(url); + + IWebBrowser2_Navigate2(&This->IWebBrowser2_iface, &variant, NULL, NULL, NULL, NULL); + + SysFreeString(V_BSTR(&variant)); +} + +static INT_PTR CALLBACK ie_dialog_open_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) +{ + static InternetExplorer* This; + + switch(msg) + { + case WM_INITDIALOG: + This = (InternetExplorer*)lparam; + EnableWindow(GetDlgItem(hwnd, IDOK), FALSE); + return TRUE; + + case WM_COMMAND: + switch(LOWORD(wparam)) + { + case IDC_BROWSE_OPEN_URL: + { + HWND hwndurl = GetDlgItem(hwnd, IDC_BROWSE_OPEN_URL); + int len = GetWindowTextLengthW(hwndurl); + + EnableWindow(GetDlgItem(hwnd, IDOK), len != 0); + break; + } + case IDOK: + { + HWND hwndurl = GetDlgItem(hwnd, IDC_BROWSE_OPEN_URL); + int len = GetWindowTextLengthW(hwndurl); + + if(len) + { + VARIANT url; + + V_VT(&url) = VT_BSTR; + V_BSTR(&url) = SysAllocStringLen(NULL, len); + + GetWindowTextW(hwndurl, V_BSTR(&url), len + 1); + IWebBrowser2_Navigate2(&This->IWebBrowser2_iface, &url, NULL, NULL, NULL, NULL); + + SysFreeString(V_BSTR(&url)); + } + } + /* fall through */ + case IDCANCEL: + EndDialog(hwnd, wparam); + return TRUE; + } + } + return FALSE; +} + +static void ie_dialog_about(HWND hwnd) +{ + HICON icon = LoadImageW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDI_APPICON), IMAGE_ICON, 48, 48, LR_SHARED); + + ShellAboutW(hwnd, wszWineInternetExplorer, NULL, icon); + + DestroyIcon(icon); +} + +static void add_tb_separator(HWND hwnd) +{ + TBBUTTON btn; + + ZeroMemory(&btn, sizeof(btn)); + + btn.iBitmap = 3; + btn.fsStyle = BTNS_SEP; + SendMessageW(hwnd, TB_ADDBUTTONSW, 1, (LPARAM)&btn); +} + +static void add_tb_button(HWND hwnd, int bmp, int cmd, int strId) +{ + TBBUTTON btn; + WCHAR buf[30]; + + LoadStringW(ieframe_instance, strId, buf, sizeof(buf)/sizeof(buf[0])); + + btn.iBitmap = bmp; + btn.idCommand = cmd; + btn.fsState = TBSTATE_ENABLED; + btn.fsStyle = BTNS_SHOWTEXT; + btn.dwData = 0; + btn.iString = (INT_PTR)buf; + + SendMessageW(hwnd, TB_ADDBUTTONSW, 1, (LPARAM)&btn); +} + +static void create_rebar(HWND hwnd) +{ + HWND hwndRebar; + HWND hwndAddress; + HWND hwndToolbar; + REBARINFO rebarinf; + REBARBANDINFOW bandinf; + WCHAR addr[40]; + HIMAGELIST imagelist; + SIZE toolbar_size; + + LoadStringW(ieframe_instance, IDS_ADDRESS, addr, sizeof(addr)/sizeof(addr[0])); + + hwndRebar = CreateWindowExW(WS_EX_TOOLWINDOW, REBARCLASSNAMEW, NULL, + WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|RBS_VARHEIGHT|CCS_TOP|CCS_NODIVIDER, 0, 0, 0, 0, + hwnd, (HMENU)IDC_BROWSE_REBAR, ieframe_instance, NULL); + + rebarinf.cbSize = sizeof(rebarinf); + rebarinf.fMask = 0; + rebarinf.himl = NULL; + + SendMessageW(hwndRebar, RB_SETBARINFO, 0, (LPARAM)&rebarinf); + + hwndToolbar = CreateWindowExW(TBSTYLE_EX_MIXEDBUTTONS, TOOLBARCLASSNAMEW, NULL, TBSTYLE_FLAT | WS_CHILD | WS_VISIBLE | CCS_NORESIZE, + 0, 0, 0, 0, hwndRebar, (HMENU)IDC_BROWSE_TOOLBAR, ieframe_instance, NULL); + + imagelist = ImageList_LoadImageW(ieframe_instance, MAKEINTRESOURCEW(IDB_IETOOLBAR), 32, 0, CLR_NONE, IMAGE_BITMAP, LR_CREATEDIBSECTION); + + SendMessageW(hwndToolbar, TB_SETIMAGELIST, 0, (LPARAM)imagelist); + SendMessageW(hwndToolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0); + add_tb_button(hwndToolbar, 0, ID_BROWSE_BACK, IDS_TB_BACK); + add_tb_button(hwndToolbar, 1, ID_BROWSE_FORWARD, IDS_TB_FORWARD); + add_tb_button(hwndToolbar, 2, ID_BROWSE_STOP, IDS_TB_STOP); + add_tb_button(hwndToolbar, 3, ID_BROWSE_REFRESH, IDS_TB_REFRESH); + add_tb_button(hwndToolbar, 4, ID_BROWSE_HOME, IDS_TB_HOME); + add_tb_separator(hwndToolbar); + add_tb_button(hwndToolbar, 5, ID_BROWSE_PRINT, IDS_TB_PRINT); + SendMessageW(hwndToolbar, TB_SETBUTTONSIZE, 0, MAKELPARAM(55,50)); + SendMessageW(hwndToolbar, TB_GETMAXSIZE, 0, (LPARAM)&toolbar_size); + + bandinf.cbSize = sizeof(bandinf); + bandinf.fMask = RBBIM_STYLE | RBBIM_CHILD | RBBIM_CHILDSIZE; + bandinf.fStyle = RBBS_CHILDEDGE; + bandinf.cxMinChild = toolbar_size.cx; + bandinf.cyMinChild = toolbar_size.cy+2; + bandinf.hwndChild = hwndToolbar; + + SendMessageW(hwndRebar, RB_INSERTBANDW, -1, (LPARAM)&bandinf); + + hwndAddress = CreateWindowExW(0, WC_COMBOBOXEXW, NULL, WS_BORDER|WS_CHILD|WS_VISIBLE|CBS_DROPDOWN, + 0, 0, 100,20,hwndRebar, (HMENU)IDC_BROWSE_ADDRESSBAR, ieframe_instance, NULL); + + bandinf.fMask |= RBBIM_TEXT; + bandinf.fStyle = RBBS_CHILDEDGE | RBBS_BREAK; + bandinf.lpText = addr; + bandinf.cxMinChild = 100; + bandinf.cyMinChild = 20; + bandinf.hwndChild = hwndAddress; + + SendMessageW(hwndRebar, RB_INSERTBANDW, -1, (LPARAM)&bandinf); +} + +static LRESULT iewnd_OnCreate(HWND hwnd, LPCREATESTRUCTW lpcs) +{ + InternetExplorer* This = (InternetExplorer*)lpcs->lpCreateParams; + SetWindowLongPtrW(hwnd, 0, (LONG_PTR) lpcs->lpCreateParams); + + This->menu = create_ie_menu(); + + This->status_hwnd = CreateStatusWindowW(WS_VISIBLE|WS_CHILD|SBT_NOBORDERS|CCS_NODIVIDER, + NULL, hwnd, IDC_BROWSE_STATUSBAR); + SendMessageW(This->status_hwnd, SB_SIMPLE, TRUE, 0); + + create_rebar(hwnd); + + return 0; +} + +static LRESULT iewnd_OnSize(InternetExplorer *This, INT width, INT height) +{ + HWND hwndRebar = GetDlgItem(This->frame_hwnd, IDC_BROWSE_REBAR); + INT barHeight = SendMessageW(hwndRebar, RB_GETBARHEIGHT, 0, 0); + RECT docarea = {0, 0, width, height}; + + SendMessageW(This->status_hwnd, WM_SIZE, 0, 0); + + adjust_ie_docobj_rect(This->frame_hwnd, &docarea); + + if(This->doc_host->doc_host.hwnd) + SetWindowPos(This->doc_host->doc_host.hwnd, NULL, docarea.left, docarea.top, docarea.right, docarea.bottom, + SWP_NOZORDER | SWP_NOACTIVATE); + + SetWindowPos(hwndRebar, NULL, 0, 0, width, barHeight, SWP_NOZORDER | SWP_NOACTIVATE); + + return 0; +} + +static LRESULT iewnd_OnNotify(InternetExplorer *This, WPARAM wparam, LPARAM lparam) +{ + NMHDR* hdr = (NMHDR*)lparam; + + if(hdr->idFrom == IDC_BROWSE_ADDRESSBAR && hdr->code == CBEN_ENDEDITW) + { + NMCBEENDEDITW* info = (NMCBEENDEDITW*)lparam; + + if(info->fChanged && info->iWhy == CBENF_RETURN) + { + VARIANT vt; + + V_VT(&vt) = VT_BSTR; + V_BSTR(&vt) = SysAllocString(info->szText); + + IWebBrowser2_Navigate2(&This->IWebBrowser2_iface, &vt, NULL, NULL, NULL, NULL); + + SysFreeString(V_BSTR(&vt)); + + return 0; + } + } + + if(hdr->idFrom == IDC_BROWSE_REBAR && hdr->code == RBN_HEIGHTCHANGE) + { + RECT docarea; + + GetClientRect(This->frame_hwnd, &docarea); + adjust_ie_docobj_rect(This->frame_hwnd, &docarea); + + if(This->doc_host->doc_host.hwnd) + SetWindowPos(This->doc_host->doc_host.hwnd, NULL, docarea.left, docarea.top, docarea.right, docarea.bottom, + SWP_NOZORDER | SWP_NOACTIVATE); + } + + return 0; +} + +static LRESULT iewnd_OnDestroy(InternetExplorer *This) +{ + HWND hwndRebar = GetDlgItem(This->frame_hwnd, IDC_BROWSE_REBAR); + HWND hwndToolbar = GetDlgItem(hwndRebar, IDC_BROWSE_TOOLBAR); + HIMAGELIST list = (HIMAGELIST)SendMessageW(hwndToolbar, TB_GETIMAGELIST, 0, 0); + + TRACE("%p\n", This); + + free_fav_menu_data(get_fav_menu(This->menu)); + ImageList_Destroy(list); + This->frame_hwnd = NULL; + + return 0; +} + +static LRESULT iewnd_OnCommand(InternetExplorer *This, HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) +{ + switch(LOWORD(wparam)) + { + case ID_BROWSE_OPEN: + DialogBoxParamW(ieframe_instance, MAKEINTRESOURCEW(IDD_BROWSE_OPEN), hwnd, ie_dialog_open_proc, (LPARAM)This); + break; + + case ID_BROWSE_PRINT: + if(This->doc_host->doc_host.document) + { + IOleCommandTarget* target; + + if(FAILED(IUnknown_QueryInterface(This->doc_host->doc_host.document, &IID_IOleCommandTarget, (LPVOID*)&target))) + break; + + IOleCommandTarget_Exec(target, &CGID_MSHTML, IDM_PRINT, OLECMDEXECOPT_DODEFAULT, NULL, NULL); + + IOleCommandTarget_Release(target); + } + break; + + case ID_BROWSE_HOME: + IWebBrowser2_GoHome(&This->IWebBrowser2_iface); + break; + + case ID_BROWSE_BACK: + IWebBrowser2_GoBack(&This->IWebBrowser2_iface); + break; + + case ID_BROWSE_FORWARD: + IWebBrowser2_GoForward(&This->IWebBrowser2_iface); + break; + + case ID_BROWSE_STOP: + IWebBrowser2_Stop(&This->IWebBrowser2_iface); + break; + + case ID_BROWSE_REFRESH: + IWebBrowser2_Refresh(&This->IWebBrowser2_iface); + break; + + case ID_BROWSE_ABOUT: + ie_dialog_about(hwnd); + break; + + case ID_BROWSE_QUIT: + ShowWindow(hwnd, SW_HIDE); + break; + + default: + if(LOWORD(wparam) >= ID_BROWSE_GOTOFAV_FIRST && LOWORD(wparam) <= ID_BROWSE_GOTOFAV_MAX) + { + LPCWSTR url = get_fav_url_from_id(get_fav_menu(This->menu), LOWORD(wparam)); + + if(url) + ie_navigate(This, url); + } + return DefWindowProcW(hwnd, msg, wparam, lparam); + } + return 0; +} + +static LRESULT update_addrbar(InternetExplorer *This, LPARAM lparam) +{ + HWND hwndRebar = GetDlgItem(This->frame_hwnd, IDC_BROWSE_REBAR); + HWND hwndAddress = GetDlgItem(hwndRebar, IDC_BROWSE_ADDRESSBAR); + HWND hwndEdit = (HWND)SendMessageW(hwndAddress, CBEM_GETEDITCONTROL, 0, 0); + LPCWSTR url = (LPCWSTR)lparam; + + SendMessageW(hwndEdit, WM_SETTEXT, 0, (LPARAM)url); + + return 0; +} + +static LRESULT WINAPI ie_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) +{ + InternetExplorer *This = (InternetExplorer*) GetWindowLongPtrW(hwnd, 0); + + switch (msg) + { + case WM_CREATE: + return iewnd_OnCreate(hwnd, (LPCREATESTRUCTW)lparam); + case WM_CLOSE: + TRACE("WM_CLOSE\n"); + ShowWindow(hwnd, SW_HIDE); + return 0; + case WM_SHOWWINDOW: + TRACE("WM_SHOWWINDOW %lx\n", wparam); + if(wparam) + IWebBrowser2_AddRef(&This->IWebBrowser2_iface); + else + IWebBrowser2_Release(&This->IWebBrowser2_iface); + break; + case WM_DESTROY: + return iewnd_OnDestroy(This); + case WM_SIZE: + return iewnd_OnSize(This, LOWORD(lparam), HIWORD(lparam)); + case WM_COMMAND: + return iewnd_OnCommand(This, hwnd, msg, wparam, lparam); + case WM_NOTIFY: + return iewnd_OnNotify(This, wparam, lparam); + case WM_DOCHOSTTASK: + return process_dochost_tasks(&This->doc_host->doc_host); + case WM_UPDATEADDRBAR: + return update_addrbar(This, lparam); + } + return DefWindowProcW(hwnd, msg, wparam, lparam); +} + +void register_iewindow_class(void) +{ + WNDCLASSEXW wc; + + memset(&wc, 0, sizeof wc); + wc.cbSize = sizeof(wc); + wc.style = 0; + wc.lpfnWndProc = ie_window_proc; + wc.cbClsExtra = 0; + wc.cbWndExtra = sizeof(InternetExplorer*); + wc.hInstance = ieframe_instance; + wc.hIcon = LoadIconW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDI_APPICON)); + wc.hIconSm = LoadImageW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDI_APPICON), IMAGE_ICON, + GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED); + wc.hCursor = LoadCursorW(0, MAKEINTRESOURCEW(IDC_ARROW)); + wc.hbrBackground = 0; + wc.lpszClassName = szIEWinFrame; + wc.lpszMenuName = NULL; + + RegisterClassExW(&wc); +} + +void unregister_iewindow_class(void) +{ + UnregisterClassW(szIEWinFrame, ieframe_instance); +} + +static void create_frame_hwnd(InternetExplorer *This) +{ + This->frame_hwnd = CreateWindowExW( + WS_EX_WINDOWEDGE, + szIEWinFrame, wszWineInternetExplorer, + WS_CLIPCHILDREN | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME + | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, + CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, + NULL, NULL /* FIXME */, ieframe_instance, This); + + This->doc_host->doc_host.frame_hwnd = This->frame_hwnd; + create_doc_view_hwnd(&This->doc_host->doc_host); +} + +static inline IEDocHost *impl_from_DocHost(DocHost *iface) +{ + return CONTAINING_RECORD(iface, IEDocHost, doc_host); +} + +static ULONG IEDocHost_addref(DocHost *iface) +{ + IEDocHost *This = impl_from_DocHost(iface); + LONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + return ref; +} + +static ULONG IEDocHost_release(DocHost *iface) +{ + IEDocHost *This = impl_from_DocHost(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) { + if(This->ie) + ERR("This->ie is not NULL\n"); + heap_free(This); + } + + return ref; +} + +static void WINAPI DocHostContainer_GetDocObjRect(DocHost* This, RECT* rc) +{ + GetClientRect(This->frame_hwnd, rc); + adjust_ie_docobj_rect(This->frame_hwnd, rc); +} + +static HRESULT WINAPI DocHostContainer_SetStatusText(DocHost *iface, LPCWSTR text) +{ + IEDocHost *This = impl_from_DocHost(iface); + return update_ie_statustext(This->ie, text); +} + +static void WINAPI DocHostContainer_SetURL(DocHost* iface, LPCWSTR url) +{ + IEDocHost *This = impl_from_DocHost(iface); + + if(!This->ie) + return; + + This->ie->nohome = FALSE; + SendMessageW(This->ie->frame_hwnd, WM_UPDATEADDRBAR, 0, (LPARAM)url); +} + +static HRESULT DocHostContainer_exec(DocHost* This, const GUID *cmd_group, DWORD cmdid, DWORD execopt, VARIANT *in, + VARIANT *out) +{ + return E_NOTIMPL; +} + +static const IDocHostContainerVtbl DocHostContainerVtbl = { + IEDocHost_addref, + IEDocHost_release, + DocHostContainer_GetDocObjRect, + DocHostContainer_SetStatusText, + DocHostContainer_SetURL, + DocHostContainer_exec +}; + +static HRESULT create_ie(InternetExplorer **ret_obj) +{ + InternetExplorer *ret; + + ret = heap_alloc_zero(sizeof(InternetExplorer)); + if(!ret) + return E_OUTOFMEMORY; + + ret->doc_host = heap_alloc_zero(sizeof(IEDocHost)); + if(!ret->doc_host) { + heap_free(ret); + return E_OUTOFMEMORY; + } + + ret->ref = 1; + ret->doc_host->ref = 1; + ret->doc_host->ie = ret; + + DocHost_Init(&ret->doc_host->doc_host, &ret->IWebBrowser2_iface, &DocHostContainerVtbl); + + InternetExplorer_WebBrowser_Init(ret); + + HlinkFrame_Init(&ret->hlink_frame, (IUnknown*)&ret->IWebBrowser2_iface, &ret->doc_host->doc_host); + + create_frame_hwnd(ret); + + InterlockedIncrement(&obj_cnt); + list_add_tail(&ie_list, &ret->entry); + *ret_obj = ret; + return S_OK; +} + +HRESULT WINAPI InternetExplorer_Create(IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppv) +{ + InternetExplorer *ret; + HRESULT hres; + + TRACE("(%p %s %p)\n", pOuter, debugstr_guid(riid), ppv); + + hres = create_ie(&ret); + if(FAILED(hres)) + return hres; + + hres = IWebBrowser2_QueryInterface(&ret->IWebBrowser2_iface, riid, ppv); + IWebBrowser2_Release(&ret->IWebBrowser2_iface); + if(FAILED(hres)) + return hres; + + return S_OK; +} + +void released_obj(void) +{ + if(!InterlockedDecrement(&obj_cnt)) + PostQuitMessage(0); +} + +static BOOL create_ie_window(const WCHAR *cmdline) +{ + InternetExplorer *ie; + HRESULT hres; + + hres = create_ie(&ie); + if(FAILED(hres)) + return FALSE; + + IWebBrowser2_put_Visible(&ie->IWebBrowser2_iface, VARIANT_TRUE); + IWebBrowser2_put_MenuBar(&ie->IWebBrowser2_iface, VARIANT_TRUE); + + if(!*cmdline) { + IWebBrowser2_GoHome(&ie->IWebBrowser2_iface); + }else { + VARIANT var_url; + int cmdlen; + + static const WCHAR nohomeW[] = {'-','n','o','h','o','m','e'}; + + while(*cmdline == ' ' || *cmdline == '\t') + cmdline++; + cmdlen = strlenW(cmdline); + if(cmdlen > 2 && cmdline[0] == '"' && cmdline[cmdlen-1] == '"') { + cmdline++; + cmdlen -= 2; + } + + if(cmdlen == sizeof(nohomeW)/sizeof(*nohomeW) && !memcmp(cmdline, nohomeW, sizeof(nohomeW))) { + ie->nohome = TRUE; + }else { + V_VT(&var_url) = VT_BSTR; + + V_BSTR(&var_url) = SysAllocStringLen(cmdline, cmdlen); + + /* navigate to the first page */ + IWebBrowser2_Navigate2(&ie->IWebBrowser2_iface, &var_url, NULL, NULL, NULL, NULL); + + SysFreeString(V_BSTR(&var_url)); + } + } + + IWebBrowser2_Release(&ie->IWebBrowser2_iface); + return TRUE; +} + +static HDDEDATA open_dde_url(WCHAR *dde_url) +{ + InternetExplorer *ie = NULL, *iter; + WCHAR *url, *url_end; + VARIANT urlv; + HRESULT hres; + + TRACE("%s\n", debugstr_w(dde_url)); + + url = dde_url; + if(*url == '"') { + url++; + url_end = strchrW(url, '"'); + if(!url_end) { + FIXME("missing string terminator\n"); + return 0; + } + *url_end = 0; + }else { + url_end = strchrW(url, ','); + if(url_end) + *url_end = 0; + else + url_end = url + strlenW(url); + } + + LIST_FOR_EACH_ENTRY(iter, &ie_list, InternetExplorer, entry) { + if(iter->nohome) { + IWebBrowser2_AddRef(&iter->IWebBrowser2_iface); + ie = iter; + break; + } + } + + if(!ie) { + hres = create_ie(&ie); + if(FAILED(hres)) + return 0; + } + + IWebBrowser2_put_Visible(&ie->IWebBrowser2_iface, VARIANT_TRUE); + IWebBrowser2_put_MenuBar(&ie->IWebBrowser2_iface, VARIANT_TRUE); + + V_VT(&urlv) = VT_BSTR; + V_BSTR(&urlv) = SysAllocStringLen(url, url_end-url); + if(!V_BSTR(&urlv)) { + IWebBrowser2_Release(&ie->IWebBrowser2_iface); + return 0; + } + + hres = IWebBrowser2_Navigate2(&ie->IWebBrowser2_iface, &urlv, NULL, NULL, NULL, NULL); + if(FAILED(hres)) + return 0; + + IWebBrowser2_Release(&ie->IWebBrowser2_iface); + return ULongToHandle(DDE_FACK); +} + +static HDDEDATA WINAPI dde_proc(UINT type, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2, HDDEDATA data, + ULONG_PTR dwData1, ULONG_PTR dwData2) +{ + switch(type) { + case XTYP_CONNECT: + TRACE("XTYP_CONNECT %p\n", hsz1); + return ULongToHandle(!DdeCmpStringHandles(hsz1, ddestr_openurl)); + + case XTYP_EXECUTE: { + WCHAR *url; + DWORD size; + HDDEDATA ret; + + TRACE("XTYP_EXECUTE %p\n", data); + + size = DdeGetData(data, NULL, 0, 0); + if(!size) { + WARN("size = 0\n"); + break; + } + + url = heap_alloc(size); + if(!url) + break; + + if(DdeGetData(data, (BYTE*)url, size, 0) != size) { + ERR("error during read\n"); + heap_free(url); + break; + } + + ret = open_dde_url(url); + + heap_free(url); + return ret; + } + + case XTYP_REQUEST: + FIXME("XTYP_REQUEST\n"); + break; + + default: + TRACE("type %d\n", type); + } + + return NULL; +} + +static void init_dde(void) +{ + UINT res; + + static const WCHAR iexploreW[] = {'I','E','x','p','l','o','r','e',0}; + static const WCHAR openurlW[] = {'W','W','W','_','O','p','e','n','U','R','L',0}; + + res = DdeInitializeW(&dde_inst, dde_proc, CBF_SKIP_ALLNOTIFICATIONS | CBF_FAIL_ADVISES | CBF_FAIL_POKES, 0); + if(res != DMLERR_NO_ERROR) { + WARN("DdeInitialize failed: %u\n", res); + return; + } + + ddestr_iexplore = DdeCreateStringHandleW(dde_inst, iexploreW, CP_WINUNICODE); + if(!ddestr_iexplore) + WARN("Failed to create string handle: %u\n", DdeGetLastError(dde_inst)); + + ddestr_openurl = DdeCreateStringHandleW(dde_inst, openurlW, CP_WINUNICODE); + if(!ddestr_openurl) + WARN("Failed to create string handle: %u\n", DdeGetLastError(dde_inst)); + + res = HandleToULong(DdeNameService(dde_inst, ddestr_iexplore, 0, DNS_REGISTER)); + if(res != DMLERR_NO_ERROR) + WARN("DdeNameService failed: %u\n", res); +} + +static void release_dde(void) +{ + if(ddestr_iexplore) + DdeNameService(dde_inst, ddestr_iexplore, 0, DNS_UNREGISTER); + if(ddestr_openurl) + DdeFreeStringHandle(dde_inst, ddestr_openurl); + if(ddestr_iexplore) + DdeFreeStringHandle(dde_inst, ddestr_iexplore); + DdeUninitialize(dde_inst); +} + +/****************************************************************** + * IEWinMain (ieframe.101) + * + * Only returns on error. + */ +DWORD WINAPI IEWinMain(const WCHAR *cmdline, int nShowWindow) +{ + MSG msg; + HRESULT hres; + + static const WCHAR embeddingW[] = {'-','e','m','b','e','d','d','i','n','g',0}; + + TRACE("%s %d\n", debugstr_w(cmdline), nShowWindow); + + CoInitialize(NULL); + + hres = register_class_object(TRUE); + if(FAILED(hres)) { + CoUninitialize(); + ExitProcess(1); + } + + init_dde(); + + if(strcmpiW(cmdline, embeddingW)) { + if(!create_ie_window(cmdline)) { + CoUninitialize(); + ExitProcess(1); + } + } + + /* run the message loop for this thread */ + while (GetMessageW(&msg, 0, 0, 0)) + { + TranslateMessage(&msg); + DispatchMessageW(&msg); + } + + register_class_object(FALSE); + release_dde(); + + CoUninitialize(); + + ExitProcess(0); + return 0; +} diff --git a/reactos/dll/win32/ieframe/intshcut.c b/reactos/dll/win32/ieframe/intshcut.c new file mode 100644 index 00000000000..31b35167e3d --- /dev/null +++ b/reactos/dll/win32/ieframe/intshcut.c @@ -0,0 +1,897 @@ +/* + * Copyright 2008 Damjan Jovanovic + * + * ShellLink's barely documented cousin that handles URLs. + * + * 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 + */ + +/* + * TODO: + * Implement the IShellLinkA/W interfaces + * Handle the SetURL flags + * Implement any other interfaces? Does any software actually use them? + * + * The installer for the Zuma Deluxe Popcap game is good for testing. + */ + +#include + +#include "ieframe.h" + +//#include "shlobj.h" +//#include "shobjidl.h" +#include +#include +#include +//#include "shlwapi.h" +//#include "shlguid.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +typedef struct +{ + IUniformResourceLocatorA IUniformResourceLocatorA_iface; + IUniformResourceLocatorW IUniformResourceLocatorW_iface; + IPersistFile IPersistFile_iface; + IPropertySetStorage IPropertySetStorage_iface; + + LONG refCount; + + IPropertySetStorage *property_set_storage; + WCHAR *url; + BOOLEAN isDirty; + LPOLESTR currentFile; +} InternetShortcut; + +/* utility functions */ + +static inline InternetShortcut* impl_from_IUniformResourceLocatorA(IUniformResourceLocatorA *iface) +{ + return CONTAINING_RECORD(iface, InternetShortcut, IUniformResourceLocatorA_iface); +} + +static inline InternetShortcut* impl_from_IUniformResourceLocatorW(IUniformResourceLocatorW *iface) +{ + return CONTAINING_RECORD(iface, InternetShortcut, IUniformResourceLocatorW_iface); +} + +static inline InternetShortcut* impl_from_IPersistFile(IPersistFile *iface) +{ + return CONTAINING_RECORD(iface, InternetShortcut, IPersistFile_iface); +} + +static inline InternetShortcut* impl_from_IPropertySetStorage(IPropertySetStorage *iface) +{ + return CONTAINING_RECORD(iface, InternetShortcut, IPropertySetStorage_iface); +} + +static BOOL run_winemenubuilder( const WCHAR *args ) +{ + static const WCHAR menubuilder[] = {'\\','w','i','n','e','m','e','n','u','b','u','i','l','d','e','r','.','e','x','e',0}; + LONG len; + LPWSTR buffer; + STARTUPINFOW si; + PROCESS_INFORMATION pi; + BOOL ret; + WCHAR app[MAX_PATH]; + void *redir; + + GetSystemDirectoryW( app, MAX_PATH - sizeof(menubuilder)/sizeof(WCHAR) ); + strcatW( app, menubuilder ); + + len = (strlenW( app ) + strlenW( args ) + 1) * sizeof(WCHAR); + buffer = heap_alloc( len ); + if( !buffer ) + return FALSE; + + strcpyW( buffer, app ); + strcatW( buffer, args ); + + TRACE("starting %s\n",debugstr_w(buffer)); + + memset(&si, 0, sizeof(si)); + si.cb = sizeof(si); + + Wow64DisableWow64FsRedirection( &redir ); + ret = CreateProcessW( app, buffer, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &si, &pi ); + Wow64RevertWow64FsRedirection( redir ); + + heap_free( buffer ); + + if (ret) + { + CloseHandle( pi.hProcess ); + CloseHandle( pi.hThread ); + } + + return ret; +} + +static BOOL StartLinkProcessor( LPCOLESTR szLink ) +{ + static const WCHAR szFormat[] = { ' ','-','w',' ','-','u',' ','"','%','s','"',0 }; + LONG len; + LPWSTR buffer; + BOOL ret; + + len = sizeof(szFormat) + lstrlenW( szLink ) * sizeof(WCHAR); + buffer = heap_alloc( len ); + if( !buffer ) + return FALSE; + + sprintfW( buffer, szFormat, szLink ); + ret = run_winemenubuilder( buffer ); + heap_free( buffer ); + return ret; +} + +/* interface functions */ + +static HRESULT Unknown_QueryInterface(InternetShortcut *This, REFIID riid, PVOID *ppvObject) +{ + TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppvObject); + *ppvObject = NULL; + if (IsEqualGUID(&IID_IUnknown, riid)) + *ppvObject = &This->IUniformResourceLocatorA_iface; + else if (IsEqualGUID(&IID_IUniformResourceLocatorA, riid)) + *ppvObject = &This->IUniformResourceLocatorA_iface; + else if (IsEqualGUID(&IID_IUniformResourceLocatorW, riid)) + *ppvObject = &This->IUniformResourceLocatorW_iface; + else if (IsEqualGUID(&IID_IPersistFile, riid)) + *ppvObject = &This->IPersistFile_iface; + else if (IsEqualGUID(&IID_IPropertySetStorage, riid)) + *ppvObject = &This->IPropertySetStorage_iface; + else if (IsEqualGUID(&IID_IShellLinkA, riid)) + { + FIXME("The IShellLinkA interface is not yet supported by InternetShortcut\n"); + return E_NOINTERFACE; + } + else if (IsEqualGUID(&IID_IShellLinkW, riid)) + { + FIXME("The IShellLinkW interface is not yet supported by InternetShortcut\n"); + return E_NOINTERFACE; + } + else + { + FIXME("Interface with GUID %s not yet implemented by InternetShortcut\n", debugstr_guid(riid)); + return E_NOINTERFACE; + } + IUnknown_AddRef((IUnknown*)*ppvObject); + return S_OK; +} + +static ULONG Unknown_AddRef(InternetShortcut *This) +{ + TRACE("(%p)\n", This); + return InterlockedIncrement(&This->refCount); +} + +static ULONG Unknown_Release(InternetShortcut *This) +{ + ULONG count; + TRACE("(%p)\n", This); + count = InterlockedDecrement(&This->refCount); + if (count == 0) + { + CoTaskMemFree(This->url); + CoTaskMemFree(This->currentFile); + IPropertySetStorage_Release(This->property_set_storage); + heap_free(This); + unlock_module(); + } + return count; +} + +static HRESULT WINAPI UniformResourceLocatorW_QueryInterface(IUniformResourceLocatorW *url, REFIID riid, PVOID *ppvObject) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorW(url); + TRACE("(%p, %s, %p)\n", url, debugstr_guid(riid), ppvObject); + return Unknown_QueryInterface(This, riid, ppvObject); +} + +static ULONG WINAPI UniformResourceLocatorW_AddRef(IUniformResourceLocatorW *url) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorW(url); + TRACE("(%p)\n", url); + return Unknown_AddRef(This); +} + +static ULONG WINAPI UniformResourceLocatorW_Release(IUniformResourceLocatorW *url) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorW(url); + TRACE("(%p)\n", url); + return Unknown_Release(This); +} + +static HRESULT WINAPI UniformResourceLocatorW_SetUrl(IUniformResourceLocatorW *url, LPCWSTR pcszURL, DWORD dwInFlags) +{ + WCHAR *newURL = NULL; + InternetShortcut *This = impl_from_IUniformResourceLocatorW(url); + TRACE("(%p, %s, 0x%x)\n", url, debugstr_w(pcszURL), dwInFlags); + if (dwInFlags != 0) + FIXME("ignoring unsupported flags 0x%x\n", dwInFlags); + if (pcszURL != NULL) + { + newURL = co_strdupW(pcszURL); + if (newURL == NULL) + return E_OUTOFMEMORY; + } + CoTaskMemFree(This->url); + This->url = newURL; + This->isDirty = TRUE; + return S_OK; +} + +static HRESULT WINAPI UniformResourceLocatorW_GetUrl(IUniformResourceLocatorW *url, LPWSTR *ppszURL) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorW(url); + + TRACE("(%p, %p)\n", url, ppszURL); + + if (!This->url) { + *ppszURL = NULL; + return S_FALSE; + } + + *ppszURL = co_strdupW(This->url); + if (!*ppszURL) + return E_OUTOFMEMORY; + + return S_OK; +} + +static HRESULT WINAPI UniformResourceLocatorW_InvokeCommand(IUniformResourceLocatorW *url, PURLINVOKECOMMANDINFOW pCommandInfo) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorW(url); + WCHAR app[64]; + HKEY hkey; + static const WCHAR wszURLProtocol[] = {'U','R','L',' ','P','r','o','t','o','c','o','l',0}; + SHELLEXECUTEINFOW sei; + DWORD res, type; + HRESULT hres; + + TRACE("%p %p\n", This, pCommandInfo ); + + if (pCommandInfo->dwcbSize < sizeof (URLINVOKECOMMANDINFOW)) + return E_INVALIDARG; + + if (pCommandInfo->dwFlags != IURL_INVOKECOMMAND_FL_USE_DEFAULT_VERB) + { + FIXME("(%p, %p): non-default verbs not implemented\n", url, pCommandInfo); + return E_NOTIMPL; + } + + hres = CoInternetParseUrl(This->url, PARSE_SCHEMA, 0, app, sizeof(app)/sizeof(WCHAR), NULL, 0); + if(FAILED(hres)) + return E_FAIL; + + res = RegOpenKeyW(HKEY_CLASSES_ROOT, app, &hkey); + if(res != ERROR_SUCCESS) + return E_FAIL; + + res = RegQueryValueExW(hkey, wszURLProtocol, NULL, &type, NULL, NULL); + RegCloseKey(hkey); + if(res != ERROR_SUCCESS || type != REG_SZ) + return E_FAIL; + + memset(&sei, 0, sizeof(sei)); + sei.cbSize = sizeof(sei); + sei.lpFile = This->url; + sei.nShow = SW_SHOW; + + if( ShellExecuteExW(&sei) ) + return S_OK; + else + return E_FAIL; +} + +static HRESULT WINAPI UniformResourceLocatorA_QueryInterface(IUniformResourceLocatorA *url, REFIID riid, PVOID *ppvObject) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorA(url); + TRACE("(%p, %s, %p)\n", url, debugstr_guid(riid), ppvObject); + return Unknown_QueryInterface(This, riid, ppvObject); +} + +static ULONG WINAPI UniformResourceLocatorA_AddRef(IUniformResourceLocatorA *url) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorA(url); + TRACE("(%p)\n", url); + return Unknown_AddRef(This); +} + +static ULONG WINAPI UniformResourceLocatorA_Release(IUniformResourceLocatorA *url) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorA(url); + TRACE("(%p)\n", url); + return Unknown_Release(This); +} + +static HRESULT WINAPI UniformResourceLocatorA_SetUrl(IUniformResourceLocatorA *url, LPCSTR pcszURL, DWORD dwInFlags) +{ + WCHAR *newURL = NULL; + InternetShortcut *This = impl_from_IUniformResourceLocatorA(url); + TRACE("(%p, %s, 0x%x)\n", url, debugstr_a(pcszURL), dwInFlags); + if (dwInFlags != 0) + FIXME("ignoring unsupported flags 0x%x\n", dwInFlags); + if (pcszURL != NULL) + { + newURL = co_strdupAtoW(pcszURL); + if (newURL == NULL) + return E_OUTOFMEMORY; + } + CoTaskMemFree(This->url); + This->url = newURL; + This->isDirty = TRUE; + return S_OK; +} + +static HRESULT WINAPI UniformResourceLocatorA_GetUrl(IUniformResourceLocatorA *url, LPSTR *ppszURL) +{ + InternetShortcut *This = impl_from_IUniformResourceLocatorA(url); + + TRACE("(%p, %p)\n", url, ppszURL); + + if (!This->url) { + *ppszURL = NULL; + return S_FALSE; + + } + + *ppszURL = co_strdupWtoA(This->url); + if (!*ppszURL) + return E_OUTOFMEMORY; + + return S_OK; +} + +static HRESULT WINAPI UniformResourceLocatorA_InvokeCommand(IUniformResourceLocatorA *url, PURLINVOKECOMMANDINFOA pCommandInfo) +{ + URLINVOKECOMMANDINFOW wideCommandInfo; + int len; + WCHAR *wideVerb; + HRESULT res; + InternetShortcut *This = impl_from_IUniformResourceLocatorA(url); + + wideCommandInfo.dwcbSize = sizeof wideCommandInfo; + wideCommandInfo.dwFlags = pCommandInfo->dwFlags; + wideCommandInfo.hwndParent = pCommandInfo->hwndParent; + + len = MultiByteToWideChar(CP_ACP, 0, pCommandInfo->pcszVerb, -1, NULL, 0); + wideVerb = heap_alloc(len * sizeof(WCHAR)); + MultiByteToWideChar(CP_ACP, 0, pCommandInfo->pcszVerb, -1, wideVerb, len); + + wideCommandInfo.pcszVerb = wideVerb; + + res = UniformResourceLocatorW_InvokeCommand(&This->IUniformResourceLocatorW_iface, &wideCommandInfo); + heap_free(wideVerb); + + return res; +} + +static HRESULT WINAPI PersistFile_QueryInterface(IPersistFile *pFile, REFIID riid, PVOID *ppvObject) +{ + InternetShortcut *This = impl_from_IPersistFile(pFile); + TRACE("(%p, %s, %p)\n", pFile, debugstr_guid(riid), ppvObject); + return Unknown_QueryInterface(This, riid, ppvObject); +} + +static ULONG WINAPI PersistFile_AddRef(IPersistFile *pFile) +{ + InternetShortcut *This = impl_from_IPersistFile(pFile); + TRACE("(%p)\n", pFile); + return Unknown_AddRef(This); +} + +static ULONG WINAPI PersistFile_Release(IPersistFile *pFile) +{ + InternetShortcut *This = impl_from_IPersistFile(pFile); + TRACE("(%p)\n", pFile); + return Unknown_Release(This); +} + +static HRESULT WINAPI PersistFile_GetClassID(IPersistFile *pFile, CLSID *pClassID) +{ + TRACE("(%p, %p)\n", pFile, pClassID); + *pClassID = CLSID_InternetShortcut; + return S_OK; +} + +static HRESULT WINAPI PersistFile_IsDirty(IPersistFile *pFile) +{ + InternetShortcut *This = impl_from_IPersistFile(pFile); + TRACE("(%p)\n", pFile); + return This->isDirty ? S_OK : S_FALSE; +} + +/* A helper function: Allocate and fill rString. Return number of bytes read. */ +static DWORD get_profile_string(LPCWSTR lpAppName, LPCWSTR lpKeyName, + LPCWSTR lpFileName, WCHAR **rString ) +{ + DWORD r = 0; + DWORD len = 128; + WCHAR *buffer; + + buffer = CoTaskMemAlloc(len * sizeof(*buffer)); + if (buffer != NULL) + { + r = GetPrivateProfileStringW(lpAppName, lpKeyName, NULL, buffer, len, lpFileName); + while (r == len-1) + { + WCHAR *realloc_buf; + + len *= 2; + realloc_buf = CoTaskMemRealloc(buffer, len * sizeof(*buffer)); + if (realloc_buf == NULL) + { + CoTaskMemFree(buffer); + *rString = NULL; + return 0; + } + buffer = realloc_buf; + + r = GetPrivateProfileStringW(lpAppName, lpKeyName, NULL, buffer, len, lpFileName); + } + } + + *rString = buffer; + return r; +} + +static HRESULT WINAPI PersistFile_Load(IPersistFile *pFile, LPCOLESTR pszFileName, DWORD dwMode) +{ + WCHAR str_header[] = {'I','n','t','e','r','n','e','t','S','h','o','r','t','c','u','t',0}; + WCHAR str_URL[] = {'U','R','L',0}; + WCHAR str_iconfile[] = {'i','c','o','n','f','i','l','e',0}; + WCHAR str_iconindex[] = {'i','c','o','n','i','n','d','e','x',0}; + WCHAR *filename = NULL; + HRESULT hr; + InternetShortcut *This = impl_from_IPersistFile(pFile); + TRACE("(%p, %s, 0x%x)\n", pFile, debugstr_w(pszFileName), dwMode); + if (dwMode != 0) + FIXME("ignoring unimplemented mode 0x%x\n", dwMode); + filename = co_strdupW(pszFileName); + if (filename != NULL) + { + DWORD r; + WCHAR *url; + + r = get_profile_string(str_header, str_URL, pszFileName, &url); + + if (url == NULL) + { + hr = E_OUTOFMEMORY; + CoTaskMemFree(filename); + } + else if (r == 0) + { + hr = E_FAIL; + CoTaskMemFree(filename); + } + else + { + hr = S_OK; + CoTaskMemFree(This->currentFile); + This->currentFile = filename; + CoTaskMemFree(This->url); + This->url = url; + This->isDirty = FALSE; + } + + /* Now we're going to read in the iconfile and iconindex. + If we don't find them, that's not a failure case -- it's possible + that they just aren't in there. */ + if (SUCCEEDED(hr)) + { + IPropertyStorage *pPropStg; + WCHAR *iconfile; + WCHAR *iconindexstring; + hr = IPropertySetStorage_Open(This->property_set_storage, &FMTID_Intshcut, + STGM_READWRITE | STGM_SHARE_EXCLUSIVE, + &pPropStg); + + r = get_profile_string(str_header, str_iconfile, pszFileName, &iconfile); + if (iconfile != NULL) + { + PROPSPEC ps; + PROPVARIANT pv; + ps.ulKind = PRSPEC_PROPID; + ps.u.propid = PID_IS_ICONFILE; + pv.vt = VT_LPWSTR; + pv.u.pwszVal = iconfile; + hr = IPropertyStorage_WriteMultiple(pPropStg, 1, &ps, &pv, 0); + if (FAILED(hr)) + { + TRACE("Failed to store the iconfile to our property storage. hr = 0x%x\n", hr); + } + + CoTaskMemFree(iconfile); + } + + r = get_profile_string(str_header, str_iconindex, pszFileName, &iconindexstring); + + if (iconindexstring != NULL) + { + int iconindex; + PROPSPEC ps; + PROPVARIANT pv; + char *iconindexastring = co_strdupWtoA(iconindexstring); + sscanf(iconindexastring, "%d", &iconindex); + CoTaskMemFree(iconindexastring); + ps.ulKind = PRSPEC_PROPID; + ps.u.propid = PID_IS_ICONINDEX; + pv.vt = VT_I4; + pv.u.iVal = iconindex; + hr = IPropertyStorage_WriteMultiple(pPropStg, 1, &ps, &pv, 0); + if (FAILED(hr)) + { + TRACE("Failed to store the iconindex to our property storage. hr = 0x%x\n", hr); + } + + CoTaskMemFree(iconindexstring); + } + + IPropertyStorage_Release(pPropStg); + } + else + hr = E_OUTOFMEMORY; + } + else + hr = E_OUTOFMEMORY; + return hr; +} + +static HRESULT WINAPI PersistFile_Save(IPersistFile *pFile, LPCOLESTR pszFileName, BOOL fRemember) +{ + HRESULT hr = S_OK; + INT len; + CHAR *url; + InternetShortcut *This = impl_from_IPersistFile(pFile); + + TRACE("(%p, %s, %d)\n", pFile, debugstr_w(pszFileName), fRemember); + + if (pszFileName != NULL && fRemember) + { + LPOLESTR oldFile = This->currentFile; + This->currentFile = co_strdupW(pszFileName); + if (This->currentFile == NULL) + { + This->currentFile = oldFile; + return E_OUTOFMEMORY; + } + CoTaskMemFree(oldFile); + } + if (This->url == NULL) + return E_FAIL; + + /* Windows seems to always write: + * ASCII "[InternetShortcut]" headers + * ASCII names in "name=value" pairs + * An ASCII (probably UTF8?) value in "URL=..." + */ + len = WideCharToMultiByte(CP_UTF8, 0, This->url, -1, NULL, 0, 0, 0); + url = heap_alloc(len); + if (url != NULL) + { + HANDLE file; + WideCharToMultiByte(CP_UTF8, 0, This->url, -1, url, len, 0, 0); + file = CreateFileW(pszFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (file != INVALID_HANDLE_VALUE) + { + DWORD bytesWritten; + char *iconfile; + char str_header[] = "[InternetShortcut]"; + char str_URL[] = "URL="; + char str_ICONFILE[] = "ICONFILE="; + char str_eol[] = "\r\n"; + IPropertyStorage *pPropStgRead; + PROPSPEC ps[2]; + PROPVARIANT pvread[2]; + ps[0].ulKind = PRSPEC_PROPID; + ps[0].u.propid = PID_IS_ICONFILE; + ps[1].ulKind = PRSPEC_PROPID; + ps[1].u.propid = PID_IS_ICONINDEX; + + WriteFile(file, str_header, lstrlenA(str_header), &bytesWritten, NULL); + WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); + WriteFile(file, str_URL, lstrlenA(str_URL), &bytesWritten, NULL); + WriteFile(file, url, lstrlenA(url), &bytesWritten, NULL); + WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); + + hr = IPropertySetStorage_Open(This->property_set_storage, &FMTID_Intshcut, STGM_READ|STGM_SHARE_EXCLUSIVE, &pPropStgRead); + if (SUCCEEDED(hr)) + { + hr = IPropertyStorage_ReadMultiple(pPropStgRead, 2, ps, pvread); + if (hr == S_FALSE) + { + /* None of the properties are present, that's ok */ + hr = S_OK; + IPropertyStorage_Release(pPropStgRead); + } + else if (SUCCEEDED(hr)) + { + char indexString[50]; + len = WideCharToMultiByte(CP_UTF8, 0, pvread[0].u.pwszVal, -1, NULL, 0, 0, 0); + iconfile = heap_alloc(len); + if (iconfile != NULL) + { + WideCharToMultiByte(CP_UTF8, 0, pvread[0].u.pwszVal, -1, iconfile, len, 0, 0); + WriteFile(file, str_ICONFILE, lstrlenA(str_ICONFILE), &bytesWritten, NULL); + WriteFile(file, iconfile, lstrlenA(iconfile), &bytesWritten, NULL); + WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); + } + + sprintf(indexString, "ICONINDEX=%d", pvread[1].u.iVal); + WriteFile(file, indexString, lstrlenA(indexString), &bytesWritten, NULL); + WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); + + IPropertyStorage_Release(pPropStgRead); + PropVariantClear(&pvread[0]); + PropVariantClear(&pvread[1]); + } + else + { + TRACE("Unable to read properties.\n"); + } + } + else + { + TRACE("Unable to get the IPropertyStorage.\n"); + } + + CloseHandle(file); + if (pszFileName == NULL || fRemember) + This->isDirty = FALSE; + StartLinkProcessor(pszFileName); + } + else + hr = E_FAIL; + heap_free(url); + } + else + hr = E_OUTOFMEMORY; + + return hr; +} + +static HRESULT WINAPI PersistFile_SaveCompleted(IPersistFile *pFile, LPCOLESTR pszFileName) +{ + FIXME("(%p, %p): stub\n", pFile, pszFileName); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistFile_GetCurFile(IPersistFile *pFile, LPOLESTR *ppszFileName) +{ + HRESULT hr = S_OK; + InternetShortcut *This = impl_from_IPersistFile(pFile); + TRACE("(%p, %p)\n", pFile, ppszFileName); + if (This->currentFile == NULL) + *ppszFileName = NULL; + else + { + *ppszFileName = co_strdupW(This->currentFile); + if (*ppszFileName == NULL) + hr = E_OUTOFMEMORY; + } + return hr; +} + +static HRESULT WINAPI PropertySetStorage_QueryInterface(IPropertySetStorage *iface, REFIID riid, PVOID *ppvObject) +{ + InternetShortcut *This = impl_from_IPropertySetStorage(iface); + TRACE("(%p)\n", iface); + return Unknown_QueryInterface(This, riid, ppvObject); +} + +static ULONG WINAPI PropertySetStorage_AddRef(IPropertySetStorage *iface) +{ + InternetShortcut *This = impl_from_IPropertySetStorage(iface); + TRACE("(%p)\n", iface); + return Unknown_AddRef(This); +} + +static ULONG WINAPI PropertySetStorage_Release(IPropertySetStorage *iface) +{ + InternetShortcut *This = impl_from_IPropertySetStorage(iface); + TRACE("(%p)\n", iface); + return Unknown_Release(This); +} + +static HRESULT WINAPI PropertySetStorage_Create( + IPropertySetStorage* iface, + REFFMTID rfmtid, + const CLSID *pclsid, + DWORD grfFlags, + DWORD grfMode, + IPropertyStorage **ppprstg) +{ + InternetShortcut *This = impl_from_IPropertySetStorage(iface); + TRACE("(%s, %p, 0x%x, 0x%x, %p)\n", debugstr_guid(rfmtid), pclsid, grfFlags, grfMode, ppprstg); + + return IPropertySetStorage_Create(This->property_set_storage, + rfmtid, + pclsid, + grfFlags, + grfMode, + ppprstg); +} + +static HRESULT WINAPI PropertySetStorage_Open( + IPropertySetStorage* iface, + REFFMTID rfmtid, + DWORD grfMode, + IPropertyStorage **ppprstg) +{ + InternetShortcut *This = impl_from_IPropertySetStorage(iface); + TRACE("(%s, 0x%x, %p)\n", debugstr_guid(rfmtid), grfMode, ppprstg); + + /* Note: The |STGM_SHARE_EXCLUSIVE is to cope with a bug in the implementation. Should be fixed in ole32. */ + return IPropertySetStorage_Open(This->property_set_storage, + rfmtid, + grfMode|STGM_SHARE_EXCLUSIVE, + ppprstg); +} + +static HRESULT WINAPI PropertySetStorage_Delete(IPropertySetStorage *iface, REFFMTID rfmtid) +{ + InternetShortcut *This = impl_from_IPropertySetStorage(iface); + TRACE("(%s)\n", debugstr_guid(rfmtid)); + + + return IPropertySetStorage_Delete(This->property_set_storage, + rfmtid); +} + +static HRESULT WINAPI PropertySetStorage_Enum(IPropertySetStorage *iface, IEnumSTATPROPSETSTG **ppenum) +{ + FIXME("(%p): stub\n", ppenum); + return E_NOTIMPL; +} + +static const IUniformResourceLocatorWVtbl uniformResourceLocatorWVtbl = { + UniformResourceLocatorW_QueryInterface, + UniformResourceLocatorW_AddRef, + UniformResourceLocatorW_Release, + UniformResourceLocatorW_SetUrl, + UniformResourceLocatorW_GetUrl, + UniformResourceLocatorW_InvokeCommand +}; + +static const IUniformResourceLocatorAVtbl uniformResourceLocatorAVtbl = { + UniformResourceLocatorA_QueryInterface, + UniformResourceLocatorA_AddRef, + UniformResourceLocatorA_Release, + UniformResourceLocatorA_SetUrl, + UniformResourceLocatorA_GetUrl, + UniformResourceLocatorA_InvokeCommand +}; + +static const IPersistFileVtbl persistFileVtbl = { + PersistFile_QueryInterface, + PersistFile_AddRef, + PersistFile_Release, + PersistFile_GetClassID, + PersistFile_IsDirty, + PersistFile_Load, + PersistFile_Save, + PersistFile_SaveCompleted, + PersistFile_GetCurFile +}; + +static const IPropertySetStorageVtbl propertySetStorageVtbl = { + PropertySetStorage_QueryInterface, + PropertySetStorage_AddRef, + PropertySetStorage_Release, + PropertySetStorage_Create, + PropertySetStorage_Open, + PropertySetStorage_Delete, + PropertySetStorage_Enum +}; + +static InternetShortcut *create_shortcut(void) +{ + InternetShortcut *newshortcut; + + newshortcut = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(InternetShortcut)); + if (newshortcut) + { + HRESULT hr; + IPropertyStorage *dummy; + + newshortcut->IUniformResourceLocatorA_iface.lpVtbl = &uniformResourceLocatorAVtbl; + newshortcut->IUniformResourceLocatorW_iface.lpVtbl = &uniformResourceLocatorWVtbl; + newshortcut->IPersistFile_iface.lpVtbl = &persistFileVtbl; + newshortcut->IPropertySetStorage_iface.lpVtbl = &propertySetStorageVtbl; + newshortcut->refCount = 1; + hr = StgCreateStorageEx(NULL, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE, + STGFMT_STORAGE, 0, NULL, NULL, &IID_IPropertySetStorage, (void **) &newshortcut->property_set_storage); + if (FAILED(hr)) + { + TRACE("Failed to create the storage object needed for the shortcut.\n"); + heap_free(newshortcut); + return NULL; + } + + hr = IPropertySetStorage_Create(newshortcut->property_set_storage, &FMTID_Intshcut, NULL, PROPSETFLAG_DEFAULT, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &dummy); + if (FAILED(hr)) + { + TRACE("Failed to create the property object needed for the shortcut.\n"); + IPropertySetStorage_Release(newshortcut->property_set_storage); + heap_free(newshortcut); + return NULL; + } + IPropertyStorage_Release(dummy); + } + + return newshortcut; +} + +HRESULT WINAPI InternetShortcut_Create(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv) +{ + InternetShortcut *This; + HRESULT hres; + + TRACE("(%p, %s, %p)\n", outer, debugstr_guid(riid), ppv); + + *ppv = NULL; + + if(outer) + return CLASS_E_NOAGGREGATION; + + This = create_shortcut(); + if(!This) + return E_OUTOFMEMORY; + + hres = Unknown_QueryInterface(This, riid, ppv); + Unknown_Release(This); + return hres; +} + + +/********************************************************************** + * OpenURL (ieframe.@) + */ +void WINAPI OpenURL(HWND hWnd, HINSTANCE hInst, LPCSTR lpcstrUrl, int nShowCmd) +{ + InternetShortcut *shortcut; + WCHAR* urlfilepath = NULL; + int len; + + shortcut = create_shortcut(); + + if(!shortcut) + return; + + len = MultiByteToWideChar(CP_ACP, 0, lpcstrUrl, -1, NULL, 0); + urlfilepath = heap_alloc(len * sizeof(WCHAR)); + MultiByteToWideChar(CP_ACP, 0, lpcstrUrl, -1, urlfilepath, len); + + if(SUCCEEDED(IPersistFile_Load(&shortcut->IPersistFile_iface, urlfilepath, 0))) { + URLINVOKECOMMANDINFOW ici; + + memset( &ici, 0, sizeof ici ); + ici.dwcbSize = sizeof ici; + ici.dwFlags = IURL_INVOKECOMMAND_FL_USE_DEFAULT_VERB; + ici.hwndParent = hWnd; + + if(FAILED(UniformResourceLocatorW_InvokeCommand(&shortcut->IUniformResourceLocatorW_iface, (PURLINVOKECOMMANDINFOW) &ici))) + TRACE("failed to open URL: %s\n", debugstr_a(lpcstrUrl)); + } + + heap_free(urlfilepath); + Unknown_Release(shortcut); +} diff --git a/reactos/dll/win32/ieframe/navigate.c b/reactos/dll/win32/ieframe/navigate.c new file mode 100644 index 00000000000..e4010622843 --- /dev/null +++ b/reactos/dll/win32/ieframe/navigate.c @@ -0,0 +1,1456 @@ +/* + * Copyright 2006-2007 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 + */ + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT + +#include "ieframe.h" + +#include +#include +#include +#include +#include +//#include "mshtml.h" +#include "resource.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static const WCHAR emptyW[] = {0}; + +typedef struct { + IBindStatusCallback IBindStatusCallback_iface; + IHttpNegotiate IHttpNegotiate_iface; + IHttpSecurity IHttpSecurity_iface; + + LONG ref; + + DocHost *doc_host; + IBinding *binding; + + BSTR url; + HGLOBAL post_data; + BSTR headers; + ULONG post_data_len; +} BindStatusCallback; + +static void dump_BINDINFO(BINDINFO *bi) +{ + static const char * const BINDINFOF_str[] = { + "#0", + "BINDINFOF_URLENCODESTGMEDDATA", + "BINDINFOF_URLENCODEDEXTRAINFO" + }; + + static const char * const BINDVERB_str[] = { + "BINDVERB_GET", + "BINDVERB_POST", + "BINDVERB_PUT", + "BINDVERB_CUSTOM" + }; + + TRACE("\n" + "BINDINFO = {\n" + " %d, %s,\n" + " {%d, %p, %p},\n" + " %s,\n" + " %s,\n" + " %s,\n" + " %d, %08x, %d, %d\n" + " {%d %p %x},\n" + " %s\n" + " %p, %d\n" + "}\n", + + bi->cbSize, debugstr_w(bi->szExtraInfo), + bi->stgmedData.tymed, bi->stgmedData.u.hGlobal, bi->stgmedData.pUnkForRelease, + bi->grfBindInfoF > BINDINFOF_URLENCODEDEXTRAINFO + ? "unknown" : BINDINFOF_str[bi->grfBindInfoF], + bi->dwBindVerb > BINDVERB_CUSTOM + ? "unknown" : BINDVERB_str[bi->dwBindVerb], + debugstr_w(bi->szCustomVerb), + bi->cbstgmedData, bi->dwOptions, bi->dwOptionsFlags, bi->dwCodePage, + bi->securityAttributes.nLength, + bi->securityAttributes.lpSecurityDescriptor, + bi->securityAttributes.bInheritHandle, + debugstr_guid(&bi->iid), + bi->pUnk, bi->dwReserved + ); +} + +static void set_status_text(BindStatusCallback *This, ULONG statuscode, LPCWSTR str) +{ + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + WCHAR fmt[IDS_STATUSFMT_MAXLEN]; + WCHAR buffer[IDS_STATUSFMT_MAXLEN + INTERNET_MAX_URL_LENGTH]; + + if(!This->doc_host) + return; + + TRACE("(%p, %d, %s)\n", This, statuscode, debugstr_w(str)); + buffer[0] = 0; + if (statuscode && str && *str) { + fmt[0] = 0; + /* the format string must have one "%s" for the str */ + LoadStringW(ieframe_instance, IDS_STATUSFMT_FIRST + statuscode, fmt, IDS_STATUSFMT_MAXLEN); + snprintfW(buffer, sizeof(buffer)/sizeof(WCHAR), fmt, str); + } + + V_VT(&arg) = VT_BSTR; + V_BSTR(&arg) = str ? SysAllocString(buffer) : NULL; + TRACE("=> %s\n", debugstr_w(V_BSTR(&arg))); + + call_sink(This->doc_host->cps.wbe2, DISPID_STATUSTEXTCHANGE, &dispparams); + + if(This->doc_host->frame) + IOleInPlaceFrame_SetStatusText(This->doc_host->frame, buffer); + + VariantClear(&arg); + +} + +HRESULT set_dochost_url(DocHost *This, const WCHAR *url) +{ + WCHAR *new_url; + + if(url) { + new_url = heap_strdupW(url); + if(!new_url) + return E_OUTOFMEMORY; + }else { + new_url = NULL; + } + + heap_free(This->url); + This->url = new_url; + + This->container_vtbl->SetURL(This, This->url); + return S_OK; +} + +static inline BindStatusCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface) +{ + return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface); +} + +static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface, + REFIID riid, void **ppv) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IBindStatusCallback_iface; + }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) { + TRACE("(%p)->(IID_IBindStatusCallback %p)\n", This, ppv); + *ppv = &This->IBindStatusCallback_iface; + }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) { + TRACE("(%p)->(IID_IHttpNegotiate %p)\n", This, ppv); + *ppv = &This->IHttpNegotiate_iface; + }else if(IsEqualGUID(&IID_IWindowForBindingUI, riid)) { + TRACE("(%p)->(IID_IWindowForBindingUI %p)\n", This, ppv); + *ppv = &This->IHttpSecurity_iface; + }else if(IsEqualGUID(&IID_IHttpSecurity, riid)) { + TRACE("(%p)->(IID_IHttpSecurity %p)\n", This, ppv); + *ppv = &This->IHttpSecurity_iface; + }else { + *ppv = NULL; + WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + LONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + return ref; +} + +static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) { + if(This->doc_host) + IOleClientSite_Release(&This->doc_host->IOleClientSite_iface); + if(This->binding) + IBinding_Release(This->binding); + if(This->post_data) + GlobalFree(This->post_data); + SysFreeString(This->headers); + SysFreeString(This->url); + heap_free(This); + } + + return ref; +} + +static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface, + DWORD dwReserved, IBinding *pbind) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + + TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind); + + This->binding = pbind; + IBinding_AddRef(This->binding); + + return S_OK; +} + +static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, + LONG *pnPriority) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + FIXME("(%p)->(%p)\n", This, pnPriority); + return E_NOTIMPL; +} + +static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, + DWORD reserved) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + FIXME("(%p)->(%d)\n", This, reserved); + return E_NOTIMPL; +} + +static DWORD get_http_status_code(IBinding *binding) +{ + IWinInetHttpInfo *http_info; + DWORD status, size = sizeof(DWORD); + HRESULT hres; + + hres = IBinding_QueryInterface(binding, &IID_IWinInetHttpInfo, (void**)&http_info); + if(FAILED(hres)) + return HTTP_STATUS_OK; + + hres = IWinInetHttpInfo_QueryInfo(http_info, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, + &status, &size, NULL, NULL); + IWinInetHttpInfo_Release(http_info); + + if(FAILED(hres)) + return HTTP_STATUS_OK; + return status; +} + +static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, + ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + DWORD status_code; + + TRACE("(%p)->(%d %d %d %s)\n", This, ulProgress, ulProgressMax, ulStatusCode, + debugstr_w(szStatusText)); + + switch(ulStatusCode) { + case BINDSTATUS_REDIRECTING: + return set_dochost_url(This->doc_host, szStatusText); + case BINDSTATUS_BEGINDOWNLOADDATA: + set_status_text(This, ulStatusCode, szStatusText); + status_code = get_http_status_code(This->binding); + if(status_code != HTTP_STATUS_OK) + handle_navigation_error(This->doc_host, status_code, This->url, NULL); + return S_OK; + + case BINDSTATUS_FINDINGRESOURCE: + case BINDSTATUS_ENDDOWNLOADDATA: + case BINDSTATUS_SENDINGREQUEST: + set_status_text(This, ulStatusCode, szStatusText); + return S_OK; + + case BINDSTATUS_CONNECTING: + case BINDSTATUS_CACHEFILENAMEAVAILABLE: + case BINDSTATUS_CLASSIDAVAILABLE: + case BINDSTATUS_MIMETYPEAVAILABLE: + case BINDSTATUS_BEGINSYNCOPERATION: + case BINDSTATUS_ENDSYNCOPERATION: + return S_OK; + default: + FIXME("status code %u\n", ulStatusCode); + } + + return S_OK; +} + +void handle_navigation_error(DocHost* doc_host, HRESULT hres, BSTR url, IHTMLWindow2 *win2) +{ + VARIANT var_status_code, var_frame_name, var_url; + DISPPARAMS dispparams; + VARIANTARG params[5]; + VARIANT_BOOL cancel = VARIANT_FALSE; + + dispparams.cArgs = 5; + dispparams.cNamedArgs = 0; + dispparams.rgdispidNamedArgs = NULL; + dispparams.rgvarg = params; + + V_VT(params) = VT_BOOL|VT_BYREF; + V_BOOLREF(params) = &cancel; + + V_VT(params+1) = VT_VARIANT|VT_BYREF; + V_VARIANTREF(params+1) = &var_status_code; + V_VT(&var_status_code) = VT_I4; + V_I4(&var_status_code) = hres; + + V_VT(params+2) = VT_VARIANT|VT_BYREF; + V_VARIANTREF(params+2) = &var_frame_name; + V_VT(&var_frame_name) = VT_BSTR; + if(win2) { + hres = IHTMLWindow2_get_name(win2, &V_BSTR(&var_frame_name)); + if(FAILED(hres)) + V_BSTR(&var_frame_name) = NULL; + } else + V_BSTR(&var_frame_name) = NULL; + + V_VT(params+3) = VT_VARIANT|VT_BYREF; + V_VARIANTREF(params+3) = &var_url; + V_VT(&var_url) = VT_BSTR; + V_BSTR(&var_url) = url; + + V_VT(params+4) = VT_DISPATCH; + V_DISPATCH(params+4) = (IDispatch*)doc_host->wb; + + call_sink(doc_host->cps.wbe2, DISPID_NAVIGATEERROR, &dispparams); + SysFreeString(V_BSTR(&var_frame_name)); + + if(!cancel) + FIXME("Navigate to error page\n"); +} + +static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface, + HRESULT hresult, LPCWSTR szError) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + + TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError)); + + set_status_text(This, 0, emptyW); + + if(!This->doc_host) + return S_OK; + + if(FAILED(hresult)) + handle_navigation_error(This->doc_host, hresult, This->url, NULL); + + IOleClientSite_Release(&This->doc_host->IOleClientSite_iface); + This->doc_host = NULL; + + IBinding_Release(This->binding); + This->binding = NULL; + + return S_OK; +} + +static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface, + DWORD *grfBINDF, BINDINFO *pbindinfo) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + + TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo); + + *grfBINDF = BINDF_ASYNCHRONOUS; + + if(This->post_data) { + pbindinfo->dwBindVerb = BINDVERB_POST; + + pbindinfo->stgmedData.tymed = TYMED_HGLOBAL; + pbindinfo->stgmedData.u.hGlobal = This->post_data; + pbindinfo->cbstgmedData = This->post_data_len; + pbindinfo->stgmedData.pUnkForRelease = (IUnknown*)&This->IBindStatusCallback_iface; + IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface); + } + + return S_OK; +} + +static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface, + DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + FIXME("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed); + return E_NOTIMPL; +} + +static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface, + REFIID riid, IUnknown *punk) +{ + BindStatusCallback *This = impl_from_IBindStatusCallback(iface); + + TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk); + + return dochost_object_available(This->doc_host, punk); +} + +static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = { + BindStatusCallback_QueryInterface, + BindStatusCallback_AddRef, + BindStatusCallback_Release, + BindStatusCallback_OnStartBinding, + BindStatusCallback_GetPriority, + BindStatusCallback_OnLowResource, + BindStatusCallback_OnProgress, + BindStatusCallback_OnStopBinding, + BindStatusCallback_GetBindInfo, + BindStatusCallback_OnDataAvailable, + BindStatusCallback_OnObjectAvailable +}; + +static inline BindStatusCallback *impl_from_IHttpNegotiate(IHttpNegotiate *iface) +{ + return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface); +} + +static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate *iface, + REFIID riid, void **ppv) +{ + BindStatusCallback *This = impl_from_IHttpNegotiate(iface); + return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv); +} + +static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate *iface) +{ + BindStatusCallback *This = impl_from_IHttpNegotiate(iface); + return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface); +} + +static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate *iface) +{ + BindStatusCallback *This = impl_from_IHttpNegotiate(iface); + return IBindStatusCallback_Release(&This->IBindStatusCallback_iface); +} + +static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate *iface, + LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders) +{ + BindStatusCallback *This = impl_from_IHttpNegotiate(iface); + + TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders), + dwReserved, pszAdditionalHeaders); + + if(This->headers) { + int size = (strlenW(This->headers)+1)*sizeof(WCHAR); + *pszAdditionalHeaders = CoTaskMemAlloc(size); + memcpy(*pszAdditionalHeaders, This->headers, size); + } + + return S_OK; +} + +static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate *iface, + DWORD dwResponseCode, LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, + LPWSTR *pszAdditionalRequestHeaders) +{ + BindStatusCallback *This = impl_from_IHttpNegotiate(iface); + TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders), + debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders); + return S_OK; +} + +static const IHttpNegotiateVtbl HttpNegotiateVtbl = { + HttpNegotiate_QueryInterface, + HttpNegotiate_AddRef, + HttpNegotiate_Release, + HttpNegotiate_BeginningTransaction, + HttpNegotiate_OnResponse +}; + +static inline BindStatusCallback *impl_from_IHttpSecurity(IHttpSecurity *iface) +{ + return CONTAINING_RECORD(iface, BindStatusCallback, IHttpSecurity_iface); +} + +static HRESULT WINAPI HttpSecurity_QueryInterface(IHttpSecurity *iface, REFIID riid, void **ppv) +{ + BindStatusCallback *This = impl_from_IHttpSecurity(iface); + return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv); +} + +static ULONG WINAPI HttpSecurity_AddRef(IHttpSecurity *iface) +{ + BindStatusCallback *This = impl_from_IHttpSecurity(iface); + return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface); +} + +static ULONG WINAPI HttpSecurity_Release(IHttpSecurity *iface) +{ + BindStatusCallback *This = impl_from_IHttpSecurity(iface); + return IBindStatusCallback_Release(&This->IBindStatusCallback_iface); +} + +static HRESULT WINAPI HttpSecurity_GetWindow(IHttpSecurity *iface, REFGUID rguidReason, HWND *phwnd) +{ + BindStatusCallback *This = impl_from_IHttpSecurity(iface); + + TRACE("(%p)->(%s %p)\n", This, debugstr_guid(rguidReason), phwnd); + + if(!This->doc_host) + return E_FAIL; + + *phwnd = This->doc_host->frame_hwnd; + return S_OK; +} + +static HRESULT WINAPI HttpSecurity_OnSecurityProblem(IHttpSecurity *iface, DWORD dwProblem) +{ + BindStatusCallback *This = impl_from_IHttpSecurity(iface); + FIXME("(%p)->(%u)\n", This, dwProblem); + return S_FALSE; +} + +static const IHttpSecurityVtbl HttpSecurityVtbl = { + HttpSecurity_QueryInterface, + HttpSecurity_AddRef, + HttpSecurity_Release, + HttpSecurity_GetWindow, + HttpSecurity_OnSecurityProblem +}; + +static BindStatusCallback *create_callback(DocHost *doc_host, LPCWSTR url, PBYTE post_data, + ULONG post_data_len, LPCWSTR headers) +{ + BindStatusCallback *ret = heap_alloc(sizeof(BindStatusCallback)); + + ret->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl; + ret->IHttpNegotiate_iface.lpVtbl = &HttpNegotiateVtbl; + ret->IHttpSecurity_iface.lpVtbl = &HttpSecurityVtbl; + + ret->ref = 1; + ret->url = SysAllocString(url); + ret->post_data = NULL; + ret->post_data_len = post_data_len; + ret->headers = headers ? SysAllocString(headers) : NULL; + + ret->doc_host = doc_host; + IOleClientSite_AddRef(&doc_host->IOleClientSite_iface); + + ret->binding = NULL; + + if(post_data) { + ret->post_data = GlobalAlloc(0, post_data_len); + memcpy(ret->post_data, post_data, post_data_len); + } + + return ret; +} + +static void on_before_navigate2(DocHost *This, LPCWSTR url, SAFEARRAY *post_data, LPWSTR headers, VARIANT_BOOL *cancel) +{ + VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers; + DISPPARAMS dispparams; + VARIANTARG params[7]; + WCHAR file_path[MAX_PATH]; + DWORD file_path_len = sizeof(file_path) / sizeof(*file_path); + + dispparams.cArgs = 7; + dispparams.cNamedArgs = 0; + dispparams.rgdispidNamedArgs = NULL; + dispparams.rgvarg = params; + + This->busy = VARIANT_TRUE; + + V_VT(params) = VT_BOOL|VT_BYREF; + V_BOOLREF(params) = cancel; + + V_VT(params+1) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+1) = &var_headers; + V_VT(&var_headers) = VT_BSTR; + V_BSTR(&var_headers) = headers; + + V_VT(params+2) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+2) = &var_post_data2; + V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(&var_post_data2) = &var_post_data; + + if(post_data) { + V_VT(&var_post_data) = VT_UI1|VT_ARRAY; + V_ARRAY(&var_post_data) = post_data; + }else { + V_VT(&var_post_data) = VT_EMPTY; + } + + V_VT(params+3) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+3) = &var_frame_name; + V_VT(&var_frame_name) = VT_BSTR; + V_BSTR(&var_frame_name) = NULL; + + V_VT(params+4) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+4) = &var_flags; + V_VT(&var_flags) = VT_I4; + V_I4(&var_flags) = 0; + + V_VT(params+5) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+5) = &var_url; + V_VT(&var_url) = VT_BSTR; + if(PathCreateFromUrlW(url, file_path, &file_path_len, 0) == S_OK) + V_BSTR(&var_url) = SysAllocString(file_path); + else + V_BSTR(&var_url) = SysAllocString(url); + + V_VT(params+6) = (VT_DISPATCH); + V_DISPATCH(params+6) = (IDispatch*)This->wb; + + call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams); + + SysFreeString(V_BSTR(&var_url)); +} + +/* FIXME: urlmon should handle it */ +static BOOL try_application_url(LPCWSTR url) +{ + SHELLEXECUTEINFOW exec_info; + WCHAR app[64]; + HKEY hkey; + DWORD res, type; + HRESULT hres; + + static const WCHAR wszURLProtocol[] = {'U','R','L',' ','P','r','o','t','o','c','o','l',0}; + + hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, app, sizeof(app)/sizeof(WCHAR), NULL, 0); + if(FAILED(hres)) + return FALSE; + + res = RegOpenKeyW(HKEY_CLASSES_ROOT, app, &hkey); + if(res != ERROR_SUCCESS) + return FALSE; + + res = RegQueryValueExW(hkey, wszURLProtocol, NULL, &type, NULL, NULL); + RegCloseKey(hkey); + if(res != ERROR_SUCCESS || type != REG_SZ) + return FALSE; + + TRACE("opening application %s\n", debugstr_w(app)); + + memset(&exec_info, 0, sizeof(exec_info)); + exec_info.cbSize = sizeof(exec_info); + exec_info.lpFile = url; + exec_info.nShow = SW_SHOW; + + return ShellExecuteExW(&exec_info); +} + +static HRESULT create_moniker(LPCWSTR url, IMoniker **mon) +{ + WCHAR new_url[INTERNET_MAX_URL_LENGTH]; + DWORD size; + HRESULT hres; + + if(PathIsURLW(url)) + return CreateURLMoniker(NULL, url, mon); + + size = sizeof(new_url)/sizeof(WCHAR); + hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE); + TRACE("was %s got %s\n", debugstr_w(url), debugstr_w(new_url)); + if(FAILED(hres)) { + WARN("UrlApplyScheme failed: %08x\n", hres); + return hres; + } + + return CreateURLMoniker(NULL, new_url, mon); +} + +static HRESULT bind_to_object(DocHost *This, IMoniker *mon, LPCWSTR url, IBindCtx *bindctx, + IBindStatusCallback *callback) +{ + IUnknown *unk = NULL; + WCHAR *display_name; + HRESULT hres; + + if(mon) { + IMoniker_AddRef(mon); + }else { + hres = create_moniker(url, &mon); + if(FAILED(hres)) + return hres; + } + + hres = IMoniker_GetDisplayName(mon, 0, NULL, &display_name); + if(FAILED(hres)) { + FIXME("GetDisplayName failed: %08x\n", hres); + return hres; + } + + hres = set_dochost_url(This, display_name); + CoTaskMemFree(display_name); + if(FAILED(hres)) + return hres; + + IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, + (IUnknown*)&This->IOleClientSite_iface); + + hres = IMoniker_BindToObject(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk); + if(SUCCEEDED(hres)) { + hres = S_OK; + if(unk) + IUnknown_Release(unk); + }else if(try_application_url(url)) { + hres = S_OK; + }else { + FIXME("BindToObject failed: %08x\n", hres); + } + + IMoniker_Release(mon); + return S_OK; +} + +static void html_window_navigate(DocHost *This, IHTMLPrivateWindow *window, BSTR url, BSTR headers, SAFEARRAY *post_data) +{ + VARIANT headers_var, post_data_var; + BSTR empty_str; + HRESULT hres; + + hres = set_dochost_url(This, url); + if(FAILED(hres)) + return; + + empty_str = SysAllocStringLen(NULL, 0); + + if(headers) { + V_VT(&headers_var) = VT_BSTR; + V_BSTR(&headers_var) = headers; + }else { + V_VT(&headers_var) = VT_EMPTY; + } + + if(post_data) { + V_VT(&post_data_var) = VT_UI1|VT_ARRAY; + V_ARRAY(&post_data_var) = post_data; + }else { + V_VT(&post_data_var) = VT_EMPTY; + } + + set_doc_state(This, READYSTATE_LOADING); + hres = IHTMLPrivateWindow_SuperNavigate(window, url, empty_str, NULL, NULL, &post_data_var, &headers_var, 0); + SysFreeString(empty_str); + if(FAILED(hres)) + WARN("SuprtNavigate failed: %08x\n", hres); +} + +typedef struct { + task_header_t header; + BSTR url; + BSTR headers; + SAFEARRAY *post_data; + BOOL async_notif; +} task_doc_navigate_t; + +static void doc_navigate_task_destr(task_header_t *t) +{ + task_doc_navigate_t *task = (task_doc_navigate_t*)t; + + SysFreeString(task->url); + SysFreeString(task->headers); + if(task->post_data) + SafeArrayDestroy(task->post_data); + heap_free(task); +} + +static void doc_navigate_proc(DocHost *This, task_header_t *t) +{ + task_doc_navigate_t *task = (task_doc_navigate_t*)t; + IHTMLPrivateWindow *priv_window; + HRESULT hres; + + if(!This->doc_navigate) { + ERR("Skip nav\n"); + return; + } + + if(task->async_notif) { + VARIANT_BOOL cancel = VARIANT_FALSE; + on_before_navigate2(This, task->url, task->post_data, task->headers, &cancel); + if(cancel) { + TRACE("Navigation canceled\n"); + return; + } + } + + hres = IUnknown_QueryInterface(This->doc_navigate, &IID_IHTMLPrivateWindow, (void**)&priv_window); + if(SUCCEEDED(hres)) { + html_window_navigate(This, priv_window, task->url, task->headers, task->post_data); + IHTMLPrivateWindow_Release(priv_window); + }else { + WARN("Could not get IHTMLPrivateWindow iface: %08x\n", hres); + } +} + +static HRESULT async_doc_navigate(DocHost *This, LPCWSTR url, LPCWSTR headers, PBYTE post_data, ULONG post_data_size, + BOOL async_notif) +{ + task_doc_navigate_t *task; + + TRACE("%s\n", debugstr_w(url)); + + task = heap_alloc_zero(sizeof(*task)); + if(!task) + return E_OUTOFMEMORY; + + task->url = SysAllocString(url); + if(!task->url) { + doc_navigate_task_destr(&task->header); + return E_OUTOFMEMORY; + } + + if(headers) { + task->headers = SysAllocString(headers); + if(!task->headers) { + doc_navigate_task_destr(&task->header); + return E_OUTOFMEMORY; + } + } + + if(post_data) { + task->post_data = SafeArrayCreateVector(VT_UI1, 0, post_data_size); + if(!task->post_data) { + doc_navigate_task_destr(&task->header); + return E_OUTOFMEMORY; + } + + memcpy(task->post_data->pvData, post_data, post_data_size); + } + + if(!async_notif) { + VARIANT_BOOL cancel = VARIANT_FALSE; + + on_before_navigate2(This, task->url, task->post_data, task->headers, &cancel); + if(cancel) { + TRACE("Navigation canceled\n"); + doc_navigate_task_destr(&task->header); + return S_OK; + } + } + + task->async_notif = async_notif; + abort_dochost_tasks(This, doc_navigate_proc); + push_dochost_task(This, &task->header, doc_navigate_proc, doc_navigate_task_destr, FALSE); + return S_OK; +} + +static HRESULT navigate_bsc(DocHost *This, BindStatusCallback *bsc, IMoniker *mon) +{ + VARIANT_BOOL cancel = VARIANT_FALSE; + SAFEARRAY *post_data = NULL; + IBindCtx *bindctx; + HRESULT hres; + + set_doc_state(This, READYSTATE_LOADING); + + if(bsc->post_data) { + post_data = SafeArrayCreateVector(VT_UI1, 0, bsc->post_data_len); + memcpy(post_data->pvData, post_data, bsc->post_data_len); + } + + on_before_navigate2(This, bsc->url, post_data, bsc->headers, &cancel); + if(post_data) + SafeArrayDestroy(post_data); + if(cancel) { + FIXME("Navigation canceled\n"); + return S_OK; + } + + if(This->document) + deactivate_document(This); + + CreateAsyncBindCtx(0, &bsc->IBindStatusCallback_iface, 0, &bindctx); + + if(This->frame) + IOleInPlaceFrame_EnableModeless(This->frame, FALSE); + + hres = bind_to_object(This, mon, bsc->url, bindctx, &bsc->IBindStatusCallback_iface); + + if(This->frame) + IOleInPlaceFrame_EnableModeless(This->frame, TRUE); + + IBindCtx_Release(bindctx); + + return hres; +} + +typedef struct { + task_header_t header; + BindStatusCallback *bsc; +} task_navigate_bsc_t; + +static void navigate_bsc_task_destr(task_header_t *t) +{ + task_navigate_bsc_t *task = (task_navigate_bsc_t*)t; + + IBindStatusCallback_Release(&task->bsc->IBindStatusCallback_iface); + heap_free(task); +} + +static void navigate_bsc_proc(DocHost *This, task_header_t *t) +{ + task_navigate_bsc_t *task = (task_navigate_bsc_t*)t; + + if(!This->hwnd) + create_doc_view_hwnd(This); + + navigate_bsc(This, task->bsc, NULL); +} + + +HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags, + const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers) +{ + PBYTE post_data = NULL; + ULONG post_data_len = 0; + LPWSTR headers = NULL; + HRESULT hres = S_OK; + + TRACE("navigating to %s\n", debugstr_w(url)); + + if((Flags && V_VT(Flags) != VT_EMPTY) + || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY)) + FIXME("Unsupported args (Flags %p:%d; TargetFrameName %p:%d)\n", + Flags, Flags ? V_VT(Flags) : -1, TargetFrameName, + TargetFrameName ? V_VT(TargetFrameName) : -1); + + if(PostData && V_VT(PostData) == (VT_ARRAY | VT_UI1) && V_ARRAY(PostData)) { + SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data); + post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements; + } + + if(Headers && V_VT(Headers) == VT_BSTR) { + headers = V_BSTR(Headers); + TRACE("Headers: %s\n", debugstr_w(headers)); + } + + set_doc_state(This, READYSTATE_LOADING); + This->ready_state = READYSTATE_LOADING; + + if(This->doc_navigate) { + WCHAR new_url[INTERNET_MAX_URL_LENGTH]; + + if(PathIsURLW(url)) { + new_url[0] = 0; + }else { + DWORD size; + + size = sizeof(new_url)/sizeof(WCHAR); + hres = UrlApplySchemeW(url, new_url, &size, + URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT); + if(FAILED(hres)) { + WARN("UrlApplyScheme failed: %08x\n", hres); + new_url[0] = 0; + } + } + + hres = async_doc_navigate(This, *new_url ? new_url : url, headers, post_data, + post_data_len, TRUE); + }else { + task_navigate_bsc_t *task; + + task = heap_alloc(sizeof(*task)); + task->bsc = create_callback(This, url, post_data, post_data_len, headers); + push_dochost_task(This, &task->header, navigate_bsc_proc, navigate_bsc_task_destr, This->url == NULL); + } + + if(post_data) + SafeArrayUnaccessData(V_ARRAY(PostData)); + + return hres; +} + +static HRESULT navigate_hlink(DocHost *This, IMoniker *mon, IBindCtx *bindctx, + IBindStatusCallback *callback) +{ + IHttpNegotiate *http_negotiate; + BindStatusCallback *bsc; + PBYTE post_data = NULL; + ULONG post_data_len = 0; + LPWSTR headers = NULL, url; + BINDINFO bindinfo; + DWORD bindf = 0; + HRESULT hres; + + TRACE("\n"); + + hres = IMoniker_GetDisplayName(mon, 0, NULL, &url); + if(FAILED(hres)) + FIXME("GetDisplayName failed: %08x\n", hres); + + hres = IBindStatusCallback_QueryInterface(callback, &IID_IHttpNegotiate, + (void**)&http_negotiate); + if(SUCCEEDED(hres)) { + static const WCHAR null_string[] = {0}; + + IHttpNegotiate_BeginningTransaction(http_negotiate, null_string, null_string, 0, + &headers); + IHttpNegotiate_Release(http_negotiate); + } + + memset(&bindinfo, 0, sizeof(bindinfo)); + bindinfo.cbSize = sizeof(bindinfo); + + hres = IBindStatusCallback_GetBindInfo(callback, &bindf, &bindinfo); + dump_BINDINFO(&bindinfo); + if(bindinfo.dwBindVerb == BINDVERB_POST) { + post_data_len = bindinfo.cbstgmedData; + if(post_data_len) + post_data = bindinfo.stgmedData.u.hGlobal; + } + + if(This->doc_navigate) { + hres = async_doc_navigate(This, url, headers, post_data, post_data_len, FALSE); + }else { + bsc = create_callback(This, url, post_data, post_data_len, headers); + hres = navigate_bsc(This, bsc, mon); + IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface); + } + + CoTaskMemFree(url); + CoTaskMemFree(headers); + ReleaseBindInfo(&bindinfo); + + return hres; +} + +HRESULT go_home(DocHost *This) +{ + HKEY hkey; + DWORD res, type, size; + WCHAR wszPageName[MAX_PATH]; + static const WCHAR wszAboutBlank[] = {'a','b','o','u','t',':','b','l','a','n','k',0}; + static const WCHAR wszStartPage[] = {'S','t','a','r','t',' ','P','a','g','e',0}; + static const WCHAR wszSubKey[] = {'S','o','f','t','w','a','r','e','\\', + 'M','i','c','r','o','s','o','f','t','\\', + 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\', + 'M','a','i','n',0}; + + res = RegOpenKeyW(HKEY_CURRENT_USER, wszSubKey, &hkey); + if (res != ERROR_SUCCESS) + return navigate_url(This, wszAboutBlank, NULL, NULL, NULL, NULL); + + size = sizeof(wszPageName); + res = RegQueryValueExW(hkey, wszStartPage, NULL, &type, (LPBYTE)wszPageName, &size); + RegCloseKey(hkey); + if (res != ERROR_SUCCESS || type != REG_SZ) + return navigate_url(This, wszAboutBlank, NULL, NULL, NULL, NULL); + + return navigate_url(This, wszPageName, NULL, NULL, NULL, NULL); +} + +HRESULT go_back(DocHost *This) +{ + WCHAR *url; + HRESULT hres; + + if(!This->travellog_position) { + WARN("No history available\n"); + return E_FAIL; + } + + url = This->travellog[--This->travellog_position].url; + + if(This->doc_navigate) { + hres = async_doc_navigate(This, url, NULL, NULL, 0, FALSE); + }else { + FIXME("unsupported doc_navigate FALSE\n"); + hres = E_NOTIMPL; + } + + heap_free(url); + return hres; +} + +HRESULT get_location_url(DocHost *This, BSTR *ret) +{ + FIXME("semi-stub\n"); + + *ret = This->url ? SysAllocString(This->url) : SysAllocStringLen(NULL, 0); + if(!*ret) + return E_OUTOFMEMORY; + + return This->url ? S_OK : S_FALSE; +} + +static inline HlinkFrame *impl_from_IHlinkFrame(IHlinkFrame *iface) +{ + return CONTAINING_RECORD(iface, HlinkFrame, IHlinkFrame_iface); +} + +static HRESULT WINAPI HlinkFrame_QueryInterface(IHlinkFrame *iface, REFIID riid, void **ppv) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + return IUnknown_QueryInterface(This->outer, riid, ppv); +} + +static ULONG WINAPI HlinkFrame_AddRef(IHlinkFrame *iface) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + return IUnknown_AddRef(This->outer); +} + +static ULONG WINAPI HlinkFrame_Release(IHlinkFrame *iface) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + return IUnknown_Release(This->outer); +} + +static HRESULT WINAPI HlinkFrame_SetBrowseContext(IHlinkFrame *iface, + IHlinkBrowseContext *pihlbc) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + FIXME("(%p)->(%p)\n", This, pihlbc); + return E_NOTIMPL; +} + +static HRESULT WINAPI HlinkFrame_GetBrowseContext(IHlinkFrame *iface, + IHlinkBrowseContext **ppihlbc) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + FIXME("(%p)->(%p)\n", This, ppihlbc); + return E_NOTIMPL; +} + +static HRESULT WINAPI HlinkFrame_Navigate(IHlinkFrame *iface, DWORD grfHLNF, LPBC pbc, + IBindStatusCallback *pibsc, IHlink *pihlNavigate) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + IMoniker *mon; + LPWSTR location = NULL; + + TRACE("(%p)->(%08x %p %p %p)\n", This, grfHLNF, pbc, pibsc, pihlNavigate); + + if(grfHLNF) + FIXME("unsupported grfHLNF=%08x\n", grfHLNF); + + /* Windows calls GetTargetFrameName here. */ + + IHlink_GetMonikerReference(pihlNavigate, 1, &mon, &location); + + if(location) { + FIXME("location = %s\n", debugstr_w(location)); + CoTaskMemFree(location); + } + + /* Windows calls GetHlinkSite here */ + + if(grfHLNF & HLNF_OPENINNEWWINDOW) { + FIXME("Not supported HLNF_OPENINNEWWINDOW\n"); + return E_NOTIMPL; + } + + return navigate_hlink(This->doc_host, mon, pbc, pibsc); +} + +static HRESULT WINAPI HlinkFrame_OnNavigate(IHlinkFrame *iface, DWORD grfHLNF, + IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName, DWORD dwreserved) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + FIXME("(%p)->(%08x %p %s %s %d)\n", This, grfHLNF, pimkTarget, debugstr_w(pwzLocation), + debugstr_w(pwzFriendlyName), dwreserved); + return E_NOTIMPL; +} + +static HRESULT WINAPI HlinkFrame_UpdateHlink(IHlinkFrame *iface, ULONG uHLID, + IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName) +{ + HlinkFrame *This = impl_from_IHlinkFrame(iface); + FIXME("(%p)->(%u %p %s %s)\n", This, uHLID, pimkTarget, debugstr_w(pwzLocation), + debugstr_w(pwzFriendlyName)); + return E_NOTIMPL; +} + +static const IHlinkFrameVtbl HlinkFrameVtbl = { + HlinkFrame_QueryInterface, + HlinkFrame_AddRef, + HlinkFrame_Release, + HlinkFrame_SetBrowseContext, + HlinkFrame_GetBrowseContext, + HlinkFrame_Navigate, + HlinkFrame_OnNavigate, + HlinkFrame_UpdateHlink +}; + +static inline HlinkFrame *impl_from_ITargetFrame2(ITargetFrame2 *iface) +{ + return CONTAINING_RECORD(iface, HlinkFrame, IHlinkFrame_iface); +} + +static HRESULT WINAPI TargetFrame2_QueryInterface(ITargetFrame2 *iface, REFIID riid, void **ppv) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + return IUnknown_QueryInterface(This->outer, riid, ppv); +} + +static ULONG WINAPI TargetFrame2_AddRef(ITargetFrame2 *iface) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + return IUnknown_AddRef(This->outer); +} + +static ULONG WINAPI TargetFrame2_Release(ITargetFrame2 *iface) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + return IUnknown_Release(This->outer); +} + +static HRESULT WINAPI TargetFrame2_SetFrameName(ITargetFrame2 *iface, LPCWSTR pszFrameName) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(pszFrameName)); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_GetFrameName(ITargetFrame2 *iface, LPWSTR *ppszFrameName) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%p)\n", This, ppszFrameName); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_GetParentFrame(ITargetFrame2 *iface, IUnknown **ppunkParent) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%p)\n", This, ppunkParent); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_SetFrameSrc(ITargetFrame2 *iface, LPCWSTR pszFrameSrc) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(pszFrameSrc)); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_GetFrameSrc(ITargetFrame2 *iface, LPWSTR *ppszFrameSrc) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_GetFramesContainer(ITargetFrame2 *iface, IOleContainer **ppContainer) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%p)\n", This, ppContainer); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_SetFrameOptions(ITargetFrame2 *iface, DWORD dwFlags) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%x)\n", This, dwFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_GetFrameOptions(ITargetFrame2 *iface, DWORD *pdwFlags) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%p)\n", This, pdwFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_SetFrameMargins(ITargetFrame2 *iface, DWORD dwWidth, DWORD dwHeight) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%d %d)\n", This, dwWidth, dwHeight); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_GetFrameMargins(ITargetFrame2 *iface, DWORD *pdwWidth, DWORD *pdwHeight) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%p %p)\n", This, pdwWidth, pdwHeight); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_FindFrame(ITargetFrame2 *iface, LPCWSTR pszTargetName, DWORD dwFlags, IUnknown **ppunkTargetFrame) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%s %x %p)\n", This, debugstr_w(pszTargetName), dwFlags, ppunkTargetFrame); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFrame2_GetTargetAlias(ITargetFrame2 *iface, LPCWSTR pszTargetName, LPWSTR *ppszTargetAlias) +{ + HlinkFrame *This = impl_from_ITargetFrame2(iface); + FIXME("(%p)->(%s %p)\n", This, debugstr_w(pszTargetName), ppszTargetAlias); + return E_NOTIMPL; +} + +static const ITargetFrame2Vtbl TargetFrame2Vtbl = { + TargetFrame2_QueryInterface, + TargetFrame2_AddRef, + TargetFrame2_Release, + TargetFrame2_SetFrameName, + TargetFrame2_GetFrameName, + TargetFrame2_GetParentFrame, + TargetFrame2_SetFrameSrc, + TargetFrame2_GetFrameSrc, + TargetFrame2_GetFramesContainer, + TargetFrame2_SetFrameOptions, + TargetFrame2_GetFrameOptions, + TargetFrame2_SetFrameMargins, + TargetFrame2_GetFrameMargins, + TargetFrame2_FindFrame, + TargetFrame2_GetTargetAlias +}; + +static inline HlinkFrame *impl_from_ITargetFramePriv2(ITargetFramePriv2 *iface) +{ + return CONTAINING_RECORD(iface, HlinkFrame, ITargetFramePriv2_iface); +} + +static HRESULT WINAPI TargetFramePriv2_QueryInterface(ITargetFramePriv2 *iface, REFIID riid, void **ppv) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + return IUnknown_QueryInterface(This->outer, riid, ppv); +} + +static ULONG WINAPI TargetFramePriv2_AddRef(ITargetFramePriv2 *iface) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + return IUnknown_AddRef(This->outer); +} + +static ULONG WINAPI TargetFramePriv2_Release(ITargetFramePriv2 *iface) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + return IUnknown_Release(This->outer); +} + +static HRESULT WINAPI TargetFramePriv2_FindFrameDownwards(ITargetFramePriv2 *iface, + LPCWSTR pszTargetName, DWORD dwFlags, IUnknown **ppunkTargetFrame) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + FIXME("(%p)->(%s %x %p)\n", This, debugstr_w(pszTargetName), dwFlags, ppunkTargetFrame); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFramePriv2_FindFrameInContext(ITargetFramePriv2 *iface, + LPCWSTR pszTargetName, IUnknown *punkContextFrame, DWORD dwFlags, IUnknown **ppunkTargetFrame) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + FIXME("(%p)->(%s %p %x %p)\n", This, debugstr_w(pszTargetName), punkContextFrame, dwFlags, ppunkTargetFrame); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFramePriv2_OnChildFrameActivate(ITargetFramePriv2 *iface, IUnknown *pUnkChildFrame) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + FIXME("(%p)->(%p)\n", This, pUnkChildFrame); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFramePriv2_OnChildFrameDeactivate(ITargetFramePriv2 *iface, IUnknown *pUnkChildFrame) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + FIXME("(%p)->(%p)\n", This, pUnkChildFrame); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFramePriv2_NavigateHack(ITargetFramePriv2 *iface, DWORD grfHLNF, LPBC pbc, + IBindStatusCallback *pibsc, LPCWSTR pszTargetName, LPCWSTR pszUrl, LPCWSTR pszLocation) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + FIXME("(%p)->(%x %p %p %s %s %s)\n", This, grfHLNF, pbc, pibsc, debugstr_w(pszTargetName), + debugstr_w(pszUrl), debugstr_w(pszLocation)); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFramePriv2_FindBrowserByIndex(ITargetFramePriv2 *iface, DWORD dwID, IUnknown **ppunkBrowser) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + FIXME("(%p)->(%d %p)\n", This, dwID, ppunkBrowser); + return E_NOTIMPL; +} + +static HRESULT WINAPI TargetFramePriv2_AggregatedNavigation2(ITargetFramePriv2 *iface, DWORD grfHLNF, LPBC pbc, + IBindStatusCallback *pibsc, LPCWSTR pszTargetName, IUri *pUri, LPCWSTR pszLocation) +{ + HlinkFrame *This = impl_from_ITargetFramePriv2(iface); + IMoniker *mon; + HRESULT hres; + + TRACE("(%p)->(%x %p %p %s %p %s)\n", This, grfHLNF, pbc, pibsc, debugstr_w(pszTargetName), + pUri, debugstr_w(pszLocation)); + + /* + * NOTE: This is an undocumented function. It seems to be working the way it's implemented, + * but I couldn't get its tests working. It's used by mshtml to load content in a new + * instance of browser. + */ + + hres = CreateURLMonikerEx2(NULL, pUri, &mon, 0); + if(FAILED(hres)) + return hres; + + hres = navigate_hlink(This->doc_host, mon, pbc, pibsc); + IMoniker_Release(mon); + return hres; +} + +static const ITargetFramePriv2Vtbl TargetFramePriv2Vtbl = { + TargetFramePriv2_QueryInterface, + TargetFramePriv2_AddRef, + TargetFramePriv2_Release, + TargetFramePriv2_FindFrameDownwards, + TargetFramePriv2_FindFrameInContext, + TargetFramePriv2_OnChildFrameActivate, + TargetFramePriv2_OnChildFrameDeactivate, + TargetFramePriv2_NavigateHack, + TargetFramePriv2_FindBrowserByIndex, + TargetFramePriv2_AggregatedNavigation2 +}; + +BOOL HlinkFrame_QI(HlinkFrame *This, REFIID riid, void **ppv) +{ + if(IsEqualGUID(&IID_IHlinkFrame, riid)) { + TRACE("(%p)->(IID_IHlinkFrame %p)\n", This, ppv); + *ppv = &This->IHlinkFrame_iface; + }else if(IsEqualGUID(&IID_ITargetFrame2, riid)) { + TRACE("(%p)->(IID_ITargetFrame2 %p)\n", This, ppv); + *ppv = &This->ITargetFrame2_iface; + }else if(IsEqualGUID(&IID_ITargetFramePriv, riid)) { + TRACE("(%p)->(IID_ITargetFramePriv %p)\n", This, ppv); + *ppv = &This->ITargetFramePriv2_iface; + }else if(IsEqualGUID(&IID_ITargetFramePriv2, riid)) { + TRACE("(%p)->(IID_ITargetFramePriv2 %p)\n", This, ppv); + *ppv = &This->ITargetFramePriv2_iface; + }else { + return FALSE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return TRUE; +} + +void HlinkFrame_Init(HlinkFrame *This, IUnknown *outer, DocHost *doc_host) +{ + This->IHlinkFrame_iface.lpVtbl = &HlinkFrameVtbl; + This->ITargetFrame2_iface.lpVtbl = &TargetFrame2Vtbl; + This->ITargetFramePriv2_iface.lpVtbl = &TargetFramePriv2Vtbl; + + This->outer = outer; + This->doc_host = doc_host; +} diff --git a/reactos/dll/win32/ieframe/oleobject.c b/reactos/dll/win32/ieframe/oleobject.c new file mode 100644 index 00000000000..350a4119332 --- /dev/null +++ b/reactos/dll/win32/ieframe/oleobject.c @@ -0,0 +1,1124 @@ +/* + * Implementation of IOleObject interfaces for WebBrowser control + * + * - IOleObject + * - IOleInPlaceObject + * - IOleControl + * + * Copyright 2001 John R. Sheets (for CodeWeavers) + * Copyright 2005 Jacek Caban + * + * 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 + +#include "ieframe.h" + +//#include "htiframe.h" +#include +#include + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +/* shlwapi.dll */ +HWND WINAPI SHSetParentHwnd(HWND hWnd, HWND hWndParent); + +static ATOM shell_embedding_atom = 0; + +static LRESULT resize_window(WebBrowser *This, LONG width, LONG height) +{ + if(This->doc_host.hwnd) + SetWindowPos(This->doc_host.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) +{ + 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_window(This, LOWORD(lParam), HIWORD(lParam)); + case WM_DOCHOSTTASK: + return process_dochost_tasks(&This->doc_host); + } + + return DefWindowProcW(hwnd, msg, wParam, lParam); +} + +static void create_shell_embedding_hwnd(WebBrowser *This) +{ + IOleInPlaceSite *inplace; + HWND parent = NULL; + HRESULT hres; + + static const WCHAR wszShellEmbedding[] = + {'S','h','e','l','l',' ','E','m','b','e','d','d','i','n','g',0}; + + if(!shell_embedding_atom) { + static WNDCLASSEXW wndclass = { + sizeof(wndclass), + CS_DBLCLKS, + shell_embedding_proc, + 0, 0 /* native uses 8 */, NULL, NULL, NULL, + (HBRUSH)(COLOR_WINDOW + 1), NULL, + wszShellEmbedding, + NULL + }; + wndclass.hInstance = ieframe_instance; + + RegisterClassExW(&wndclass); + } + + hres = IOleClientSite_QueryInterface(This->client, &IID_IOleInPlaceSite, (void**)&inplace); + if(SUCCEEDED(hres)) { + IOleInPlaceSite_GetWindow(inplace, &parent); + IOleInPlaceSite_Release(inplace); + } + + This->doc_host.frame_hwnd = This->shell_embedding_hwnd = CreateWindowExW( + WS_EX_WINDOWEDGE, + wszShellEmbedding, wszShellEmbedding, + WS_CLIPSIBLINGS | WS_CLIPCHILDREN + | (parent ? WS_CHILD | WS_TABSTOP : WS_POPUP | WS_MAXIMIZEBOX), + 0, 0, 0, 0, parent, + NULL, ieframe_instance, This); + + TRACE("parent=%p hwnd=%p\n", parent, This->shell_embedding_hwnd); +} + +static HRESULT activate_inplace(WebBrowser *This, IOleClientSite *active_site) +{ + HWND parent_hwnd; + HRESULT hres; + + if(This->inplace) + return S_OK; + + if(!active_site) + return E_INVALIDARG; + + hres = IOleClientSite_QueryInterface(active_site, &IID_IOleInPlaceSite, + (void**)&This->inplace); + if(FAILED(hres)) { + WARN("Could not get IOleInPlaceSite\n"); + return hres; + } + + hres = IOleInPlaceSiteEx_CanInPlaceActivate(This->inplace); + if(hres != S_OK) { + WARN("CanInPlaceActivate returned: %08x\n", hres); + IOleInPlaceSiteEx_Release(This->inplace); + This->inplace = NULL; + return E_FAIL; + } + + hres = IOleInPlaceSiteEx_GetWindow(This->inplace, &parent_hwnd); + if(SUCCEEDED(hres)) + SHSetParentHwnd(This->shell_embedding_hwnd, parent_hwnd); + + IOleInPlaceSiteEx_OnInPlaceActivate(This->inplace); + + This->frameinfo.cb = sizeof(OLEINPLACEFRAMEINFO); + IOleInPlaceSiteEx_GetWindowContext(This->inplace, &This->doc_host.frame, &This->uiwindow, + &This->pos_rect, &This->clip_rect, + &This->frameinfo); + + 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) { + IOleContainer *container; + + IOleClientSite_ShowObject(This->client); + + hres = IOleClientSite_GetContainer(This->client, &container); + if(SUCCEEDED(hres)) { + if(This->container) + IOleContainer_Release(This->container); + This->container = container; + } + } + + if(This->doc_host.frame) + IOleInPlaceFrame_GetWindow(This->doc_host.frame, &This->frame_hwnd); + + return S_OK; +} + +static HRESULT activate_ui(WebBrowser *This, IOleClientSite *active_site) +{ + HRESULT hres; + + static const WCHAR wszitem[] = {'i','t','e','m',0}; + + if(This->inplace) + { + if(This->shell_embedding_hwnd) + ShowWindow(This->shell_embedding_hwnd, SW_SHOW); + return S_OK; + } + + hres = activate_inplace(This, active_site); + if(FAILED(hres)) + return hres; + + IOleInPlaceSiteEx_OnUIActivate(This->inplace); + + if(This->doc_host.frame) + IOleInPlaceFrame_SetActiveObject(This->doc_host.frame, &This->IOleInPlaceActiveObject_iface, wszitem); + if(This->uiwindow) + IOleInPlaceUIWindow_SetActiveObject(This->uiwindow, &This->IOleInPlaceActiveObject_iface, wszitem); + + if(This->doc_host.frame) + IOleInPlaceFrame_SetMenu(This->doc_host.frame, NULL, NULL, This->shell_embedding_hwnd); + + SetFocus(This->shell_embedding_hwnd); + + return S_OK; +} + +static HRESULT get_client_disp_property(IOleClientSite *client, DISPID dispid, VARIANT *res) +{ + IDispatch *disp = NULL; + DISPPARAMS dispparams = {NULL, 0}; + HRESULT hres; + + VariantInit(res); + + if(!client) + return S_OK; + + hres = IOleClientSite_QueryInterface(client, &IID_IDispatch, (void**)&disp); + if(FAILED(hres)) { + TRACE("Could not get IDispatch\n"); + return hres; + } + + hres = IDispatch_Invoke(disp, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT, + DISPATCH_PROPERTYGET, &dispparams, res, NULL, NULL); + + IDispatch_Release(disp); + + return hres; +} + +static HRESULT on_offlineconnected_change(WebBrowser *This) +{ + VARIANT offline; + + get_client_disp_property(This->client, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &offline); + + if(V_VT(&offline) == VT_BOOL) + IWebBrowser2_put_Offline(&This->IWebBrowser2_iface, V_BOOL(&offline)); + else if(V_VT(&offline) != VT_EMPTY) + WARN("wrong V_VT(silent) %d\n", V_VT(&offline)); + + return S_OK; +} + +static HRESULT on_silent_change(WebBrowser *This) +{ + VARIANT silent; + + get_client_disp_property(This->client, DISPID_AMBIENT_SILENT, &silent); + + if(V_VT(&silent) == VT_BOOL) + IWebBrowser2_put_Silent(&This->IWebBrowser2_iface, V_BOOL(&silent)); + else if(V_VT(&silent) != VT_EMPTY) + WARN("wrong V_VT(silent) %d\n", V_VT(&silent)); + + return S_OK; +} + +static void release_client_site(WebBrowser *This) +{ + release_dochost_client(&This->doc_host); + + if(This->shell_embedding_hwnd) { + DestroyWindow(This->shell_embedding_hwnd); + This->shell_embedding_hwnd = NULL; + } + + if(This->inplace) { + IOleInPlaceSiteEx_Release(This->inplace); + This->inplace = NULL; + } + + if(This->container) { + IOleContainer_Release(This->container); + This->container = NULL; + } + + if(This->uiwindow) { + IOleInPlaceUIWindow_Release(This->uiwindow); + This->uiwindow = NULL; + } + + if(This->client) { + IOleClientSite_Release(This->client); + This->client = NULL; + } +} + +typedef struct { + IEnumOLEVERB IEnumOLEVERB_iface; + + LONG ref; +} EnumOLEVERB; + +static inline EnumOLEVERB *impl_from_IEnumOLEVERB(IEnumOLEVERB *iface) +{ + return CONTAINING_RECORD(iface, EnumOLEVERB, IEnumOLEVERB_iface); +} + +static HRESULT WINAPI EnumOLEVERB_QueryInterface(IEnumOLEVERB *iface, REFIID riid, void **ppv) +{ + EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IEnumOLEVERB_iface; + }else if(IsEqualGUID(&IID_IEnumOLEVERB, riid)) { + TRACE("(%p)->(IID_IEnumOLEVERB %p)\n", This, ppv); + *ppv = &This->IEnumOLEVERB_iface; + }else { + WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); + *ppv = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI EnumOLEVERB_AddRef(IEnumOLEVERB *iface) +{ + EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface); + LONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + return ref; +} + +static ULONG WINAPI EnumOLEVERB_Release(IEnumOLEVERB *iface) +{ + EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) + heap_free(This); + + return ref; +} + +static HRESULT WINAPI EnumOLEVERB_Next(IEnumOLEVERB *iface, ULONG celt, OLEVERB *rgelt, ULONG *pceltFetched) +{ + EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface); + + TRACE("(%p)->(%u %p %p)\n", This, celt, rgelt, pceltFetched); + + if(pceltFetched) + *pceltFetched = 0; + return S_OK; +} + +static HRESULT WINAPI EnumOLEVERB_Skip(IEnumOLEVERB *iface, ULONG celt) +{ + EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface); + TRACE("(%p)->(%u)\n", This, celt); + return S_OK; +} + +static HRESULT WINAPI EnumOLEVERB_Reset(IEnumOLEVERB *iface) +{ + EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface); + TRACE("(%p)\n", This); + return S_OK; +} + +static HRESULT WINAPI EnumOLEVERB_Clone(IEnumOLEVERB *iface, IEnumOLEVERB **ppenum) +{ + EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface); + FIXME("(%p)->(%p)\n", This, ppenum); + return E_NOTIMPL; +} + +static const IEnumOLEVERBVtbl EnumOLEVERBVtbl = { + EnumOLEVERB_QueryInterface, + EnumOLEVERB_AddRef, + EnumOLEVERB_Release, + EnumOLEVERB_Next, + EnumOLEVERB_Skip, + EnumOLEVERB_Reset, + EnumOLEVERB_Clone +}; + +/********************************************************************** + * Implement the IOleObject interface for the WebBrowser control + */ + +static inline WebBrowser *impl_from_IOleObject(IOleObject *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IOleObject_iface); +} + +static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv) +{ + WebBrowser *This = impl_from_IOleObject(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppv); +} + +static ULONG WINAPI OleObject_AddRef(IOleObject *iface) +{ + WebBrowser *This = impl_from_IOleObject(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI OleObject_Release(IOleObject *iface) +{ + WebBrowser *This = impl_from_IOleObject(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, LPOLECLIENTSITE pClientSite) +{ + WebBrowser *This = impl_from_IOleObject(iface); + IDocHostUIHandler *hostui; + IOleContainer *container; + IDispatch *disp; + HRESULT hres; + + TRACE("(%p)->(%p)\n", This, pClientSite); + + if(This->client == pClientSite) + return S_OK; + + release_client_site(This); + + if(!pClientSite) { + if(This->doc_host.document) + deactivate_document(&This->doc_host); + return S_OK; + } + + IOleClientSite_AddRef(pClientSite); + This->client = pClientSite; + + hres = IOleClientSite_QueryInterface(This->client, &IID_IDispatch, + (void**)&disp); + if(SUCCEEDED(hres)) + This->doc_host.client_disp = disp; + + hres = IOleClientSite_QueryInterface(This->client, &IID_IDocHostUIHandler, + (void**)&hostui); + if(SUCCEEDED(hres)) + This->doc_host.hostui = hostui; + + hres = IOleClientSite_GetContainer(This->client, &container); + if(SUCCEEDED(hres)) { + ITargetContainer *target_container; + + hres = IOleContainer_QueryInterface(container, &IID_ITargetContainer, + (void**)&target_container); + if(SUCCEEDED(hres)) { + FIXME("Unsupported ITargetContainer\n"); + ITargetContainer_Release(target_container); + } + + IOleContainer_Release(container); + } + + create_shell_embedding_hwnd(This); + + on_offlineconnected_change(This); + on_silent_change(This); + + return S_OK; +} + +static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, LPOLECLIENTSITE *ppClientSite) +{ + WebBrowser *This = impl_from_IOleObject(iface); + + TRACE("(%p)->(%p)\n", This, ppClientSite); + + if(!ppClientSite) + return E_INVALIDARG; + + if(This->client) + IOleClientSite_AddRef(This->client); + *ppClientSite = This->client; + + return S_OK; +} + +static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, + LPCOLESTR szContainerObj) +{ + WebBrowser *This = impl_from_IOleObject(iface); + + TRACE("(%p)->(%s, %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj)); + + /* We have nothing to do here. */ + return S_OK; +} + +static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption) +{ + WebBrowser *This = impl_from_IOleObject(iface); + + TRACE("(%p)->(%d)\n", This, dwSaveOption); + + if(dwSaveOption != OLECLOSE_NOSAVE) { + FIXME("unimplemented flag: %x\n", dwSaveOption); + return E_NOTIMPL; + } + + if(This->doc_host.frame) + IOleInPlaceFrame_SetActiveObject(This->doc_host.frame, NULL, NULL); + + if(This->uiwindow) + IOleInPlaceUIWindow_SetActiveObject(This->uiwindow, NULL, NULL); + + if(This->inplace) { + IOleInPlaceSiteEx_OnUIDeactivate(This->inplace, FALSE); + IOleInPlaceSiteEx_OnInPlaceDeactivate(This->inplace); + } + + return IOleObject_SetClientSite(iface, NULL); +} + +static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker* pmk) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%d, %p)\n", This, dwWhichMoniker, pmk); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, + DWORD dwWhichMoniker, LPMONIKER *ppmk) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%d, %d, %p)\n", This, dwAssign, dwWhichMoniker, ppmk); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, LPDATAOBJECT pDataObject, + BOOL fCreation, DWORD dwReserved) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%p, %d, %d)\n", This, pDataObject, fCreation, dwReserved); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, + LPDATAOBJECT *ppDataObject) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%d, %p)\n", This, dwReserved, ppDataObject); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, struct tagMSG* lpmsg, + LPOLECLIENTSITE pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect) +{ + WebBrowser *This = impl_from_IOleObject(iface); + + TRACE("(%p)->(%d %p %p %d %p %s)\n", This, iVerb, lpmsg, pActiveSite, lindex, hwndParent, + wine_dbgstr_rect(lprcPosRect)); + + switch (iVerb) + { + case OLEIVERB_SHOW: + TRACE("OLEIVERB_SHOW\n"); + return activate_ui(This, pActiveSite); + case OLEIVERB_UIACTIVATE: + TRACE("OLEIVERB_UIACTIVATE\n"); + return activate_ui(This, pActiveSite); + case OLEIVERB_INPLACEACTIVATE: + TRACE("OLEIVERB_INPLACEACTIVATE\n"); + return activate_inplace(This, pActiveSite); + case OLEIVERB_HIDE: + TRACE("OLEIVERB_HIDE\n"); + if(This->inplace) + IOleInPlaceSiteEx_OnInPlaceDeactivate(This->inplace); + if(This->shell_embedding_hwnd) + ShowWindow(This->shell_embedding_hwnd, SW_HIDE); + return S_OK; + default: + FIXME("stub for %d\n", iVerb); + break; + } + + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb) +{ + WebBrowser *This = impl_from_IOleObject(iface); + EnumOLEVERB *ret; + + TRACE("(%p)->(%p)\n", This, ppEnumOleVerb); + + ret = heap_alloc(sizeof(*ret)); + if(!ret) + return E_OUTOFMEMORY; + + ret->IEnumOLEVERB_iface.lpVtbl = &EnumOLEVERBVtbl; + ret->ref = 1; + + *ppEnumOleVerb = &ret->IEnumOLEVERB_iface; + return S_OK; +} + +static HRESULT WINAPI OleObject_Update(IOleObject *iface) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID* pClsid) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%p)\n", This, pClsid); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, + LPOLESTR* pszUserType) +{ + WebBrowser *This = impl_from_IOleObject(iface); + TRACE("(%p, %d, %p)\n", This, dwFormOfType, pszUserType); + return OleRegGetUserType(&CLSID_WebBrowser, dwFormOfType, pszUserType); +} + +static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel) +{ + WebBrowser *This = impl_from_IOleObject(iface); + + TRACE("(%p)->(%x %p)\n", This, dwDrawAspect, psizel); + + /* Tests show that dwDrawAspect is ignored */ + This->extent = *psizel; + return S_OK; +} + +static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel) +{ + WebBrowser *This = impl_from_IOleObject(iface); + + TRACE("(%p)->(%x, %p)\n", This, dwDrawAspect, psizel); + + /* Tests show that dwDrawAspect is ignored */ + *psizel = This->extent; + return S_OK; +} + +static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, + DWORD* pdwConnection) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%p, %p)\n", This, pAdvSink, pdwConnection); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%d)\n", This, dwConnection); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%p)\n", This, ppenumAdvise); + return S_OK; +} + +static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus) +{ + WebBrowser *This = impl_from_IOleObject(iface); + + TRACE("(%p)->(%x, %p)\n", This, dwAspect, pdwStatus); + + *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT + |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE; + + return S_OK; +} + +static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE* pLogpal) +{ + WebBrowser *This = impl_from_IOleObject(iface); + FIXME("(%p)->(%p)\n", This, pLogpal); + return E_NOTIMPL; +} + +static const IOleObjectVtbl OleObjectVtbl = +{ + OleObject_QueryInterface, + OleObject_AddRef, + OleObject_Release, + OleObject_SetClientSite, + OleObject_GetClientSite, + OleObject_SetHostNames, + OleObject_Close, + OleObject_SetMoniker, + OleObject_GetMoniker, + OleObject_InitFromData, + OleObject_GetClipboardData, + OleObject_DoVerb, + OleObject_EnumVerbs, + OleObject_Update, + OleObject_IsUpToDate, + OleObject_GetUserClassID, + OleObject_GetUserType, + OleObject_SetExtent, + OleObject_GetExtent, + OleObject_Advise, + OleObject_Unadvise, + OleObject_EnumAdvise, + OleObject_GetMiscStatus, + OleObject_SetColorScheme +}; + +/********************************************************************** + * Implement the IOleInPlaceObject interface + */ + +static inline WebBrowser *impl_from_IOleInPlaceObject(IOleInPlaceObject *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IOleInPlaceObject_iface); +} + +static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObject *iface, + REFIID riid, LPVOID *ppobj) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppobj); +} + +static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObject *iface) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObject *iface) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObject *iface, HWND* phwnd) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + + TRACE("(%p)->(%p)\n", This, phwnd); + + *phwnd = This->shell_embedding_hwnd; + return S_OK; +} + +static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObject *iface, + BOOL fEnterMode) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + FIXME("(%p)->(%x)\n", This, fEnterMode); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObject *iface) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + FIXME("(%p)\n", This); + + if(This->inplace) { + IOleInPlaceSiteEx_Release(This->inplace); + This->inplace = NULL; + } + + return S_OK; +} + +static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObject *iface) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObject *iface, + LPCRECT lprcPosRect, LPCRECT lprcClipRect) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + + TRACE("(%p)->(%p %p)\n", This, lprcPosRect, lprcClipRect); + + This->pos_rect = *lprcPosRect; + + if(lprcClipRect) + This->clip_rect = *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) +{ + WebBrowser *This = impl_from_IOleInPlaceObject(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static const IOleInPlaceObjectVtbl OleInPlaceObjectVtbl = +{ + OleInPlaceObject_QueryInterface, + OleInPlaceObject_AddRef, + OleInPlaceObject_Release, + OleInPlaceObject_GetWindow, + OleInPlaceObject_ContextSensitiveHelp, + OleInPlaceObject_InPlaceDeactivate, + OleInPlaceObject_UIDeactivate, + OleInPlaceObject_SetObjectRects, + OleInPlaceObject_ReactivateAndUndo +}; + +/********************************************************************** + * Implement the IOleControl interface + */ + +static inline WebBrowser *impl_from_IOleControl(IOleControl *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IOleControl_iface); +} + +static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, + REFIID riid, LPVOID *ppobj) +{ + WebBrowser *This = impl_from_IOleControl(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppobj); +} + +static ULONG WINAPI OleControl_AddRef(IOleControl *iface) +{ + WebBrowser *This = impl_from_IOleControl(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI OleControl_Release(IOleControl *iface) +{ + WebBrowser *This = impl_from_IOleControl(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, LPCONTROLINFO pCI) +{ + WebBrowser *This = impl_from_IOleControl(iface); + + TRACE("(%p)->(%p)\n", This, pCI); + + /* Tests show that this function should be not implemented */ + return E_NOTIMPL; +} + +static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, struct tagMSG *pMsg) +{ + WebBrowser *This = impl_from_IOleControl(iface); + FIXME("(%p)->(%p)\n", This, pMsg); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID) +{ + WebBrowser *This = impl_from_IOleControl(iface); + + TRACE("(%p)->(%d)\n", This, dispID); + + switch(dispID) { + case DISPID_UNKNOWN: + /* Unknown means multiple properties changed, so check them all. + * BUT the Webbrowser OleControl object doesn't appear to do this. + */ + return S_OK; + case DISPID_AMBIENT_DLCONTROL: + return S_OK; + case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED: + return on_offlineconnected_change(This); + case DISPID_AMBIENT_SILENT: + return on_silent_change(This); + } + + FIXME("Unknown dispID %d\n", dispID); + return E_NOTIMPL; +} + +static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze) +{ + WebBrowser *This = impl_from_IOleControl(iface); + FIXME("(%p)->(%x)\n", This, bFreeze); + return E_NOTIMPL; +} + +static const IOleControlVtbl OleControlVtbl = +{ + OleControl_QueryInterface, + OleControl_AddRef, + OleControl_Release, + OleControl_GetControlInfo, + OleControl_OnMnemonic, + OleControl_OnAmbientPropertyChange, + OleControl_FreezeEvents +}; + +static inline WebBrowser *impl_from_IOleInPlaceActiveObject(IOleInPlaceActiveObject *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IOleInPlaceActiveObject_iface); +} + +static HRESULT WINAPI InPlaceActiveObject_QueryInterface(IOleInPlaceActiveObject *iface, + REFIID riid, void **ppv) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppv); +} + +static ULONG WINAPI InPlaceActiveObject_AddRef(IOleInPlaceActiveObject *iface) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI InPlaceActiveObject_Release(IOleInPlaceActiveObject *iface) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI InPlaceActiveObject_GetWindow(IOleInPlaceActiveObject *iface, + HWND *phwnd) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(iface); + return IOleInPlaceObject_GetWindow(&This->IOleInPlaceObject_iface, phwnd); +} + +static HRESULT WINAPI InPlaceActiveObject_ContextSensitiveHelp(IOleInPlaceActiveObject *iface, + BOOL fEnterMode) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(iface); + return IOleInPlaceObject_ContextSensitiveHelp(&This->IOleInPlaceObject_iface, fEnterMode); +} + +static HRESULT WINAPI InPlaceActiveObject_TranslateAccelerator(IOleInPlaceActiveObject *iface, + LPMSG lpmsg) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(iface); + IOleInPlaceActiveObject *activeobj; + HRESULT hr = S_FALSE; + + TRACE("(%p)->(%p)\n", This, lpmsg); + + if(This->doc_host.document) { + if(SUCCEEDED(IUnknown_QueryInterface(This->doc_host.document, + &IID_IOleInPlaceActiveObject, + (void**)&activeobj))) { + hr = IOleInPlaceActiveObject_TranslateAccelerator(activeobj, lpmsg); + IOleInPlaceActiveObject_Release(activeobj); + } + } + + if(SUCCEEDED(hr)) + return hr; + else + return S_FALSE; +} + +static HRESULT WINAPI InPlaceActiveObject_OnFrameWindowActivate(IOleInPlaceActiveObject *iface, + BOOL fActivate) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(iface); + FIXME("(%p)->(%x)\n", This, fActivate); + return E_NOTIMPL; +} + +static HRESULT WINAPI InPlaceActiveObject_OnDocWindowActivate(IOleInPlaceActiveObject *iface, + BOOL fActivate) +{ + WebBrowser *This = impl_from_IOleInPlaceActiveObject(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 = impl_from_IOleInPlaceActiveObject(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 = impl_from_IOleInPlaceActiveObject(iface); + FIXME("(%p)->(%x)\n", This, fEnable); + return E_NOTIMPL; +} + +static const IOleInPlaceActiveObjectVtbl OleInPlaceActiveObjectVtbl = { + InPlaceActiveObject_QueryInterface, + InPlaceActiveObject_AddRef, + InPlaceActiveObject_Release, + InPlaceActiveObject_GetWindow, + InPlaceActiveObject_ContextSensitiveHelp, + InPlaceActiveObject_TranslateAccelerator, + InPlaceActiveObject_OnFrameWindowActivate, + InPlaceActiveObject_OnDocWindowActivate, + InPlaceActiveObject_ResizeBorder, + InPlaceActiveObject_EnableModeless +}; + +static inline WebBrowser *impl_from_IOleCommandTarget(IOleCommandTarget *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IOleCommandTarget_iface); +} + +static HRESULT WINAPI WBOleCommandTarget_QueryInterface(IOleCommandTarget *iface, + REFIID riid, void **ppv) +{ + WebBrowser *This = impl_from_IOleCommandTarget(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppv); +} + +static ULONG WINAPI WBOleCommandTarget_AddRef(IOleCommandTarget *iface) +{ + WebBrowser *This = impl_from_IOleCommandTarget(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI WBOleCommandTarget_Release(IOleCommandTarget *iface) +{ + WebBrowser *This = impl_from_IOleCommandTarget(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI WBOleCommandTarget_QueryStatus(IOleCommandTarget *iface, + const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText) +{ + WebBrowser *This = impl_from_IOleCommandTarget(iface); + IOleCommandTarget *cmdtrg; + HRESULT hres; + + TRACE("(%p)->(%s %u %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, + pCmdText); + + if(!This->doc_host.document) + return 0x80040104; + + /* NOTE: There are probably some commands that we should handle here + * instead of forwarding to document object. */ + + hres = IUnknown_QueryInterface(This->doc_host.document, &IID_IOleCommandTarget, (void**)&cmdtrg); + if(FAILED(hres)) + return hres; + + hres = IOleCommandTarget_QueryStatus(cmdtrg, pguidCmdGroup, cCmds, prgCmds, pCmdText); + IOleCommandTarget_Release(cmdtrg); + + return hres; +} + +static HRESULT WINAPI WBOleCommandTarget_Exec(IOleCommandTarget *iface, + const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, + VARIANT *pvaOut) +{ + WebBrowser *This = impl_from_IOleCommandTarget(iface); + FIXME("(%p)->(%s %d %d %p %p)\n", This, debugstr_guid(pguidCmdGroup), nCmdID, + nCmdexecopt, pvaIn, pvaOut); + return E_NOTIMPL; +} + +static const IOleCommandTargetVtbl OleCommandTargetVtbl = { + WBOleCommandTarget_QueryInterface, + WBOleCommandTarget_AddRef, + WBOleCommandTarget_Release, + WBOleCommandTarget_QueryStatus, + WBOleCommandTarget_Exec +}; + +void WebBrowser_OleObject_Init(WebBrowser *This) +{ + DWORD dpi_x; + DWORD dpi_y; + HDC hdc; + + /* default aspect ratio is 96dpi / 96dpi */ + hdc = GetDC(0); + dpi_x = GetDeviceCaps(hdc, LOGPIXELSX); + dpi_y = GetDeviceCaps(hdc, LOGPIXELSY); + ReleaseDC(0, hdc); + + This->IOleObject_iface.lpVtbl = &OleObjectVtbl; + This->IOleInPlaceObject_iface.lpVtbl = &OleInPlaceObjectVtbl; + This->IOleControl_iface.lpVtbl = &OleControlVtbl; + This->IOleInPlaceActiveObject_iface.lpVtbl = &OleInPlaceActiveObjectVtbl; + This->IOleCommandTarget_iface.lpVtbl = &OleCommandTargetVtbl; + + /* Default size is 50x20 pixels, in himetric units */ + This->extent.cx = MulDiv( 50, 2540, dpi_x ); + This->extent.cy = MulDiv( 20, 2540, dpi_y ); +} + +void WebBrowser_OleObject_Destroy(WebBrowser *This) +{ + release_client_site(This); +} diff --git a/reactos/dll/win32/ieframe/persist.c b/reactos/dll/win32/ieframe/persist.c new file mode 100644 index 00000000000..037df915c52 --- /dev/null +++ b/reactos/dll/win32/ieframe/persist.c @@ -0,0 +1,284 @@ +/* + * Implementation of IPersist interfaces for WebBrowser control + * + * Copyright 2001 John R. Sheets (for CodeWeavers) + * Copyright 2005 Jacek Caban + * + * 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 "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +/********************************************************************** + * Implement the IPersistStorage interface + */ + +static inline WebBrowser *impl_from_IPersistStorage(IPersistStorage *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IPersistStorage_iface); +} + +static HRESULT WINAPI PersistStorage_QueryInterface(IPersistStorage *iface, + REFIID riid, LPVOID *ppobj) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppobj); +} + +static ULONG WINAPI PersistStorage_AddRef(IPersistStorage *iface) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI PersistStorage_Release(IPersistStorage *iface) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI PersistStorage_GetClassID(IPersistStorage *iface, CLSID *pClassID) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + FIXME("(%p)->(%p)\n", This, pClassID); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistStorage_IsDirty(IPersistStorage *iface) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistStorage_InitNew(IPersistStorage *iface, LPSTORAGE pStg) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + FIXME("(%p)->(%p)\n", This, pStg); + return S_OK; +} + +static HRESULT WINAPI PersistStorage_Load(IPersistStorage *iface, LPSTORAGE pStg) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + FIXME("(%p)->(%p)\n", This, pStg); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistStorage_Save(IPersistStorage *iface, LPSTORAGE pStg, + BOOL fSameAsLoad) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + FIXME("(%p)->(%p %x)\n", This, pStg, fSameAsLoad); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistStorage_SaveCompleted(IPersistStorage *iface, LPSTORAGE pStgNew) +{ + WebBrowser *This = impl_from_IPersistStorage(iface); + FIXME("(%p)->(%p)\n", This, pStgNew); + return E_NOTIMPL; +} + +static const IPersistStorageVtbl PersistStorageVtbl = +{ + PersistStorage_QueryInterface, + PersistStorage_AddRef, + PersistStorage_Release, + PersistStorage_GetClassID, + PersistStorage_IsDirty, + PersistStorage_InitNew, + PersistStorage_Load, + PersistStorage_Save, + PersistStorage_SaveCompleted +}; + +/********************************************************************** + * Implement the IPersistMemory interface + */ + +static inline WebBrowser *impl_from_IPersistMemory(IPersistMemory *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IPersistMemory_iface); +} + +static HRESULT WINAPI PersistMemory_QueryInterface(IPersistMemory *iface, + REFIID riid, LPVOID *ppobj) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppobj); +} + +static ULONG WINAPI PersistMemory_AddRef(IPersistMemory *iface) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI PersistMemory_Release(IPersistMemory *iface) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI PersistMemory_GetClassID(IPersistMemory *iface, CLSID *pClassID) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + FIXME("(%p)->(%p)\n", This, pClassID); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistMemory_IsDirty(IPersistMemory *iface) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistMemory_InitNew(IPersistMemory *iface) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + FIXME("(%p)\n", This); + return S_OK; +} + +static HRESULT WINAPI PersistMemory_Load(IPersistMemory *iface, LPVOID pMem, ULONG cbSize) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + FIXME("(%p)->(%p %x)\n", This, pMem, cbSize); + return S_OK; +} + +static HRESULT WINAPI PersistMemory_Save(IPersistMemory *iface, LPVOID pMem, + BOOL fClearDirty, ULONG cbSize) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + FIXME("(%p)->(%p %x %x)\n", This, pMem, fClearDirty, cbSize); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistMemory_GetSizeMax(IPersistMemory *iface, ULONG *pCbSize) +{ + WebBrowser *This = impl_from_IPersistMemory(iface); + FIXME("(%p)->(%p)\n", This, pCbSize); + return E_NOTIMPL; +} + +static const IPersistMemoryVtbl PersistMemoryVtbl = +{ + PersistMemory_QueryInterface, + PersistMemory_AddRef, + PersistMemory_Release, + PersistMemory_GetClassID, + PersistMemory_IsDirty, + PersistMemory_Load, + PersistMemory_Save, + PersistMemory_GetSizeMax, + PersistMemory_InitNew +}; + +/********************************************************************** + * Implement the IPersistStreamInit interface + */ + +static inline WebBrowser *impl_from_IPersistStreamInit(IPersistStreamInit *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IPersistStreamInit_iface); +} + +static HRESULT WINAPI PersistStreamInit_QueryInterface(IPersistStreamInit *iface, + REFIID riid, LPVOID *ppobj) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppobj); +} + +static ULONG WINAPI PersistStreamInit_AddRef(IPersistStreamInit *iface) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI PersistStreamInit_Release(IPersistStreamInit *iface) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI PersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + return IPersistStorage_GetClassID(&This->IPersistStorage_iface, pClassID); +} + +static HRESULT WINAPI PersistStreamInit_IsDirty(IPersistStreamInit *iface) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + return IPersistStorage_IsDirty(&This->IPersistStorage_iface); +} + +static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStg) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + FIXME("(%p)->(%p)\n", This, pStg); + return S_OK; +} + +static HRESULT WINAPI PersistStreamInit_Save(IPersistStreamInit *iface, LPSTREAM pStg, + BOOL fSameAsLoad) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + FIXME("(%p)->(%p %x)\n", This, pStg, fSameAsLoad); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistStreamInit_GetSizeMax(IPersistStreamInit *iface, + ULARGE_INTEGER *pcbSize) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + FIXME("(%p)->(%p)\n", This, pcbSize); + return E_NOTIMPL; +} + +static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface) +{ + WebBrowser *This = impl_from_IPersistStreamInit(iface); + FIXME("(%p)\n", This); + return S_OK; +} + +static const IPersistStreamInitVtbl PersistStreamInitVtbl = +{ + PersistStreamInit_QueryInterface, + PersistStreamInit_AddRef, + PersistStreamInit_Release, + PersistStreamInit_GetClassID, + PersistStreamInit_IsDirty, + PersistStreamInit_Load, + PersistStreamInit_Save, + PersistStreamInit_GetSizeMax, + PersistStreamInit_InitNew +}; + +void WebBrowser_Persist_Init(WebBrowser *This) +{ + This->IPersistStorage_iface.lpVtbl = &PersistStorageVtbl; + This->IPersistMemory_iface.lpVtbl = &PersistMemoryVtbl; + This->IPersistStreamInit_iface.lpVtbl = &PersistStreamInitVtbl; +} diff --git a/reactos/dll/win32/ieframe/resource.h b/reactos/dll/win32/ieframe/resource.h new file mode 100644 index 00000000000..ae02b20b6b4 --- /dev/null +++ b/reactos/dll/win32/ieframe/resource.h @@ -0,0 +1,73 @@ +/* + * Resource identifiers for ieframe.dll + * + * Copyright 2010 Alexander N. Sørnes + * + * 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 +#include + +#define IDR_BROWSE_MAIN_MENU 1000 +#define IDD_BROWSE_OPEN 1001 +#define IDC_BROWSE_OPEN_URL 1002 +#define IDC_BROWSE_REBAR 1003 +#define IDC_BROWSE_ADDRESSBAR 1004 +#define IDC_BROWSE_STATUSBAR 1005 +#define IDC_BROWSE_TOOLBAR 1006 + +#define ID_BROWSE_NEW_WINDOW 275 +#define ID_BROWSE_OPEN 256 +#define ID_BROWSE_SAVE 257 +#define ID_BROWSE_SAVE_AS 258 +#define ID_BROWSE_PRINT_FORMAT 259 +#define ID_BROWSE_PRINT 260 +#define ID_BROWSE_PRINT_PREVIEW 277 +#define ID_BROWSE_PROPERTIES 262 +#define ID_BROWSE_QUIT 278 +#define ID_BROWSE_ABOUT 336 + +#define ID_BROWSE_ADDFAV 1200 +#define ID_BROWSE_HOME 1201 +#define ID_BROWSE_BACK 1202 +#define ID_BROWSE_FORWARD 1203 +#define ID_BROWSE_STOP 1204 +#define ID_BROWSE_REFRESH 1205 + +#define ID_BROWSE_BAR_STD 1300 +#define ID_BROWSE_BAR_ADDR 1301 + +#define ID_BROWSE_GOTOFAV_FIRST 2000 +#define ID_BROWSE_GOTOFAV_MAX 65000 + +#define IDS_TB_BACK 1100 +#define IDS_TB_FORWARD 1101 +#define IDS_TB_STOP 1102 +#define IDS_TB_REFRESH 1103 +#define IDS_TB_HOME 1104 +#define IDS_TB_PRINT 1105 + +#define IDS_ADDRESS 1106 + +#define IDB_IETOOLBAR 1400 + +/* update status text in BINDSTATUS_* callback */ +#define IDS_STATUSFMT_FIRST 4096 +#define IDS_FINDINGRESOURCE (IDS_STATUSFMT_FIRST + 1) +#define IDS_BEGINDOWNLOADDATA (IDS_STATUSFMT_FIRST + 4) +#define IDS_ENDDOWNLOADDATA (IDS_STATUSFMT_FIRST + 6) +#define IDS_SENDINGREQUEST (IDS_STATUSFMT_FIRST + 11) +#define IDS_STATUSFMT_MAXLEN 256 diff --git a/reactos/dll/win32/ieframe/shellbrowser.c b/reactos/dll/win32/ieframe/shellbrowser.c new file mode 100644 index 00000000000..6fdab426a31 --- /dev/null +++ b/reactos/dll/win32/ieframe/shellbrowser.c @@ -0,0 +1,982 @@ +/* + * Implementation of IShellBrowser interface + * + * Copyright 2011 Piotr Caban for CodeWeavers + * Copyright 2012 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 + +#include "ieframe.h" +#include + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static inline ShellBrowser *impl_from_IShellBrowser(IShellBrowser *iface) +{ + return CONTAINING_RECORD(iface, ShellBrowser, IShellBrowser_iface); +} + +static HRESULT WINAPI ShellBrowser_QueryInterface(IShellBrowser* iface, REFIID riid, void **ppv) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IShellBrowser_iface; + }else if(IsEqualGUID(&IID_IOleWindow, riid)) { + TRACE("(%p)->(IID_IOleWindow %p)\n", This, ppv); + *ppv = &This->IShellBrowser_iface; + }else if(IsEqualGUID(&IID_IShellBrowser, riid)) { + TRACE("(%p)->(IID_IShellBrowser %p)\n", This, ppv); + *ppv = &This->IShellBrowser_iface; + }else if(IsEqualGUID(&IID_IBrowserService, riid)) { + TRACE("(%p)->(IID_IBrowserService %p)\n", This, ppv); + *ppv = &This->IBrowserService_iface; + }else if(IsEqualGUID(&IID_IDocObjectService, riid)) { + TRACE("(%p)->(IID_IDocObjectService %p)\n", This, ppv); + *ppv = &This->IDocObjectService_iface; + }else { + FIXME("%p %s %p\n", This, debugstr_guid(riid), ppv); + *ppv = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI ShellBrowser_AddRef( + IShellBrowser* iface) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + LONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + return ref; +} + +static ULONG WINAPI ShellBrowser_Release(IShellBrowser* iface) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) { + assert(!This->doc_host); + heap_free(This); + } + + return ref; +} + +static HRESULT WINAPI ShellBrowser_GetWindow( + IShellBrowser* iface, + HWND *phwnd) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p\n", This, phwnd); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_ContextSensitiveHelp( + IShellBrowser* iface, + BOOL fEnterMode) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %d\n", This, fEnterMode); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_InsertMenusSB( + IShellBrowser* iface, + HMENU hmenuShared, + LPOLEMENUGROUPWIDTHS lpMenuWidths) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p %p\n", This, hmenuShared, lpMenuWidths); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_SetMenuSB( + IShellBrowser* iface, + HMENU hmenuShared, + HOLEMENU holemenuReserved, + HWND hwndActiveObject) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p %p %p\n", This, hmenuShared, holemenuReserved, hwndActiveObject); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_RemoveMenusSB( + IShellBrowser* iface, + HMENU hmenuShared) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p\n", This, hmenuShared); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_SetStatusTextSB( + IShellBrowser* iface, + LPCOLESTR pszStatusText) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %s\n", This, debugstr_w(pszStatusText)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_EnableModelessSB( + IShellBrowser* iface, + BOOL fEnable) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %d\n", This, fEnable); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_TranslateAcceleratorSB( + IShellBrowser* iface, + MSG *pmsg, + WORD wID) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p %d\n", This, pmsg, (int)wID); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_BrowseObject( + IShellBrowser* iface, + LPCITEMIDLIST pidl, + UINT wFlags) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p %u\n", This, pidl, wFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_GetViewStateStream( + IShellBrowser* iface, + DWORD grfMode, + IStream **ppStrm) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %x %p\n", This, grfMode, ppStrm); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_GetControlWindow( + IShellBrowser* iface, + UINT id, + HWND *phwnd) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %u %p\n", This, id, phwnd); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_SendControlMsg( + IShellBrowser* iface, + UINT id, + UINT uMsg, + WPARAM wParam, + LPARAM lParam, + LRESULT *pret) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %u %u %p\n", This, id, uMsg, pret); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_QueryActiveShellView( + IShellBrowser* iface, + IShellView **ppshv) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p\n", This, ppshv); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_OnViewWindowActive( + IShellBrowser* iface, + IShellView *pshv) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p\n", This, pshv); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellBrowser_SetToolbarItems( + IShellBrowser* iface, + LPTBBUTTONSB lpButtons, + UINT nButtons, + UINT uFlags) +{ + ShellBrowser *This = impl_from_IShellBrowser(iface); + FIXME("%p %p %u %u\n", This, lpButtons, nButtons, uFlags); + return E_NOTIMPL; +} + +static const IShellBrowserVtbl ShellBrowserVtbl = { + ShellBrowser_QueryInterface, + ShellBrowser_AddRef, + ShellBrowser_Release, + ShellBrowser_GetWindow, + ShellBrowser_ContextSensitiveHelp, + ShellBrowser_InsertMenusSB, + ShellBrowser_SetMenuSB, + ShellBrowser_RemoveMenusSB, + ShellBrowser_SetStatusTextSB, + ShellBrowser_EnableModelessSB, + ShellBrowser_TranslateAcceleratorSB, + ShellBrowser_BrowseObject, + ShellBrowser_GetViewStateStream, + ShellBrowser_GetControlWindow, + ShellBrowser_SendControlMsg, + ShellBrowser_QueryActiveShellView, + ShellBrowser_OnViewWindowActive, + ShellBrowser_SetToolbarItems +}; + +static inline ShellBrowser *impl_from_IBrowserService(IBrowserService *iface) +{ + return CONTAINING_RECORD(iface, ShellBrowser, IBrowserService_iface); +} + +static HRESULT WINAPI BrowserService_QueryInterface( + IBrowserService* iface, + REFIID riid, + void **ppvObject) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + return IShellBrowser_QueryInterface(&This->IShellBrowser_iface, riid, ppvObject); +} + +static ULONG WINAPI BrowserService_AddRef( + IBrowserService *iface) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + return IShellBrowser_AddRef(&This->IShellBrowser_iface); +} + +static ULONG WINAPI BrowserService_Release( + IBrowserService* iface) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + return IShellBrowser_Release(&This->IShellBrowser_iface); +} + +static HRESULT WINAPI BrowserService_GetParentSite( + IBrowserService* iface, + IOleInPlaceSite **ppipsite) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, ppipsite); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_SetTitle( + IBrowserService* iface, + IShellView *psv, + LPCWSTR pszName) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %s\n", This, psv, debugstr_w(pszName)); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetTitle( + IBrowserService* iface, + IShellView *psv, + LPWSTR pszName, + DWORD cchName) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %p %d\n", This, psv, pszName, cchName); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetOleObject( + IBrowserService* iface, + IOleObject **ppobjv) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, ppobjv); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetTravelLog( + IBrowserService* iface, + ITravelLog **pptl) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, pptl); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_ShowControlWindow( + IBrowserService* iface, + UINT id, + BOOL fShow) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %u %d\n", This, id, fShow); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_IsControlWindowShown( + IBrowserService* iface, + UINT id, + BOOL *pfShown) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %u %p\n", This, id, pfShown); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_IEGetDisplayName( + IBrowserService* iface, + PCIDLIST_ABSOLUTE pidl, + LPWSTR pwszName, + UINT uFlags) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %p %u\n", This, pidl, pwszName, uFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_IEParseDisplayName( + IBrowserService* iface, + UINT uiCP, + LPCWSTR pwszPath, + PIDLIST_ABSOLUTE *ppidlOut) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %u %s %p\n", This, uiCP, debugstr_w(pwszPath), ppidlOut); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_DisplayParseError( + IBrowserService* iface, + HRESULT hres, + LPCWSTR pwszPath) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %x %s\n", This, hres, debugstr_w(pwszPath)); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_NavigateToPidl( + IBrowserService* iface, + PCIDLIST_ABSOLUTE pidl, + DWORD grfHLNF) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %d\n", This, pidl, grfHLNF); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_SetNavigateState( + IBrowserService* iface, + BNSTATE bnstate) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %d\n", This, bnstate); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetNavigateState( + IBrowserService* iface, + BNSTATE *pbnstate) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, pbnstate); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_NotifyRedirect( + IBrowserService* iface, + IShellView *psv, + PCIDLIST_ABSOLUTE pidl, + BOOL *pfDidBrowse) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %p %p\n", This, psv, pidl, pfDidBrowse); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_UpdateWindowList( + IBrowserService* iface) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_UpdateBackForwardState( + IBrowserService* iface) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_SetFlags( + IBrowserService* iface, + DWORD dwFlags, + DWORD dwFlagMask) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %x %x\n", This, dwFlags, dwFlagMask); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetFlags( + IBrowserService* iface, + DWORD *pdwFlags) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, pdwFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_CanNavigateNow( + IBrowserService* iface) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetPidl( + IBrowserService* iface, + PIDLIST_ABSOLUTE *ppidl) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, ppidl); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_SetReferrer( + IBrowserService* iface, + PCIDLIST_ABSOLUTE pidl) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, pidl); + return E_NOTIMPL; +} + +static DWORD WINAPI BrowserService_GetBrowserIndex( + IBrowserService* iface) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetBrowserByIndex( + IBrowserService* iface, + DWORD dwID, + IUnknown **ppunk) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %x %p\n", This, dwID, ppunk); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetHistoryObject( + IBrowserService* iface, + IOleObject **ppole, + IStream **pstm, + IBindCtx **ppbc) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %p %p\n", This, ppole, pstm, ppbc); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_SetHistoryObject( + IBrowserService* iface, + IOleObject *pole, + BOOL fIsLocalAnchor) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %d\n", This, pole, fIsLocalAnchor); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_CacheOLEServer( + IBrowserService* iface, + IOleObject *pole) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, pole); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetSetCodePage( + IBrowserService* iface, + VARIANT *pvarIn, + VARIANT *pvarOut) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %p\n", This, pvarIn, pvarOut); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_OnHttpEquiv( + IBrowserService* iface, + IShellView *psv, + BOOL fDone, + VARIANT *pvarargIn, + VARIANT *pvarargOut) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p %d %p %p\n", This, psv, fDone, pvarargIn, pvarargOut); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_GetPalette( + IBrowserService* iface, + HPALETTE *hpal) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %p\n", This, hpal); + return E_NOTIMPL; +} + +static HRESULT WINAPI BrowserService_RegisterWindow( + IBrowserService* iface, + BOOL fForceRegister, + int swc) +{ + ShellBrowser *This = impl_from_IBrowserService(iface); + FIXME("%p %d %d\n", This, fForceRegister, swc); + return E_NOTIMPL; +} + +static const IBrowserServiceVtbl BrowserServiceVtbl = { + BrowserService_QueryInterface, + BrowserService_AddRef, + BrowserService_Release, + BrowserService_GetParentSite, + BrowserService_SetTitle, + BrowserService_GetTitle, + BrowserService_GetOleObject, + BrowserService_GetTravelLog, + BrowserService_ShowControlWindow, + BrowserService_IsControlWindowShown, + BrowserService_IEGetDisplayName, + BrowserService_IEParseDisplayName, + BrowserService_DisplayParseError, + BrowserService_NavigateToPidl, + BrowserService_SetNavigateState, + BrowserService_GetNavigateState, + BrowserService_NotifyRedirect, + BrowserService_UpdateWindowList, + BrowserService_UpdateBackForwardState, + BrowserService_SetFlags, + BrowserService_GetFlags, + BrowserService_CanNavigateNow, + BrowserService_GetPidl, + BrowserService_SetReferrer, + BrowserService_GetBrowserIndex, + BrowserService_GetBrowserByIndex, + BrowserService_GetHistoryObject, + BrowserService_SetHistoryObject, + BrowserService_CacheOLEServer, + BrowserService_GetSetCodePage, + BrowserService_OnHttpEquiv, + BrowserService_GetPalette, + BrowserService_RegisterWindow +}; + +static inline ShellBrowser *impl_from_IDocObjectService(IDocObjectService *iface) +{ + return CONTAINING_RECORD(iface, ShellBrowser, IDocObjectService_iface); +} + +static HRESULT WINAPI DocObjectService_QueryInterface( + IDocObjectService* iface, + REFIID riid, + void **ppvObject) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + return IShellBrowser_QueryInterface(&This->IShellBrowser_iface, riid, ppvObject); +} + +static ULONG WINAPI DocObjectService_AddRef( + IDocObjectService* iface) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + return IShellBrowser_AddRef(&This->IShellBrowser_iface); +} + +static ULONG WINAPI DocObjectService_Release( + IDocObjectService* iface) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + return IShellBrowser_Release(&This->IShellBrowser_iface); +} + +static HRESULT WINAPI DocObjectService_FireBeforeNavigate2( + IDocObjectService* iface, + IDispatch *pDispatch, + LPCWSTR lpszUrl, + DWORD dwFlags, + LPCWSTR lpszFrameName, + BYTE *pPostData, + DWORD cbPostData, + LPCWSTR lpszHeaders, + BOOL fPlayNavSound, + BOOL *pfCancel) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers; + VARIANTARG params[7]; + DISPPARAMS dp = {params, NULL, 7, 0}; + VARIANT_BOOL cancel = VARIANT_FALSE; + SAFEARRAY *post_data; + + TRACE("%p %p %s %x %s %p %d %s %d %p\n", This, pDispatch, debugstr_w(lpszUrl), + dwFlags, debugstr_w(lpszFrameName), pPostData, cbPostData, + debugstr_w(lpszHeaders), fPlayNavSound, pfCancel); + + if(cbPostData) { + post_data = SafeArrayCreateVector(VT_UI1, 0, cbPostData); + if(!post_data) + return E_OUTOFMEMORY; + memcpy(post_data->pvData, pPostData, cbPostData); + }else { + post_data = NULL; + } + + V_VT(params) = VT_BOOL|VT_BYREF; + V_BOOLREF(params) = &cancel; + + V_VT(params+1) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+1) = &var_headers; + V_VT(&var_headers) = VT_BSTR; + V_BSTR(&var_headers) = lpszHeaders ? SysAllocString(lpszHeaders) : NULL; + + V_VT(params+2) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+2) = &var_post_data2; + V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(&var_post_data2) = &var_post_data; + + if(post_data) { + V_VT(&var_post_data) = VT_UI1|VT_ARRAY; + V_ARRAY(&var_post_data) = post_data; + }else { + V_VT(&var_post_data) = VT_EMPTY; + } + + V_VT(params+3) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+3) = &var_frame_name; + V_VT(&var_frame_name) = VT_BSTR; + V_BSTR(&var_frame_name) = NULL; + + V_VT(params+4) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+4) = &var_flags; + V_VT(&var_flags) = VT_I4; + V_I4(&var_flags) = 0; + + V_VT(params+5) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params+5) = &var_url; + V_VT(&var_url) = VT_BSTR; + V_BSTR(&var_url) = SysAllocString(lpszUrl); + + V_VT(params+6) = (VT_DISPATCH); + V_DISPATCH(params+6) = (IDispatch*)This->doc_host->wb; + + TRACE(">>>\n"); + call_sink(This->doc_host->cps.wbe2, DISPID_BEFORENAVIGATE2, &dp); + TRACE("<<<\n"); + + SysFreeString(V_BSTR(&var_url)); + SysFreeString(V_BSTR(&var_headers)); + SafeArrayDestroy(post_data); + + *pfCancel = !!cancel; + return S_OK; +} + +static HRESULT WINAPI DocObjectService_FireNavigateComplete2( + IDocObjectService* iface, + IHTMLWindow2 *pHTMLWindow2, + DWORD dwFlags) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + IHTMLPrivateWindow *priv_window; + VARIANTARG params[2]; + DISPPARAMS dp = {params, NULL, 2, 0}; + VARIANT url_var; + BSTR url; + HRESULT hres; + + TRACE("%p %p %x\n", This, pHTMLWindow2, dwFlags); + + hres = IHTMLWindow2_QueryInterface(pHTMLWindow2, &IID_IHTMLPrivateWindow, (void**)&priv_window); + if(FAILED(hres)) + return hres; + + hres = IHTMLPrivateWindow_GetAddressBarUrl(priv_window, &url); + IHTMLPrivateWindow_Release(priv_window); + if(FAILED(hres)) + return hres; + + TRACE("got URL %s\n", debugstr_w(url)); + set_dochost_url(This->doc_host, url); + + V_VT(params) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params) = &url_var; + + V_VT(params+1) = VT_DISPATCH; + V_DISPATCH(params+1) = (IDispatch*)This->doc_host->wb; + + V_VT(&url_var) = VT_BSTR; + V_BSTR(&url_var) = url; + + TRACE(">>>\n"); + call_sink(This->doc_host->cps.wbe2, DISPID_NAVIGATECOMPLETE2, &dp); + TRACE("<<<\n"); + + SysFreeString(url); + + This->doc_host->busy = VARIANT_FALSE; + return S_OK; +} + +static HRESULT WINAPI DocObjectService_FireDownloadBegin( + IDocObjectService* iface) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + FIXME("%p\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocObjectService_FireDownloadComplete( + IDocObjectService* iface) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + FIXME("%p\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocObjectService_FireDocumentComplete( + IDocObjectService* iface, + IHTMLWindow2 *pHTMLWindow, + DWORD dwFlags) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + IHTMLPrivateWindow *priv_window; + VARIANTARG params[2]; + DISPPARAMS dp = {params, NULL, 2, 0}; + VARIANT url_var; + BSTR url; + HRESULT hres; + + TRACE("%p %p %x\n", This, pHTMLWindow, dwFlags); + + hres = IHTMLWindow2_QueryInterface(pHTMLWindow, &IID_IHTMLPrivateWindow, (void**)&priv_window); + if(FAILED(hres)) + return hres; + + hres = IHTMLPrivateWindow_GetAddressBarUrl(priv_window, &url); + IHTMLPrivateWindow_Release(priv_window); + if(FAILED(hres)) + return hres; + + TRACE("got URL %s\n", debugstr_w(url)); + + V_VT(params) = (VT_BYREF|VT_VARIANT); + V_VARIANTREF(params) = &url_var; + + V_VT(params+1) = VT_DISPATCH; + V_DISPATCH(params+1) = (IDispatch*)This->doc_host->wb; + + V_VT(&url_var) = VT_BSTR; + V_BSTR(&url_var) = url; + + TRACE(">>>\n"); + call_sink(This->doc_host->cps.wbe2, DISPID_DOCUMENTCOMPLETE, &dp); + TRACE("<<<\n"); + + SysFreeString(url); + This->doc_host->busy = VARIANT_FALSE; + return S_OK; +} + +static HRESULT WINAPI DocObjectService_UpdateDesktopComponent( + IDocObjectService* iface, + IHTMLWindow2 *pHTMLWindow) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + FIXME("%p %p\n", This, pHTMLWindow); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocObjectService_GetPendingUrl( + IDocObjectService* iface, + BSTR *pbstrPendingUrl) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + FIXME("%p %p\n", This, pbstrPendingUrl); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocObjectService_ActiveElementChanged( + IDocObjectService* iface, + IHTMLElement *pHTMLElement) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + FIXME("%p %p\n", This, pHTMLElement); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocObjectService_GetUrlSearchComponent( + IDocObjectService* iface, + BSTR *pbstrSearch) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + FIXME("%p %p\n", This, pbstrSearch); + return E_NOTIMPL; +} + +static HRESULT WINAPI DocObjectService_IsErrorUrl( + IDocObjectService* iface, + LPCWSTR lpszUrl, + BOOL *pfIsError) +{ + ShellBrowser *This = impl_from_IDocObjectService(iface); + FIXME("%p %s %p\n", This, debugstr_w(lpszUrl), pfIsError); + + *pfIsError = FALSE; + return S_OK; +} + +static const IDocObjectServiceVtbl DocObjectServiceVtbl = { + DocObjectService_QueryInterface, + DocObjectService_AddRef, + DocObjectService_Release, + DocObjectService_FireBeforeNavigate2, + DocObjectService_FireNavigateComplete2, + DocObjectService_FireDownloadBegin, + DocObjectService_FireDownloadComplete, + DocObjectService_FireDocumentComplete, + DocObjectService_UpdateDesktopComponent, + DocObjectService_GetPendingUrl, + DocObjectService_ActiveElementChanged, + DocObjectService_GetUrlSearchComponent, + DocObjectService_IsErrorUrl +}; + +HRESULT create_browser_service(DocHost *doc_host, ShellBrowser **ret) +{ + ShellBrowser *sb; + + sb = heap_alloc(sizeof(ShellBrowser)); + if(!sb) + return E_OUTOFMEMORY; + + sb->IShellBrowser_iface.lpVtbl = &ShellBrowserVtbl; + sb->IBrowserService_iface.lpVtbl = &BrowserServiceVtbl; + sb->IDocObjectService_iface.lpVtbl = &DocObjectServiceVtbl; + + sb->ref = 1; + sb->doc_host = doc_host; + + *ret = sb; + return S_OK; +} + +void detach_browser_service(ShellBrowser *sb) +{ + sb->doc_host = NULL; + IShellBrowser_Release(&sb->IShellBrowser_iface); +} + +static inline NewWindowManager *impl_from_INewWindowManager(INewWindowManager *iface) +{ + return CONTAINING_RECORD(iface, NewWindowManager, INewWindowManager_iface); +} + +static HRESULT WINAPI NewWindowManager_QueryInterface(INewWindowManager *iface, REFIID riid, void **ppv) +{ + NewWindowManager *This = impl_from_INewWindowManager(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->INewWindowManager_iface; + }else if(IsEqualGUID(&IID_INewWindowManager, riid)) { + TRACE("(%p)->(IID_INewWindowManager %p)\n", This, ppv); + *ppv = &This->INewWindowManager_iface; + }else { + WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); + *ppv = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI NewWindowManager_AddRef(INewWindowManager *iface) +{ + NewWindowManager *This = impl_from_INewWindowManager(iface); + + TRACE("(%p)\n", This); + + return IOleClientSite_AddRef(&This->doc_host->IOleClientSite_iface); +} + +static ULONG WINAPI NewWindowManager_Release(INewWindowManager *iface) +{ + NewWindowManager *This = impl_from_INewWindowManager(iface); + + TRACE("(%p)\n", This); + + return IOleClientSite_Release(&This->doc_host->IOleClientSite_iface); +} + +static HRESULT WINAPI NewWindowManager_EvaluateNewWindow(INewWindowManager *iface, LPCWSTR pszUrl, + LPCWSTR pszName, LPCWSTR pszUrlContext, LPCWSTR pszFeatures, BOOL fReplace, DWORD dwFlags, + DWORD dwUserActionTime) +{ + NewWindowManager *This = impl_from_INewWindowManager(iface); + FIXME("(%p)->(%s %s %s %s %x %x %d)\n", This, debugstr_w(pszUrl), debugstr_w(pszName), debugstr_w(pszUrlContext), + debugstr_w(pszFeatures), fReplace, dwFlags, dwUserActionTime); + return S_OK; +} + +static const INewWindowManagerVtbl NewWindowManagerVtbl = { + NewWindowManager_QueryInterface, + NewWindowManager_AddRef, + NewWindowManager_Release, + NewWindowManager_EvaluateNewWindow +}; + +void NewWindowManager_Init(DocHost *doc_host) +{ + doc_host->nwm.INewWindowManager_iface.lpVtbl = &NewWindowManagerVtbl; + doc_host->nwm.doc_host = doc_host; +} diff --git a/reactos/dll/win32/ieframe/shelluihelper.c b/reactos/dll/win32/ieframe/shelluihelper.c new file mode 100644 index 00000000000..fafab2421a1 --- /dev/null +++ b/reactos/dll/win32/ieframe/shelluihelper.c @@ -0,0 +1,378 @@ +/* + * Copyright 2012 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 "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +struct ShellUIHelper { + IShellUIHelper2 IShellUIHelper2_iface; + LONG ref; +}; + +static inline ShellUIHelper *impl_from_IShellUIHelper2(IShellUIHelper2 *iface) +{ + return CONTAINING_RECORD(iface, ShellUIHelper, IShellUIHelper2_iface); +} + +static HRESULT WINAPI ShellUIHelper2_QueryInterface(IShellUIHelper2 *iface, REFIID riid, void **ppv) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IShellUIHelper2_iface; + }else if(IsEqualGUID(&IID_IDispatch, riid)) { + TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv); + *ppv = &This->IShellUIHelper2_iface; + }else if(IsEqualGUID(&IID_IShellUIHelper, riid)) { + TRACE("(%p)->(IID_IShellUIHelper %p)\n", This, ppv); + *ppv = &This->IShellUIHelper2_iface; + }else if(IsEqualGUID(&IID_IShellUIHelper, riid)) { + TRACE("(%p)->(IID_IShellUIHelper2 %p)\n", This, ppv); + *ppv = &This->IShellUIHelper2_iface; + }else { + WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); + *ppv = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI ShellUIHelper2_AddRef(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + LONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + return ref; +} + +static ULONG WINAPI ShellUIHelper2_Release(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) + heap_free(This); + + return ref; +} + +static HRESULT WINAPI ShellUIHelper2_GetTypeInfoCount(IShellUIHelper2 *iface, UINT *pctinfo) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + + TRACE("(%p)->(%p)\n", This, pctinfo); + + *pctinfo = 1; + return S_OK; +} + +static HRESULT WINAPI ShellUIHelper2_GetTypeInfo(IShellUIHelper2 *iface, UINT iTInfo, LCID lcid, LPTYPEINFO *ppTInfo) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%d %d %p)\n", This, iTInfo, lcid, ppTInfo); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_GetIDsOfNames(IShellUIHelper2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, + LCID lcid, DISPID *rgDispId) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %p %d %d %p)\n", This, debugstr_guid(riid), rgszNames, cNames, + lcid, rgDispId); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_Invoke(IShellUIHelper2 *iface, DISPID dispIdMember, + REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, + EXCEPINFO *pExepInfo, UINT *puArgErr) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%d %s %d %08x %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid), + lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_ResetFirstBootMode(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_ResetSafeMode(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_RefreshOfflineDesktop(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_AddFavourite(IShellUIHelper2 *iface, BSTR URL, VARIANT *Title) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %s)\n", This, debugstr_w(URL), debugstr_variant(Title)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_AddChannel(IShellUIHelper2 *iface, BSTR URL) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(URL)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_AddDesktopComponent(IShellUIHelper2 *iface, BSTR URL, BSTR Type, + VARIANT *Left, VARIANT *Top, VARIANT *Width, VARIANT *Height) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %s %s %s %s %s)\n", This, debugstr_w(URL), debugstr_w(Type), debugstr_variant(Left), + debugstr_variant(Top), debugstr_variant(Width), debugstr_variant(Height)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_IsSubscribed(IShellUIHelper2 *iface, BSTR URL, VARIANT_BOOL *pBool) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %p)\n", This, debugstr_w(URL), pBool); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_NavigateAndFind(IShellUIHelper2 *iface, BSTR URL, BSTR strQuery, VARIANT *varTargetFrame) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(URL), debugstr_w(strQuery), debugstr_variant(varTargetFrame)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_ImportExportFavourites(IShellUIHelper2 *iface, VARIANT_BOOL fImport, BSTR strImpExpPath) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%x %s)\n", This, fImport, debugstr_w(strImpExpPath)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_AutoCompleteSaveForm(IShellUIHelper2 *iface, VARIANT *Form) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_variant(Form)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_AutoScan(IShellUIHelper2 *iface, BSTR strSearch, BSTR strFailureUrl, VARIANT *pvarTargetFrame) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(strSearch), debugstr_w(strFailureUrl), debugstr_variant(pvarTargetFrame)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_AutoCompleteAttach(IShellUIHelper2 *iface, VARIANT *Reserved) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_variant(Reserved)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_ShowBrowserUI(IShellUIHelper2 *iface, BSTR bstrName, VARIANT *pvarIn, VARIANT *pvarOut) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(bstrName), debugstr_variant(pvarIn), pvarOut); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_AddSearchProvider(IShellUIHelper2 *iface, BSTR URL) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(URL)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_RunOnceShown(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_SkipRunOnce(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_CustomizeSettings(IShellUIHelper2 *iface, VARIANT_BOOL fSQM, + VARIANT_BOOL fPhishing, BSTR bstrLocale) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%x %x %s)\n", This, fSQM, fPhishing, debugstr_w(bstrLocale)); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_SqmEnabled(IShellUIHelper2 *iface, VARIANT_BOOL *pfEnabled) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%p)\n", This, pfEnabled); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_PhishingEnabled(IShellUIHelper2 *iface, VARIANT_BOOL *pfEnabled) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%p)\n", This, pfEnabled); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_BrandImageUri(IShellUIHelper2 *iface, BSTR *pbstrUri) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%p)\n", This, pbstrUri); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_SkipTabsWelcome(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_DiagnoseConnection(IShellUIHelper2 *iface) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_CustomizeClearType(IShellUIHelper2 *iface, VARIANT_BOOL fSet) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%x)\n", This, fSet); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_IsSearchProviderInstalled(IShellUIHelper2 *iface, BSTR URL, DWORD *pdwResult) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%s %p)\n", This, debugstr_w(URL), pdwResult); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_IsSearchMigrated(IShellUIHelper2 *iface, VARIANT_BOOL *pfMigrated) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%p)\n", This, pfMigrated); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_DefaultSearchProvider(IShellUIHelper2 *iface, BSTR *pbstrName) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%p)\n", This, pbstrName); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_RunOnceRequiredSettingsComplete(IShellUIHelper2 *iface, VARIANT_BOOL fComplete) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%x)\n", This, fComplete); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_RunOnceHasShown(IShellUIHelper2 *iface, VARIANT_BOOL *pfShown) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%p)\n", This, pfShown); + return E_NOTIMPL; +} + +static HRESULT WINAPI ShellUIHelper2_SearchGuideUrl(IShellUIHelper2 *iface, BSTR *pbstrUrl) +{ + ShellUIHelper *This = impl_from_IShellUIHelper2(iface); + FIXME("(%p)->(%p)\n", This, pbstrUrl); + return E_NOTIMPL; +} + +static const IShellUIHelper2Vtbl ShellUIHelper2Vtbl = { + ShellUIHelper2_QueryInterface, + ShellUIHelper2_AddRef, + ShellUIHelper2_Release, + ShellUIHelper2_GetTypeInfoCount, + ShellUIHelper2_GetTypeInfo, + ShellUIHelper2_GetIDsOfNames, + ShellUIHelper2_Invoke, + ShellUIHelper2_ResetFirstBootMode, + ShellUIHelper2_ResetSafeMode, + ShellUIHelper2_RefreshOfflineDesktop, + ShellUIHelper2_AddFavourite, + ShellUIHelper2_AddChannel, + ShellUIHelper2_AddDesktopComponent, + ShellUIHelper2_IsSubscribed, + ShellUIHelper2_NavigateAndFind, + ShellUIHelper2_ImportExportFavourites, + ShellUIHelper2_AutoCompleteSaveForm, + ShellUIHelper2_AutoScan, + ShellUIHelper2_AutoCompleteAttach, + ShellUIHelper2_ShowBrowserUI, + ShellUIHelper2_AddSearchProvider, + ShellUIHelper2_RunOnceShown, + ShellUIHelper2_SkipRunOnce, + ShellUIHelper2_CustomizeSettings, + ShellUIHelper2_SqmEnabled, + ShellUIHelper2_PhishingEnabled, + ShellUIHelper2_BrandImageUri, + ShellUIHelper2_SkipTabsWelcome, + ShellUIHelper2_DiagnoseConnection, + ShellUIHelper2_CustomizeClearType, + ShellUIHelper2_IsSearchProviderInstalled, + ShellUIHelper2_IsSearchMigrated, + ShellUIHelper2_DefaultSearchProvider, + ShellUIHelper2_RunOnceRequiredSettingsComplete, + ShellUIHelper2_RunOnceHasShown, + ShellUIHelper2_SearchGuideUrl +}; + +HRESULT create_shell_ui_helper(IShellUIHelper2 **_ret) +{ + ShellUIHelper *ret; + + ret = heap_alloc(sizeof(*ret)); + if(!ret) + return E_OUTOFMEMORY; + + ret->IShellUIHelper2_iface.lpVtbl = &ShellUIHelper2Vtbl; + ret->ref = 1; + + *_ret = &ret->IShellUIHelper2_iface; + return S_OK; +} diff --git a/reactos/dll/win32/ieframe/urlhist.c b/reactos/dll/win32/ieframe/urlhist.c new file mode 100644 index 00000000000..42b6b34ae5c --- /dev/null +++ b/reactos/dll/win32/ieframe/urlhist.c @@ -0,0 +1,132 @@ +/* + * 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 "ieframe.h" +#include + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static HRESULT WINAPI UrlHistoryStg_QueryInterface(IUrlHistoryStg2 *iface, REFIID riid, void **ppv) +{ + *ppv = NULL; + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(IID_IUnknown %p)\n", ppv); + *ppv = iface; + }else if(IsEqualGUID(&IID_IUrlHistoryStg, riid)) { + TRACE("(IID_IUrlHistoryStg %p)\n", ppv); + *ppv = iface; + }else if(IsEqualGUID(&IID_IUrlHistoryStg2, riid)) { + TRACE("(IID_IUrlHistoryStg2 %p)\n", ppv); + *ppv = iface; + } + + if(*ppv) { + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; + } + + WARN("(%s %p)\n", debugstr_guid(riid), ppv); + return E_NOINTERFACE; +} + +static ULONG WINAPI UrlHistoryStg_AddRef(IUrlHistoryStg2 *iface) +{ + lock_module(); + return 2; +} + +static ULONG WINAPI UrlHistoryStg_Release(IUrlHistoryStg2 *iface) +{ + unlock_module(); + return 1; +} + +static HRESULT WINAPI UrlHistoryStg_AddUrl(IUrlHistoryStg2 *iface, LPCOLESTR lpcsUrl, + LPCOLESTR pocsTitle, DWORD dwFlags) +{ + FIXME("(%s %s %08x)\n", debugstr_w(lpcsUrl), debugstr_w(pocsTitle), dwFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI UrlHistoryStg_DeleteUrl(IUrlHistoryStg2 *iface, LPCOLESTR lpcsUrl, + DWORD dwFlags) +{ + FIXME("(%s %08x)\n", debugstr_w(lpcsUrl), dwFlags); + return E_NOTIMPL; +} + +static HRESULT WINAPI UrlHistoryStg_QueryUrl(IUrlHistoryStg2 *iface, LPCOLESTR lpcsUrl, + DWORD dwFlags, LPSTATURL lpSTATURL) +{ + FIXME("(%s %08x %p)\n", debugstr_w(lpcsUrl), dwFlags, lpSTATURL); + return E_NOTIMPL; +} + +static HRESULT WINAPI UrlHistoryStg_BindToObject(IUrlHistoryStg2 *iface, LPCOLESTR lpcsUrl, + REFIID riid, void **ppv) +{ + FIXME("(%s %s %p)\n", debugstr_w(lpcsUrl), debugstr_guid(riid), ppv); + return E_NOTIMPL; +} + +static HRESULT WINAPI UrlHistoryStg_EnumUrls(IUrlHistoryStg2 *iface, IEnumSTATURL **ppEnum) +{ + FIXME("(%p)\n", ppEnum); + return E_NOTIMPL; +} + +static HRESULT WINAPI UrlHistoryStg_AddUrlAndNotify(IUrlHistoryStg2 *iface, LPCOLESTR pocsUrl, + LPCOLESTR pocsTitle, DWORD dwFlags, BOOL fWriteHistory, IOleCommandTarget *poctNotify, + IUnknown *punkISFolder) +{ + FIXME("(%s %s %08x %x %p %p)\n", debugstr_w(pocsUrl), debugstr_w(pocsTitle), + dwFlags, fWriteHistory, poctNotify, punkISFolder); + return E_NOTIMPL; +} + +static HRESULT WINAPI UrlHistoryStg_ClearHistory(IUrlHistoryStg2 *iface) +{ + FIXME("()\n"); + return E_NOTIMPL; +} + +static const IUrlHistoryStg2Vtbl UrlHistoryStg2Vtbl = { + UrlHistoryStg_QueryInterface, + UrlHistoryStg_AddRef, + UrlHistoryStg_Release, + UrlHistoryStg_AddUrl, + UrlHistoryStg_DeleteUrl, + UrlHistoryStg_QueryUrl, + UrlHistoryStg_BindToObject, + UrlHistoryStg_EnumUrls, + UrlHistoryStg_AddUrlAndNotify, + UrlHistoryStg_ClearHistory +}; + +static IUrlHistoryStg2 UrlHistoryStg2 = { &UrlHistoryStg2Vtbl }; + +HRESULT WINAPI CUrlHistory_Create(IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppv) +{ + if(pOuter) + return CLASS_E_NOAGGREGATION; + + return IUrlHistoryStg2_QueryInterface(&UrlHistoryStg2, riid, ppv); +} diff --git a/reactos/dll/win32/ieframe/view.c b/reactos/dll/win32/ieframe/view.c new file mode 100644 index 00000000000..a52b257ee97 --- /dev/null +++ b/reactos/dll/win32/ieframe/view.c @@ -0,0 +1,237 @@ +/* + * Copyright 2005 Jacek Caban + * Copyright 2010 Ilya Shpigor + * + * 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 "ieframe.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +/********************************************************************** + * Implement the IViewObject interface + */ + +static inline WebBrowser *impl_from_IViewObject2(IViewObject2 *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IViewObject2_iface); +} + +static HRESULT WINAPI ViewObject_QueryInterface(IViewObject2 *iface, REFIID riid, void **ppv) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppv); +} + +static ULONG WINAPI ViewObject_AddRef(IViewObject2 *iface) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI ViewObject_Release(IViewObject2 *iface) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI ViewObject_Draw(IViewObject2 *iface, DWORD dwDrawAspect, + LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, + HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, + BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR), + ULONG_PTR dwContinue) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + FIXME("(%p)->(%d %d %p %p %p %p %p %p %p %08lx)\n", This, dwDrawAspect, lindex, + pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds, pfnContinue, + dwContinue); + return E_NOTIMPL; +} + +static HRESULT WINAPI ViewObject_GetColorSet(IViewObject2 *iface, DWORD dwAspect, + LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, + LOGPALETTE **ppColorSet) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + FIXME("(%p)->(%d %d %p %p %p %p)\n", This, dwAspect, lindex, pvAspect, ptd, + hicTargetDev, ppColorSet); + return E_NOTIMPL; +} + +static HRESULT WINAPI ViewObject_Freeze(IViewObject2 *iface, DWORD dwDrawAspect, LONG lindex, + void *pvAspect, DWORD *pdwFreeze) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + FIXME("(%p)->(%d %d %p %p)\n", This, dwDrawAspect, lindex, pvAspect, pdwFreeze); + return E_NOTIMPL; +} + +static HRESULT WINAPI ViewObject_Unfreeze(IViewObject2 *iface, DWORD dwFreeze) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + FIXME("(%p)->(%d)\n", This, dwFreeze); + return E_NOTIMPL; +} + +static HRESULT WINAPI ViewObject_SetAdvise(IViewObject2 *iface, DWORD aspects, DWORD advf, + IAdviseSink *pAdvSink) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + FIXME("(%p)->(%d %08x %p)\n", This, aspects, advf, pAdvSink); + return E_NOTIMPL; +} + +static HRESULT WINAPI ViewObject_GetAdvise(IViewObject2 *iface, DWORD *pAspects, + DWORD *pAdvf, IAdviseSink **ppAdvSink) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + FIXME("(%p)->(%p %p %p)\n", This, pAspects, pAdvf, ppAdvSink); + return E_NOTIMPL; +} + +static HRESULT WINAPI ViewObject_GetExtent(IViewObject2 *iface, DWORD dwAspect, LONG lindex, + DVTARGETDEVICE *ptd, LPSIZEL lpsizel) +{ + WebBrowser *This = impl_from_IViewObject2(iface); + FIXME("(%p)->(%d %d %p %p)\n", This, dwAspect, lindex, ptd, lpsizel); + return E_NOTIMPL; +} + +static const IViewObject2Vtbl ViewObjectVtbl = { + ViewObject_QueryInterface, + ViewObject_AddRef, + ViewObject_Release, + ViewObject_Draw, + ViewObject_GetColorSet, + ViewObject_Freeze, + ViewObject_Unfreeze, + ViewObject_SetAdvise, + ViewObject_GetAdvise, + ViewObject_GetExtent +}; + +/********************************************************************** + * Implement the IDataObject interface + */ + +static inline WebBrowser *impl_from_IDataObject(IDataObject *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IDataObject_iface); +} + +static HRESULT WINAPI DataObject_QueryInterface(LPDATAOBJECT iface, REFIID riid, LPVOID * ppvObj) +{ + WebBrowser *This = impl_from_IDataObject(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppvObj); +} + +static ULONG WINAPI DataObject_AddRef(LPDATAOBJECT iface) +{ + WebBrowser *This = impl_from_IDataObject(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI DataObject_Release(LPDATAOBJECT iface) +{ + WebBrowser *This = impl_from_IDataObject(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT WINAPI DataObject_GetData(LPDATAOBJECT iface, LPFORMATETC pformatetcIn, STGMEDIUM *pmedium) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_GetDataHere(LPDATAOBJECT iface, LPFORMATETC pformatetc, STGMEDIUM *pmedium) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_QueryGetData(LPDATAOBJECT iface, LPFORMATETC pformatetc) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_GetCanonicalFormatEtc(LPDATAOBJECT iface, LPFORMATETC pformatectIn, LPFORMATETC pformatetcOut) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_SetData(LPDATAOBJECT iface, LPFORMATETC pformatetc, STGMEDIUM *pmedium, BOOL fRelease) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_EnumFormatEtc(LPDATAOBJECT iface, DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_DAdvise(LPDATAOBJECT iface, FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_DUnadvise(LPDATAOBJECT iface, DWORD dwConnection) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI DataObject_EnumDAdvise(LPDATAOBJECT iface, IEnumSTATDATA **ppenumAdvise) +{ + WebBrowser *This = impl_from_IDataObject(iface); + FIXME("(%p)->()\n", This); + return E_NOTIMPL; +} + +static const IDataObjectVtbl DataObjectVtbl = { + DataObject_QueryInterface, + DataObject_AddRef, + DataObject_Release, + DataObject_GetData, + DataObject_GetDataHere, + DataObject_QueryGetData, + DataObject_GetCanonicalFormatEtc, + DataObject_SetData, + DataObject_EnumFormatEtc, + DataObject_DAdvise, + DataObject_DUnadvise, + DataObject_EnumDAdvise +}; + +void WebBrowser_ViewObject_Init(WebBrowser *This) +{ + This->IViewObject2_iface.lpVtbl = &ViewObjectVtbl; + This->IDataObject_iface.lpVtbl = &DataObjectVtbl; +} diff --git a/reactos/dll/win32/ieframe/webbrowser.c b/reactos/dll/win32/ieframe/webbrowser.c new file mode 100644 index 00000000000..fcfb65495ef --- /dev/null +++ b/reactos/dll/win32/ieframe/webbrowser.c @@ -0,0 +1,1291 @@ +/* + * Implementation of IWebBrowser interface for WebBrowser control + * + * Copyright 2001 John R. Sheets (for CodeWeavers) + * Copyright 2005 Jacek Caban + * + * 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 "ieframe.h" + +#include +//#include "mshtml.h" + +#include + +WINE_DEFAULT_DEBUG_CHANNEL(ieframe); + +static inline WebBrowser *impl_from_IWebBrowser2(IWebBrowser2 *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IWebBrowser2_iface); +} + +static HRESULT WINAPI WebBrowser_QueryInterface(IWebBrowser2 *iface, REFIID riid, LPVOID *ppv) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + if (ppv == NULL) + return E_POINTER; + *ppv = NULL; + + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IDispatch, riid)) { + TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IWebBrowser, riid)) { + TRACE("(%p)->(IID_IWebBrowser %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IWebBrowserApp, riid)) { + TRACE("(%p)->(IID_IWebBrowserApp %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IWebBrowser2, riid)) { + TRACE("(%p)->(IID_IWebBrowser2 %p)\n", This, ppv); + *ppv = &This->IWebBrowser2_iface; + }else if(IsEqualGUID(&IID_IOleObject, riid)) { + TRACE("(%p)->(IID_IOleObject %p)\n", This, ppv); + *ppv = &This->IOleObject_iface; + }else if(IsEqualGUID(&IID_IOleWindow, riid)) { + TRACE("(%p)->(IID_IOleWindow %p)\n", This, ppv); + *ppv = &This->IOleInPlaceObject_iface; + }else if(IsEqualGUID (&IID_IOleInPlaceObject, riid)) { + TRACE("(%p)->(IID_IOleInPlaceObject %p)\n", This, ppv); + *ppv = &This->IOleInPlaceObject_iface; + }else if(IsEqualGUID(&IID_IOleControl, riid)) { + TRACE("(%p)->(IID_IOleControl %p)\n", This, ppv); + *ppv = &This->IOleControl_iface; + }else if(IsEqualGUID(&IID_IPersist, riid)) { + TRACE("(%p)->(IID_IPersist %p)\n", This, ppv); + *ppv = &This->IPersistStorage_iface; + }else if(IsEqualGUID(&IID_IPersistStorage, riid)) { + TRACE("(%p)->(IID_IPersistStorage %p)\n", This, ppv); + *ppv = &This->IPersistStorage_iface; + }else if(IsEqualGUID(&IID_IPersistMemory, riid)) { + TRACE("(%p)->(IID_IPersistStorage %p)\n", This, ppv); + *ppv = &This->IPersistMemory_iface; + }else if(IsEqualGUID (&IID_IPersistStreamInit, riid)) { + TRACE("(%p)->(IID_IPersistStreamInit %p)\n", This, ppv); + *ppv = &This->IPersistStreamInit_iface; + }else if(IsEqualGUID(&IID_IProvideClassInfo, riid)) { + TRACE("(%p)->(IID_IProvideClassInfo %p)\n", This, ppv); + *ppv = &This->IProvideClassInfo2_iface; + }else if(IsEqualGUID(&IID_IProvideClassInfo2, riid)) { + TRACE("(%p)->(IID_IProvideClassInfo2 %p)\n", This, ppv); + *ppv = &This->IProvideClassInfo2_iface; + }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) { + TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv); + *ppv = &This->doc_host.cps.IConnectionPointContainer_iface; + }else if(IsEqualGUID(&IID_IViewObject, riid)) { + TRACE("(%p)->(IID_IViewObject %p)\n", This, ppv); + *ppv = &This->IViewObject2_iface; + }else if(IsEqualGUID(&IID_IViewObject2, riid)) { + TRACE("(%p)->(IID_IViewObject2 %p)\n", This, ppv); + *ppv = &This->IViewObject2_iface; + }else if(IsEqualGUID(&IID_IOleInPlaceActiveObject, riid)) { + TRACE("(%p)->(IID_IOleInPlaceActiveObject %p)\n", This, ppv); + *ppv = &This->IOleInPlaceActiveObject_iface; + }else if(IsEqualGUID(&IID_IOleCommandTarget, riid)) { + TRACE("(%p)->(IID_IOleCommandTarget %p)\n", This, ppv); + *ppv = &This->IOleCommandTarget_iface; + }else if(IsEqualGUID(&IID_IServiceProvider, riid)) { + *ppv = &This->IServiceProvider_iface; + TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv); + }else if(IsEqualGUID(&IID_IDataObject, riid)) { + *ppv = &This->IDataObject_iface; + TRACE("(%p)->(IID_IDataObject %p)\n", This, ppv); + }else if(IsEqualGUID(&IID_IQuickActivate, riid)) { + TRACE("(%p)->(IID_IQuickActivate %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IRunnableObject, riid)) { + TRACE("(%p)->(IID_IRunnableObject %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IPerPropertyBrowsing, riid)) { + TRACE("(%p)->(IID_IPerPropertyBrowsing %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IOleCache, riid)) { + TRACE("(%p)->(IID_IOleCache %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IOleInPlaceSite, riid)) { + TRACE("(%p)->(IID_IOleInPlaceSite %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IObjectWithSite, riid)) { + TRACE("(%p)->(IID_IObjectWithSite %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IViewObjectEx, riid)) { + TRACE("(%p)->(IID_IViewObjectEx %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IOleLink, riid)) { + TRACE("(%p)->(IID_IOleLink %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IMarshal, riid)) { + TRACE("(%p)->(IID_IMarshal %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(IsEqualGUID(&IID_IStdMarshalInfo, riid)) { + /* This is implemented since IE10 */ + WARN("(%p)->(IID_IStdMarshalInfo %p) returning NULL\n", This, ppv); + return E_NOINTERFACE; + }else if(HlinkFrame_QI(&This->hlink_frame, riid, ppv)) { + return S_OK; + } + + if(*ppv) { + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; + } + + FIXME("(%p)->(%s %p) interface not supported\n", This, debugstr_guid(riid), ppv); + return E_NOINTERFACE; +} + +static ULONG WINAPI WebBrowser_AddRef(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + LONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p) ref=%d\n", This, ref); + return ref; +} + +static ULONG WINAPI WebBrowser_Release(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) { + if(This->doc_host.document) + IUnknown_Release(This->doc_host.document); + + DocHost_Release(&This->doc_host); + + WebBrowser_OleObject_Destroy(This); + + heap_free(This); + unlock_module(); + } + + return ref; +} + +/* IDispatch methods */ +static HRESULT WINAPI WebBrowser_GetTypeInfoCount(IWebBrowser2 *iface, UINT *pctinfo) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pctinfo); + + *pctinfo = 1; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_GetTypeInfo(IWebBrowser2 *iface, UINT iTInfo, LCID lcid, + LPTYPEINFO *ppTInfo) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + ITypeInfo *typeinfo; + HRESULT hres; + + TRACE("(%p)->(%d %d %p)\n", This, iTInfo, lcid, ppTInfo); + + hres = get_typeinfo(IWebBrowser2_tid, &typeinfo); + if(FAILED(hres)) + return hres; + + ITypeInfo_AddRef(typeinfo); + *ppTInfo = typeinfo; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_GetIDsOfNames(IWebBrowser2 *iface, REFIID riid, + LPOLESTR *rgszNames, UINT cNames, + LCID lcid, DISPID *rgDispId) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + ITypeInfo *typeinfo; + HRESULT hres; + + TRACE("(%p)->(%s %p %d %d %p)\n", This, debugstr_guid(riid), rgszNames, cNames, + lcid, rgDispId); + + hres = get_typeinfo(IWebBrowser2_tid, &typeinfo); + if(FAILED(hres)) + return hres; + + return ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId); +} + +static HRESULT WINAPI WebBrowser_Invoke(IWebBrowser2 *iface, DISPID dispIdMember, + REFIID riid, LCID lcid, WORD wFlags, + DISPPARAMS *pDispParams, VARIANT *pVarResult, + EXCEPINFO *pExepInfo, UINT *puArgErr) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + ITypeInfo *typeinfo; + HRESULT hres; + + TRACE("(%p)->(%d %s %d %08x %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid), + lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + + hres = get_typeinfo(IWebBrowser2_tid, &typeinfo); + if(FAILED(hres)) + return hres; + + return ITypeInfo_Invoke(typeinfo, &This->IWebBrowser2_iface, dispIdMember, wFlags, pDispParams, + pVarResult, pExepInfo, puArgErr); +} + +/* IWebBrowser methods */ +static HRESULT WINAPI WebBrowser_GoBack(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + TRACE("(%p)\n", This); + return go_back(&This->doc_host); +} + +static HRESULT WINAPI WebBrowser_GoForward(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_GoHome(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + TRACE("(%p)\n", This); + return go_home(&This->doc_host); +} + +static HRESULT WINAPI WebBrowser_GoSearch(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_Navigate(IWebBrowser2 *iface, BSTR szUrl, + VARIANT *Flags, VARIANT *TargetFrameName, + VARIANT *PostData, VARIANT *Headers) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(szUrl), debugstr_variant(Flags), + debugstr_variant(TargetFrameName), debugstr_variant(PostData), + debugstr_variant(Headers)); + + return navigate_url(&This->doc_host, szUrl, Flags, TargetFrameName, PostData, Headers); +} + +static HRESULT WINAPI WebBrowser_Refresh(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)\n", This); + + return refresh_document(&This->doc_host); +} + +static HRESULT WINAPI WebBrowser_Refresh2(IWebBrowser2 *iface, VARIANT *Level) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_variant(Level)); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_Stop(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)\n", This); + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_Application(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, ppDisp); + + if(!ppDisp) + return E_POINTER; + + *ppDisp = (IDispatch*)&This->IWebBrowser2_iface; + IDispatch_AddRef(*ppDisp); + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_Parent(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, ppDisp); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_Container(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, ppDisp); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_Document(IWebBrowser2 *iface, IDispatch **ppDisp) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + IDispatch *disp = NULL; + + TRACE("(%p)->(%p)\n", This, ppDisp); + + if(This->doc_host.document) { + HRESULT hres; + + hres = IUnknown_QueryInterface(This->doc_host.document, &IID_IDispatch, (void**)&disp); + if(SUCCEEDED(hres)) { + IDispatch *html_doc; + + /* Some broken apps cast returned IDispatch to IHTMLDocument2 + * without QueryInterface call */ + hres = IDispatch_QueryInterface(disp, &IID_IHTMLDocument2, (void**)&html_doc); + if(SUCCEEDED(hres)) { + IDispatch_Release(disp); + disp = html_doc; + } + } + } + + *ppDisp = disp; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_TopLevelContainer(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pBool); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_Type(IWebBrowser2 *iface, BSTR *Type) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Type); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_Left(IWebBrowser2 *iface, LONG *pl) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pl); + + *pl = This->pos_rect.left; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_Left(IWebBrowser2 *iface, LONG Left) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + RECT rect; + + TRACE("(%p)->(%d)\n", This, Left); + + if(!This->inplace) + return E_UNEXPECTED; + + rect = This->pos_rect; + rect.left = Left; + + /* We don't really change the window position here. + * We just notify the embedder that he should do so. */ + return IOleInPlaceSiteEx_OnPosRectChange(This->inplace, &rect); +} + +static HRESULT WINAPI WebBrowser_get_Top(IWebBrowser2 *iface, LONG *pl) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pl); + + *pl = This->pos_rect.top; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_Top(IWebBrowser2 *iface, LONG Top) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + RECT rect; + + TRACE("(%p)->(%d)\n", This, Top); + + if(!This->inplace) + return E_UNEXPECTED; + + rect = This->pos_rect; + rect.top = Top; + + /* We don't really change the window position here. + * We just notify the embedder that he should do so. */ + return IOleInPlaceSiteEx_OnPosRectChange(This->inplace, &rect); +} + +static HRESULT WINAPI WebBrowser_get_Width(IWebBrowser2 *iface, LONG *pl) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pl); + + *pl = This->pos_rect.right - This->pos_rect.left; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_Width(IWebBrowser2 *iface, LONG Width) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + RECT rect; + + TRACE("(%p)->(%d)\n", This, Width); + + if(!This->inplace) + return E_UNEXPECTED; + + rect = This->pos_rect; + rect.right = rect.left+Width; + + /* We don't really change the window size here. + * We just notify the embedder that he should do so. */ + return IOleInPlaceSiteEx_OnPosRectChange(This->inplace, &rect); +} + +static HRESULT WINAPI WebBrowser_get_Height(IWebBrowser2 *iface, LONG *pl) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pl); + + *pl = This->pos_rect.bottom - This->pos_rect.top; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_Height(IWebBrowser2 *iface, LONG Height) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + RECT rect; + + TRACE("(%p)->(%d)\n", This, Height); + + if(!This->inplace) + return E_UNEXPECTED; + + rect = This->pos_rect; + rect.bottom = rect.top+Height; + + /* We don't really change the window size here. + * We just notify the embedder that he should do so. */ + return IOleInPlaceSiteEx_OnPosRectChange(This->inplace, &rect); +} + +static HRESULT WINAPI WebBrowser_get_LocationName(IWebBrowser2 *iface, BSTR *LocationName) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, LocationName); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_LocationURL(IWebBrowser2 *iface, BSTR *LocationURL) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, LocationURL); + + return get_location_url(&This->doc_host, LocationURL); +} + +static HRESULT WINAPI WebBrowser_get_Busy(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pBool); + + *pBool = This->doc_host.busy; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_Quit(IWebBrowser2 *iface) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)\n", This); + + /* It's a InternetExplorer specific method, we have nothing to do here. */ + return E_FAIL; +} + +static HRESULT WINAPI WebBrowser_ClientToWindow(IWebBrowser2 *iface, int *pcx, int *pcy) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p %p)\n", This, pcx, pcy); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_PutProperty(IWebBrowser2 *iface, BSTR szProperty, VARIANT vtValue) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s %s)\n", This, debugstr_w(szProperty), debugstr_variant(&vtValue)); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_GetProperty(IWebBrowser2 *iface, BSTR szProperty, VARIANT *pvtValue) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s %s)\n", This, debugstr_w(szProperty), debugstr_variant(pvtValue)); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_Name(IWebBrowser2 *iface, BSTR *Name) +{ + static const WCHAR sName[] = {'M','i','c','r','o','s','o','f','t',' ','W','e','b', + ' ','B','r','o','w','s','e','r',' ','C','o','n','t','r','o','l',0}; + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, Name); + + *Name = SysAllocString(sName); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_HWND(IWebBrowser2 *iface, LONG *pHWND) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pHWND); + + /* WebBrowser control never has a frame window (in opposition to InternetExplorer) */ + *pHWND = 0; + return E_FAIL; +} + +static HRESULT WINAPI WebBrowser_get_FullName(IWebBrowser2 *iface, BSTR *FullName) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, FullName); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_Path(IWebBrowser2 *iface, BSTR *Path) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, Path); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_Visible(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pBool); + + *pBool = This->visible; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_Visible(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + TRACE("(%p)->(%x)\n", This, Value); + + This->visible = Value; + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = Value; + call_sink(This->doc_host.cps.wbe2, DISPID_ONVISIBLE, &dispparams); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_StatusBar(IWebBrowser2 *iface, VARIANT_BOOL *pBool) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pBool); + + *pBool = This->status_bar; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_StatusBar(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + TRACE("(%p)->(%x)\n", This, Value); + + This->status_bar = Value ? VARIANT_TRUE : VARIANT_FALSE; + + /* In opposition to InternetExplorer, all we should do here is + * inform the embedder about the status bar change. */ + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = Value; + call_sink(This->doc_host.cps.wbe2, DISPID_ONSTATUSBAR, &dispparams); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_StatusText(IWebBrowser2 *iface, BSTR *StatusText) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, StatusText); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_put_StatusText(IWebBrowser2 *iface, BSTR StatusText) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(StatusText)); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_ToolBar(IWebBrowser2 *iface, int *Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, Value); + + *Value = This->tool_bar; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_ToolBar(IWebBrowser2 *iface, int Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + TRACE("(%p)->(%x)\n", This, Value); + + This->tool_bar = Value ? VARIANT_TRUE : VARIANT_FALSE; + + /* In opposition to InternetExplorer, all we should do here is + * inform the embedder about the tool bar change. */ + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = This->tool_bar; + call_sink(This->doc_host.cps.wbe2, DISPID_ONTOOLBAR, &dispparams); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_MenuBar(IWebBrowser2 *iface, VARIANT_BOOL *Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, Value); + + *Value = This->menu_bar; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_MenuBar(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + TRACE("(%p)->(%x)\n", This, Value); + + This->menu_bar = Value ? VARIANT_TRUE : VARIANT_FALSE; + + /* In opposition to InternetExplorer, all we should do here is + * inform the embedder about the menu bar change. */ + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = Value; + call_sink(This->doc_host.cps.wbe2, DISPID_ONMENUBAR, &dispparams); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_FullScreen(IWebBrowser2 *iface, VARIANT_BOOL *pbFullScreen) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pbFullScreen); + + *pbFullScreen = This->full_screen; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_FullScreen(IWebBrowser2 *iface, VARIANT_BOOL bFullScreen) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + /* In opposition to InternetExplorer, all we should do here is + * inform the embedder about the fullscreen change. */ + + TRACE("(%p)->(%x)\n", This, bFullScreen); + + This->full_screen = bFullScreen ? VARIANT_TRUE : VARIANT_FALSE; + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = bFullScreen; + call_sink(This->doc_host.cps.wbe2, DISPID_ONFULLSCREEN, &dispparams); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VARIANT *Flags, + VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + LPCWSTR url; + + TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_variant(URL), debugstr_variant(Flags), + debugstr_variant(TargetFrameName), debugstr_variant(PostData), debugstr_variant(Headers)); + + if(!This->client) + return E_FAIL; + + if(!URL) + return S_OK; + + switch (V_VT(URL)) + { + case VT_BSTR: + url = V_BSTR(URL); + break; + case VT_BSTR|VT_BYREF: + url = *V_BSTRREF(URL); + break; + default: + FIXME("Unsupported V_VT(URL) %d\n", V_VT(URL)); + return E_INVALIDARG; + } + + return navigate_url(&This->doc_host, url, Flags, TargetFrameName, PostData, Headers); +} + +static HRESULT WINAPI WebBrowser_QueryStatusWB(IWebBrowser2 *iface, OLECMDID cmdID, OLECMDF *pcmdf) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + IOleCommandTarget *target = NULL; + OLECMD ole_command[1]; + HRESULT hres; + + TRACE("(%p)->(%d %p)\n", This, cmdID, pcmdf); + + if (!pcmdf) + return E_POINTER; + ole_command[0].cmdID = cmdID; + ole_command[0].cmdf = *pcmdf; + + if (This->container) + { + hres = IOleContainer_QueryInterface(This->container, &IID_IOleCommandTarget, (LPVOID*)&target); + if(FAILED(hres)) + target = NULL; + } + if (!target && This->doc_host.document) + { + hres = IUnknown_QueryInterface(This->doc_host.document, &IID_IOleCommandTarget, (LPVOID*)&target); + if(FAILED(hres)) + target = NULL; + } + + if (!target) + return E_UNEXPECTED; + + hres = IOleCommandTarget_QueryStatus(target, NULL, 1, ole_command, NULL); + if (SUCCEEDED(hres)) + *pcmdf = ole_command[0].cmdf; + if (hres == OLECMDERR_E_NOTSUPPORTED) + { + *pcmdf = 0; + hres = S_OK; + } + IOleCommandTarget_Release(target); + + return hres; +} + +static HRESULT WINAPI WebBrowser_ExecWB(IWebBrowser2 *iface, OLECMDID cmdID, + OLECMDEXECOPT cmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + IOleCommandTarget *target = NULL; + HRESULT hres; + + TRACE("(%p)->(%d %d %s %p)\n", This, cmdID, cmdexecopt, debugstr_variant(pvaIn), pvaOut); + + if(This->container) + { + hres = IOleContainer_QueryInterface(This->container, &IID_IOleCommandTarget, (LPVOID*)&target); + if(FAILED(hres)) + target = NULL; + } + if(!target && This->doc_host.document) + { + hres = IUnknown_QueryInterface(This->doc_host.document, &IID_IOleCommandTarget, (LPVOID*)&target); + if(FAILED(hres)) + target = NULL; + } + + if(!target) + return E_UNEXPECTED; + + hres = IOleCommandTarget_Exec(target, NULL, cmdID, cmdexecopt, pvaIn, pvaOut); + IOleCommandTarget_Release(target); + + return hres; +} + +static HRESULT WINAPI WebBrowser_ShowBrowserBar(IWebBrowser2 *iface, VARIANT *pvaClsid, + VARIANT *pvarShow, VARIANT *pvarSize) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%s %s %s)\n", This, debugstr_variant(pvaClsid), debugstr_variant(pvarShow), + debugstr_variant(pvarSize)); + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_get_ReadyState(IWebBrowser2 *iface, READYSTATE *lpReadyState) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, lpReadyState); + + *lpReadyState = This->doc_host.ready_state; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_Offline(IWebBrowser2 *iface, VARIANT_BOOL *pbOffline) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pbOffline); + + *pbOffline = This->doc_host.offline; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_Offline(IWebBrowser2 *iface, VARIANT_BOOL bOffline) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%x)\n", This, bOffline); + + This->doc_host.offline = bOffline ? VARIANT_TRUE : VARIANT_FALSE; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_Silent(IWebBrowser2 *iface, VARIANT_BOOL *pbSilent) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pbSilent); + + *pbSilent = This->doc_host.silent; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_Silent(IWebBrowser2 *iface, VARIANT_BOOL bSilent) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%x)\n", This, bSilent); + + This->doc_host.silent = bSilent ? VARIANT_TRUE : VARIANT_FALSE; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_RegisterAsBrowser(IWebBrowser2 *iface, + VARIANT_BOOL *pbRegister) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + FIXME("(%p)->(%p)\n", This, pbRegister); + + *pbRegister = This->register_browser; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_RegisterAsBrowser(IWebBrowser2 *iface, + VARIANT_BOOL bRegister) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + FIXME("(%p)->(%x)\n", This, bRegister); + + This->register_browser = bRegister ? VARIANT_TRUE : VARIANT_FALSE; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_RegisterAsDropTarget(IWebBrowser2 *iface, + VARIANT_BOOL *pbRegister) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%p)\n", This, pbRegister); + *pbRegister=0; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_RegisterAsDropTarget(IWebBrowser2 *iface, + VARIANT_BOOL bRegister) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + FIXME("(%p)->(%x)\n", This, bRegister); + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_TheaterMode(IWebBrowser2 *iface, VARIANT_BOOL *pbRegister) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, pbRegister); + + *pbRegister = This->theater_mode; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_TheaterMode(IWebBrowser2 *iface, VARIANT_BOOL bRegister) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + TRACE("(%p)->(%x)\n", This, bRegister); + + This->theater_mode = bRegister ? VARIANT_TRUE : VARIANT_FALSE; + + /* In opposition to InternetExplorer, all we should do here is + * inform the embedder about the theater mode change. */ + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = bRegister; + call_sink(This->doc_host.cps.wbe2, DISPID_ONTHEATERMODE, &dispparams); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_AddressBar(IWebBrowser2 *iface, VARIANT_BOOL *Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, Value); + + *Value = This->address_bar; + return S_OK; +} + +static HRESULT WINAPI WebBrowser_put_AddressBar(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + TRACE("(%p)->(%x)\n", This, Value); + + This->address_bar = Value ? VARIANT_TRUE : VARIANT_FALSE; + + /* In opposition to InternetExplorer, all we should do here is + * inform the embedder about the address bar change. */ + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = Value; + call_sink(This->doc_host.cps.wbe2, DISPID_ONADDRESSBAR, &dispparams); + + return S_OK; +} + +static HRESULT WINAPI WebBrowser_get_Resizable(IWebBrowser2 *iface, VARIANT_BOOL *Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + + TRACE("(%p)->(%p)\n", This, Value); + + /* It's InternetExplorer object's method. We have nothing to do here. */ + return E_NOTIMPL; +} + +static HRESULT WINAPI WebBrowser_put_Resizable(IWebBrowser2 *iface, VARIANT_BOOL Value) +{ + WebBrowser *This = impl_from_IWebBrowser2(iface); + VARIANTARG arg; + DISPPARAMS dispparams = {&arg, NULL, 1, 0}; + + TRACE("(%p)->(%x)\n", This, Value); + + /* In opposition to InternetExplorer, all we should do here is + * inform the embedder about the resizable change. */ + + V_VT(&arg) = VT_BOOL; + V_BOOL(&arg) = Value; + call_sink(This->doc_host.cps.wbe2, DISPID_WINDOWSETRESIZABLE, &dispparams); + + return S_OK; +} + +static const IWebBrowser2Vtbl WebBrowser2Vtbl = +{ + WebBrowser_QueryInterface, + WebBrowser_AddRef, + WebBrowser_Release, + WebBrowser_GetTypeInfoCount, + WebBrowser_GetTypeInfo, + WebBrowser_GetIDsOfNames, + WebBrowser_Invoke, + WebBrowser_GoBack, + WebBrowser_GoForward, + WebBrowser_GoHome, + WebBrowser_GoSearch, + WebBrowser_Navigate, + WebBrowser_Refresh, + WebBrowser_Refresh2, + WebBrowser_Stop, + WebBrowser_get_Application, + WebBrowser_get_Parent, + WebBrowser_get_Container, + WebBrowser_get_Document, + WebBrowser_get_TopLevelContainer, + WebBrowser_get_Type, + WebBrowser_get_Left, + WebBrowser_put_Left, + WebBrowser_get_Top, + WebBrowser_put_Top, + WebBrowser_get_Width, + WebBrowser_put_Width, + WebBrowser_get_Height, + WebBrowser_put_Height, + WebBrowser_get_LocationName, + WebBrowser_get_LocationURL, + WebBrowser_get_Busy, + WebBrowser_Quit, + WebBrowser_ClientToWindow, + WebBrowser_PutProperty, + WebBrowser_GetProperty, + WebBrowser_get_Name, + WebBrowser_get_HWND, + WebBrowser_get_FullName, + WebBrowser_get_Path, + WebBrowser_get_Visible, + WebBrowser_put_Visible, + WebBrowser_get_StatusBar, + WebBrowser_put_StatusBar, + WebBrowser_get_StatusText, + WebBrowser_put_StatusText, + WebBrowser_get_ToolBar, + WebBrowser_put_ToolBar, + WebBrowser_get_MenuBar, + WebBrowser_put_MenuBar, + WebBrowser_get_FullScreen, + WebBrowser_put_FullScreen, + WebBrowser_Navigate2, + WebBrowser_QueryStatusWB, + WebBrowser_ExecWB, + WebBrowser_ShowBrowserBar, + WebBrowser_get_ReadyState, + WebBrowser_get_Offline, + WebBrowser_put_Offline, + WebBrowser_get_Silent, + WebBrowser_put_Silent, + WebBrowser_get_RegisterAsBrowser, + WebBrowser_put_RegisterAsBrowser, + WebBrowser_get_RegisterAsDropTarget, + WebBrowser_put_RegisterAsDropTarget, + WebBrowser_get_TheaterMode, + WebBrowser_put_TheaterMode, + WebBrowser_get_AddressBar, + WebBrowser_put_AddressBar, + WebBrowser_get_Resizable, + WebBrowser_put_Resizable +}; + +static inline WebBrowser *impl_from_IServiceProvider(IServiceProvider *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, IServiceProvider_iface); +} + +static HRESULT WINAPI WBServiceProvider_QueryInterface(IServiceProvider *iface, + REFIID riid, LPVOID *ppv) +{ + WebBrowser *This = impl_from_IServiceProvider(iface); + return IWebBrowser2_QueryInterface(&This->IWebBrowser2_iface, riid, ppv); +} + +static ULONG WINAPI WBServiceProvider_AddRef(IServiceProvider *iface) +{ + WebBrowser *This = impl_from_IServiceProvider(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WINAPI WBServiceProvider_Release(IServiceProvider *iface) +{ + WebBrowser *This = impl_from_IServiceProvider(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static HRESULT STDMETHODCALLTYPE WBServiceProvider_QueryService(IServiceProvider *iface, + REFGUID guidService, REFIID riid, void **ppv) +{ + WebBrowser *This = impl_from_IServiceProvider(iface); + + if(IsEqualGUID(&SID_SHTMLWindow, riid)) { + TRACE("(%p)->(SID_SHTMLWindow)\n", This); + return IHTMLWindow2_QueryInterface(&This->doc_host.html_window.IHTMLWindow2_iface, riid, ppv); + } + + if(IsEqualGUID(&IID_IBrowserService2, riid)) { + TRACE("(%p)->(IID_IBrowserService2 return E_FAIL)\n", This); + *ppv = NULL; + return E_FAIL; + } + + FIXME("(%p)->(%s, %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv); + *ppv = NULL; + return E_NOINTERFACE; +} + +static const IServiceProviderVtbl ServiceProviderVtbl = +{ + WBServiceProvider_QueryInterface, + WBServiceProvider_AddRef, + WBServiceProvider_Release, + WBServiceProvider_QueryService +}; + +static inline WebBrowser *impl_from_DocHost(DocHost *iface) +{ + return CONTAINING_RECORD(iface, WebBrowser, doc_host); +} + +static ULONG WebBrowser_addref(DocHost *iface) +{ + WebBrowser *This = impl_from_DocHost(iface); + return IWebBrowser2_AddRef(&This->IWebBrowser2_iface); +} + +static ULONG WebBrowser_release(DocHost *iface) +{ + WebBrowser *This = impl_from_DocHost(iface); + return IWebBrowser2_Release(&This->IWebBrowser2_iface); +} + +static void WINAPI DocHostContainer_GetDocObjRect(DocHost* This, RECT* rc) +{ + GetClientRect(This->frame_hwnd, rc); +} + +static HRESULT WINAPI DocHostContainer_SetStatusText(DocHost* This, LPCWSTR text) +{ + return E_NOTIMPL; +} + +static void WINAPI DocHostContainer_SetURL(DocHost* This, LPCWSTR url) +{ + +} + +static HRESULT DocHostContainer_exec(DocHost *doc_host, const GUID *cmd_group, DWORD cmdid, DWORD execopt, VARIANT *in, + VARIANT *out) +{ + WebBrowser *This = impl_from_DocHost(doc_host); + IOleCommandTarget *cmdtrg = NULL; + HRESULT hres; + + if(This->client) { + hres = IOleClientSite_QueryInterface(This->client, &IID_IOleCommandTarget, (void**)&cmdtrg); + if(FAILED(hres)) + cmdtrg = NULL; + } + + if(!cmdtrg && This->container) { + hres = IOleContainer_QueryInterface(This->container, &IID_IOleCommandTarget, (void**)&cmdtrg); + if(FAILED(hres)) + cmdtrg = NULL; + } + + if(!cmdtrg) + return E_NOTIMPL; + + hres = IOleCommandTarget_Exec(cmdtrg, cmd_group, cmdid, execopt, in, out); + IOleCommandTarget_Release(cmdtrg); + if(SUCCEEDED(hres)) + TRACE("Exec returned %08x %s\n", hres, debugstr_variant(out)); + else + FIXME("Exec failed\n"); + + return hres; +} + +static const IDocHostContainerVtbl DocHostContainerVtbl = { + WebBrowser_addref, + WebBrowser_release, + DocHostContainer_GetDocObjRect, + DocHostContainer_SetStatusText, + DocHostContainer_SetURL, + DocHostContainer_exec +}; + +static HRESULT create_webbrowser(int version, IUnknown *outer, REFIID riid, void **ppv) +{ + WebBrowser *ret; + HRESULT hres; + + TRACE("(%p %s %p) version=%d\n", outer, debugstr_guid(riid), ppv, version); + + ret = heap_alloc_zero(sizeof(WebBrowser)); + + ret->IWebBrowser2_iface.lpVtbl = &WebBrowser2Vtbl; + ret->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl; + ret->ref = 1; + ret->version = version; + + DocHost_Init(&ret->doc_host, &ret->IWebBrowser2_iface, &DocHostContainerVtbl); + + ret->visible = VARIANT_TRUE; + ret->menu_bar = VARIANT_TRUE; + ret->address_bar = VARIANT_TRUE; + ret->status_bar = VARIANT_TRUE; + ret->tool_bar = VARIANT_TRUE; + + WebBrowser_OleObject_Init(ret); + WebBrowser_ViewObject_Init(ret); + WebBrowser_Persist_Init(ret); + WebBrowser_ClassInfo_Init(ret); + + HlinkFrame_Init(&ret->hlink_frame, (IUnknown*)&ret->IWebBrowser2_iface, &ret->doc_host); + + lock_module(); + + hres = IWebBrowser2_QueryInterface(&ret->IWebBrowser2_iface, riid, ppv); + + IWebBrowser2_Release(&ret->IWebBrowser2_iface); + return hres; +} + +HRESULT WINAPI WebBrowserV1_Create(IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppv) +{ + return create_webbrowser(1, pOuter, riid, ppv); +} + +HRESULT WINAPI WebBrowser_Create(IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppv) +{ + return create_webbrowser(2, pOuter, riid, ppv); +} diff --git a/reactos/include/psdk/CMakeLists.txt b/reactos/include/psdk/CMakeLists.txt index a0e8a008dde..fab06367c95 100644 --- a/reactos/include/psdk/CMakeLists.txt +++ b/reactos/include/psdk/CMakeLists.txt @@ -36,11 +36,13 @@ list(APPEND SOURCE dimm.idl dispex.idl docobj.idl + docobjectservice.idl downloadmgr.idl # dyngraph.idl exdisp.idl fusion.idl hlink.idl + htiface.idl htiframe.idl httprequest.idl iads.idl diff --git a/reactos/include/psdk/docobjectservice.idl b/reactos/include/psdk/docobjectservice.idl new file mode 100644 index 00000000000..7478551b363 --- /dev/null +++ b/reactos/include/psdk/docobjectservice.idl @@ -0,0 +1,67 @@ +/* + * Copyright 2011 Piotr 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 + */ + +import "objidl.idl"; +import "mshtml.idl"; + +[ + local, + object, + uuid(3050f801-98b5-11cf-bb82-00aa00bdce0b) +] +interface IDocObjectService : IUnknown +{ + HRESULT FireBeforeNavigate2( + [in] IDispatch *pDispatch, + [in] LPCWSTR lpszUrl, + [in] DWORD dwFlags, + [in] LPCWSTR lpszFrameName, + [in] BYTE *pPostData, + [in] DWORD cbPostData, + [in] LPCWSTR lpszHeaders, + [in] BOOL fPlayNavSound, + [out] BOOL *pfCancel); + + HRESULT FireNavigateComplete2( + [in] IHTMLWindow2 *pHTMLWindow2, + [in] DWORD dwFlags); + + HRESULT FireDownloadBegin(void); + + HRESULT FireDownloadComplete(void); + + HRESULT FireDocumentComplete( + [in] IHTMLWindow2 *pHTMLWindow, + [in] DWORD dwFlags); + + HRESULT UpdateDesktopComponent( + [in] IHTMLWindow2 *pHTMLWindow); + + HRESULT GetPendingUrl( + [out] BSTR *pbstrPendingUrl); + + HRESULT ActiveElementChanged( + [in] IHTMLElement *pHTMLElement); + + HRESULT GetUrlSearchComponent( + [out] BSTR *pbstrSearch); + + HRESULT IsErrorUrl( + [in] LPCWSTR lpszUrl, + [out] BOOL *pfIsError); +}; diff --git a/reactos/include/psdk/htiface.idl b/reactos/include/psdk/htiface.idl new file mode 100644 index 00000000000..e82a7b40dd5 --- /dev/null +++ b/reactos/include/psdk/htiface.idl @@ -0,0 +1,128 @@ +/* + * Copyright 2006,2011 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 + */ + +import "objidl.idl"; +import "oleidl.idl"; +import "urlmon.idl"; + +cpp_quote("#include ") + + +/***************************************************************************** + * ITargetFrame interface + */ +[ + object, + uuid(d5f78c80-5252-11cf-90fa-00aa0042106e), + pointer_default(unique) +] +interface ITargetFrame: IUnknown +{ + typedef [unique] ITargetFrame *LPTARGETFRAME; + + typedef enum { + NAVIGATEFRAME_FL_RECORD = 0x01, + NAVIGATEFRAME_FL_POST = 0x02, + NAVIGATEFRAME_FL_NO_DOC_CACHE = 0x04, + NAVIGATEFRAME_FL_NO_IMAGE_CACHE = 0x08, + NAVIGATEFRAME_FL_AUTH_FAIL_CACHE_OK = 0x10, + NAVIGATEFRAME_FL_SENDING_FROM_FORM = 0x20, + NAVIGATEFRAME_FL_REALLY_SENDING_FROM_FORM = 0x40 + } NAVIGATEFRAME_FLAGS; + + typedef struct tagNavigateData { + ULONG ulTarget; + ULONG ulURL; + ULONG ulRefURL; + ULONG ulPostData; + DWORD dwFlags; + } NAVIGATEDATA; + + HRESULT SetFrameName([in] LPCWSTR pszFrameName); + HRESULT GetFrameName([out] LPWSTR *ppszFrameName); + HRESULT GetParentFrame([out] IUnknown **ppunkParent); + + HRESULT FindFrame( + [in] LPCWSTR pszTargetName, + [in] IUnknown *ppunkContextFrame, + [in] DWORD dwFlags, + [out] IUnknown **ppunkTargetFrame); + + HRESULT SetFrameSrc([in] LPCWSTR pszFrameSrc); + HRESULT GetFrameSrc([out] LPWSTR *ppszFrameSrc); +} + +/***************************************************************************** + * ITargetFramePriv interface + */ +[ + object, + uuid(9216e421-2bf5-11d0-82b4-00a0c90c29c5), + pointer_default(unique) +] +interface ITargetFramePriv : IUnknown +{ + typedef [unique] ITargetFramePriv *LPTARGETFRAMEPRIV; + + HRESULT FindFrameDownwards( + [in] LPCWSTR pszTargetName, + [in] DWORD dwFlags, + [out] IUnknown **ppunkTargetFrame); + + HRESULT FindFrameInContext( + [in] LPCWSTR pszTargetName, + [in] IUnknown *punkContextFrame, + [in] DWORD dwFlags, + [out] IUnknown **ppunkTargetFrame); + + HRESULT OnChildFrameActivate([in] IUnknown *pUnkChildFrame); + HRESULT OnChildFrameDeactivate([in] IUnknown *pUnkChildFrame); + + HRESULT NavigateHack( + [in] DWORD grfHLNF, + [in, unique] LPBC pbc, + [in, unique] IBindStatusCallback *pibsc, + [in, unique] LPCWSTR pszTargetName, + [in] LPCWSTR pszUrl, + [in, unique] LPCWSTR pszLocation); + + HRESULT FindBrowserByIndex( + [in] DWORD dwID, + [out] IUnknown **ppunkBrowser); +} + +/***************************************************************************** + * ITargetFramePriv2 interface + */ +[ + object, + uuid(b2c867e6-69d6-46f2-a611-ded9a4bd7fef), + pointer_default(unique) +] +interface ITargetFramePriv2 : ITargetFramePriv +{ + typedef [unique] ITargetFramePriv2 *LPTARGETFRAMEPRIV2; + + HRESULT AggregatedNavigation2( + [in] DWORD grfHLNF, + [in, unique] LPBC pbc, + [in, unique] IBindStatusCallback *pibsc, + [in, unique] LPCWSTR pszTargetName, + [in] IUri *pUri, + [in, unique] LPCWSTR pszLocation); +} diff --git a/reactos/include/psdk/shlobj.h b/reactos/include/psdk/shlobj.h index ff1599d5c8f..98ccd1d6988 100644 --- a/reactos/include/psdk/shlobj.h +++ b/reactos/include/psdk/shlobj.h @@ -1727,6 +1727,23 @@ BOOL WINAPI DAD_DragLeave(void); BOOL WINAPI DAD_AutoScroll(HWND,AUTO_SCROLL_DATA*,const POINT*); HRESULT WINAPI SHDoDragDrop(HWND,IDataObject*,IDropSource*,DWORD,LPDWORD); +/**************************************************************************** + * Internet shortcut properties + */ + +#define PID_IS_URL 2 +#define PID_IS_NAME 4 +#define PID_IS_WORKINGDIR 5 +#define PID_IS_HOTKEY 6 +#define PID_IS_SHOWCMD 7 +#define PID_IS_ICONINDEX 8 +#define PID_IS_ICONFILE 9 +#define PID_IS_WHATSNEW 10 +#define PID_IS_AUTHOR 11 +#define PID_IS_DESCRIPTION 12 +#define PID_IS_COMMENT 13 + + LPITEMIDLIST WINAPI ILAppendID(LPITEMIDLIST,LPCSHITEMID,BOOL); LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST); LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST); diff --git a/reactos/lib/sdk/uuid/CMakeLists.txt b/reactos/lib/sdk/uuid/CMakeLists.txt index 12c4e528f99..4a620f65c36 100644 --- a/reactos/lib/sdk/uuid/CMakeLists.txt +++ b/reactos/lib/sdk/uuid/CMakeLists.txt @@ -46,7 +46,7 @@ list(APPEND IDL_SOURCES hlink.idl # hnetbcon.idl # hnetcfg.idl -# htiface.idl + htiface.idl htiframe.idl # htmlfilter.idl httprequest.idl @@ -149,6 +149,7 @@ list(APPEND IDL_SOURCES bits.idl bits1_5.idl control.idl + docobjectservice.idl downloadmgr.idl fusion.idl iads.idl diff --git a/reactos/lib/sdk/uuid/ieguids.c b/reactos/lib/sdk/uuid/ieguids.c index a1847390313..1d1fe5c980f 100644 --- a/reactos/lib/sdk/uuid/ieguids.c +++ b/reactos/lib/sdk/uuid/ieguids.c @@ -10,6 +10,7 @@ DEFINE_GUID(IID_IBindStatusCallbackHolder,0x79eac9cc,0xbaf9,0x11ce,0x8c,0x82,0x0 DEFINE_GUID(CLSID_StdHlink, 0x79eac9d0, 0xbaf9, 0x11ce, 0x8c, 0x82, 0x00, 0xaa,0x00,0x4b,0xa9,0x0b); DEFINE_GUID(CLSID_StdHlinkBrowseContext, 0x79eac9d1, 0xbaf9, 0x11ce, 0x8c, 0x82, 0x00, 0xaa,0x00,0x4b,0xa9,0x0b); DEFINE_GUID(SID_SContainerDispatch, 0xb722be00,0x4e68,0x101b,0xa2,0xbc,0x00,0xaa,0x00,0x40,0x47,0x70); +DEFINE_GUID(CGID_DocHostCommandHandler,0xf38bc242,0xb950,0x11d1,0x89,0x18,0x00,0xc0,0x4f,0xc2,0xc8,0x36); //SID_SVersionHost //CGID_InternetExplorer @@ -35,7 +36,6 @@ DEFINE_GUID(SID_SContainerDispatch, 0xb722be00,0x4e68,0x101b,0xa2,0xbc,0x00,0xaa //BFID_RGB_4 //BFID_MONOCHROME //SID_SHTMLEditServices -//CGID_DocHostCommandHandler //CLSID_HTMLPluginDocument //CLSID_HTMLApplication //CLSID_HTADocument diff --git a/reactos/media/doc/README.WINE b/reactos/media/doc/README.WINE index 5573737ee3b..ca41c6476fb 100644 --- a/reactos/media/doc/README.WINE +++ b/reactos/media/doc/README.WINE @@ -70,6 +70,7 @@ reactos/dll/win32/hnetcfg # Synced to Wine-1.5.4 reactos/dll/win32/httpapi # Synced to Wine-1.5.4 reactos/dll/win32/iccvid # Synced to Wine-1.5.19 reactos/dll/win32/icmp # Synced to Wine-0_9_10 +reactos/dll/win32/ieframe # Synced to Wine-1.5.26 reactos/dll/win32/imaadp32.acm # Synced to Wine-1.5.4 reactos/dll/win32/imagehlp # Synced to Wine-1.5.4 reactos/dll/win32/imm32 # Synced to Wine-1.5.19