Aegisub/devel/traydict/IEHtmlWin.cpp
Amar Takhar aa506bfe40 SVN Transition Step 6/7
1. svn mv OverLua SSATool athenasub avisynth_prs kanamemo \
     motiontracker prs traydict unit_test vsfilter devel/

* See r2749 for full description.

Originally committed to SVN as r2755.
2009-03-08 08:31:54 +00:00

1610 lines
42 KiB
C++

#include "IEHtmlWin.h"
//#include "App/EdApp.h"
#include <wx/msw/ole/oleutils.h>
#include <oleidl.h>
#include <winerror.h>
#include <exdispid.h>
#include <olectl.h>
#include <strsafe.h>
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<IStream*>(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"));
}