1178 lines
36 KiB
C++
1178 lines
36 KiB
C++
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved
|
|
|
|
Module Name:
|
|
|
|
PrMrIe.cpp
|
|
|
|
Abstract:
|
|
|
|
Inclusion / Exclusion property Page.
|
|
|
|
Author:
|
|
|
|
Art Bragg [abragg] 08-Aug-1997
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include "PrMrIe.h"
|
|
#include "Rule.h"
|
|
#include "joblib.h"
|
|
#include "manvol.h"
|
|
#include "IeList.h"
|
|
|
|
static DWORD pHelpIds[] =
|
|
{
|
|
|
|
IDC_LIST_IE_LABEL, idh_rule_list,
|
|
IDC_LIST_IE, idh_rule_list,
|
|
IDC_BTN_ADD, idh_new_rule_button,
|
|
IDC_BTN_REMOVE, idh_rule_delete_button,
|
|
IDC_BTN_EDIT, idh_rule_edit_button,
|
|
IDC_BTN_UP, idh_rule_up_button,
|
|
IDC_BTN_DOWN, idh_rule_down_button,
|
|
|
|
0, 0
|
|
};
|
|
|
|
// Columns for listview control
|
|
#define IE_COLUMN_ACTION 0
|
|
#define IE_COLUMN_FILE_TYPE 1
|
|
#define IE_COLUMN_PATH 2
|
|
#define IE_COLUMN_ATTRS 3
|
|
|
|
int CALLBACK CompareFunc( LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort );
|
|
int PathCollate( CString PathA, CString PathB );
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPrMrIe property page
|
|
|
|
CPrMrIe::CPrMrIe( ) : CSakVolPropPage( CPrMrIe::IDD )
|
|
{
|
|
//{{AFX_DATA_INIT( CPrMrIe )
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_hConsoleHandle = NULL;
|
|
m_LineCount = 0;
|
|
m_pHelpIds = pHelpIds;
|
|
}
|
|
|
|
CPrMrIe::~CPrMrIe( )
|
|
{
|
|
int i;
|
|
// Clean up old lines
|
|
for( i = 0; i < m_LineCount; i++ ) {
|
|
if( m_LineList[ i ] ) {
|
|
delete m_LineList[ i ];
|
|
}
|
|
}
|
|
m_LineCount = 0;
|
|
}
|
|
|
|
void CPrMrIe::DoDataExchange( CDataExchange* pDX )
|
|
{
|
|
CSakVolPropPage::DoDataExchange( pDX );
|
|
//{{AFX_DATA_MAP( CPrMrIe )
|
|
DDX_Control( pDX, IDC_BTN_UP, m_BtnUp );
|
|
DDX_Control( pDX, IDC_BTN_REMOVE, m_BtnRemove );
|
|
DDX_Control( pDX, IDC_BTN_EDIT, m_BtnEdit );
|
|
DDX_Control( pDX, IDC_BTN_DOWN, m_BtnDown );
|
|
DDX_Control( pDX, IDC_BTN_ADD, m_BtnAdd );
|
|
DDX_Control( pDX, IDC_LIST_IE, m_listIncExc );
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP( CPrMrIe, CSakVolPropPage )
|
|
//{{AFX_MSG_MAP( CPrMrIe )
|
|
ON_BN_CLICKED( IDC_BTN_ADD, OnBtnAdd )
|
|
ON_BN_CLICKED( IDC_BTN_DOWN, OnBtnDown )
|
|
ON_BN_CLICKED( IDC_BTN_REMOVE, OnBtnRemove )
|
|
ON_BN_CLICKED( IDC_BTN_UP, OnBtnUp )
|
|
ON_BN_CLICKED( IDC_BTN_EDIT, OnBtnEdit )
|
|
ON_WM_DESTROY( )
|
|
ON_NOTIFY( NM_DBLCLK, IDC_LIST_IE, OnDblclkListIe )
|
|
ON_NOTIFY( NM_CLICK, IDC_LIST_IE, OnClickListIe )
|
|
ON_NOTIFY( LVN_ITEMCHANGED, IDC_LIST_IE, OnItemchangedListIe )
|
|
ON_WM_VSCROLL( )
|
|
ON_WM_DRAWITEM( )
|
|
ON_WM_MEASUREITEM( )
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPrMrIe message handlers
|
|
|
|
BOOL CPrMrIe::OnApply( )
|
|
{
|
|
ULONG count = 0;
|
|
int i;
|
|
CComPtr<IHsmRule> pLocalRule;
|
|
CString path;
|
|
CString name;
|
|
BOOL bInclude;
|
|
BOOL bSubdirs;
|
|
BOOL bUserDefined;
|
|
HRESULT hr;
|
|
CComPtr<IHsmRule> pRemoteRule;
|
|
CComPtr<IWsbCreateLocalObject> pLocalObject;
|
|
CComPtr<IHsmCriteria> pCriteria;
|
|
CComPtr<IWsbCollection> pCriteriaCollection;
|
|
CComPtr <IUnknown> pUnkRule;
|
|
CComPtr <IWsbCollection> pRulesCollection;
|
|
|
|
try {
|
|
|
|
// Empty the collection of rules
|
|
WsbAffirmPointer( m_pRulesIndexedCollection );
|
|
WsbAffirmHr( m_pRulesIndexedCollection->QueryInterface( IID_IWsbCollection,( void ** ) &pRulesCollection ) );
|
|
pRulesCollection->RemoveAllAndRelease( );
|
|
|
|
//
|
|
// Get a CreateLocalobject interface with which to create the
|
|
// new rule( s ).
|
|
//
|
|
WsbAffirmPointer( m_pFsaServer );
|
|
WsbAffirmHr( m_pFsaServer->QueryInterface( IID_IWsbCreateLocalObject,( void ** ) &pLocalObject ) );
|
|
|
|
//
|
|
// Now go through the list box and add the rules in the list box to the
|
|
// collection. Must do this backwards to be considered correctly by
|
|
// job mechanism
|
|
//
|
|
int listCount = m_listIncExc.GetItemCount( );
|
|
int insertIndex = 0;
|
|
|
|
for( i = listCount - 1; i >= 0; i-- ) {
|
|
|
|
//
|
|
// Get the pointer to the rule from the list box
|
|
//
|
|
pLocalRule.Release( );
|
|
pLocalRule = (IHsmRule *) m_listIncExc.GetItemData( i );
|
|
if( pLocalRule ) {
|
|
|
|
//
|
|
// Get rule data from the local object
|
|
//
|
|
WsbAffirmHr( GetRuleFromObject( pLocalRule, path,
|
|
name, &bInclude, &bSubdirs, &bUserDefined ) );
|
|
|
|
//
|
|
// Create a new remote rule object in the Fsa
|
|
//
|
|
pRemoteRule.Release( );
|
|
WsbAffirmHr( pLocalObject->CreateInstance( CLSID_CHsmRule, IID_IHsmRule,( void** ) &pRemoteRule ) );
|
|
|
|
//
|
|
// Set the data in the remote rule object
|
|
//
|
|
WsbAffirmHr( SetRuleInObject( pRemoteRule, path, name, bInclude, bSubdirs, bUserDefined ) );
|
|
|
|
//
|
|
// Add the rule pointer to the collection of rules
|
|
//
|
|
pUnkRule.Release( );
|
|
WsbAffirmHr( pRemoteRule->QueryInterface( IID_IUnknown, (void **) &pUnkRule ) );
|
|
WsbAffirmHr( m_pRulesIndexedCollection->AddAt( pUnkRule, insertIndex++ ) );
|
|
|
|
//
|
|
// Get the criteria collection pointer
|
|
//
|
|
pCriteriaCollection.Release( );
|
|
WsbAffirmHr( pRemoteRule->Criteria( &pCriteriaCollection ) );
|
|
|
|
//
|
|
// Add the appropriate criterion to the rule
|
|
//
|
|
pCriteria.Release( );
|
|
switch( bInclude ) {
|
|
case TRUE:
|
|
//
|
|
// Include
|
|
//
|
|
WsbAffirmHr( pLocalObject->CreateInstance( CLSID_CHsmCritManageable, IID_IHsmCriteria,( void** ) &pCriteria ) );
|
|
WsbAffirmHr( pCriteria->SetIsNegated( FALSE ) );
|
|
break;
|
|
|
|
case FALSE:
|
|
//
|
|
// Exclude
|
|
//
|
|
WsbAffirmHr( pLocalObject->CreateInstance( CLSID_CHsmCritAlways, IID_IHsmCriteria,( void** ) &pCriteria ) );
|
|
WsbAffirmHr( pCriteria->SetIsNegated( FALSE ) );
|
|
break;
|
|
|
|
}
|
|
|
|
WsbAffirmHr( pCriteriaCollection->Add( pCriteria ) );
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//
|
|
// Tell the FSA to save itself.
|
|
//
|
|
WsbAffirmHr( RsServerSaveAll( m_pFsaServer ) );
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return CSakVolPropPage::OnApply( );
|
|
}
|
|
HRESULT CPrMrIe::SetRuleInObject(
|
|
IHsmRule *pHsmRule,
|
|
CString Path,
|
|
CString Name,
|
|
BOOL bInclude,
|
|
BOOL bSubdirs,
|
|
BOOL bUserDefined )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
CWsbStringPtr wsbPath = Path;
|
|
CWsbStringPtr wsbName = Name;
|
|
WsbAffirmHr( pHsmRule->SetPath( ( OLECHAR * )wsbPath ) );
|
|
WsbAffirmHr( pHsmRule->SetName( ( OLECHAR * )wsbName ) );
|
|
WsbAffirmHr( pHsmRule->SetIsInclude( bInclude ) );
|
|
WsbAffirmHr( pHsmRule->SetIsUsedInSubDirs( bSubdirs ) );
|
|
WsbAffirmHr( pHsmRule->SetIsUserDefined( bUserDefined ) );
|
|
} WsbCatch( hr );
|
|
return( hr );
|
|
}
|
|
|
|
BOOL CPrMrIe::OnInitDialog( )
|
|
{
|
|
CSakVolPropPage::OnInitDialog( );
|
|
|
|
AFX_MANAGE_STATE( AfxGetStaticModuleState( ) );
|
|
|
|
ULONG count = 0;
|
|
int index = 0;
|
|
HRESULT hr = S_OK;
|
|
CString path;
|
|
CString name;
|
|
BOOL bInclude;
|
|
BOOL bSubdirs;
|
|
BOOL bUserDefined;
|
|
RECT rect;
|
|
CString *columnWidths[20];
|
|
int cColumns;
|
|
int columnWidth[20];
|
|
CString *columnTitles[20];
|
|
CSize size;
|
|
|
|
try {
|
|
|
|
//
|
|
// Set the icons into the buttons
|
|
//
|
|
HRESULT hrAlternateIcon = RsIsWhiteOnBlack( );
|
|
HICON downIcon, upIcon;
|
|
downIcon = (HICON)LoadImage( _Module.m_hInstResource,
|
|
S_OK == hrAlternateIcon ? MAKEINTRESOURCE( IDI_MOVEDOWN2 ) : MAKEINTRESOURCE( IDI_MOVEDOWN ),
|
|
IMAGE_ICON, 16, 16, 0 );
|
|
upIcon = (HICON)LoadImage( _Module.m_hInstResource,
|
|
S_OK == hrAlternateIcon ? MAKEINTRESOURCE( IDI_MOVEUP2 ) : MAKEINTRESOURCE( IDI_MOVEUP ),
|
|
IMAGE_ICON, 16, 16, 0 );
|
|
|
|
m_BtnDown.SetIcon( downIcon );
|
|
m_BtnUp.SetIcon( upIcon );
|
|
|
|
//
|
|
// Setup up rules listview
|
|
//
|
|
CString sTitle;
|
|
m_listIncExc.GetClientRect( &rect );
|
|
ULONG totalWidth = rect.right;
|
|
|
|
RsGetInitialLVColumnProps(
|
|
IDS_LISTVIEW_WIDTHS_IE,
|
|
IDS_LISTVIEW_TITLES_IE,
|
|
columnWidths,
|
|
columnTitles,
|
|
&cColumns
|
|
);
|
|
|
|
//
|
|
// NOTE: We shouldn't throw any errors until the DC is released
|
|
//
|
|
for( int col = 0; col < cColumns; col++ ) {
|
|
|
|
size = m_listIncExc.GetStringWidth( *columnWidths[col] );
|
|
columnWidth[col] = size.cx + 12;
|
|
m_listIncExc.InsertColumn( col, *columnTitles[col], LVCFMT_LEFT, columnWidth[col] );
|
|
|
|
// Free the CStrings
|
|
delete columnTitles[col];
|
|
delete columnWidths[col];
|
|
|
|
}
|
|
|
|
m_listIncExc.Initialize( cColumns, IE_COLUMN_PATH );
|
|
|
|
// Set the Path column to fit
|
|
int leftOver = totalWidth - columnWidth[IE_COLUMN_ACTION] -
|
|
columnWidth[IE_COLUMN_FILE_TYPE] - columnWidth[IE_COLUMN_ATTRS];
|
|
m_listIncExc.SetColumnWidth( IE_COLUMN_PATH, leftOver );
|
|
|
|
// Note: this page is only implemented for single select
|
|
WsbAffirm( ( m_pParent->IsMultiSelect( ) != S_OK ), E_FAIL );
|
|
|
|
// Get the FsaServer interface - Apply will need it
|
|
WsbAffirmHr( m_pParent->GetFsaServer( &m_pFsaServer ) );
|
|
// Get the resource pointer from the sheet object
|
|
WsbAffirmHr( m_pVolParent->GetFsaResource( &m_pFsaResource ) );
|
|
|
|
// Get the rules collection from the resource
|
|
CComPtr <IWsbCollection> pRulesCollection;
|
|
WsbAffirmHr( m_pFsaResource->GetDefaultRules( &pRulesCollection ) );
|
|
WsbAffirmHr( pRulesCollection->QueryInterface( IID_IWsbIndexedCollection, (void **) &m_pRulesIndexedCollection ) );
|
|
|
|
CString resourceName;
|
|
WsbAffirmHr( RsGetVolumeDisplayName( m_pFsaResource, resourceName ) );
|
|
m_pResourceName = resourceName;
|
|
|
|
// Itterate through the indexed collection
|
|
WsbAffirmHr( m_pRulesIndexedCollection->GetEntries( &count ) );
|
|
|
|
CComPtr <IHsmRule> pLocalRule;
|
|
CComPtr <IHsmRule> pHsmRule;
|
|
|
|
// Put the rules in the collection in reverse order
|
|
for( INT i =( int ) count - 1; i >= 0; i-- ) {
|
|
|
|
pHsmRule.Release( );
|
|
pLocalRule.Release( );
|
|
WsbAffirmHr( m_pRulesIndexedCollection->At( i, IID_IHsmRule,( void** )&pHsmRule ) );
|
|
|
|
//
|
|
// Create a local rule object and copy the remote object to it
|
|
//
|
|
WsbAffirmHr( pLocalRule.CoCreateInstance( CLSID_CHsmRule ) );
|
|
WsbAffirmHr( GetRuleFromObject( pHsmRule, path, name, &bInclude, &bSubdirs, &bUserDefined ) );
|
|
WsbAffirmHr( SetRuleInObject( pLocalRule, path, name, bInclude, bSubdirs, bUserDefined ) );
|
|
|
|
//
|
|
// Insert rule in list box
|
|
//
|
|
index = m_listIncExc.InsertItem( count - 1 - i, TEXT( "" ) );
|
|
|
|
//
|
|
// Set the item data to the local object
|
|
//
|
|
m_listIncExc.SetItemData( index, (UINT_PTR) pLocalRule.Detach( ) );
|
|
|
|
//
|
|
// Show the rule in the list box
|
|
//
|
|
WsbAffirmHr( DisplayUserRuleText( &m_listIncExc, index ) );
|
|
|
|
} // for
|
|
|
|
SortList( );
|
|
|
|
} WsbCatch( hr );
|
|
|
|
SetBtnState( );
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
//HRESULT CPrMrIe::CreateImageList( )
|
|
//{
|
|
// HICON hIcon;
|
|
// int nImage;
|
|
// HRESULT hr;
|
|
//
|
|
// AFX_MANAGE_STATE( AfxGetStaticModuleState( ) );
|
|
//
|
|
// try {
|
|
//
|
|
// CWinApp* pApp = AfxGetApp( );
|
|
//
|
|
// WsbAffirm( m_ImageList.Create( ::GetSystemMetrics( SM_CXSMICON ),
|
|
// ::GetSystemMetrics( SM_CYSMICON ),
|
|
// ILC_COLOR | ILC_MASK, 2,5 ), E_FAIL );
|
|
//
|
|
// hIcon = pApp->LoadIcon( IDI_LOCKED );
|
|
// WsbAffirm( hIcon, E_FAIL );
|
|
// nImage = m_ImageList.Add( hIcon );
|
|
// ::DeleteObject( hIcon );
|
|
//
|
|
// hIcon = pApp->LoadIcon( IDI_UNLOCKED );
|
|
// WsbAffirm( hIcon, E_FAIL );
|
|
// nImage = m_ImageList.Add( hIcon );
|
|
// ::DeleteObject( hIcon );
|
|
//
|
|
// m_listIncExc.SetImageList( &m_ImageList, LVSIL_SMALL );
|
|
// } WsbCatch( hr );
|
|
// return( hr );
|
|
//}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Display the rule contained in the supplied object in the supplied list at the indicated
|
|
// index. The itemdata must be set to the object with correct data in it.
|
|
//
|
|
HRESULT CPrMrIe::DisplayUserRuleText(
|
|
CListCtrl *pListControl,
|
|
int index )
|
|
{
|
|
AFX_MANAGE_STATE( AfxGetStaticModuleState( ) );
|
|
|
|
HRESULT hr = S_OK;
|
|
try {
|
|
|
|
CString textString, tempString;
|
|
CString path, name;
|
|
BOOL bInclude;
|
|
BOOL bSubdirs;
|
|
BOOL bUserDefined;
|
|
CComPtr<IHsmRule> pHsmRule;
|
|
|
|
//
|
|
// Get the rule from the object
|
|
//
|
|
pHsmRule = (IHsmRule *) m_listIncExc.GetItemData( index );
|
|
WsbAssertPointer( pHsmRule );
|
|
WsbAffirmHr( GetRuleFromObject( pHsmRule, path, name, &bInclude, &bSubdirs, &bUserDefined ) );
|
|
|
|
//
|
|
// Show the values in the list box
|
|
//
|
|
|
|
// ACTION
|
|
textString.LoadString( bInclude ? IDS_INCLUDE : IDS_EXCLUDE );
|
|
WsbAffirm( pListControl->SetItemText( index, IE_COLUMN_ACTION, textString ), E_FAIL );
|
|
|
|
// FILE TYPE
|
|
WsbAffirm( pListControl->SetItemText( index, IE_COLUMN_FILE_TYPE, name ), E_FAIL );
|
|
|
|
// PATH
|
|
WsbAffirm( pListControl->SetItemText( index, IE_COLUMN_PATH, path ), E_FAIL );
|
|
|
|
// ATTRS
|
|
textString.LoadString( bSubdirs ? IDS_RULE_SUBDIRS_USE : IDS_RULE_SUBDIRS_IGNORE );
|
|
tempString.LoadString( bUserDefined ? IDS_RULE_TYPE_USER : IDS_RULE_TYPE_SYSTEM );
|
|
textString.TrimLeft( );
|
|
tempString.TrimLeft( );
|
|
textString += tempString;
|
|
WsbAffirm( pListControl->SetItemText( index, IE_COLUMN_ATTRS, textString ), E_FAIL );
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT CPrMrIe::GetRuleFromObject(
|
|
IHsmRule *pHsmRule,
|
|
CString& Path,
|
|
CString& Name,
|
|
BOOL *bInclude,
|
|
BOOL *bSubdirs,
|
|
BOOL *bUserDefined )
|
|
{
|
|
CWsbStringPtr wsbName;
|
|
CWsbStringPtr wsbPath;
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
// Get the values from the object
|
|
WsbAffirmHr( pHsmRule->GetName( &wsbName, 0 ) );
|
|
Name = wsbName;
|
|
WsbAffirmHr ( pHsmRule->GetPath( &wsbPath, 0 ) );
|
|
Path = wsbPath;
|
|
*bInclude =( pHsmRule->IsInclude( ) == S_OK ) ? TRUE : FALSE;
|
|
*bSubdirs =( pHsmRule->IsUsedInSubDirs( ) == S_OK ) ? TRUE : FALSE;
|
|
*bUserDefined =( pHsmRule->IsUserDefined( ) == S_OK ) ? TRUE : FALSE;
|
|
} WsbCatch( hr );
|
|
return( hr );
|
|
}
|
|
void CPrMrIe::OnBtnAdd( )
|
|
{
|
|
LRESULT nRet;
|
|
int index;
|
|
BOOL fDone = FALSE;
|
|
HRESULT hr;
|
|
|
|
AFX_MANAGE_STATE( AfxGetStaticModuleState( ) );
|
|
|
|
CRule ruleDlg;
|
|
ruleDlg.m_subDirs = FALSE;
|
|
ruleDlg.m_includeExclude = 0; // Exclude
|
|
ruleDlg.m_path = TEXT( "" );
|
|
ruleDlg.m_fileSpec = TEXT( "" );
|
|
ruleDlg.m_pResourceName = m_pResourceName;
|
|
|
|
try {
|
|
while( !fDone )
|
|
{
|
|
nRet = ruleDlg.DoModal( );
|
|
if( nRet == IDOK ) {
|
|
|
|
//
|
|
// OK was pressed
|
|
// Check for dupes( in entire list )
|
|
//
|
|
if( !IsRuleInList( ruleDlg.m_path, ruleDlg.m_fileSpec, -1 ) ) {
|
|
|
|
fDone = TRUE;
|
|
|
|
//
|
|
// Create a new local rule object
|
|
//
|
|
CComPtr <IHsmRule> pLocalRule;
|
|
WsbAffirmHr( pLocalRule.CoCreateInstance( CLSID_CHsmRule ) );
|
|
|
|
//
|
|
// Set the data in the local object
|
|
//
|
|
WsbAffirmHr( SetRuleInObject( pLocalRule, ruleDlg.m_path, ruleDlg.m_fileSpec,
|
|
ruleDlg.m_includeExclude, ruleDlg.m_subDirs, TRUE ) );
|
|
|
|
//
|
|
// Insert the rule and put the pointer in the list.
|
|
// We will sort the list later
|
|
//
|
|
index = m_listIncExc.InsertItem( 0, TEXT( "" ) );
|
|
|
|
//
|
|
// Set the item data to the local object
|
|
//
|
|
m_listIncExc.SetItemData( index, (UINT_PTR) pLocalRule.Detach( ) );
|
|
|
|
//
|
|
// Show the rule in the list box
|
|
//
|
|
WsbAffirmHr( DisplayUserRuleText( &m_listIncExc, index ) );
|
|
|
|
//
|
|
// Sort the list
|
|
//
|
|
SortList( );
|
|
SetSelectedItem( (ULONG_PTR)(void *) pLocalRule );
|
|
SetModified( );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Rule is a duplicate
|
|
//
|
|
CString sText;
|
|
AfxFormatString2( sText, IDS_ERR_RULE_DUPLICATE, ruleDlg.m_path, ruleDlg.m_fileSpec );
|
|
AfxMessageBox( sText, RS_MB_ERROR );
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Cancel was pressed
|
|
//
|
|
fDone = TRUE;
|
|
|
|
}
|
|
|
|
} // while
|
|
} WsbCatch( hr )
|
|
|
|
SetBtnState( );
|
|
}
|
|
|
|
// Select the item corresponding to the supplied item data
|
|
void CPrMrIe::SetSelectedItem( ULONG_PTR itemData )
|
|
{
|
|
|
|
int listCount = m_listIncExc.GetItemCount( );
|
|
for( int i = 0; i < listCount; i++ ) {
|
|
|
|
// Get the pointer to the rule from the list box
|
|
if( itemData ==( m_listIncExc.GetItemData( i ) ) ) {
|
|
|
|
// Mark the item as selected
|
|
m_listIncExc.SetItemState( i, LVIS_SELECTED, LVIS_SELECTED );
|
|
m_listIncExc.EnsureVisible( i, FALSE );
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void CPrMrIe::OnBtnDown( )
|
|
{
|
|
|
|
MoveSelectedListItem( &m_listIncExc, + 1 );
|
|
SetBtnState( );
|
|
}
|
|
|
|
void CPrMrIe::SortList( )
|
|
{
|
|
m_listIncExc.SortItems( CompareFunc, NULL );
|
|
}
|
|
|
|
int CALLBACK CompareFunc( LPARAM lParam1, LPARAM lParam2,
|
|
LPARAM /*lParamSort*/ )
|
|
{
|
|
CComPtr<IHsmRule> pHsmRule;
|
|
CWsbStringPtr wsbPathA;
|
|
CWsbStringPtr wsbPathB;
|
|
|
|
// Get data for RuleA
|
|
pHsmRule = (IHsmRule *) lParam1;
|
|
WsbAffirmHr( pHsmRule->GetPath( &wsbPathA, 0 ) );
|
|
CString pathA = wsbPathA;
|
|
|
|
// Get data for RuleB
|
|
pHsmRule = (IHsmRule *) lParam2;
|
|
WsbAffirmHr ( pHsmRule->GetPath( &wsbPathB, 0 ) );
|
|
CString pathB = wsbPathB;
|
|
|
|
// Upper case the paths
|
|
pathA.MakeUpper( );
|
|
pathB.MakeUpper( );
|
|
|
|
// Compare the two paths
|
|
int rVal = PathCollate( pathA, pathB );
|
|
// int rVal = pathA.Collate( pathB );
|
|
// int rVal = pathB.Compare( pathA );
|
|
|
|
return rVal;
|
|
}
|
|
|
|
int PathCollate( CString PathA, CString PathB )
|
|
{
|
|
CString charA;
|
|
CString charB;
|
|
int compareLen;
|
|
int rVal;
|
|
|
|
int lenA = PathA.GetLength( );
|
|
int lenB = PathB.GetLength( );
|
|
|
|
compareLen = min( lenA, lenB );
|
|
|
|
for( int i = 0; i < compareLen; i++ )
|
|
{
|
|
charA = PathA.GetAt( i );
|
|
charB = PathB.GetAt( i );
|
|
|
|
// If either is a \, we bypass Collate
|
|
if( ( charA == L"\\" ) &( charB != L"\\" ) ) {
|
|
|
|
// A is \ and B is not - A is less than B
|
|
return -1;
|
|
|
|
}
|
|
if( ( charA != L"\\" ) &( charB == L"\\" ) ) {
|
|
|
|
// A is not \ and B is - B is less than A
|
|
return 1;
|
|
|
|
}
|
|
|
|
// NOTE: If both are \, the CString Collate result is correct
|
|
|
|
rVal = charA.Collate( charB );
|
|
if( rVal != 0 ) {
|
|
|
|
return rVal;
|
|
|
|
}
|
|
|
|
}
|
|
// If we get here, the strings are equal as far as the shorter string.
|
|
rVal = ( lenA < lenB ) ? -1 : ( lenB < lenA ) ? 1 : 0;
|
|
|
|
return rVal;
|
|
}
|
|
|
|
void CPrMrIe::MoveSelectedListItem( CListCtrl *pList, int moveAmount )
|
|
{
|
|
|
|
int curIndex = -1;
|
|
int itemCount = 0;
|
|
CString pathA;
|
|
CString pathB;
|
|
CString path;
|
|
CString name;
|
|
BOOL bInclude;
|
|
BOOL bSubdirs;
|
|
BOOL bUserDefined;
|
|
CComPtr<IHsmRule> pLocalRule;
|
|
|
|
// Get the current index
|
|
curIndex = pList->GetNextItem( -1, LVNI_SELECTED );
|
|
|
|
// Is an item selected?
|
|
if( curIndex != -1 ) {
|
|
|
|
// Is this a user-defined rule?
|
|
pLocalRule =( IHsmRule * ) m_listIncExc.GetItemData( curIndex );
|
|
|
|
GetRuleFromObject( pLocalRule, path, name, &bInclude, &bSubdirs, &bUserDefined );
|
|
if( bUserDefined )
|
|
{
|
|
// Get the item count
|
|
itemCount = pList->GetItemCount( );
|
|
|
|
// Is there more than one item in the list?
|
|
if( itemCount > 1 )
|
|
{
|
|
// Make sure where we're moving to is in range
|
|
if( ( ( curIndex + moveAmount ) < itemCount ) &&
|
|
( ( curIndex + moveAmount ) >= 0 ) ) {
|
|
|
|
// Does the rule we're moving to have the same path?
|
|
pathA = pList->GetItemText( curIndex, IE_COLUMN_PATH );
|
|
pathB = pList->GetItemText( curIndex + moveAmount, IE_COLUMN_PATH );
|
|
|
|
if( pathA.CompareNoCase( pathB ) == 0 ) {
|
|
// Swap the lines
|
|
SwapLines( pList, curIndex, curIndex + moveAmount );
|
|
// Select the orignal line in it's new position and make
|
|
// sure it's shown.
|
|
pList->SetItemState( curIndex + moveAmount, LVIS_SELECTED, LVIS_SELECTED );
|
|
pList->EnsureVisible( curIndex + moveAmount, FALSE );
|
|
|
|
SetModified( );
|
|
}
|
|
else {
|
|
MessageBeep( MB_OK );
|
|
}
|
|
|
|
} else {
|
|
MessageBeep( MB_OK );
|
|
}
|
|
}
|
|
else {
|
|
MessageBeep( MB_OK );
|
|
}
|
|
|
|
} else {
|
|
MessageBeep( MB_OK );
|
|
}
|
|
} else {
|
|
MessageBeep( MB_OK );
|
|
}
|
|
}
|
|
void CPrMrIe::SwapLines( CListCtrl *pListControl, int indexA, int indexB )
|
|
{
|
|
|
|
CComPtr<IHsmRule> pHsmRuleA;
|
|
CComPtr<IHsmRule> pHsmRuleB;
|
|
|
|
//-------------------- Get data from list ----------------------------------
|
|
// LIST A
|
|
// Get the item data
|
|
pHsmRuleA = (IHsmRule *) pListControl->GetItemData( indexA );
|
|
|
|
// LIST B
|
|
// Get the item data
|
|
pHsmRuleB = (IHsmRule *) pListControl->GetItemData( indexB );
|
|
|
|
//--------------------- Show data in list ------------------------------------
|
|
|
|
// Set the item data
|
|
m_listIncExc.SetItemData( indexA,( DWORD_PTR )( void * ) pHsmRuleB );
|
|
|
|
// Show the rule
|
|
DisplayUserRuleText( pListControl, indexA );
|
|
|
|
// Set the item data
|
|
m_listIncExc.SetItemData( indexB,( DWORD_PTR )( void * ) pHsmRuleA );
|
|
|
|
// Show the rule
|
|
DisplayUserRuleText( pListControl, indexB );
|
|
|
|
}
|
|
|
|
void CPrMrIe::SetBtnState( )
|
|
{
|
|
CString path;
|
|
CString name;
|
|
CWsbStringPtr pathAbove;
|
|
CWsbStringPtr pathBelow;
|
|
BOOL bInclude;
|
|
BOOL bSubdirs;
|
|
BOOL bUserDefined;
|
|
int curIndex;
|
|
CComPtr<IHsmRule> pLocalRule;
|
|
CComPtr<IHsmRule> pLocalRuleAbove;
|
|
CComPtr<IHsmRule> pLocalRuleBelow;
|
|
|
|
|
|
curIndex = m_listIncExc.GetNextItem( -1, LVNI_SELECTED );
|
|
if( curIndex != -1 ) {
|
|
// An item is selected. Is it User-Defined?
|
|
pLocalRule =( IHsmRule * ) m_listIncExc.GetItemData( curIndex );
|
|
if( !pLocalRule ) {
|
|
|
|
// Seperator
|
|
m_BtnRemove.EnableWindow( FALSE );
|
|
m_BtnEdit.EnableWindow( FALSE );
|
|
m_BtnAdd.EnableWindow( TRUE );
|
|
m_BtnUp.EnableWindow( FALSE );
|
|
m_BtnDown.EnableWindow( FALSE );
|
|
|
|
} else {
|
|
|
|
GetRuleFromObject( pLocalRule, path, name, &bInclude, &bSubdirs, &bUserDefined );
|
|
if( bUserDefined ) {
|
|
// User-Defined Rule is editable
|
|
m_BtnRemove.EnableWindow( TRUE );
|
|
m_BtnEdit.EnableWindow( TRUE );
|
|
m_BtnAdd.EnableWindow( TRUE );
|
|
// Are we at the top?
|
|
if( curIndex == 0 ) {
|
|
|
|
m_BtnUp.EnableWindow( FALSE );
|
|
|
|
} else {
|
|
|
|
// Does the rule above have the same path? or is separator
|
|
pLocalRuleAbove =( IHsmRule * ) m_listIncExc.GetItemData( curIndex - 1 );
|
|
if( pLocalRuleAbove ) {
|
|
pLocalRuleAbove->GetPath( &pathAbove, 0 );
|
|
if( path.CompareNoCase( pathAbove ) == 0 ) {
|
|
m_BtnUp.EnableWindow( TRUE );
|
|
} else {
|
|
m_BtnUp.EnableWindow( FALSE );
|
|
}
|
|
} else {
|
|
m_BtnUp.EnableWindow( FALSE );
|
|
}
|
|
|
|
}
|
|
// Are we at the bottom?
|
|
if( curIndex ==( m_listIncExc.GetItemCount( ) - 1 ) ) {
|
|
m_BtnDown.EnableWindow( FALSE );
|
|
} else {
|
|
// Does the rule below have the same path?
|
|
pLocalRuleBelow =( IHsmRule * ) m_listIncExc.GetItemData( curIndex + 1 );
|
|
if( pLocalRuleBelow ) {
|
|
pLocalRuleBelow->GetPath( &pathBelow, 0 );
|
|
if( path.CompareNoCase( pathBelow ) == 0 ) {
|
|
m_BtnDown.EnableWindow( TRUE );
|
|
} else {
|
|
m_BtnDown.EnableWindow( FALSE );
|
|
}
|
|
} else {
|
|
m_BtnDown.EnableWindow( FALSE );
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// System rule. Cannot be moved or modified.
|
|
m_BtnUp.EnableWindow( FALSE );
|
|
m_BtnRemove.EnableWindow( FALSE );
|
|
m_BtnEdit.EnableWindow( FALSE );
|
|
m_BtnDown.EnableWindow( FALSE );
|
|
m_BtnAdd.EnableWindow( TRUE );
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// No items selected
|
|
m_BtnUp.EnableWindow( FALSE );
|
|
m_BtnRemove.EnableWindow( FALSE );
|
|
m_BtnEdit.EnableWindow( FALSE );
|
|
m_BtnDown.EnableWindow( FALSE );
|
|
m_BtnAdd.EnableWindow( TRUE );
|
|
}
|
|
}
|
|
|
|
void CPrMrIe::OnBtnRemove( )
|
|
{
|
|
int curIndex;
|
|
CString path;
|
|
CString name;
|
|
BOOL bInclude;
|
|
BOOL bSubdirs;
|
|
BOOL bUserDefined;
|
|
IHsmRule *pHsmRule; // OK to not use smart pointer
|
|
HRESULT hr;
|
|
|
|
AFX_MANAGE_STATE( AfxGetStaticModuleState( ) );
|
|
|
|
try {
|
|
// Is there an item selected?
|
|
curIndex = m_listIncExc.GetNextItem( -1, LVNI_SELECTED );
|
|
if( curIndex != -1 )
|
|
{
|
|
// Is the rule User-Defined?
|
|
pHsmRule =( IHsmRule * ) m_listIncExc.GetItemData( curIndex );
|
|
GetRuleFromObject( pHsmRule, path, name, &bInclude, &bSubdirs, &bUserDefined );
|
|
|
|
if( bUserDefined )
|
|
{
|
|
|
|
// Confirm with user
|
|
CString sMessage;
|
|
AfxFormatString2( sMessage, IDS_CONFIRM_DELETE_RULE, path, name );
|
|
if( AfxMessageBox( sMessage, MB_ICONQUESTION | MB_DEFBUTTON2 | MB_YESNO ) == IDYES )
|
|
{
|
|
// Get and release the local object pointer
|
|
WsbAffirmPointer( pHsmRule );
|
|
pHsmRule->Release( );
|
|
|
|
// Remove from the list control
|
|
m_listIncExc.DeleteItem( curIndex );
|
|
int setIndex;
|
|
if( curIndex >= m_listIncExc.GetItemCount( ) ) {
|
|
setIndex = m_listIncExc.GetItemCount( ) - 1;
|
|
} else {
|
|
setIndex = curIndex;
|
|
}
|
|
|
|
// Select the item above the removed item
|
|
m_listIncExc.SetItemState( setIndex, LVIS_SELECTED, LVIS_SELECTED );
|
|
m_listIncExc.EnsureVisible( setIndex, FALSE );
|
|
SortList( );
|
|
SetModified( );
|
|
}
|
|
}
|
|
else {
|
|
MessageBeep( MB_OK );
|
|
}
|
|
}
|
|
else {
|
|
|
|
// No item selected
|
|
AfxMessageBox( IDS_ERR_NO_ITEM_SELECTED, RS_MB_ERROR );
|
|
}
|
|
} WsbCatch( hr );
|
|
SetBtnState( );
|
|
}
|
|
|
|
void CPrMrIe::OnBtnUp( )
|
|
{
|
|
MoveSelectedListItem( &m_listIncExc, - 1 );
|
|
SetBtnState( );
|
|
}
|
|
|
|
void CPrMrIe::OnBtnEdit( )
|
|
{
|
|
BOOL fDone = FALSE;
|
|
LRESULT nRet;
|
|
int curIndex;
|
|
CString path;
|
|
CString name;
|
|
BOOL bInclude;
|
|
BOOL bSubdirs;
|
|
BOOL bUserDefined;
|
|
|
|
HRESULT hr;
|
|
|
|
AFX_MANAGE_STATE( AfxGetStaticModuleState( ) );
|
|
|
|
|
|
try {
|
|
|
|
// Get the currently selected item
|
|
curIndex = m_listIncExc.GetNextItem( -1, LVNI_SELECTED );
|
|
if( curIndex == -1 ) {
|
|
|
|
// No item selected
|
|
AfxMessageBox( IDS_ERR_NO_ITEM_SELECTED, RS_MB_ERROR );
|
|
|
|
} else {
|
|
|
|
// Create the rule dialog
|
|
CRule ruleDlg;
|
|
|
|
// Get the local object from the list itemdata
|
|
CComPtr<IHsmRule> pLocalRule;
|
|
pLocalRule = (IHsmRule *) m_listIncExc.GetItemData( curIndex );
|
|
WsbAffirmPointer( pLocalRule );
|
|
|
|
// Get the rule from the local object
|
|
WsbAffirmHr( GetRuleFromObject( pLocalRule, path, name, &bInclude, &bSubdirs, &bUserDefined ) );
|
|
|
|
// Is this a user-defined rule?
|
|
if( bUserDefined ) {
|
|
|
|
// Set the rule info in the rule dialog
|
|
ruleDlg.m_subDirs = bSubdirs;
|
|
ruleDlg.m_includeExclude = bInclude;
|
|
ruleDlg.m_path = path;
|
|
ruleDlg.m_fileSpec = name;
|
|
ruleDlg.m_pResourceName = m_pResourceName;
|
|
|
|
|
|
while( !fDone ) {
|
|
|
|
// Show the dialog
|
|
nRet = ruleDlg.DoModal( );
|
|
if( nRet == IDOK ) {
|
|
// OK was pressed
|
|
|
|
// Check for duplicates - but don't check against the rule we edited
|
|
// in case the path and fileSpec are stil the same
|
|
|
|
if( !IsRuleInList( ruleDlg.m_path, ruleDlg.m_fileSpec, curIndex ) ) {
|
|
|
|
fDone = TRUE;
|
|
SetModified( );
|
|
|
|
// Set the data in the local object
|
|
WsbAffirmHr( SetRuleInObject( pLocalRule, ruleDlg.m_path, ruleDlg.m_fileSpec,
|
|
ruleDlg.m_includeExclude, ruleDlg.m_subDirs, TRUE ) );
|
|
|
|
// Show the edited rule in the list box
|
|
WsbAffirmHr( DisplayUserRuleText( &m_listIncExc, curIndex ) );
|
|
|
|
// Resort the list
|
|
SortList( );
|
|
SetSelectedItem( (ULONG_PTR)(IHsmRule*) pLocalRule );
|
|
|
|
} else {
|
|
|
|
CString sText;
|
|
AfxFormatString2( sText, IDS_ERR_RULE_DUPLICATE, ruleDlg.m_path, ruleDlg.m_fileSpec );
|
|
AfxMessageBox( sText, RS_MB_ERROR );
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fDone = TRUE;
|
|
|
|
}
|
|
|
|
} // while
|
|
|
|
} else { // Not user defined
|
|
|
|
MessageBeep( MB_OK );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} WsbCatch( hr );
|
|
SetBtnState( );
|
|
}
|
|
|
|
BOOL CPrMrIe::IsRuleInList( CString Path, CString Name, int ignoreIndex )
|
|
{
|
|
int i;
|
|
int count;
|
|
short result;
|
|
HRESULT hr;
|
|
BOOL fDuplicate = FALSE;
|
|
CWsbStringPtr wsbPath;
|
|
CWsbStringPtr wsbName;
|
|
|
|
count = m_listIncExc.GetItemCount( );
|
|
for( i = 0; i < count; i++ ) {
|
|
// Make sure we're not comparing the rule to itself
|
|
if( i != ignoreIndex ) {
|
|
|
|
// Get the pointer to the rule from the list box
|
|
CComPtr<IHsmRule> pHsmRule;
|
|
pHsmRule = (IHsmRule *) m_listIncExc.GetItemData( i );
|
|
if( !pHsmRule ) continue;
|
|
|
|
// Convert name and path to wsb strings
|
|
wsbPath = Path;
|
|
wsbName = Name;
|
|
|
|
hr = pHsmRule->CompareToPathAndName( wsbPath, wsbName, &result );
|
|
if( result == 0 ) {
|
|
|
|
// The rules are the same
|
|
fDuplicate = TRUE;
|
|
break;
|
|
}
|
|
|
|
}
|
|
} // for
|
|
return fDuplicate;
|
|
}
|
|
|
|
void CPrMrIe::OnDestroy( )
|
|
{
|
|
HRESULT hr;
|
|
CSakVolPropPage::OnDestroy( );
|
|
IHsmRule *pHsmRule; //OK not to be smart pointer
|
|
ULONG lRefCount;
|
|
|
|
try {
|
|
|
|
// Release all local object pointers in the list box
|
|
int listCount = m_listIncExc.GetItemCount( );
|
|
for( int i = 0; i < listCount; i++ )
|
|
{
|
|
// Get the pointer to the rule from the list box
|
|
pHsmRule = (IHsmRule *) m_listIncExc.GetItemData( i );
|
|
if( pHsmRule ) {
|
|
|
|
lRefCount = pHsmRule->Release( );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} WsbCatch( hr );
|
|
}
|
|
|
|
void CPrMrIe::OnDblclkListIe( NMHDR* /*pNMHDR*/, LRESULT* pResult )
|
|
{
|
|
OnBtnEdit( );
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CPrMrIe::OnClickListIe( NMHDR* /*pNMHDR*/, LRESULT* pResult )
|
|
{
|
|
SetBtnState( );
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CPrMrIe::OnItemchangedListIe( NMHDR* pNMHDR, LRESULT* pResult )
|
|
{
|
|
NM_LISTVIEW* pNMListView =( NM_LISTVIEW* )pNMHDR;
|
|
SetBtnState( );
|
|
*pResult = 0;
|
|
}
|
|
|
|
|
|
void CPrMrIe::OnVScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
|
|
CSakVolPropPage::OnVScroll( nSBCode, nPos, pScrollBar );
|
|
}
|
|
|
|
void CPrMrIe::OnDrawItem( int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct )
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
|
|
CSakVolPropPage::OnDrawItem( nIDCtl, lpDrawItemStruct );
|
|
}
|
|
|
|
void CPrMrIe::OnMeasureItem( int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct )
|
|
{
|
|
CFont *pFont;
|
|
LOGFONT logFont;
|
|
|
|
pFont = GetFont( );
|
|
pFont->GetLogFont( &logFont );
|
|
|
|
LONG fontHeight = abs( logFont.lfHeight );
|
|
|
|
// Ask the list how high to make each row. It needs to know the font
|
|
// height at this point because it's window is not yet created.
|
|
lpMeasureItemStruct->itemHeight = m_listIncExc.GetItemHeight( fontHeight );
|
|
|
|
CSakVolPropPage::OnMeasureItem( nIDCtl, lpMeasureItemStruct );
|
|
}
|