You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1743 lines
51 KiB
1743 lines
51 KiB
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 1996-2002 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// AtlExtDll.cpp
|
|
//
|
|
// Abstract:
|
|
// Implementation of the Cluster Administrator extension classes.
|
|
//
|
|
// Author:
|
|
// David Potter (davidp) May 31, 1996
|
|
//
|
|
// Revision History:
|
|
//
|
|
// Notes:
|
|
// This file is intended to be included in a stub file which includes
|
|
// the ATL header files and defines _Module. This allos _Module to be
|
|
// defined as an instance of some application-specific class.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include <algorithm>
|
|
#include <CluAdmEx.h>
|
|
#include "CluAdmExHostSvr.h"
|
|
#include "AtlExtDll.h"
|
|
#include "AdmCommonRes.h"
|
|
#include "AtlExtMenu.h"
|
|
//#include "TraceTag.h"
|
|
#include "ExcOper.h"
|
|
#include "ClusObj.h"
|
|
#include "AtlBaseSheet.h"
|
|
#include "AtlBasePropSheet.h"
|
|
#include "AtlBaseWiz.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Global Variables
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if DBG
|
|
//CTraceTag g_tagExtDll(_T("UI"), _T("EXTENSION DLL"), 0);
|
|
//CTraceTag g_tagExtDllRef(_T("UI"), _T("EXTENSION DLL References"), 0);
|
|
#endif // DBG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// class CCluAdmExtensions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::Init
|
|
//
|
|
// Routine Description:
|
|
// Common initializer for all interfaces.
|
|
//
|
|
// Arguments:
|
|
// rlstrExtensions [IN] List of extension CLSID strings.
|
|
// pco [IN OUT] Cluster object to be administered.
|
|
// hfont [IN] Font for dialog text.
|
|
// hicon [IN] Icon for upper left corner.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by new.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExtensions::Init(
|
|
IN const CStringList & rlstrExtensions,
|
|
IN OUT CClusterObject * pco,
|
|
IN HFONT hfont,
|
|
IN HICON hicon
|
|
)
|
|
{
|
|
ATLASSERT( rlstrExtensions.size() > 0 );
|
|
ATLASSERT( pco != NULL );
|
|
|
|
CWaitCursor wc;
|
|
|
|
UnloadExtensions();
|
|
|
|
//
|
|
// Save parameters.
|
|
//
|
|
m_plstrExtensions = &rlstrExtensions;
|
|
m_pco = pco;
|
|
m_hfont = hfont;
|
|
m_hicon = hicon;
|
|
|
|
//
|
|
// Allocate a new Data Object.
|
|
//
|
|
m_pdoData = new CComObject< CCluAdmExDataObject >;
|
|
if ( m_pdoData == NULL )
|
|
{
|
|
goto MemoryError;
|
|
} // if: error allocating memory
|
|
m_pdoData->AddRef();
|
|
|
|
// Construct the Data Object.
|
|
Pdo()->Init( pco, GetUserDefaultLCID(), hfont, hicon );
|
|
|
|
// Allocate the extension list.
|
|
m_plextdll = new CCluAdmExDllList;
|
|
if ( m_plextdll == NULL )
|
|
{
|
|
goto MemoryError;
|
|
} // if: error allocating memory
|
|
ATLASSERT( Plextdll() != NULL );
|
|
|
|
//
|
|
// Loop through the extensions and load each one.
|
|
//
|
|
{
|
|
CComCluAdmExDll * pextdll = NULL;
|
|
CStringList::iterator itCurrent = rlstrExtensions.begin();
|
|
CStringList::iterator itLast = rlstrExtensions.end();
|
|
CCluAdmExDllList::iterator itDll;
|
|
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
//
|
|
// Allocate an extension DLL object and add it to the list.
|
|
//
|
|
pextdll = new CComCluAdmExDll;
|
|
if ( pextdll == NULL )
|
|
{
|
|
goto MemoryError;
|
|
} // if: error allocating memory
|
|
pextdll->AddRef();
|
|
itDll = Plextdll()->insert( Plextdll()->end(), pextdll );
|
|
try
|
|
{
|
|
pextdll->Init( *itCurrent, this );
|
|
} // try
|
|
catch ( CException * pe )
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
|
|
ATLASSERT( itDll != Plextdll()->end() );
|
|
Plextdll()->erase( itDll );
|
|
delete pextdll;
|
|
} // catch: CException
|
|
} // while: more items in the list
|
|
} // Loop through the extensions and load each one
|
|
|
|
Cleanup:
|
|
return;
|
|
|
|
MemoryError:
|
|
CNTException nte(
|
|
static_cast< DWORD >( E_OUTOFMEMORY ),
|
|
ADMC_IDS_INIT_EXT_PAGES_ERROR,
|
|
NULL, // pszOperArg1
|
|
NULL, // pszOperArg2
|
|
FALSE // bAutoDelete
|
|
);
|
|
nte.ReportError();
|
|
goto Cleanup;
|
|
|
|
} //*** CCluAdmExtensions::Init()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::UnloadExtensions
|
|
//
|
|
// Routine Description:
|
|
// Unload the extension DLL.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExtensions::UnloadExtensions( void )
|
|
{
|
|
//
|
|
// Delete all the extension DLL objects.
|
|
//
|
|
if ( Plextdll() != NULL )
|
|
{
|
|
CCluAdmExDllList::iterator itCurrent = Plextdll()->begin();
|
|
CCluAdmExDllList::iterator itLast = Plextdll()->end();
|
|
CComCluAdmExDll * pextdll;
|
|
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pextdll = *itCurrent;
|
|
pextdll->AddRef(); // See comment below.
|
|
pextdll->UnloadExtension();
|
|
if ( pextdll->m_dwRef != 2 )
|
|
{
|
|
Trace( g_tagError, _T("CCluAdmExtensions::UnloadExtensions() - Extension DLL has ref count = %d"), pextdll->m_dwRef );
|
|
} // if: not last reference
|
|
|
|
// We added a reference above. Combined with the reference that
|
|
// was added when the object was created, we typically will need
|
|
// to release two references. However, due to bogus code
|
|
// generated by earlier versions of the custom AppWizard where the
|
|
// extension was releasing the interface but not zeroing out its
|
|
// pointer in the error case, we may not need to release the
|
|
// second reference.
|
|
if ( pextdll->Release() != 0 )
|
|
{
|
|
pextdll->Release();
|
|
} // if: more references to release
|
|
} // while: more items in the list
|
|
delete m_plextdll;
|
|
m_plextdll = NULL;
|
|
} // if: there is a list of extensions
|
|
|
|
if ( m_pdoData != NULL )
|
|
{
|
|
if ( m_pdoData->m_dwRef != 1 )
|
|
{
|
|
Trace( g_tagError, _T("CCluAdmExtensions::UnloadExtensions() - Data Object has ref count = %d"), m_pdoData->m_dwRef );
|
|
} // if: not last reference
|
|
m_pdoData->Release();
|
|
m_pdoData = NULL;
|
|
} // if: data object allocated
|
|
|
|
m_pco = NULL;
|
|
m_hfont = NULL;
|
|
m_hicon = NULL;
|
|
|
|
//
|
|
// Delete all menu items.
|
|
//
|
|
if ( PlMenuItems() != NULL )
|
|
{
|
|
CCluAdmExMenuItemList::iterator itCurrent = PlMenuItems()->begin();
|
|
CCluAdmExMenuItemList::iterator itLast = PlMenuItems()->end();
|
|
CCluAdmExMenuItem * pemi;
|
|
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pemi = *itCurrent;
|
|
delete pemi;
|
|
} // while: more items in the list
|
|
delete m_plMenuItems;
|
|
m_plMenuItems = NULL;
|
|
} // if: there is a list of menu items
|
|
|
|
} //*** CCluAdmExtensions::UnloadExtensions()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::PwpPageFromHpage
|
|
//
|
|
// Routine Description:
|
|
// Get the wizard page pointer from an HPROPSHEETPAGE.
|
|
//
|
|
// Arguments:
|
|
// hpage [IN] Page handle.
|
|
//
|
|
// Return Value:
|
|
// pwp Pointer to wizard page object.
|
|
// NULL Page not found.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CWizardPageWindow * CCluAdmExtensions::PwpPageFromHpage( IN HPROPSHEETPAGE hpage )
|
|
{
|
|
ATLASSERT( hpage != NULL );
|
|
|
|
//
|
|
// Get a pointer to the wizard object so we can traverse the page list.
|
|
//
|
|
CWizardWindow * pwiz = dynamic_cast< CWizardWindow * >( Psht() );
|
|
ATLASSERT( pwiz != NULL );
|
|
|
|
//
|
|
// Loop through each page looking for an extension page whose
|
|
// page handle matches the one specified.
|
|
//
|
|
CWizardPageList::iterator itCurrent = pwiz->PlwpPages()->begin();
|
|
CWizardPageList::iterator itLast = pwiz->PlwpPages()->end();
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
CCluAdmExWizPage * pewp = dynamic_cast< CCluAdmExWizPage * >( *itCurrent );
|
|
if ( pewp != NULL )
|
|
{
|
|
if ( pewp->Hpage() == hpage )
|
|
{
|
|
return pewp;
|
|
} // if: found the matching page
|
|
} // if: found an extension page
|
|
} // for: each page in the list
|
|
|
|
//
|
|
// Look at the alternate wizard if there is one.
|
|
//
|
|
pwiz = pwiz->PwizAlternate();
|
|
if ( pwiz != NULL )
|
|
{
|
|
itCurrent = pwiz->PlwpPages()->begin();
|
|
itLast = pwiz->PlwpPages()->end();
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
CCluAdmExWizPage * pewp = dynamic_cast< CCluAdmExWizPage * >( *itCurrent );
|
|
if ( pewp != NULL )
|
|
{
|
|
if ( pewp->Hpage() == hpage )
|
|
{
|
|
return pewp;
|
|
} // if: found the matching page
|
|
} // if: found an extension page
|
|
} // for: each page in the list
|
|
} // if: alternate wizard exists
|
|
|
|
return NULL;
|
|
|
|
} //*** CCluAdmExtensions::PwpPageFromHpage()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::CreatePropertySheetPages
|
|
//
|
|
// Routine Description:
|
|
// Add pages to a property sheet.
|
|
//
|
|
// Arguments:
|
|
// psht [IN OUT] Property sheet to which pages are to be added.
|
|
// rlstrExtensions [IN] List of extension CLSID strings.
|
|
// pco [IN OUT] Cluster object to be administered.
|
|
// hfont [IN] Font for dialog text.
|
|
// hicon [IN] Icon for upper left corner.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CCluAdmExDll::AddPages().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExtensions::CreatePropertySheetPages(
|
|
IN OUT CBasePropertySheetWindow * psht,
|
|
IN const CStringList & rlstrExtensions,
|
|
IN OUT CClusterObject * pco,
|
|
IN HFONT hfont,
|
|
IN HICON hicon
|
|
)
|
|
{
|
|
ATLASSERT( psht != NULL );
|
|
ATLASSERT( pco != NULL );
|
|
|
|
m_psht = psht;
|
|
|
|
//
|
|
// Initialize for all extensions.
|
|
//
|
|
Init( rlstrExtensions, pco, hfont, hicon );
|
|
ATLASSERT( Plextdll() != NULL );
|
|
|
|
//
|
|
// Let each extension create property pages.
|
|
//
|
|
CCluAdmExDllList::iterator itCurrent = Plextdll()->begin();
|
|
CCluAdmExDllList::iterator itLast = Plextdll()->end();
|
|
CComCluAdmExDll * pextdll;
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pextdll = *itCurrent;
|
|
try
|
|
{
|
|
pextdll->CreatePropertySheetPages();
|
|
} // try
|
|
catch ( CException * pe )
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
} // catch: CException
|
|
} // while: more items in the list
|
|
|
|
} //*** CCluAdmExtensions::CreatePropertySheetPages()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::CreateWizardPages
|
|
//
|
|
// Routine Description:
|
|
// Add pages to a wizard.
|
|
//
|
|
// Arguments:
|
|
// psht [IN OUT] Property sheet to which pages are to be added.
|
|
// rlstrExtensions [IN] List of extension CLSID strings.
|
|
// pco [IN OUT] Cluster object to be administered.
|
|
// hfont [IN] Font for dialog text.
|
|
// hicon [IN] Icon for upper left corner.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CCluAdmExDll::AddPages().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExtensions::CreateWizardPages(
|
|
IN OUT CWizardWindow * psht,
|
|
IN const CStringList & rlstrExtensions,
|
|
IN OUT CClusterObject * pco,
|
|
IN HFONT hfont,
|
|
IN HICON hicon
|
|
)
|
|
{
|
|
ATLASSERT( psht != NULL );
|
|
ATLASSERT( pco != NULL );
|
|
|
|
m_psht = psht;
|
|
|
|
//
|
|
// Initialize for all extensions.
|
|
//
|
|
Init( rlstrExtensions, pco, hfont, hicon );
|
|
ATLASSERT( Plextdll() != NULL );
|
|
|
|
//
|
|
// Let each extension create wizard pages.
|
|
//
|
|
CCluAdmExDllList::iterator itCurrent = Plextdll()->begin();
|
|
CCluAdmExDllList::iterator itLast = Plextdll()->end();
|
|
CComCluAdmExDll * pextdll;
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pextdll = *itCurrent;
|
|
try
|
|
{
|
|
pextdll->CreateWizardPages();
|
|
} // try
|
|
catch ( CException * pe )
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
} // catch: CException
|
|
} // while: more items in the list
|
|
|
|
} //*** CCluAdmExtensions::CreateWizardPages()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::CreateWizard97Pages
|
|
//
|
|
// Routine Description:
|
|
// Add pages to a Wizard 97 wizard.
|
|
//
|
|
// Arguments:
|
|
// psht [IN OUT] Property sheet to which pages are to be added.
|
|
// rlstrExtensions [IN] List of extension CLSID strings.
|
|
// pco [IN OUT] Cluster object to be administered.
|
|
// hfont [IN] Font for dialog text.
|
|
// hicon [IN] Icon for upper left corner.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CCluAdmExDll::AddPages().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExtensions::CreateWizard97Pages(
|
|
IN OUT CWizardWindow * psht,
|
|
IN const CStringList & rlstrExtensions,
|
|
IN OUT CClusterObject * pco,
|
|
IN HFONT hfont,
|
|
IN HICON hicon
|
|
)
|
|
{
|
|
ATLASSERT( psht != NULL );
|
|
ATLASSERT( pco != NULL );
|
|
|
|
m_psht = psht;
|
|
|
|
//
|
|
// Initialize for all extensions.
|
|
//
|
|
Init( rlstrExtensions, pco, hfont, hicon );
|
|
ATLASSERT( Plextdll() != NULL );
|
|
|
|
//
|
|
// Let each extension create wizard pages.
|
|
//
|
|
CCluAdmExDllList::iterator itCurrent = Plextdll()->begin();
|
|
CCluAdmExDllList::iterator itLast = Plextdll()->end();
|
|
CComCluAdmExDll * pextdll;
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pextdll = *itCurrent;
|
|
try
|
|
{
|
|
pextdll->CreateWizard97Pages();
|
|
} // try
|
|
catch ( CException * pe )
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
} // catch: CException
|
|
} // while: more items in the list
|
|
|
|
} //*** CCluAdmExtensions::CreateWizard97Pages()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::AddContextMenuItems
|
|
//
|
|
// Routine Description:
|
|
// Query the extension DLL for new menu items to be added to the context
|
|
// menu.
|
|
//
|
|
// Arguments:
|
|
// pmenu [IN OUT] Menu to which items are to be added.
|
|
// rlstrExtensions [IN] List of extension CLSID strings.
|
|
// pco [IN OUT] Cluster object to be administered.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CCluAdmExDll::AddContextMenuItems() or
|
|
// CExtMenuItemList::new().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExtensions::AddContextMenuItems(
|
|
IN OUT CMenu * pmenu,
|
|
IN const CStringList & rlstrExtensions,
|
|
IN OUT CClusterObject * pco
|
|
)
|
|
{
|
|
ATLASSERT( m_pmenu == NULL );
|
|
ATLASSERT( pmenu != NULL );
|
|
|
|
//
|
|
// Initialize for all extensions.
|
|
//
|
|
Init( rlstrExtensions, pco, NULL, NULL );
|
|
ATLASSERT( Plextdll() != NULL );
|
|
|
|
m_pmenu = pmenu;
|
|
m_nFirstCommandID = CAEXT_MENU_FIRST_ID;
|
|
m_nNextCommandID = m_nFirstCommandID;
|
|
m_nFirstMenuID = 0;
|
|
m_nNextMenuID = m_nFirstMenuID;
|
|
|
|
//
|
|
// Create the list of menu items.
|
|
//
|
|
ATLASSERT( m_plMenuItems == NULL );
|
|
m_plMenuItems = new CCluAdmExMenuItemList;
|
|
if ( m_plMenuItems == NULL )
|
|
{
|
|
CNTException nte(
|
|
static_cast< DWORD >( E_OUTOFMEMORY ),
|
|
ADMC_IDS_INIT_EXT_PAGES_ERROR,
|
|
NULL, // pszOperArg1
|
|
NULL, // pszOperArg2
|
|
FALSE // bAutoDelete
|
|
);
|
|
nte.ReportError();
|
|
} // if: error allocating memory
|
|
else
|
|
{
|
|
CCluAdmExDllList::iterator itCurrent = Plextdll()->begin();
|
|
CCluAdmExDllList::iterator itLast = Plextdll()->end();
|
|
CComCluAdmExDll * pextdll;
|
|
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pextdll = *itCurrent;
|
|
try
|
|
{
|
|
pextdll->AddContextMenuItems();
|
|
} // try
|
|
catch ( CException * pe )
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
} // catch: CException
|
|
} // while: more items in the list
|
|
} // else: memory allocated successfully
|
|
|
|
} //*** CCluAdmExtensions::AddContextMenuItems()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::BExecuteContextMenuItem
|
|
//
|
|
// Routine Description:
|
|
// Execute a command associated with a menu item added to a context menu
|
|
// by the extension DLL.
|
|
//
|
|
// Arguments:
|
|
// nCommandID [IN] Command ID for the menu item chosen by the user.
|
|
//
|
|
// Return Value:
|
|
// TRUE Context menu item was executed.
|
|
// FALSE Context menu item was not executed.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CExceptionDll::BExecuteContextMenuItem().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CCluAdmExtensions::BExecuteContextMenuItem( IN ULONG nCommandID )
|
|
{
|
|
BOOL bHandled = FALSE;
|
|
HRESULT hr;
|
|
CCluAdmExMenuItem * pemi;
|
|
|
|
//
|
|
// Find the item in our list.
|
|
//
|
|
pemi = PemiFromCommandID( nCommandID );
|
|
if ( pemi != NULL )
|
|
{
|
|
ATLASSERT( pemi->PiCommand() != NULL );
|
|
Pdo()->AddRef();
|
|
hr = pemi->PiCommand()->InvokeCommand( pemi->NExtCommandID(), Pdo()->GetUnknown() );
|
|
if ( hr == NOERROR )
|
|
{
|
|
bHandled = TRUE;
|
|
} // if: no error occurred
|
|
} // if: found an item for the command ID
|
|
|
|
return bHandled;
|
|
|
|
} //*** CCluAdmExtensions::BExecuteContextMenuItem()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::BGetCommandString
|
|
//
|
|
// Routine Description:
|
|
// Get a command string from a menu ID.
|
|
//
|
|
// Arguments:
|
|
// nCommandID [IN] Command ID for the menu item.
|
|
// rstrMessage [OUT] String in which to return the message.
|
|
//
|
|
// Return Value:
|
|
// TRUE String is being returned.
|
|
// FALSE No string is being returned.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CCluAdmExDll::BGetCommandString().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CCluAdmExtensions::BGetCommandString(
|
|
IN ULONG nCommandID,
|
|
OUT CString & rstrMessage
|
|
)
|
|
{
|
|
BOOL bHandled = FALSE;
|
|
CCluAdmExMenuItem * pemi;
|
|
|
|
//
|
|
// Find the item in our list.
|
|
//
|
|
pemi = PemiFromCommandID( nCommandID );
|
|
if ( pemi != NULL )
|
|
{
|
|
rstrMessage = pemi->StrStatusBarText();
|
|
bHandled = TRUE;
|
|
} // if: found an item for the command ID
|
|
|
|
return bHandled;
|
|
|
|
} //*** CCluAdmExtensions::BGetCommandString()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::OnUpdateCommand
|
|
//
|
|
// Routine Description:
|
|
// Determines whether extension DLL menu items should be enabled or not.
|
|
//
|
|
// Arguments:
|
|
// pCmdUI [IN OUT] Command routing object.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CCluAdmExDll::BOnUpdateCommand().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#if 0
|
|
void CCluAdmExtensions::OnUpdateCommand( CCmdUI * pCmdUI )
|
|
{
|
|
CCluAdmExMenuItem * pemi;
|
|
|
|
ATLASSERT( Plextdll() != NULL );
|
|
|
|
//
|
|
// Find the item in our list.
|
|
//
|
|
// Trace( g_tagExtDll, _T("OnUpdateCommand() - ID = %d"), pCmdUI->m_nID );
|
|
pemi = PemiFromCommandID( pCmdUI->m_nID );
|
|
if ( pemi != NULL )
|
|
{
|
|
// Trace( g_tagExtDll, _T("OnUpdateCommand() - Found a match with '%s' ExtID = %d"), pemi->StrName(), pemi->NExtCommandID() );
|
|
pCmdUI->Enable();
|
|
} // if: found an item for the command ID
|
|
|
|
} //*** CCluAdmExtensions::OnUpdateCommand()
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::OnCmdMsg
|
|
//
|
|
// Routine Description:
|
|
// Processes command messages. Attempts to pass them on to a selected
|
|
// item first.
|
|
//
|
|
// Arguments:
|
|
// nID [IN] Command ID.
|
|
// nCode [IN] Notification code.
|
|
// pExtra [IN OUT] Used according to the value of nCode.
|
|
// pHandlerInfo [OUT] ???
|
|
//
|
|
// Return Value:
|
|
// TRUE Message has been handled.
|
|
// FALSE Message has NOT been handled.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#if 0
|
|
BOOL CCluAdmExtensions::OnCmdMsg(
|
|
UINT nID,
|
|
int nCode,
|
|
void * pExtra,
|
|
AFX_CMDHANDLERINFO * pHandlerInfo
|
|
)
|
|
{
|
|
return BExecuteContextMenuItem( nID );
|
|
|
|
} //*** CCluAdmExtensions::OnCmdMsg()
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::PemiFromCommandID
|
|
//
|
|
// Routine Description:
|
|
// Find the menu item for the specified command ID.
|
|
//
|
|
// Arguments:
|
|
// nCommandID [IN] Command ID for the menu item.
|
|
//
|
|
// Return Value:
|
|
// pemi Menu item or NULL if not found.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CCluAdmExMenuItem * CCluAdmExtensions::PemiFromCommandID( IN ULONG nCommandID ) const
|
|
{
|
|
CCluAdmExMenuItem * pemiReturn = NULL;
|
|
|
|
if ( PlMenuItems() != NULL )
|
|
{
|
|
CCluAdmExMenuItemList::iterator itCurrent = PlMenuItems()->begin();
|
|
CCluAdmExMenuItemList::iterator itLast = PlMenuItems()->end();
|
|
CCluAdmExMenuItem * pemi;
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pemi = *itCurrent;
|
|
if ( pemi->NCommandID() == nCommandID )
|
|
{
|
|
pemiReturn = pemi;
|
|
break;
|
|
} // if: match was found
|
|
} // while: more items in the list
|
|
} // if: item list exists
|
|
|
|
return pemiReturn;
|
|
|
|
} //*** CCluAdmExtensions::PemiFromCommandID()
|
|
|
|
#if DBG
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExtensions::PemiFromExtCommandID
|
|
//
|
|
// Routine Description:
|
|
// Find the menu item for the specified extension command ID.
|
|
//
|
|
// Arguments:
|
|
// nExtCommandID [IN] Extension command ID for the menu item.
|
|
//
|
|
// Return Value:
|
|
// pemi Menu item or NULL if not found.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CCluAdmExMenuItem * CCluAdmExtensions::PemiFromExtCommandID( IN ULONG nExtCommandID ) const
|
|
{
|
|
CCluAdmExMenuItem * pemiReturn = NULL;
|
|
|
|
if ( PlMenuItems() != NULL )
|
|
{
|
|
CCluAdmExMenuItemList::iterator itCurrent = PlMenuItems()->begin();
|
|
CCluAdmExMenuItemList::iterator itLast = PlMenuItems()->end();
|
|
CCluAdmExMenuItem * pemi;
|
|
|
|
for ( ; itCurrent != itLast ; itCurrent++ )
|
|
{
|
|
pemi = *itCurrent;
|
|
if ( pemi->NExtCommandID() == nExtCommandID )
|
|
{
|
|
pemiReturn = pemi;
|
|
break;
|
|
} // if: match was found
|
|
} // while: more items in the list
|
|
} // if: item list exists
|
|
|
|
return pemiReturn;
|
|
|
|
} //*** CCluAdmExtensions::PemiFromExtCommandID()
|
|
#endif // DBG
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CComObject< CCluAdmExDll >
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
BEGIN_OBJECT_MAP( AtlExtDll_ObjectMap )
|
|
OBJECT_ENTRY( CLSID_CoCluAdmExHostSvr, CComCluAdmExDll )
|
|
END_OBJECT_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::Init
|
|
//
|
|
// Routine Description:
|
|
// Initialize this class in preparation for accessing the extension.
|
|
//
|
|
// Arguments:
|
|
// rstrCLSID [IN] CLSID of the extension in string form.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException 0 (error converting CLSID from string)
|
|
// Any exceptions thrown by CString::operater=().
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExDll::Init(
|
|
IN const CString & rstrCLSID,
|
|
IN OUT CCluAdmExtensions * pext
|
|
)
|
|
{
|
|
ATLASSERT( pext != NULL );
|
|
|
|
HRESULT hr;
|
|
CWaitCursor wc;
|
|
|
|
//
|
|
// Save parameters.
|
|
//
|
|
ATLASSERT( StrCLSID().IsEmpty() || (StrCLSID() == rstrCLSID) );
|
|
m_strCLSID = rstrCLSID;
|
|
m_pext = pext;
|
|
|
|
//
|
|
// Convert the CLSID string to a CLSID.
|
|
//
|
|
hr = ::CLSIDFromString( (LPWSTR) (LPCTSTR) rstrCLSID, &m_clsid );
|
|
if ( hr != S_OK )
|
|
{
|
|
ThrowStaticException( hr, ADMC_IDS_CLSIDFROMSTRING_ERROR, rstrCLSID );
|
|
} // if: error converting CLSID
|
|
|
|
} //*** CCluAdmExDll::Init()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::LoadInterface
|
|
//
|
|
// Routine Description:
|
|
// Load an extension DLL.
|
|
//
|
|
// Arguments:
|
|
// riid [IN] Interface ID.
|
|
//
|
|
// Return Value:
|
|
// piUnk IUnknown interface pointer for interface.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException ADMC_IDS_EXT_CREATE_INSTANCE_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IUnknown * CCluAdmExDll::LoadInterface( IN /*const*/ REFIID riid )
|
|
{
|
|
HRESULT hr;
|
|
IUnknown * piUnk;
|
|
CWaitCursor wc;
|
|
|
|
//
|
|
// Load the inproc server and get the specified interface pointer.
|
|
//
|
|
// Trace( g_tagExtDllRef, _T("LoadInterface() - Getting interface pointer") );
|
|
hr = ::CoCreateInstance(
|
|
Rclsid(),
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
riid,
|
|
(LPVOID *) &piUnk
|
|
);
|
|
if ( (hr != S_OK)
|
|
&& (hr != REGDB_E_CLASSNOTREG)
|
|
&& (hr != E_NOINTERFACE)
|
|
)
|
|
{
|
|
ThrowStaticException( hr, ADMC_IDS_EXT_CREATE_INSTANCE_ERROR, StrCLSID() );
|
|
} // if: error creating the object instance
|
|
|
|
return piUnk;
|
|
|
|
} //*** CCluAdmExDll::LoadInterface()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::UnloadExtension
|
|
//
|
|
// Routine Description:
|
|
// Unload the extension DLL.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExDll::UnloadExtension( void )
|
|
{
|
|
//
|
|
// Release the interface pointers in the opposite order in which they
|
|
//
|
|
// were obtained.
|
|
ReleaseInterface( &m_piExtendPropSheet );
|
|
ReleaseInterface( &m_piExtendWizard );
|
|
ReleaseInterface( &m_piExtendWizard97 );
|
|
ReleaseInterface( &m_piExtendContextMenu );
|
|
ReleaseInterface( &m_piInvokeCommand );
|
|
|
|
m_strCLSID.Empty();
|
|
|
|
} //*** CCluAdmExDll::UnloadExtension()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::CreatePropertySheetPages
|
|
//
|
|
// Routine Description:
|
|
// Add pages to a property sheet.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException ADMC_IDS_EXT_ADD_PAGES_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExDll::CreatePropertySheetPages( void )
|
|
{
|
|
ATLASSERT( Pext() != NULL );
|
|
ATLASSERT( Psht() != NULL );
|
|
ATLASSERT( m_piExtendPropSheet == NULL );
|
|
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Load the interface.
|
|
//
|
|
m_piExtendPropSheet = reinterpret_cast< interface IWEExtendPropertySheet * >( LoadInterface( IID_IWEExtendPropertySheet ) );
|
|
if ( m_piExtendPropSheet == NULL )
|
|
{
|
|
return;
|
|
} // if: error loading the interface
|
|
ATLASSERT( m_piExtendPropSheet != NULL );
|
|
|
|
//
|
|
// Add pages from the extension.
|
|
//
|
|
GetUnknown()->AddRef(); // Add a reference because extension is going to release.
|
|
Pdo()->AddRef();
|
|
try
|
|
{
|
|
hr = PiExtendPropSheet()->CreatePropertySheetPages( Pdo()->GetUnknown(), this );
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
hr = E_FAIL;
|
|
} // catch
|
|
if ( (hr != NOERROR) && (hr != E_NOTIMPL) )
|
|
{
|
|
ThrowStaticException( hr, ADMC_IDS_EXT_ADD_PAGES_ERROR, StrCLSID() );
|
|
} // if: error creating property sheet pages
|
|
|
|
} //*** CCluAdmExDll::CreatePropertySheetPages()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::CreateWizardPages
|
|
//
|
|
// Routine Description:
|
|
// Add pages to a wizard.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException ADMC_IDS_EXT_ADD_PAGES_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExDll::CreateWizardPages( void )
|
|
{
|
|
ATLASSERT( Pext() != NULL );
|
|
ATLASSERT( Psht() != NULL );
|
|
ATLASSERT( m_piExtendWizard == NULL );
|
|
ATLASSERT( m_piExtendWizard97 == NULL );
|
|
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Load the interface. If it can't be loaded, try to load the
|
|
// Wizard97 interface so that Wizard97 pages can be added.
|
|
//
|
|
m_piExtendWizard = reinterpret_cast< interface IWEExtendWizard * >( LoadInterface( IID_IWEExtendWizard ) );
|
|
if ( m_piExtendWizard == NULL )
|
|
{
|
|
//
|
|
// Try to load the Wizard97 interface.
|
|
//
|
|
m_piExtendWizard97 = reinterpret_cast< interface IWEExtendWizard97 * >( LoadInterface( IID_IWEExtendWizard97 ) );
|
|
if ( m_piExtendWizard97 == NULL )
|
|
{
|
|
return;
|
|
} // if: error loading the non-Wizard97 interface
|
|
} // if: error loading the interface
|
|
ATLASSERT( (m_piExtendWizard != NULL) || (m_piExtendWizard97 != NULL) );
|
|
|
|
//
|
|
// Add pages from the extension.
|
|
//
|
|
GetUnknown()->AddRef(); // Add a reference because extension is going to release.
|
|
Pdo()->AddRef();
|
|
try
|
|
{
|
|
if ( PiExtendWizard() != NULL )
|
|
{
|
|
hr = PiExtendWizard()->CreateWizardPages( Pdo()->GetUnknown(), this );
|
|
} // if: extension supports non-Wizard97 interface
|
|
else
|
|
{
|
|
ATLASSERT( PiExtendWizard97() != NULL );
|
|
hr = PiExtendWizard97()->CreateWizard97Pages( Pdo()->GetUnknown(), this );
|
|
} // else: extension doesn't support non-Wizard97 interface
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
hr = E_FAIL;
|
|
} // catch
|
|
if ( (hr != NOERROR) && (hr != E_NOTIMPL) )
|
|
{
|
|
ThrowStaticException( hr, ADMC_IDS_EXT_ADD_PAGES_ERROR, StrCLSID() );
|
|
} // if: error creating wizard pages
|
|
|
|
} //*** CCluAdmExDll::CreateWizardPages()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::CreateWizard97Pages
|
|
//
|
|
// Routine Description:
|
|
// Add pages to a Wizard 97 wizard.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException ADMC_IDS_EXT_ADD_PAGES_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExDll::CreateWizard97Pages( void )
|
|
{
|
|
ATLASSERT( Pext() != NULL );
|
|
ATLASSERT( Psht() != NULL );
|
|
ATLASSERT( m_piExtendWizard == NULL );
|
|
ATLASSERT( m_piExtendWizard97 == NULL );
|
|
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Load the interface. If it can't be loaded, try to load the non-
|
|
// Wizard97 interface so that non-Wizard97 pages can be added.
|
|
//
|
|
m_piExtendWizard97 = reinterpret_cast< interface IWEExtendWizard97 * >( LoadInterface( IID_IWEExtendWizard97 ) );
|
|
if ( m_piExtendWizard97 == NULL )
|
|
{
|
|
//
|
|
// Try to load the non-Wizard97 interface.
|
|
//
|
|
m_piExtendWizard = reinterpret_cast< interface IWEExtendWizard * >( LoadInterface( IID_IWEExtendWizard ) );
|
|
if ( m_piExtendWizard == NULL )
|
|
{
|
|
return;
|
|
} // if: error loading the non-Wizard97 interface
|
|
} // if: error loading the Wizard97 interface
|
|
ATLASSERT( (m_piExtendWizard97 != NULL) || (m_piExtendWizard != NULL) );
|
|
|
|
//
|
|
// Add pages from the extension.
|
|
//
|
|
GetUnknown()->AddRef(); // Add a reference because extension is going to release.
|
|
Pdo()->AddRef();
|
|
try
|
|
{
|
|
if ( PiExtendWizard97() != NULL )
|
|
{
|
|
hr = PiExtendWizard97()->CreateWizard97Pages( Pdo()->GetUnknown(), this );
|
|
} // if: extension supports Wizard97 interface
|
|
else
|
|
{
|
|
ATLASSERT( PiExtendWizard() != NULL );
|
|
hr = PiExtendWizard()->CreateWizardPages( Pdo()->GetUnknown(), this );
|
|
} // else: extension doesn't support Wizard97 interface
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
hr = E_FAIL;
|
|
} // catch
|
|
if ( (hr != NOERROR) && (hr != E_NOTIMPL) )
|
|
{
|
|
ThrowStaticException( hr, ADMC_IDS_EXT_ADD_PAGES_ERROR, StrCLSID() );
|
|
} // if: error creating wizard pages
|
|
|
|
} //*** CCluAdmExDll::CreateWizard97Pages()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::AddContextMenuItems
|
|
//
|
|
// Routine Description:
|
|
// Ask the extension DLL to add items to the menu.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException ADMC_IDS_EXT_QUERY_CONTEXT_MENU_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CCluAdmExDll::AddContextMenuItems( void )
|
|
{
|
|
ATLASSERT( Pext() != NULL );
|
|
ATLASSERT( Pmenu() != NULL );
|
|
ATLASSERT( m_piExtendContextMenu == NULL );
|
|
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Load the interfaces.
|
|
//
|
|
m_piExtendContextMenu = reinterpret_cast< interface IWEExtendContextMenu * >( LoadInterface( IID_IWEExtendContextMenu ) );
|
|
if ( m_piExtendContextMenu == NULL )
|
|
{
|
|
return;
|
|
} // if: error loading the interface
|
|
ATLASSERT( m_piExtendContextMenu != NULL );
|
|
|
|
hr = PiExtendContextMenu()->QueryInterface( IID_IWEInvokeCommand, (LPVOID *) &m_piInvokeCommand );
|
|
if ( hr != NOERROR )
|
|
{
|
|
PiExtendContextMenu()->Release();
|
|
m_piExtendContextMenu = NULL;
|
|
ThrowStaticException( hr, ADMC_IDS_EXT_QUERY_CONTEXT_MENU_ERROR, StrCLSID() );
|
|
} // if: error getting the InvokeCommand interface
|
|
|
|
//
|
|
// Add context menu items.
|
|
//
|
|
GetUnknown()->AddRef(); // Add a reference because extension is going to release.
|
|
Pdo()->AddRef();
|
|
// Trace( g_tagExtDll, _T("CCluAdmExDll::AddContextMenuItem() - Adding context menu items from '%s'"), StrCLSID() );
|
|
try
|
|
{
|
|
hr = PiExtendContextMenu()->AddContextMenuItems( Pdo()->GetUnknown(), this );
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
hr = E_FAIL;
|
|
} // catch
|
|
if ( hr != NOERROR )
|
|
{
|
|
ThrowStaticException( hr, ADMC_IDS_EXT_QUERY_CONTEXT_MENU_ERROR, StrCLSID() );
|
|
} // if: error occurred
|
|
|
|
//
|
|
// Add a separator after the extension's items.
|
|
//
|
|
// Trace( g_tagExtDll, _T("CCluAdmExDll::AddContextMenuItem() - Adding separator") );
|
|
try
|
|
{
|
|
hr = AddExtensionMenuItem( NULL, NULL, (ULONG) -1, 0, MF_SEPARATOR );
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
hr = E_FAIL;
|
|
} // catch
|
|
if ( hr != NOERROR )
|
|
{
|
|
ThrowStaticException( hr, ADMC_IDS_EXT_QUERY_CONTEXT_MENU_ERROR, StrCLSID() );
|
|
} // if: error adding a separator
|
|
|
|
} //*** CCluAdmExDll::AddContextMenuItems()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::InterfaceSupportsErrorInfo [ISupportsErrorInfo]
|
|
//
|
|
// Routine Description:
|
|
// Determines whether the interface supports error info (???).
|
|
//
|
|
// Arguments:
|
|
// riid [IN] Reference to the interface ID.
|
|
//
|
|
// Return Value:
|
|
// S_OK Interface supports error info.
|
|
// S_FALSE Interface does not support error info.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP CCluAdmExDll::InterfaceSupportsErrorInfo( REFIID riid )
|
|
{
|
|
static const IID * rgiid[] =
|
|
{
|
|
&IID_IWCPropertySheetCallback,
|
|
&IID_IWCWizardCallback,
|
|
&IID_IWCWizard97Callback,
|
|
&IID_IWCContextMenuCallback,
|
|
};
|
|
int iiid;
|
|
|
|
for ( iiid = 0 ; iiid < sizeof( rgiid ) / sizeof( rgiid[0] ) ; iiid++ )
|
|
{
|
|
if ( InlineIsEqualGUID( *rgiid[iiid], riid ) )
|
|
{
|
|
return S_OK;
|
|
} // if: found a match
|
|
}
|
|
return S_FALSE;
|
|
|
|
} //*** CCluAdmExDll::InterfaceSupportsErrorInfo()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::AddPropertySheetPage [IWCPropertySheetCallback]
|
|
//
|
|
// Routine Description:
|
|
// Add a page to the property sheet.
|
|
//
|
|
// Arguments:
|
|
// plong_hpage [IN] Page to add.
|
|
//
|
|
// Return Value:
|
|
// NOERROR Page added successfully.
|
|
// E_INVALIDARG NULL hpage.
|
|
// Any hresult returned from CBasePropertySheetWindow::HrAddExtensionPage().
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP CCluAdmExDll::AddPropertySheetPage( IN LONG * plong_hpage )
|
|
{
|
|
ATLASSERT( plong_hpage != NULL );
|
|
ATLASSERT( Psht() != NULL );
|
|
|
|
HRESULT hr;
|
|
|
|
// Loop to avoid goto's.
|
|
do
|
|
{
|
|
//
|
|
// Do this for the release build.
|
|
//
|
|
if ( (plong_hpage == NULL)
|
|
|| (Psht() == NULL) )
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
} // if: no page or sheet
|
|
|
|
//
|
|
// Allocate a new page object.
|
|
//
|
|
CCluAdmExPropPage * ppp = new CCluAdmExPropPage( reinterpret_cast< HPROPSHEETPAGE >( plong_hpage ) );
|
|
ATLASSERT( ppp != NULL );
|
|
if ( ppp == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
} // if: error allocating memory
|
|
|
|
//
|
|
// Initialize the page object.
|
|
//
|
|
if ( ! ppp->BInit( Psht() ) )
|
|
{
|
|
delete ppp;
|
|
hr = E_FAIL;
|
|
break;
|
|
} // if: error initializing the page object
|
|
|
|
//
|
|
// Add the page to the sheet.
|
|
//
|
|
CBasePropertySheetWindow * psht = dynamic_cast< CBasePropertySheetWindow * >( Psht() );
|
|
ATLASSERT( psht != NULL );
|
|
hr = psht->HrAddExtensionPage( ppp );
|
|
if ( hr != NOERROR )
|
|
{
|
|
delete ppp;
|
|
break;
|
|
} // if: error adding the extension page
|
|
} while ( 0 );
|
|
|
|
return hr;
|
|
|
|
} //*** CCluAdmExDll::AddPropertySheetPage()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::AddWizardPage [IWCWizardCallback]
|
|
//
|
|
// Routine Description:
|
|
// Add a page to the wizard.
|
|
//
|
|
// Arguments:
|
|
// plong_hpage [IN] Page to add.
|
|
//
|
|
// Return Value:
|
|
// NOERROR Page added successfully.
|
|
// E_INVALIDARG NULL hpage.
|
|
// Any hresult returned from CWizardWindow::HrAddExtensionPage().
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP CCluAdmExDll::AddWizardPage( IN LONG * plong_hpage )
|
|
{
|
|
ATLASSERT( plong_hpage != NULL );
|
|
ATLASSERT( Psht() != NULL );
|
|
|
|
HRESULT hr;
|
|
|
|
// Loop to avoid goto's.
|
|
do
|
|
{
|
|
//
|
|
// Do this for the release build.
|
|
//
|
|
if ( (plong_hpage == NULL)
|
|
|| (Psht() == NULL) )
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
} // if: no page or sheet
|
|
|
|
//
|
|
// Allocate a new page object.
|
|
//
|
|
CCluAdmExWizPage * pwp = new CCluAdmExWizPage( reinterpret_cast< HPROPSHEETPAGE >( plong_hpage ) );
|
|
ATLASSERT( pwp != NULL );
|
|
if ( pwp == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
} // if: error allocating memory
|
|
|
|
//
|
|
// Initialize the page object.
|
|
//
|
|
if ( ! pwp->BInit( Psht() ) )
|
|
{
|
|
delete pwp;
|
|
hr = E_FAIL;
|
|
break;
|
|
} // if: error initializing the page object
|
|
|
|
//
|
|
// Set the default buttons to display. This assumes that there is
|
|
// a non-extension page already in the sheet and that there will
|
|
// be a page added after all extension pages have been added.
|
|
//
|
|
pwp->SetDefaultWizardButtons( PSWIZB_BACK | PSWIZB_NEXT );
|
|
|
|
//
|
|
// Add the page to the sheet.
|
|
//
|
|
CWizardWindow * pwiz = dynamic_cast< CWizardWindow * >( Psht() );
|
|
ATLASSERT( pwiz != NULL );
|
|
hr = pwiz->HrAddExtensionPage( pwp );
|
|
if ( hr != NOERROR )
|
|
{
|
|
delete pwp;
|
|
break;
|
|
} // if: error adding the extension page
|
|
} while ( 0 );
|
|
|
|
return hr;
|
|
|
|
} //*** CCluAdmExDll::AddWizardPage()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::AddWizard97Page [IWCWizard97Callback]
|
|
//
|
|
// Routine Description:
|
|
// Add a page to the Wizard97 wizard.
|
|
//
|
|
// Arguments:
|
|
// plong_hpage [IN] Page to add.
|
|
//
|
|
// Return Value:
|
|
// NOERROR Page added successfully.
|
|
// E_INVALIDARG NULL hpage.
|
|
// Any hresult returned from CWizardWindow::HrAddExtensionPage().
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP CCluAdmExDll::AddWizard97Page( IN LONG * plong_hpage )
|
|
{
|
|
ATLASSERT( plong_hpage != NULL );
|
|
ATLASSERT( Psht() != NULL );
|
|
|
|
HRESULT hr;
|
|
|
|
// Loop to avoid goto's.
|
|
do
|
|
{
|
|
//
|
|
// Do this for the release build.
|
|
//
|
|
if ( (plong_hpage == NULL)
|
|
|| (Psht() == NULL) )
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
} // if: no page or sheet
|
|
|
|
//
|
|
// Allocate a new page object.
|
|
//
|
|
CCluAdmExWiz97Page * pwp = new CCluAdmExWiz97Page( reinterpret_cast< HPROPSHEETPAGE >( plong_hpage ) );
|
|
ATLASSERT( pwp != NULL );
|
|
if ( pwp == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
} // if: error allocating memory
|
|
|
|
//
|
|
// Initialize the page object.
|
|
//
|
|
if ( ! pwp->BInit( Psht() ) )
|
|
{
|
|
delete pwp;
|
|
hr = E_FAIL;
|
|
break;
|
|
} // if: error initializing the page object
|
|
|
|
//
|
|
// Set the default buttons to display. This assumes that there is
|
|
// a non-extension page already in the sheet and that there will
|
|
// be a page added after all extension pages have been added.
|
|
//
|
|
pwp->SetDefaultWizardButtons( PSWIZB_BACK | PSWIZB_NEXT );
|
|
|
|
//
|
|
// Add the page to the sheet.
|
|
//
|
|
CWizardWindow * pwiz = dynamic_cast< CWizardWindow * >( Psht() );
|
|
ATLASSERT( pwiz != NULL );
|
|
hr = pwiz->HrAddExtensionPage( pwp );
|
|
if ( hr != NOERROR )
|
|
{
|
|
delete pwp;
|
|
break;
|
|
} // if: error adding the extension page
|
|
} while ( 0 );
|
|
|
|
return hr;
|
|
|
|
} //*** CCluAdmExDll::AddWizard97Page()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::EnableNext [IWCWizardCallback/IWCWizard97Callback]
|
|
//
|
|
// Routine Description:
|
|
// Enable or disable the NEXT button. If it is the last page, the
|
|
// FINISH button will be enabled or disabled.
|
|
//
|
|
// Arguments:
|
|
// hpage [IN] Page for which the button is being enabled or
|
|
// disabled.
|
|
// bEnable [IN] TRUE = Enable the button, FALSE = disable.
|
|
//
|
|
// Return Value:
|
|
// NOERROR Success.
|
|
// E_INVALIDARG Unknown hpage specified.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP CCluAdmExDll::EnableNext(
|
|
IN LONG * plong_hpage,
|
|
IN BOOL bEnable
|
|
)
|
|
{
|
|
ATLASSERT( plong_hpage != NULL );
|
|
ATLASSERT( Psht() != NULL );
|
|
|
|
//
|
|
// Find the page in the extension page list.
|
|
//
|
|
CWizardPageWindow * pwp = Pext()->PwpPageFromHpage( reinterpret_cast< HPROPSHEETPAGE >( plong_hpage ) );
|
|
if ( pwp == NULL )
|
|
{
|
|
return E_INVALIDARG;
|
|
} // if: page not found
|
|
|
|
//
|
|
// Let the page enable/disable the Next button.
|
|
//
|
|
pwp->EnableNext( bEnable );
|
|
|
|
return NOERROR;
|
|
|
|
} //*** CCluAdmExDll::EnableNext()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCluAdmExDll::AddExtensionMenuItem [IWCContextMenuCallback]
|
|
//
|
|
// Routine Description:
|
|
// Add a page to the wizard.
|
|
//
|
|
// Arguments:
|
|
// lpszName [IN] Name of item.
|
|
// lpszStatusBarText [IN] Text to appear on the status bar when the
|
|
// item is highlighted.
|
|
// nCommandID [IN] ID for the command when menu item is invoked.
|
|
// Must not be -1.
|
|
// nSubmenuCommandID [IN] ID for a submenu.
|
|
// uFlags [IN] Menu flags. The following are not supported:
|
|
// MF_OWNERDRAW, MF_POPUP
|
|
//
|
|
// Return Value:
|
|
// NOERROR Item added successfully.
|
|
// E_INVALIDARG MF_OWNERDRAW or MF_POPUP were specified.
|
|
// E_OUTOFMEMORY Error allocating the item.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP CCluAdmExDll::AddExtensionMenuItem(
|
|
IN BSTR lpszName,
|
|
IN BSTR lpszStatusBarText,
|
|
IN ULONG nCommandID,
|
|
IN ULONG nSubmenuCommandID,
|
|
IN ULONG uFlags
|
|
)
|
|
{
|
|
ATLASSERT( Pext() != NULL );
|
|
ATLASSERT( Pmenu() != NULL );
|
|
ATLASSERT( !(uFlags & (MF_OWNERDRAW | MF_POPUP)) );
|
|
|
|
HRESULT hr = NOERROR;
|
|
CCluAdmExMenuItem * pemi = NULL;
|
|
|
|
//
|
|
// Do this for the release build.
|
|
//
|
|
if ( (uFlags & (MF_OWNERDRAW | MF_POPUP)) != 0 )
|
|
{
|
|
hr = E_INVALIDARG;
|
|
} // if: invalid menu flags specified
|
|
else
|
|
{
|
|
ATLASSERT( Pext()->PemiFromExtCommandID( nCommandID ) == NULL );
|
|
|
|
try
|
|
{
|
|
// Trace( g_tagExtDll, _T("CCluAdmExDll::AddExtensionMenuItem() - Adding menu item '%s', ExtID = %d"), lpszName, nCommandID );
|
|
|
|
//
|
|
// Allocate a new item.
|
|
//
|
|
pemi = new CCluAdmExMenuItem(
|
|
OLE2CT( lpszName ),
|
|
OLE2CT( lpszStatusBarText ),
|
|
nCommandID,
|
|
NNextCommandID(),
|
|
NNextMenuID(),
|
|
uFlags,
|
|
FALSE, /*bMakeDefault*/
|
|
PiInvokeCommand()
|
|
);
|
|
if ( pemi == NULL )
|
|
{
|
|
ThrowStaticException( static_cast< DWORD >( E_OUTOFMEMORY ), static_cast< UINT >( 0 ) );
|
|
} // if: error allocating memory
|
|
|
|
//
|
|
// Insert the item in the menu.
|
|
//
|
|
if ( ! Pmenu()->InsertMenu( NNextMenuID(), MF_BYPOSITION | uFlags, NNextCommandID(), pemi->StrName() ) )
|
|
{
|
|
ThrowStaticException( ::GetLastError(), ADMC_IDS_INSERT_MENU_ERROR, pemi->StrName() );
|
|
} // if: error inserting the menu
|
|
|
|
//
|
|
// Add the item to the tail of the list.
|
|
//
|
|
Pext()->PlMenuItems()->insert( Pext()->PlMenuItems()->end(), pemi );
|
|
pemi = NULL;
|
|
|
|
//
|
|
// Update the counters.
|
|
//
|
|
Pext()->m_nNextCommandID++;
|
|
Pext()->m_nNextMenuID++;
|
|
} // try
|
|
catch ( CNTException * pnte )
|
|
{
|
|
hr = pnte->Sc();
|
|
pnte->ReportError();
|
|
pnte->Delete();
|
|
} // catch: CNTException
|
|
catch ( CException * pe )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
} // catch: CException
|
|
} // else: we can add the item
|
|
|
|
delete pemi;
|
|
return hr;
|
|
|
|
} //*** CCluAdmExDll::AddExtensionMenuItem()
|