1674 lines
52 KiB
C++
1674 lines
52 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 1996-2000 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// CluAdmin.cpp
|
|
//
|
|
// Abstract:
|
|
// Implementation of the CClusterAdminApp class.
|
|
// Defines the class behaviors for the application.
|
|
//
|
|
// Author:
|
|
// David Potter (davidp) May 1, 1996
|
|
//
|
|
// Revision History:
|
|
//
|
|
// Notes:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include "CluAdmin.h"
|
|
#include "ConstDef.h"
|
|
#include "CASvc.h"
|
|
#include "MainFrm.h"
|
|
#include "SplitFrm.h"
|
|
#include "ClusDoc.h"
|
|
#include "TreeView.h"
|
|
#include "OpenClus.h"
|
|
#include "ClusMru.h"
|
|
#include "ExcOper.h"
|
|
#include "Notify.h"
|
|
#include "TraceTag.h"
|
|
#include "TraceDlg.h"
|
|
#include "Barf.h"
|
|
#include "BarfDlg.h"
|
|
#include "About.h"
|
|
#include "CmdLine.h"
|
|
#include "VerInfo.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Global Variables
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
static LPCTSTR g_pszProfileName = _T("Cluster Administrator");
|
|
|
|
#ifdef _DEBUG
|
|
CTraceTag g_tagApp( _T("App"), _T("APP"), 0 );
|
|
CTraceTag g_tagAppMenu( _T("Menu"), _T("APP"), 0 );
|
|
CTraceTag g_tagAppNotify( _T("Notify"), _T("APP NOTIFY"), 0 );
|
|
CTraceTag g_tagNotifyThread( _T("Notify"), _T("NOTIFY THREAD"), 0 );
|
|
CTraceTag g_tagNotifyThreadReg( _T("Notify"), _T("NOTIFY THREAD (REG)"), 0 );
|
|
#endif
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusterAdminApp
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// The one and only CClusterAdminApp object
|
|
|
|
CClusterAdminApp theApp;
|
|
|
|
IMPLEMENT_DYNAMIC( CClusterNotifyContext, CObject );
|
|
IMPLEMENT_DYNAMIC( CClusterAdminApp, CWinApp );
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Message Maps
|
|
|
|
BEGIN_MESSAGE_MAP( CClusterAdminApp, CWinApp )
|
|
//{{AFX_MSG_MAP(CClusterAdminApp)
|
|
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
|
|
ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
|
|
ON_COMMAND(ID_FILE_NEW_CLUSTER, OnFileNewCluster)
|
|
ON_COMMAND(ID_WINDOW_CLOSE_ALL, OnWindowCloseAll)
|
|
ON_UPDATE_COMMAND_UI(ID_WINDOW_CLOSE_ALL, OnUpdateWindowCloseAll)
|
|
//}}AFX_MSG_MAP
|
|
// Standard file based document commands
|
|
ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
|
|
#ifdef _DEBUG
|
|
ON_COMMAND(ID_DEBUG_TRACE_SETTINGS, OnTraceSettings)
|
|
ON_COMMAND(ID_DEBUG_BARF_SETTINGS, OnBarfSettings)
|
|
ON_COMMAND(ID_DEBUG_BARF_ALL, OnBarfAllSettings)
|
|
#endif // _DEBUG
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::CClusterAdminApp
|
|
//
|
|
// Routine Description:
|
|
// Default constructor.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CClusterAdminApp::CClusterAdminApp( void )
|
|
{
|
|
// TODO: add construction code here,
|
|
// Place all significant initialization in InitInstance
|
|
m_pDocTemplate = NULL;
|
|
m_hchangeNotifyPort = NULL;
|
|
m_lcid = MAKELCID( MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ), SORT_DEFAULT );
|
|
m_hOpenedCluster = NULL;
|
|
m_nIdleCount = 0;
|
|
|
|
m_punkClusCfgClient = NULL;
|
|
|
|
FillMemory( m_rgiimg, sizeof( m_rgiimg ), 0xFF );
|
|
|
|
} //*** CClusterAdminApp::CClusterAdminApp()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::InitInstance
|
|
//
|
|
// Routine Description:
|
|
// Initialize this instance of the application.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// TRUE Application successfully initialized.
|
|
// FALSE Failed to initialize the application.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterAdminApp::InitInstance( void )
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
CMainFrame * pMainFrame = NULL;
|
|
CCluAdminCommandLineInfo cmdInfo;
|
|
|
|
// CG: The following block was added by the Splash Screen component.
|
|
{
|
|
// CCluAdminCommandLineInfo cmdInfo;
|
|
// ParseCommandLine(cmdInfo);
|
|
}
|
|
|
|
// Initialize OLE libraries
|
|
if ( ! AfxOleInit() )
|
|
{
|
|
AfxMessageBox( IDP_OLE_INIT_FAILED );
|
|
return FALSE;
|
|
}
|
|
|
|
if ( CoInitializeSecurity(
|
|
NULL,
|
|
-1,
|
|
NULL,
|
|
NULL,
|
|
RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
|
|
RPC_C_IMP_LEVEL_IMPERSONATE,
|
|
NULL,
|
|
EOAC_NONE,
|
|
0
|
|
) != S_OK )
|
|
{
|
|
return FALSE;
|
|
} // if:
|
|
|
|
// Construct the help path.
|
|
{
|
|
TCHAR szPath[ _MAX_PATH ];
|
|
TCHAR szDrive[ _MAX_PATH ];
|
|
TCHAR szDir[ _MAX_DIR ];
|
|
int cchPath;
|
|
VERIFY( ::GetSystemWindowsDirectory( szPath, _MAX_PATH ) );
|
|
cchPath = lstrlen( szPath );
|
|
if ( szPath[ cchPath - 1 ] != _T('\\') )
|
|
{
|
|
szPath[ cchPath++ ] = _T('\\');
|
|
szPath[ cchPath ] = _T('\0');
|
|
} // if: no backslash on the end of the path
|
|
lstrcpy( &szPath[ cchPath ], _T("Help\\") );
|
|
_tsplitpath( szPath, szDrive, szDir, NULL, NULL );
|
|
_tmakepath( szPath, szDrive, szDir, _T("cluadmin"), _T(".hlp") );
|
|
free( (void *) m_pszHelpFilePath );
|
|
BOOL bEnable;
|
|
bEnable = AfxEnableMemoryTracking( FALSE );
|
|
m_pszHelpFilePath = _tcsdup( szPath );
|
|
AfxEnableMemoryTracking( bEnable );
|
|
} // Construct the help path
|
|
|
|
// Standard initialization
|
|
// If you are not using these features and wish to reduce the size
|
|
// of your final executable, you should remove from the following
|
|
// the specific initialization routines you do not need.
|
|
|
|
SetRegistryKey( IDS_REGKEY_COMPANY ); // Set the registry key for the program.
|
|
|
|
//
|
|
// Override the profile name because we don't want to localize it.
|
|
//
|
|
free( (void *) m_pszProfileName );
|
|
m_pszProfileName = NULL;
|
|
m_pszProfileName = (LPTSTR) malloc( ( lstrlen( g_pszProfileName ) + 1 ) * sizeof( TCHAR ) );
|
|
if ( m_pszProfileName == NULL )
|
|
{
|
|
goto MemoryError;
|
|
} // if: error allocating the profile name buffer
|
|
lstrcpyn( const_cast< LPTSTR >( m_pszProfileName ), g_pszProfileName, lstrlen( g_pszProfileName ) + 1 );
|
|
|
|
InitAllTraceTags(); // Initialize all trace tags.
|
|
InitBarf(); // Initialize Basic Artificial Resource Failure system.
|
|
|
|
// Load version information.
|
|
#if 0
|
|
{
|
|
CVersionInfo verinfo;
|
|
DWORD dwValue;
|
|
|
|
// Initialize the version info.
|
|
verinfo.Init();
|
|
|
|
// Get the Locale ID.
|
|
if ( verinfo.BQueryValue( _T("\\VarFileInfo\\Translation"), dwValue ) )
|
|
{
|
|
m_lcid = MAKELCID( dwValue, SORT_DEFAULT );
|
|
} // if: locale ID is available
|
|
} // Load version information
|
|
#else
|
|
// Get the locale ID from the system to support MUI.
|
|
m_lcid = GetUserDefaultLCID();
|
|
#endif
|
|
|
|
// Initialize global CImageList
|
|
InitGlobalImageList();
|
|
|
|
#ifdef _AFXDLL
|
|
Enable3dControls(); // Call this when using MFC in a shared DLL
|
|
#else
|
|
Enable3dControlsStatic(); // Call this when linking to MFC statically
|
|
#endif
|
|
|
|
LoadStdProfileSettings( 0 ); // Load standard INI file options (including MRU)
|
|
|
|
// Create cluster MRU.
|
|
m_pRecentFileList = new CRecentClusterList( 0, _T("Recent Cluster List"), _T("Cluster%d"), 4 );
|
|
if ( m_pRecentFileList == NULL )
|
|
{
|
|
goto MemoryError;
|
|
} // if: error allocating memory
|
|
m_pRecentFileList->ReadList();
|
|
|
|
// Register the application's document templates. Document templates
|
|
// serve as the connection between documents, frame windows and views.
|
|
|
|
m_pDocTemplate = new CMultiDocTemplate(
|
|
IDR_CLUADMTYPE,
|
|
RUNTIME_CLASS( CClusterDoc ),
|
|
RUNTIME_CLASS( CSplitterFrame ), // custom MDI child frame
|
|
RUNTIME_CLASS( CClusterTreeView )
|
|
);
|
|
if ( m_pDocTemplate == NULL )
|
|
{
|
|
goto MemoryError;
|
|
} // if: error allocating memory
|
|
AddDocTemplate( m_pDocTemplate );
|
|
|
|
// create main MDI Frame window
|
|
pMainFrame = new CMainFrame;
|
|
if ( pMainFrame == NULL )
|
|
{
|
|
goto MemoryError;
|
|
} // if: error allocating memory
|
|
ASSERT( pMainFrame != NULL );
|
|
if ( ! pMainFrame->LoadFrame( IDR_MAINFRAME ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if: error loading the frame
|
|
m_pMainWnd = pMainFrame;
|
|
|
|
// Parse command line for standard shell commands, DDE, file open
|
|
// cmdInfo.m_nShellCommand = CCommandLineInfo::FileNothing; // Don't want to do a FileNew.
|
|
ParseCommandLine( cmdInfo );
|
|
|
|
// If no commands were specified on the command line, restore the desktop.
|
|
if ( cmdInfo.m_nShellCommand == CCommandLineInfo::FileNothing )
|
|
{
|
|
pMainFrame->PostMessage( WM_CAM_RESTORE_DESKTOP, cmdInfo.m_bReconnect );
|
|
} // if: no commands specified on the command line
|
|
|
|
// Create the cluster notification thread.
|
|
if ( ! BInitNotifyThread() )
|
|
{
|
|
goto Cleanup;
|
|
} // if: error creating the cluster notification thread
|
|
|
|
// The main window has been initialized, so show and update it.
|
|
{
|
|
WINDOWPLACEMENT wp;
|
|
|
|
// Set the placement of the window.
|
|
if ( ReadWindowPlacement( &wp, REGPARAM_SETTINGS, 0 ) )
|
|
{
|
|
pMainFrame->SetWindowPlacement( &wp );
|
|
m_nCmdShow = wp.showCmd; // set the show command.
|
|
} // if: read from profile
|
|
|
|
// Activate and update the frame window.
|
|
pMainFrame->ActivateFrame( m_nCmdShow );
|
|
pMainFrame->UpdateWindow();
|
|
} // The main window has been initialized, so show and update it
|
|
|
|
// Dispatch commands specified on the command line
|
|
if ( ! ProcessShellCommand( cmdInfo ) )
|
|
{
|
|
goto Cleanup;
|
|
} // if: error processing the command line
|
|
|
|
TraceMenu( g_tagAppMenu, AfxGetMainWnd()->GetMenu(), _T("InitInstance menu: ") );
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Cleanup:
|
|
if ( m_pMainWnd != pMainFrame )
|
|
{
|
|
delete pMainFrame;
|
|
} // if: main frame windows allocated but not saved yet
|
|
return bSuccess;
|
|
|
|
MemoryError:
|
|
CNTException nte(
|
|
ERROR_NOT_ENOUGH_MEMORY,
|
|
0, // idsOperation
|
|
NULL, // pszOperArg1
|
|
NULL, // pszOperArg2
|
|
FALSE // bAutoDelete
|
|
);
|
|
nte.ReportError();
|
|
nte.Delete();
|
|
goto Cleanup;
|
|
|
|
} //*** CClusterAdminApp::InitInstance()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnIdle
|
|
//
|
|
// Routine Description:
|
|
// Process the command line or shell command.
|
|
//
|
|
// Arguments:
|
|
// LONG [IN] Number of time we have been called before the next
|
|
// message arrives in the queue
|
|
//
|
|
// Return Value:
|
|
// TRUE if more idle processing
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterAdminApp::OnIdle(IN LONG lCount)
|
|
{
|
|
BOOL bMore = CWinApp::OnIdle(lCount);
|
|
|
|
//
|
|
// Since the MFC framework processing many messages lCount was never getting
|
|
// higher than 1. Since this work should not be done everytime we are idle
|
|
// I added my own counter that determines when the work is done.
|
|
//
|
|
if ((++m_nIdleCount % 200) == 0)
|
|
{
|
|
POSITION posDoc; // position in the documents collection
|
|
POSITION posDel; // position in the to be deleted list
|
|
POSITION posRemove; // position in the to be deleted list to remove
|
|
CClusterDoc * pdoc;
|
|
CClusterItem * pitem;
|
|
CWaitCursor cw;
|
|
|
|
posDoc = PdocTemplate()->GetFirstDocPosition();
|
|
while (posDoc != NULL)
|
|
{
|
|
pdoc = (CClusterDoc *) PdocTemplate()->GetNextDoc(posDoc);
|
|
ASSERT_VALID(pdoc);
|
|
try
|
|
{
|
|
posDel = pdoc->LpciToBeDeleted().GetHeadPosition();
|
|
while (posDel != NULL)
|
|
{
|
|
posRemove = posDel; // save posDel to posRemove since the next call is going to inc posDel
|
|
pitem = (CClusterItem *) pdoc->LpciToBeDeleted().GetNext(posDel);
|
|
ASSERT_VALID(pitem);
|
|
if ((pitem != NULL) && ( pitem->NReferenceCount() == 1))
|
|
{
|
|
pdoc->LpciToBeDeleted().RemoveAt(posRemove); // the saved position posRemove
|
|
} // if: the list's refence is the only one
|
|
} // while: more items in the to be deleted list
|
|
}
|
|
catch (CException * pe)
|
|
{
|
|
pe->Delete();
|
|
} // catch: CException
|
|
} // while: more items in the list
|
|
|
|
m_nIdleCount = 0;
|
|
bMore = FALSE; // don't want any more calls until some new messages are received
|
|
} // if: every 200th time...
|
|
|
|
return bMore;
|
|
|
|
} //*** CClusterAdminApp::OnIdle()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::ProcessShellCommand
|
|
//
|
|
// Routine Description:
|
|
// Process the command line or shell command.
|
|
//
|
|
// Arguments:
|
|
// rCmdInfo [IN OUT] Command line info.
|
|
//
|
|
// Return Value:
|
|
// 0 Error.
|
|
// !0 No error.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterAdminApp::ProcessShellCommand(IN OUT CCluAdminCommandLineInfo & rCmdInfo)
|
|
{
|
|
BOOL bSuccess = TRUE;
|
|
|
|
if (rCmdInfo.m_nShellCommand == CCommandLineInfo::FileOpen)
|
|
{
|
|
POSITION pos;
|
|
|
|
try
|
|
{
|
|
pos = rCmdInfo.LstrClusters().GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
OpenDocumentFile(rCmdInfo.LstrClusters().GetNext(pos));
|
|
} // while: more clusters in the list
|
|
} // try
|
|
catch (CException * pe)
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
bSuccess = FALSE;
|
|
} // catch: CException
|
|
} // if: we are opening clusters
|
|
else
|
|
bSuccess = CWinApp::ProcessShellCommand(rCmdInfo);
|
|
|
|
return bSuccess;
|
|
|
|
} //*** CClusterAdminApp::ProcessShellCommand()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::ExitInstance
|
|
//
|
|
// Routine Description:
|
|
// Exit this instance of the application.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// 0 No errors.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
int CClusterAdminApp::ExitInstance(void)
|
|
{
|
|
// Close the notification port.
|
|
if (HchangeNotifyPort() != NULL)
|
|
{
|
|
::CloseClusterNotifyPort(HchangeNotifyPort());
|
|
m_hchangeNotifyPort = NULL;
|
|
|
|
// Allow the notification port threads to clean themselves up.
|
|
::Sleep(100);
|
|
} // if: notification port is open
|
|
|
|
// Delete all the items in the notification key list.
|
|
{
|
|
POSITION pos;
|
|
|
|
pos = Cnkl().GetHeadPosition();
|
|
while (pos != NULL)
|
|
delete Cnkl().GetNext(pos);
|
|
Cnkl().RemoveAll();
|
|
} // Delete all the items in the notification key list
|
|
|
|
CleanupAllTraceTags(); // Cleanup trace tags.
|
|
CleanupBarf(); // Cleanup Basic Artificial Resource Failure system.
|
|
|
|
// Release the ClusCfg client object.
|
|
if ( m_punkClusCfgClient != NULL )
|
|
{
|
|
m_punkClusCfgClient->Release();
|
|
}
|
|
|
|
return CWinApp::ExitInstance();
|
|
|
|
} //*** CClusterAdminApp::ExitInstance()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::InitGlobalImageList
|
|
//
|
|
// Routine Description:
|
|
// Initialize the global image list.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::InitGlobalImageList(void)
|
|
{
|
|
// Create small image list.
|
|
VERIFY(PilSmallImages()->Create(
|
|
(int) 16, // cx
|
|
16, // cy
|
|
TRUE, // bMask
|
|
17, // nInitial
|
|
4 // nGrow
|
|
));
|
|
|
|
PilSmallImages()->SetBkColor(::GetSysColor(COLOR_WINDOW));
|
|
|
|
// Load the images into the small image list.
|
|
LoadImageIntoList(PilSmallImages(), IDB_FOLDER_16, IMGLI_FOLDER);
|
|
LoadImageIntoList(PilSmallImages(), IDB_CLUSTER_16, IMGLI_CLUSTER);
|
|
LoadImageIntoList(PilSmallImages(), IDB_CLUSTER_UNKNOWN_16, IMGLI_CLUSTER_UNKNOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NODE_16, IMGLI_NODE);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NODE_DOWN_16, IMGLI_NODE_DOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NODE_PAUSED_16, IMGLI_NODE_PAUSED);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NODE_UNKNOWN_16, IMGLI_NODE_UNKNOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_GROUP_16, IMGLI_GROUP);
|
|
LoadImageIntoList(PilSmallImages(), IDB_GROUP_PARTIAL_ONLINE_16, IMGLI_GROUP_PARTIALLY_ONLINE);
|
|
LoadImageIntoList(PilSmallImages(), IDB_GROUP_PENDING_16, IMGLI_GROUP_PENDING);
|
|
LoadImageIntoList(PilSmallImages(), IDB_GROUP_OFFLINE_16, IMGLI_GROUP_OFFLINE);
|
|
LoadImageIntoList(PilSmallImages(), IDB_GROUP_FAILED_16, IMGLI_GROUP_FAILED);
|
|
LoadImageIntoList(PilSmallImages(), IDB_GROUP_UNKNOWN_16, IMGLI_GROUP_UNKNOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_RES_16, IMGLI_RES);
|
|
LoadImageIntoList(PilSmallImages(), IDB_RES_OFFLINE_16, IMGLI_RES_OFFLINE);
|
|
LoadImageIntoList(PilSmallImages(), IDB_RES_PENDING_16, IMGLI_RES_PENDING);
|
|
LoadImageIntoList(PilSmallImages(), IDB_RES_FAILED_16, IMGLI_RES_FAILED);
|
|
LoadImageIntoList(PilSmallImages(), IDB_RES_UNKNOWN_16, IMGLI_RES_UNKNOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_RESTYPE_16, IMGLI_RESTYPE);
|
|
LoadImageIntoList(PilSmallImages(), IDB_RESTYPE_UNKNOWN_16, IMGLI_RESTYPE_UNKNOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETWORK_16, IMGLI_NETWORK);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETWORK_PARTITIONED_16, IMGLI_NETWORK_PARTITIONED);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETWORK_DOWN_16, IMGLI_NETWORK_DOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETWORK_UNKNOWN_16, IMGLI_NETWORK_UNKNOWN);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETIFACE_16, IMGLI_NETIFACE);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETIFACE_UNREACHABLE_16, IMGLI_NETIFACE_UNREACHABLE);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETIFACE_FAILED_16, IMGLI_NETIFACE_FAILED);
|
|
LoadImageIntoList(PilSmallImages(), IDB_NETIFACE_UNKNOWN_16, IMGLI_NETIFACE_UNKNOWN);
|
|
|
|
// Create large image list.
|
|
VERIFY(PilLargeImages()->Create(
|
|
(int) 32, // cx
|
|
32, // cy
|
|
TRUE, // bMask
|
|
17, // nInitial
|
|
4 // nGrow
|
|
));
|
|
PilLargeImages()->SetBkColor(::GetSysColor(COLOR_WINDOW));
|
|
|
|
// Load the images into the large image list.
|
|
LoadImageIntoList(PilLargeImages(), IDB_FOLDER_32, IMGLI_FOLDER);
|
|
LoadImageIntoList(PilLargeImages(), IDB_CLUSTER_32, IMGLI_CLUSTER);
|
|
LoadImageIntoList(PilLargeImages(), IDB_CLUSTER_UNKNOWN_32, IMGLI_CLUSTER_UNKNOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NODE_32, IMGLI_NODE);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NODE_DOWN_32, IMGLI_NODE_DOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NODE_PAUSED_32, IMGLI_NODE_PAUSED);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NODE_UNKNOWN_32, IMGLI_NODE_UNKNOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_GROUP_32, IMGLI_GROUP);
|
|
LoadImageIntoList(PilLargeImages(), IDB_GROUP_PARTIAL_ONLINE_32, IMGLI_GROUP_PARTIALLY_ONLINE);
|
|
LoadImageIntoList(PilLargeImages(), IDB_GROUP_PENDING_32, IMGLI_GROUP_PENDING);
|
|
LoadImageIntoList(PilLargeImages(), IDB_GROUP_OFFLINE_32, IMGLI_GROUP_OFFLINE);
|
|
LoadImageIntoList(PilLargeImages(), IDB_GROUP_FAILED_32, IMGLI_GROUP_FAILED);
|
|
LoadImageIntoList(PilLargeImages(), IDB_GROUP_UNKNOWN_32, IMGLI_GROUP_UNKNOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_RES_32, IMGLI_RES);
|
|
LoadImageIntoList(PilLargeImages(), IDB_RES_OFFLINE_32, IMGLI_RES_OFFLINE);
|
|
LoadImageIntoList(PilLargeImages(), IDB_RES_PENDING_32, IMGLI_RES_PENDING);
|
|
LoadImageIntoList(PilLargeImages(), IDB_RES_FAILED_32, IMGLI_RES_FAILED);
|
|
LoadImageIntoList(PilLargeImages(), IDB_RES_UNKNOWN_32, IMGLI_RES_UNKNOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_RESTYPE_32, IMGLI_RESTYPE);
|
|
LoadImageIntoList(PilLargeImages(), IDB_RESTYPE_UNKNOWN_32, IMGLI_RESTYPE_UNKNOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETWORK_32, IMGLI_NETWORK);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETWORK_PARTITIONED_32, IMGLI_NETWORK_PARTITIONED);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETWORK_DOWN_32, IMGLI_NETWORK_DOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETWORK_UNKNOWN_32, IMGLI_NETWORK_UNKNOWN);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETIFACE_32, IMGLI_NETIFACE);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETIFACE_UNREACHABLE_32, IMGLI_NETIFACE_UNREACHABLE);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETIFACE_FAILED_32, IMGLI_NETIFACE_FAILED);
|
|
LoadImageIntoList(PilLargeImages(), IDB_NETIFACE_UNKNOWN_32, IMGLI_NETIFACE_UNKNOWN);
|
|
|
|
} //*** CClusterAdminApp::InitGlobalImageList()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::LoadImageIntoList
|
|
//
|
|
// Routine Description:
|
|
// Load images into an image list.
|
|
//
|
|
// Arguments:
|
|
// pil [IN OUT] Image list into which to load the image.
|
|
// idbImage [IN] Resource ID for the image bitmap.
|
|
// imgli [IN] Index into the index array.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::LoadImageIntoList(
|
|
IN OUT CImageList * pil,
|
|
IN ID idbImage,
|
|
IN UINT imgli
|
|
)
|
|
{
|
|
CBitmap bm;
|
|
UINT iimg;
|
|
|
|
LoadImageIntoList(pil, idbImage, &iimg);
|
|
if (m_rgiimg[imgli] == (UINT) -1)
|
|
m_rgiimg[imgli] = iimg;
|
|
#ifdef DEBUG
|
|
else
|
|
ASSERT(m_rgiimg[imgli] == iimg);
|
|
#endif
|
|
|
|
} //*** CClusterAdminApp::LoadImageIntoList()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// CClusterAdminApp::LoadImageIntoList
|
|
//
|
|
// Routine Description:
|
|
// Load images into an image list.
|
|
//
|
|
// Arguments:
|
|
// pil [IN OUT] Image list into which to load the image.
|
|
// idbImage [IN] Resource ID for the image bitmap.
|
|
// piimg [OUT] Pointer to image index.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::LoadImageIntoList(
|
|
IN OUT CImageList * pil,
|
|
IN ID idbImage,
|
|
OUT UINT * piimg
|
|
)
|
|
{
|
|
CBitmap bm;
|
|
UINT iimg;
|
|
COLORREF crMaskColor = RGB(255,0,255);
|
|
|
|
ASSERT(pil != NULL);
|
|
ASSERT(idbImage != 0);
|
|
|
|
if (piimg == NULL)
|
|
piimg = &iimg;
|
|
|
|
bm.LoadBitmap(idbImage);
|
|
*piimg = pil->Add(&bm, crMaskColor);
|
|
|
|
} //*** CClusterAdminApp::LoadImageIntoList()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnRestoreDesktop
|
|
//
|
|
// Routine Description:
|
|
// Handler for the WM_CAM_RESTORE_DESKTOP message.
|
|
// Restores the desktop from the saved parameters.
|
|
//
|
|
// Arguments:
|
|
// wparam TRUE = reconnect, FALSE, don't reconnect.
|
|
// lparam Unused.
|
|
//
|
|
// Return Value:
|
|
// 0
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
LRESULT CClusterAdminApp::OnRestoreDesktop(WPARAM wparam, LPARAM lparam)
|
|
{
|
|
CString strConnections;
|
|
WPARAM bReconnect = wparam;
|
|
|
|
if (bReconnect)
|
|
{
|
|
// Read the connections the user had last time they exited.
|
|
try
|
|
{
|
|
strConnections = GetProfileString(REGPARAM_CONNECTIONS, REGPARAM_CONNECTIONS);
|
|
} // try
|
|
catch (CException * pe)
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
} // catch: CException
|
|
|
|
// If there were any connections, restore them.
|
|
if (strConnections.GetLength() > 0)
|
|
{
|
|
LPTSTR pszConnections;
|
|
LPTSTR pszConnection;
|
|
TCHAR szSep[] = _T(",");
|
|
|
|
ASSERT(m_pMainWnd != NULL);
|
|
|
|
try
|
|
{
|
|
pszConnections = strConnections.GetBuffer(1);
|
|
pszConnection = _tcstok(pszConnections, szSep);
|
|
while (pszConnection != NULL)
|
|
{
|
|
// Open a connection to this cluster.
|
|
OpenDocumentFile(pszConnection);
|
|
|
|
// Find the next connection.
|
|
pszConnection = _tcstok(NULL, szSep);
|
|
} // while: more connections
|
|
} // try
|
|
catch (CException * pe)
|
|
{
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
} // catch: CException
|
|
strConnections.ReleaseBuffer();
|
|
} // if: connections saved previously
|
|
else
|
|
bReconnect = FALSE;
|
|
} // if: reconnect is desired
|
|
|
|
if (!bReconnect)
|
|
{
|
|
CWaitCursor wc;
|
|
Sleep(1500);
|
|
} // if: not reconnecting
|
|
|
|
// If there were no previous connections and we are not minimized, do a standard file open.
|
|
if (!bReconnect && !AfxGetMainWnd()->IsIconic())
|
|
OnFileOpen();
|
|
|
|
// Otherwise, restore the desktop.
|
|
|
|
return 0;
|
|
|
|
} //*** CClusterAdminApp::OnRestoreDesktop()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::SaveConnections
|
|
//
|
|
// Routine Description:
|
|
// Save the current connections so they can be restored later.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::SaveConnections(void)
|
|
{
|
|
POSITION pos;
|
|
CClusterDoc * pdoc;
|
|
CString strConnections;
|
|
TCHAR szSep[] = _T("\0");
|
|
|
|
pos = PdocTemplate()->GetFirstDocPosition();
|
|
while (pos != NULL)
|
|
{
|
|
pdoc = (CClusterDoc *) PdocTemplate()->GetNextDoc(pos);
|
|
ASSERT_VALID(pdoc);
|
|
try
|
|
{
|
|
strConnections += szSep + pdoc->StrNode();
|
|
szSep[0] = _T(','); // Subsequent connections are preceded by a separator
|
|
}
|
|
catch (CException * pe)
|
|
{
|
|
pe->Delete();
|
|
} // catch: CException
|
|
|
|
// Save connection-specific settings as well.
|
|
pdoc->SaveSettings();
|
|
} // while: more items in the list
|
|
WriteProfileString(REGPARAM_CONNECTIONS, REGPARAM_CONNECTIONS, strConnections);
|
|
|
|
} //*** CClusterAdminApp::SaveConnections()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnFileOpen
|
|
//
|
|
// Routine Description:
|
|
// Prompt the user for the name of a cluster or server and then open it.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnFileOpen(void)
|
|
{
|
|
COpenClusterDialog dlg;
|
|
ID idDlgStatus;
|
|
CDocument * pdoc = NULL;
|
|
HCLUSTER hCluster = NULL;
|
|
|
|
do
|
|
{
|
|
idDlgStatus = (ID) dlg.DoModal();
|
|
if ( idDlgStatus != IDOK )
|
|
{
|
|
break;
|
|
}
|
|
|
|
switch ( dlg.m_nAction )
|
|
{
|
|
case OPEN_CLUSTER_DLG_CREATE_NEW_CLUSTER:
|
|
OnFileNewCluster();
|
|
break;
|
|
|
|
case OPEN_CLUSTER_DLG_ADD_NODES:
|
|
case OPEN_CLUSTER_DLG_OPEN_CONNECTION:
|
|
if ( hCluster != NULL )
|
|
{
|
|
CloseCluster( hCluster );
|
|
} // if: previous cluster opened
|
|
hCluster = HOpenCluster( dlg.m_strName );
|
|
if ( hCluster == NULL )
|
|
{
|
|
CNTException nte( GetLastError(), IDS_OPEN_CLUSTER_ERROR, dlg.m_strName );
|
|
nte.ReportError();
|
|
} // if: error opening the cluster
|
|
else
|
|
{
|
|
Trace( g_tagApp, _T("OnFileOpen() - Opening the cluster document on '%s'"), dlg.m_strName );
|
|
m_hOpenedCluster = hCluster;
|
|
pdoc = OpenDocumentFile( dlg.m_strName );
|
|
m_hOpenedCluster = NULL;
|
|
hCluster = NULL;
|
|
} // else: cluster opened successfully
|
|
|
|
if ( ( pdoc != NULL ) && ( dlg.m_nAction == OPEN_CLUSTER_DLG_ADD_NODES ) )
|
|
{
|
|
NewNodeWizard(
|
|
dlg.m_strName,
|
|
FALSE // fIgnoreErrors
|
|
);
|
|
} // if: add a node to the cluster
|
|
break;
|
|
} // switch: dialog action
|
|
} while ( ( pdoc == NULL )
|
|
&& ( dlg.m_nAction != OPEN_CLUSTER_DLG_CREATE_NEW_CLUSTER ) );
|
|
|
|
if ( hCluster != NULL )
|
|
{
|
|
CloseCluster( hCluster );
|
|
}
|
|
|
|
} //*** CClusterAdminApp::OnFileOpen()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OpenDocumentFile
|
|
//
|
|
// Routine Description:
|
|
// Open a cluster.
|
|
//
|
|
// Arguments:
|
|
// lpszFileName The name of the cluster or a server in that cluster.
|
|
//
|
|
// Return Value:
|
|
// NULL Invalid cluster or server name.
|
|
// pOpenDocument The document instance for the open cluster.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CDocument * CClusterAdminApp::OpenDocumentFile(LPCTSTR lpszFileName)
|
|
{
|
|
// find the highest confidence
|
|
CDocTemplate::Confidence bestMatch = CDocTemplate::noAttempt;
|
|
CDocTemplate * pBestTemplate = NULL;
|
|
CDocument * pOpenDocument = NULL;
|
|
|
|
{
|
|
ASSERT_KINDOF(CDocTemplate, m_pDocTemplate);
|
|
|
|
CDocTemplate::Confidence match;
|
|
ASSERT(pOpenDocument == NULL);
|
|
match = m_pDocTemplate->MatchDocType(lpszFileName, pOpenDocument);
|
|
if (match > bestMatch)
|
|
{
|
|
bestMatch = match;
|
|
pBestTemplate = m_pDocTemplate;
|
|
}
|
|
}
|
|
|
|
if (pOpenDocument != NULL)
|
|
{
|
|
POSITION pos = pOpenDocument->GetFirstViewPosition();
|
|
if (pos != NULL)
|
|
{
|
|
CView * pView = pOpenDocument->GetNextView(pos); // get first one
|
|
ASSERT_VALID(pView);
|
|
CFrameWnd * pFrame = pView->GetParentFrame();
|
|
if (pFrame != NULL)
|
|
pFrame->ActivateFrame();
|
|
else
|
|
Trace(g_tagApp, _T("Error: Can not find a frame for document to activate."));
|
|
CFrameWnd * pAppFrame;
|
|
if (pFrame != (pAppFrame = (CFrameWnd*)AfxGetApp()->m_pMainWnd))
|
|
{
|
|
ASSERT_KINDOF(CFrameWnd, pAppFrame);
|
|
pAppFrame->ActivateFrame();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Trace(g_tagApp, _T("Error: Can not find a view for document to activate."));
|
|
}
|
|
return pOpenDocument;
|
|
}
|
|
|
|
if (pBestTemplate == NULL)
|
|
{
|
|
TCHAR szMsg[1024];
|
|
AfxLoadString(AFX_IDP_FAILED_TO_OPEN_DOC, szMsg, sizeof(szMsg));
|
|
AfxMessageBox(szMsg);
|
|
return NULL;
|
|
}
|
|
|
|
return pBestTemplate->OpenDocumentFile(lpszFileName);
|
|
|
|
} //*** CClusterAdminApp::OpenDocumentFile()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::AddToRecentFileList
|
|
//
|
|
// Routine Description:
|
|
// Adds a file to the Most Recently Used file list. Overridden to
|
|
// prevent the cluster name from being fully qualified as a file.
|
|
//
|
|
// Arguments:
|
|
// lpszPathName [IN] The path of the file.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::AddToRecentFileList(LPCTSTR lpszPathName)
|
|
{
|
|
ASSERT_VALID(this);
|
|
ASSERT(lpszPathName != NULL);
|
|
ASSERT(AfxIsValidString(lpszPathName));
|
|
|
|
if (m_pRecentFileList != NULL)
|
|
{
|
|
// Don't fully qualify the path name.
|
|
m_pRecentFileList->Add(lpszPathName);
|
|
}
|
|
|
|
} //*** CClusterAdminApp::AddToRecentFileList()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::LoadClusCfgClient
|
|
//
|
|
// Routine Description:
|
|
// Makes sure that the ClusCfg client has been loaded. This is
|
|
// required because it can only be loaded once per process.
|
|
//
|
|
// Note: DavidP 21-AUG-2000 This is a hack, IMHO!
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::LoadClusCfgClient( void )
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ( m_punkClusCfgClient == NULL )
|
|
{
|
|
//
|
|
// Get the service manager.
|
|
//
|
|
|
|
hr = CoCreateInstance(
|
|
CLSID_ServiceManager
|
|
, NULL
|
|
, CLSCTX_INPROC_SERVER
|
|
, IID_IUnknown
|
|
, reinterpret_cast< void ** >( &m_punkClusCfgClient )
|
|
);
|
|
if ( FAILED( hr ) )
|
|
{
|
|
ThrowStaticException( hr, IDS_CREATE_CLUSCFGWIZ_OBJ_ERROR );
|
|
} // if: error loading the ClusCfg client
|
|
} // if: not loaded yet
|
|
|
|
} //*** CClusterAdminApp::LoadClusCfgClient()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnFileNewCluster
|
|
//
|
|
// Routine Description:
|
|
// Processes the ID_FILE_NEW_CLUSTER menu command.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnFileNewCluster( void )
|
|
{
|
|
HRESULT hr;
|
|
IClusCfgWizard * piWiz;
|
|
BOOL fCommitted = FALSE;
|
|
|
|
// Make sure the ClusCfg client has been loaded.
|
|
LoadClusCfgClient();
|
|
|
|
// Get an interface pointer for the wizard.
|
|
hr = CoCreateInstance(
|
|
CLSID_ClusCfgWizard,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IClusCfgWizard,
|
|
(LPVOID *) &piWiz
|
|
);
|
|
if ( FAILED( hr ) )
|
|
{
|
|
CNTException nte( hr, IDS_CREATE_CLUSCFGWIZ_OBJ_ERROR, NULL, NULL, FALSE /*bAutoDelete*/ );
|
|
nte.ReportError();
|
|
return;
|
|
} // if: error getting the interface pointer
|
|
|
|
// Display the wizard.
|
|
hr = piWiz->CreateCluster(
|
|
AfxGetMainWnd()->m_hWnd,
|
|
&fCommitted
|
|
);
|
|
if ( FAILED( hr ) )
|
|
{
|
|
CNTException nte( hr, IDS_CREATE_CLUSTER_ERROR, NULL, NULL, FALSE /*bAutoDelete*/ );
|
|
nte.ReportError();
|
|
} // if: error adding cluster nodes
|
|
|
|
if ( fCommitted )
|
|
{
|
|
BSTR bstrClusterName;
|
|
hr = piWiz->get_ClusterName( &bstrClusterName );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
CNTException nte( hr, IDS_CREATE_CLUSTER_ERROR, NULL, NULL, FALSE /*bAutoDelete*/ );
|
|
nte.ReportError();
|
|
}
|
|
else
|
|
{
|
|
if ( hr == S_OK )
|
|
{
|
|
HCLUSTER hCluster;
|
|
|
|
ASSERT( bstrClusterName != NULL );
|
|
|
|
// Open the cluster with the cluster name specified by the
|
|
// wizard. If it not successful, translate this to a NetBIOS
|
|
// name in case that is more reliable.
|
|
hCluster = OpenCluster( bstrClusterName );
|
|
if ( hCluster == NULL )
|
|
{
|
|
WCHAR szClusterNetBIOSName[ MAX_COMPUTERNAME_LENGTH + 1 ];
|
|
DWORD nSize = sizeof( szClusterNetBIOSName ) / sizeof( szClusterNetBIOSName[ 0 ] );
|
|
|
|
DnsHostnameToComputerName( bstrClusterName, szClusterNetBIOSName, &nSize );
|
|
SysFreeString( bstrClusterName );
|
|
bstrClusterName = SysAllocString( szClusterNetBIOSName );
|
|
}
|
|
else
|
|
{
|
|
CloseCluster( hCluster );
|
|
}
|
|
OpenDocumentFile( bstrClusterName );
|
|
} // if: retrieved cluster name successfully
|
|
SysFreeString( bstrClusterName );
|
|
} // else: retrieving cluster name didn't fail
|
|
} // if: user didn't cancel the wizard
|
|
|
|
piWiz->Release();
|
|
|
|
} //*** CClusterAdminApp::OnFileNewCluster()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnAppAbout
|
|
//
|
|
// Routine Description:
|
|
// Displays the about box.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnAppAbout(void)
|
|
{
|
|
CAboutDlg aboutDlg;
|
|
aboutDlg.DoModal();
|
|
|
|
} //*** CClusterAdminApp::OnAppAbout()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnUpdateWindowCloseAll
|
|
//
|
|
// Routine Description:
|
|
// Determines whether menu items corresponding to ID_WINDOW_CLOSE_ALL
|
|
// should be enabled or not.
|
|
//
|
|
// Arguments:
|
|
// pCmdUI [IN OUT] Command routing object.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnUpdateWindowCloseAll(CCmdUI * pCmdUI)
|
|
{
|
|
pCmdUI->Enable(m_pDocTemplate->GetFirstDocPosition() != NULL);
|
|
|
|
} //*** CClusterAdminApp::OnUpdateWindowCloseAll()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnWindowCloseAll
|
|
//
|
|
// Routine Description:
|
|
// Processes the ID_WINDOW_CLOSE_ALL menu command.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnWindowCloseAll(void)
|
|
{
|
|
CloseAllDocuments(FALSE /*bEndSession*/);
|
|
|
|
} //*** CClusterAdminApp::OnWindowCloseAll()
|
|
|
|
#ifdef _DEBUG
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnTraceSettings
|
|
//
|
|
// Routine Description:
|
|
// Displays the Trace Settings dialog.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnTraceSettings(void)
|
|
{
|
|
CTraceDialog dlgTraceSettings;
|
|
dlgTraceSettings.DoModal();
|
|
|
|
} //*** CClusterAdminApp::OnTraceSettings()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnBarfSettings
|
|
//
|
|
// Routine Description:
|
|
// Displays the BARF Settings dialog.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnBarfSettings(void)
|
|
{
|
|
DoBarfDialog();
|
|
|
|
} //*** CClusterAdminApp::OnBarfSettings()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnBarfAllSettings
|
|
//
|
|
// Routine Description:
|
|
// Displays the BARF All Settings dialog.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterAdminApp::OnBarfAllSettings(void)
|
|
{
|
|
BarfAll();
|
|
|
|
} //*** CClusterAdminApp::OnBarfAllSettings()
|
|
|
|
#endif // _DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::OnClusterNotify
|
|
//
|
|
// Routine Description:
|
|
// Handler for the WM_CAM_CLUSTER_NOTIFY message.
|
|
// Processes cluster notifications.
|
|
//
|
|
// Arguments:
|
|
// wparam WPARAM.
|
|
// LPARAM LPARAM = CClusterNotify object describing the notification.
|
|
//
|
|
// Return Value:
|
|
// Value returned from the application method.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
LRESULT CClusterAdminApp::OnClusterNotify(WPARAM wparam, LPARAM lparam)
|
|
{
|
|
CClusterNotify * pnotify = (CClusterNotify *) lparam;
|
|
|
|
ASSERT(pnotify != NULL);
|
|
ASSERT(pnotify->m_dwNotifyKey != NULL);
|
|
|
|
// Send change notifications to the object that registered it.
|
|
if (pnotify->m_pcnk != NULL)
|
|
{
|
|
// Find the notification key in our list of keys. If it is not
|
|
// found, ignore it. Otherwise, ask the object that registered
|
|
// the notification to handle it.
|
|
if (Cnkl().Find(pnotify->m_pcnk) != NULL)
|
|
{
|
|
switch (pnotify->m_pcnk->m_cnkt)
|
|
{
|
|
case cnktDoc:
|
|
ASSERT_VALID(pnotify->m_pcnk->m_pdoc);
|
|
return pnotify->m_pcnk->m_pdoc->OnClusterNotify(pnotify);
|
|
|
|
case cnktClusterItem:
|
|
ASSERT_VALID(pnotify->m_pcnk->m_pci);
|
|
ASSERT_VALID(pnotify->m_pcnk->m_pci->Pdoc());
|
|
return pnotify->m_pcnk->m_pci->OnClusterNotify(pnotify);
|
|
} // switch: notification key type
|
|
} // if: notification key found in the list
|
|
} // if: non-NULL object pointer
|
|
|
|
// Notification not handled.
|
|
Trace(g_tagError, _T("*** Unhandled notification: key %08.8x, filter %x (%s) - '%s'"), pnotify->m_dwNotifyKey, pnotify->m_dwFilterType, PszNotificationName(pnotify->m_dwFilterType), pnotify->m_strName);
|
|
delete pnotify;
|
|
return 0;
|
|
|
|
} //*** CClusterAdminApp::OnClusterNotify()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::BInitNotifyThread
|
|
//
|
|
// Routine Description:
|
|
// Initialize the cluster notification thread.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// TRUE Thread initialized successfully.
|
|
// FALSE Thread NOT initialized successfully.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterAdminApp::BInitNotifyThread(void)
|
|
{
|
|
try
|
|
{
|
|
// Create the notification port.
|
|
m_hchangeNotifyPort = ::CreateClusterNotifyPort(
|
|
(HCHANGE) INVALID_HANDLE_VALUE, // hChange
|
|
(HCLUSTER) INVALID_HANDLE_VALUE, // hCluster
|
|
0, // dwFilter
|
|
0 // dwNotifyKey
|
|
);
|
|
if (HchangeNotifyPort() == NULL)
|
|
ThrowStaticException(GetLastError());
|
|
|
|
// Construct the context object.
|
|
Pcnctx()->m_hchangeNotifyPort = HchangeNotifyPort();
|
|
Pcnctx()->m_hwndFrame = m_pMainWnd->m_hWnd;
|
|
|
|
// Begin the thread.
|
|
m_wtNotifyThread = AfxBeginThread(NotifyThreadProc, Pcnctx());
|
|
if (WtNotifyThread() == NULL)
|
|
ThrowStaticException(GetLastError());
|
|
} // try
|
|
catch (CException * pe)
|
|
{
|
|
// Close the notify port.
|
|
if (HchangeNotifyPort() != NULL)
|
|
{
|
|
::CloseClusterNotifyPort(HchangeNotifyPort());
|
|
m_hchangeNotifyPort = NULL;
|
|
} // if: notify port is open
|
|
|
|
pe->ReportError();
|
|
pe->Delete();
|
|
return FALSE;
|
|
} // catch: CException
|
|
|
|
return TRUE;
|
|
|
|
} //*** CClusterAdminApp::BInitNotifyThread()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterAdminApp::NotifyThreadProc (static)
|
|
//
|
|
// Routine Description:
|
|
// Notification thread procedure.
|
|
//
|
|
// Arguments:
|
|
// pParam [IN OUT] Thread procedure parameter -- a notification
|
|
// context object.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
UINT AFX_CDECL CClusterAdminApp::NotifyThreadProc(LPVOID pParam)
|
|
{
|
|
DWORD dwStatus;
|
|
WCHAR* pwszName;
|
|
DWORD cchName;
|
|
DWORD cchBuffer;
|
|
DWORD_PTR dwNotifyKey;
|
|
DWORD dwFilterType;
|
|
CClusterNotify * pnotify = NULL;
|
|
CClusterNotifyContext * pnctx = (CClusterNotifyContext *) pParam;
|
|
#ifdef _DEBUG
|
|
TCHAR * pszTracePrefix;
|
|
CTraceTag * ptag;
|
|
#endif
|
|
|
|
ASSERT(pParam != NULL);
|
|
ASSERT_KINDOF(CClusterNotifyContext, pnctx);
|
|
ASSERT(pnctx->m_hchangeNotifyPort != NULL);
|
|
ASSERT(pnctx->m_hwndFrame != NULL);
|
|
|
|
pwszName = new WCHAR[1024];
|
|
cchBuffer = 1024;
|
|
|
|
ASSERT( pwszName != NULL );
|
|
|
|
if ( pwszName == NULL )
|
|
{
|
|
AfxThrowMemoryException();
|
|
} // if: memory exception
|
|
|
|
for (;;)
|
|
{
|
|
cchName = cchBuffer;
|
|
dwStatus = GetClusterNotify(
|
|
pnctx->m_hchangeNotifyPort,
|
|
&dwNotifyKey,
|
|
&dwFilterType,
|
|
pwszName,
|
|
&cchName,
|
|
INFINITE
|
|
);
|
|
|
|
if (dwStatus == ERROR_INVALID_HANDLE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( dwStatus == ERROR_MORE_DATA )
|
|
{
|
|
cchName++; // add one for NULL
|
|
|
|
ASSERT( cchName > cchBuffer );
|
|
|
|
cchBuffer = cchName;
|
|
|
|
// buffer was too small, reallocate
|
|
delete [] pwszName;
|
|
pwszName = new WCHAR[cchBuffer];
|
|
|
|
ASSERT( pwszName != NULL );
|
|
|
|
if ( pwszName == NULL )
|
|
{
|
|
AfxThrowMemoryException();
|
|
} // if: memory exception
|
|
|
|
continue;
|
|
}
|
|
|
|
if (dwStatus != ERROR_SUCCESS)
|
|
{
|
|
TraceError(_T("CClusterAdminApp::NotifyThreadProc() %s"), dwStatus);
|
|
continue;
|
|
} // if: error getting notification
|
|
|
|
try
|
|
{
|
|
pnotify = new CClusterNotify();
|
|
ASSERT(pnotify != NULL);
|
|
|
|
if (pnotify != NULL)
|
|
{
|
|
pnotify->m_dwNotifyKey = dwNotifyKey;
|
|
pnotify->m_dwFilterType = dwFilterType;
|
|
pnotify->m_strName = pwszName;
|
|
#ifdef _DEBUG
|
|
pszTracePrefix = _T("");
|
|
if ( (dwNotifyKey == NULL)
|
|
|| (dwNotifyKey == 0xfeeefeee)
|
|
|| (dwNotifyKey == 0xbaadf00d))
|
|
{
|
|
ptag = &g_tagError;
|
|
pszTracePrefix = _T("*** NOTIFY THREAD ");
|
|
} // if: bad notification key
|
|
else if (dwFilterType & (CLUSTER_CHANGE_REGISTRY_NAME | CLUSTER_CHANGE_REGISTRY_ATTRIBUTES | CLUSTER_CHANGE_REGISTRY_VALUE))
|
|
ptag = &g_tagNotifyThreadReg;
|
|
else
|
|
ptag = &g_tagNotifyThread;
|
|
Trace(*ptag, _T("%sNotification - key %08.8x, filter %x (%s), %s"), pszTracePrefix, dwNotifyKey, dwFilterType, PszNotificationName(dwFilterType), pnotify->m_strName);
|
|
#endif
|
|
if (!::PostMessage(
|
|
pnctx->m_hwndFrame,
|
|
WM_CAM_CLUSTER_NOTIFY,
|
|
NULL,
|
|
(LPARAM) pnotify
|
|
))
|
|
delete pnotify;
|
|
} // if: allocated object successfully
|
|
} // try
|
|
catch (...)
|
|
{
|
|
if (pnotify != NULL)
|
|
{
|
|
delete pnotify;
|
|
pnotify = NULL;
|
|
} // if: notification record allocated
|
|
} // catch: any exception
|
|
} // forever
|
|
|
|
delete [] pwszName;
|
|
|
|
return 0;
|
|
|
|
} //*** CClusterAdminApp::NotifyThreadProc()
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Global Functions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// BCreateFont
|
|
//
|
|
// Routine Description:
|
|
// Create a font.
|
|
//
|
|
// Arguments:
|
|
// rfont [OUT] Font to create.
|
|
// nPoints [IN] Point size.
|
|
// bBold [IN] Flag specifying whether font is bold or not.
|
|
//
|
|
// Return Value:
|
|
// TRUE Font created successfully.
|
|
// FALSE Error creating font.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL BCreateFont(OUT CFont & rfont, IN int nPoints, IN BOOL bBold)
|
|
{
|
|
return rfont.CreateFont(
|
|
-nPoints, // nHeight
|
|
0, // nWidth
|
|
0, // nEscapement
|
|
0, // nOrientation
|
|
(bBold ? FW_BOLD : FW_DONTCARE), // nWeight
|
|
FALSE, // bItalic
|
|
FALSE, // bUnderline
|
|
FALSE, // cStrikeout
|
|
ANSI_CHARSET, // nCharSet
|
|
OUT_DEFAULT_PRECIS, // nOutPrecision
|
|
CLIP_DEFAULT_PRECIS, // nClipPrecision
|
|
DEFAULT_QUALITY, // nQuality
|
|
DEFAULT_PITCH | FF_DONTCARE, // nPitchAndFamily
|
|
_T("MS Shell Dlg") // lpszFaceName
|
|
);
|
|
|
|
} //*** BCreateFont()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// NewNodeWizard
|
|
//
|
|
// Routine Description:
|
|
// Invoke the Add Nodes to Cluster Wizard.
|
|
//
|
|
// Arguments:
|
|
// pcszName -- Name of cluster to add nodes to.
|
|
// fIgnoreErrors -- TRUE = don't display error messages.
|
|
// Defaults to FALSE.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void NewNodeWizard(
|
|
LPCTSTR pcszName,
|
|
BOOL fIgnoreErrors // = FALSE
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
IClusCfgWizard * pccwWiz;
|
|
BSTR bstrConnectName = NULL;
|
|
BOOL fCommitted = FALSE;
|
|
|
|
// Make sure the ClusCfg client has been loaded.
|
|
GetClusterAdminApp()->LoadClusCfgClient();
|
|
|
|
// Get an interface pointer for the wizard.
|
|
hr = CoCreateInstance(
|
|
CLSID_ClusCfgWizard,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IClusCfgWizard,
|
|
(void **) &pccwWiz
|
|
);
|
|
if ( FAILED( hr ) )
|
|
{
|
|
if ( ! fIgnoreErrors )
|
|
{
|
|
CNTException nte( hr, IDS_CREATE_CLUSCFGWIZ_OBJ_ERROR, NULL, NULL, FALSE /*bAutoDelete*/ );
|
|
nte.ReportError();
|
|
}
|
|
return;
|
|
} // if: error getting the interface pointer
|
|
|
|
// TODO: DavidP 24-AUG-2000
|
|
// Get the FQDN of the cluster name.
|
|
|
|
// Specify the name of the cluster we are going to add a node to.
|
|
bstrConnectName = SysAllocString( pcszName );
|
|
if ( bstrConnectName == NULL )
|
|
{
|
|
AfxThrowMemoryException();
|
|
}
|
|
hr = pccwWiz->put_ClusterName( bstrConnectName );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
if ( ! fIgnoreErrors )
|
|
{
|
|
CNTException nte( hr, IDS_ADD_NODES_TO_CLUSTER_ERROR, bstrConnectName, NULL, FALSE /*bAutoDelete*/ );
|
|
nte.ReportError();
|
|
}
|
|
} // if: error setting the cluster name
|
|
|
|
// Display the wizard.
|
|
hr = pccwWiz->AddClusterNodes(
|
|
AfxGetMainWnd()->m_hWnd,
|
|
&fCommitted
|
|
);
|
|
if ( FAILED( hr ) )
|
|
{
|
|
if ( ! fIgnoreErrors )
|
|
{
|
|
CNTException nte( hr, IDS_ADD_NODES_TO_CLUSTER_ERROR, bstrConnectName, NULL, FALSE /*bAutoDelete*/ );
|
|
nte.ReportError();
|
|
}
|
|
} // if: error adding cluster nodes
|
|
|
|
SysFreeString( bstrConnectName );
|
|
pccwWiz->Release();
|
|
|
|
} //*** NewNodeWizard()
|