HRESULT WebBrowserEventSinker::SetCustomDocUIHandler(LPDISPATCH lpDisp)
{
if(lpDisp == NULL)
return E_INVALIDARG;
IWebBrowser2Ptr pWebBrowser2;
HRESULT hr = lpDisp->QueryInterface(IID_IWebBrowser2, (void**)&pWebBrowser2);
if(SUCCEEDED(hr) && pWebBrowser2)
{
IDispatchPtr pDoc;
hr = pWebBrowser2->get_Document(&pDoc);
if(SUCCEEDED(hr) && pDoc)
{
ICustomDocPtr pCustDoc;
hr = pDoc->QueryInterface(IID_ICustomDoc, (void**)&pCustDoc);
if(SUCCEEDED(hr) && pCustDoc != NULL)
{
IDocHostUIHandler* pUIHandler;
CreateObjectInterface<CDocHostUIHandler, IDocHostUIHandler>(NULL, &pUIHandler);
if (pUIHandler)
pCustDoc->SetUIHandler(pUIHandler);
pUIHandler->Release();
}
}
}
return hr;
}
// @pymethod |PyIDocHostUIHandler|TranslateUrl|Description of TranslateUrl.
PyObject *PyIDocHostUIHandler::TranslateUrl(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm int|dwTranslate||Description for dwTranslate
// @pyparm <o unicode>|pchURLIn||Description for pchURLIn
PyObject *obpchURLIn;
DWORD dwTranslate;
OLECHAR *pchURLIn;
OLECHAR *pchURLOut = 0;
if ( !PyArg_ParseTuple(args, "lO:TranslateUrl", &dwTranslate, &obpchURLIn) )
return NULL;
if (!PyWinObject_AsWCHAR(obpchURLIn, &pchURLIn))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->TranslateUrl( dwTranslate, pchURLIn, &pchURLOut);
PyWinObject_FreeWCHAR(pchURLIn);
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
PyObject *pyretval = MakeOLECHARToObj(pchURLOut);
CoTaskMemFree(pchURLOut);
return pyretval;
}
// @pymethod |PyIDocHostUIHandler|ShowContextMenu|Description of ShowContextMenu.
PyObject *PyIDocHostUIHandler::ShowContextMenu(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm int|dwID||Description for dwID
POINT pt;
// @pyparm (int, int)|pt||Description for ppt
// @pyparm <o PyIUnknown>|pcmdtReserved||Description for pcmdtReserved
// @pyparm <o PyIDispatch>|pdispReserved||Description for pdispReserved
PyObject *obpcmdtReserved;
PyObject *obpdispReserved;
DWORD dwID;
IUnknown * pcmdtReserved;
IDispatch * pdispReserved;
if ( !PyArg_ParseTuple(args, "l(ii)OO:ShowContextMenu", &dwID, &pt.x, &pt.y,
&obpcmdtReserved, &obpdispReserved) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpcmdtReserved, IID_IUnknown, (void **)&pcmdtReserved, TRUE /* bNoneOK */))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpdispReserved, IID_IDispatch, (void **)&pdispReserved, TRUE /* bNoneOK */)) {
if (pcmdtReserved) pcmdtReserved->Release();
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->ShowContextMenu( dwID, &pt, pcmdtReserved, pdispReserved );
if (pcmdtReserved) pcmdtReserved->Release();
if (pdispReserved) pdispReserved->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyInt_FromLong(hr);
}
// @pymethod |PyIDocHostUIHandler|TranslateAccelerator|Description of TranslateAccelerator.
PyObject *PyIDocHostUIHandler::TranslateAccelerator(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
MSG msg;
PyObject *oblpMsg;
// @pyparm <o PyLPMSG>|lpMsg||Description for lpMsg
// @pyparm <o PyIID>|pguidCmdGroup||Description for pguidCmdGroup
// @pyparm int|nCmdID||Description for nCmdID
PyObject *obpguidCmdGroup;
IID guidCmdGroup;
DWORD nCmdID;
if ( !PyArg_ParseTuple(args, "OOl:TranslateAccelerator", &oblpMsg, &obpguidCmdGroup, &nCmdID) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyWinObject_AsMSG(oblpMsg, &msg)) bPythonIsHappy = FALSE;
if (!PyWinObject_AsIID(obpguidCmdGroup, &guidCmdGroup)) bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->TranslateAccelerator(&msg, &guidCmdGroup, nCmdID );
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyInt_FromLong(hr);
}
// @pymethod |PyIDocHostUIHandler|ResizeBorder|Description of ResizeBorder.
PyObject *PyIDocHostUIHandler::ResizeBorder(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
RECT border;
// @pyparm (int, int, int, int)|prcBorder||Description for prcBorder
// @pyparm <o PyIOleInPlaceUIWindow>|pUIWindow||Description for pUIWindow
// @pyparm int|fRameWindow||Description for fRameWindow
PyObject *obpUIWindow;
IOleInPlaceUIWindow * pUIWindow;
BOOL fRameWindow;
if ( !PyArg_ParseTuple(args, "(iiii)Oi:ResizeBorder",
&border.left, &border.top, &border.right, &border.bottom,
&obpUIWindow, &fRameWindow) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpUIWindow, IID_IOleInPlaceUIWindow, (void **)&pUIWindow, TRUE /* bNoneOK */))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->ResizeBorder(&border, pUIWindow, fRameWindow );
if (pUIWindow) pUIWindow->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyInt_FromLong(hr);
}
// @pymethod |PyIDocHostUIHandler|UpdateUI|Description of UpdateUI.
PyObject *PyIDocHostUIHandler::UpdateUI(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
if ( !PyArg_ParseTuple(args, ":UpdateUI") )
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->UpdateUI( );
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyInt_FromLong(hr);
}
// @pymethod |PyIDocHostUIHandler|GetExternal|Description of GetExternal.
PyObject *PyIDocHostUIHandler::GetExternal(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
IDispatch * ppDispatch;
if ( !PyArg_ParseTuple(args, ":GetExternal") )
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->GetExternal( &ppDispatch );
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyCom_PyObjectFromIUnknown(ppDispatch, IID_IDispatch, FALSE);
}
// @pymethod |PyIDocHostUIHandler|OnFrameWindowActivate|Description of OnFrameWindowActivate.
PyObject *PyIDocHostUIHandler::OnFrameWindowActivate(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm int|fActivate||Description for fActivate
BOOL fActivate;
if ( !PyArg_ParseTuple(args, "i:OnFrameWindowActivate", &fActivate) )
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->OnFrameWindowActivate( fActivate );
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyInt_FromLong(hr);
}
// @pymethod |PyIDocHostUIHandler|EnableModeless|Description of EnableModeless.
PyObject *PyIDocHostUIHandler::EnableModeless(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm int|fEnable||Description for fEnable
BOOL fEnable;
if ( !PyArg_ParseTuple(args, "i:EnableModeless", &fEnable) )
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->EnableModeless( fEnable );
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyInt_FromLong(hr);
}
// @pymethod |PyIDocHostUIHandler|ShowUI|Description of ShowUI.
PyObject *PyIDocHostUIHandler::ShowUI(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm int|dwID||Description for dwID
// @pyparm <o PyIOleInPlaceActiveObject>|pActiveObject||Description for pActiveObject
// @pyparm <o PyIOleCommandTarget>|pCommandTarget||Description for pCommandTarget
// @pyparm <o PyIOleInPlaceFrame>|pFrame||Description for pFrame
// @pyparm <o PyIOleInPlaceUIWindow>|pDoc||Description for pDoc
PyObject *obpActiveObject;
PyObject *obpCommandTarget;
PyObject *obpFrame;
PyObject *obpDoc;
DWORD dwID;
if ( !PyArg_ParseTuple(args, "lOOOO:ShowUI", &dwID, &obpActiveObject, &obpCommandTarget, &obpFrame, &obpDoc) )
return NULL;
IOleInPlaceActiveObject * pActiveObject;
IOleCommandTarget * pCommandTarget;
IOleInPlaceFrame * pFrame;
IOleInPlaceUIWindow * pDoc;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpActiveObject, IID_IOleInPlaceActiveObject, (void **)&pActiveObject, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpCommandTarget, IID_IOleCommandTarget, (void **)&pCommandTarget, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpFrame, IID_IOleInPlaceFrame, (void **)&pFrame, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpDoc, IID_IOleInPlaceUIWindow, (void **)&pDoc, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->ShowUI( dwID, pActiveObject, pCommandTarget, pFrame, pDoc );
if (pActiveObject) pActiveObject->Release();
if (pCommandTarget) pCommandTarget->Release();
if (pFrame) pFrame->Release();
if (pDoc) pDoc->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyInt_FromLong(hr);
}
// @pymethod |PyIDocHostUIHandler|GetHostInfo|Description of GetHostInfo.
PyObject *PyIDocHostUIHandler::GetHostInfo(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
DOCHOSTUIINFO info;
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
if ( !PyArg_ParseTuple(args, ":GetHostInfo"))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->GetHostInfo(&info);
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler);
return Py_BuildValue("iiNN", info.dwFlags, info.dwDoubleClick,
MakeOLECHARToObj(info.pchHostCss),
MakeOLECHARToObj(info.pchHostNS));
}
// @pymethod |PyIDocHostUIHandler|GetOptionKeyPath|Description of GetOptionKeyPath.
PyObject *PyIDocHostUIHandler::GetOptionKeyPath(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm int|dw||Description for dw
LPOLESTR pchKey;
DWORD dw;
if ( !PyArg_ParseTuple(args, "l:GetOptionKeyPath", &dw) )
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->GetOptionKeyPath( &pchKey, dw );
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
PyObject *pyretval = MakeOLECHARToObj(pchKey);
CoTaskMemFree(pchKey);
return pyretval;
}
// @pymethod |PyIDocHostUIHandler|FilterDataObject|Description of FilterDataObject.
PyObject *PyIDocHostUIHandler::FilterDataObject(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm <o PyIDataObject>|pDO||Description for pDO
PyObject *obpDO;
IDataObject * pDO;
IDataObject * ppDORet;
if ( !PyArg_ParseTuple(args, "O:FilterDataObject", &obpDO) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpDO, IID_IDataObject, (void **)&pDO, TRUE /* bNoneOK */))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->FilterDataObject( pDO, &ppDORet );
if (pDO) pDO->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyCom_PyObjectFromIUnknown(ppDORet, IID_IDataObject, FALSE);
}
// @pymethod |PyIDocHostUIHandler|GetDropTarget|Description of GetDropTarget.
PyObject *PyIDocHostUIHandler::GetDropTarget(PyObject *self, PyObject *args)
{
IDocHostUIHandler *pIDHUIH = GetI(self);
if ( pIDHUIH == NULL )
return NULL;
// @pyparm <o PyIDropTarget>|pDropTarget||Description for pDropTarget
PyObject *obpDropTarget;
IDropTarget * pDropTarget;
IDropTarget * ppDropTarget;
if ( !PyArg_ParseTuple(args, "O:GetDropTarget", &obpDropTarget) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpDropTarget, IID_IDropTarget, (void **)&pDropTarget, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDHUIH->GetDropTarget( pDropTarget, &ppDropTarget );
if (pDropTarget) pDropTarget->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDHUIH, IID_IDocHostUIHandler );
return PyCom_PyObjectFromIUnknown(ppDropTarget, IID_IDropTarget, FALSE);
}
HRESULT CPasteCommand::PasteFromClipboard (
IMarkupPointer* pPasteStart,
IMarkupPointer* pPasteEnd,
IDataObject* pDataObject,
CSpringLoader* psl)
{
CXindowsEditor* pEditor = GetEditor();
IDataObject* pdoFromClipboard = NULL;
CLIPFORMAT cf = 0;
HGLOBAL hglobal = NULL;
HRESULT hr = DV_E_FORMATETC;
HRESULT hr2 = S_OK;
HGLOBAL hUnicode = NULL;
int i;
int nFETC;
STGMEDIUM medium = { 0, NULL };
FORMATETC* pfetc;
LPTSTR ptext = NULL;
IHTMLViewServices* pViewServices = pEditor->GetViewServices();
IHTMLElement* pElement = NULL;
IHTMLElement* pFlowElement = NULL;
BOOL fAcceptsHTML, fContainer;
IMarkupServices* pMarkupServices = pEditor->GetMarkupServices();
IMarkupPointer* pRangeStart = NULL;
IMarkupPointer* pRangeEnd = NULL;
IDataObject* pdoFiltered = NULL;
IDocHostUIHandler* pHostUIHandler = NULL;
// Set up a pair of pointers for URL Autodetection after the insert
IFC(pMarkupServices->CreateMarkupPointer(&pRangeStart));
IFC(pRangeStart->MoveToPointer(pPasteStart));
IFC(pRangeStart->SetGravity(POINTER_GRAVITY_Left));
IFC(pMarkupServices->CreateMarkupPointer(&pRangeEnd));
IFC(pRangeEnd->MoveToPointer(pPasteStart));
IFC(pRangeEnd->SetGravity(POINTER_GRAVITY_Right));
pfetc = GetFETCs(&nFETC);
Assert(pfetc);
if(!pDataObject)
{
hr2 = OleGetClipboard(&pdoFromClipboard);
if(hr2 != NOERROR)
{
return hr2;
}
Assert(pdoFromClipboard);
// See if the host handler wants to give us a massaged data object.
IFC(pViewServices->GetDocHostUIHandler(&pHostUIHandler));
pDataObject = pdoFromClipboard;
if(pHostUIHandler)
{
// The host may want to massage the data object to block/add
// certain formats.
hr = pHostUIHandler->FilterDataObject(pDataObject, &pdoFiltered);
if(!hr && pdoFiltered)
{
pDataObject = pdoFiltered;
}
else
{
hr = S_OK;
}
}
}
if(pPasteEnd)
{
IFC(pMarkupServices->Remove(pPasteStart, pPasteEnd));
}
// Check if we accept HTML
IFC(pViewServices->GetFlowElement(pPasteStart, &pFlowElement));
if(!pFlowElement)
{
// Elements that do not accept HTML, e.g. TextArea, always have a flow layout.
// If the element does not have a flow layout then it might have been created
// using the DOM (see bug 42685). Set fAcceptsHTML to true.
fAcceptsHTML = TRUE;
}
else
{
IFC(pViewServices->IsContainerElement(pFlowElement, &fContainer, &fAcceptsHTML));
}
for(i=0; i<nFETC; i++,pfetc++)
{
// make sure the format is either 1.) a plain text format
// if we are in plain text mode or 2.) a rich text format
// or 3.) matches the requested format.
if(cf && cf!=pfetc->cfFormat)
{
continue;
}
// If we don't accept HTML and i does not correspond to text format
// skip it
if(fAcceptsHTML || i==iAnsiFETC || i==iUnicodeFETC)
{
// make sure the format is available
if(pDataObject->QueryGetData(pfetc) != NOERROR)
{
continue;
}
// If we have one of the formats that uses an hglobal get it
// and lock it.
if(i==iAnsiFETC || i==iUnicodeFETC || i==iHTML)
{
if(pDataObject->GetData(pfetc, &medium) == NOERROR)
{
Assert(medium.tymed == TYMED_HGLOBAL);
hglobal = medium.hGlobal;
ptext = (LPTSTR)GlobalLock(hglobal);
if(!ptext)
{
ReleaseStgMedium(&medium);
return E_OUTOFMEMORY;
}
}
else
{
continue;
}
}
switch(i)
{
case iHTML:
{
// Fire the springloader.
BOOL fSamePosition = FALSE;
if(pPasteStart && psl
&& (!pPasteEnd || (S_OK==pPasteStart->IsEqualTo(pPasteEnd, &fSamePosition) && fSamePosition))
&& S_OK==psl->Fire(pPasteStart)
&& pPasteEnd)
{
pPasteEnd->MoveToPointer(pPasteStart);
}
hr = pViewServices->DoTheDarnPasteHTML(pPasteStart, pPasteEnd, hglobal);
goto Cleanup;
}
case iRtfFETC:
{
BOOL fEnabled = FALSE;
continue;
}
case iRtfAsTextFETC:
case iAnsiFETC: // ANSI plain text. If data can be stored
hUnicode = TextHGlobalAtoW(hglobal);
if(hUnicode)
{
ptext = (LPTSTR)GlobalLock(hUnicode);
if(!ptext)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = GetEditor()->InsertSanitizedText(ptext, pPasteStart, pMarkupServices, psl, FALSE);
GlobalUnlock(hUnicode);
}
goto Cleanup;
case iUnicodeFETC: // Unicode plain text
ptext = (LPTSTR)GlobalLock(hglobal);
if(!ptext)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = GetEditor()->InsertSanitizedText(ptext, pPasteStart, pMarkupServices, psl, FALSE);
goto Cleanup;
}
//Break out of the for loop
break;
}
}
Cleanup:
ReleaseInterface(pRangeStart);
ReleaseInterface(pRangeEnd);
ReleaseInterface(pElement);
ReleaseInterface(pFlowElement);
ReleaseInterface(pdoFiltered);
ReleaseInterface(pHostUIHandler);
ReleaseInterface(pdoFromClipboard);
if(hUnicode)
{
GlobalFree(hUnicode);
}
//If we used the hglobal unlock it and free it.
if(hglobal)
{
GlobalUnlock(hglobal);
ReleaseStgMedium(&medium);
}
return hr;
}
