able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/activec/conui/amc.cpp

3750 lines
108 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1999
//
// File: amc.cpp
//
// Contents: The one and only app
//
// History: 01-Jan-96 TRomano Created
// 16-Jul-96 WayneSc Add code to switch views
//
//--------------------------------------------------------------------------
#include "stdafx.h"
#include "AMC.h"
#include "MainFrm.h"
#include "ChildFrm.h"
#include "AMCDoc.h"
#include "AMCView.h"
#include "amcdocmg.h"
#include "sysmenu.h"
#include <shlobj.h>
#include "strings.h"
#include "macros.h"
#include "scripthost.h"
#include "HtmlHelp.h"
#include "scriptevents.h"
#include "mmcutil.h"
#include "guidhelp.h" // for CLSID relational operators
#include "archpicker.h"
#include "classreg.h"
#define DECLSPEC_UUID(x) __declspec(uuid(x))
#include "websnk.h"
#include "websnk_i.c"
// We aren't picking this up from winuser.h for some reason.
#define ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID MAKEINTRESOURCE(3)
/*
* define our own Win64 symbol to make it easy to include 64-bit only
* code in the 32-bit build, so we can exercise some code on 32-bit Windows
* where the debuggers are better
*/
#ifdef _WIN64
#define MMC_WIN64
#endif
#ifndef MMC_WIN64
#include <wow64t.h> // for Wow64DisableFilesystemRedirector
#endif
/*
* multimon.h is included by stdafx.h, without defining COMPILE_MULTIMON_STUBS
* first. We need to include it again here after defining COMPILE_MULTIMON_STUBS
* so we'll get the stub functions.
*/
#if (_WIN32_WINNT < 0x0500)
#define COMPILE_MULTIMON_STUBS
#include <multimon.h>
#endif
#ifdef DBG
CTraceTag tagEnableScriptEngines(_T("MMCScriptEngines"), _T("Enable"));
CTraceTag tag32BitTransfer(_T("64/32-bit interop"), _T("64/32-bit interop"));
#endif
// Note: These strings do not need to be localizable.
const TCHAR CAMCApp::m_szSettingsSection[] = _T("Settings");
const TCHAR CAMCApp::m_szUserDirectoryEntry[] = _T("Save Location");
bool CanCloseDoc(void);
SC ScExpandEnvironmentStrings (CString& str);
//############################################################################
//############################################################################
//
// ATL Support
//
//############################################################################
//############################################################################
#include <atlimpl.cpp>
#include <atlwin.cpp>
// The one and only instance of CAtlGlobalModule
CAtlGlobalModule _Module;
//############################################################################
//############################################################################
//
// Trace Tags
//
//############################################################################
//############################################################################
#ifdef DBG
// enable this tag if you suspect memory corruption
// and you don't mind things slowing way down
BEGIN_TRACETAG(CDebugCRTCheck)
void OnEnable()
{
_CrtSetDbgFlag (_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG)
| _CRTDBG_CHECK_ALWAYS_DF
| _CRTDBG_DELAY_FREE_MEM_DF);
}
void OnDisable()
{
_CrtSetDbgFlag (_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG)
& ~(_CRTDBG_CHECK_ALWAYS_DF
| _CRTDBG_DELAY_FREE_MEM_DF) );
}
END_TRACETAG(CDebugCRTCheck, TEXT("Debug CRTs"), TEXT("Memory Check - SLOW!"))
CTraceTag tagAMCAppInit(TEXT("CAMCView"), TEXT("InitInstance"));
CTraceTag tagATLLock(TEXT("ATL"), TEXT("Lock/Unlock")); // used by atlconui.h
CTraceTag tagGDIBatching(TEXT("CAMCView"), TEXT("Disable Graphics/GDI Batching"));
CTraceTag tagForceMirror(TEXT("Mirroring"), TEXT("Force MMC windows to be mirrored on non-mirrored systems"));
#endif
//############################################################################
//############################################################################
//
// Implementation of class CMMCApplication - the root level
// automation class
//
//############################################################################
//############################################################################
class CMMCApplication :
public CMMCIDispatchImpl<_Application, &CLSID_Application>,
public CComCoClass<CMMCApplication, &CLSID_Application>,
// support for connection points (script events)
public IConnectionPointContainerImpl<CMMCApplication>,
public IConnectionPointImpl<CMMCApplication, &DIID_AppEvents, CComDynamicUnkArray>,
public IProvideClassInfo2Impl<&CLSID_Application, &DIID_AppEvents, &LIBID_MMC20>
{
public:
BEGIN_MMC_COM_MAP(CMMCApplication)
COM_INTERFACE_ENTRY(IProvideClassInfo)
COM_INTERFACE_ENTRY(IProvideClassInfo2)
COM_INTERFACE_ENTRY(IConnectionPointContainer)
END_MMC_COM_MAP()
DECLARE_NOT_AGGREGATABLE(CMMCApplication)
static HRESULT WINAPI UpdateRegistry(BOOL bRegister)
{
CObjectRegParams op (
CLSID_Application,
_T("mmc.exe"),
_T("MMC Application Class"),
_T("MMC20.Application.1"),
_T("MMC20.Application"),
_T("LocalServer32") );
return (MMCUpdateRegistry (bRegister, &op, NULL));
}
//hooks into ATL's construction
HRESULT InternalFinalConstructRelease(); // not FinalConstruct() - this is to work around a bogus ATL assert.
BEGIN_CONNECTION_POINT_MAP(CMMCApplication)
CONNECTION_POINT_ENTRY(DIID_AppEvents)
END_CONNECTION_POINT_MAP()
// overriden to do more job than the base class does
virtual ::SC ScOnDisconnectObjects();
private:
//IMMCApplication
public:
void STDMETHODCALLTYPE Help();
void STDMETHODCALLTYPE Quit();
STDMETHOD(get_Document) (Document **ppDocument);
STDMETHOD(Load) (BSTR bstrFilename);
STDMETHOD(get_Frame) (Frame **ppFrame);
STDMETHOD(get_Visible) (BOOL *pVisible);
STDMETHOD(Show) ();
STDMETHOD(Hide) ();
STDMETHOD(get_UserControl) (PBOOL pUserControl);
STDMETHOD(put_UserControl) (BOOL bUserControl);
STDMETHOD(get_VersionMajor) (PLONG pVersionMajor);
STDMETHOD(get_VersionMinor) (PLONG pVersionMinor);
private:
// Return the CAMCApp only if it is initialized. We do not want
// object model methods to operate on app while initializing.
CAMCApp *GetApp()
{
CAMCApp *pApp = AMCGetApp();
if ( (! pApp) || (pApp->IsInitializing()) )
return NULL;
return pApp;
}
};
//############################################################################
//############################################################################
//
// Event map for application events
//
//############################################################################
//############################################################################
DISPATCH_CALL_MAP_BEGIN(AppEvents)
DISPATCH_CALL1( OnQuit, PAPPLICATION )
DISPATCH_CALL2( OnDocumentOpen, PDOCUMENT, BOOL)
DISPATCH_CALL1( OnDocumentClose, PDOCUMENT )
DISPATCH_CALL2( OnSnapInAdded, PDOCUMENT, PSNAPIN )
DISPATCH_CALL2( OnSnapInRemoved, PDOCUMENT, PSNAPIN )
DISPATCH_CALL1( OnNewView, PVIEW )
DISPATCH_CALL1( OnViewClose, PVIEW )
DISPATCH_CALL2( OnViewChange, PVIEW, PNODE );
DISPATCH_CALL2( OnSelectionChange, PVIEW, PNODES )
DISPATCH_CALL1( OnContextMenuExecuted, PMENUITEM );
DISPATCH_CALL0( OnToolbarButtonClicked )
DISPATCH_CALL1( OnListUpdated, PVIEW )
DISPATCH_CALL_MAP_END()
/*+-------------------------------------------------------------------------*
*
* CMMCApplication::InternalFinalConstructRelease
*
* PURPOSE: Hands the CAMCApp a pointer to the 'this' object.
*
*+-------------------------------------------------------------------------*/
HRESULT
CMMCApplication::InternalFinalConstructRelease()
{
DECLARE_SC(sc, TEXT("CMMCApplication::InternalFinalConstructRelease"));
// Dont use GetApp, we need to get CAMCApp even if it is not fully initialized.
CAMCApp *pApp = AMCGetApp();
sc = ScCheckPointers(pApp);
if(sc)
return sc.ToHr(); // some wierd error.
sc = pApp->ScRegister_Application(this);
return sc.ToHr();
}
/*+-------------------------------------------------------------------------*
*
* CMMCApplication::GetFrame
*
* PURPOSE: A static function that hooks into the COM interface entry list
* and allows a tear-off object to be created that implements the
* Frame interface.
*
* PARAMETERS:
* void* pv : Defined by ATL to hold a pointer to the CMMCApplication object
* because this is a static method.
* REFIID riid : As per QI
* LPVOID* ppv : As per QI
* DWORD dw : ignored
*
* RETURNS:
* HRESULT WINAPI
*
*+-------------------------------------------------------------------------*/
STDMETHODIMP
CMMCApplication::get_Frame(Frame **ppFrame)
{
DECLARE_SC(sc, TEXT("CMMCApplication::get_Frame"));
if(!ppFrame)
{
sc = E_POINTER;
return sc.ToHr();
}
// get the app
CAMCApp *pApp = GetApp();
if(NULL == pApp)
{
sc = E_UNEXPECTED;
return sc.ToHr();
}
CMainFrame *pMainFrame = pApp->GetMainFrame();
if(!pMainFrame)
{
sc = E_UNEXPECTED;
return sc.ToHr();
}
sc = pMainFrame->ScGetFrame(ppFrame);
return sc.ToHr();
}
STDMETHODIMP
CMMCApplication::get_Document(Document **ppDocument)
{
DECLARE_SC(sc, TEXT("CMMCApplication::get_Document"));
CAMCDoc* const pDoc = CAMCDoc::GetDocument();
ASSERT(ppDocument != NULL);
if(ppDocument == NULL || (pDoc == NULL))
{
sc = E_POINTER;
return sc.ToHr();
}
sc = pDoc->ScGetMMCDocument(ppDocument);
if(sc)
return sc.ToHr();
return sc.ToHr();
}
/***************************************************************************\
*
* METHOD: CMMCApplication::Load
*
* PURPOSE: implements Application.Load for object model
*
* PARAMETERS:
* BSTR bstrFilename - console file to load
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
STDMETHODIMP
CMMCApplication::Load(BSTR bstrFilename)
{
DECLARE_SC(sc, TEXT("CMMCApplication::Load"));
CAMCApp *pApp = GetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return sc.ToHr();
USES_CONVERSION;
pApp->OpenDocumentFile(OLE2CT(bstrFilename));
return sc.ToHr();
}
void
STDMETHODCALLTYPE CMMCApplication::Help()
{
DECLARE_SC(sc, TEXT("CMMCApplication::Help"));
CAMCApp *pApp = GetApp();
if(NULL == pApp)
{
sc = E_UNEXPECTED;
return;
}
sc = pApp->ScHelp();
if(sc)
return;
return;
}
void
STDMETHODCALLTYPE CMMCApplication::Quit()
{
SC sc;
CAMCApp *pApp = GetApp();
if(NULL == pApp)
goto Error;
// confiscate the control from user
pApp->SetUnderUserControl(false);
// get mainframe
{
CMainFrame * pMainFrame = pApp->GetMainFrame();
if(NULL == pMainFrame)
goto Error;
// close it gracefully.
pMainFrame->PostMessage(WM_CLOSE);
}
Cleanup:
return;
Error:
sc = E_UNEXPECTED;
TraceError(TEXT("CMMCApplication::Quit"), sc);
goto Cleanup;
}
/*+-------------------------------------------------------------------------*
*
* CMMCApplication::get_VersionMajor
*
* PURPOSE: Returns the major version number for the installed version of MMC.
*
* PARAMETERS:
* PLONG pVersionMajor :
*
* RETURNS:
* HRESULT
*
*+-------------------------------------------------------------------------*/
HRESULT
CMMCApplication::get_VersionMajor(PLONG pVersionMajor)
{
DECLARE_SC(sc, TEXT("CMMCApplication::get_VersionMajor"));
sc = ScCheckPointers(pVersionMajor);
if(sc)
return sc.ToHr();
*pVersionMajor = MMC_VERSION_MAJOR;
return sc.ToHr();
}
/*+-------------------------------------------------------------------------*
*
* CMMCApplication::get_VersionMinor
*
* PURPOSE: Returns the minor version number for the installed version of MMC.
*
* PARAMETERS:
* PLONG pVersionMinor :
*
* RETURNS:
* HRESULT
*
*+-------------------------------------------------------------------------*/
HRESULT
CMMCApplication::get_VersionMinor(PLONG pVersionMinor)
{
DECLARE_SC(sc, TEXT("CMMCApplication::get_VersionMinor"));
sc = ScCheckPointers(pVersionMinor);
if(sc)
return sc.ToHr();
*pVersionMinor = MMC_VERSION_MINOR;
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CMMCApplication::get_Visible
//
// Synopsis: Returns the visible property
//
// Arguments: [PBOOL] - out bool
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
HRESULT CMMCApplication::get_Visible (PBOOL pbVisible)
{
DECLARE_SC(sc, _T("CMMCApplication::get_Visible"));
sc = ScCheckPointers(pbVisible);
if (sc)
return sc.ToHr();
// get the app
CAMCApp *pApp = GetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
CMainFrame *pMainFrame = pApp->GetMainFrame();
sc = ScCheckPointers(pMainFrame, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
*pbVisible = pMainFrame->IsWindowVisible();
return (sc.ToHr());
}
//+-------------------------------------------------------------------
//
// Member: CMMCApplication::Show
//
// Synopsis: Shows the application
//
// Arguments: None
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
HRESULT CMMCApplication::Show ()
{
DECLARE_SC(sc, _T("CMMCApplication::Show"));
// get the app
CAMCApp *pApp = GetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
CMainFrame *pMainFrame = pApp->GetMainFrame();
sc = ScCheckPointers(pMainFrame, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
sc = pMainFrame->ShowWindow(SW_SHOW);
return (sc.ToHr());
}
//+-------------------------------------------------------------------
//
// Member: CMMCApplication::Hide
//
// Synopsis: Hides the application.
//
// Arguments: None
//
// Returns: HRESULT
//
// Note: If the user is under control (UserControl property is set)
// then Hide fails.
//
//--------------------------------------------------------------------
HRESULT CMMCApplication::Hide ()
{
DECLARE_SC(sc, _T("CMMCApplication::Hide"));
// get the app
CAMCApp *pApp = GetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
// Cant hide if app is under user control.
if (pApp->IsUnderUserControl())
{
sc = E_FAIL;
return sc.ToHr();
}
CMainFrame *pMainFrame = pApp->GetMainFrame();
sc = ScCheckPointers(pMainFrame, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
sc = pMainFrame->ShowWindow(SW_HIDE);
return (sc.ToHr());
}
//+-------------------------------------------------------------------
//
// Member: CMMCApplication::get_UserControl
//
// Synopsis: Returns the UserControl property
//
// Arguments: PBOOL - out param.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
HRESULT CMMCApplication::get_UserControl (PBOOL pbUserControl)
{
DECLARE_SC(sc, _T("CMMCApplication::get_UserControl"));
sc = ScCheckPointers(pbUserControl);
if (sc)
return (sc.ToHr());
// get the app
CAMCApp *pApp = GetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
*pbUserControl = pApp->IsUnderUserControl();
return (sc.ToHr());
}
//+-------------------------------------------------------------------
//
// Member: CMMCApplication::put_UserControl
//
// Synopsis: Sets the UserControl property
//
// Arguments: BOOL
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
HRESULT CMMCApplication::put_UserControl (BOOL bUserControl)
{
DECLARE_SC(sc, _T("CMMCApplication::put_UserControl"));
// get the app
CAMCApp *pApp = GetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
pApp->SetUnderUserControl(bUserControl);
return (sc.ToHr());
}
/***************************************************************************\
*
* METHOD: CMMCApplication::ScOnDisconnectObjects
*
* PURPOSE: special disconnect implementation. For this object implementation
* provided by the base class is not enough, since connection point
* is an internal object which may also have strong references on it
*
* PARAMETERS:
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CMMCApplication::ScOnDisconnectObjects()
{
DECLARE_SC(sc, TEXT("CMMCApplication::ScOnDisconnectObjects"));
// get the connection point container
IConnectionPointContainerPtr spContainer(GetUnknown());
sc = ScCheckPointers( spContainer, E_UNEXPECTED );
if (sc)
return sc;
// get the connection point
IConnectionPointPtr spConnectionPoint;
sc = spContainer->FindConnectionPoint( DIID_AppEvents, &spConnectionPoint );
if (sc)
return sc;
// cut connection point references
sc = CoDisconnectObject( spConnectionPoint, 0/*dwReserved*/ );
if (sc)
return sc;
// let the base class do the rest
sc = CMMCIDispatchImplClass::ScOnDisconnectObjects();
if (sc)
return sc;
return sc;
}
//############################################################################
//############################################################################
//
// ATL GLobal Object Map
//
//############################################################################
//############################################################################
BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_Application, CMMCApplication)
END_OBJECT_MAP()
/*+-------------------------------------------------------------------------*
* CLockChildWindowUpdate
*
* Helper class whose constructor turns off redraw for all of the children
* of the given window, and whose destructor turns redraw back on for all
* of the windows for which it was turned off.
*
* This is used to prevent ugly transient drawing while opening console
* files that take a long time to completely open (bug 150356).
*--------------------------------------------------------------------------*/
class CLockChildWindowUpdate
{
public:
CLockChildWindowUpdate (CWnd* pwndLock) : m_pwndLock(pwndLock)
{
if (m_pwndLock != NULL)
{
CWnd* pwndChild;
/*
* turn off redraw for each child, saving the HWND for later
* so we can turn it back on (we save the HWND instead of the
* CWnd* because MFC might have returned a temporary object).
*/
for (pwndChild = m_pwndLock->GetWindow (GW_CHILD);
pwndChild != NULL;
pwndChild = pwndChild->GetNextWindow())
{
pwndChild->SetRedraw (false);
m_vChildren.push_back (pwndChild->GetSafeHwnd());
}
}
}
~CLockChildWindowUpdate()
{
std::vector<HWND>::iterator it;
/*
* for every window for which we turned off redraw, turn it back on
*/
for (it = m_vChildren.begin(); it != m_vChildren.end(); ++it)
{
HWND hWndChild = *it;
if ( (hWndChild != NULL) && ::IsWindow(hWndChild) )
{
CWnd *pwndChild = CWnd::FromHandle(hWndChild);
pwndChild->SetRedraw (true);
pwndChild->RedrawWindow (NULL, NULL,
RDW_INVALIDATE | RDW_UPDATENOW |
RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
}
}
}
private:
CWnd* const m_pwndLock;
std::vector<HWND> m_vChildren;
};
//############################################################################
//############################################################################
//
// Implementation of class CAMCMultiDocTemplate
//
//############################################################################
//############################################################################
class CAMCMultiDocTemplate : public CMultiDocTemplate
{
public:
CAMCMultiDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,
CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass)
: CMultiDocTemplate(nIDResource, pDocClass, pFrameClass, pViewClass)
{
}
CDocument* OpenDocumentFile(LPCTSTR lpszPathName,
BOOL bMakeVisible)
{
DECLARE_SC(sc, TEXT("CAMCMultiDocTemplate::OpenDocumentFile"));
CAMCDoc* const pDoc = CAMCDoc::GetDocument();
if (pDoc && (!pDoc->SaveModified() || !CanCloseDoc() ))
return NULL; // leave the original one
CLockChildWindowUpdate lock (AfxGetMainWnd());
CAMCDoc* pDocument = (CAMCDoc*)CreateNewDocument();
if (pDocument == NULL)
{
TRACE0("CDocTemplate::CreateNewDocument returned NULL.\n");
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC); // do not change to MMCMessageBox
return NULL;
}
HRESULT hr;
if ((hr = pDocument->InitNodeManager()) != S_OK)
{
TRACE1("CAMCDoc::InitNodeManager failed, 0x%08x\n", hr);
CAMCApp* pApp = AMCGetApp();
MMCErrorBox((pApp && pApp->IsWin9xPlatform())
? IDS_NODEMGR_FAILED_9x
: IDS_NODEMGR_FAILED);
delete pDocument; // explicit delete on error
return NULL;
}
ASSERT_VALID(pDocument);
BOOL bAutoDelete = pDocument->m_bAutoDelete;
pDocument->m_bAutoDelete = FALSE; // don't destroy if something goes wrong
CFrameWnd* pFrame = CreateNewFrame(pDocument, NULL);
pDocument->m_bAutoDelete = bAutoDelete;
if (pFrame == NULL)
{
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC); // do not change to MMCMessageBox
delete pDocument; // explicit delete on error
return NULL;
}
ASSERT_VALID(pFrame);
if (lpszPathName == NULL)
{
// create a new document - with default document name
SetDefaultTitle(pDocument);
// avoid creating temporary compound file when starting up invisible
if (!bMakeVisible)
pDocument->m_bEmbedded = TRUE;
if (!pDocument->OnNewDocument())
{
// user has be alerted to what failed in OnNewDocument
TRACE0("CDocument::OnNewDocument returned FALSE.\n");
AfxMessageBox (AFX_IDP_FAILED_TO_CREATE_DOC); // do not change to MMCMessageBox
pFrame->DestroyWindow();
return NULL;
}
// it worked, now bump untitled count
m_nUntitledCount++;
InitialUpdateFrame(pFrame, pDocument, bMakeVisible);
}
else
{
// open an existing document
CWaitCursor wait;
if (!pDocument->OnOpenDocument(lpszPathName))
{
// user has be alerted to what failed in OnOpenDocument
TRACE0("CDocument::OnOpenDocument returned FALSE.\n");
pFrame->DestroyWindow();
return NULL;
}
#ifdef _MAC
// if the document is dirty, we must have opened a stationery pad
// - don't change the pathname because we want to treat the document
// as untitled
if (!pDocument->IsModified())
#endif
pDocument->SetPathName(lpszPathName);
//REVIEW: dburg: InitialUpdateFrame(pFrame, pDocument, bMakeVisible);
pFrame->DestroyWindow();
pDocument->SetModifiedFlag (false);
pDocument->SetFrameModifiedFlag (false);
}
// fire script event
CAMCApp* pApp = AMCGetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return pDocument;
sc = pApp->ScOnNewDocument(pDocument, (lpszPathName != NULL));
if (sc)
sc.TraceAndClear();
return pDocument;
}
// this method is overrided to catch application quit event
virtual void CloseAllDocuments( BOOL bEndSession )
{
DECLARE_SC(sc, TEXT("CAMCMultiDocTemplate::CloseAllDocuments"));
// invoke base class to perform required tasks
CMultiDocTemplate::CloseAllDocuments( bEndSession );
// no other way we can get here but exit app
// so that's a good time for script to know it
CAMCApp* pApp = AMCGetApp();
sc = ScCheckPointers(pApp, E_UNEXPECTED);
if (sc)
return;
// forward to application to emit the script event
sc = pApp->ScOnQuitApp();
if (sc)
sc.TraceAndClear();
// cut off all strong references now.
// Quit was executed - nothing else matters
sc = GetComObjectEventSource().ScFireEvent( CComObjectObserver::ScOnDisconnectObjects );
if (sc)
sc.TraceAndClear();
}
};
// Declare debug infolevel for this component
DECLARE_INFOLEVEL(AMCConUI);
//############################################################################
//############################################################################
//
// Implementation of class CAMCApp
//
//############################################################################
//############################################################################
IMPLEMENT_DYNAMIC(CAMCApp, CWinApp)
BEGIN_MESSAGE_MAP(CAMCApp, CWinApp)
//{{AFX_MSG_MAP(CAMCApp)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
//}}AFX_MSG_MAP
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
ON_COMMAND(ID_FILE_NEW_USER_MODE, OnFileNewInUserMode) // CTRL+N in user mode - do nothing
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CAMCApp construction
CAMCApp::CAMCApp() :
m_bOleInitialized(FALSE),
m_bDefaultDirSet(FALSE),
m_eMode(eMode_Error),
m_fAuthorModeForced(false),
m_fInitializing(true),
m_fDelayCloseUntilIdle(false),
m_fCloseCameFromMainPump(false),
m_nMessagePumpNestingLevel(0),
m_fIsWin9xPlatform(false),
m_dwHelpCookie(0),
m_bHelpInitialized(false),
m_fUnderUserControl(true),
m_fRunningAsOLEServer(false)
{
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CAMCApp object
CAMCApp theApp;
const CRect g_rectEmpty (0, 0, 0, 0);
void DeleteDDEKeys()
{
HKEY key;
if (ERROR_SUCCESS == RegOpenKeyEx (HKEY_CLASSES_ROOT,
_T("MSCFile\\shell\\open"),
0, KEY_SET_VALUE, &key))
{
theApp.DelRegTree (key, _T("ddeexec"));
RegCloseKey (key);
}
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::GetMainFrame
*
* PURPOSE: Returns a pointer to the main frame.
*
* RETURNS:
* CMainFrame *
*
*+-------------------------------------------------------------------------*/
CMainFrame *
CAMCApp::GetMainFrame()
{
return dynamic_cast<CMainFrame *>(m_pMainWnd);
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::ScGet_Application
*
* PURPOSE: Returns a pointer to an _Application object.
*
* PARAMETERS:
* _Application ** pp_Application :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CAMCApp::ScGet_Application(_Application **pp_Application)
{
DECLARE_SC(sc, TEXT("CAMCApp::ScGet_Application"));
// parameter check
sc = ScCheckPointers(pp_Application);
if (sc)
return sc;
// init out param
*pp_Application = NULL;
// see if we have a chached one
if (m_sp_Application != NULL)
{
*pp_Application = m_sp_Application;
(*pp_Application)->AddRef(); // addref for the client.
return sc;
}
// create an _Application object. This is needed if MMC was instantiated
// by a user, not COM.
sc = CMMCApplication::CreateInstance(pp_Application);
if(sc)
return sc;
// The constructor of the CMMCApplication calls ScRegister_Application
// which sets the m_sp_Application pointer. Do not set this pointer here.
sc = ScCheckPointers(*pp_Application, E_UNEXPECTED);
if (sc)
return sc;
// done
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::ScRegister_Application
*
* PURPOSE: called by a CMMCApplication object to enable the CAMCApp to store
* a pointer to it.
*
* PARAMETERS:
* _Application * p_Application :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CAMCApp::ScRegister_Application(_Application *p_Application)
{
DECLARE_SC(sc, TEXT("CAMCApp::ScRegister_Application"));
ASSERT(m_sp_Application == NULL); // only one _Application object should ever register.
sc = ScCheckPointers(p_Application);
if(sc)
return sc;
m_sp_Application = p_Application;
return sc;
}
//+-------------------------------------------------------------------
//
// Member: RegisterShellFileTypes
//
// Synopsis: Register the file associations.
//
// Note: Also set all other relevant registry keys like
// Open, Author, RunAs. Eventhough the setup has
// done this it may have been deleted mistakenly.
//
// History:
// [AnandhaG] - Added the registry repair.
// Returns: None.
//
//--------------------------------------------------------------------
void CAMCApp::RegisterShellFileTypes(BOOL bCompat)
{
CWinApp::RegisterShellFileTypes (bCompat);
do
{
// Create the top level MSCFile key.
CRegKey regKey;
LONG lRet = regKey.Create(HKEY_CLASSES_ROOT, _T("MSCFile"), REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE);
if (ERROR_SUCCESS != lRet)
break;
/*
* for platforms that support it (i.e. not Win9x), set the MUI-friendly
* value for the MSCFile document type
*/
if (!IsWin9xPlatform())
{
CString strMUIValue;
strMUIValue.Format (_T("@%%SystemRoot%%\\system32\\mmcbase.dll,-%d"), IDR_MUIFRIENDLYNAME);
lRet = RegSetValueEx (regKey, _T("FriendlyTypeName"), NULL, REG_EXPAND_SZ,
(CONST BYTE *)(LPCTSTR) strMUIValue,
sizeof(TCHAR) * (strMUIValue.GetLength()+1) );
if (ERROR_SUCCESS != lRet)
break;
}
// Set the EditFlags value.
lRet = regKey.SetValue(0x100000, _T("EditFlags"));
if (ERROR_SUCCESS != lRet)
break;
// Create the Author verb.
lRet = regKey.Create(HKEY_CLASSES_ROOT, _T("MSCFile\\shell\\Author"), REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE);
if (ERROR_SUCCESS != lRet)
break;
// And set default value for author (this reflects in shell menu).
CString strRegVal;
LoadString(strRegVal, IDS_MENUAUTHOR);
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_SZ,
(CONST BYTE *)(LPCTSTR)strRegVal, sizeof(TCHAR) * (strRegVal.GetLength()+1) );
if (ERROR_SUCCESS != lRet)
break;
/*
* for platforms that support it (i.e. not Win9x), set the MUI-friendly
* value for the menu item
*/
if (!IsWin9xPlatform())
{
CString strMUIValue;
strMUIValue.Format (_T("@%%SystemRoot%%\\system32\\mmcbase.dll,-%d"), IDS_MENUAUTHOR);
lRet = RegSetValueEx (regKey, _T("MUIVerb"), NULL, REG_EXPAND_SZ,
(CONST BYTE *)(LPCTSTR) strMUIValue,
sizeof(TCHAR) * (strMUIValue.GetLength()+1) );
if (ERROR_SUCCESS != lRet)
break;
}
// Create the Author command.
lRet = regKey.Create(HKEY_CLASSES_ROOT, _T("MSCFile\\shell\\Author\\command"), REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE);
if (ERROR_SUCCESS != lRet)
break;
//////////////////////////////////////////////////////////////
// Win95 does not support REG_EXPAND_SZ for default values. //
// So we set expand strings and set registry strings as //
// REG_SZ for Win9x. //
// The following declarations are for Win9x platform. //
//////////////////////////////////////////////////////////////
TCHAR szRegValue[2 * MAX_PATH];
TCHAR szWinDir[MAX_PATH];
if (0 == ExpandEnvironmentStrings(_T("%WinDir%"), szWinDir, MAX_PATH) )
break;
DWORD dwCount = 0;
LPTSTR lpszRegValue = NULL;
// Set the default value for Author command.
if (IsWin9xPlatform() == false)
{
lpszRegValue = _T("%SystemRoot%\\system32\\mmc.exe /a \"%1\" %*");
dwCount = sizeof(TCHAR) * (1 + _tcslen(lpszRegValue));
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_EXPAND_SZ,
(CONST BYTE *)lpszRegValue, dwCount);
}
else // Win9x platform
{
lpszRegValue = _T("\\mmc.exe /a \"%1\" %2 %3 %4 %5 %6 %7 %8 %9");
_tcscpy(szRegValue, szWinDir);
_tcscat(szRegValue, lpszRegValue);
dwCount = sizeof(TCHAR) * (1 + _tcslen(szRegValue));
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_SZ,
(CONST BYTE *)szRegValue, dwCount);
}
if (ERROR_SUCCESS != lRet)
break;
// Create the Open verb.
lRet = regKey.Create(HKEY_CLASSES_ROOT, _T("MSCFile\\shell\\Open"), REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE);
if (ERROR_SUCCESS != lRet)
break;
// Set default value for Open.
LoadString(strRegVal, IDS_MENUOPEN);
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_SZ,
(CONST BYTE *)(LPCTSTR)strRegVal,sizeof(TCHAR) * (strRegVal.GetLength()+1) );
if (ERROR_SUCCESS != lRet)
break;
/*
* for platforms that support it (i.e. not Win9x), set the MUI-friendly
* value for the menu item
*/
if (!IsWin9xPlatform())
{
CString strMUIValue;
strMUIValue.Format (_T("@%%SystemRoot%%\\system32\\mmcbase.dll,-%d"), IDS_MENUOPEN);
lRet = RegSetValueEx (regKey, _T("MUIVerb"), NULL, REG_EXPAND_SZ,
(CONST BYTE *)(LPCTSTR) strMUIValue,
sizeof(TCHAR) * (strMUIValue.GetLength()+1) );
if (ERROR_SUCCESS != lRet)
break;
}
// Create the Open command.
lRet = regKey.Create(HKEY_CLASSES_ROOT, _T("MSCFile\\shell\\Open\\command"), REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE);
if (ERROR_SUCCESS != lRet)
break;
// Set the default value for Open command.
if (IsWin9xPlatform() == false)
{
lpszRegValue = _T("%SystemRoot%\\system32\\mmc.exe \"%1\" %*");
dwCount = sizeof(TCHAR) * (1 + _tcslen(lpszRegValue));
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_EXPAND_SZ,
(CONST BYTE *)lpszRegValue, dwCount);
}
else // Win9x platform
{
lpszRegValue = _T("\\mmc.exe \"%1\" %2 %3 %4 %5 %6 %7 %8 %9");
_tcscpy(szRegValue, szWinDir);
_tcscat(szRegValue, lpszRegValue);
dwCount = sizeof(TCHAR) * (1 + _tcslen(szRegValue));
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_SZ,
(CONST BYTE *)szRegValue, dwCount);
}
if (ERROR_SUCCESS != lRet)
break;
// Create the RunAs verb (only on NT).
if (IsWin9xPlatform() == false)
{
lRet = regKey.Create(HKEY_CLASSES_ROOT, _T("MSCFile\\shell\\RunAs"), REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE);
if (ERROR_SUCCESS != lRet)
break;
// Set default value for RunAs verb.
LoadString(strRegVal, IDS_MENURUNAS);
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_SZ,
(CONST BYTE *)(LPCTSTR)strRegVal,sizeof(TCHAR) * (strRegVal.GetLength()+1) );
if (ERROR_SUCCESS != lRet)
break;
/*
* for platforms that support it (i.e. not Win9x), set the MUI-friendly
* value for the menu item
*/
if (!IsWin9xPlatform())
{
CString strMUIValue;
strMUIValue.Format (_T("@%%SystemRoot%%\\system32\\mmcbase.dll,-%d"), IDS_MENURUNAS);
lRet = RegSetValueEx (regKey, _T("MUIVerb"), NULL, REG_EXPAND_SZ,
(CONST BYTE *)(LPCTSTR) strMUIValue,
sizeof(TCHAR) * (strMUIValue.GetLength()+1) );
if (ERROR_SUCCESS != lRet)
break;
}
// Create the RunAs command.
lRet = regKey.Create(HKEY_CLASSES_ROOT, _T("MSCFile\\shell\\RunAs\\command"), REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE);
if (ERROR_SUCCESS != lRet)
break;
// Set the default value for RunAs command. (Only on NT Unicode)
lpszRegValue = _T("%SystemRoot%\\system32\\mmc.exe \"%1\" %*");
dwCount = sizeof(TCHAR) * (1 + _tcslen(lpszRegValue));
lRet = RegSetValueEx ((HKEY)regKey, (LPCTSTR)NULL, NULL, REG_EXPAND_SZ,
(CONST BYTE *)lpszRegValue, dwCount);
}
if (ERROR_SUCCESS != lRet)
break;
} while ( FALSE );
return;
}
/////////////////////////////////////////////////////////////////////////////
// CAMCApp initialization
#ifdef UNICODE
SC ScLaunchMMC (eArchitecture eArch, int nCmdShow);
#endif
#ifdef MMC_WIN64
class CMMCCommandLineInfo;
SC ScDetermineArchitecture (const CMMCCommandLineInfo& rCmdInfo, eArchitecture& eArch);
#else
bool IsWin64();
#endif // MMC_WIN64
class CMMCCommandLineInfo : public CCommandLineInfo
{
public:
eArchitecture m_eArch;
bool m_fForceAuthorMode;
bool m_fRegisterServer;
CString m_strDumpFilename;
public:
CMMCCommandLineInfo() :
m_eArch (eArch_Any),
m_fForceAuthorMode(false),
m_fRegisterServer(false)
{}
virtual void ParseParam (LPCTSTR pszParam, BOOL bFlag, BOOL bLast)
{
bool fHandledHere = false;
if (bFlag)
{
/*
* ignore the following parameters:
* -dde (await DDE command), -s (splash screen, obsolete).
*/
if ((lstrcmpi (pszParam, _T("s")) == 0) ||
(lstrcmpi (pszParam, _T("dde")) == 0))
{
fHandledHere = true;
}
// force author mode
else if (lstrcmpi (pszParam, _T("a")) == 0)
{
m_fForceAuthorMode = true;
fHandledHere = true;
}
// register the server only
else if (lstrcmpi (pszParam, _T("RegServer")) == 0)
{
m_fRegisterServer = true;
fHandledHere = true;
}
// force 64-bit MMC to run
else if (lstrcmp (pszParam, _T("64")) == 0)
{
m_eArch = eArch_64bit;
fHandledHere = true;
}
// force 32-bit MMC to run
else if (lstrcmp (pszParam, _T("32")) == 0)
{
m_eArch = eArch_32bit;
fHandledHere = true;
}
else
{
static const TCHAR szDumpParam[] = _T("dump:");
const int cchDumpParam = countof (szDumpParam);
TCHAR szParam[cchDumpParam];
lstrcpyn (szParam, pszParam, cchDumpParam);
szParam[cchDumpParam-1] = _T('\0');
// dump console file contents
if (lstrcmpi (szParam, szDumpParam) == 0)
{
m_strDumpFilename = pszParam + cchDumpParam - 1;
fHandledHere = true;
}
}
}
// if not handled, pass it on to base class
// if just handled last parameter, call base class ParseLast
// so it can do the final processing
if (!fHandledHere)
CCommandLineInfo::ParseParam (pszParam, bFlag, bLast);
else if (bLast)
CCommandLineInfo::ParseLast(bLast);
}
}; // class CMMCCommandLineInfo
/*+-------------------------------------------------------------------------*
* CWow64FilesystemRedirectionDisabler
*
* Disables Wow64 file system redirection for the file represented in the
* given CMMCCommandLineInfo. We do this so MMC32 can open consoles in
* %windir%\system32 without having the path redirected to %windir%\syswow64.
*--------------------------------------------------------------------------*/
class CWow64FilesystemRedirectionDisabler
{
public:
CWow64FilesystemRedirectionDisabler (LPCTSTR pszFilename)
{
#ifndef MMC_WIN64
m_fDisabled = ((pszFilename != NULL) && IsWin64());
if (m_fDisabled)
{
Trace (tag32BitTransfer, _T("Disabling Wow64 file system redirection for %s"), pszFilename);
Wow64DisableFilesystemRedirector (pszFilename);
}
#endif // !MMC_WIN64
}
~CWow64FilesystemRedirectionDisabler ()
{
#ifndef MMC_WIN64
if (m_fDisabled)
{
Trace (tag32BitTransfer, _T("Enabling Wow64 file system redirection"));
Wow64EnableFilesystemRedirector();
}
#endif // !MMC_WIN64
}
private:
#ifndef MMC_WIN64
bool m_fDisabled;
#endif // !MMC_WIN64
};
/*+-------------------------------------------------------------------------*
*
* CAMCApp::ScProcessAuthorModeRestrictions
*
* PURPOSE: Determines whether author mode restrictions are being enforced
* by system policy, and if author mode is not allowed,
* displays an error box and exits.
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CAMCApp::ScProcessAuthorModeRestrictions()
{
DECLARE_SC(sc, TEXT("CAMCApp::ScProcessAuthorModeRestrictions"));
CRegKey regKey;
// The mode is initialized to "author", if it is not in
// initialized state just return.
if (eMode_Author != m_eMode)
return sc;
// The console file mode is already read.
// Check if user policy permits author mode.
long lResult = regKey.Open(HKEY_CURRENT_USER, POLICY_KEY, KEY_READ);
if (lResult != ERROR_SUCCESS)
return sc;
// get the value of RestrictAuthorMode.
DWORD dwRestrictAuthorMode = 0;
lResult = regKey.QueryValue(dwRestrictAuthorMode, g_szRestrictAuthorMode);
if (lResult != ERROR_SUCCESS)
return sc;
if (dwRestrictAuthorMode == 0) // Author mode is not restricted so return.
return sc;
/*
* If called from script (running as embedded server) see if policy
* restricts scripts from entering into author mode.
*
* If restricted then script will fail, thus restricting rogue scripts.
*
* Even if not restricted here cannot add snapins that are restricted.
*/
if (IsMMCRunningAsOLEServer())
{
DWORD dwRestrictScriptsFromEnteringAuthorMode = 0;
lResult = regKey.QueryValue(dwRestrictScriptsFromEnteringAuthorMode, g_szRestrictScriptsFromEnteringAuthorMode);
if (lResult != ERROR_SUCCESS)
return sc;
if (dwRestrictScriptsFromEnteringAuthorMode == 0) // Scripts can enter author mode so return
return sc;
sc = ScFromMMC(IDS_AUTHORMODE_NOTALLOWED_FORSCRIPTS);
}
else
// If author mode is not allowed and
// the user tried to force author mode
// then display error message and exit.
sc = ScFromMMC(IDS_AUTHORMODE_NOTALLOWED);
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::ScCheckMMCPrerequisites
*
* PURPOSE: Checks all prerequisites. These are: (add to the list as appropriate)
* 1) Internet Explorer 5.5 or greater must be installed
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CAMCApp::ScCheckMMCPrerequisites()
{
DECLARE_SC(sc, TEXT("CAMCApp::ScCheckMMCPrerequisites"));
// 1. Determine the installed version of Internet Explorer.
const int CBDATA = 100;
TCHAR szVersion[CBDATA];
BOOL bIE55Found = false;
HKEY hkey = NULL;
DWORD dwType =0;
DWORD cbData =CBDATA;
DWORD dwMajor =0;
DWORD dwMinor =0;
DWORD dwRevision =0;
DWORD dwBuild =0;
lstrcpy(szVersion, TEXT(""));
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Internet Explorer"), 0, KEY_READ, &hkey))
{
cbData = 100;
RegQueryValueEx(hkey, TEXT("Version"), 0, &dwType, (LPBYTE)szVersion, &cbData);
RegCloseKey(hkey);
if (lstrlen(szVersion) > 0)
{
_stscanf(szVersion, TEXT("%d.%d.%d.%d"), &dwMajor, &dwMinor, &dwRevision, &dwBuild);
//Make sure IE 5.5 or greater is installed. To do this:
// 1) Check if the major version is >= 6. If so we're done.
// 2) If the major version is 5, the minor version should be >= 50
if (dwMajor >= 6)
{
bIE55Found = true;
}
if (dwMajor == 5)
{
if(dwMinor >= 50)
bIE55Found = true;
}
}
}
if (!bIE55Found)
{
sc = ScFromMMC(MMC_E_INCORRECT_IE_VERSION); // NOTE: update the string when the version requirement changes
return sc;
}
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::InitInstance
*
* PURPOSE: Initializes the document.
*
* NOTE: as an aside, if you need to break on, say, the 269th allocation,
* add the following code:
*
* #define ALLOCATION_NUM 269
* _CrtSetBreakAlloc(ALLOCATION_NUM);
* _crtBreakAlloc = ALLOCATION_NUM;
*
* RETURNS:
* BOOL
*
*+-------------------------------------------------------------------------*/
BOOL CAMCApp::InitInstance()
{
DECLARE_SC(sc, TEXT("CAMCApp::InitInstance"));
/*
* Initialize Fusion.
*/
SHFusionInitializeFromModuleID (NULL, static_cast<int>(reinterpret_cast<ULONG_PTR>(SXS_MANIFEST_RESOURCE_ID)));
#ifdef DBG
if (tagForceMirror.FAny())
{
HINSTANCE hmodUser = GetModuleHandle (_T("user32.dll"));
if (hmodUser != NULL)
{
BOOL (WINAPI* pfnSetProcessDefaultLayout)(DWORD);
(FARPROC&)pfnSetProcessDefaultLayout = GetProcAddress (hmodUser, "SetProcessDefaultLayout");
if (pfnSetProcessDefaultLayout != NULL)
(*pfnSetProcessDefaultLayout)(LAYOUT_RTL);
}
}
#endif
BOOL bRet = TRUE;
// Initialize OLE libraries
if (InitializeOLE() == FALSE)
return FALSE;
// Initialize the ATL Module
_Module.Init(ObjectMap,m_hInstance);
#ifdef DBG
if(tagGDIBatching.FAny())
{
// disable GDI batching so we'll see drawing as it happens
GdiSetBatchLimit (1);
}
#endif
Unregister();
Trace(tagAMCAppInit, TEXT("CAMCApp::InitInstance"));
CMMCCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
/*
* if we got a file on the command line, expand environment
* variables in the filename so we can open files like
* "%SystemRoot%\system32\compmgmt.msc"
*/
if (!cmdInfo.m_strFileName.IsEmpty())
{
CWow64FilesystemRedirectionDisabler disabler (cmdInfo.m_strFileName);
sc = ScExpandEnvironmentStrings (cmdInfo.m_strFileName);
if (sc)
{
MMCErrorBox (sc);
return (false);
}
}
// Don't use an .ini file for the MRU or Settings
// Note: This string does not need to be localizable.
// HKEY_CURRENT_USER\\Software\\Microsoft\\Microsoft Management Console
SetRegistryKey(_T("Microsoft"));
// Find out OS version.
OSVERSIONINFO versInfo;
versInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
BOOL bStat = GetVersionEx(&versInfo);
ASSERT(bStat);
m_fIsWin9xPlatform = (versInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
// default to Author mode (loading a console may change this later)
InitializeMode (eMode_Author);
m_fAuthorModeForced = cmdInfo.m_fForceAuthorMode ||
cmdInfo.m_strFileName.IsEmpty();
/*
* dump the snap-ins (and do nothing else) if we got "-dump:<filename>"
*/
if (!cmdInfo.m_strDumpFilename.IsEmpty())
{
DumpConsoleFile (cmdInfo.m_strFileName, cmdInfo.m_strDumpFilename);
return (false);
}
#ifdef MMC_WIN64
/*
* We're currently running the MMC64. See if we need to defer to MMC32.
* If we do, try to launch MMC32. If we were able to launch MMC32
* successfully, abort MMC64.
*/
eArchitecture eArch = eArch_64bit;
sc = ScDetermineArchitecture (cmdInfo, eArch);
if (sc)
{
DisplayFileOpenError (sc, cmdInfo.m_strFileName);
return (false);
}
switch (eArch)
{
/*
* MMC64 is fine, do nothing
*/
case eArch_64bit:
break;
/*
* User cancelled action, abort
*/
case eArch_None:
return (false);
break;
/*
* We need MMC32, so try to launch it. If we were able to launch MMC32
* successfully, abort MMC64; if not, continue running MMC64.
*/
case eArch_32bit:
if (!ScLaunchMMC(eArch_32bit, m_nCmdShow).IsError())
{
Trace (tag32BitTransfer, _T("32-bit MMC launched successfully"));
return (false);
}
Trace (tag32BitTransfer, _T("32-bit MMC failed to launch"));
MMCErrorBox (MMC_E_UnableToLaunchMMC32);
break;
default:
ASSERT (false && "Unexpected architecture returned from ScDetermineArchitecture");
break;
}
#elif defined(UNICODE)
/*
* We're currently running the MMC32. If it's running on IA64 and 32-bit
* wasn't specifically requested with a "-32" switch (this is what MMC64
* will do when it defers to MMC32), defer to MMC64 so it can do snap-in
* analysis and determine the appropriate "bitness" to run.
*/
if ((cmdInfo.m_eArch != eArch_32bit) && IsWin64())
{
/*
* We need MMC64, so try to launch it. If we were able to launch MMC64
* successfully, abort MMC32; if not, continue running MMC32.
*/
if (!ScLaunchMMC(eArch_64bit, m_nCmdShow).IsError())
{
Trace (tag32BitTransfer, _T("64-bit MMC launched successfully"));
return (false);
}
Trace (tag32BitTransfer, _T("64-bit MMC failed to launch"));
MMCErrorBox (MMC_E_UnableToLaunchMMC64);
}
#endif // MMC_WIN64
AfxEnableControlContainer();
// Standard initialization
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
LoadStdProfileSettings(); // Load standard INI file options (including MRU)
// create our own CDocManager derivative before adding any templates
// (CWinApp::~CWinApp will delete it)
m_pDocManager = new CAMCDocManager;
// Register document templates
CMultiDocTemplate* pDocTemplate;
pDocTemplate = new CAMCMultiDocTemplate(
IDR_AMCTYPE,
RUNTIME_CLASS(CAMCDoc),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CAMCView));
AddDocTemplate(pDocTemplate);
// Note: MDI applications register all server objects without regard
// to the /Embedding or /Automation on the command line.
if (cmdInfo.m_fRegisterServer)
{
sc = _Module.RegisterServer(TRUE);// ATL Classes
if (sc == TYPE_E_REGISTRYACCESS)
sc.TraceAndClear();
}
if (sc)
{
MMCErrorBox (sc);
return (false);
}
// create main MDI Frame window
CMainFrame *pMainFrame = new CMainFrame;
if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
return FALSE;
m_pMainWnd = pMainFrame;
// set the HWND to use as the parent for modal error dialogs.
SC::SetHWnd(pMainFrame->GetSafeHwnd());
// save this main thread's ID to check if snapins call MMC
// interfaces from main thread.
SC::SetMainThreadID(::GetCurrentThreadId());
m_fRunningAsOLEServer = false;
// Check to see if launched as OLE server
if (RunEmbedded() || RunAutomated())
{
m_fRunningAsOLEServer = true;
// Application was run with /Embedding or /Automation. Don't show the
// main window in this case.
//return TRUE;
// Also set that script is controlling the application not the user
// The script can modify the UserControl property on the application.
SetUnderUserControl(false);
// When a server application is launched stand-alone, it is a good idea to register all objects
// ATL ones specifically register with REGCLS_MULTIPLEUSE
// we register class objects only when run as an OLE server. This way, cannot connect to
// an existing instance of MMC.
sc = _Module.RegisterClassObjects(CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE);
if(sc)
goto Error;
}
if (cmdInfo.m_fRegisterServer)
{
CString strTypeLib;
strTypeLib.Format(TEXT("\\%d"), IDR_WEBSINK_TYPELIB); // this should evaluate to something like "\\4"
sc = _Module.RegisterTypeLib((LPCTSTR)strTypeLib);
if (sc == TYPE_E_REGISTRYACCESS)
sc.TraceAndClear();
if(sc)
goto Error;
}
// Don't Enable drag/drop open
// m_pMainWnd->DragAcceptFiles();
// Enable DDE Execute open
if (cmdInfo.m_fRegisterServer)
RegisterShellFileTypes(FALSE);
EnableShellOpen();
if (cmdInfo.m_fRegisterServer)
DeleteDDEKeys();
/*
* At this point, all of our registration is complete. If we were invoked
* with -RegServer, we can bail now.
*/
if (cmdInfo.m_fRegisterServer)
return (false);
{ // limit scope of disabler
CWow64FilesystemRedirectionDisabler disabler (cmdInfo.m_strFileName);
// Dispatch commands specified on the command line.
// This loads a console file if necessary.
if (!ProcessShellCommand(cmdInfo))
return (false); // user is already informed about errors
}
// Now the console file is loaded. Check if Author mode
// is permitted.
sc = ScProcessAuthorModeRestrictions(); // check if there are any restrictions set by policy
if(sc)
goto Error;
// if proccessing the command line put MMC into author mode,
// it has to stick with it forever.
// see bug 102465 openning an author mode console file and then
// a user mode console switched MMC into user mode
if (eMode_Author == m_eMode)
m_fAuthorModeForced = true;
// create a document automatically only if we're not instantiated as an
// OLE server.
if(! IsMMCRunningAsOLEServer ())
{
// if we don't have a document now (maybe because
// the Node Manager wasn't registered), punt
CAMCDoc* pDoc = CAMCDoc::GetDocument ();
if (pDoc == NULL)
return (FALSE);
pDoc->SetFrameModifiedFlag (false);
pDoc->UpdateFrameCounts ();
CMainFrame *pMainFrame = GetMainFrame();
if (pMainFrame)
{
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();
}
// showing will set the frame and "Modified" - reset it
pDoc->SetFrameModifiedFlag (false);
}
// register itself as dispatcher able to dispatch com events
sc = CConsoleEventDispatcherProvider::ScSetConsoleEventDispatcher( this );
if (sc)
goto Error;
m_fInitializing = false;
// check for all MMC prerequisites
sc = ScCheckMMCPrerequisites();
if (sc)
goto Error;
// Comment out below line when script engines hosted in mmc are enabled.
// sc = ScRunTestScript();
Cleanup:
return bRet;
Error:
MMCErrorBox(sc);
bRet = FALSE;
goto Cleanup;
}
//+-------------------------------------------------------------------
//
// Member: ScRunTestScript
//
// Synopsis: Test program to run a script. Once script input mechanisms
// are defined this can be removed.
//
// Arguments: None
//
// Returns: SC
//
//--------------------------------------------------------------------
SC CAMCApp::ScRunTestScript ()
{
DECLARE_SC(sc, _T("CAMCApp::ScRunTestScript"));
// The Running of scripts is enabled only in debug mode.
bool bEnableScriptEngines = false;
#ifdef DBG
if (tagEnableScriptEngines.FAny())
bEnableScriptEngines = true;
#endif
if (!bEnableScriptEngines)
return sc;
// Get the IDispatch from MMC object, the script engine needs
// the IUnknown to top level object & the ITypeInfo ptr.
CComPtr<_Application> spApplication;
sc = ScGet_Application(&spApplication);
if (sc)
return sc;
IDispatchPtr spDispatch = NULL;
sc = spApplication->QueryInterface(IID_IDispatch, (LPVOID*)&spDispatch);
if (sc)
return sc;
// The CScriptHostMgr should be instead created on the stack (as we have only
// one per app) and destroyed with app. This change can be made once we decide
// how & when the script host will be used to execute the scripts.
CScriptHostMgr* pMgr = new CScriptHostMgr(spDispatch);
if (NULL == pMgr)
return (sc = E_OUTOFMEMORY);
LPOLESTR pszScript = L"set WShShell=CreateObject(\"WScript.Shell\")\n\
WshShell.Popup(\"Anand\")\n\
Select Case WshShell.Popup(\"Anand\",5,\"Ganesan\", vbyesnocancel)\n\
End Select";
tstring strExtn = _T(".vbs");
sc = pMgr->ScExecuteScript(pszScript, strExtn);
tstring strFile = _T("E:\\newnt\\admin\\mmcdev\\test\\script\\MMCStartupScript.vbs");
sc = pMgr->ScExecuteScript(strFile);
delete pMgr;
return (sc);
}
// App command to run the dialog
void CAMCApp::OnAppAbout()
{
/*
* load the title of the about dialog
*/
CString strTitle (MAKEINTRESOURCE (IDS_APP_NAME));
CString strVersion (MAKEINTRESOURCE (IDS_APP_VERSION));
strTitle += _T(" ");
strTitle += strVersion;
ShellAbout(*AfxGetMainWnd(), strTitle, NULL, LoadIcon(IDR_MAINFRAME));
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::OnFileNewInUserMode
*
* PURPOSE: Do nothing in user mode when CTRL+N is pressed.
* This handler prevents the hotkey from going to any WebBrowser controls
*
* RETURNS:
* void
*
*+-------------------------------------------------------------------------*/
void CAMCApp::OnFileNewInUserMode()
{
MessageBeep(-1);
}
//+-------------------------------------------------------------------
//
// Member: ScShowHtmlHelp
//
// Synopsis: Initialize and then call Help control to display help topic.
//
// Arguments: [pszFile] - File to display.
// [dwData] - Depends on uCommand for HH_DISPLAY_TOPIC it
// is help topic string.
//
// Note: The command is always HH_DISPLAY_TOPIC. HWND is NULL so that
// Help can get behind MMC window.
// See ScUnintializeHelpControl's Note for more info.
//
// Returns: SC
//
//--------------------------------------------------------------------
SC CAMCApp::ScShowHtmlHelp(LPCTSTR pszFile, DWORD_PTR dwData)
{
DECLARE_SC(sc, _T("CAMCApp::ScInitializeHelpControl"));
/*
* displaying HtmlHelp might take awhile, so show a wait cursor
*/
CWaitCursor wait;
if (! m_bHelpInitialized)
HtmlHelp (NULL, NULL, HH_INITIALIZE, (DWORD_PTR)&m_dwHelpCookie);
// No documented return value for HH_INITIALIZE so always assume
// Initialize is successful.
m_bHelpInitialized = true;
HtmlHelp (NULL, pszFile, HH_DISPLAY_TOPIC, dwData);
return sc;
}
//+-------------------------------------------------------------------
//
// Member: ScUninitializeHelpControl
//
// Synopsis: UnInitialize the help if it was initialized by MMC.
//
// Note: The help-control calls OleInitialize & OleUninitialize
// in its DllMain. If a snapin creates any free threaded object
// on main thread (STA), the OLE creates an MTA.
// The last OleUninitialize does OLEProcessUninitialize in which
// then OLE waits for the above MTA to cleanup and return.
// By the time help-control does last OleUninitialize in its
// DllMain the MTA is already terminated so OLE waits for this
// MTA to signal which it never would.
// We call HtmlHelp(.. HH_UNINITIALIZE..) to force help control
// to uninit so that MMC does last OleUninit.
// (This will not solve the problem of snapins calling help directly).
//
// Arguments:
//
// Returns: SC, S_FALSE if already uninitialized else S_OK.
//
//--------------------------------------------------------------------
SC CAMCApp::ScUninitializeHelpControl()
{
DECLARE_SC(sc, _T("CAMCApp::ScUninitializeHelpControl"));
if (false == m_bHelpInitialized)
return (sc = S_FALSE);
HtmlHelp (NULL, NULL, HH_UNINITIALIZE, m_dwHelpCookie);
m_bHelpInitialized = false;
m_dwHelpCookie = 0;
return sc;
}
BOOL CAMCApp::InitializeOLE()
{
if (FAILED(::OleInitialize(NULL)))
return FALSE;
return (m_bOleInitialized = TRUE);
}
void CAMCApp::DeinitializeOLE()
{
// Uninit help, see ScUninitializeHelpControl note.
SC sc = ScUninitializeHelpControl();
if (sc)
{
TraceError(_T("Uninit Help control failed"), sc);
}
// Forced DllCanUnloadNow before mmc exits.
::CoFreeUnusedLibraries();
if (m_bOleInitialized == TRUE)
{
::OleUninitialize();
m_bOleInitialized = FALSE;
}
}
/////////////////////////////////////////////////////////////////////////////
// CAMCApp diagnostics
#ifdef _DEBUG
void CAMCApp::AssertValid() const
{
CWinApp::AssertValid();
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CAMCApp commands
int CAMCApp::ExitInstance()
{
DECLARE_SC(sc, TEXT("CAMCApp::ExitInstance"));
// if the main window is not destroyed yet - do that now.
// since we need to get rid of all the objects before denitializing OLE.
// It is not requred in most cases, since usually quit starts from closing the mainframe,
// but in cases like system shut down it will come here with a valid window
// See WindowsBug(ntbug9) #178858
if ( ::IsWindow( AfxGetMainWnd()->GetSafeHwnd() ) )
{
AfxGetMainWnd()->DestroyWindow();
}
// disconnect the pointers to event dispatcher
sc = CConsoleEventDispatcherProvider::ScSetConsoleEventDispatcher( NULL );
if (sc)
sc.TraceAndClear();
// release cached application object
m_sp_Application = NULL;
// MFC's class factories registration is automatically revoked by MFC itself
if (RunEmbedded() || RunAutomated())
_Module.RevokeClassObjects(); // Revoke class factories for ATL
_Module.Term(); // clanup ATL GLobal Module
// Ask node manager to cleanup what's got cached
CComPtr<IComCacheCleanup> spComCacheCleanup;
HRESULT hr = spComCacheCleanup.CoCreateInstance(CLSID_ComCacheCleanup, NULL, MMC_CLSCTX_INPROC);
if (hr == S_OK)
{
spComCacheCleanup->ReleaseCachedOleObjects();
spComCacheCleanup.Release();
}
// by now EVERY reference should be released
ASSERT(_Module.GetLockCount() == 0 && "Outstanding references still exist on exit");
DeinitializeOLE();
/*
* uninitialize Fusion
*/
SHFusionUninitialize();
int iRet = CWinApp::ExitInstance();
DEBUG_VERIFY_INSTANCE_COUNT(CAMCTreeView);
DEBUG_VERIFY_INSTANCE_COUNT(CAMCListView);
DEBUG_VERIFY_INSTANCE_COUNT(CCCListViewCtrl);
return iRet;
}
BOOL CAMCApp::PreTranslateMessage(MSG* pMsg)
{
// Give HTML help a chance to crack the message. (Bug# 119355 & 206909).
if ( m_bHelpInitialized && HtmlHelp(NULL, NULL, HH_PRETRANSLATEMESSAGE, (DWORD_PTR)pMsg) )
return TRUE;
// let all of the hook windows have a crack at this message
WindowListIterator it = m_TranslateMessageHookWindows.begin();
while (it != m_TranslateMessageHookWindows.end())
{
HWND hwndHook = *it;
CWnd* pwndHook = CWnd::FromHandlePermanent (hwndHook);
// if this window is no longer valid, or it's not a permanent
// window, remove it from the list
if (!IsWindow (hwndHook) || (pwndHook == NULL))
it = m_TranslateMessageHookWindows.erase (it);
else
{
// otherwise if the hook window handled the message, bail
if (pwndHook->PreTranslateMessage (pMsg))
return (TRUE);
++it;
}
}
// give the MMC defined main window accelerators a crack at the message
if (m_Accel.TranslateAccelerator (AfxGetMainWnd()->GetSafeHwnd(), pMsg))
return TRUE;
return CWinApp::PreTranslateMessage(pMsg);
}
/*+-------------------------------------------------------------------------*
* CAMCApp::SaveUserDirectory
*
*
*--------------------------------------------------------------------------*/
void CAMCApp::SaveUserDirectory(LPCTSTR pszUserDir)
{
// if we got an empty string, change the pointer to NULL so
// the entry will be removed from the registry
if ((pszUserDir != NULL) && (lstrlen(pszUserDir) == 0))
pszUserDir = NULL;
WriteProfileString (m_szSettingsSection, m_szUserDirectoryEntry,
pszUserDir);
}
/*+-------------------------------------------------------------------------*
* CAMCApp::GetUserDirectory
*
*
*--------------------------------------------------------------------------*/
CString CAMCApp::GetUserDirectory(void)
{
return (GetProfileString (m_szSettingsSection, m_szUserDirectoryEntry));
}
/*+-------------------------------------------------------------------------*
* CAMCApp::GetDefaultDirectory
*
*
*--------------------------------------------------------------------------*/
CString CAMCApp::GetDefaultDirectory(void)
{
static CString strDefaultDir;
if (strDefaultDir.IsEmpty())
{
LPITEMIDLIST pidl;
if (SUCCEEDED(SHGetSpecialFolderLocation(
AfxGetMainWnd()->GetSafeHwnd(),
CSIDL_ADMINTOOLS | CSIDL_FLAG_CREATE, &pidl)))
{
// Convert to path name
SHGetPathFromIDList (pidl, strDefaultDir.GetBuffer (MAX_PATH));
strDefaultDir.ReleaseBuffer ();
// Free IDList
LPMALLOC pMalloc;
if (SUCCEEDED(SHGetMalloc (&pMalloc)))
{
pMalloc->Free(pidl);
pMalloc->Release();
}
}
}
return (strDefaultDir);
}
/*+-------------------------------------------------------------------------*
* CAMCApp::SetDefaultDirectory
*
*
*--------------------------------------------------------------------------*/
void CAMCApp::SetDefaultDirectory(void)
{
// Only set default first time, so we don't override user selection
if (m_bDefaultDirSet)
return;
// Set the current directory to the default directory
CString strDirectory;
BOOL rc = FALSE;
strDirectory = GetDefaultDirectory ();
if (!strDirectory.IsEmpty())
rc = SetCurrentDirectory (strDirectory);
m_bDefaultDirSet = rc;
}
/*+-------------------------------------------------------------------------*
* CAMCApp::PumpMessage
*
*
*--------------------------------------------------------------------------*/
BOOL CAMCApp::PumpMessage()
{
m_nMessagePumpNestingLevel++;
MSG msg;
::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE);
if (msg.message == WM_CLOSE)
m_fCloseCameFromMainPump = true;
BOOL rc = CWinApp::PumpMessage();
if (m_fDelayCloseUntilIdle && (m_nMessagePumpNestingLevel == 1))
{
m_fCloseCameFromMainPump = true;
CMainFrame *pMainFrame = GetMainFrame();
if (pMainFrame)
pMainFrame->SendMessage (WM_CLOSE);
m_fDelayCloseUntilIdle = false;
}
m_fCloseCameFromMainPump = false;
m_nMessagePumpNestingLevel--;
ASSERT (m_nMessagePumpNestingLevel >= 0);
return (rc);
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::ScHelp
*
* PURPOSE: Displays help for the application.
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CAMCApp::ScHelp()
{
DECLARE_SC(sc, TEXT("CAMCApp::ScHelp"));
CMainFrame * pMainFrame = GetMainFrame();
if(!pMainFrame)
{
sc = E_UNEXPECTED;
return sc;
}
pMainFrame->OnHelpTopics();
return sc;
}
/*+-------------------------------------------------------------------------*
* CAMCApp::OnIdle
*
* WM_IDLE handler for CAMCApp.
*--------------------------------------------------------------------------*/
BOOL CAMCApp::OnIdle(LONG lCount)
{
SC sc;
CIdleTaskQueue * pQueue = GetIdleTaskQueue();
BOOL fMoreIdleWork = TRUE;
if(NULL == pQueue)
{
ASSERT(0 && "Should not come here.");
goto Error;
}
fMoreIdleWork = CWinApp::OnIdle(lCount);
if (!fMoreIdleWork)
{
CMainFrame *pMainFrame = GetMainFrame();
if (pMainFrame)
pMainFrame->OnIdle ();
}
/*
* if MFC doesn't have any more idle work to do,
* check our idle task queue (if we have one)
*/
if (!fMoreIdleWork && (pQueue != NULL))
{
LONG_PTR cIdleTasks;
pQueue->ScGetTaskCount (&cIdleTasks);
if(sc)
goto Error;
/*
* do we have any idle tasks?
*/
if (cIdleTasks > 0)
{
SC sc = pQueue->ScPerformNextTask();
if(sc)
goto Error;
/*
* this idle task may have added others; refresh the count
*/
sc = pQueue->ScGetTaskCount(&cIdleTasks);
if(sc)
goto Error;
}
/*
* do we have any more idle work to do?
*/
fMoreIdleWork = (cIdleTasks > 0);
}
if (!fMoreIdleWork)
{
// this code is to trigger MMC exit sequence when it
// is under the script control and the last reference is released.
// (we do not use MFC [which would simply delete the mainframe] to do that)
if ( !IsUnderUserControl() && CMMCStrongReferences::LastRefReleased() )
{
// we are in script control mode and all references are released
// a good time to say goodbye
CMainFrame *pMainFrame = GetMainFrame();
sc = ScCheckPointers(pMainFrame, E_UNEXPECTED);
if (sc)
goto Error;
// disabled main window will probably mean we are under modal dialog
// wait until it is dismissed ( and try again )
if (pMainFrame->IsWindowEnabled())
{
// here is the deal: if MMC is shown - we will initiate the exit sequence,
// but put into the user mode first, so if user chooses to cancel it - it will have
// the control over the application. He will also have to handle save request if
// something has changed in the console
if ( pMainFrame->IsWindowVisible() )
{
if ( !m_fUnderUserControl )
SetUnderUserControl();
pMainFrame->PostMessage(WM_CLOSE);
}
else
{
// if the application is hidden it should wait until user closes all open property sheets.
// since it will come back here, waiting means just doing nothing at this point.
if ( !FArePropertySheetsOpen(NULL, false /*bBringToFrontAndAskToClose*/ ) )
{
// if there are not sheets open - we must die silently
CAMCDoc* const pDoc = CAMCDoc::GetDocument();
if(pDoc == NULL)
{
sc = E_POINTER;
//fall thru; (need to close anyway)
}
else
{
// discard document without asking to save
pDoc->OnCloseDocument();
}
// say goodbye
pMainFrame->PostMessage(WM_CLOSE);
}
}
}
}
}
Cleanup:
return (fMoreIdleWork);
Error:
TraceError(TEXT("CAMCApp::OnIdle"), sc);
goto Cleanup;
}
//+-------------------------------------------------------------------
//
// Member: InitializeMode
//
// Synopsis: Set the mode and load the menus, accelerator tables.
//
// Arguments: [eMode] - New application mode.
//
// Returns: None.
//
//--------------------------------------------------------------------
void CAMCApp::InitializeMode (ProgramMode eMode)
{
SetMode(eMode);
UpdateFrameWindow(false);
}
//+-------------------------------------------------------------------
//
// Member: SetMode
//
// Synopsis: Set the mode.
//
// Note: Call UpdateFrameWindow some time soon to update
// menus/toolbars for this mode.
// Cannot do this in this method. This is called
// from CAMCDoc::LoadAppMode. The CAMCDoc::LoadFrame
// calls the UpdateFrameWindow.
//
// Arguments: [eMode] - New application mode.
//
// Returns: None.
//
//--------------------------------------------------------------------
void CAMCApp::SetMode (ProgramMode eMode)
{
ASSERT (IsValidProgramMode (eMode));
if (m_fAuthorModeForced)
{
ASSERT (m_eMode == eMode_Author);
ASSERT (GetMainFrame()->IsMenuVisible ());
}
else
m_eMode = eMode;
}
//+-------------------------------------------------------------------
//
// Member: UpdateFrameWindow
//
// Synopsis: Load the menu/accelerator tables and update
// them if loaded from console file.
//
// Note: Call UpdateFrameWindow some time soon after
// calling SetMode to update menus/toolbars for this mode.
// This is called from CAMCDoc::LoadFrame.
//
// Arguments: [bUpdate] - BOOL
// We need to update the toolbar/menus only
// if loaded from console file
//
// Returns: None.
//
//--------------------------------------------------------------------
void CAMCApp::UpdateFrameWindow(bool bUpdate)
{
static const struct ModeDisplayParams
{
int nResourceID;
bool fShowToolbar;
} aDisplayParams[eMode_Count] =
{
{ IDR_AMCTYPE, true }, // eMode_Author
{ IDR_AMCTYPE_USER, false }, // eMode_User
{ IDR_AMCTYPE_MDI_USER, false }, // eMode_User_MDI
{ IDR_AMCTYPE_SDI_USER, false }, // eMode_User_SDI
};
if (m_fAuthorModeForced)
{
ASSERT (m_eMode == eMode_Author);
ASSERT (GetMainFrame()->IsMenuVisible ());
return;
}
m_Menu.DestroyMenu ();
m_Accel.DestroyAcceleratorTable ();
VERIFY (m_Menu.LoadMenu (aDisplayParams[m_eMode].nResourceID));
m_Accel.LoadAccelerators (aDisplayParams[m_eMode].nResourceID);
if (bUpdate)
{
CMainFrame *pMainFrame = GetMainFrame();
ASSERT (pMainFrame != NULL);
ASSERT_VALID (pMainFrame);
CMDIChildWnd* pwndActive = pMainFrame ? pMainFrame->MDIGetActive () : NULL;
// bypass CMainFrame::OnUpdateFrameMenu so CMainFrame::NotifyMenuChanged
// doesn't get called twice and remove the new menu entirely
if (pwndActive != NULL)
pwndActive->OnUpdateFrameMenu (TRUE, pwndActive, m_Menu);
else if (pMainFrame)
pMainFrame->OnUpdateFrameMenu (m_Menu);
if (m_eMode == eMode_User_SDI)
{
if (pwndActive != NULL)
pwndActive->MDIMaximize ();
if (pMainFrame)
AppendToSystemMenu (pMainFrame, eMode_User_SDI);
}
if (pMainFrame)
pMainFrame->ShowMenu (true /*Always show menu*/);
}
}
/*+-------------------------------------------------------------------------*
* IsInContainer
*
*
*--------------------------------------------------------------------------*/
template<class InputIterator, class T>
bool Find (InputIterator itFirst, InputIterator itLast, const T& t)
{
return (std::find (itFirst, itLast, t) != itLast);
}
/*+-------------------------------------------------------------------------*
* CAMCApp::HookPreTranslateMessage
*
* Adds a window the the list of windows that get prioritized cracks at
* PreTranslateMessage. Hooks set later get priority over earlier hooks.
*--------------------------------------------------------------------------*/
void CAMCApp::HookPreTranslateMessage (CWnd* pwndHook)
{
HWND hwndHook = pwndHook->GetSafeHwnd();
ASSERT (IsWindow (hwndHook));
// this only makes sense for permanent windows
ASSERT (CWnd::FromHandlePermanent(hwndHook) == pwndHook);
/*
* Put the hook window at the front of the hook list. We're preserving
* the HWND instead of the CWnd* so we don't have unnecessary list<>
* code generated. We already use a list<HWND> for m_DelayedUpdateWindows,
* so using list<HWND> here doesn't cause any more code to be generated.
*/
if (!Find (m_TranslateMessageHookWindows.begin(),
m_TranslateMessageHookWindows.end(),
hwndHook))
{
m_TranslateMessageHookWindows.push_front (hwndHook);
}
}
/*+-------------------------------------------------------------------------*
* CAMCApp::UnhookPreTranslateMessage
*
*
*--------------------------------------------------------------------------*/
void CAMCApp::UnhookPreTranslateMessage (CWnd* pwndUnhook)
{
HWND hwndUnhook = pwndUnhook->GetSafeHwnd();
ASSERT (IsWindow (hwndUnhook));
WindowListIterator itEnd = m_TranslateMessageHookWindows.end();
WindowListIterator itFound = std::find (m_TranslateMessageHookWindows.begin(),
itEnd, hwndUnhook);
if (itFound != itEnd)
m_TranslateMessageHookWindows.erase (itFound);
}
/*+-------------------------------------------------------------------------*
* CAMCApp::GetIdleTaskQueue
*
* Returns the IIdleTaskQueue interface for the application, creating it
* if necessary.
*--------------------------------------------------------------------------*/
CIdleTaskQueue * CAMCApp::GetIdleTaskQueue ()
{
return &m_IdleTaskQueue;
}
/*+-------------------------------------------------------------------------*
* ScExpandEnvironmentStrings
*
* Expands the any environment string (e.g. %SystemRoot%) in the input
* string, in place.
*--------------------------------------------------------------------------*/
SC ScExpandEnvironmentStrings (CString& str)
{
DECLARE_SC (sc, _T("ScExpandEnvironmentStrings"));
if (str.Find(_T('%')) != -1)
{
TCHAR szBuffer[MAX_PATH];
if (!ExpandEnvironmentStrings (str, szBuffer, countof(szBuffer)))
return (sc.FromLastError());
str = szBuffer;
}
return (sc);
}
/*+-------------------------------------------------------------------------*
* ScCreateDumpSnapins
*
* Creates a CLSID_MMCDocConfig object, opens it on the supplied filename,
* and returns a pointer to the IDumpSnapins interface on the object.
*--------------------------------------------------------------------------*/
SC ScCreateDumpSnapins (
CString& strConsoleFile, /* I/O:console file */
IDumpSnapins** ppDumpSnapins) /* O:IDumpSnapins interface */
{
DECLARE_SC (sc, _T("ScCreateDumpSnapins"));
/*
* validate input
*/
sc = ScCheckPointers (ppDumpSnapins);
if (sc)
return (sc);
*ppDumpSnapins = NULL;
/*
* create a doc config object
*/
IDocConfigPtr spDocConfig;
sc = spDocConfig.CreateInstance (CLSID_MMCDocConfig);
if (sc)
return (sc);
/*
* expand any embedded environment strings in the console filename
*/
sc = ScExpandEnvironmentStrings (strConsoleFile);
if (sc)
return (sc);
/*
* open the console file
*/
sc = spDocConfig->OpenFile (::ATL::CComBSTR (strConsoleFile));
if (sc)
return (sc);
/*
* get the IDumpSnapins interface
*/
sc = spDocConfig.QueryInterface (IID_IDumpSnapins, *ppDumpSnapins);
if (sc)
return (sc);
return (sc);
}
/*+-------------------------------------------------------------------------*
* CAMCApp::DumpConsoleFile
*
*
*--------------------------------------------------------------------------*/
HRESULT CAMCApp::DumpConsoleFile (CString strConsoleFile, CString strDumpFile)
{
DECLARE_SC (sc, _T("CAMCApp::DumpConsoleFile"));
const CString* pstrFileWithError = &strConsoleFile;
/*
* get an IDumpSnapins interface on this console file
*/
IDumpSnapinsPtr spDumpSnapins;
sc = ScCreateDumpSnapins (strConsoleFile, &spDumpSnapins);
if (sc)
goto Error;
sc = ScCheckPointers (spDumpSnapins, E_UNEXPECTED);
if (sc)
goto Error;
/*
* expand the dump filename if necessary
*/
sc = ScExpandEnvironmentStrings (strDumpFile);
if (sc)
goto Error;
/*
* If there's no directory specifier on the dump file, put a "current
* directory" marker on it. We do this to prevent WritePrivateProfile*
* from putting the file in the Windows directory.
*/
if (strDumpFile.FindOneOf(_T(":\\")) == -1)
strDumpFile = _T(".\\") + strDumpFile;
/*
* future file-related errors will pertain to the dump file
* (see Error handler)
*/
pstrFileWithError = &strDumpFile;
/*
* wipe out the existing file, if any
*/
if ((GetFileAttributes (strDumpFile) != 0xFFFFFFFF) && !DeleteFile (strDumpFile))
{
sc.FromLastError();
goto Error;
}
/*
* dump the contents of the console file
*/
sc = spDumpSnapins->Dump (strDumpFile);
if (sc)
goto Error;
return (sc.ToHr());
Error:
MMCErrorBox (*pstrFileWithError, sc);
return (sc.ToHr());
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnNewDocument
*
* PURPOSE: Emits script event for application object
*
* PARAMETERS:
* CAMCDoc *pDocument [in] document being created/opened
* BOOL bLoadedFromConsole [in] if document is loaded from file
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnNewDocument(CAMCDoc *pDocument, BOOL bLoadedFromConsole)
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnNewDocument"));
// check if there are "listeners"
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks;
return sc;
// construct document com object
DocumentPtr spComDoc;
sc = pDocument->ScGetMMCDocument(&spComDoc);
if (sc)
return sc;
// check pointer
sc = ScCheckPointers(spComDoc, E_POINTER);
if (sc)
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnDocumentOpen (spComDoc , bLoadedFromConsole == FALSE));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnQuitApp
*
* PURPOSE: Emits script event for application object
*
* PARAMETERS:
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnQuitApp()
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnQuitApp"));
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnQuit (m_sp_Application));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnCloseView
*
* PURPOSE: Script event firing helper. Invoked when the view is closed
*
* PARAMETERS:
* CAMCView *pView [in] - view being closed
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnCloseView( CAMCView *pView )
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnCloseView"));
// parameter check
sc = ScCheckPointers(pView);
if (sc)
return sc;
// check if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
// construct view com object
ViewPtr spView;
sc = pView->ScGetMMCView(&spView);
if (sc)
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnViewClose (spView));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnViewChange
*
* PURPOSE: Script event firing helper. Invoked when scope selection change
*
* PARAMETERS:
* CAMCView *pView [in] affected view
* HNODE hNode [in] new selected scope node
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnViewChange( CAMCView *pView, HNODE hNode )
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnViewChange"));
// parameter check
sc = ScCheckPointers(pView);
if (sc)
return sc;
// check if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
// construct view com object
ViewPtr spView;
sc = pView->ScGetMMCView(&spView);
if (sc)
return sc;
// construct Node com object
NodePtr spNode;
sc = pView->ScGetScopeNode( hNode, &spNode );
if (sc)
return sc;
// fire script event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnViewChange(spView, spNode));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnResultSelectionChange
*
* PURPOSE: Script event firing helper. Invoked when result selection change
*
* PARAMETERS:
* CAMCView *pView [in] - affected view
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnResultSelectionChange( CAMCView *pView )
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnResultSelectionChange"));
// parameter check
sc = ScCheckPointers(pView);
if (sc)
return sc;
// check if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
// construct view com object
ViewPtr spView;
sc = pView->ScGetMMCView(&spView);
if (sc)
return sc;
// construct Node com object
NodesPtr spNodes;
sc = pView->Scget_Selection( &spNodes );
if (sc)
return sc;
// fire script event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnSelectionChange(spView, spNodes));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CMMCApplication::ScOnContextMenuExecuted
*
* PURPOSE: called when the context menu is executed to fire the event to script
*
* PARAMETERS:
* PMENUITEM pMenuItem - menu item (note: it may be NULL if menu item is gone)
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnContextMenuExecuted( PMENUITEM pMenuItem )
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnContextMenuExecuted"));
// see if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents, OnContextMenuExecuted( pMenuItem ) );
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CAMCApp::ScOnListViewItemUpdated
*
* PURPOSE:
*
* PARAMETERS:
* CAMCView * pView :
* int nIndex :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CAMCApp::ScOnListViewItemUpdated(CAMCView *pView , int nIndex)
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnListViewItemUpdated"));
// parameter check
sc = ScCheckPointers(pView);
if (sc)
return sc;
// check if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
// construct view com object
ViewPtr spView;
sc = pView->ScGetMMCView(&spView);
if (sc)
return sc;
// fire script event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnListUpdated(spView));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnSnapinAdded
*
* PURPOSE: Script event firing helper. Implements interface accessible from
* node manager
*
* PARAMETERS:
* PSNAPIN pSnapIn [in] - snapin added to the console
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnSnapinAdded(CAMCDoc *pAMCDoc, PSNAPIN pSnapIn)
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnSnapinAdded"));
// parameter check
sc = ScCheckPointers(pAMCDoc, pSnapIn);
if (sc)
return sc;
// see if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
DocumentPtr spDocument;
sc = pAMCDoc->ScGetMMCDocument(&spDocument);
if (sc)
return sc;
// check
sc = ScCheckPointers(spDocument, E_UNEXPECTED);
if (sc)
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnSnapInAdded (spDocument, pSnapIn));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnSnapinRemoved
*
* PURPOSE: Script event firing helper. Implements interface accessible from
* node manager
*
* PARAMETERS:
* PSNAPIN pSnapIn [in] - snapin removed from console
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnSnapinRemoved(CAMCDoc *pAMCDoc, PSNAPIN pSnapIn)
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnSnapinRemoved"));
// parameter check
sc = ScCheckPointers(pAMCDoc, pSnapIn);
if (sc)
return sc;
// see if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
DocumentPtr spDocument;
sc = pAMCDoc->ScGetMMCDocument(&spDocument);
if (sc)
return sc;
// check
sc = ScCheckPointers(spDocument, E_UNEXPECTED);
if (sc)
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnSnapInRemoved (spDocument, pSnapIn));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnNewView
*
* PURPOSE: Script event firing helper
*
* PARAMETERS:
* CAMCView *pView [in] - created view
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnNewView(CAMCView *pView)
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnNewView"));
// parameter check
sc = ScCheckPointers(pView);
if (sc)
return sc;
// see if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
// construct View com object
ViewPtr spView;
sc = pView->ScGetMMCView(&spView);
if (sc)
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnNewView(spView));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::OnCloseDocument
*
* PURPOSE: Helper for invoking com event
*
* PARAMETERS:
* CAMCDoc *pAMCDoc [in] - document being closed
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnCloseDocument(CAMCDoc *pAMCDoc)
{
DECLARE_SC(sc, TEXT("CAMCApp::OnCloseDocument"));
// parameter check
sc = ScCheckPointers(pAMCDoc);
if (sc)
return sc;
// see if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
DocumentPtr spDocument;
sc = pAMCDoc->ScGetMMCDocument(&spDocument);
if (sc)
return sc;
// check
sc = ScCheckPointers(spDocument, E_UNEXPECTED);
if (sc)
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnDocumentClose (spDocument));
if (sc)
sc.TraceAndClear(); // failure to issue the com event is not critical to this action
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::ScOnToolbarButtonClicked
*
* PURPOSE: Observed toolbar event - used to fire com event
*
* PARAMETERS:
* CAMCView *pAMCView - [in] view which toobar is executed
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC CAMCApp::ScOnToolbarButtonClicked( )
{
DECLARE_SC(sc, TEXT("CAMCApp::ScOnToolbarButtonClicked"));
// see if we have sinks connected
sc = ScHasSinks(m_sp_Application, AppEvents);
if (sc)
return sc;
if (sc == SC(S_FALSE)) // no sinks
return sc;
// fire the event
sc = ScFireComEvent(m_sp_Application, AppEvents , OnToolbarButtonClicked ( ));
if (sc)
sc.TraceAndClear(); // ignore the error - should not affect main behavior
return sc;
}
/***************************************************************************\
*
* METHOD: CAMCApp::SetUnderUserControl
*
* PURPOSE: puts application into user control/script control mode
* implements Application.UserControl property
*
* PARAMETERS:
* bool bUserControl [in] true == set user control
*
* RETURNS:
* void
*
\***************************************************************************/
void CAMCApp::SetUnderUserControl(bool bUserControl /* = true */ )
{
m_fUnderUserControl = bUserControl;
AfxOleSetUserCtrl(bUserControl); // allow MFC to know that
if (bUserControl)
{
// make sure application is visible if it's under user control
CMainFrame *pMainFrame = GetMainFrame();
if(pMainFrame && !pMainFrame->IsWindowVisible())
{
pMainFrame->ShowWindow(SW_SHOW);
}
}
}
#ifdef MMC_WIN64
/*+-------------------------------------------------------------------------*
* CompareBasicSnapinInfo
*
* Implements a less-than comparison for CBasicSnapinInfo, based solely on
* the CLSID. Returns true if the CLSID for bsi1 is less than the CLSID
* for bsi2, false otherwise.
*--------------------------------------------------------------------------*/
bool CompareBasicSnapinInfo (const CBasicSnapinInfo& bsi1, const CBasicSnapinInfo& bsi2)
{
return (bsi1.m_clsid < bsi2.m_clsid);
}
/*+-------------------------------------------------------------------------*
* ScDetermineArchitecture
*
* Determines whether MMC64 (which is currently executing) should chain
* to MMC32. This will occur in one of three situations:
*
* 1. The "-32" command line parameter was specified.
*
* 2. A console file was specified on the command line, and it contains
* one or more snap-ins that were not registered in the 64-bit HKCR
* hive, but all snap-ins are registered in the 32-bit HKCR hive.
*
* 3. A console file was specified on the command line, and it contained
* one or more snap-ins that were not registered in the 64-bit HKCR
* hive, and one or more snap-ins that are not registered in the 32-bit
* HKCR hive. In this case we'll do one of three things:
*
* a. If the set of unavailable 64-bit snap-ins is a subset of the
* set of unavailable 32-bit snap-ins, the 64-bit console will be
* more functional than the 32-bit console, so we'll run MMC64.
*
* b. If the set of unavailable 32-bit snap-ins is a subset of the
* set of unavailable 64-bit snap-ins, the 32-bit console will be
* more functional than the 64-bit console, so we'll run MMC32.
*
* c. If neither a. or b. is true, we'll display UI asking which
* version of MMC to run.
*
* Returns:
* eArch == eArch_64bit - 64-bit MMC is needed (or an error occurred)
* eArch == eArch_32bit - 32-bit MMC is needed
* eArch == eArch_None - user cancelled the operation
*--------------------------------------------------------------------------*/
SC ScDetermineArchitecture (const CMMCCommandLineInfo& rCmdInfo, eArchitecture& eArch)
{
DECLARE_SC (sc, _T("ScDetermineArchitecture"));
/*
* default to 64-bit
*/
eArch = eArch_64bit;
/*
* Case 0: Was "-64" specified on the command line? 64-bit needed
*/
if (rCmdInfo.m_eArch == eArch_64bit)
{
Trace (tag32BitTransfer, _T("\"-64\" parameter specified, 64-bit MMC needed"));
return (sc);
}
/*
* Case 1: Was "-32" specified on the command line? 32-bit needed
*/
if (rCmdInfo.m_eArch == eArch_32bit)
{
Trace (tag32BitTransfer, _T("\"-32\" parameter specified, 32-bit MMC needed"));
eArch = eArch_32bit;
return (sc);
}
/*
* No file on the command line? 64-bit needed
*/
if (rCmdInfo.m_nShellCommand != CCommandLineInfo::FileOpen)
{
Trace (tag32BitTransfer, _T("No console file specified, 64-bit MMC needed"));
return (sc);
}
/*
* Cases 2 and 3: Analyze the specified console file
*/
Trace (tag32BitTransfer, _T("Analyzing snap-ins in \"%s\""), (LPCTSTR) rCmdInfo.m_strFileName);
/*
* get an IDumpSnapins interface so we can analyze the console file
*/
IDumpSnapinsPtr spDumpSnapins;
CString strConsoleFile = rCmdInfo.m_strFileName;
sc = ScCreateDumpSnapins (strConsoleFile, &spDumpSnapins);
if (sc)
return (sc);
sc = ScCheckPointers (spDumpSnapins, E_UNEXPECTED);
if (sc)
return (sc);
/*
* analyze the 64-bit snap-ins in this console
*/
CAvailableSnapinInfo asi64(false);
sc = spDumpSnapins->CheckSnapinAvailability (asi64);
if (sc)
return (sc);
/*
* if no snap-ins are unavailable in 64-bit form, no need for MMC32
*/
if (asi64.m_vAvailableSnapins.size() == asi64.m_cTotalSnapins)
{
Trace (tag32BitTransfer, _T("All snapins are available in 64-bit form, 64-bit MMC needed"));
return (sc);
}
/*
* analyze the 32-bit snap-ins in this console
*/
CAvailableSnapinInfo asi32(true);
sc = spDumpSnapins->CheckSnapinAvailability (asi32);
if (sc)
return (sc);
/*
* Case 2: If no snap-ins are unavailable in 32-bit form, 32-bit needed
*/
if (asi32.m_vAvailableSnapins.size() == asi32.m_cTotalSnapins)
{
Trace (tag32BitTransfer, _T("All snapins are available in 32-bit form, 32-bit MMC needed"));
eArch = eArch_32bit;
return (sc);
}
/*
* std::includes depends on its ranges being sorted, so make sure
* that's the case
*/
std::sort (asi32.m_vAvailableSnapins.begin(), asi32.m_vAvailableSnapins.end(), CompareBasicSnapinInfo);
std::sort (asi64.m_vAvailableSnapins.begin(), asi64.m_vAvailableSnapins.end(), CompareBasicSnapinInfo);
/*
* Case 3a: If the set of available 64-bit snap-ins is a
* superset of the set of available 32-bit snap-ins, run MMC64
*/
if (std::includes (asi64.m_vAvailableSnapins.begin(), asi64.m_vAvailableSnapins.end(),
asi32.m_vAvailableSnapins.begin(), asi32.m_vAvailableSnapins.end(),
CompareBasicSnapinInfo))
{
Trace (tag32BitTransfer, _T("The set of available 64-bit snapins is a superset of..."));
Trace (tag32BitTransfer, _T("...the set of available 32-bit snapins, 64-bit MMC needed"));
return (sc);
}
/*
* Case 3b: If the set of available 32-bit snap-ins is a
* superset of the set of available 64-bit snap-ins, run MMC32
*/
if (std::includes (asi32.m_vAvailableSnapins.begin(), asi32.m_vAvailableSnapins.end(),
asi64.m_vAvailableSnapins.begin(), asi64.m_vAvailableSnapins.end(),
CompareBasicSnapinInfo))
{
Trace (tag32BitTransfer, _T("The set of available 32-bit snapins is a superset of..."));
Trace (tag32BitTransfer, _T("...the set of available 64-bit snapins, 32-bit MMC needed"));
eArch = eArch_32bit;
return (sc);
}
/*
* Case 3c: Ask the user which to run
*/
CArchitecturePicker dlg (rCmdInfo.m_strFileName, asi64, asi32);
if (dlg.DoModal() == IDOK)
{
eArch = dlg.GetArchitecture();
Trace (tag32BitTransfer, _T("User chose %d-bit, %d-bit MMC needed"), (eArch == eArch_32bit) ? 32 : 64, (eArch == eArch_32bit) ? 32 : 64);
}
else
{
Trace (tag32BitTransfer, _T("User chose to exit, terminating"));
eArch = eArch_None;
}
return (sc);
}
#endif // MMC_WIN64
#ifdef UNICODE
/*+-------------------------------------------------------------------------*
* ScLaunchMMC
*
* Launches a specific architecture of MMC (i.e. MMC32 from MMC64 or vice
* versa) with the same command line used to launch this process.
*
* Returns S_OK if the given architecture of MMC was launched successfully,
* or an error code if an error occurred.
*--------------------------------------------------------------------------*/
SC ScLaunchMMC (
eArchitecture eArch, /* I:desired architecture */
int nCmdShow) /* I:show state */
{
DECLARE_SC (sc, _T("ScLaunchMMC"));
CString strArgs;
int nFolder;
switch (eArch)
{
case eArch_64bit:
nFolder = CSIDL_SYSTEM;
break;
case eArch_32bit:
/*
* make sure we give MMC32 a "-32" argument so it won't defer
* to MMC64 again (see CAMCApp::InitInstance)
*/
strArgs = _T("-32 ");
nFolder = CSIDL_SYSTEMX86;
break;
default:
return (sc = E_INVALIDARG);
break;
}
/*
* Get the directory where MMC32 lives (%SystemRoot%\syswow64) and
* append the executable name
*/
CString strProgram;
sc = SHGetFolderPath (NULL, nFolder, NULL, 0, strProgram.GetBuffer(MAX_PATH));
if (sc)
return (sc);
strProgram.ReleaseBuffer();
strProgram += _T("\\mmc.exe");
/*
* disable file system redirection so MMC32 will be able to launch MMC64
*/
CWow64FilesystemRedirectionDisabler disabler (strProgram);
/*
* get the arguments for the original invocation of MMC, skipping
* argv[0] (the executable name) and any "-32" or "-64" parameters
*/
int argc;
CAutoGlobalPtr<LPWSTR> argv (CommandLineToArgvW (GetCommandLine(), &argc));
if (argv == NULL)
return (sc.FromLastError());
for (int i = 1; i < argc; i++)
{
CString strArg = argv[i];
if ((strArg != _T("-32")) && (strArg != _T("/32")) &&
(strArg != _T("-64")) && (strArg != _T("/64")))
{
strArgs += _T("\"") + strArg + _T("\" ");
}
}
/*
* start the requested architecture of MMC
*/
Trace (tag32BitTransfer, _T("Attempting to run: %s %s"), (LPCTSTR) strProgram, (LPCTSTR) strArgs);
SHELLEXECUTEINFO sei = {0};
sei.cbSize = sizeof (sei);
sei.fMask = SEE_MASK_FLAG_NO_UI;
sei.lpFile = strProgram;
sei.lpParameters = strArgs;
sei.nShow = nCmdShow;
if (!ShellExecuteEx (&sei))
return (sc.FromLastError());
return (sc);
}
#endif // UNICODE
#ifndef MMC_WIN64
/*+-------------------------------------------------------------------------*
* IsWin64
*
* Returns true if we're running on Win64, false otherwise.
*--------------------------------------------------------------------------*/
bool IsWin64()
{
#ifdef UNICODE
/*
* get a pointer to kernel32!GetSystemWow64Directory
*/
HMODULE hmod = GetModuleHandle (_T("kernel32.dll"));
if (hmod == NULL)
return (false);
UINT (WINAPI* pfnGetSystemWow64Directory)(LPTSTR, UINT);
(FARPROC&)pfnGetSystemWow64Directory = GetProcAddress (hmod, "GetSystemWow64DirectoryW");
if (pfnGetSystemWow64Directory == NULL)
return (false);
/*
* if GetSystemWow64Directory fails and sets the last error to
* ERROR_CALL_NOT_IMPLEMENTED, we're on a 32-bit OS
*/
TCHAR szWow64Dir[MAX_PATH];
if (((pfnGetSystemWow64Directory)(szWow64Dir, countof(szWow64Dir)) == 0) &&
(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
{
return (false);
}
/*
* if we get here, we're on Win64
*/
return (true);
#else
/*
* non-Unicode platforms cannot be Win64
*/
return (false);
#endif // UNICODE
}
#endif // !MMC_WIN64
Reference in a new issue Copy permalink