diff --git a/traydict/IEHtmlWin.cpp b/traydict/IEHtmlWin.cpp new file mode 100644 index 000000000..f4faa14f6 --- /dev/null +++ b/traydict/IEHtmlWin.cpp @@ -0,0 +1,1610 @@ +#include "IEHtmlWin.h" +//#include "App/EdApp.h" +#include +#include +#include +#include +#include +#include + +BEGIN_EVENT_TABLE(IEHtmlWin, wxWindow) + EVT_SIZE(IEHtmlWin::OnSize) + //EVT_MOVE(IEHtmlWin::OnMove) + EVT_SET_FOCUS(IEHtmlWin::OnSetFocus) + EVT_PAINT(IEHtmlWin::OnPaint) + EVT_MOUSE_EVENTS(IEHtmlWin::OnMouse) + EVT_CHAR(IEHtmlWin::OnChar) +END_EVENT_TABLE() + +void wxLogTrace(const wchar_t *lol) {} + +class IEHtmlWin; +class FS_IOleInPlaceFrame; +class FS_IOleInPlaceSiteWindowless; +class FS_IOleClientSite; +class FS_IOleControlSite; +class FS_IOleCommandTarget; +class FS_IOleItemContainer; +class FS_IDispatch; +class FS_DWebBrowserEvents2; +class FS_IAdviseSink2; +class FS_IAdviseSinkEx; + +class FrameSite : public IUnknown +{ + friend class IEHtmlWin; + friend class FS_IOleInPlaceFrame; + friend class FS_IOleInPlaceSiteWindowless; + friend class FS_IOleClientSite; + friend class FS_IOleControlSite; + friend class FS_IOleCommandTarget; + friend class FS_IOleItemContainer; + friend class FS_IDispatch; + friend class FS_DWebBrowserEvents2; + friend class FS_IAdviseSink2; + friend class FS_IAdviseSinkEx; +public: + FrameSite(IEHtmlWin * win); + ~FrameSite(); + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject); + ULONG STDMETHODCALLTYPE AddRef(); + ULONG STDMETHODCALLTYPE Release(); + +protected: + int m_cRef; + + FS_IOleInPlaceFrame * m_IOleInPlaceFrame; + FS_IOleInPlaceSiteWindowless * m_IOleInPlaceSiteWindowless; + FS_IOleClientSite * m_IOleClientSite; + FS_IOleControlSite * m_IOleControlSite; + FS_IOleCommandTarget * m_IOleCommandTarget; + FS_IOleItemContainer * m_IOleItemContainer; + FS_IDispatch * m_IDispatch; + FS_DWebBrowserEvents2 * m_DWebBrowserEvents2; + FS_IAdviseSink2 * m_IAdviseSink2; + FS_IAdviseSinkEx * m_IAdviseSinkEx; + + IEHtmlWin * m_window; + + HDC m_hDCBuffer; + HWND m_hWndParent; + + bool m_bSupportsWindowlessActivation; + bool m_bInPlaceLocked; + bool m_bInPlaceActive; + bool m_bUIActive; + bool m_bWindowless; + + LCID m_nAmbientLocale; + COLORREF m_clrAmbientForeColor; + COLORREF m_clrAmbientBackColor; + bool m_bAmbientShowHatching; + bool m_bAmbientShowGrabHandles; + bool m_bAmbientUserMode; + bool m_bAmbientAppearance; +}; + +class FS_IOleInPlaceFrame : public IOleInPlaceFrame +{ +public: + FS_IOleInPlaceFrame(FrameSite* fs) { m_fs = fs; } + ~FS_IOleInPlaceFrame() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IOleWindow + STDMETHODIMP GetWindow(HWND*); + STDMETHODIMP ContextSensitiveHelp(BOOL); + //IOleInPlaceUIWindow + STDMETHODIMP GetBorder(LPRECT); + STDMETHODIMP RequestBorderSpace(LPCBORDERWIDTHS); + STDMETHODIMP SetBorderSpace(LPCBORDERWIDTHS); + STDMETHODIMP SetActiveObject(IOleInPlaceActiveObject*, LPCOLESTR); + //IOleInPlaceFrame + STDMETHODIMP InsertMenus(HMENU, LPOLEMENUGROUPWIDTHS); + STDMETHODIMP SetMenu(HMENU, HOLEMENU, HWND); + STDMETHODIMP RemoveMenus(HMENU); + STDMETHODIMP SetStatusText(LPCOLESTR); + STDMETHODIMP EnableModeless(BOOL); + STDMETHODIMP TranslateAccelerator(LPMSG, WORD); +protected: + FrameSite * m_fs; +}; + +class FS_IOleInPlaceSiteWindowless : public IOleInPlaceSiteWindowless +{ +public: + FS_IOleInPlaceSiteWindowless(FrameSite* fs) { m_fs = fs; } + ~FS_IOleInPlaceSiteWindowless() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IOleWindow + STDMETHODIMP GetWindow(HWND* h) + { return m_fs->m_IOleInPlaceFrame->GetWindow(h); } + STDMETHODIMP ContextSensitiveHelp(BOOL b) + { return m_fs->m_IOleInPlaceFrame->ContextSensitiveHelp(b); } + //IOleInPlaceSite + STDMETHODIMP CanInPlaceActivate(); + STDMETHODIMP OnInPlaceActivate(); + STDMETHODIMP OnUIActivate(); + STDMETHODIMP GetWindowContext(IOleInPlaceFrame**, IOleInPlaceUIWindow**, + LPRECT, LPRECT, LPOLEINPLACEFRAMEINFO); + STDMETHODIMP Scroll(SIZE); + STDMETHODIMP OnUIDeactivate(BOOL); + STDMETHODIMP OnInPlaceDeactivate(); + STDMETHODIMP DiscardUndoState(); + STDMETHODIMP DeactivateAndUndo(); + STDMETHODIMP OnPosRectChange(LPCRECT); + //IOleInPlaceSiteEx + STDMETHODIMP OnInPlaceActivateEx(BOOL*, DWORD); + STDMETHODIMP OnInPlaceDeactivateEx(BOOL); + STDMETHODIMP RequestUIActivate(); + //IOleInPlaceSiteWindowless + STDMETHODIMP CanWindowlessActivate(); + STDMETHODIMP GetCapture(); + STDMETHODIMP SetCapture(BOOL); + STDMETHODIMP GetFocus(); + STDMETHODIMP SetFocus(BOOL); + STDMETHODIMP GetDC(LPCRECT, DWORD, HDC*); + STDMETHODIMP ReleaseDC(HDC); + STDMETHODIMP InvalidateRect(LPCRECT, BOOL); + STDMETHODIMP InvalidateRgn(HRGN, BOOL); + STDMETHODIMP ScrollRect(INT, INT, LPCRECT, LPCRECT); + STDMETHODIMP AdjustRect(LPRECT); + STDMETHODIMP OnDefWindowMessage(UINT, WPARAM, LPARAM, LRESULT*); +protected: + FrameSite * m_fs; +}; + +class FS_IOleClientSite : public IOleClientSite +{ +public: + FS_IOleClientSite(FrameSite* fs) { m_fs = fs; } + ~FS_IOleClientSite() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IOleClientSite + STDMETHODIMP SaveObject(); + STDMETHODIMP GetMoniker(DWORD, DWORD, IMoniker**); + STDMETHODIMP GetContainer(LPOLECONTAINER FAR*); + STDMETHODIMP ShowObject(); + STDMETHODIMP OnShowWindow(BOOL); + STDMETHODIMP RequestNewObjectLayout(); +protected: + FrameSite * m_fs; +}; + +class FS_IOleControlSite : public IOleControlSite +{ +public: + FS_IOleControlSite(FrameSite* fs) { m_fs = fs; } + ~FS_IOleControlSite() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IOleControlSite + STDMETHODIMP OnControlInfoChanged(); + STDMETHODIMP LockInPlaceActive(BOOL); + STDMETHODIMP GetExtendedControl(IDispatch**); + STDMETHODIMP TransformCoords(POINTL*, POINTF*, DWORD); + STDMETHODIMP TranslateAccelerator(LPMSG, DWORD); + STDMETHODIMP OnFocus(BOOL); + STDMETHODIMP ShowPropertyFrame(); +protected: + FrameSite * m_fs; +}; + +class FS_IOleCommandTarget : public IOleCommandTarget +{ +public: + FS_IOleCommandTarget(FrameSite* fs) { m_fs = fs; } + ~FS_IOleCommandTarget() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IOleCommandTarget + STDMETHODIMP QueryStatus(const GUID*, ULONG, OLECMD[], OLECMDTEXT*); + STDMETHODIMP Exec(const GUID*, DWORD, DWORD, VARIANTARG*, VARIANTARG*); +protected: + FrameSite * m_fs; +}; + +class FS_IOleItemContainer : public IOleItemContainer +{ +public: + FS_IOleItemContainer(FrameSite* fs) { m_fs = fs; } + ~FS_IOleItemContainer() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IParseDisplayName + STDMETHODIMP ParseDisplayName(IBindCtx*, LPOLESTR, ULONG*, IMoniker**); + //IOleContainer + STDMETHODIMP EnumObjects(DWORD, IEnumUnknown**); + STDMETHODIMP LockContainer(BOOL); + //IOleItemContainer + STDMETHODIMP GetObjectW(LPOLESTR, DWORD, IBindCtx*, REFIID, void**); + STDMETHODIMP GetObjectStorage(LPOLESTR, IBindCtx*, REFIID, void**); + STDMETHODIMP IsRunning(LPOLESTR); +protected: + FrameSite * m_fs; +}; + +class FS_IDispatch : public IDispatch +{ +public: + FS_IDispatch(FrameSite* fs) { m_fs = fs; } + ~FS_IDispatch() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IDispatch + STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR**, unsigned int, LCID, DISPID*); + STDMETHODIMP GetTypeInfo(unsigned int, LCID, ITypeInfo**); + STDMETHODIMP GetTypeInfoCount(unsigned int*); + STDMETHODIMP Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*); +protected: + FrameSite * m_fs; +}; + +class FS_DWebBrowserEvents2 : public DWebBrowserEvents2 +{ +public: + FS_DWebBrowserEvents2(FrameSite* fs) { m_fs = fs; } + ~FS_DWebBrowserEvents2() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IDispatch + STDMETHODIMP GetIDsOfNames(REFIID r, OLECHAR** o, unsigned int i, LCID l, DISPID* d) + { return m_fs->m_IDispatch->GetIDsOfNames(r, o, i, l, d); } + STDMETHODIMP GetTypeInfo(unsigned int i, LCID l, ITypeInfo** t) + { return m_fs->m_IDispatch->GetTypeInfo(i, l, t); } + STDMETHODIMP GetTypeInfoCount(unsigned int* i) + { return m_fs->m_IDispatch->GetTypeInfoCount(i); } + STDMETHODIMP Invoke(DISPID d, REFIID r, LCID l, WORD w, DISPPARAMS* dp, + VARIANT* v, EXCEPINFO* e, UINT* u) + { return m_fs->m_IDispatch->Invoke(d, r, l, w, dp, v, e, u); } +protected: + FrameSite * m_fs; +}; + +class FS_IAdviseSink2 : public IAdviseSink2 +{ +public: + FS_IAdviseSink2(FrameSite* fs) { m_fs = fs; } + ~FS_IAdviseSink2() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IAdviseSink + void STDMETHODCALLTYPE OnDataChange(FORMATETC*, STGMEDIUM*); + void STDMETHODCALLTYPE OnViewChange(DWORD, LONG); + void STDMETHODCALLTYPE OnRename(IMoniker*); + void STDMETHODCALLTYPE OnSave(); + void STDMETHODCALLTYPE OnClose(); + //IAdviseSink2 + void STDMETHODCALLTYPE OnLinkSrcChange(IMoniker*); +protected: + FrameSite * m_fs; +}; + +class FS_IAdviseSinkEx : public IAdviseSinkEx +{ +public: + FS_IAdviseSinkEx(FrameSite* fs) { m_fs = fs; } + ~FS_IAdviseSinkEx() {} + + //IUnknown + STDMETHODIMP QueryInterface(REFIID iid, void ** ppvObject) { return m_fs->QueryInterface(iid, ppvObject); } + ULONG STDMETHODCALLTYPE AddRef() { return m_fs->AddRef(); } + ULONG STDMETHODCALLTYPE Release() { return m_fs->Release(); } + //IAdviseSink + void STDMETHODCALLTYPE OnDataChange(FORMATETC* f, STGMEDIUM* s) + { m_fs->m_IAdviseSink2->OnDataChange(f, s); } + void STDMETHODCALLTYPE OnViewChange(DWORD d, LONG l) + { m_fs->m_IAdviseSink2->OnViewChange(d, l); } + void STDMETHODCALLTYPE OnRename(IMoniker* i) + { m_fs->m_IAdviseSink2->OnRename(i); } + void STDMETHODCALLTYPE OnSave() + { m_fs->m_IAdviseSink2->OnSave(); } + void STDMETHODCALLTYPE OnClose() + { m_fs->m_IAdviseSink2->OnClose(); } + //IAdviseSinkEx + void STDMETHODCALLTYPE OnViewStatusChange(DWORD); +protected: + FrameSite * m_fs; +}; + +class wxIStream : public IStream { + wxIStream(const wxString &src) : source(src) { + _refcount = 1; + pos = 0; + } + + ~wxIStream() { + } + +public: + HRESULT static OpenString(const wxString &str, IStream ** ppStream) { + *ppStream = new wxIStream(str); + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject) { + if (iid == __uuidof(IUnknown) || iid == __uuidof(IStream) || iid == __uuidof(ISequentialStream)) { + *ppvObject = static_cast(this); + AddRef(); + return S_OK; + } + else return E_NOINTERFACE; + } + + virtual ULONG STDMETHODCALLTYPE AddRef(void) { + return (ULONG)InterlockedIncrement(&_refcount); + } + + virtual ULONG STDMETHODCALLTYPE Release(void) { + ULONG res = (ULONG) InterlockedDecrement(&_refcount); + if (res == 0) delete this; + return res; + } + + // ISequentialStream Interface +public: + virtual HRESULT STDMETHODCALLTYPE Read(void* pv, ULONG cb, ULONG* pcbRead) { + memcpy(pv,&source[pos],cb*2); + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE Write(void const* pv, ULONG cb, ULONG* pcbWritten) { + return E_NOTIMPL; + } + + // IStream Interface +public: + virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE CopyTo(IStream*, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE Commit(DWORD) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE Revert(void) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE Clone(IStream **) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER liDistanceToMove, DWORD dwOrigin,ULARGE_INTEGER* lpNewFilePointer) { + return E_NOTIMPL; + } + + virtual HRESULT STDMETHODCALLTYPE Stat(STATSTG* pStatstg, DWORD grfStatFlag) { + return E_NOTIMPL; + } + +private: + const wxString &source; + int pos; + LONG _refcount; +}; + +IEHtmlWin::IEHtmlWin(wxWindow * parent, wxWindowID id) + : wxWindow(parent, id) +{ + m_oleObject = NULL; + m_oleInPlaceObject = NULL; + m_webBrowser = NULL; + + m_currentUrl = _T(""); + m_specificallyOpened = false; + + CreateBrowser(); +} + +static const CLSID CLSID_MozillaBrowser = +{ 0x1339B54C, 0x3453, 0x11D2, + { 0x93, 0xB9, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 } }; + +void IEHtmlWin::CreateBrowser() +{ + SetTransparent(255); + + HRESULT hret; + + IUnknown *p; + // Get IUnknown Interface + hret = CoCreateInstance(CLSID_WebBrowser, NULL, CLSCTX_ALL, IID_IUnknown, (void**)(&p)); + wxASSERT(SUCCEEDED(hret)); + + // Get IOleObject interface + hret = p->QueryInterface(IID_IViewObject, (void**)(&m_viewObject)); + wxASSERT(SUCCEEDED(hret)); + hret = p->QueryInterface(IID_IOleObject, (void**)(&m_oleObject)); + wxASSERT(SUCCEEDED(hret)); + + FrameSite * c = new FrameSite(this); + c->AddRef(); + + DWORD dwMiscStatus; + m_oleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus); + bool m_bSetClientSiteFirst = false; + if (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST) + { + m_bSetClientSiteFirst = true; + } + bool m_bVisibleAtRuntime = true; + if (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME) + { + m_bVisibleAtRuntime = false; + } + + if (m_bSetClientSiteFirst) m_oleObject->SetClientSite(c->m_IOleClientSite); + + IPersistStreamInit * psInit = NULL; + hret = p->QueryInterface(IID_IPersistStreamInit, (void**)(&psInit)); + if (SUCCEEDED(hret) && psInit != NULL) { + hret = psInit->InitNew(); + wxASSERT(SUCCEEDED(hret)); + } + + // Get IOleInPlaceObject interface + hret = p->QueryInterface(IID_IOleInPlaceObject, (void**)(&m_oleInPlaceObject)); + assert(SUCCEEDED(hret)); + + hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND); + wxASSERT(SUCCEEDED(hret)); + + ::SetActiveWindow(m_oleObjectHWND); + + int w, h; + GetSize(&w, &h); + RECT posRect; + posRect.left = 0; + posRect.top = 0; + posRect.right = w; + posRect.bottom = h; + + m_oleInPlaceObject->SetObjectRects(&posRect, &posRect); + + if (m_bVisibleAtRuntime) { + hret = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, + c->m_IOleClientSite, 0, (HWND)GetHWND(), &posRect); + } + + if (!m_bSetClientSiteFirst) m_oleObject->SetClientSite(c->m_IOleClientSite); + + // Get IWebBrowser2 Interface + hret = p->QueryInterface(IID_IWebBrowser2, (void**)(&m_webBrowser)); + assert(SUCCEEDED(hret)); + + IConnectionPointContainer * cpContainer; + hret = p->QueryInterface(IID_IConnectionPointContainer, (void**)(&cpContainer)); + assert(SUCCEEDED(hret)); + hret = cpContainer->FindConnectionPoint(DIID_DWebBrowserEvents2, &m_connectionPoint); + assert(SUCCEEDED(hret)); + m_connectionPoint->Advise(c->m_DWebBrowserEvents2, &m_adviseCookie); + cpContainer->Release(); + + p->Release(); + + m_webBrowser->put_MenuBar(VARIANT_FALSE); + m_webBrowser->put_AddressBar(VARIANT_FALSE); + m_webBrowser->put_StatusBar(VARIANT_FALSE); + m_webBrowser->put_ToolBar(VARIANT_FALSE); + + m_webBrowser->put_RegisterAsBrowser(VARIANT_TRUE); + m_webBrowser->put_RegisterAsDropTarget(VARIANT_TRUE); +} + +IEHtmlWin::~IEHtmlWin() +{ + if (m_oleInPlaceObject) { + m_oleInPlaceObject->InPlaceDeactivate(); + m_oleInPlaceObject->UIDeactivate(); + m_oleInPlaceObject->Release(); + } + if (m_connectionPoint) { + m_connectionPoint->Unadvise(m_adviseCookie); + m_connectionPoint->Release(); + } + if (m_oleObject) { + m_oleObject->Close(OLECLOSE_NOSAVE); + m_oleObject->SetClientSite(NULL); + m_oleObject->Release(); + } + if (m_viewObject) { + m_viewObject->Release(); + } + if (m_webBrowser) { + m_webBrowser->Release(); + } +} + +void IEHtmlWin::OnSize(wxSizeEvent& event) +{ + int w, h; + GetSize(&w, &h); + + if (m_webBrowser) { + m_webBrowser->put_Height(h); + m_webBrowser->put_Width(w); + } + + RECT posRect; + posRect.left = 0; + posRect.top = 0; + posRect.right = w; + posRect.bottom = h; + + //::SetWindowPos((HWND)GetHWND(), m_oleObjectHWND, 0, 0, w, h, SWP_NOMOVE | SWP_NOACTIVATE | SWP_HIDEWINDOW); + if (m_oleInPlaceObject) { + m_oleInPlaceObject->SetObjectRects(&posRect, &posRect); + } + +} + +void IEHtmlWin::OnMove(wxMoveEvent& event) +{ + int x, y; + GetPosition(&x, &y); + + if (m_webBrowser) { + m_webBrowser->put_Left(0/*x*/); + m_webBrowser->put_Top(0/*y*/); + } +} + +bool IEHtmlWin::Show(bool shown) +{ + bool ret; + ret = wxWindow::Show(shown); + //ret = ::ShowWindow(m_oleObjectHWND, (shown) ? SW_SHOW : SW_HIDE); + if (m_webBrowser) { + m_webBrowser->put_Visible(shown); + } + return ret; +} + +void IEHtmlWin::OnSetFocus(wxFocusEvent& event) +{ + if (m_webBrowser) { + m_webBrowser->put_Visible(TRUE); + ::PostMessage(m_oleObjectHWND, WM_SETFOCUS, (WPARAM)GetHWND(), NULL); + } + if (m_oleInPlaceObject) { + //::PostMessage(m_oleObjectHWND, WM_SETFOCUS, (WPARAM)GetHWND(), NULL); + } +} + +void IEHtmlWin::OnPaint(wxPaintEvent& event) +{ + wxLogTrace(_T("repainting html win")); + wxPaintDC dc(this); + int w, h; + GetSize(&w, &h); + RECT posRect; + posRect.left = 0; + posRect.top = 0; + posRect.right = w; + posRect.bottom = h; + + // Draw only when control is windowless or deactivated + if (m_viewObject) + { + ::RedrawWindow(m_oleObjectHWND, NULL, NULL, RDW_INTERNALPAINT); + { + RECTL *prcBounds = (RECTL *) &posRect; + m_viewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, + (HDC)dc.GetHDC(), prcBounds, NULL, NULL, 0); + } + } + else + { + dc.SetBrush(*wxRED_BRUSH); + dc.DrawRectangle(0, 0, w, h); + dc.SetBrush(wxNullBrush); + } +} + +void IEHtmlWin::OnMouse(wxMouseEvent& event) +{ + wxLogTrace(_T("mouse event")); + UINT msg = 0; + WPARAM wParam = 0; + LPARAM lParam = 0; + LRESULT lResult = 0; + + if (event.m_metaDown) wParam |= MK_CONTROL; + if (event.m_shiftDown) wParam |= MK_SHIFT; + if (event.m_leftDown) wParam |= MK_LBUTTON; + if (event.m_middleDown) wParam |= MK_MBUTTON; + if (event.m_rightDown) wParam |= MK_RBUTTON; + lParam = event.m_x << 16; + lParam |= event.m_y; + + if (event.LeftDown()) { + msg = WM_LBUTTONDOWN; + SetFocus(); + } + else if (event.LeftDClick()) msg = WM_LBUTTONDBLCLK; + else if (event.LeftUp()) msg = WM_LBUTTONUP; + else if (event.MiddleDown()) { + msg = WM_MBUTTONDOWN; + SetFocus(); + } + else if (event.MiddleDClick()) msg = WM_MBUTTONDBLCLK; + else if (event.MiddleUp()) msg = WM_MBUTTONUP; + else if (event.RightDown()) { + msg = WM_RBUTTONDOWN; + SetFocus(); + } + else if (event.RightDClick()) msg = WM_RBUTTONDBLCLK; + else if (event.RightUp()) msg = WM_RBUTTONUP; + else if (event.Moving() || event.Dragging()) msg = WM_MOUSEMOVE; + + wxString log; + if (msg == 0) { wxLogTrace(_T("no message")); event.Skip(); return; } + if (m_oleInPlaceObject == NULL) { wxLogTrace(_T("no oleInPlaceObject")); event.Skip(); return; } + if (!::SendMessage(m_oleObjectHWND, msg, wParam, lParam)) { wxLogTrace(_T("msg not delivered")); event.Skip(); return; } + wxLogTrace(_T("msg sent")); +} + +void IEHtmlWin::OnChar(wxKeyEvent& event) +{ +} + +bool IEHtmlWin::OnStartURL(wxString& url) +{ + wxLogTrace(_T("loading url:")); + wxLogTrace(url.c_str()); + + m_currentUrl = url; + if (m_specificallyOpened) { + m_specificallyOpened = false; + return true; + } + + // should we open this url? + // you should subclass IEHtmlWin and provide your own + // implementation of when to load the specificed url + + return true; +} + +void IEHtmlWin::OnProgressURL(long current, long maximum) +{ + //wxString log; + //log.Printf(_T("url progress: %li/%li", current, maximum); + //wxLogTrace(log.c_str()); +} + +void IEHtmlWin::OnFinishURL(wxString& url) +{ + wxLogTrace(_T("loaded url:")); + wxLogTrace(url.c_str()); + + m_currentUrl = url; +} + +void IEHtmlWin::OpenURL(const wxString& url) +{ + VARIANTARG navFlag, targetFrame, postData, headers; + navFlag.vt = VT_EMPTY; + //navFlag.vt = VT_I2; + //navFlag.iVal = navNoReadFromCache; + targetFrame.vt = VT_EMPTY; + postData.vt = VT_EMPTY; + headers.vt = VT_EMPTY; + + m_specificallyOpened = true; + + HRESULT hret; + hret = m_webBrowser->Navigate((BSTR)(const wchar_t*)url.wc_str(wxConvLibc), + &navFlag, &targetFrame, &postData, &headers); +} + +HRESULT LoadWebBrowserFromStream(IWebBrowser* pWebBrowser, IStream* pStream) +{ + HRESULT hr; + IDispatch* pHtmlDoc = NULL; + IPersistStreamInit* pPersistStreamInit = NULL; + + // Retrieve the document object. + hr = pWebBrowser->get_Document( &pHtmlDoc ); + if ( SUCCEEDED(hr) ) + { + // Query for IPersistStreamInit. + hr = pHtmlDoc->QueryInterface( IID_IPersistStreamInit, (void**)&pPersistStreamInit ); + if ( SUCCEEDED(hr) ) + { + // Initialize the document. + hr = pPersistStreamInit->InitNew(); + if ( SUCCEEDED(hr) ) + { + // Load the contents of the stream. + hr = pPersistStreamInit->Load( pStream ); + } + pPersistStreamInit->Release(); + } + } + return S_OK; +} + +void IEHtmlWin::LoadData(const wxString& data) { + HRESULT hr; + IUnknown* pUnkBrowser = NULL; + IUnknown* pUnkDisp = NULL; + IStream* pStream = NULL; + HGLOBAL hHTMLText; + wxCharBuffer buf = data.mb_str(wxConvUTF8); + const char *szHTMLText = buf.data(); + + // Is this the DocumentComplete event for the top frame window? + // Check COM identity: compare IUnknown interface pointers. + hr = m_webBrowser->QueryInterface( IID_IUnknown, (void**)&pUnkBrowser ); + if ( SUCCEEDED(hr) ) + { + hr = m_viewObject->QueryInterface( IID_IUnknown, (void**)&pUnkDisp ); + if ( SUCCEEDED(hr) ) + { + if ( pUnkBrowser == pUnkDisp ){ + size_t buffer = strlen(szHTMLText); + hHTMLText = GlobalAlloc(GPTR, buffer+1); + + if ( hHTMLText ) { + StringCchCopyA((char*)hHTMLText, buffer+1, szHTMLText); + + hr = CreateStreamOnHGlobal(hHTMLText, false, &pStream); + if ( SUCCEEDED(hr) ) + { + // Call the helper function to load the browser from the stream. + LoadWebBrowserFromStream(m_webBrowser, pStream); + pStream->Release(); + } + GlobalFree(hHTMLText); + } + } + pUnkDisp->Release(); + } + pUnkBrowser->Release(); + } +} + +FrameSite::FrameSite(IEHtmlWin * win) +{ + m_cRef = 0; + + m_window = win; + m_bSupportsWindowlessActivation = true; + m_bInPlaceLocked = false; + m_bUIActive = false; + m_bInPlaceActive = false; + m_bWindowless = false; + + m_nAmbientLocale = 0; + m_clrAmbientForeColor = ::GetSysColor(COLOR_WINDOWTEXT); + m_clrAmbientBackColor = ::GetSysColor(COLOR_WINDOW); + m_bAmbientUserMode = true; + m_bAmbientShowHatching = true; + m_bAmbientShowGrabHandles = true; + m_bAmbientAppearance = true; + + m_hDCBuffer = NULL; + m_hWndParent = (HWND)m_window->GetHWND(); + + m_IOleInPlaceFrame = new FS_IOleInPlaceFrame(this); + m_IOleInPlaceSiteWindowless = new FS_IOleInPlaceSiteWindowless(this); + m_IOleClientSite = new FS_IOleClientSite(this); + m_IOleControlSite = new FS_IOleControlSite(this); + m_IOleCommandTarget = new FS_IOleCommandTarget(this); + m_IOleItemContainer = new FS_IOleItemContainer(this); + //m_IOleItemContainer = NULL; + m_IDispatch = new FS_IDispatch(this); + m_DWebBrowserEvents2 = new FS_DWebBrowserEvents2(this); + m_IAdviseSink2 = new FS_IAdviseSink2(this); + m_IAdviseSinkEx = new FS_IAdviseSinkEx(this); +} + +FrameSite::~FrameSite() +{ + delete m_IAdviseSinkEx; + delete m_IAdviseSink2; + delete m_DWebBrowserEvents2; + delete m_IDispatch; + delete m_IOleItemContainer; + delete m_IOleCommandTarget; + delete m_IOleControlSite; + delete m_IOleClientSite; + delete m_IOleInPlaceSiteWindowless; + delete m_IOleInPlaceFrame; +} + +//IUnknown + +STDMETHODIMP FrameSite::QueryInterface(REFIID riid, void **ppv) +{ + if (ppv == NULL) return E_INVALIDARG; + *ppv = NULL; + if (riid == IID_IUnknown) + *ppv = this; + else if (riid == IID_IOleWindow || + riid == IID_IOleInPlaceUIWindow || + riid == IID_IOleInPlaceFrame) + *ppv = m_IOleInPlaceFrame; + else if (riid == IID_IOleInPlaceSite || + riid == IID_IOleInPlaceSiteEx || + riid == IID_IOleInPlaceSiteWindowless) + *ppv = m_IOleInPlaceSiteWindowless; + else if (riid == IID_IOleClientSite) + *ppv = m_IOleClientSite; + else if (riid == IID_IOleControlSite) + *ppv = m_IOleControlSite; + else if (riid == IID_IOleCommandTarget) + *ppv = m_IOleCommandTarget; + else if (riid == IID_IOleItemContainer || + riid == IID_IOleContainer || + riid == IID_IParseDisplayName) + *ppv = m_IOleItemContainer; + else if (riid == IID_IDispatch) + *ppv = m_IDispatch; + else if (riid == DIID_DWebBrowserEvents2) + *ppv = m_DWebBrowserEvents2; + else if (riid == IID_IAdviseSink || + riid == IID_IAdviseSink2) + *ppv = m_IAdviseSink2; + else if (riid == IID_IAdviseSinkEx) + *ppv = m_IAdviseSinkEx; + + if (*ppv == NULL) return (HRESULT) E_NOINTERFACE; + AddRef(); + return S_OK; +} + +STDMETHODIMP_(ULONG) FrameSite::AddRef() +{ + return ++m_cRef; +} + +STDMETHODIMP_(ULONG) FrameSite::Release() +{ + if ( --m_cRef == 0 ) { + delete this; + return 0; + } + else return m_cRef; +} + +//IDispatch + +HRESULT FS_IDispatch::GetIDsOfNames(REFIID riid, OLECHAR ** rgszNames, unsigned int cNames, + LCID lcid, DISPID * rgDispId) +{ + wxLogTrace(_T("IDispatch::GetIDsOfNames")); + return E_NOTIMPL; +} + +HRESULT FS_IDispatch::GetTypeInfo(unsigned int iTInfo, LCID lcid, ITypeInfo ** ppTInfo) +{ + wxLogTrace(_T("IDispatch::GetTypeInfo")); + return E_NOTIMPL; +} + +HRESULT FS_IDispatch::GetTypeInfoCount(unsigned int * pcTInfo) +{ + wxLogTrace(_T("IDispatch::GetTypeInfoCount")); + return E_NOTIMPL; +} + +HRESULT FS_IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, + WORD wFlags, DISPPARAMS * pDispParams, + VARIANT * pVarResult, EXCEPINFO * pExcepInfo, + unsigned int * puArgErr) +{ + wxLogTrace(_T("IDispatch::Invoke")); + if (wFlags & DISPATCH_PROPERTYGET) + { + if (pVarResult == NULL) return E_INVALIDARG; + switch (dispIdMember) + { + case DISPID_AMBIENT_APPEARANCE: + pVarResult->vt = VT_BOOL; + pVarResult->boolVal = m_fs->m_bAmbientAppearance; + break; + + case DISPID_AMBIENT_FORECOLOR: + pVarResult->vt = VT_I4; + pVarResult->lVal = (long) m_fs->m_clrAmbientForeColor; + break; + + case DISPID_AMBIENT_BACKCOLOR: + pVarResult->vt = VT_I4; + pVarResult->lVal = (long) m_fs->m_clrAmbientBackColor; + break; + + case DISPID_AMBIENT_LOCALEID: + pVarResult->vt = VT_I4; + pVarResult->lVal = (long) m_fs->m_nAmbientLocale; + break; + + case DISPID_AMBIENT_USERMODE: + pVarResult->vt = VT_BOOL; + pVarResult->boolVal = m_fs->m_bAmbientUserMode; + break; + + case DISPID_AMBIENT_SHOWGRABHANDLES: + pVarResult->vt = VT_BOOL; + pVarResult->boolVal = m_fs->m_bAmbientShowGrabHandles; + break; + + case DISPID_AMBIENT_SHOWHATCHING: + pVarResult->vt = VT_BOOL; + pVarResult->boolVal = m_fs->m_bAmbientShowHatching; + break; + + default: + return DISP_E_MEMBERNOTFOUND; + } + return S_OK; + } + + switch (dispIdMember) + { + case DISPID_BEFORENAVIGATE2: + { + VARIANT * vurl = pDispParams->rgvarg[5].pvarVal; + wxString url; + if (vurl->vt & VT_BYREF) url = *vurl->pbstrVal; + else url = vurl->bstrVal; + if (m_fs->m_window->OnStartURL(url)) { + *pDispParams->rgvarg->pboolVal = VARIANT_FALSE; + } else { + *pDispParams->rgvarg->pboolVal = VARIANT_TRUE; + } + break; + } + case DISPID_PROGRESSCHANGE: + { + long current = pDispParams->rgvarg[1].lVal; + long maximum = pDispParams->rgvarg[0].lVal; + m_fs->m_window->OnProgressURL(current, maximum); + break; + } + case DISPID_DOCUMENTCOMPLETE: + { + VARIANT * vurl = pDispParams->rgvarg[0].pvarVal; + wxString url; + if (vurl->vt & VT_BYREF) url = *vurl->pbstrVal; + else url = vurl->bstrVal; + m_fs->m_window->OnFinishURL(url); + break; + } + } + + return S_OK; +} + +//IOleWindow + +HRESULT FS_IOleInPlaceFrame::GetWindow(HWND * phwnd) +{ + wxLogTrace(_T("IOleWindow::GetWindow")); + if (phwnd == NULL) return E_INVALIDARG; + (*phwnd) = m_fs->m_hWndParent; + return S_OK; +} + +HRESULT FS_IOleInPlaceFrame::ContextSensitiveHelp(BOOL fEnterMode) +{ + wxLogTrace(_T("IOleWindow::ContextSensitiveHelp")); + return S_OK; +} + +//IOleInPlaceUIWindow + +HRESULT FS_IOleInPlaceFrame::GetBorder(LPRECT lprectBorder) +{ + wxLogTrace(_T("IOleInPlaceUIWindow::GetBorder")); + if (lprectBorder == NULL) return E_INVALIDARG; + return INPLACE_E_NOTOOLSPACE; +} + +HRESULT FS_IOleInPlaceFrame::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths) +{ + wxLogTrace(_T("IOleInPlaceUIWindow::RequestBorderSpace")); + if (pborderwidths == NULL) return E_INVALIDARG; + return INPLACE_E_NOTOOLSPACE; +} + +HRESULT FS_IOleInPlaceFrame::SetBorderSpace(LPCBORDERWIDTHS pborderwidths) +{ + wxLogTrace(_T("IOleInPlaceUIWindow::SetBorderSpace")); + return S_OK; +} + +HRESULT FS_IOleInPlaceFrame::SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName) +{ + wxLogTrace(_T("IOleInPlaceUIWindow::SetActiveObject")); + return S_OK; +} + +//IOleInPlaceFrame + +HRESULT FS_IOleInPlaceFrame::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths) +{ + wxLogTrace(_T("IOleInPlaceFrame::InsertMenus")); + return S_OK; +} + +HRESULT FS_IOleInPlaceFrame::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject) +{ + wxLogTrace(_T("IOleInPlaceFrame::SetMenu")); + return S_OK; +} + +HRESULT FS_IOleInPlaceFrame::RemoveMenus(HMENU hmenuShared) +{ + wxLogTrace(_T("IOleInPlaceFrame::RemoveMenus")); + return S_OK; +} + +HRESULT FS_IOleInPlaceFrame::SetStatusText(LPCOLESTR pszStatusText) +{ + wxLogTrace(_T("IOleInPlaceFrame::SetStatusText")); + //((wxFrame*)wxGetApp()->GetTopWindow())->GetStatusBar()->SetStatusText(pszStatusText); + return S_OK; +} + +HRESULT FS_IOleInPlaceFrame::EnableModeless(BOOL fEnable) +{ + wxLogTrace(_T("IOleInPlaceFrame::EnableModeless")); + return S_OK; +} + +HRESULT FS_IOleInPlaceFrame::TranslateAccelerator(LPMSG lpmsg, WORD wID) +{ + wxLogTrace(_T("IOleInPlaceFrame::TranslateAccelerator")); + // TODO: send an event with this id + return E_NOTIMPL; +} + +//IOleInPlaceSite + +HRESULT FS_IOleInPlaceSiteWindowless::CanInPlaceActivate() +{ + wxLogTrace(_T("IOleInPlaceSite::CanInPlaceActivate")); + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::OnInPlaceActivate() +{ + wxLogTrace(_T("IOleInPlaceSite::OnInPlaceActivate")); + m_fs->m_bInPlaceActive = true; + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::OnUIActivate() +{ + wxLogTrace(_T("IOleInPlaceSite::OnUIActivate")); + m_fs->m_bUIActive = true; + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::GetWindowContext(IOleInPlaceFrame **ppFrame, + IOleInPlaceUIWindow **ppDoc, + LPRECT lprcPosRect, + LPRECT lprcClipRect, + LPOLEINPLACEFRAMEINFO lpFrameInfo) +{ + wxLogTrace(_T("IOleInPlaceSite::GetWindowContext")); + if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL || + lprcClipRect == NULL || lpFrameInfo == NULL) + { + if (ppFrame != NULL) (*ppFrame) = NULL; + if (ppDoc != NULL) (*ppDoc) = NULL; + return E_INVALIDARG; + } + + (*ppDoc) = (*ppFrame) = m_fs->m_IOleInPlaceFrame; + (*ppDoc)->AddRef(); + (*ppFrame)->AddRef(); + + int w, h; + m_fs->m_window->GetSize(&w, &h); + lprcPosRect->left = lprcPosRect->top = 0; + lprcPosRect->right = w; + lprcPosRect->bottom = h; + lprcClipRect->left = lprcClipRect->top = 0; + lprcClipRect->right = w; + lprcClipRect->bottom = h; + + lpFrameInfo->fMDIApp = FALSE; + lpFrameInfo->hwndFrame = m_fs->m_hWndParent; + lpFrameInfo->haccel = NULL; + lpFrameInfo->cAccelEntries = 0; + + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::Scroll(SIZE scrollExtent) +{ + wxLogTrace(_T("IOleInPlaceSite::Scroll")); + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::OnUIDeactivate(BOOL fUndoable) +{ + wxLogTrace(_T("IOleInPlaceSite::OnUIDeactivate")); + m_fs->m_bUIActive = false; + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::OnInPlaceDeactivate() +{ + wxLogTrace(_T("IOleInPlaceSite::OnInPlaceDeactivate")); + m_fs->m_bInPlaceActive = false; + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::DiscardUndoState() +{ + wxLogTrace(_T("IOleInPlaceSite::DiscardUndoState")); + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::DeactivateAndUndo() +{ + wxLogTrace(_T("IOleInPlaceSite::DeactivateAndUndo")); + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::OnPosRectChange(LPCRECT lprcPosRect) +{ + wxLogTrace(_T("IOleInPlaceSite::OnPosRectChange")); + return S_OK; +} + +//IOleInPlaceSiteEx + +HRESULT FS_IOleInPlaceSiteWindowless::OnInPlaceActivateEx(BOOL * pfNoRedraw, DWORD dwFlags) +{ + wxLogTrace(_T("IOleInPlaceSiteEx::OnInPlaceActivateEx")); + if (pfNoRedraw) (*pfNoRedraw) = FALSE; + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::OnInPlaceDeactivateEx(BOOL fNoRedraw) +{ + wxLogTrace(_T("IOleInPlaceSiteEx::OnInPlaceDeactivateEx")); + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::RequestUIActivate() +{ + wxLogTrace(_T("IOleInPlaceSiteEx::RequestUIActivate")); + return S_FALSE; +} + +//IOleInPlaceSiteWindowless + +HRESULT FS_IOleInPlaceSiteWindowless::CanWindowlessActivate() +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::CanWindowlessActivate")); + return (m_fs->m_bSupportsWindowlessActivation) ? S_OK : S_FALSE; +} + +HRESULT FS_IOleInPlaceSiteWindowless::GetCapture() +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::GetCapture")); + return S_FALSE; +} + +HRESULT FS_IOleInPlaceSiteWindowless::SetCapture(BOOL fCapture) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::SetCapture")); + return S_FALSE; +} + +HRESULT FS_IOleInPlaceSiteWindowless::GetFocus() +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::GetFocus")); + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::SetFocus(BOOL fFocus) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::SetFocus")); + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::GetDC(LPCRECT pRect, DWORD grfFlags, HDC* phDC) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::GetDC")); + if (phDC == NULL) return E_INVALIDARG; + + if (grfFlags & OLEDC_NODRAW) + { + (*phDC) = m_fs->m_hDCBuffer; + return S_OK; + } + + if (m_fs->m_hDCBuffer != NULL) return E_UNEXPECTED; + + return E_NOTIMPL; +} + +HRESULT FS_IOleInPlaceSiteWindowless::ReleaseDC(HDC hDC) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::ReleaseDC")); + return E_NOTIMPL; +} + +HRESULT FS_IOleInPlaceSiteWindowless::InvalidateRect(LPCRECT pRect, BOOL fErase) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::InvalidateRect")); + // Clip the rectangle against the object's size and invalidate it + RECT rcI = { 0, 0, 0, 0 }; + RECT posRect; + int w, h; + m_fs->m_window->GetSize(&w, &h); + posRect.left = 0; + posRect.top = 0; + posRect.right = w; + posRect.bottom = h; + if (pRect == NULL) + { + rcI = posRect; + } + else + { + IntersectRect(&rcI, &posRect, pRect); + } + ::InvalidateRect(m_fs->m_hWndParent, &rcI, fErase); + + return S_OK; +} + +HRESULT FS_IOleInPlaceSiteWindowless::InvalidateRgn(HRGN, BOOL) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::InvalidateRgn")); + return E_NOTIMPL; +} + +HRESULT FS_IOleInPlaceSiteWindowless::ScrollRect(INT, INT, LPCRECT, LPCRECT) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::ScrollRect")); + return E_NOTIMPL; +} + +HRESULT FS_IOleInPlaceSiteWindowless::AdjustRect(LPRECT) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::AdjustRect")); + return E_NOTIMPL; +} + +HRESULT FS_IOleInPlaceSiteWindowless::OnDefWindowMessage(UINT, WPARAM, LPARAM, LRESULT*) +{ + wxLogTrace(_T("IOleInPlaceSiteWindowless::OnDefWindowMessage")); + return E_NOTIMPL; +} + +//IOleClientSite + +HRESULT FS_IOleClientSite::SaveObject() +{ + wxLogTrace(_T("IOleClientSite::SaveObject")); + return S_OK; +} + +HRESULT FS_IOleClientSite::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, + IMoniker ** ppmk) +{ + wxLogTrace(_T("IOleClientSite::GetMoniker")); + return E_NOTIMPL; +} + +HRESULT FS_IOleClientSite::GetContainer(LPOLECONTAINER * ppContainer) +{ + wxLogTrace(_T("IOleClientSite::GetContainer")); + if (ppContainer == NULL) return E_INVALIDARG; + this->QueryInterface(IID_IOleContainer, (void**)(ppContainer)); + return S_OK; +} + +HRESULT FS_IOleClientSite::ShowObject() +{ + wxLogTrace(_T("IOleClientSite::ShowObject")); + return S_OK; +} + +HRESULT FS_IOleClientSite::OnShowWindow(BOOL fShow) +{ + wxLogTrace(_T("IOleClientSite::OnShowWindow")); + return S_OK; +} + +HRESULT FS_IOleClientSite::RequestNewObjectLayout() +{ + wxLogTrace(_T("IOleClientSite::RequestNewObjectLayout")); + return E_NOTIMPL; +} + +//IParseDisplayName + +HRESULT FS_IOleItemContainer::ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName, + ULONG *pchEaten, IMoniker **ppmkOut) +{ + wxLogTrace(_T("IParseDisplayName::ParseDisplayName")); + return E_NOTIMPL; +} + +//IOleContainer + +HRESULT FS_IOleItemContainer::EnumObjects(DWORD grfFlags, IEnumUnknown **ppenum) +{ + wxLogTrace(_T("IOleContainer::EnumObjects")); + return E_NOTIMPL; +} + +HRESULT FS_IOleItemContainer::LockContainer(BOOL fLock) +{ + wxLogTrace(_T("IOleContainer::LockContainer")); + // TODO + return S_OK; +} + +//IOleItemContainer + +HRESULT FS_IOleItemContainer::GetObjectW(LPOLESTR pszItem, DWORD dwSpeedNeeded, + IBindCtx * pbc, REFIID riid, void ** ppvObject) +{ + wxLogTrace(_T("IOleItemContainer::GetObject")); + if (pszItem == NULL) return E_INVALIDARG; + if (ppvObject == NULL) return E_INVALIDARG; + + *ppvObject = NULL; + return MK_E_NOOBJECT; +} + +HRESULT FS_IOleItemContainer::GetObjectStorage(LPOLESTR pszItem, IBindCtx * pbc, + REFIID riid, void ** ppvStorage) +{ + wxLogTrace(_T("IOleItemContainer::GetObjectStorage")); + if (pszItem == NULL) return E_INVALIDARG; + if (ppvStorage == NULL) return E_INVALIDARG; + + *ppvStorage = NULL; + return MK_E_NOOBJECT; +} + +HRESULT FS_IOleItemContainer::IsRunning(LPOLESTR pszItem) +{ + wxLogTrace(_T("IOleItemContainer::IsRunning")); + if (pszItem == NULL) return E_INVALIDARG; + + return MK_E_NOOBJECT; +} + +//IOleControlSite + +HRESULT FS_IOleControlSite::OnControlInfoChanged() +{ + wxLogTrace(_T("IOleControlSite::OnControlInfoChanged")); + return S_OK; +} + +HRESULT FS_IOleControlSite::LockInPlaceActive(BOOL fLock) +{ + wxLogTrace(_T("IOleControlSite::LockInPlaceActive")); + m_fs->m_bInPlaceLocked = (fLock) ? true : false; + return S_OK; +} + +HRESULT FS_IOleControlSite::GetExtendedControl(IDispatch ** ppDisp) +{ + wxLogTrace(_T("IOleControlSite::GetExtendedControl")); + return E_NOTIMPL; +} + +HRESULT FS_IOleControlSite::TransformCoords(POINTL * pPtlHimetric, POINTF * pPtfContainer, DWORD dwFlags) +{ + wxLogTrace(_T("IOleControlSite::TransformCoords")); + HRESULT hr = S_OK; + + if (pPtlHimetric == NULL) + { + return E_INVALIDARG; + } + if (pPtfContainer == NULL) + { + return E_INVALIDARG; + } + + HDC hdc = ::GetDC(m_fs->m_hWndParent); + ::SetMapMode(hdc, MM_HIMETRIC); + POINT rgptConvert[2]; + rgptConvert[0].x = 0; + rgptConvert[0].y = 0; + + if (dwFlags & XFORMCOORDS_HIMETRICTOCONTAINER) + { + rgptConvert[1].x = pPtlHimetric->x; + rgptConvert[1].y = pPtlHimetric->y; + ::LPtoDP(hdc, rgptConvert, 2); + if (dwFlags & XFORMCOORDS_SIZE) + { + pPtfContainer->x = (float)(rgptConvert[1].x - rgptConvert[0].x); + pPtfContainer->y = (float)(rgptConvert[0].y - rgptConvert[1].y); + } + else if (dwFlags & XFORMCOORDS_POSITION) + { + pPtfContainer->x = (float)rgptConvert[1].x; + pPtfContainer->y = (float)rgptConvert[1].y; + } + else + { + hr = E_INVALIDARG; + } + } + else if (dwFlags & XFORMCOORDS_CONTAINERTOHIMETRIC) + { + rgptConvert[1].x = (int)(pPtfContainer->x); + rgptConvert[1].y = (int)(pPtfContainer->y); + ::DPtoLP(hdc, rgptConvert, 2); + if (dwFlags & XFORMCOORDS_SIZE) + { + pPtlHimetric->x = rgptConvert[1].x - rgptConvert[0].x; + pPtlHimetric->y = rgptConvert[0].y - rgptConvert[1].y; + } + else if (dwFlags & XFORMCOORDS_POSITION) + { + pPtlHimetric->x = rgptConvert[1].x; + pPtlHimetric->y = rgptConvert[1].y; + } + else + { + hr = E_INVALIDARG; + } + } + else + { + hr = E_INVALIDARG; + } + + ::ReleaseDC(m_fs->m_hWndParent, hdc); + return hr; +} + +HRESULT FS_IOleControlSite::TranslateAccelerator(LPMSG pMsg, DWORD grfModifiers) +{ + wxLogTrace(_T("IOleControlSite::TranslateAccelerator")); + // TODO: send an event with this id + return E_NOTIMPL; +} + +HRESULT FS_IOleControlSite::OnFocus(BOOL fGotFocus) +{ + wxLogTrace(_T("IOleControlSite::OnFocus")); + return S_OK; +} + +HRESULT FS_IOleControlSite::ShowPropertyFrame() +{ + wxLogTrace(_T("IOleControlSite::ShowPropertyFrame")); + return E_NOTIMPL; +} + +//IOleCommandTarget + +HRESULT FS_IOleCommandTarget::QueryStatus(const GUID * pguidCmdGroup, ULONG cCmds, + OLECMD * prgCmds, OLECMDTEXT * pCmdTet) +{ + wxLogTrace(_T("IOleCommandTarget::QueryStatus")); + if (prgCmds == NULL) return E_INVALIDARG; + bool bCmdGroupFound = false; + + for (ULONG nCmd = 0; nCmd < cCmds; nCmd++) + { + // unsupported by default + prgCmds[nCmd].cmdf = 0; + + // TODO + } + + if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; } + return S_OK; +} + +HRESULT FS_IOleCommandTarget::Exec(const GUID * pguidCmdGroup, DWORD nCmdID, + DWORD nCmdExecOpt, VARIANTARG * pVaIn, + VARIANTARG * pVaOut) +{ + wxLogTrace(_T("IOleCommandTarget::Exec")); + bool bCmdGroupFound = false; + + if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; } + return OLECMDERR_E_NOTSUPPORTED; +} + +//IAdviseSink + +void STDMETHODCALLTYPE FS_IAdviseSink2::OnDataChange(FORMATETC * pFormatEtc, STGMEDIUM * pgStgMed) +{ + wxLogTrace(_T("IAdviseSink::OnDataChange")); +} + +void STDMETHODCALLTYPE FS_IAdviseSink2::OnViewChange(DWORD dwAspect, LONG lIndex) +{ + wxLogTrace(_T("IAdviseSink::OnViewChange")); + // redraw the control + m_fs->m_IOleInPlaceSiteWindowless->InvalidateRect(NULL, FALSE); +} + +void STDMETHODCALLTYPE FS_IAdviseSink2::OnRename(IMoniker * pmk) +{ + wxLogTrace(_T("IAdviseSink::OnRename")); +} + +void STDMETHODCALLTYPE FS_IAdviseSink2::OnSave() +{ + wxLogTrace(_T("IAdviseSink::OnSave")); +} + +void STDMETHODCALLTYPE FS_IAdviseSink2::OnClose() +{ + wxLogTrace(_T("IAdviseSink::OnClose")); +} + +//IAdviseSink2 + +void STDMETHODCALLTYPE FS_IAdviseSink2::OnLinkSrcChange(IMoniker * pmk) +{ + wxLogTrace(_T("IAdviseSink2::OnLinkSrcChange")); +} + +//IAdviseSinkEx + +void STDMETHODCALLTYPE FS_IAdviseSinkEx::OnViewStatusChange(DWORD dwViewStatus) +{ + wxLogTrace(_T("IAdviseSinkEx::OnViewStatusChange")); +} + diff --git a/traydict/IEHtmlWin.h b/traydict/IEHtmlWin.h new file mode 100644 index 000000000..285ae10ad --- /dev/null +++ b/traydict/IEHtmlWin.h @@ -0,0 +1,50 @@ +#ifndef _IEHTMLWIN_H_ +#define _IEHTMLWIN_H_ + +#include +#include +#include + +class IEHtmlWin : public wxWindow { +public: + IEHtmlWin(wxWindow * parent, wxWindowID id = -1); + virtual ~IEHtmlWin(); + + void OpenURL(const wxString&); + void LoadData(const wxString&); + + bool Show(bool shown = true); + + void CreateBrowser(); + + void OnPaint(wxPaintEvent&); + void OnSize(wxSizeEvent&); + void OnMove(wxMoveEvent&); + void OnSetFocus(wxFocusEvent&); + void OnMouse(wxMouseEvent&); + void OnChar(wxKeyEvent&); + + virtual bool OnStartURL(wxString& url); + virtual void OnFinishURL(wxString& url); + virtual void OnProgressURL(long current, long maximum); + + wxString& GetOpenedPage() { return m_currentUrl; } + + DECLARE_EVENT_TABLE(); + +protected: + + wxString m_currentUrl; + bool m_specificallyOpened; + + IWebBrowser2 * m_webBrowser; + IOleObject * m_oleObject; + IOleInPlaceObject * m_oleInPlaceObject; + IViewObject * m_viewObject; + IConnectionPoint * m_connectionPoint; + HWND m_oleObjectHWND; + + DWORD m_adviseCookie; +}; + +#endif /* _IEHTMLWIN_H_ */ diff --git a/traydict/TrayDict.vcproj b/traydict/TrayDict.vcproj index 79022428b..2db20a2cb 100644 --- a/traydict/TrayDict.vcproj +++ b/traydict/TrayDict.vcproj @@ -66,8 +66,8 @@ Name="VCLinkerTool" OutputFile="bin/traydict_d.exe" LinkIncremental="1" - AdditionalLibraryDirectories="D:\wxWidgets-2.8.6\lib\vc_lib" - IgnoreDefaultLibraryNames="" + AdditionalLibraryDirectories="D:\wxWidgets-2.8.6\lib\vc_lib;F:\Projects\aegisub\src\traydict\geckolib" + IgnoreDefaultLibraryNames="msvcrt.lib" GenerateDebugInformation="true" SubSystem="2" TargetMachine="1" @@ -289,6 +289,18 @@ RelativePath=".\dictionary_display.h" > + + + + + + @@ -297,6 +309,14 @@ RelativePath=".\gecko_display.h" > + + + + diff --git a/traydict/dict_window.cpp b/traydict/dict_window.cpp index 3e8dd153f..b79720e21 100644 --- a/traydict/dict_window.cpp +++ b/traydict/dict_window.cpp @@ -124,6 +124,7 @@ DictWindow::DictWindow() results = new DictionaryDisplay(this); manager->AddPane(results,wxCENTER,_("Results")); manager->Update(); + results->InitGecko(); // Create dictionary files if (false) { diff --git a/traydict/dictionary_display.cpp b/traydict/dictionary_display.cpp index 48e27e23d..a39ac31b4 100644 Binary files a/traydict/dictionary_display.cpp and b/traydict/dictionary_display.cpp differ diff --git a/traydict/dictionary_display.h b/traydict/dictionary_display.h index b918272b9..cc1b686bd 100644 --- a/traydict/dictionary_display.h +++ b/traydict/dictionary_display.h @@ -39,15 +39,23 @@ /////////// // Headers #include "dictionary.h" +//#include "IEHtmlWin.h" #include "gecko_display.h" /////////////////////////////////// // Dictionary result display class +//class DictionaryDisplay : public IEHtmlWin { class DictionaryDisplay : public GeckoDisplay { +private: + wxString data; + public: DictionaryDisplay(wxWindow *parent); + void SetText(wxString text); + void AppendText(wxString text); + void PrintResults(const ResultSet &results); void ResultsStart(); void ResultsDone(); diff --git a/traydict/gecko_controller.cpp b/traydict/gecko_controller.cpp new file mode 100644 index 000000000..7a6300f7e --- /dev/null +++ b/traydict/gecko_controller.cpp @@ -0,0 +1,346 @@ +// Copyright (c) 2007, Rodrigo Braz Monteiro +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of the TrayDict Group nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ----------------------------------------------------------------------------- +// +// TRAYDICT +// +// Website: http://aegisub.cellosoft.com +// Contact: mailto:zeratul@cellosoft.com +// + + +/////////// +// Headers +#include "gecko_controller.h" +#include "gecko_display.h" +#include "gecko/nsEmbedCID.h" +#include "gecko/nsCOMPtr.h" +#include "gecko/nsIProfile.h" +#include "gecko/nsServiceManagerUtils.h" +#include "gecko/nsXPCOM.h" +#include "gecko/nsIComponentRegistrar.h" +#include "gecko/nsComponentManagerUtils.h" +#include "gecko/nsIWebBrowserSetup.h" +#include "gecko/nsIInterfaceRequestor.h" +#include "gecko/nsIBaseWindow.h" +#include "gecko/nsIWidget.h" + + +///////////// +// Libraries +#if __VISUALC__ >= 1200 +#pragma comment(lib,"nspr4.lib") +#pragma comment(lib,"plds4.lib") +#pragma comment(lib,"plc4.lib") +#pragma comment(lib,"xpcom.lib") +#pragma comment(lib,"embed_base_s.lib") +#pragma comment(lib,"xpcomglue_s.lib") +#pragma comment(lib,"xpcomglue.lib") +#endif + + +/////////// +// Statics +int GeckoController::controllers = 0; + + +/////////////// +// Constructor +GeckoController::GeckoController(GeckoDisplay *_display,const wxString _path) +{ + try { + // Setup + nsresult rv; + display = _display; + + // Gecko Controller count + controllers++; + + // Initialize Gecko + if (controllers == 1) { + // Get folder + nsCOMPtr file; + wxString path = _path; + path = path.Left(path.Length()-1); + rv = NS_NewLocalFile(nsString(path.c_str()),false,getter_AddRefs(file)); + if (NS_FAILED(rv)) throw rv; + + // Initialize embedding + rv = NS_InitEmbedding(file,nsnull); + // If at first you don't succeed... (and you won't) + if (NS_FAILED(rv)) { + // ...the second does seem to work, though. lol, gecko. + rv = NS_InitEmbedding(file,nsnull); + if (NS_FAILED(rv)) throw rv; + } + + // Register factories... I think + if (NS_FAILED(rv)) throw rv; + nsCOMPtr registrar; + rv = NS_GetComponentRegistrar(getter_AddRefs(registrar)); + if (NS_FAILED(rv)) throw rv; + rv = registrar->AutoRegister(nsnull); + } + + AddRef(); + + // Create browser + nsWebBrowser = do_CreateInstance(NS_WEBBROWSER_CONTRACTID,&rv); + if (NS_FAILED(rv)) throw rv; + + // Get pointer to navigation + rv = NS_OK; + nsNav = do_QueryInterface(nsWebBrowser, &rv); + if (NS_FAILED(rv)) throw rv; + + // Set container window + rv = nsWebBrowser->SetContainerWindow(NS_STATIC_CAST(nsIWebBrowserChrome*, this)); + if (NS_FAILED(rv)) throw rv; + + // Setup + nsCOMPtr setup (do_QueryInterface(nsWebBrowser)); + if (setup) setup->SetProperty(nsIWebBrowserSetup::SETUP_IS_CHROME_WRAPPER,PR_TRUE); + else throw NS_ERROR_FAILURE; + + // Create the base window + rv = NS_OK; + mBaseWindow = do_QueryInterface(nsWebBrowser, &rv); + if (NS_FAILED(rv)) throw rv; + + // Initialize the window + wxSize size = display->GetClientSize(); + rv = mBaseWindow->InitWindow(nsNativeWidget(display->GetHandle()), nsnull,0, 0, size.GetWidth(),size.GetHeight()); + if (NS_FAILED(rv)) throw rv; + rv = mBaseWindow->Create(); + if (NS_FAILED(rv)) throw rv; + + // Set listener + //nsCOMPtr listener(NS_STATIC_CAST(nsIWebProgressListener*, this)); + //nsCOMPtr thisListener(do_GetWeakReference(listener)); + //rv = nsWebBrowser->AddWebBrowserListener(thisListener, NS_GET_IID(nsIWebProgressListener)); + nsWeakPtr weakling (dont_AddRef(NS_GetWeakReference(NS_STATIC_CAST(nsIWebProgressListener*, this)))); + rv = nsWebBrowser->AddWebBrowserListener(weakling, NS_GET_IID(nsIWebProgressListener)); + if (NS_FAILED(rv)) throw rv; + + // Show window + rv = mBaseWindow->SetVisibility(PR_TRUE); + if (NS_FAILED(rv)) throw rv; + + // Navigate somewhere for shits and giggles + rv = nsNav->LoadURI(L"http://www.aegisub.net",nsIWebNavigation::LOAD_FLAGS_NONE,nsnull,nsnull,nsnull); + if (NS_FAILED(rv)) throw rv; + } + + // Failed + catch (...) { + NS_TermEmbedding(); + } +} + + +////////////// +// Destructor +GeckoController::~GeckoController() +{ + controllers--; + if (controllers == 0) NS_TermEmbedding(); +} + + +//////////// +// Set size +void GeckoController::SetSize(wxSize &size) +{ + mBaseWindow->SetPositionAndSize(0,0,size.GetWidth(),size.GetHeight(),true); + //mBaseWindow->SetPositionAndSize(32,32,size.GetWidth()-64,size.GetHeight()-64,true); + mBaseWindow->SetVisibility(true); +} + + +/////////////// +// nsISupports +NS_IMPL_ADDREF(GeckoController) +NS_IMPL_RELEASE(GeckoController) + +NS_INTERFACE_MAP_BEGIN(GeckoController) +NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebBrowserChrome) +//NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) +NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome) +NS_INTERFACE_MAP_ENTRY(nsIEmbeddingSiteWindow) +NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) +NS_INTERFACE_MAP_ENTRY(nsSupportsWeakReference) +NS_INTERFACE_MAP_END + + +/////////////////////// +// nsIWebBrowserChrome +nsresult GeckoController::SetStatus(PRUint32 statusType, const PRUnichar *status) +{ + return NS_OK; +} + +nsresult GeckoController::DestroyBrowserWindow() +{ + return NS_OK; +} + +nsresult GeckoController::SizeBrowserTo(PRInt32 aCX, PRInt32 aCY) +{ + display->SetClientSize(aCX,aCY); + return NS_OK; +} + +nsresult GeckoController::ShowAsModal() +{ + return NS_OK; +} + +nsresult GeckoController::IsWindowModal(PRBool *_retval) +{ + *_retval = FALSE; + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult GeckoController::ExitModalEventLoop(nsresult aStatus) +{ + return NS_OK; +} + +nsresult GeckoController::SetWebBrowser(nsIWebBrowser *aWebBrowser) +{ + nsWebBrowser = aWebBrowser; + return NS_OK; +} + +nsresult GeckoController::GetWebBrowser(nsIWebBrowser **aWebBrowser) +{ + if (aWebBrowser) *aWebBrowser = nsWebBrowser; + return NS_OK; +} + +nsresult GeckoController::SetChromeFlags(PRUint32 aChromeFlags) +{ + mChromeFlags = aChromeFlags; + return NS_OK; +} + +nsresult GeckoController::GetChromeFlags(PRUint32 *aChromeFlags) +{ + if (aChromeFlags) *aChromeFlags = mChromeFlags; + return NS_OK; +} + + +////////////////////////// +// nsIEmbeddingSiteWindow +nsresult GeckoController::SetDimensions(PRUint32 flags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy) +{ + return NS_OK; +} + +nsresult GeckoController::GetDimensions(PRUint32 flags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy) +{ + wxRect pos = display->GetClientRect(); + if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION) { + if (x) *x = pos.GetLeft(); + if (y) *y = pos.GetTop(); + } + else if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER) { + wxRect size = display->GetClientSize(); + if (cx) *cx = size.GetWidth(); + if (cy) *cy = size.GetHeight(); + } + else if (flags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER) { + wxRect size = display->GetSize(); + if (cx) *cx = size.GetWidth(); + if (cy) *cy = size.GetHeight(); + } + return NS_OK; +} + +nsresult GeckoController::SetFocus(void) +{ + display->SetFocus(); + return NS_OK; +} + +nsresult GeckoController::GetVisibility(PRBool *aVisibility) +{ + *aVisibility = TRUE; + return NS_OK; +} + +nsresult GeckoController::SetVisibility(PRBool aVisibility) +{ + return NS_OK; +} + +nsresult GeckoController::GetTitle(PRUnichar * *aTitle) +{ + if (aTitle) *aTitle = nsnull; + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult GeckoController::SetTitle(const PRUnichar * aTitle) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult GeckoController::GetSiteWindow(void * *aSiteWindow) +{ + if (aSiteWindow) *aSiteWindow = (nativeWindow) display->GetHandle(); + return NS_OK; +} + + +////////////////////////// +// nsIWebProgressListener +nsresult GeckoController::OnStateChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRUint32 aStateFlags, nsresult aStatus) +{ + return NS_OK; +} + +nsresult GeckoController::OnProgressChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRInt32 aCurSelfProgress, PRInt32 aMaxSelfProgress, PRInt32 aCurTotalProgress, PRInt32 aMaxTotalProgress) +{ + return NS_OK; +} + +nsresult GeckoController::OnLocationChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsIURI *aLocation) +{ + return NS_OK; +} + +nsresult GeckoController::OnStatusChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsresult aStatus, const PRUnichar *aMessage) +{ + return NS_OK; +} + +nsresult GeckoController::OnSecurityChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRUint32 aState) +{ + return NS_OK; +} diff --git a/traydict/gecko_controller.h b/traydict/gecko_controller.h new file mode 100644 index 000000000..dc3ca7e91 --- /dev/null +++ b/traydict/gecko_controller.h @@ -0,0 +1,86 @@ +// Copyright (c) 2007, Rodrigo Braz Monteiro +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of the TrayDict Group nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ----------------------------------------------------------------------------- +// +// TRAYDICT +// +// Website: http://aegisub.cellosoft.com +// Contact: mailto:zeratul@cellosoft.com +// + +#pragma once + + +/////////// +// Headers +#include +#include "gecko/nsStringAPI.h" +#include "gecko/nsEmbedAPI.h" +#include "gecko/nsIWebBrowserChrome.h" +#include "gecko/nsIEmbeddingSiteWindow.h" +#include "gecko/nsIWebProgressListener.h" +#include "gecko/nsWeakReference.h" +#include "gecko/nsIWebNavigation.h" +#include "gecko/nsIWebBrowser.h" +#include "gecko/nsIBaseWindow.h" + + +////////////// +// Prototypes +class GeckoDisplay; + + +//////////////////// +// Gecko Controller +class GeckoController : public nsIWebBrowserChrome, + public nsIEmbeddingSiteWindow, + public nsIWebProgressListener, + public nsSupportsWeakReference +{ +private: + int refCount; + static int controllers; + GeckoDisplay *display; + + nsCOMPtr nsNav; + nsCOMPtr nsWebBrowser; + nsCOMPtr mBaseWindow; + unsigned int mChromeFlags; + +public: + GeckoController(GeckoDisplay *_display,const wxString _path); + ~GeckoController(); + + void SetSize(wxSize &size); + + NS_DECL_ISUPPORTS + NS_DECL_NSIWEBBROWSERCHROME + NS_DECL_NSIEMBEDDINGSITEWINDOW + NS_DECL_NSIWEBPROGRESSLISTENER + //NS_DECL_NSISUPPORTSWEAKREFERENCE +}; diff --git a/traydict/gecko_display.cpp b/traydict/gecko_display.cpp index 3d0f5daf6..83792d5c5 100644 --- a/traydict/gecko_display.cpp +++ b/traydict/gecko_display.cpp @@ -37,6 +37,8 @@ /////////// // Headers #include "gecko_display.h" +#include "gecko_controller.h" +#include "main.h" /////////////// @@ -44,7 +46,25 @@ GeckoDisplay::GeckoDisplay(wxWindow *parent) : wxPanel(parent) { + controller = NULL; + controller = new GeckoController(this,TrayDict::folderName); + controller->AddRef(); +} + +////////////// +// Destructor +GeckoDisplay::~GeckoDisplay() +{ + controller->Release(); + //delete controller; +} + + +//////////////////// +// Initialize gecko +void GeckoDisplay::InitGecko() +{ } @@ -62,3 +82,31 @@ void GeckoDisplay::SetText(wxString text) { } + + +/////////////// +// Event table +BEGIN_EVENT_TABLE(GeckoDisplay,wxPanel) + EVT_SIZE(GeckoDisplay::OnSize) + EVT_SET_FOCUS(GeckoDisplay::OnSetFocus) + EVT_KILL_FOCUS(GeckoDisplay::OnKillFocus) +END_EVENT_TABLE() + + +//////// +// Size +void GeckoDisplay::OnSize(wxSizeEvent &event) +{ + if (controller) controller->SetSize(event.GetSize()); +} + + +///////// +// Focus +void GeckoDisplay::OnSetFocus(wxFocusEvent &event) +{ +} + +void GeckoDisplay::OnKillFocus(wxFocusEvent &event) +{ +} diff --git a/traydict/gecko_display.h b/traydict/gecko_display.h index 9cc717389..d31590d69 100644 --- a/traydict/gecko_display.h +++ b/traydict/gecko_display.h @@ -35,16 +35,40 @@ #pragma once + /////////// // Headers #include +#include "gecko/nsStringAPI.h" +#include "gecko/nsEmbedAPI.h" +#include "gecko/nsIWebBrowserChrome.h" +#include "gecko/nsIEmbeddingSiteWindow.h" +#include "gecko/nsIWebProgressListener.h" + + +////////////// +// Prototypes +class GeckoController; + ///////////////// // Gecko Display class GeckoDisplay : public wxPanel { +private: + GeckoController *controller; + + void OnSize(wxSizeEvent &event); + void OnSetFocus(wxFocusEvent &event); + void OnKillFocus(wxFocusEvent &event); + public: GeckoDisplay(wxWindow *parent); + ~GeckoDisplay(); + + void InitGecko(); void AppendText(wxString text); void SetText(wxString text); + + DECLARE_EVENT_TABLE() }; diff --git a/traydict/main.cpp b/traydict/main.cpp index 7ec84ca17..c0b0b8eb1 100644 --- a/traydict/main.cpp +++ b/traydict/main.cpp @@ -101,6 +101,7 @@ bool TrayDict::OnInit() { // Get path GetFullPath(argv[0]); GetFolderName(); + wxSetWorkingDirectory(folderName); // Create the window DictWindow *window = new DictWindow();