|
|
// Copyright (c)1997-1999 Microsoft Corporation, All Rights Reserved
// Notes on m_bfModeSwitched and m_bfReloadAttempted.
// IE5 bug 52818 was punted; pages containing IFrames don't refresh when changing
// browse/edit modes, because the stream is seen as dirty (because the IFrame
// considers itself dirty.) In response, we set m_bfModeSwitched when changing mode,
// m_bfReloadAttempted when and ATTEMPT is made to reload the page, and check for BOTH
// in OnReadyStateChanged. If the mode was changed but the page wasn't reloaded,
// we have to reload it manually.
#include "stdafx.h"
#include "DHTMLEd.h"
#include "DHTMLEdit.h"
#include "site.h"
#include "proxyframe.h"
#include <TRIEDIID.h>
#include <mshtmdid.h>
#include "dispexa.h"
#include <wchar.h>
#include <string.h>
// HTML to initialize Trident with if the host didn't supply any
// The <P> </P> works around a nasty Trident bug.
// Change: now there is one with paragraphs, one with DIVs.
//
static WCHAR* g_initialHTMLwithP = \L"<HTML>\r\n\
<HEAD>\r\n\<META NAME=\"GENERATOR\" Content=\"Microsoft DHTML Editing Control\">\r\n\
<TITLE></TITLE>\r\n\</HEAD>\r\n\<BODY>\r\n\<P> </P>\r\n\</BODY>\r\n\</HTML>\r\n";
static WCHAR* g_initialHTMLwithDIV = \L"<HTML>\r\n\
<HEAD>\r\n\<META NAME=\"GENERATOR\" Content=\"Microsoft DHTML Editing Control\">\r\n\
<TITLE></TITLE>\r\n\</HEAD>\r\n\<BODY>\r\n\<DIV> </DIV>\r\n\</BODY>\r\n\</HTML>\r\n";
// Text, numbers and constants used to construct a unique-per-process protocol ID
//
static WCHAR* g_wszProtocolPrefix = L"DHTMLEd";static int s_iProtocolSuffix = 0;#define MAX_PROTOCOL_SUFFIX 999999
// Name of the Title property which we get from the IHtmlDocument2 interface.
static WCHAR* g_wszHTMLTitlePropName = L"title";
// Maps private DHTMLEdit command IDs to Triedit command IDs.
// The third field is true if the command includes an out parameter.
//
static CommandMap cmdMap[] = { {DECMD_BOLD, IDM_TRIED_BOLD, FALSE}, {DECMD_COPY, IDM_TRIED_COPY, FALSE}, {DECMD_CUT, IDM_TRIED_CUT, FALSE}, {DECMD_DELETE, IDM_TRIED_DELETE, FALSE}, {DECMD_DELETECELLS, IDM_TRIED_DELETECELLS, FALSE}, {DECMD_DELETECOLS, IDM_TRIED_DELETECOLS, FALSE}, {DECMD_DELETEROWS, IDM_TRIED_DELETEROWS, FALSE}, {DECMD_FINDTEXT, IDM_TRIED_FIND, FALSE}, {DECMD_FONT, IDM_TRIED_FONT, FALSE}, {DECMD_GETBACKCOLOR, IDM_TRIED_BACKCOLOR, TRUE}, {DECMD_GETBLOCKFMT, IDM_TRIED_BLOCKFMT, TRUE}, {DECMD_GETBLOCKFMTNAMES, IDM_TRIED_GETBLOCKFMTS, TRUE}, {DECMD_GETFONTNAME, IDM_TRIED_FONTNAME, TRUE}, {DECMD_GETFONTSIZE, IDM_TRIED_FONTSIZE, TRUE}, {DECMD_GETFORECOLOR, IDM_TRIED_FORECOLOR, TRUE}, {DECMD_HYPERLINK, IDM_TRIED_HYPERLINK, FALSE}, {DECMD_IMAGE, IDM_TRIED_IMAGE, FALSE}, {DECMD_INDENT, IDM_TRIED_INDENT, FALSE}, {DECMD_INSERTCELL, IDM_TRIED_INSERTCELL, FALSE}, {DECMD_INSERTCOL, IDM_TRIED_INSERTCOL, FALSE}, {DECMD_INSERTROW, IDM_TRIED_INSERTROW, FALSE}, {DECMD_INSERTTABLE, IDM_TRIED_INSERTTABLE, FALSE}, {DECMD_ITALIC, IDM_TRIED_ITALIC, FALSE}, {DECMD_JUSTIFYLEFT, IDM_TRIED_JUSTIFYLEFT, FALSE}, {DECMD_JUSTIFYRIGHT, IDM_TRIED_JUSTIFYRIGHT, FALSE}, {DECMD_JUSTIFYCENTER, IDM_TRIED_JUSTIFYCENTER, FALSE}, {DECMD_LOCK_ELEMENT, IDM_TRIED_LOCK_ELEMENT, FALSE}, {DECMD_MAKE_ABSOLUTE, IDM_TRIED_MAKE_ABSOLUTE, FALSE}, {DECMD_MERGECELLS, IDM_TRIED_MERGECELLS, FALSE}, {DECMD_ORDERLIST, IDM_TRIED_ORDERLIST, FALSE}, {DECMD_OUTDENT, IDM_TRIED_OUTDENT, FALSE}, {DECMD_PASTE, IDM_TRIED_PASTE, FALSE}, {DECMD_REDO, IDM_TRIED_REDO, FALSE}, {DECMD_REMOVEFORMAT, IDM_TRIED_REMOVEFORMAT, FALSE}, {DECMD_SELECTALL, IDM_TRIED_SELECTALL, FALSE}, {DECMD_SEND_BACKWARD, IDM_TRIED_SEND_BACKWARD, FALSE}, {DECMD_BRING_FORWARD, IDM_TRIED_SEND_FORWARD, FALSE}, {DECMD_SEND_BELOW_TEXT, IDM_TRIED_SEND_BEHIND_1D, FALSE}, {DECMD_BRING_ABOVE_TEXT, IDM_TRIED_SEND_FRONT_1D, FALSE}, {DECMD_SEND_TO_BACK, IDM_TRIED_SEND_TO_BACK, FALSE}, {DECMD_BRING_TO_FRONT, IDM_TRIED_SEND_TO_FRONT, FALSE}, {DECMD_SETBACKCOLOR, IDM_TRIED_BACKCOLOR, FALSE}, {DECMD_SETBLOCKFMT, IDM_TRIED_BLOCKFMT, FALSE}, {DECMD_SETFONTNAME, IDM_TRIED_FONTNAME, FALSE}, {DECMD_SETFONTSIZE, IDM_TRIED_FONTSIZE, FALSE}, {DECMD_SETFORECOLOR, IDM_TRIED_FORECOLOR, FALSE}, {DECMD_SPLITCELL, IDM_TRIED_SPLITCELL, FALSE}, {DECMD_UNDERLINE, IDM_TRIED_UNDERLINE, FALSE}, {DECMD_UNDO, IDM_TRIED_UNDO, FALSE}, {DECMD_UNLINK, IDM_TRIED_UNLINK, FALSE}, {DECMD_UNORDERLIST, IDM_TRIED_UNORDERLIST, FALSE}, {DECMD_PROPERTIES, IDM_TRIED_DOVERB, FALSE}};
CProxyFrame::CProxyFrame(CDHTMLSafe* pCtl){ SAFEARRAYBOUND rgsabound[1] = {0};
_ASSERTE(pCtl);
m_cRef = 1;
m_pUnkTriEdit = NULL; m_hWndObj = NULL; m_pIOleIPActiveObject = NULL; m_pSite = NULL; m_pCtl = pCtl;
m_fCreated = FALSE; m_fActivated = FALSE; m_state = ESTATE_NOTCREATED; m_readyState = READYSTATE_UNINITIALIZED; m_dwFilterFlags = m_dwFilterOutFlags = filterAll;
m_fActivateApplets = FALSE; m_fActivateControls = FALSE; m_fActivateDTCs = TRUE; m_fShowAllTags = FALSE; m_fShowBorders = FALSE;
m_fDialogEditing = TRUE; m_fDisplay3D = TRUE; m_fScrollbars = TRUE; m_fDisplayFlatScrollbars = FALSE; m_fContextMenu = TRUE;
m_fPreserveSource = TRUE;
m_fAbsoluteDropMode = FALSE; m_fSnapToGrid = FALSE; m_ulSnapToGridX = 50; m_ulSnapToGridY = 50;
rgsabound[0].lLbound = 0; rgsabound[0].cElements = 0;
m_pMenuStrings = NULL; m_pMenuStates = NULL;
m_vbBrowseMode = VARIANT_FALSE;
m_vbUseDivOnCr = VARIANT_FALSE; m_bfIsLoading = FALSE; m_bfBaseURLFromBASETag = FALSE; m_bfPreserveDirtyFlagAcrossBrowseMode = FALSE; m_bstrInitialDoc.Empty ();
m_bstrCurDocPath.Empty ();
wcscpy ( m_wszProtocol, g_wszProtocolPrefix ); WCHAR wszSuffix[8]; _itow ( s_iProtocolSuffix++, wszSuffix, 10 ); if ( MAX_PROTOCOL_SUFFIX <= s_iProtocolSuffix ) { s_iProtocolSuffix = 0; // Roll over.
} wcscat ( m_wszProtocol, wszSuffix ); wcscpy ( m_wszProtocolPrefix, m_wszProtocol ); wcscat ( m_wszProtocolPrefix, L":" );
m_pProtInfo = NULL; m_bfIsURL = FALSE; m_bstrBaseURL = L""; m_hwndRestoreFocus = NULL;
#ifdef LATE_BIND_URLMON_WININET
m_hUlrMon = NULL; m_hWinINet = NULL; m_pfnCoInternetCombineUrl = NULL; m_pfnCoInternetParseUrl = NULL; m_pfnCreateURLMoniker = NULL; m_pfnCoInternetGetSession = NULL; m_pfnURLOpenBlockingStream = NULL;
m_pfnDeleteUrlCacheEntry = NULL; m_pfnInternetCreateUrl = NULL; m_pfnInternetCrackUrl = NULL;#endif // LATE_BIND_URLMON_WININET
m_bfModeSwitched = FALSE; m_bfReloadAttempted = FALSE; m_bfSFSRedirect = FALSE;}
CProxyFrame::~CProxyFrame(){ _ASSERTE(FALSE == m_fCreated); _ASSERTE(FALSE == m_fActivated); _ASSERTE( m_cRef == 0 );
if (m_pMenuStrings) { SafeArrayDestroy(m_pMenuStrings); m_pMenuStrings = NULL; }
if (m_pMenuStates) { SafeArrayDestroy(m_pMenuStates); m_pMenuStates = NULL; }
// This should never happen: SetActiveObject should take care of it.
_ASSERTE ( NULL == m_pIOleIPActiveObject ); if (m_pIOleIPActiveObject) { m_pIOleIPActiveObject->Release(); m_pIOleIPActiveObject = NULL; }
UnRegisterPluggableProtocol ();#ifdef LATE_BIND_URLMON_WININET
DynUnloadLibraries ();#endif // LATE_BIND_URLMON_WININET
}
// Create the TriEdit object and host it.
// Clean up and return an error if there was any problem.
//
HRESULTCProxyFrame::Init(IUnknown* pUnk, IUnknown** ppUnkTriEdit){ HRESULT hr = S_OK;
#ifdef LATE_BIND_URLMON_WININET
if ( ! DynLoadLibraries () ) { return E_FAIL; }#endif // LATE_BIND_URLMON_WININET
hr = RegisterPluggableProtocol (); if ( FAILED ( hr ) ) { return hr; }
_ASSERTE(NULL == m_pSite); _ASSERTE(GetState() == ESTATE_NOTCREATED);
InitializeDocString ();
if (m_pSite) return E_UNEXPECTED;
if (GetState() != ESTATE_NOTCREATED) return E_UNEXPECTED;
// Create and initialize the site for TriEdit
m_pSite = new CSite(this);
if (NULL == m_pSite) { return E_OUTOFMEMORY; }
m_pSite->AddRef(); // So we can free with Release
// Ask the site to create TriEdit
if (SUCCEEDED(hr = m_pSite->HrCreate(pUnk, &m_pUnkTriEdit))) { ChangeState(ESTATE_CREATED); m_fCreated = TRUE; if (ppUnkTriEdit) { m_pUnkTriEdit->AddRef(); *ppUnkTriEdit = m_pUnkTriEdit; } } else { m_pSite->Release(); m_pSite = NULL; }
return hr; }
// Destroy the site and the TriEdit object.
//
HRESULTCProxyFrame::Close(){ HRESULT hr = S_OK;
_ASSERTE(m_pUnkTriEdit); _ASSERTE(m_pSite); _ASSERTE(GetState() != ESTATE_NOTCREATED);
m_bstrCurDocPath.Empty ();
// triedit must be created
// any state from created to activated is ok
if (GetState() == ESTATE_NOTCREATED) return E_UNEXPECTED;
if (m_fActivated) { hr = HrExecCommand(&CGID_MSHTML, IDM_STOP, MSOCMDEXECOPT_DONTPROMPTUSER, NULL, NULL); _ASSERTE(SUCCEEDED(hr)); }
ChangeState(ESTATE_NOTCREATED); m_fCreated = FALSE; m_fActivated = FALSE; if (m_pSite != NULL) { CSite* pSite = m_pSite; // prevents reentry;
m_pSite = NULL;
pSite->Close(FALSE); ReleaseInterface(pSite) pSite = NULL; }
if (m_pUnkTriEdit != NULL) { LPUNKNOWN pUnkTriEdit = m_pUnkTriEdit; m_pUnkTriEdit = NULL;
ReleaseInterface(pUnkTriEdit); pUnkTriEdit = NULL; }
m_hwndRestoreFocus = NULL;
return S_OK;}
// Determine which string constant to use and return a pointer to it.
//
WCHAR* CProxyFrame::GetInitialHTML (){ if ( m_vbUseDivOnCr ) { return g_initialHTMLwithDIV; } else { return g_initialHTMLwithP; }}
// Perform these steps before loading TriEdit's contents
//
HRESULTCProxyFrame::PreActivate(){ HRESULT hr = S_OK; _ASSERTE(m_pSite); _ASSERTE(m_pCtl);
_ASSERTE(ESTATE_CREATED == GetState());
if (GetState() != ESTATE_CREATED) return E_UNEXPECTED;
if (FAILED(hr = m_pSite->HrObjectInitialize())) { _ASSERTE(SUCCEEDED(hr)); goto error; }
m_fActivated = TRUE; ChangeState(ESTATE_PREACTIVATING);
if (FAILED(hr = HrSetRuntimeProperties())) { _ASSERTE(SUCCEEDED(hr)); goto error; }
ChangeState(ESTATE_ACTIVATING);
error:
return hr;}
voidCProxyFrame::UIDeactivate(){ // This was m_pSite->GetIPObject()->UIDeactivate(),
// but the QA teams VB app using this version of the control crashed
// with a NULL pointer dereference.
if ( NULL != m_pSite ) { LPOLEINPLACEOBJECT pipObj = m_pSite->GetIPObject(); if ( NULL != pipObj ) { pipObj->UIDeactivate(); } }}
// Perform these steps after loading TriEdits contents to go UI active.
//
HRESULTCProxyFrame::Activate(){ HRESULT hr = S_OK;
_ASSERTE(m_pSite); _ASSERTE(m_pCtl); _ASSERTE(m_pCtl->m_hWndCD);
_ASSERTE(GetState() == ESTATE_ACTIVATING);
if (GetState() != ESTATE_ACTIVATING) return E_UNEXPECTED;
// UI-activate the control
if ( ! m_pCtl->m_bUIActive ) { // Used to be UIActivate, until MohanB fixed OnSetFocus and activation/deactivation linkage.
m_pCtl->DoVerbInPlaceActivate ( NULL, NULL ); }
// activate Trident with "Show"
m_pSite->InitialActivate(OLEIVERB_SHOW, m_pCtl->m_hWndCD);
ChangeState(ESTATE_ACTIVATED);
// This may have been deferred, because the site's command target did not yet exist...
SetBrowseMode ( m_vbBrowseMode );
return hr;}
// Load and activate the control with a minimal, empty page.
//
HRESULTCProxyFrame::LoadInitialDoc(){ HRESULT hr = S_OK;
_ASSERTE(GetState() == ESTATE_CREATED);
if (GetState() != ESTATE_CREATED) return E_UNEXPECTED; if (FAILED(hr = PreActivate())) goto error;
if (FAILED(hr = LoadBSTRDeferred ( m_bstrInitialDoc ))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = Activate())) goto error;
error:
return hr;}
// Before getting or setting a property or calling a method on the docobject,
// assure that it's been properly activated.
//
void CProxyFrame::AssureActivated (){ if ( ! m_fActivated ) { if ( m_pCtl->IsUserMode() ) { if ( !m_pCtl->m_bInPlaceActive ) { m_pCtl->DoVerbInPlaceActivate ( NULL, NULL ); } LoadInitialDoc (); } }}
// Loading MSHTML shifts the focus to its document window.
// This is not desirable in a control. Experimentation has demonstrated
// that the focus shifts between various QIs from MSHTML (probably in response
// to posted messages.) There is no routine in DHTMLEdit which enters with the
// focus outside the control and exits with the focus within the control.
// Therefore, a member variable is used to preserve the appropriate focus
// across calls to OnReadyStateChanged, which are called in response to events
// fired by the control. m_hwndRestoreFocus is used to preserve the appropriate
// window to receive the focus. Note that NULL may be appropriate, but is not honored.
// If no window had focus, the document will gain focus.
//
void CProxyFrame::OnReadyStateChanged(READYSTATE readyState){ _ASSERTE(m_pCtl);
m_readyState = readyState;
switch (m_readyState) { case READYSTATE_UNINITIALIZED: { m_hwndRestoreFocus = NULL; } break;
case READYSTATE_LOADING: { m_hwndRestoreFocus = ::GetFocus (); } break; case READYSTATE_LOADED: { } break;
case READYSTATE_INTERACTIVE: { if ( NULL != m_hwndRestoreFocus ) { _ASSERTE ( ::IsWindow ( m_hwndRestoreFocus ) ); if ( ::IsWindow ( m_hwndRestoreFocus ) ) { ::SetFocus ( m_hwndRestoreFocus ); } }
// See if we failed to get a refresh on a mode change. This happens if
// there are IFrames on the page, perhaps in other cases as well.
if ( m_bfModeSwitched && !m_bfReloadAttempted ) { HRESULT hr = S_OK;
CComPtr<IMoniker> srpMoniker; CComPtr<IBindCtx> srpBindCtx; CComQIPtr<IPersistMoniker, &IID_IPersistMoniker> srpPM (m_pUnkTriEdit); _ASSERTE ( srpPM );
if ( srpPM ) { CComBSTR bstrProtocol = m_wszProtocolPrefix;
#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnCreateURLMoniker ); hr = (*m_pfnCreateURLMoniker)( NULL, bstrProtocol, &srpMoniker );#else
hr = CreateURLMoniker ( NULL, bstrProtocol, &srpMoniker );#endif // LATE_BIND_URLMON_WININET
_ASSERTE ( SUCCEEDED( hr ) ); if ( SUCCEEDED ( hr ) ) { hr = ::CreateBindCtx(NULL, &srpBindCtx); _ASSERTE ( SUCCEEDED( hr ) ); if ( SUCCEEDED ( hr ) ) { hr = srpPM->Load(FALSE, srpMoniker, srpBindCtx, STGM_READ); } } } } m_bfModeSwitched = FALSE; m_bfReloadAttempted = FALSE; } break;
case READYSTATE_COMPLETE: { HRESULT hr = S_OK;
m_hwndRestoreFocus = NULL; if ( ! m_vbBrowseMode ) { hr = HrSetDocLoadedProperties(); _ASSERTE(SUCCEEDED(hr)); }
_ASSERTE ( m_pCtl->m_hWnd ); _ASSERTE ( ::IsWindow ( m_pCtl->m_hWnd ) );
if ( m_bfPreserveDirtyFlagAcrossBrowseMode && !m_vbBrowseMode ) { m_bfPreserveDirtyFlagAcrossBrowseMode = FALSE; SetDirtyFlag ( TRUE ); } // Post a user message to fire the DocumentComplete event.
// Otherwise, calling things like LoadURL from DocumentComplete behaves strangely.
::PostMessage ( m_pCtl->m_hWnd, DOCUMENT_COMPETE_MESSAGE, DOCUMENT_COMPETE_SIGNATURE, 0L ); HrSetRuntimeProperties (); //m_bfIsLoading = FALSE; // This has been moved the the DOCUMENT_COMPETE_MESSAGE handler.
SetBaseURLFromBaseHref (); // Must be called after clearing m_bfIsLoading
} break; }}
/*
* IUnknown implementation *//*
* CProxyFrame::QueryInterface * CProxyFrame::AddRef * CProxyFrame::Release */STDMETHODIMP CProxyFrame::QueryInterface( REFIID riid, void **ppv ){ /*
* We provide IOleInPlaceFrame and IOleCommandTarget * interfaces here for the ActiveX Document hosting */ *ppv = NULL;
if ( IID_IUnknown == riid || IID_IOleInPlaceUIWindow == riid || IID_IOleWindow == riid || IID_IOleInPlaceFrame == riid ) { *ppv = static_cast<IOleInPlaceFrame *>(this); }
else if ( IID_IOleCommandTarget == riid ) { *ppv = static_cast<IOleCommandTarget *>(this); } else if ( IID_IBindStatusCallback == riid ) { *ppv = static_cast<IBindStatusCallback *>(this); } else if ( IID_IAuthenticate == riid ) { *ppv = static_cast<IAuthenticate *>(this); } else if ( IID_IServiceProvider == riid ) { // Ask the control for a security manager IF in edit mode:
if ( ! m_vbBrowseMode ) { return m_pCtl->GetUnknown()->QueryInterface ( riid, ppv ); } }
if ( NULL != *ppv ) { ((LPUNKNOWN)*ppv)->AddRef(); return S_OK; }
return E_NOINTERFACE;}
STDMETHODIMP_(ULONG) CProxyFrame::AddRef( void ){ return ++m_cRef;}
STDMETHODIMP_(ULONG) CProxyFrame::Release( void ){ //Nothing special happening here-- life if user-controlled.
// Debug check to see we don't fall below 0
_ASSERTE( m_cRef != 0 );
ULONG ulRefCount = --m_cRef; if ( 0 == ulRefCount ) { delete this; // Do not refer to any member variables after this.
} return ulRefCount;}
/*
* IOleInPlaceFrame implementation *//*
* CProxyFrame::GetWindow * * Purpose: * Retrieves the handle of the window associated with the object * on which this interface is implemented. * * Parameters: * phWnd HWND * in which to store the window handle. * * Return Value: * HRESULT S_OK if successful, E_FAIL if there is no * window. */STDMETHODIMP CProxyFrame::GetWindow( HWND* phWnd ){ if ( m_pCtl != NULL ) { *phWnd = m_pCtl->m_hWnd; } return S_OK;}
/*
* CProxyFrame::ContextSensitiveHelp * * Purpose: * Instructs the object on which this interface is implemented to * enter or leave a context-sensitive help mode. * * Parameters: * fEnterMode BOOL TRUE to enter the mode, FALSE otherwise. * * Return Value: * HRESULT S_OK */STDMETHODIMP CProxyFrame::ContextSensitiveHelp( BOOL /*fEnterMode*/ ){ return S_OK;}
/*
* CProxyFrame::GetBorder * * Purpose: * Returns the rectangle in which the container is willing to * negotiate about an object's adornments. * * Parameters: * prcBorder LPRECT in which to store the rectangle. * * Return Value: * HRESULT S_OK if all is well, INPLACE_E_NOTOOLSPACE * if there is no negotiable space. */STDMETHODIMP CProxyFrame::GetBorder( LPRECT prcBorder ){ if ( NULL == prcBorder ) { return E_INVALIDARG; }
//We return all the client area space
m_pCtl->GetClientRect( prcBorder ); return S_OK;}
/*
* CProxyFrame::RequestBorderSpace * * Purpose: * Asks the container if it can surrender the amount of space * in pBW that the object would like for it's adornments. The * container does nothing but validate the spaces on this call. * * Parameters: * pBW LPCBORDERWIDTHS containing the requested space. * The values are the amount of space requested * from each side of the relevant window. * * Return Value: * HRESULT S_OK if we can give up space, * INPLACE_E_NOTOOLSPACE otherwise. */STDMETHODIMP CProxyFrame::RequestBorderSpace( LPCBORDERWIDTHS /*pBW*/ ){ // We have no border space restrictions
return S_OK;}
/*
* CProxyFrame::SetBorderSpace * * Purpose: * Called when the object now officially requests that the * container surrender border space it previously allowed * in RequestBorderSpace. The container should resize windows * appropriately to surrender this space. * * Parameters: * pBW LPCBORDERWIDTHS containing the amount of space * from each side of the relevant window that the * object is now reserving. * * Return Value: * HRESULT S_OK */STDMETHODIMP CProxyFrame::SetBorderSpace( LPCBORDERWIDTHS /*pBW*/ ){ // We turn off the MSHTML.DLL UI so we ignore all of this.
return S_OK;}
/*
* CProxyFrame::SetActiveObject * * Purpose: * Provides the container with the object's IOleInPlaceActiveObject * pointer * * Parameters: * pIIPActiveObj LPOLEINPLACEACTIVEOBJECT of interest. * pszObj LPCOLESTR naming the object. Not used. * * Return Value: * HRESULT S_OK */STDMETHODIMP CProxyFrame::SetActiveObject( LPOLEINPLACEACTIVEOBJECT pIIPActiveObj, LPCOLESTR /*pszObj*/){ // If we already have an active Object then release it.
if ( NULL != m_pIOleIPActiveObject ) { m_pIOleIPActiveObject->Release(); }
//NULLs m_pIOleIPActiveObject if pIIPActiveObj is NULL
m_pIOleIPActiveObject = pIIPActiveObj;
if ( NULL != m_pIOleIPActiveObject ) { m_pIOleIPActiveObject->AddRef(); m_pIOleIPActiveObject->GetWindow( &m_hWndObj ); } return S_OK;}
/*
* CProxyFrame::InsertMenus * * Purpose: * Instructs the container to place its in-place menu items where * necessary in the given menu and to fill in elements 0, 2, and 4 * of the OLEMENUGROUPWIDTHS array to indicate how many top-level * items are in each group. * * Parameters: * hMenu HMENU in which to add popups. * pMGW LPOLEMENUGROUPWIDTHS in which to store the * width of each container menu group. * * Return Value: * HRESULT E_NOTIMPL */STDMETHODIMP CProxyFrame::InsertMenus( HMENU /*hMenu*/, LPOLEMENUGROUPWIDTHS /*pMGW*/ ){ // We've turned off the MSHTML.DLL Menus so we don't expect any merging to go on!
return E_NOTIMPL;}
/*
* CProxyFrame::SetMenu * * Purpose: * Instructs the container to replace whatever menu it's currently * using with the given menu and to call OleSetMenuDescritor so OLE * knows to whom to dispatch messages. * * Parameters: * hMenu HMENU to show. * hOLEMenu HOLEMENU to the menu descriptor. * hWndObj HWND of the active object to which messages are * dispatched. * * Return Value: * HRESULT NOERROR */STDMETHODIMP CProxyFrame::SetMenu( HMENU /*hMenu*/, HOLEMENU /*hOLEMenu*/, HWND /*hWndObj*/ ){ // We've turned off the MSHTML.DLL Menus so we don't expect any merging to go on!
return E_NOTIMPL;}
/*
* CProxyFrame::RemoveMenus * * Purpose: * Asks the container to remove any menus it put into hMenu in * InsertMenus. * * Parameters: * hMenu HMENU from which to remove the container's * items. * * Return Value: * HRESULT NOERROR */STDMETHODIMP CProxyFrame::RemoveMenus( HMENU /*hMenu*/ ){ // We've turned off the MSHTML.DLL Menus so we don't expect any merging to go on!
return E_NOTIMPL;}
/*
* CProxyFrame::SetStatusText * * Purpose: * Asks the container to place some text in a status line, if one * exists. If the container does not have a status line it * should return E_FAIL here in which case the object could * display its own. * * Parameters: * pszText LPCOLESTR to display. * * Return Value: * HRESULT S_OK if successful, S_TRUNCATED if not all * of the text could be displayed, or E_FAIL if * the container has no status line. */STDMETHODIMP CProxyFrame::SetStatusText( LPCOLESTR /*pszText*/ ){ return S_OK;}
/*
* CProxyFrame::EnableModeless * * Purpose: * Instructs the container to show or hide any modeless popup * windows that it may be using. * * Parameters: * fEnable BOOL indicating to enable/show the windows * (TRUE) or to hide them (FALSE). * * Return Value: * HRESULT S_OK */
STDMETHODIMP CProxyFrame::EnableModeless( BOOL /*fEnable*/ ){ return S_OK;}
/*
* CProxyFrame::TranslateAccelerator * * Purpose: * When dealing with an in-place object from an EXE server, this * is called to give the container a chance to process accelerators * after the server has looked at the message. * * Parameters: * pMSG LPMSG for the container to examine. * wID WORD the identifier in the container's * accelerator table (from IOleInPlaceSite * ::GetWindowContext) for this message (OLE does * some translation before calling). * * Return Value: * HRESULT NOERROR if the keystroke was used, * S_FALSE otherwise. */STDMETHODIMP CProxyFrame::TranslateAccelerator( LPMSG /*pMSG*/, WORD /*wID*/ ){ return S_FALSE;}
/*
* IOleCommandTarget::QueryStatus */STDMETHODIMP CProxyFrame::QueryStatus( const GUID* pguidCmdGroup, ULONG cCmds, OLECMD* prgCmds, OLECMDTEXT* pCmdText ){ if ( pguidCmdGroup != NULL ) { // It's a nonstandard group!!
return OLECMDERR_E_UNKNOWNGROUP; }
MSOCMD* pCmd; INT c; HRESULT hr = S_OK;
// By default command text is NOT SUPPORTED.
if ( pCmdText && ( pCmdText->cmdtextf != OLECMDTEXTF_NONE ) ) { pCmdText->cwActual = 0; }
// Loop through each command in the array, setting the status of each.
for ( pCmd = prgCmds, c = cCmds; --c >= 0; pCmd++ ) { // By default command status is NOT SUPPORTED.
pCmd->cmdf = 0;
switch ( pCmd->cmdID ) { case OLECMDID_UPDATECOMMANDS: pCmd->cmdf = OLECMDF_SUPPORTED; break;
case OLECMDID_NEW: case OLECMDID_OPEN: case OLECMDID_SAVE: pCmd->cmdf = (MSOCMDF_SUPPORTED | MSOCMDF_ENABLED); break; } }
return (hr);}
/*
* IOleCommandTarget::Exec */
STDMETHODIMP CProxyFrame::Exec( const GUID* pguidCmdGroup, DWORD nCmdID, DWORD /*nCmdexecopt*/, VARIANTARG* /*pvaIn*/, VARIANTARG* /*pvaOut*/ ){ HRESULT hr = S_OK;
if ( pguidCmdGroup == NULL ) { switch (nCmdID) {
case OLECMDID_UPDATECOMMANDS: { // Fires event to container.
m_pCtl->Fire_DisplayChanged(); hr = S_OK; } break;
default: hr = OLECMDERR_E_NOTSUPPORTED; break; } } else { hr = OLECMDERR_E_UNKNOWNGROUP; } return (hr);}
// Connector from control to site.
//
voidCProxyFrame::UpdateObjectRects(){ _ASSERTE ( m_pSite ); if ( NULL != m_pSite ) { m_pSite->UpdateObjectRects(); }}
// Called from the control's TranslateAccelerator.
// Try our own (VID-like) acclerators first, and if not handled pass them along to TriEdit.
//
HRESULTCProxyFrame::HrTranslateAccelerator(LPMSG lpmsg){ HRESULT hr = S_OK;
if (NULL != m_pIOleIPActiveObject) { _ASSERTE(lpmsg);
hr = HrHandleAccelerator(lpmsg);
if (hr != S_OK) { _ASSERTE(SUCCEEDED(hr)); hr = m_pIOleIPActiveObject->TranslateAccelerator(lpmsg); } }
return hr;}
// A lot of time was lost here in scenarios like clicking on/tabbing to a control
// embedded in a VB OCX, tabbing to a control on a page, etc.
// Exercise great caution and perform a lot of testing if this is changed.
//
LRESULTCProxyFrame::OnSetFocus(UINT /*nMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled){ if ( ! m_pCtl->m_bUIActive ) { m_pCtl->DoVerbUIActivate ( NULL, NULL ); }
// Give the focus to the ActiveX Document window
if ( m_hWndObj != NULL ) { ::SetFocus( m_hWndObj ); bHandled = TRUE; }
// activate Trident with "Show"
m_pSite->Activate(OLEIVERB_SHOW);
return 0;}
// Sets the Trident window's parent correctly when created and destroyed.
//
voidCProxyFrame::SetParent ( HWND hwndParent ){ // This may be called before the control has been drawn.
if ( NULL != m_hWndObj ) { if( hwndParent ) { HWND hwndOldParent = ::SetParent ( m_hWndObj, hwndParent ); if ( NULL == hwndOldParent ) { DWORD dwErr = 0; dwErr = GetLastError (); } _ASSERTE ( m_pSite ); m_pSite->SetWindow ( hwndParent ); } }}
// Handles WM_SHOWWINDOW messages directed to the control.
//
voidCProxyFrame::Show ( WPARAM nCmdShow ){ // This may be called before the control has been drawn.
// Hide or show the hosted Trident
if ( NULL != m_hWndObj ) { ::ShowWindow ( m_hWndObj, (int)nCmdShow ); }}
///////////////////////////////////////////////////////////////////////////////////////////
//
// ExecCommand mechanism
//
///////////////////////////////////////////////////////////////////////////////////////////
// Convert a command ID into a TriEdit command ID.
// Some commands used to represent other command groups as well, thus the ppguidCmdGroup parameter.
// While this does little now, it may be useful again in the future.
//
HRESULTCProxyFrame::HrMapCommand(DHTMLEDITCMDID typeLibCmdID, ULONG* cmdID, const GUID** ppguidCmdGroup, BOOL* pbOutParam){
_ASSERTE(cmdID); _ASSERTE(ppguidCmdGroup); _ASSERTE(pbOutParam);
*cmdID = 0; *ppguidCmdGroup = NULL; *pbOutParam = FALSE;
for (UINT i=0; i < sizeof(cmdMap)/sizeof(CommandMap); ++i) { if (typeLibCmdID == cmdMap[i].typeLibCmdID) { *cmdID = cmdMap[i].cmdID; *ppguidCmdGroup = &GUID_TriEditCommandGroup; *pbOutParam = cmdMap[i].bOutParam;
return S_OK; } }
return OLECMDERR_E_NOTSUPPORTED ;}
// Helper routine for calling Exec.
//
HRESULTCProxyFrame::HrExecCommand(const GUID* pguidCmdGroup, ULONG ucmdID, OLECMDEXECOPT cmdexecopt, VARIANT* pVarIn, VARIANT* pVarOut){ HRESULT hr = E_FAIL; LPOLECOMMANDTARGET pCommandTarget = NULL;
// note that it is valid for pguidCmdGroup to be NULL
_ASSERTE(m_pSite);
if (NULL == m_pSite) return E_UNEXPECTED;
pCommandTarget = m_pSite->GetCommandTarget();
_ASSERTE(pCommandTarget);
if (pCommandTarget != NULL) { hr = pCommandTarget->Exec(pguidCmdGroup, ucmdID, cmdexecopt, pVarIn, pVarOut); }
return hr;}
// Main command dispatcher; called from the control's ExecCommand method.
// Handle our unique commands here, pass the rest onto HrExecGenericCommands.
//
HRESULTCProxyFrame::HrMapExecCommand(DHTMLEDITCMDID deCommand, OLECMDEXECOPT cmdexecopt, VARIANT* pVarInput, VARIANT* pVarOutput){ HRESULT hr = S_OK; LPOLECOMMANDTARGET pCmdTgt = NULL; ULONG ulMappedCommand = 0; const GUID* pguidCmdGroup = NULL; BOOL bOutParam = FALSE;
if (FALSE == m_fActivated) return E_UNEXPECTED;
_ASSERTE(m_pSite); if (NULL == m_pSite) return E_UNEXPECTED;
pCmdTgt = m_pSite->GetCommandTarget(); _ASSERTE(pCmdTgt);
if (NULL == pCmdTgt) return E_UNEXPECTED;
// Its valid for pVarInput to be NULL
if (FAILED(hr = HrMapCommand(deCommand, &ulMappedCommand, &pguidCmdGroup, &bOutParam))) return hr;
AssureActivated();
switch ( deCommand ) { case DECMD_GETBLOCKFMTNAMES: hr = HrExecGetBlockFmtNames(pVarInput); break;
case DECMD_INSERTTABLE: hr = HrExecInsertTable(pVarInput); break;
case DECMD_GETFORECOLOR: case DECMD_GETBACKCOLOR: hr = HrExecGetColor(deCommand, ulMappedCommand, pVarOutput); break;
case DECMD_SETFONTSIZE: hr = HrExecSetFontSize(pVarInput); break;
case DECMD_GETBLOCKFMT: // Trident inconsistancy: GetBlockFmt fails if outparam isn't a BSTR. GetFontName is OK with VT_EMPTY
VariantChangeType ( pVarOutput, pVarOutput, 0, VT_BSTR ); // Fall through; do not break!
case DECMD_GETFONTNAME: case DECMD_GETFONTSIZE: hr = HrExecGenericCommands(pguidCmdGroup, ulMappedCommand, cmdexecopt, pVarOutput, TRUE ); break;
// Because our QueryStatus on DECMD_PROPERTIES returns TRUE for anything with IOleObject, executing the properties
// verb can return an unexpected error. Therefore, we ALWAYS return S_OK from this command to avoid causing VB and
// script to terminate.
case DECMD_PROPERTIES: { CComVariant varParam; varParam.vt = VT_I4; varParam.lVal = OLEIVERB_PROPERTIES; hr = HrExecGenericCommands(pguidCmdGroup, ulMappedCommand, cmdexecopt, &varParam, FALSE ); hr = S_OK; } break;
default: hr = HrExecGenericCommands(pguidCmdGroup, ulMappedCommand, cmdexecopt, pVarInput, bOutParam); break; }
if (FAILED(hr)) { if (DISP_E_BADVARTYPE == hr || DISP_E_MEMBERNOTFOUND == hr) { // Map these Trident errors to something more general.
// These errors can occur if Trident expected the element
// it was trying to operate on to support certain interfaces.
// The caller was trying to perform an operation not valid
// for the current selection. Probably didn't call QueryStatus
// first.
hr = OLECMDERR_E_NOTSUPPORTED; } }
return hr;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// ExecCommand handler implementations
//
///////////////////////////////////////////////////////////////////////////////////////////
// Helper routine for calling Exec and dealing with results.
//
HRESULTCProxyFrame::HrExecGenericCommands(const GUID* pguidCmdGroup, ULONG cmdID, OLECMDEXECOPT cmdexecopt, LPVARIANT pVarInput, BOOL bOutParam){ HRESULT hr = S_OK; LPOLECOMMANDTARGET pCmdTgt = NULL; LPVARIANT _pVar = NULL; VARIANT varCopy;
pCmdTgt = m_pSite->GetCommandTarget();
if (pVarInput && V_VT(pVarInput) & VT_BYREF) { // convert VARIANTARGs to Variant for use by Trident
// this occurs in VB if the user specified a basic type
// as an arg, i.e., String or Long, instead of Variant
VariantInit(&varCopy); if (FAILED(hr = VariantCopyInd(&varCopy, pVarInput))) { _ASSERTE(SUCCEEDED(hr)); return hr; }
_pVar = &varCopy; } else if (pVarInput) _pVar = pVarInput;
if (bOutParam) { hr = pCmdTgt->Exec(pguidCmdGroup, cmdID, cmdexecopt, NULL, _pVar); } else { hr = pCmdTgt->Exec(pguidCmdGroup, cmdID, cmdexecopt, _pVar, NULL); }
if (FAILED(hr)) goto cleanup;
// if a VARIANTARG was passed in for a command with output then
// fill it in with the result from the Exec
if (bOutParam && pVarInput && (V_VT(pVarInput) & VT_BYREF)) { _ASSERTE(_pVar); // _pVar should always be non NULL here
// if there was an input arg that was byref,
// then it should have been mapped to _pVar
if (NULL == _pVar) return E_UNEXPECTED; // the catch all error return for "we are in a weird state"
// if the type of return is different that the type the caller
// passed in then do nothing and return
if (V_VT(_pVar) != (V_VT(pVarInput) ^ VT_BYREF)) return hr;
switch(V_VT(_pVar)) { case VT_BSTR: _ASSERTE(V_VT(pVarInput) == (VT_BSTR|VT_BYREF));
if (V_BSTRREF(pVarInput)) hr = SysReAllocString(V_BSTRREF(pVarInput), V_BSTR(_pVar)); break;
case VT_BOOL: _ASSERTE(V_VT(pVarInput) == (VT_BOOL|VT_BYREF));
if (V_BOOLREF(pVarInput)) *(V_BOOLREF(pVarInput)) = V_BOOL(_pVar); break;
case VT_I4: _ASSERTE(V_VT(pVarInput) == (VT_I4|VT_BYREF));
if (V_I4REF(pVarInput)) *(V_I4REF(pVarInput)) = V_I4(_pVar); break;
default: _ASSERTE(0); break; } }
cleanup: // Our documentation replaces E_FAIL with DE_E_UNEXPECTED: different values.
if ( E_FAIL == hr ) { hr = DE_E_UNEXPECTED; }
return hr;}
// Handler for command DECMD_GETBLOCKFMTNAMES.
// There are plenty of possible types of arrays to be handled.
//
HRESULTCProxyFrame::HrExecGetBlockFmtNames(LPVARIANT pVarInput){ HRESULT hr = S_OK; LPOLECOMMANDTARGET pCmdTgt = NULL; VARIANT varArray; LPUNKNOWN pUnk = NULL; CComPtr<IDEGetBlockFmtNamesParam> piNamesParam;
pCmdTgt = m_pSite->GetCommandTarget();
if (NULL == pVarInput) return E_INVALIDARG;
if (V_VT(pVarInput) == (VT_BYREF|VT_DISPATCH)) { if (V_DISPATCHREF(pVarInput)) pUnk = *(V_DISPATCHREF(pVarInput)); else return E_INVALIDARG; } else if (V_VT(pVarInput) == VT_DISPATCH) { if (V_DISPATCH(pVarInput)) pUnk = V_DISPATCH(pVarInput); else return E_INVALIDARG; } else if (V_VT(pVarInput) == (VT_BYREF|VT_UNKNOWN)) { if (V_UNKNOWNREF(pVarInput)) pUnk = *(V_UNKNOWNREF(pVarInput)); else return E_INVALIDARG; } else if (V_VT(pVarInput) == VT_UNKNOWN) { if (V_UNKNOWN(pVarInput)) pUnk = V_UNKNOWN(pVarInput); else return E_INVALIDARG; } else return E_INVALIDARG;
// This can happen in VB if an object that has not
// been set with CreateObject has been passed in
if (NULL == pUnk) return E_INVALIDARG;
// Try to get the names object before
// performing the command
if (FAILED(hr = pUnk->QueryInterface(IID_IDEGetBlockFmtNamesParam, (LPVOID*) &piNamesParam))) return E_INVALIDARG;
_ASSERTE((!piNamesParam) == FALSE);
// Trident wants the vt to be specifically VT_ARRAY with
// no type qualifer -- if you give one it fails even though
// an array of BSTRs is returned
VariantInit(&varArray); V_VT(&varArray) = VT_ARRAY;
hr = pCmdTgt->Exec(&GUID_TriEditCommandGroup, IDM_TRIED_GETBLOCKFMTS, MSOCMDEXECOPT_DONTPROMPTUSER, NULL, &varArray);
if (FAILED(hr)) goto cleanup;
piNamesParam->put_Names(&varArray);
cleanup:
return hr;}
// Handler for command DECMD_INSERTTABLE.
//
HRESULTCProxyFrame::HrExecInsertTable(LPVARIANT pVarInput){ HRESULT hr = S_OK; LPOLECOMMANDTARGET pCmdTgt = NULL; VARIANT varTableArray; LPUNKNOWN pUnk = NULL; CComPtr<IDEInsertTableParam> piTableParam;
pCmdTgt = m_pSite->GetCommandTarget();
VariantInit(&varTableArray);
if (NULL == pVarInput) return E_INVALIDARG;
if (V_VT(pVarInput) == (VT_BYREF|VT_DISPATCH)) { if (V_DISPATCHREF(pVarInput)) pUnk = *(V_DISPATCHREF(pVarInput)); else return E_INVALIDARG; } else if (V_VT(pVarInput) == VT_DISPATCH) { if (V_DISPATCH(pVarInput)) pUnk = V_DISPATCH(pVarInput); else return E_INVALIDARG; } else if (V_VT(pVarInput) == (VT_BYREF|VT_UNKNOWN)) { if (V_UNKNOWNREF(pVarInput)) pUnk = *(V_UNKNOWNREF(pVarInput)); else return E_INVALIDARG; } else if (V_VT(pVarInput) == VT_UNKNOWN) { if (V_UNKNOWN(pVarInput)) pUnk = V_UNKNOWN(pVarInput); else return E_INVALIDARG; } else return E_INVALIDARG;
// This can happen in VB if an object that has not
// been set with CreateObject has been passed in
if (NULL == pUnk) return E_INVALIDARG;
if (FAILED(hr = pUnk->QueryInterface(IID_IDEInsertTableParam, (LPVOID*) &piTableParam))) return E_INVALIDARG;
_ASSERTE((!piTableParam) == FALSE);
if (FAILED(hr = HrGetTableSafeArray(piTableParam, &varTableArray))) { _ASSERTE(SUCCEEDED(hr)); return hr; }
hr = pCmdTgt->Exec(&GUID_TriEditCommandGroup, IDM_TRIED_INSERTTABLE, MSOCMDEXECOPT_DONTPROMPTUSER, &varTableArray, NULL);
return hr;}
// Hanlder for commands DECMD_GETFORECOLOR and DECMD_GETBACKCOLOR.
// Reply with a string in the format #RRGGBB or an empty string.
//
HRESULTCProxyFrame::HrExecGetColor(DHTMLEDITCMDID deCommand, ULONG ulMappedCommand, LPVARIANT pVarOutput){ USES_CONVERSION; HRESULT hr = S_OK; LPOLECOMMANDTARGET pCmdTgt = NULL; VARIANT varColorOut; TCHAR buf[32]; WCHAR* oleStr = NULL;
pCmdTgt = m_pSite->GetCommandTarget();
if (NULL == pVarOutput) return E_INVALIDARG;
// validate the command
if (DECMD_GETFORECOLOR != deCommand && DECMD_GETBACKCOLOR != deCommand) return E_INVALIDARG;
// validate the args
if (V_VT(pVarOutput) == (VT_BYREF|VT_BSTR)) { if (NULL == V_BSTRREF(pVarOutput)) return E_INVALIDARG; } else if (V_VT(pVarOutput) == VT_BSTR) { if (NULL == V_BSTR(pVarOutput)) return E_INVALIDARG; } else if (V_VT(pVarOutput) != (VT_EMPTY) && V_VT(pVarOutput) != (VT_NULL)) return E_INVALIDARG;
VariantInit(&varColorOut); V_VT(&varColorOut) = VT_I4;
hr = pCmdTgt->Exec(&GUID_TriEditCommandGroup, ulMappedCommand, MSOCMDEXECOPT_DONTPROMPTUSER, NULL, &varColorOut);
// Trident will return VT_NULL if color selection
// was mixed or no text is selected, we return empty
// string ("") in that case.
buf[0] = 0;
if (VT_I4 == V_VT(&varColorOut)) { ULONG ulColor = 0; ULONG r=0; ULONG g=0; ULONG b=0;
ulColor = V_I4(&varColorOut); r = 0x000000ff & ulColor; g = (0x0000ff00 & ulColor) >> 8; b = (0x00ff0000 & ulColor) >> 16;
wsprintf(buf, TEXT("#%02X%02X%02X"), r, g, b); } oleStr = T2OLE(buf);
if (V_VT(pVarOutput) == (VT_BSTR|VT_BYREF)) hr = SysReAllocString(V_BSTRREF(pVarOutput), oleStr); else if (V_VT(pVarOutput) == (VT_BSTR)) hr = SysReAllocString(&(V_BSTR(pVarOutput)), oleStr); else if (V_VT(pVarOutput) == (VT_EMPTY) || V_VT(pVarOutput) == (VT_NULL)) { V_VT(pVarOutput) = VT_BSTR; V_BSTR(pVarOutput) = SysAllocString(oleStr); }
return hr;}
// Handler for command DECMD_SETFONTSIZE.
//
HRESULTCProxyFrame::HrExecSetFontSize(LPVARIANT pVarInput){ HRESULT hr = S_OK; LPOLECOMMANDTARGET pCmdTgt = NULL; VARIANT varSizeIn;
pCmdTgt = m_pSite->GetCommandTarget();
if (NULL == pVarInput) return E_INVALIDARG;
VariantInit(&varSizeIn);
if (FAILED(hr = VariantChangeType(&varSizeIn, pVarInput, 0, VT_I4))) return E_INVALIDARG;
if (varSizeIn.lVal < 0 || varSizeIn.lVal > 7) return E_INVALIDARG;
if (0 == varSizeIn.lVal) varSizeIn.lVal = varSizeIn.lVal + 1;
hr = pCmdTgt->Exec(&GUID_TriEditCommandGroup, IDM_TRIED_FONTSIZE, MSOCMDEXECOPT_DONTPROMPTUSER, &varSizeIn, NULL);
return hr;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// QueryStatus mechanism
//
///////////////////////////////////////////////////////////////////////////////////////////
// Map the control specific command ID to a TriEdit command ID and call QueryStatus.
//
HRESULTCProxyFrame::HrMapQueryStatus( DHTMLEDITCMDID ucmdID, DHTMLEDITCMDF* cmdf){ LPOLECOMMANDTARGET pCommandTarget = NULL;
_ASSERTE(cmdf);
HRESULT hr = E_FAIL;
if (FALSE == m_fActivated) return E_UNEXPECTED;
if (NULL == cmdf) return E_INVALIDARG;
*cmdf = (DHTMLEDITCMDF) 0;
_ASSERTE(m_pSite);
if (NULL == m_pSite) return E_UNEXPECTED;
pCommandTarget = m_pSite->GetCommandTarget(); _ASSERTE(pCommandTarget);
if ( pCommandTarget != NULL ) {
AssureActivated ();
ULONG cmdID = 0; const GUID* pguidCmdGroup = NULL; BOOL bOutParam = FALSE;
if (SUCCEEDED(hr = HrMapCommand(ucmdID, &cmdID, &pguidCmdGroup, &bOutParam))) { MSOCMD msocmd; msocmd.cmdID = cmdID; msocmd.cmdf = 0;
hr = pCommandTarget->QueryStatus(pguidCmdGroup, 1, &msocmd, NULL);
*cmdf = (DHTMLEDITCMDF) msocmd.cmdf; } }
return hr;}
// General routine for determining the status of a command.
// Should resolve to not supported, disabled, enabled, latched or ninched.
//
HRESULTCProxyFrame::HrQueryStatus(const GUID* pguidCmdGroup, ULONG ucmdID, OLECMDF* cmdf){ HRESULT hr = E_FAIL;
_ASSERTE(cmdf);
// Note that it is valid for pguidCmdGroup to be NULL
if (NULL == cmdf) return E_INVALIDARG;
*cmdf = (OLECMDF) 0;
_ASSERTE(m_pSite);
if ( m_pSite != NULL ) // m_pSite should always be set
{ LPOLECOMMANDTARGET pCommandTarget = m_pSite->GetCommandTarget();
if ( pCommandTarget != NULL ) { MSOCMD msocmd; msocmd.cmdID = ucmdID; msocmd.cmdf = 0;
hr = pCommandTarget->QueryStatus(pguidCmdGroup, 1, &msocmd, NULL);
*cmdf = (OLECMDF) msocmd.cmdf; } }
return hr;}
// A tragic FAT16 compatibility problem: file names in the specific form:
// [a-zA-z]\:[^\\].+ cause various, severe problems. NTFS "forgives".
// We must detect these, both in file names and file:// URL and return an error.
//
BOOLCProxyFrame::IsMissingBackSlash ( BSTR path, BOOL bfIsURL ){ BOOL bfMissing = FALSE;
if ( bfIsURL ) { WCHAR wszFileProtocol[] = L"file://"; int cchProtocol = wcslen ( wszFileProtocol );
if ( 0 == _wcsnicmp ( path, wszFileProtocol, cchProtocol ) ) { if ( OLECHAR(':') == path[cchProtocol+1] ) { if ( OLECHAR('\\') != path[cchProtocol+2] ) { bfMissing = TRUE; } } } } else { // Path name. chec for drive letter, colon, non-backslash.
if ( OLECHAR(':') == path[1] ) { if ( OLECHAR('\\') != path[2] ) { bfMissing = TRUE; } } } return bfMissing;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// Control methods and properties
//
///////////////////////////////////////////////////////////////////////////////////////////
// Handles NewDocument, LoadURL and LoadDocument control methods.
// The document is loaded indirectly via the pluggable protocol handler.
// If "path" is NULL, do NewDocument. TestbfURL to see if it's a URL or UNC path.
//
HRESULTCProxyFrame::LoadDocument(BSTR path, BOOL bfIsURL ){ USES_CONVERSION;
HRESULT hr = S_OK; UINT pathLen = 0;
AssureActivated (); // This can set m_bstrLoadText as a side effect in unactivated controls! Be careful!
if (FALSE == m_fActivated) return E_UNEXPECTED;
m_bstrLoadText.Empty (); // Clear the text to be added directly, or it will be used instead!
m_bstrCurDocPath = L""; m_bstrBaseURL = L"";
if (path) pathLen = ::SysStringLen(path); else pathLen = 0;
// We've resetting the contents of the control. Go back to default save mechanism.
// If we load Unicode it will be reset.
m_pSite->SetSaveAsUnicode ( FALSE );
if (path && pathLen) { _ASSERTE(path); _ASSERTE(pathLen > 0);
// First, look out for a wicked error: X:FileName with no '\' is BAD on FAT16.
if ( IsMissingBackSlash ( path, bfIsURL ) ) { hr = DE_E_PATH_NOT_FOUND; LoadBSTRDeferred ( m_bstrInitialDoc ); goto error; }
// Try to open the file -- stop the sequence
// if its bogus or we don't have access
if ( !bfIsURL ) { if (FAILED(hr = m_pSite->HrTestFileOpen(path))) { LoadBSTRDeferred ( m_bstrInitialDoc ); goto error; } } m_bfIsURL = bfIsURL;
m_bstrCurDocPath = path; // This needs to be set before loading, because base url is needed durring load.
SetBaseURLFromCurDocPath ( bfIsURL ); m_bfPreserveDirtyFlagAcrossBrowseMode = FALSE;
CComPtr<IMoniker> srpMoniker; CComPtr<IBindCtx> srpBindCtx; CComQIPtr<IPersistMoniker, &IID_IPersistMoniker> srpPM (m_pUnkTriEdit); _ASSERTE ( srpPM );
if ( srpPM ) { CComBSTR bstrProtocol = m_wszProtocolPrefix; bstrProtocol += L"("; bstrProtocol += path; bstrProtocol += L")";
#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnCreateURLMoniker ); hr = (*m_pfnCreateURLMoniker)( NULL, bstrProtocol, &srpMoniker );#else
hr = CreateURLMoniker ( NULL, bstrProtocol, &srpMoniker );#endif // LATE_BIND_URLMON_WININET
_ASSERTE ( SUCCEEDED( hr ) ); if ( SUCCEEDED ( hr ) ) { hr = ::CreateBindCtx(NULL, &srpBindCtx); _ASSERTE ( SUCCEEDED( hr ) ); if ( SUCCEEDED ( hr ) ) { // Delete the cache entry before downloading.
// This assures that loading, posting, and reloading works.
// Bug 18544.
// NOTE: Inexact match fails! http://www.microsoft.com fails,
// because this actually loads/caches a specific default page.
if ( bfIsURL ) { LPTSTR szURL = OLE2T ( m_bstrCurDocPath );#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnDeleteUrlCacheEntry ); (*m_pfnDeleteUrlCacheEntry)( szURL );#else
DeleteUrlCacheEntry ( szURL );#endif // LATE_BIND_URLMON_WININET
} m_bfIsLoading = TRUE; m_hrDeferredLoadError = S_OK; // URLs: don't let Trident get the error!
hr = srpPM->Load(FALSE, srpMoniker, srpBindCtx, STGM_READ);
if ( SUCCEEDED ( hr ) && FAILED ( m_hrDeferredLoadError ) ) { hr = m_hrDeferredLoadError; // In case we stashed a result
} if ( FAILED ( hr ) ) { m_bfIsLoading = FALSE; } } } } } else { if (FAILED(hr = LoadBSTRDeferred ( m_bstrInitialDoc ))) { _ASSERTE(SUCCEEDED(hr)); goto error; } }
error: return hr;}
// Implements FilterSourceCode control method
// Used to restore filtered content extracted directly from DOM.
//
HRESULTCProxyFrame::FilterSourceCode ( BSTR bsSourceIn, BSTR* pbsSourceOut ){ HRESULT hr; CComPtr<IStream> spStreamIn; IStream* piStreamOut;
hr = m_pSite->HrBstrToStream(bsSourceIn, &spStreamIn); if ( SUCCEEDED ( hr ) ) { if ( m_vbBrowseMode ) { spStreamIn.p->AddRef (); piStreamOut = spStreamIn; } else { hr = m_pSite->HrFilter ( FALSE, spStreamIn, &piStreamOut, m_dwFilterOutFlags | dwFilterSourceCode); } if ( SUCCEEDED ( hr ) ) { hr = m_pSite->HrStreamToBstr ( piStreamOut, pbsSourceOut ); piStreamOut->Release (); } } return hr;}
// Implements the control's Print method
//
HRESULTCProxyFrame::Print ( BOOL bfWithUI ){ AssureActivated ();
if (FALSE == m_fActivated) return E_UNEXPECTED; return HrExecCommand ( &GUID_TriEditCommandGroup, IDM_TRIED_PRINT, bfWithUI ? MSOCMDEXECOPT_PROMPTUSER : MSOCMDEXECOPT_DONTPROMPTUSER, NULL, NULL );}
// Implements the control's Refresh method
//
HRESULTCProxyFrame::RefreshDoc (){ if ( NULL != m_hWndObj ) { if ( ::IsWindow ( m_hWndObj ) ) { ::InvalidateRect ( m_hWndObj, NULL, TRUE ); return S_OK; } } return S_FALSE;}
// Implements the control's SaveDocument method
//
HRESULTCProxyFrame::SaveDocument(BSTR path){ HRESULT hr = S_OK; ULONG pathLen = 0;
if (FALSE == m_fActivated) return E_UNEXPECTED;
_ASSERTE(GetState() == ESTATE_ACTIVATED);
AssureActivated ();
if (GetState() != ESTATE_ACTIVATED) return E_UNEXPECTED;
_ASSERTE(path);
if (path) pathLen = ::SysStringLen(path); else pathLen = 0;
if (0 == pathLen) return E_INVALIDARG;
_ASSERTE(pathLen);
// First, look out for a wicked error: X:FileName with no '\' is BAD on FAT16.
if ( IsMissingBackSlash ( path, FALSE ) ) { return DE_E_PATH_NOT_FOUND; }
hr = m_pSite->HrSaveToFile(path, m_dwFilterOutFlags);
if ( SUCCEEDED ( hr ) ) { m_bstrCurDocPath = path; }
return hr;}
// Implements the control's SetContextMenu method
// One routine handles javascript arrays, the other simple arrays.
//
HRESULTCProxyFrame::SetContextMenu(LPVARIANT pVarMenuStrings, LPVARIANT pVarMenuStates){ if (V_VT(pVarMenuStrings) == VT_DISPATCH || V_VT(pVarMenuStates) == VT_DISPATCH) return SetContextMenuDispEx(pVarMenuStrings, pVarMenuStates); else return SetContextMenuSA(pVarMenuStrings, pVarMenuStates);}
// Get menu strings from SafeArray
//
HRESULTCProxyFrame::SetContextMenuSA(LPVARIANT pVarMenuStrings, LPVARIANT pVarMenuStates){ HRESULT hr = S_OK; SAFEARRAY* psaStrings = NULL; SAFEARRAY* psaStates = NULL; LONG lLBound, lUBound, lLBoundState, lUBoundState;
if (NULL == pVarMenuStrings || NULL == pVarMenuStates) return E_INVALIDARG;
if ((VT_ARRAY|VT_BSTR) != V_VT(pVarMenuStrings) && ((VT_ARRAY|VT_BSTR)|VT_BYREF) != V_VT(pVarMenuStrings) && ((VT_ARRAY|VT_VARIANT)|VT_BYREF) != V_VT(pVarMenuStrings) && (VT_ARRAY|VT_VARIANT) != V_VT(pVarMenuStrings)) return E_INVALIDARG;
if ((VT_ARRAY|VT_I4) != V_VT(pVarMenuStates) && ((VT_ARRAY|VT_I4)|VT_BYREF) != V_VT(pVarMenuStates) && ((VT_ARRAY|VT_VARIANT)|VT_BYREF) != V_VT(pVarMenuStates) && (VT_ARRAY|VT_VARIANT) != V_VT(pVarMenuStates)) return E_INVALIDARG;
if ((VT_ARRAY|VT_BSTR) == V_VT(pVarMenuStrings)) { psaStrings = V_ARRAY(pVarMenuStrings); } if ((VT_ARRAY|VT_VARIANT) == V_VT(pVarMenuStrings)) { psaStrings = V_ARRAY(pVarMenuStrings); } else if ((VT_ARRAY|VT_BSTR|VT_BYREF) == V_VT(pVarMenuStrings)) { if (NULL == V_ARRAYREF(pVarMenuStrings)) return E_INVALIDARG;
psaStrings = *(V_ARRAYREF(pVarMenuStrings)); } else if ((VT_ARRAY|VT_VARIANT|VT_BYREF) == V_VT(pVarMenuStrings)) { if (NULL == V_ARRAYREF(pVarMenuStrings)) return E_INVALIDARG; psaStrings = *(V_ARRAYREF(pVarMenuStrings)); }
if ((VT_ARRAY|VT_I4) == V_VT(pVarMenuStates)) { psaStates = V_ARRAY(pVarMenuStates); } if ((VT_ARRAY|VT_VARIANT) == V_VT(pVarMenuStates)) { psaStates = V_ARRAY(pVarMenuStates); } else if ((VT_ARRAY|VT_I4|VT_BYREF) == V_VT(pVarMenuStates)) { if (NULL == V_ARRAYREF(pVarMenuStates)) return E_INVALIDARG;
psaStates = *(V_ARRAYREF(pVarMenuStates)); } else if ((VT_ARRAY|VT_VARIANT|VT_BYREF) == V_VT(pVarMenuStates)) { if (NULL == V_ARRAYREF(pVarMenuStates)) return E_INVALIDARG;
psaStates = *(V_ARRAYREF(pVarMenuStates)); }
if (NULL == psaStrings || NULL == psaStates) return E_INVALIDARG;
SafeArrayGetLBound(psaStrings, 1, &lLBound); SafeArrayGetUBound(psaStrings, 1, &lUBound);
SafeArrayGetLBound(psaStates, 1, &lLBoundState); SafeArrayGetUBound(psaStates, 1, &lUBoundState);
if (lLBound != lLBoundState || lUBound != lUBoundState) return E_INVALIDARG;
if (m_pMenuStrings) { SafeArrayDestroy(m_pMenuStrings); m_pMenuStrings = NULL; }
if (m_pMenuStates) { SafeArrayDestroy(m_pMenuStates); m_pMenuStates = NULL; }
// An empty array was passed in
// The context menu has been cleared
if (lLBound ==lUBound ) goto cleanup;
if (FAILED(hr = SafeArrayCopy(psaStrings, &m_pMenuStrings))) goto cleanup;
if (FAILED(hr = SafeArrayCopy(psaStates, &m_pMenuStates))) goto cleanup;
cleanup:
if (FAILED(hr)) { if (m_pMenuStrings) { SafeArrayDestroy(m_pMenuStrings); m_pMenuStrings = NULL; }
if (m_pMenuStates) { SafeArrayDestroy(m_pMenuStates); m_pMenuStates = NULL; } }
return hr;}
// Get menu strings from JScript array, or object that supports IDispatchEx
// For iterating through JScript arrays, we expect the elements
// to be accessable by ordinals starting at 0, i.e., a 0 based array
//
HRESULTCProxyFrame::SetContextMenuDispEx(LPVARIANT pVarMenuStrings, LPVARIANT pVarMenuStates){ HRESULT hr = S_OK; ULONG i=0; ULONG ulStringsLen = 0; ULONG ulStatesLen = 0; IDispatch* pdStrings = NULL; IDispatch* pdStates = NULL; IDispatchEx* pdexStrings = NULL; IDispatchEx* pdexStates = NULL; CDispExArray dispStrings; CDispExArray dispStates; VARIANT varString; VARIANT varState; SAFEARRAYBOUND rgsabound[1] = {0}; LONG ix[1] = {0};
if (VT_DISPATCH != V_VT(pVarMenuStrings) || VT_DISPATCH != V_VT(pVarMenuStates)) return E_INVALIDARG;
VariantInit(&varString); VariantInit(&varState);
pdStrings = V_DISPATCH(pVarMenuStrings); pdStates = V_DISPATCH(pVarMenuStates);
_ASSERTE(pdStrings); _ASSERTE(pdStates);
if (FAILED(hr = pdStrings->QueryInterface(IID_IDispatchEx, (LPVOID*) &pdexStrings))) { return E_INVALIDARG; } dispStrings.Attach(pdexStrings);
if (FAILED(hr = pdStates->QueryInterface(IID_IDispatchEx, (LPVOID*) &pdexStates))) { return E_INVALIDARG; } dispStates.Attach(pdexStates);
if (FAILED(dispStrings.HrGetLength(&ulStringsLen))) goto cleanup;
if (FAILED(dispStates.HrGetLength(&ulStatesLen))) goto cleanup;
// Make sure that arrays are equal length
if (ulStringsLen != ulStatesLen) return E_INVALIDARG;
if (m_pMenuStrings) { SafeArrayDestroy(m_pMenuStrings); m_pMenuStrings = NULL; }
if (m_pMenuStates) { SafeArrayDestroy(m_pMenuStates); m_pMenuStates = NULL; }
// An empty array was passed in
// The context menu has been cleared
if (ulStringsLen <= 0) goto cleanup;
rgsabound[0].lLbound = 0; rgsabound[0].cElements = ulStringsLen;
m_pMenuStrings = SafeArrayCreate(VT_BSTR, 1, rgsabound); _ASSERTE(m_pMenuStrings); if (NULL == m_pMenuStrings) { hr = E_OUTOFMEMORY; goto cleanup; }
m_pMenuStates = SafeArrayCreate(VT_I4, 1, rgsabound); _ASSERTE(m_pMenuStates); if (NULL == m_pMenuStates) { hr = E_OUTOFMEMORY; goto cleanup; }
// For iterating through JScript arrays, we expect the elements
// to be accessable by ordinals starting at 0, i.e., a 0 based array
hr = S_OK; for (i=0; i < ulStringsLen && hr != S_FALSE; i++) { if (FAILED(hr = dispStrings.HrGetElement(i, &varString))) goto cleanup;
if (FAILED(hr = dispStates.HrGetElement(i, &varState))) goto cleanup;
if (VT_BSTR != V_VT(&varString) || VT_I4 != V_VT(&varState)) { hr = E_INVALIDARG; goto cleanup; }
ix[0] = i; if (FAILED(hr = SafeArrayPutElement(m_pMenuStrings, ix, (LPVOID) V_BSTR(&varString)))) goto cleanup;
if (FAILED(hr = SafeArrayPutElement(m_pMenuStates, ix, (LPVOID) &(V_I4(&varState))))) goto cleanup;
VariantClear ( &varString ); VariantClear ( &varState ); }
cleanup:
if (FAILED(hr)) { if (m_pMenuStrings) { SafeArrayDestroy(m_pMenuStrings); m_pMenuStrings = NULL; }
if (m_pMenuStates) { SafeArrayDestroy(m_pMenuStates); m_pMenuStates = NULL; } }
return hr;}
// DocumentTitle property implementation; read only.
// Get the property from the HTML document.
//
HRESULTCProxyFrame::GetDocumentTitle ( CComBSTR& bstrTitle ){ HRESULT hr = S_OK; DISPID dispid; DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0}; CComVariant varResult;
CComPtr<IHTMLDocument2> piHtmlDoc = NULL; hr = HrGetDoc( &piHtmlDoc );
if ( SUCCEEDED ( hr ) ) { AssureActivated();
hr = piHtmlDoc->GetIDsOfNames ( IID_NULL, &g_wszHTMLTitlePropName, 1, LOCALE_SYSTEM_DEFAULT, &dispid ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( FAILED ( hr ) ) { return hr; }
hr = piHtmlDoc->Invoke ( dispid, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &dispparamsNoArgs, &varResult, NULL, NULL ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( FAILED ( hr ) ) { return hr; } hr = varResult.ChangeType ( VT_BSTR ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( FAILED ( hr ) ) { return hr; }
bstrTitle = varResult.bstrVal; }
return hr;}
// Implements getting the control's BrowseMode property
//
HRESULTCProxyFrame::GetBrowseMode ( VARIANT_BOOL *pVal ){ *pVal = m_vbBrowseMode; return S_OK;}
// Implements setting the control's BrowseMode property
//
HRESULTCProxyFrame::SetBrowseMode ( VARIANT_BOOL newVal ){ HRESULT hr = S_FALSE; // Indicates value was set, but actual mode was not changed.
_ASSERTE ( m_pSite );
// If we're still reading the property bag, just set the value, don't change the text;
// it hasn't been loaded yet.
if ( NULL == m_pSite->GetCommandTarget() ) { m_vbBrowseMode = newVal; hr = S_OK; } else { if ( m_vbBrowseMode != newVal ) { AssureActivated ();
m_bfModeSwitched = TRUE;
if ( newVal && m_pCtl->IsUserMode () ) // newVal means "switching to browse mode"
{ CComPtr<IStream> spStream = NULL;
HrGetIsDirty ( m_bfPreserveDirtyFlagAcrossBrowseMode ); hr = m_pSite->HrSaveToStreamAndFilter ( &spStream, m_dwFilterOutFlags ); if ( SUCCEEDED ( hr ) ) { m_bstrLoadText.Empty (); // Preserve the byte order mark, or else it will not be reloaded properly
hr = m_pSite->HrStreamToBstr ( spStream, &m_bstrLoadText, TRUE ); } }
m_vbBrowseMode = newVal;
// Let Trident know the ambient property has changed.
CComQIPtr<IOleControl,&IID_IOleControl>spioc ( m_pSite->GetObjectUnknown() ); if ( spioc ) { m_bfIsLoading = TRUE; spioc->OnAmbientPropertyChange ( DISPID_AMBIENT_USERMODE ); } } } return hr;}
// Implements getting the control's UseDivOnCarriageReturn property
//
HRESULTCProxyFrame::GetDivOnCr ( VARIANT_BOOL *pVal ){ *pVal = m_vbUseDivOnCr; return S_OK;}
// Implements setting the control's UseDivOnCarriageReturn property
//
HRESULTCProxyFrame::SetDivOnCr ( VARIANT_BOOL newVal ){ HRESULT hr = S_OK; CComVariant varDefBlock;
m_vbUseDivOnCr = newVal;
// Reinitialize if we haven't loaded our properties before this point.
if ( READYSTATE_UNINITIALIZED == m_readyState ) { // InitializeDocString takes m_vbUseDivOnCr into account
InitializeDocString (); } return hr;}
// Implements getting the control's read-only Busy property
//
HRESULTCProxyFrame::GetBusy ( VARIANT_BOOL *pVal ){#pragma warning(disable: 4310) // cast truncates constant value
*pVal = ( m_bfIsLoading ) ? VARIANT_TRUE : VARIANT_FALSE;#pragma warning(default: 4310) // cast truncates constant value
return S_OK;}
// Implements setting the control's ActivateActiveXControls property
//
HRESULTCProxyFrame::HrSetPropActivateControls(BOOL activateControls){ HRESULT hr = S_OK;
if (m_fActivated) { if (SUCCEEDED(hr = HrTridentSetPropBool(IDM_NOACTIVATENORMALOLECONTROLS, !activateControls))) m_fActivateControls = activateControls; } else m_fActivateControls = activateControls;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's ActivateActiveXControls property
//
HRESULTCProxyFrame::HrGetPropActivateControls(BOOL& activateControls){ HRESULT hr = S_OK;
activateControls = m_fActivateControls;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements setting the control's ActivateApplets property
//
HRESULTCProxyFrame::HrSetPropActivateApplets(BOOL activateApplets){ HRESULT hr = S_OK;
if (m_fActivated) { if (SUCCEEDED(hr = HrTridentSetPropBool(IDM_NOACTIVATEJAVAAPPLETS, !activateApplets))) m_fActivateApplets = activateApplets; } else m_fActivateApplets = activateApplets;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's ActivateApplets property
//
HRESULTCProxyFrame::HrGetPropActivateApplets(BOOL& activateApplets){ HRESULT hr = S_OK;
activateApplets = m_fActivateApplets;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements setting the control's ActivateDTCs property
//
HRESULTCProxyFrame::HrSetPropActivateDTCs(BOOL activateDTCs){ HRESULT hr = S_OK;
if (m_fActivated) { if (SUCCEEDED(hr = HrTridentSetPropBool(IDM_NOACTIVATEDESIGNTIMECONTROLS, !activateDTCs))) m_fActivateDTCs = activateDTCs; } else m_fActivateDTCs = activateDTCs;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's ActivateDTCs property
//
HRESULTCProxyFrame::HrGetPropActivateDTCs(BOOL& activateDTCs){ HRESULT hr = S_OK;
activateDTCs = m_fActivateDTCs;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements setting the control's ShowDetails property
//
HRESULTCProxyFrame::HrSetPropShowAllTags(BOOL showAllTags){ HRESULT hr = S_OK;
if (m_fActivated) { if (SUCCEEDED(hr = HrTridentSetPropBool(IDM_SHOWALLTAGS, showAllTags))) m_fShowAllTags = showAllTags; } else m_fShowAllTags = showAllTags;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's ShowDetails property
//
HRESULTCProxyFrame::HrGetPropShowAllTags(BOOL& showAllTags){ HRESULT hr = S_OK;
showAllTags = m_fShowAllTags;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements setting the control's ShowBorders property
//
HRESULTCProxyFrame::HrSetPropShowBorders(BOOL showBorders){ HRESULT hr = S_OK;
if (m_fActivated) { if (SUCCEEDED(hr = HrTridentSetPropBool(IDM_SHOWZEROBORDERATDESIGNTIME, showBorders))) m_fShowBorders = showBorders; } else m_fShowBorders = showBorders;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's ShowBorders property
//
HRESULTCProxyFrame::HrGetPropShowBorders(BOOL& showBorders){ HRESULT hr = S_OK;
showBorders = m_fShowBorders;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements setting the control's Appearance property
//
HRESULTCProxyFrame::HrSetDisplay3D(BOOL bVal){ m_fDisplay3D = bVal; return S_OK;}
// Implements getting the control's Appearance property
//
HRESULTCProxyFrame::HrGetDisplay3D(BOOL& bVal){ bVal = m_fDisplay3D; return S_OK;}
// Implements setting the control's Scrollbars property
//
HRESULTCProxyFrame::HrSetScrollbars(BOOL bVal){ m_fScrollbars = bVal; return S_OK;}
// Implements getting the control's Scrollbars property
//
HRESULTCProxyFrame::HrGetScrollbars(BOOL& bVal){ bVal = m_fScrollbars; return S_OK;}
// Implements setting the control's ScrollbarAppearance property
//
HRESULTCProxyFrame::HrSetDisplayFlatScrollbars(BOOL bVal){ m_fDisplayFlatScrollbars = bVal; return S_OK;}
// Implements getting the control's ScrollbarAppearance property
//
HRESULTCProxyFrame::HrGetDisplayFlatScrollbars(BOOL& bVal){ bVal = m_fDisplayFlatScrollbars; return S_OK;}
// Implements setting the control's AbsoluteDropMode property
//
HRESULTCProxyFrame::HrSetAbsoluteDropMode(BOOL dropMode){ HRESULT hr = S_OK;
if (m_fActivated) { VARIANT var;
VariantInit(&var);
V_VT(&var) = VT_BOOL;#pragma warning(disable: 4310) // cast truncates constant value
V_BOOL(&var) = (dropMode) ? VARIANT_TRUE : VARIANT_FALSE;#pragma warning(default: 4310) // cast truncates constant value
if (SUCCEEDED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_SET_2D_DROP_MODE, MSOCMDEXECOPT_DONTPROMPTUSER, &var, NULL))) m_fAbsoluteDropMode = dropMode; } else m_fAbsoluteDropMode = dropMode;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's AbsoluteDropMode property
//
HRESULTCProxyFrame::HrGetAbsoluteDropMode(BOOL& dropMode){ HRESULT hr = S_OK;
dropMode = m_fAbsoluteDropMode; return hr;}
// Implements setting the control's SnapToGrid property
//
HRESULTCProxyFrame::HrSetSnapToGrid(BOOL snapToGrid){ HRESULT hr = S_OK;
if (m_fActivated) { VARIANT var; POINT pt = {0};
VariantInit(&var); if ( snapToGrid ) { pt.y = m_ulSnapToGridY; pt.x = m_ulSnapToGridX; } else { pt.y = 0; pt.x = 0; }
V_VT(&var) = VT_BYREF; V_BYREF(&var) = &pt;
if (SUCCEEDED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_SET_ALIGNMENT, MSOCMDEXECOPT_DONTPROMPTUSER, &var, NULL))) m_fSnapToGrid = snapToGrid;
} else m_fSnapToGrid = snapToGrid;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's SnapToGrid property
//
HRESULTCProxyFrame::HrGetSnapToGrid(BOOL& snapToGrid){ HRESULT hr = S_OK;
snapToGrid = m_fSnapToGrid; return hr;}
// Implements setting the control's SnapToGridX property
//
HRESULTCProxyFrame::HrSetSnapToGridX(LONG snapToGridX){ HRESULT hr = S_OK;
if ( 0 >= snapToGridX ) { return DE_E_INVALIDARG; }
if (m_fActivated) { VARIANT var; POINT pt = {0};
VariantInit(&var);
pt.x = snapToGridX; pt.y = m_ulSnapToGridY;
V_VT(&var) = VT_BYREF; V_BYREF(&var) = &pt;
if (SUCCEEDED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_SET_ALIGNMENT, MSOCMDEXECOPT_DONTPROMPTUSER, &var, NULL))) m_ulSnapToGridX = snapToGridX; } else m_ulSnapToGridX = snapToGridX;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's SnapToGridX property
//
HRESULTCProxyFrame::HrGetSnapToGridX(LONG& snapToGridX){ HRESULT hr = S_OK;
snapToGridX = m_ulSnapToGridX; return hr;}
// Implements setting the control's SnapToGridY property
//
HRESULTCProxyFrame::HrSetSnapToGridY(LONG snapToGridY){ HRESULT hr = S_OK;
if ( 0 >= snapToGridY ) { return DE_E_INVALIDARG; }
if (m_fActivated) { VARIANT var; POINT pt = {0};
VariantInit(&var); pt.y = snapToGridY; pt.x = m_ulSnapToGridX;
V_VT(&var) = VT_BYREF; V_BYREF(&var) = &pt;
if (SUCCEEDED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_SET_ALIGNMENT, MSOCMDEXECOPT_DONTPROMPTUSER, &var, NULL))) m_ulSnapToGridY = snapToGridY; } else m_ulSnapToGridY = snapToGridY;
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Implements getting the control's SnapToGridY property
//
HRESULTCProxyFrame::HrGetSnapToGridY(LONG& snapToGridY){ HRESULT hr = S_OK;
snapToGridY = m_ulSnapToGridY; return hr;}
// Implements setting the control's DocumentHTML property
//
HRESULTCProxyFrame::HrSetDocumentHTML(BSTR bVal){ HRESULT hr = S_OK;
_ASSERTE(bVal);
if (NULL == bVal) return E_INVALIDARG;
if (m_pCtl->IsUserMode ()) { hr = DE_E_UNEXPECTED;
AssureActivated (); if ( m_fActivated ) { m_bstrBaseURL = L""; m_bfPreserveDirtyFlagAcrossBrowseMode = FALSE; if ( 0 == SysStringLen ( bVal ) ) { CComBSTR bstrMT = GetInitialHTML (); hr = LoadBSTRDeferred ( bstrMT ); } else { hr = LoadBSTRDeferred ( bVal ); }
if ( FAILED ( hr ) ) { goto error; }
// We've reset the contents of the control. Go back to default save mechanism.
m_pSite->SetSaveAsUnicode ( FALSE ); } }
error:
return hr;}
// Implements getting the control's DocumentHTML property
//
HRESULTCProxyFrame::HrGetDocumentHTML(BSTR* bVal){ HRESULT hr = S_OK; BOOL bfWasDirty = FALSE;
_ASSERTE(bVal);
if (NULL == bVal) return E_INVALIDARG;
if ( m_bfIsLoading ) return DE_E_UNEXPECTED; // This is invalid while document is still loading.
if ( FAILED ( hr = m_pSite->HrIsDirtyIPersistStreamInit(bfWasDirty) ) ) { _ASSERTE ( SUCCEEDED ( hr ) ); bfWasDirty = FALSE; // what else can we do in a situation like this?
}
AssureActivated ();
if (m_fActivated) { _ASSERTE(m_pSite);
hr = m_pSite->HrSaveToBstr(bVal, m_dwFilterOutFlags );
// Preserve original dirty state.
if ( bfWasDirty ) { SetDirtyFlag ( TRUE ); } }
return hr;}
// Implements setting the control's SourceCodePreservation property
//
HRESULTCProxyFrame::HrSetPreserveSource(BOOL bVal){ m_fPreserveSource = bVal; if (m_fPreserveSource) m_dwFilterFlags = filterAll; else m_dwFilterFlags = filterDTCs | filterASP;
return S_OK;}
// Implements getting the control's SourceCodePreservation property
//
HRESULTCProxyFrame::HrGetPreserveSource(BOOL& bVal){ bVal = m_fPreserveSource; return S_OK;}
// Implements getting the control's read-only IsDirty property
//
HRESULTCProxyFrame::HrGetIsDirty(BOOL& bVal){ HRESULT hr = S_OK;
bVal = FALSE;
AssureActivated ();
if (m_fActivated) { hr = m_pSite->HrIsDirtyIPersistStreamInit(bVal); }
return hr;}
// Implements getting the BaseURL property
//
HRESULTCProxyFrame::GetBaseURL ( CComBSTR& bstrBaseURL ){ AssureActivated ();
if ( NULL == m_bstrBaseURL.m_str ) { bstrBaseURL = L""; } else { bstrBaseURL = m_bstrBaseURL; } return S_OK;}
// Implements setting the BaseURL property.
// NOTE:
// The BaseURL can't be (effectively) changed if there's a <BASE HREF=XXX> tag in
// the document. Our pluggable Protocol's CombineURL is never called in this case,
// so don't misguide the user by changing the property.
//
// Pay attention to m_bfBaseURLFromBASETag before calling to set the value from
// the routine parsing the <BASE> tag!
//
HRESULTCProxyFrame::SetBaseURL ( CComBSTR& bstrBaseURL ){ HRESULT hr = S_OK;
_ASSERTE ( bstrBaseURL );
// Non-persisted property. Ignore if not in UserMode.
if ( m_pCtl->IsUserMode () ) { if ( m_bfBaseURLFromBASETag ) { return S_FALSE; } else { if ( NULL == m_bstrBaseURL.m_str ) { m_bstrBaseURL = L""; }
// If this test succeedes, the user has done something like x.BaseURL = x.DOM.url or
// x.BaseURL = y.DOM.url.
// Response: bstrBaseURL may be the bare protocol prefix, or a prefix with a URL attached
// for example: dhtmled0:(http://www.microsoft.com).
// Strip off the prefix and parens (if they exist) and use the interior URL.
if ( 0 == _wcsnicmp ( bstrBaseURL.m_str, g_wszProtocolPrefix, wcslen ( g_wszProtocolPrefix ) ) ) { CComBSTR bstrNew = bstrBaseURL.m_str;
// There must be a colon; it would be possibe to have a legitimate base url beginning with g_wszProtocolPrefix
WCHAR* pwcURL = wcschr ( bstrNew, (WCHAR)':' ); if ( NULL != pwcURL ) { // Find the first open paren:
pwcURL = wcschr ( pwcURL, (WCHAR)'(' ); if ( NULL == pwcURL ) { bstrBaseURL = L""; // No (...)? Set the Base to empty. Input must have been bare protocol ID.
} else { pwcURL++; // Step past the paren.
// Strip of dhtmledXXX:( ...to... ) and set the BaseURL to what remains.
_ASSERTE ( (WCHAR)')' == pwcURL[wcslen(pwcURL)-1] ); if ( (WCHAR)')' == pwcURL[wcslen(pwcURL)-1] ) { pwcURL[wcslen(pwcURL)-1] = (WCHAR)'\0'; bstrBaseURL = pwcURL; } else { // Unexpected: ill formed pluggable protocol id:
// starts with dhtml[n[n]]:( but does not end with ).
// If we skipped it, we would crash. Best to use an empty base URL.
bstrBaseURL = L""; } } } }
if ( 0 != wcscmp ( m_bstrBaseURL.m_str, bstrBaseURL.m_str ) ) { m_bstrBaseURL = bstrBaseURL; m_bfIsLoading = TRUE;
// Can't Exec without a command target:
if ( NULL != m_pSite->GetCommandTarget() ) { // Reload the page, revaluating relative links.
hr = HrExecCommand(&CGID_MSHTML, IDM_REFRESH, MSOCMDEXECOPT_DONTPROMPTUSER, NULL, NULL); } } } } return hr;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// Accelerator handler implementations
//
///////////////////////////////////////////////////////////////////////////////////////////
// Nudge accelerator handler
// Nudge the selection in the given direction by one pixle if SnaptoGrid is off, or by
// the SnaptoGridX/Y quantity if SnapToGrid is on.
//
HRESULTCProxyFrame::HrNudge(DENudgeDirection dir){ HRESULT hr = S_FALSE; OLECMDF cmdf = (OLECMDF) 0; VARIANT var; LPVARIANT pVarIn = &var; LONG lXDelta = m_fSnapToGrid ? m_ulSnapToGridX : 1; LONG lYDelta = m_fSnapToGrid ? m_ulSnapToGridY : 1;
if (FAILED(hr = HrQueryStatus(&GUID_TriEditCommandGroup, IDM_TRIED_NUDGE_ELEMENT, &cmdf))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
if (cmdf & OLECMDF_SUPPORTED && cmdf & OLECMDF_ENABLED) { LPPOINT lpPoint = new POINT;
if (NULL == lpPoint) { hr = E_OUTOFMEMORY; goto cleanup; } _ASSERTE(lpPoint);
lpPoint->x = 0; lpPoint->y = 0;
// Set increment to snap to absolute grid, not relative grid.
// Find the selections current position and set increment modulo that position.
// This assures the first nudge snaps to a grid corner.
if ( m_fSnapToGrid ) { POINT ptSelPos; if ( SUCCEEDED ( GetSelectionPos ( &ptSelPos ) ) ) { LONG lXNorm = ptSelPos.x % lXDelta; LONG lYNorm = ptSelPos.y % lYDelta; lXDelta = lXNorm ? lXNorm : lXDelta; lYDelta = lYNorm ? lYNorm : lYDelta; } }
switch(dir) { case deNudgeUp: { lpPoint->x = 0; lpPoint->y = -lYDelta; } break;
case deNudgeDown: { lpPoint->x = 0; lpPoint->y = lYDelta; } break;
case deNudgeLeft: { lpPoint->x = -lXDelta; lpPoint->y = 0; } break;
case deNudgeRight: { lpPoint->x = lXDelta; lpPoint->y = 0; } break;
default: // move right by default
{ lpPoint->x = lXDelta; lpPoint->y = 0; } break; }
VariantInit(pVarIn); V_VT(pVarIn) = VT_BYREF; V_BYREF(pVarIn) = lpPoint;
if (FAILED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_NUDGE_ELEMENT, MSOCMDEXECOPT_DONTPROMPTUSER, pVarIn, NULL))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
hr = S_OK; } else hr = S_FALSE;
cleanup: return hr;}
// Accelerator handler
// Toggle the absolute positioned property of the selected object
//
HRESULTCProxyFrame::HrToggleAbsolutePositioned(){ HRESULT hr = S_FALSE; OLECMDF cmdf = (OLECMDF) 0;
if (FAILED(hr = HrQueryStatus(&GUID_TriEditCommandGroup, IDM_TRIED_MAKE_ABSOLUTE, &cmdf))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
if (cmdf & OLECMDF_SUPPORTED && cmdf & OLECMDF_ENABLED) { if (FAILED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_MAKE_ABSOLUTE, MSOCMDEXECOPT_DONTPROMPTUSER, NULL, NULL))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
hr = S_OK; }
cleanup: return hr;}
// Accelerator handler
// Make a link out of the current selection (with UI.)
//
HRESULTCProxyFrame::HrHyperLink(){ HRESULT hr = S_FALSE; OLECMDF cmdf = (OLECMDF) 0;
if (FAILED(hr = HrQueryStatus(&GUID_TriEditCommandGroup, IDM_TRIED_HYPERLINK, &cmdf))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
if (cmdf & OLECMDF_SUPPORTED && cmdf & OLECMDF_ENABLED) { if (FAILED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_HYPERLINK, MSOCMDEXECOPT_PROMPTUSER, NULL, NULL))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
hr = S_OK; }
cleanup: return hr;}
// Accelerator handler
// Increase the indent of the current selection.
//
HRESULTCProxyFrame::HrIncreaseIndent(){ HRESULT hr = S_FALSE; OLECMDF cmdf = (OLECMDF) 0;
if (FAILED(hr = HrQueryStatus(&GUID_TriEditCommandGroup, IDM_TRIED_INDENT, &cmdf))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
if (cmdf & OLECMDF_SUPPORTED && cmdf & OLECMDF_ENABLED) { if (FAILED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_INDENT, MSOCMDEXECOPT_DONTPROMPTUSER, NULL, NULL))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
hr = S_OK; }
cleanup: return hr;}
// Accelerator handler
// Decrease the indent of the current selection.
//
HRESULTCProxyFrame::HrDecreaseIndent(){ HRESULT hr = S_FALSE; OLECMDF cmdf = (OLECMDF) 0;
if (FAILED(hr = HrQueryStatus(&GUID_TriEditCommandGroup, IDM_TRIED_OUTDENT, &cmdf))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
if (cmdf & OLECMDF_SUPPORTED && cmdf & OLECMDF_ENABLED) { if (FAILED(hr = HrExecCommand(&GUID_TriEditCommandGroup, IDM_TRIED_OUTDENT, MSOCMDEXECOPT_DONTPROMPTUSER, NULL, NULL))) { _ASSERTE(SUCCEEDED(hr)); goto cleanup; }
hr = S_OK; }
cleanup: return hr;}
// Check for and handle control-specific accelerators. If none is found, call TriEdit to handle it.
//
HRESULTCProxyFrame::HrHandleAccelerator(LPMSG lpmsg){ HRESULT hr = S_FALSE; BOOL fControl = (0x8000 & GetKeyState(VK_CONTROL)); BOOL fShift = (0x8000 & GetKeyState(VK_SHIFT)); BOOL fAlt = (0x8000 & GetKeyState(VK_MENU));
if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == VK_UP) { hr = HrNudge(deNudgeUp); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == VK_DOWN) { hr = HrNudge(deNudgeDown); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == VK_LEFT) { hr = HrNudge(deNudgeLeft); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == VK_RIGHT) { hr = HrNudge(deNudgeRight); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == 'K' && fControl) { hr = HrToggleAbsolutePositioned(); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == 'L' && fControl && !fAlt) { hr = HrHyperLink(); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == 'T' && !fShift && fControl) { hr = HrIncreaseIndent(); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == 'T' && fShift && fControl) { hr = HrDecreaseIndent(); } else if (lpmsg->message == WM_KEYDOWN && lpmsg->wParam == VK_TAB && fControl) { // Process control-tab keys as belonging to the container; this allows the user
// to tab out of the control in non-MDI apps. MDI uses control-tab to switch
// windows, thus these apps (like VID) do not pass them to us.
IOleControlSite* piControlSite = m_pCtl->GetControlSite (); _ASSERTE ( piControlSite ); if ( NULL != piControlSite ) { // Eat the control key, but preserve shift to perform reverse tabbing.
// KEYMOD_SHIFT = 0x00000001, but isn't defined in any header...
DWORD dwModifiers = fShift ? 1 : 0;
hr = piControlSite->TranslateAccelerator ( lpmsg, dwModifiers ); } }
return hr;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// BaseURL helper routines
//
///////////////////////////////////////////////////////////////////////////////////////////
// Override the default BaseURL if there is one or more <BASE HREF=...> tags
// in the document. If successful, set m_bfBaseURLFromBASETag to TRUE
// If multiple BASE tags exist, simply use the last one.
// Equivilent script: baseurl = document.all.tags("BASE")[<LAST>].href,
// where <LAST> is derived.
//
HRESULTCProxyFrame::SetBaseURLFromBaseHref (){ HRESULT hr = S_OK; CComBSTR bstrBase;
if ( !m_bfBaseURLFromBASETag ) { if ( SUCCEEDED ( hr ) ) { CComPtr<IHTMLDocument2> spHtmlDoc = NULL; hr = HrGetDoc( &spHtmlDoc ); if ( spHtmlDoc && SUCCEEDED ( hr ) ) { CComPtr<IHTMLElementCollection> spAll = NULL; hr = spHtmlDoc->get_all ( &spAll ); if ( spAll && SUCCEEDED ( hr ) ) { CComVariant varTag = L"BASE"; IDispatch* piDispTags = NULL;
hr = spAll->tags ( varTag, &piDispTags ); if ( piDispTags && SUCCEEDED ( hr ) ) { CComQIPtr<IHTMLElementCollection, &IID_IHTMLElementCollection> spBases (piDispTags); piDispTags->Release (); piDispTags = NULL; if ( spBases ) { long cBases = 0; hr = spBases->get_length ( &cBases ); if ( SUCCEEDED ( hr ) && ( 0 != cBases ) ) { CComVariant varName; varName.vt = VT_I2;
for ( varName.iVal = 0; varName.iVal < cBases; varName.iVal++ ) { IDispatch* piDispBase = NULL; CComVariant varValue;
hr = spBases->item ( varName, varName, &piDispBase ); if ( piDispBase && SUCCEEDED ( hr ) ) { CComQIPtr<IHTMLElement, &IID_IHTMLElement> spElem ( piDispBase ); piDispBase->Release (); piDispBase = NULL;
if ( spElem ) { varValue.Clear (); hr = spElem->getAttribute ( L"HREF", FALSE, &varValue ); if ( SUCCEEDED ( hr ) ) { hr = varValue.ChangeType ( VT_BSTR ); if ( SUCCEEDED ( hr ) ) { if ( 0 != SysStringLen ( varValue.bstrVal ) ) { bstrBase = varValue.bstrVal; } } } } } } if ( 0 != bstrBase.Length () ) { hr = SetBaseURL ( bstrBase ); // This clears m_bfBaseURLIsDefault
m_bfBaseURLFromBASETag = TRUE; } } } } } } } } return hr;}
// Set the m_bstrBaseURL value using m_bstrCurDocPath.
// With URLs, it may be impossible to be certain about the correct BaseURL,
// so make an intellegent guess. With files, it should be deterministic.
//
HRESULTCProxyFrame::SetBaseURLFromCurDocPath ( BOOL bfIsURL ){ m_bfBaseURLFromBASETag = FALSE; // We're reloading: whipe this out.
if ( bfIsURL ) { return SetBaseURLFromURL ( m_bstrCurDocPath ); } else { return SetBaseURLFromFileName ( m_bstrCurDocPath ); }}
// Given a URL_COMPONENTS with nScheme set to INTERNET_SCHEME_FILE,
// modify the path part to reflect the base path, reconstruct the URL,
// and set m_bstrBaseURL.
// Separators may be \ or /.
//
HRESULTCProxyFrame::SetBaseUrlFromFileUrlComponents ( URL_COMPONENTS & urlc ){ TCHAR* pszPath; BOOL bfBackSlash = TRUE; HRESULT hr = S_OK;
_ASSERTE ( INTERNET_SCHEME_FILE == urlc.nScheme ); _ASSERTE ( urlc.dwUrlPathLength ); if ( urlc.dwUrlPathLength <= 0) { return E_UNEXPECTED; } pszPath = new TCHAR [urlc.dwUrlPathLength + 3]; // Extra room for \0, dot, and /.
if ( NULL != pszPath ) { TCHAR c = 0; int iPos = 0;
// Scan backwards and modify in copy (never in BSTR, please) for beginning, '/' or '\'
memcpy ( pszPath, urlc.lpszUrlPath, ( urlc.dwUrlPathLength + 1 ) * sizeof(TCHAR) ); for ( iPos = urlc.dwUrlPathLength - 1; iPos >= 0; iPos-- ) { c = pszPath[iPos]; pszPath[iPos] = '\0'; // Delete first, ask questions later. '\' must go.
if ( '\\' == c ) { break; } if ( '/' == c ) { bfBackSlash = FALSE; break; } }
// Space was reserved for an additional two characters, if needed.
// If empty, add a dot.
if ( 0 == _tcslen ( pszPath ) ) { _tcscat ( pszPath, TEXT(".") ); } // Add a / or \.
if ( bfBackSlash ) { _tcscat ( pszPath, TEXT("\\") ); } else { _tcscat ( pszPath, TEXT("/") ); }
urlc.lpszUrlPath = pszPath; urlc.dwUrlPathLength = _tcslen ( pszPath );
DWORD dwLen = 0;#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnInternetCreateUrl ); (*m_pfnInternetCreateUrl)( &urlc, 0, NULL, &dwLen ); // Get the size required.
#else
InternetCreateUrl ( &urlc, 0, NULL, &dwLen ); // Get the size required.
#endif // LATE_BIND_URLMON_WININET
_ASSERTE ( 0 != dwLen ); TCHAR* pszURL = new TCHAR [ dwLen + 1 ]; _ASSERTE ( pszURL ); if ( NULL != pszURL ) { // Incredibly, on Win98, the URL is terminated with a single byte \0.
// Intializing this buffer to zero assures full termination of the string.
dwLen += 1; memset ( pszURL, 0, sizeof(TCHAR) * dwLen );#ifdef LATE_BIND_URLMON_WININET
if ( (*m_pfnInternetCreateUrl)( &urlc, 0, pszURL, &dwLen ) )#else
if ( InternetCreateUrl ( &urlc, 0, pszURL, &dwLen ) )#endif // LATE_BIND_URLMON_WININET
{ m_bstrBaseURL = pszURL; } else { hr = HRESULT_FROM_WIN32 ( GetLastError () ); } delete [] pszURL; }
delete [] pszPath; } else { return E_FAIL; }
return hr;}
// The most complicated scenario for "guessing" at the base URL.
// URLs like http://www.x.com/stuff could be either a file or a directory;
// a default page might actually be loaded. We guess based on whether or
// not the last item in the path contains a period. If so, we eliminate it.
// We make sure the path ends with a '/'.
//
HRESULTCProxyFrame::SetBaseUrlFromUrlComponents ( URL_COMPONENTS & urlc ){ _ASSERTE ( INTERNET_SCHEME_FILE != urlc.nScheme );
BOOL bfPeriodIncluded = FALSE; HRESULT hr = S_OK;
if ( 0 == urlc.dwSchemeLength ) { m_bstrBaseURL = L""; return S_FALSE; }
// Scan backwards over path for beginning, '/'
TCHAR c = 0; int iPos = 0;
for ( iPos = urlc.dwUrlPathLength - 1; iPos >= 0; iPos-- ) { c = urlc.lpszUrlPath[iPos]; if ( '/' == c ) { break; } if ( '.' == c ) { bfPeriodIncluded = TRUE; } }
if ( bfPeriodIncluded ) { if ( 0 > iPos ) iPos = 0; urlc.lpszUrlPath[iPos] = '\0'; // Truncate at the '/', or beginning
urlc.dwUrlPathLength = _tcslen ( urlc.lpszUrlPath ); }
// Recreate the URL:
DWORD dwLen = 0;#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnInternetCreateUrl ); (*m_pfnInternetCreateUrl)( &urlc, 0, NULL, &dwLen ); // Get the size required.
#else
InternetCreateUrl ( &urlc, 0, NULL, &dwLen ); // Get the size required.
#endif // LATE_BIND_URLMON_WININET
_ASSERTE ( 0 != dwLen ); TCHAR* pszURL = new TCHAR [ dwLen + 1 ]; _ASSERTE ( pszURL ); if ( NULL != pszURL ) { dwLen += 1; memset ( pszURL, 0, sizeof(TCHAR) * dwLen );#ifdef LATE_BIND_URLMON_WININET
if ( (*m_pfnInternetCreateUrl)( &urlc, 0, pszURL, &dwLen ) )#else
if ( InternetCreateUrl ( &urlc, 0, pszURL, &dwLen ) )#endif
{ m_bstrBaseURL = pszURL;
// Append a '/' if needed.
WCHAR wc = m_bstrBaseURL.m_str[m_bstrBaseURL.Length () - 1]; if ( ( WCHAR('/') != wc ) && ( NULL != urlc.lpszHostName ) ) // hostname: special case for user pluggable protocols
{ m_bstrBaseURL += L"/"; } } else { hr = HRESULT_FROM_WIN32 ( GetLastError () ); } delete [] pszURL; } return hr;}
// Crack the URL, determine if it's a file scheme or other, and call the appropriate handler.
//
HRESULTCProxyFrame::SetBaseURLFromURL ( const CComBSTR& bstrURL ){ USES_CONVERSION;
HRESULT hr = S_OK; URL_COMPONENTS urlc; TCHAR *ptszScheme = NULL; TCHAR *ptszHostName = NULL; TCHAR *ptszUrlPath = NULL; BOOL fSuccess = FALSE; TCHAR* tszURL = NULL;
_ASSERTE ( 0 != bstrURL.Length () );
tszURL = OLE2T ( bstrURL ); _ASSERTE ( tszURL ); if ( NULL == tszURL ) { return E_OUTOFMEMORY; }
memset ( &urlc, 0, sizeof ( urlc ) ); urlc.dwStructSize = sizeof ( urlc ); urlc.dwSchemeLength = 1; urlc.dwHostNameLength = 1; urlc.dwUrlPathLength = 1;
#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnInternetCrackUrl ); fSuccess = (*m_pfnInternetCrackUrl)( tszURL, 0, 0, &urlc );#else
fSuccess = InternetCrackUrl ( tszURL, 0, 0, &urlc );#endif // LATE_BIND_URLMON_WININET
if ( !fSuccess ) { return E_FAIL; }
if ( 0 != urlc.dwSchemeLength ) { urlc.dwSchemeLength++; ptszScheme = new TCHAR[urlc.dwSchemeLength]; urlc.lpszScheme = ptszScheme; if ( NULL == ptszScheme ) goto ONERROR; } if ( 0 != urlc.dwHostNameLength ) { urlc.dwHostNameLength++; ptszHostName = new TCHAR[urlc.dwHostNameLength]; urlc.lpszHostName = ptszHostName; if ( NULL == ptszHostName ) goto ONERROR; } if ( 0 != urlc.dwUrlPathLength ) { urlc.dwUrlPathLength++; ptszUrlPath = new TCHAR[urlc.dwUrlPathLength]; urlc.lpszUrlPath = ptszUrlPath; if ( NULL == ptszUrlPath ) goto ONERROR; }
#ifdef LATE_BIND_URLMON_WININET
fSuccess = (*m_pfnInternetCrackUrl)( tszURL, 0, 0, &urlc );#else
fSuccess = InternetCrackUrl ( tszURL, 0, 0, &urlc );#endif
if ( fSuccess ) { if ( INTERNET_SCHEME_FILE == urlc.nScheme ) { hr = SetBaseUrlFromFileUrlComponents ( urlc ); } else { hr = SetBaseUrlFromUrlComponents ( urlc ); } }
ONERROR: if ( ptszScheme ) delete [] ptszScheme; if ( ptszHostName ) delete [] ptszHostName; if ( ptszUrlPath ) delete [] ptszUrlPath;
return hr;}
// Given a UNC file name, set the m_bstrBaseURL member variable.
// if bstrFName is empty, set m_bstrBaseURL to empty.
// Else, scan backward to the first "\" or the beginning of the string.
// Truncate the string at this point. If the resultant string is empty,
// add ".". Then, add "\".
//
HRESULTCProxyFrame::SetBaseURLFromFileName ( const CComBSTR& bstrFName ){ if ( 0 == bstrFName.Length () ) { m_bstrBaseURL = L""; } else { WCHAR* pwzstr = new WCHAR[bstrFName.Length () + 1]; _ASSERTE ( pwzstr ); if ( NULL != pwzstr ) { WCHAR wc = 0; int iPos = 0;
// Scan backwards and modify in copy (never in BSTR, please) for beginning or '\'
memcpy ( pwzstr, bstrFName.m_str, sizeof(WCHAR) * (bstrFName.Length () + 1) ); for ( iPos = wcslen ( pwzstr ) - 1; iPos >= 0; iPos-- ) { wc = pwzstr[iPos]; pwzstr[iPos] = WCHAR('\0'); // Delete first, ask questions later. '\' must go.
if ( WCHAR('\\') == wc ) { break; } } m_bstrBaseURL = pwzstr; delete [] pwzstr;
// If empty, add a '.'
if ( 0 == m_bstrBaseURL.Length () ) { m_bstrBaseURL += L"."; } m_bstrBaseURL += L"\\"; } else { return E_FAIL; } } return S_OK;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// Security oriented routines
//
///////////////////////////////////////////////////////////////////////////////////////////
// This is a critical security issue:
// The pluggable protocol's ParseURL is called with PARSE_SECURITY_URL in the SFS control.
// If the BaseURL is empty, and if we're hosted in Trident, we should return the
// URL of the hosting page.
// If there is no Trident host, say we're hosted in VB, return the bootdrive + : + /.
// Bootdrive is not always C.
//
HRESULTCProxyFrame::GetSecurityURL (CComBSTR& bstrSecurityURL ){ HRESULT hr = S_OK; IOleClientSite *piClientSiteUnreffed = NULL;
bstrSecurityURL = L""; piClientSiteUnreffed = m_pCtl->m_spClientSite; if ( NULL != piClientSiteUnreffed ) { CComPtr<IOleContainer> spContainer = NULL; hr = piClientSiteUnreffed->GetContainer ( &spContainer ); if ( SUCCEEDED ( hr ) && spContainer ) { CComQIPtr<IHTMLDocument2, &IID_IHTMLDocument2> spHostDoc ( spContainer ); if ( spHostDoc ) { CComPtr<IHTMLLocation> spHostLoc = NULL;
spHostDoc->get_location ( &spHostLoc ); if ( spHostLoc ) { BSTR bsOut; hr = spHostLoc->get_href ( &bsOut ); if ( SUCCEEDED ( hr ) ) { bstrSecurityURL.Empty (); bstrSecurityURL.Attach ( bsOut ); } } } else { // If we are not hosted in Trident, use local machine access:
TCHAR tszDrive[4]; GetModuleFileName ( _Module.m_hInst, tszDrive, 3 ); // Get X:\.
_ASSERTE ( TCHAR(':') == tszDrive[1] ); _ASSERTE ( TCHAR('\\') == tszDrive[2] ); bstrSecurityURL = tszDrive; hr = S_OK; } } } return hr;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// Pluggable protocol oriented routines
//
///////////////////////////////////////////////////////////////////////////////////////////
// Register our pluggable protocol handler so dhtmledN[N...] is loaded by our code.
//
HRESULTCProxyFrame::RegisterPluggableProtocol(){ HRESULT hr;
// Get InternetSession
CComPtr<IInternetSession> srpSession;#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnCoInternetGetSession ); hr = (*m_pfnCoInternetGetSession)(0, &srpSession, 0);#else
hr = CoInternetGetSession (0, &srpSession, 0);#endif // LATE_BIND_URLMON_WININET
if ( FAILED ( hr ) ) { return hr; }
if(m_pProtInfo == NULL) { hr = CComObject<CDHTMLEdProtocolInfo>::CreateInstance(&m_pProtInfo); if ( FAILED ( hr ) ) { return hr; }
// CreateInstance - doesnt AddRef
m_pProtInfo->GetUnknown()->AddRef(); }
hr = srpSession->RegisterNameSpace( static_cast<IClassFactory*>(m_pProtInfo), CLSID_DHTMLEdProtocol, m_wszProtocol, 0, NULL, 0);
if ( FAILED ( hr ) ) { return hr; }
CComQIPtr <IProtocolInfoConnector, &IID_IProtocolInfoConnector> piPic ( m_pProtInfo ); _ASSERTE ( piPic ); piPic->SetProxyFrame ( (SIZE_T*)this );
ATLTRACE( _T("CProxyFrame::Registered ProtocolInfo\n"));
return NOERROR;}
// Unregister the pluggable protocol handler installed in RegisterPluggableProtocol
//
HRESULTCProxyFrame::UnRegisterPluggableProtocol(){ if(m_pProtInfo == NULL) return E_UNEXPECTED;
// Get InternetSession
HRESULT hr; CComPtr<IInternetSession> srpSession;
#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnCoInternetGetSession ); hr = (*m_pfnCoInternetGetSession)(0, &srpSession, 0);#else
hr = CoInternetGetSession (0, &srpSession, 0);#endif // LATE_BIND_URLMON_WININET
if(SUCCEEDED(hr)) { // UnRegister Protocol
srpSession->UnregisterNameSpace( static_cast<IClassFactory*>(m_pProtInfo), m_wszProtocol);
}
m_pProtInfo->GetUnknown()->Release(); m_pProtInfo = NULL;
ATLTRACE(_T("CProxyFrame::UnRegistered ProtocolInfo\n"));
return NOERROR;}
// Workhorse routine that actually performs the loading of the control, including filtering.
// ParseAndBind calls this to retrieve the data to be displayed in the control.
//
HRESULTCProxyFrame::GetFilteredStream ( IStream** ppStream ){ USES_CONVERSION; HRESULT hr = S_OK; LPTSTR pFileName = NULL; CComPtr<IStream> piStream; BOOL bfLoadingFromBSTR = ( 0 != m_bstrLoadText.Length () );
*ppStream = NULL; m_bfReloadAttempted = TRUE;
if ( !bfLoadingFromBSTR ) { _ASSERTE(m_bstrCurDocPath);
pFileName = OLE2T(m_bstrCurDocPath);
_ASSERTE(pFileName);
if (NULL == pFileName) return E_OUTOFMEMORY; }
if ( bfLoadingFromBSTR ) { hr = m_pSite->HrBstrToStream(m_bstrLoadText, &piStream); } else if ( m_bfIsURL ) { hr = m_pSite->HrURLToStream(pFileName, &piStream); } else { hr = m_pSite->HrFileToStream(pFileName, &piStream); }
if (FAILED( hr )) { m_bstrCurDocPath.Empty (); m_bstrBaseURL.Empty ();
// Get TriEdit into a reasonable state by loading an empty document
// If we reinstanced successfully, this should never fail
// Also, this will make ignoring the above assert benign
if (FAILED(m_pSite->HrBstrToStream(m_bstrInitialDoc, ppStream))) { _ASSERTE(SUCCEEDED(hr)); }
} else { if ( m_vbBrowseMode ) { piStream.p->AddRef (); *ppStream = piStream; } else { hr = m_pSite->HrFilter(TRUE, piStream, ppStream, m_dwFilterFlags); }
if (FAILED(hr)) { m_pSite->HrBstrToStream(m_bstrInitialDoc, ppStream); } else { m_dwFilterOutFlags = m_dwFilterFlags; } }
// Store the result to return from the (indirectly) called routine,
// but don't return an error to ParseAndBind!
if ( FAILED(hr) && ( ! bfLoadingFromBSTR ) ) { m_hrDeferredLoadError = hr; // Stash this away, we'll pic it up in LoadDocument
hr = S_OK; }
return hr;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// Document event handling routines
//
///////////////////////////////////////////////////////////////////////////////////////////
HRESULTCProxyFrame::OnTriEditEvent ( const GUID& iidEventInterface, DISPID dispid ){ HRESULT hr = S_OK;
if ( DIID_HTMLDocumentEvents == iidEventInterface ) { switch ( dispid ) { case DISPID_HTMLDOCUMENTEVENTS_ONKEYPRESS: case DISPID_HTMLDOCUMENTEVENTS_ONMOUSEDOWN: if ( DISPID_HTMLDOCUMENTEVENTS_ONMOUSEDOWN == dispid ) { m_pCtl->Fire_onmousedown(); } else if ( DISPID_HTMLDOCUMENTEVENTS_ONKEYPRESS == dispid ) { m_pCtl->Fire_onkeypress(); }
// Make the control UIActive if it was clicked in. Since the DocObject swallows the clicks,
// the control isn't activated automatically.
// Not needed in browse mode.
if ( !m_pCtl->m_bUIActive && ! m_vbBrowseMode ) { m_pCtl->DoVerbUIActivate ( NULL, NULL ); if ( m_hWndObj != NULL ) { ::SetFocus( m_hWndObj ); } } break;
case DISPID_HTMLDOCUMENTEVENTS_ONMOUSEMOVE: m_pCtl->Fire_onmousemove(); break;
case DISPID_HTMLDOCUMENTEVENTS_ONMOUSEUP: m_pCtl->Fire_onmouseup(); // onclick is not delivered in edit mode. First one lost in broswe mode.
m_pCtl->Fire_onclick(); break;
case DISPID_HTMLDOCUMENTEVENTS_ONMOUSEOUT: m_pCtl->Fire_onmouseout(); break;
case DISPID_HTMLDOCUMENTEVENTS_ONMOUSEOVER: m_pCtl->Fire_onmouseover(); break;
case DISPID_HTMLDOCUMENTEVENTS_ONCLICK: // We do not fire the onclick event in response.
// It is only delivered in browse mode, and in addition,
// the first onclick is lost. We fire on onmouseup.
//m_pCtl->Fire_onclick();
// The addition of the DesignMode property, in addition to <BASE TARGET="_top">
// makes links exploitable for cross-zone access in the SFS control.
// We must disable clicks (user and script) in the SFS control to prevent this.
if ( m_pCtl->IsSafeForScripting ()) { CComPtr<IHTMLDocument2> spHtmlDoc; hr = HrGetDoc ( &spHtmlDoc ); if ( SUCCEEDED ( hr ) && spHtmlDoc ) { CComPtr<IHTMLWindow2> spWindow;
hr = spHtmlDoc->get_parentWindow ( &spWindow ); if ( SUCCEEDED ( hr ) && spWindow ) { CComPtr<IHTMLEventObj> spEvt; hr = spWindow->get_event ( &spEvt ); if ( SUCCEEDED ( hr ) && spEvt ) { CComVariant varFalse(VARIANT_FALSE);
spEvt->put_cancelBubble ( VARIANT_TRUE ); spEvt->put_returnValue ( varFalse ); } } } }
break;
case DISPID_HTMLDOCUMENTEVENTS_ONDBLCLICK: m_pCtl->Fire_ondblclick(); break;
case DISPID_HTMLDOCUMENTEVENTS_ONKEYDOWN: m_pCtl->Fire_onkeydown(); break;
case DISPID_HTMLDOCUMENTEVENTS_ONKEYUP: m_pCtl->Fire_onkeyup(); break;
case DISPID_HTMLDOCUMENTEVENTS_ONREADYSTATECHANGE: m_pCtl->Fire_onreadystatechange(); break;
default: _ASSERTE ( TRUE ); break; } } else if ( DIID_HTMLWindowEvents == iidEventInterface ) { // I expected to get these, but I'm not...
switch ( dispid ) { case DISPID_HTMLWINDOWEVENTS_ONLOAD: case DISPID_HTMLWINDOWEVENTS_ONUNLOAD: case DISPID_HTMLWINDOWEVENTS_ONHELP: case DISPID_HTMLWINDOWEVENTS_ONFOCUS: case DISPID_HTMLWINDOWEVENTS_ONBLUR: case DISPID_HTMLWINDOWEVENTS_ONERROR: case DISPID_HTMLWINDOWEVENTS_ONRESIZE: case DISPID_HTMLWINDOWEVENTS_ONSCROLL: case DISPID_HTMLWINDOWEVENTS_ONBEFOREUNLOAD: hr = S_OK; break; default: _ASSERTE ( TRUE ); break; } } return hr;}
///////////////////////////////////////////////////////////////////////////////////////////
//
// Dynamic loading routines, used in 4.0 versions
//
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef LATE_BIND_URLMON_WININET
// Load Urlmon and Wininet and get the proc addresses of every routine we use.
// We must be able to register the control, even if these libraries are not installed.
// NOTE:
// This routine loads ANSI versions. Needs addaptation for UNICODE.
//
BOOL CProxyFrame::DynLoadLibraries (){ m_hUlrMon = LoadLibrary ( TEXT("URLMON.DLL") ); m_hWinINet = LoadLibrary ( TEXT("WININET.DLL") ); if ( ( NULL == m_hUlrMon ) || ( NULL == m_hWinINet ) ) { DynUnloadLibraries (); return FALSE; }
m_pfnCoInternetCombineUrl = (PFNCoInternetCombineUrl)GetProcAddress ( m_hUlrMon, "CoInternetCombineUrl" ); _ASSERTE ( m_pfnCoInternetCombineUrl ); m_pfnCoInternetParseUrl = (PFNCoInternetParseUrl)GetProcAddress ( m_hUlrMon, "CoInternetParseUrl" ); _ASSERTE ( m_pfnCoInternetParseUrl ); m_pfnCreateURLMoniker = (PFNCreateURLMoniker)GetProcAddress ( m_hUlrMon, "CreateURLMoniker" ); _ASSERTE ( m_pfnCreateURLMoniker ); m_pfnCoInternetGetSession = (PFNCoInternetGetSession)GetProcAddress ( m_hUlrMon, "CoInternetGetSession" ); _ASSERTE ( m_pfnCoInternetGetSession ); m_pfnURLOpenBlockingStream = (PFNURLOpenBlockingStream)GetProcAddress ( m_hUlrMon, "URLOpenBlockingStreamA" ); _ASSERTE ( m_pfnURLOpenBlockingStream );
m_pfnDeleteUrlCacheEntry = (PFNDeleteUrlCacheEntry)GetProcAddress ( m_hWinINet, "DeleteUrlCacheEntry" ); _ASSERTE ( m_pfnDeleteUrlCacheEntry ); m_pfnInternetCreateUrl = (PFNInternetCreateUrl)GetProcAddress ( m_hWinINet, "InternetCreateUrlA" ); _ASSERTE ( m_pfnInternetCreateUrl ); m_pfnInternetCrackUrl = (PFNInternetCrackURL)GetProcAddress ( m_hWinINet, "InternetCrackUrlA" ); _ASSERTE ( m_pfnInternetCrackUrl );
return ( m_pfnCoInternetCombineUrl && m_pfnCoInternetParseUrl && m_pfnCreateURLMoniker && m_pfnCoInternetGetSession && m_pfnURLOpenBlockingStream && m_pfnDeleteUrlCacheEntry && m_pfnInternetCreateUrl && m_pfnInternetCrackUrl );}
// Release the libraries loaded by DynLoadLibraries
//
void CProxyFrame::DynUnloadLibraries (){ if ( NULL != m_hUlrMon ) { FreeLibrary ( m_hUlrMon ); m_hUlrMon = NULL; } if ( NULL != m_hWinINet ) { FreeLibrary ( m_hWinINet ); m_hWinINet = NULL; }
m_pfnCoInternetCombineUrl = NULL; m_pfnCoInternetParseUrl = NULL; m_pfnCreateURLMoniker = NULL; m_pfnCoInternetGetSession = NULL; m_pfnURLOpenBlockingStream = NULL;
m_pfnDeleteUrlCacheEntry = NULL; m_pfnInternetCreateUrl = NULL; m_pfnInternetCrackUrl = NULL;}#endif // LATE_BIND_URLMON_WININET
///////////////////////////////////////////////////////////////////////////////////////////
//
// Utility routines
//
///////////////////////////////////////////////////////////////////////////////////////////
// Return the IHTMLDocument2 pointer from the hosted doc.
//
HRESULTCProxyFrame::HrGetDoc(IHTMLDocument2 **ppDoc){ HRESULT hr = E_FAIL; IUnknown* lpUnk = m_pSite->GetObjectUnknown();
if (FALSE == m_fActivated) return DE_E_UNEXPECTED;
_ASSERTE(ppDoc);
if (NULL == ppDoc) return DE_E_INVALIDARG;
_ASSERTE(lpUnk);
if ( m_bfIsLoading ) return DE_E_UNEXPECTED; // This is invalid while document is still loading.
if (lpUnk != NULL) { // Request the "document" object from the MSHTML
*ppDoc = NULL; hr = lpUnk->QueryInterface(IID_IHTMLDocument2, (void **)ppDoc); }
_ASSERTE(SUCCEEDED(hr)); // this should always succeed
return hr;}
// Helper routine to set any Boolean Trident property
//
HRESULTCProxyFrame::HrTridentSetPropBool(ULONG cmd, BOOL bVal){ HRESULT hr = S_OK; VARIANT varIn;
VariantInit(&varIn); V_VT(&varIn) = VT_BOOL;
#pragma warning(disable: 4310) // cast truncates constant value
bVal ? V_BOOL(&varIn) = VARIANT_TRUE : V_BOOL(&varIn) = VARIANT_FALSE;#pragma warning(default: 4310) // cast truncates constant value
hr = HrExecCommand(&CGID_MSHTML, cmd, MSOCMDEXECOPT_DONTPROMPTUSER, &varIn, NULL);
// this should always succeed since all props
// should be set in correct phases of Trident creation
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Helper routine to get any Boolean Trident property
//
HRESULTCProxyFrame::HrTridentGetPropBool(ULONG cmd, BOOL& bVal){ HRESULT hr = S_OK; OLECMDF cmdf = (OLECMDF) 0;
if (SUCCEEDED(HrQueryStatus(&CGID_MSHTML, cmd, &cmdf))) { bVal = (cmdf & OLECMDF_ENABLED) == OLECMDF_ENABLED ? TRUE : FALSE; }
// this should always succeed since all props
// should be set in correct phases of Trident creation
_ASSERTE(SUCCEEDED(hr)); return hr;}
// Store the BSTR so LoadFilteredStream can access it, and load a URL with our protocol
// to kick off the load/resolve/display through the pluggable protocol handler.
//
// Clear the BaseURL, and mark the control "Loading..."
//
HRESULTCProxyFrame::LoadBSTRDeferred ( BSTR bVal ){ HRESULT hr = E_FAIL;
_ASSERTE ( m_pUnkTriEdit );
m_bstrLoadText = bVal;
CComPtr<IMoniker> srpMoniker; CComPtr<IBindCtx> srpBindCtx; CComQIPtr<IPersistMoniker, &IID_IPersistMoniker> srpPM (m_pUnkTriEdit); _ASSERTE ( srpPM );
if ( srpPM ) {#ifdef LATE_BIND_URLMON_WININET
_ASSERTE ( m_pfnCreateURLMoniker ); hr = (*m_pfnCreateURLMoniker)( NULL, m_wszProtocolPrefix, &srpMoniker );#else
hr = CreateURLMoniker ( NULL, m_wszProtocolPrefix, &srpMoniker );#endif // LATE_BIND_URLMON_WININET
_ASSERTE ( SUCCEEDED( hr ) ); if ( SUCCEEDED ( hr ) ) { hr = ::CreateBindCtx(NULL, &srpBindCtx); _ASSERTE ( SUCCEEDED( hr ) ); if ( SUCCEEDED ( hr ) ) { m_bfIsLoading = TRUE; m_bfBaseURLFromBASETag = FALSE;
hr = srpPM->Load(FALSE, srpMoniker, srpBindCtx, STGM_READ);
_ASSERTE ( SUCCEEDED( hr ) ); } } } return hr;}
// Set the document stream's dirty flag
//
HRESULTCProxyFrame::SetDirtyFlag ( BOOL bfMakeDirty ){ CComVariant varDirty;
varDirty = bfMakeDirty ? true : false;
return HrExecCommand(&CGID_MSHTML, IDM_SETDIRTY, MSOCMDEXECOPT_DONTPROMPTUSER, &varDirty, NULL);}
// properties that can be set only after TriEdit is in running state
HRESULTCProxyFrame::HrSetRuntimeProperties(){ HRESULT hr = S_OK;
if (FAILED(hr = HrSetPropActivateControls(m_fActivateControls))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = HrSetPropActivateApplets(m_fActivateApplets))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = HrSetPropActivateDTCs(m_fActivateDTCs))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
// toggle properties
if (FAILED(hr = HrSetPropShowAllTags(m_fShowAllTags))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = HrSetPropShowBorders(m_fShowBorders))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
error:
return hr;}
HRESULTCProxyFrame::HrGetCurrentDocumentPath(BSTR* bVal){ HRESULT hr = S_OK;
_ASSERTE(bVal);
if (NULL == bVal) return E_INVALIDARG;
*bVal = m_bstrCurDocPath.Copy (); return hr;}
// properties that can only be set after UIActivation
HRESULTCProxyFrame::HrSetDocLoadedProperties(){ HRESULT hr = S_OK; BOOL bGoodUndoBehavior = TRUE;
bGoodUndoBehavior = TRUE; if (FAILED(HrTridentGetPropBool(IDM_GOOD_UNDO_BEHAVIOR, bGoodUndoBehavior))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = HrSetAbsoluteDropMode(m_fAbsoluteDropMode))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = HrSetSnapToGridX(m_ulSnapToGridX))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = HrSetSnapToGridY(m_ulSnapToGridY))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
if (FAILED(hr = HrSetSnapToGrid(m_fSnapToGrid))) { _ASSERTE(SUCCEEDED(hr)); goto error; }
error:
return hr;}
// HrExecInsertTable helper. Extract the safearrys
//
HRESULTCProxyFrame::HrGetTableSafeArray(IDEInsertTableParam* pTable, LPVARIANT pVarIn){ HRESULT hr = S_OK; UINT i = 0; SAFEARRAY FAR* psa = NULL; SAFEARRAYBOUND rgsabound[1] = {0}; LONG ix[1] = {0}; VARIANT varElem; LONG nNumRows = 0; LONG nNumCols = 0; BSTR bstrTableAttrs = NULL; BSTR bstrCellAttrs = NULL; BSTR bstrCaption = NULL;
_ASSERTE(pTable);
if (FAILED(hr = pTable->get_NumRows(&nNumRows))) { _ASSERTE(SUCCEEDED(hr)); return hr; }
if (FAILED(hr = pTable->get_NumCols(&nNumCols))) { _ASSERTE(SUCCEEDED(hr)); return hr; }
if (FAILED(hr = pTable->get_TableAttrs(&bstrTableAttrs))) { _ASSERTE(SUCCEEDED(hr)); return hr; } _ASSERTE(bstrTableAttrs);
if (FAILED(hr = pTable->get_CellAttrs(&bstrCellAttrs))) { _ASSERTE(SUCCEEDED(hr)); return hr; } _ASSERTE(bstrCellAttrs);
if (FAILED(hr = pTable->get_Caption(&bstrCaption))) { _ASSERTE(SUCCEEDED(hr)); return hr; } _ASSERTE(bstrCaption);
rgsabound[0].lLbound = 0; rgsabound[0].cElements = 5;
psa = SafeArrayCreate(VT_VARIANT, 1, rgsabound); _ASSERTE(psa);
if(NULL == psa) return E_OUTOFMEMORY;
VariantInit(pVarIn); V_VT(pVarIn) = VT_ARRAY; V_ARRAY(pVarIn) = psa;
i=0;
// elmement 1: number of rows
ix[0] = i; VariantInit(&varElem); V_VT(&varElem) = VT_I4; V_I4(&varElem) = nNumRows; hr = SafeArrayPutElement(psa, ix, &varElem); VariantClear(&varElem); ++i;
// elmement 2: number of columns
ix[0] = i; VariantInit(&varElem); V_VT(&varElem) = VT_I4; V_I4(&varElem) = nNumCols; hr = SafeArrayPutElement(psa, ix, &varElem); VariantClear(&varElem); ++i;
// elmement 3: table tag attributes
ix[0] = i; VariantInit(&varElem); V_VT(&varElem) = VT_BSTR; V_BSTR(&varElem) = bstrTableAttrs; hr = SafeArrayPutElement(psa, ix, &varElem); VariantClear(&varElem); ++i;
// elmement 4: cell attributes
ix[0] = i; VariantInit(&varElem); V_VT(&varElem) = VT_BSTR; V_BSTR(&varElem) = bstrCellAttrs; hr = SafeArrayPutElement(psa, ix, &varElem); VariantClear(&varElem); ++i;
// elmement 5: table caption
// VK bug 15857: don't include caption if it's empty.
if ( 0 != SysStringLen ( bstrCaption ) ) { ix[0] = i; VariantInit(&varElem); V_VT(&varElem) = VT_BSTR; V_BSTR(&varElem) = bstrCaption; hr = SafeArrayPutElement(psa, ix, &varElem); VariantClear(&varElem); ++i; }
return hr;}
// Determine which object is selected, and return its position
//
HRESULTCProxyFrame::GetSelectionPos ( LPPOINT lpWhere ){ HRESULT hr = E_FAIL; CComPtr<IHTMLDocument2> spHtmlDoc = NULL; CComPtr<IHTMLSelectionObject> spSelectionObj = NULL; CComPtr<IDispatch> spRangeDisp = NULL; CComPtr<IHTMLElement> spElement = NULL; lpWhere->x = 0; lpWhere->y = 0;
hr = HrGetDoc ( &spHtmlDoc ); if ( SUCCEEDED ( hr ) ) { hr = spHtmlDoc->get_selection ( &spSelectionObj ); if ( SUCCEEDED ( hr ) ) { hr = spSelectionObj->createRange ( &spRangeDisp ); if (SUCCEEDED ( hr ) ) { CComQIPtr<IHTMLTxtRange, &IID_IHTMLTxtRange> spTextRange ( spRangeDisp ); if ( spTextRange ) { hr = spTextRange->parentElement(&spElement); } else { CComQIPtr<IHTMLControlRange, &IID_IHTMLControlRange> spControlRange ( spRangeDisp ); if ( spControlRange ) { hr = spControlRange->commonParentElement(&spElement); } } if ( spElement ) { CComPtr<IHTMLStyle> spStyle = NULL; hr = spElement->get_style ( &spStyle ); if ( spStyle ) { spStyle->get_pixelTop ( &( lpWhere->y ) ); spStyle->get_pixelLeft ( &( lpWhere->x ) ); } } } } } return hr;}
// If the current document is loaded from a URL, return the empty string.
// If it's loaded from a file, strip the path part off and return just the file name.
// Return S_FALSE for a URL or no file name. S_OK if a file name is supplied.
//
HRESULTCProxyFrame::GetCurDocNameWOPath ( CComBSTR& bstrDocName ){ bstrDocName = L"";
if ( m_bfIsURL ) { return S_FALSE; } if ( 0 == m_bstrCurDocPath.Length () ) { return S_FALSE; }
bstrDocName = m_bstrCurDocPath;
// Truncate at first backslash:
_wcsrev ( bstrDocName ); wcstok ( bstrDocName, OLESTR( "\\" ) ); _wcsrev ( bstrDocName );
return S_OK;}
// Used by ShowContextMenu to properly offset the position of the click
//
HRESULTCProxyFrame::GetScrollPos ( LPPOINT lpPos ){ HRESULT hr = E_FAIL; CComPtr<IHTMLDocument2> spHtmlDoc = NULL; CComPtr<IHTMLElement> spBodyElem = NULL;
_ASSERTE ( lpPos ); hr = HrGetDoc ( &spHtmlDoc ); // It's possible that the user clicked while the doc was still loading.
// If so, just return 0, 0.
if ( DE_E_UNEXPECTED == hr ) { lpPos->x = lpPos->y = 0; return S_FALSE; }
_ASSERTE ( spHtmlDoc ); if ( SUCCEEDED ( hr ) ) { hr = spHtmlDoc->get_body ( &spBodyElem ); _ASSERTE ( spBodyElem ); if ( SUCCEEDED ( hr ) ) { CComQIPtr<IHTMLTextContainer, &IID_IHTMLTextContainer> spHtmlTextCont ( spBodyElem ); if ( spHtmlTextCont ) { LONG lxPos = 0; LONG lyPos = 0;
hr = spHtmlTextCont->get_scrollLeft ( &lxPos ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( SUCCEEDED ( hr ) ) { hr = spHtmlTextCont->get_scrollTop ( &lyPos ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( SUCCEEDED ( hr ) ) { lpPos->x = lxPos; lpPos->y = lyPos; } } } else { hr = E_NOINTERFACE; _ASSERTE ( SUCCEEDED ( hr ) ); } } } return hr;}
HRESULTCProxyFrame::GetContainer ( LPOLECONTAINER* ppContainer ){ _ASSERTE ( m_pCtl ); _ASSERTE ( m_pCtl->m_spClientSite ); if ( m_pCtl->m_spClientSite ) { return m_pCtl->m_spClientSite->GetContainer ( ppContainer ); } return E_NOTIMPL;}
// For the Safe for Scripting control, make sure the URL specified comes from
// the same host as the SecurityURL, the URL of the hosting container..
// Note that this makes the SFS control virtually useless in VB, which returns
// the Boot Drive Root Folder as the Security URL.
//
HRESULT CProxyFrame::CheckCrossZoneSecurity ( BSTR urlToLoad ){ HRESULT hr = S_OK;
CComPtr<IInternetSecurityManager> srpSec; CComBSTR bstrSecURL;
hr = GetSecurityURL ( bstrSecURL ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( SUCCEEDED ( hr ) ) {#ifdef LATE_BIND_URLMON_WININET
hr = (m_pfnCoInternetCreateSecurityManager)( NULL, &srpSec, 0 );#else
hr = CoInternetCreateSecurityManager( NULL, &srpSec, 0 );#endif // LATE_BIND_URLMON_WININET
if ( SUCCEEDED ( hr ) && srpSec ) { BYTE* pbSidToLoad = NULL; BYTE* pbDSidSecURL = NULL; DWORD dwSizeToLoad = INTERNET_MAX_URL_LENGTH; DWORD dwSizeSecURL = INTERNET_MAX_URL_LENGTH;
pbSidToLoad = new BYTE [INTERNET_MAX_URL_LENGTH]; pbDSidSecURL = new BYTE [INTERNET_MAX_URL_LENGTH];
hr = srpSec->GetSecurityId ( urlToLoad, pbSidToLoad, &dwSizeToLoad, 0 ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( SUCCEEDED ( hr ) ) { hr = srpSec->GetSecurityId ( bstrSecURL, pbDSidSecURL, &dwSizeSecURL, 0 ); _ASSERTE ( SUCCEEDED ( hr ) ); if ( SUCCEEDED ( hr ) ) { hr = DE_E_ACCESS_DENIED;
if ( ( dwSizeToLoad == dwSizeSecURL ) && ( 0 == memcmp ( pbSidToLoad, pbDSidSecURL, dwSizeToLoad ) ) ) { hr = S_OK; } } }
delete [] pbSidToLoad; delete [] pbDSidSecURL; } else { // BUG 597887: If CoInternetCreateSecurityManager returns NULL and success, return error:
if ( !srpSec ) { hr = E_UNEXPECTED; } } } return hr;}
// A specialization of CheckCrossZoneSecurity which works on the current selection.
// Bug 547802 indicated a regression in execCommand, so we will assure safety ourselves.
//
HRESULT CProxyFrame::CheckCrossZoneSecurityOfSelection (){ HRESULT hr = S_OK; CComPtr<IHTMLDocument2> spDOM; CComPtr<IServiceProvider> srpSP; CComPtr<IHTMLEditServices> srpEditor; CComPtr<ISelectionServices> srpSelSvc; CComPtr<IMarkupContainer> sprMarkupCont; CComPtr<IHTMLDocument2> spSelDoc; CComPtr<IHTMLLocation> spHostLoc; CComBSTR bstrHref;
hr = HrGetDoc( &spDOM ); if ( FAILED(hr) ) goto ONERROR;
hr = spDOM->QueryInterface(IID_IServiceProvider, (LPVOID *)&srpSP); if ( FAILED(hr) ) goto ONERROR; hr = srpSP->QueryService(SID_SHTMLEditServices, IID_IHTMLEditServices, (void **)&srpEditor); if ( FAILED(hr) ) goto ONERROR; hr = srpEditor->GetSelectionServices(NULL, &srpSelSvc); if ( FAILED(hr) ) goto ONERROR; if ( !srpSelSvc ) goto ONERROR; hr = srpSelSvc->GetMarkupContainer(&sprMarkupCont); if ( FAILED(hr) ) goto ONERROR; if ( !sprMarkupCont ) goto ONERROR; hr = sprMarkupCont->QueryInterface(&spSelDoc); if ( FAILED(hr) ) goto ONERROR; hr = spSelDoc->get_location ( &spHostLoc ); if ( FAILED(hr) ) goto ONERROR; if ( !spHostLoc ) goto ONERROR; hr = spHostLoc->get_href ( &bstrHref ); if ( FAILED(hr) ) goto ONERROR; if ( !bstrHref ) goto ONERROR;
hr = CheckCrossZoneSecurity ( bstrHref );
return hr;
ONERROR: return DE_E_ACCESS_DENIED;}
HRESULT CProxyFrame::OnProgress(ULONG, ULONG, ULONG ulStatusCode, LPCWSTR){ if ( BINDSTATUS_REDIRECTING == ulStatusCode ) { // If we're the SFS control, cancel on Redirect. Otherwise, ignore it.
if ( m_pCtl->IsSafeForScripting ()) { m_bfSFSRedirect = TRUE; } } return E_NOTIMPL;}
|
