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();