WTL::CString CObjectUIHandler::GetType(CDiskObjectPtr obj) const
{
WTL::CString strTitle;
if(obj->IsUnitDisk())
{
if(dynamic_cast<CEmptyDiskObject*>(obj.get()) != NULL)
{
strTitle.LoadString(IDS_UNIDEV_TYPE_DISK_EMPTY);
}
else
{
strTitle.LoadString(IDS_LOGDEV_TYPE_SINGLE_DISK);
}
}
else
{
CDiskObjectCompositePtr pDiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(obj);
switch(pDiskObjectComposite->GetNDASMediaType())
{
case NMT_SINGLE: strTitle.LoadString(IDS_LOGDEV_TYPE_SINGLE_DISK); break;
case NMT_AGGREGATE: strTitle.LoadString(IDS_LOGDEV_TYPE_AGGREGATED_DISK); break;
case NMT_MIRROR: strTitle.LoadString(IDS_LOGDEV_TYPE_MIRRORED_DISK); break;
case NMT_RAID0: strTitle.LoadString(IDS_LOGDEV_TYPE_DISK_RAID0); break;
case NMT_RAID1: strTitle.LoadString(IDS_LOGDEV_TYPE_DISK_RAID1); break;
case NMT_RAID4: strTitle.LoadString(IDS_LOGDEV_TYPE_DISK_RAID4); break;
case NMT_CDROM: strTitle.LoadString(IDS_LOGDEV_TYPE_DVD_DRIVE); break;
case NMT_OPMEM: strTitle.LoadString(IDS_LOGDEV_TYPE_MO_DRIVE); break;
case NMT_FLASH: strTitle.LoadString(IDS_LOGDEV_TYPE_CF_DRIVE); break;
default:
strTitle.FormatMessage(IDS_LOGDEV_TYPE_UNKNOWN_FMT,
pDiskObjectComposite->GetNDASMediaType());
}
}
return strTitle;
}
WTL::CString CObjectUIHandler::GetTitle(CDiskObjectPtr obj) const
{
WTL::CString strTitle;
if(obj->IsUnitDisk())
{
if(dynamic_cast<CEmptyDiskObject*>(obj.get()) != NULL)
{
strTitle.LoadString(IDS_UNIDEV_TYPE_DISK_EMPTY);
}
else
{
strTitle = obj->GetTitle();
}
}
else
{
strTitle = GetType(obj);
}
return strTitle;
}
LRESULT CMainFrame::OnSelChanged(LPNMHDR /*lpNLHDR*/)
{
CTreeItem itemSelected;
itemSelected = m_view.GetSelectedItem();
UIEnable(IDM_AGGR_UNBIND, FALSE);
UIEnable(IDM_AGGR_SYNCHRONIZE, FALSE);
UIEnable(IDM_AGGR_ADDMIRROR, FALSE);
if ( !itemSelected.IsNull() )
{
CDiskObjectPtr obj = m_mapObject[itemSelected.GetData()];
ATLASSERT( obj.get() != NULL );
CCommandSet cmdSet =
CObjectUIHandler::GetUIHandler(obj)->GetCommandSet(obj);
CCommandSet::iterator itr;
for ( itr = cmdSet.begin(); itr != cmdSet.end(); itr++ )
{
UIEnable( itr->GetID(), !itr->IsDisabled() );
}
}
return 0;
}
void CMainFrame::RefreshAction()
{
int iItemSelected;
// UIEnable(IDM_AGGR_BIND, FALSE);
UIEnable(IDM_AGGR_UNBIND, FALSE);
UIEnable(IDM_AGGR_SYNCHRONIZE, FALSE);
UIEnable(IDM_AGGR_ADDMIRROR, FALSE);
if (-1 != (iItemSelected = m_viewTreeList.GetSelectedItemData()))
{
CDiskObjectPtr obj = m_mapObject[iItemSelected];
ATLASSERT( obj.get() != NULL );
CCommandSet cmdSet =
CObjectUIHandler::GetUIHandler(obj)->GetCommandSet(obj);
CCommandSet::iterator itr;
for ( itr = cmdSet.begin(); itr != cmdSet.end(); itr++ )
{
UIEnable( itr->GetID(), !itr->IsDisabled() );
}
}
}
CCommandSet CMirDiskUIHandler::GetCommandSet(CDiskObjectPtr obj) const
{
ATLASSERT( dynamic_cast<const CMirDiskObject*>(obj.get()) != NULL );
CCommandSet setCommand;
BOOL bCanWrite;
CMirDiskObjectPtr mirDisk =
boost::dynamic_pointer_cast<CMirDiskObject>(obj);
bCanWrite = mirDisk->GetAccessMask() & GENERIC_WRITE;
setCommand.push_back( CCommand( IDM_TOOL_UNBIND, bCanWrite ) );
if(NMT_MIRROR == mirDisk->GetNDASMediaType())
{
// migrate : mirror -> RAID 1
setCommand.push_back( CCommand( IDM_TOOL_MIGRATE,
!mirDisk->IsBroken() && mirDisk->HasWriteAccess()));
}
else
{
// do not check IsDirty here (cause it takes some time)
setCommand.push_back( CCommand( IDM_TOOL_SYNCHRONIZE,
/* bCanWrite && */ mirDisk->IsDirty() && !mirDisk->IsBroken() && mirDisk->HasWriteAccess()));
}
return setCommand;
}
BOOL CMirDiskUIHandler::OnSynchronize(CDiskObjectPtr obj) const
{
ATLASSERT( dynamic_cast<CMirDiskObject*>(obj.get()) != NULL );
CMirDiskObjectPtr mirDisk =
boost::dynamic_pointer_cast<CMirDiskObject>(obj);
CUnitDiskObjectPtr sourceDisk, destDisk;
BOOL bFirstDefected, bSecondDefected;
BOOL bResults;
bResults = mirDisk->GetDirtyDiskStatus(&bFirstDefected, &bSecondDefected);
if(!bResults)
return FALSE;
// check dirty status here
// ATLASSERT( mirDisk->GetDirtyDiskCount() > 0 );
if ( !bFirstDefected && !bSecondDefected)
{
WTL::CString strMsg;
strMsg.LoadString(IDS_WARNING_NOT_NEED_RECOVER );
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
::GetFocus(),
strMsg,
strTitle,
MB_OK | MB_ICONERROR
);
return TRUE;
}
//
// Select the source disk and the dest disk
//
if ( bFirstDefected && bSecondDefected)
{
CSelectDiskDlg dlgSelect(IDD_SELSOURCE);
CDiskObjectList listDisks;
listDisks.push_back( mirDisk->front() );
listDisks.push_back( mirDisk->back() );
dlgSelect.SetSingleDisks( listDisks );
if ( dlgSelect.DoModal() != IDOK )
return TRUE;
sourceDisk = dlgSelect.GetSelectedDisk();
if ( sourceDisk == mirDisk->front() )
destDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(mirDisk->back());
else
destDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(mirDisk->front());
}
else
{
if (bFirstDefected)
{
sourceDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->SecondDisk());
destDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->FirstDisk());
}
else if (bSecondDefected )
{
sourceDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->FirstDisk());
destDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->SecondDisk());
}
else
{
return FALSE;
}
}
//
// Synchronize
//
CRecoverDlg dlgRecover(FALSE, IDS_LOGDEV_TYPE_DISK_RAID1, IDS_RECOVERDLG_TASK_RECOVER);
dlgRecover.SetMemberDevice(destDisk);
dlgRecover.DoModal();
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
bResults = HixChangeNotify.Initialize();
if(bResults)
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node,
sourceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
sourceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
CopyMemory(unitDeviceId.DeviceId.Node,
destDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
destDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
return TRUE;
}
WTL::CString CObjectUIHandler::GetFaultTolerance(CDiskObjectPtr obj) const
{
WTL::CString strTitle;
strTitle = _T("");
if(obj->IsUnitDisk())
{
if((dynamic_cast<CEmptyDiskObject*>(obj.get()) == NULL))
{
CDiskObjectPtr parent;
CUnitDiskObjectPtr pUnitDiskObject =
boost::dynamic_pointer_cast<CUnitDiskObject>(obj);
if(!(parent = pUnitDiskObject->GetParent())->IsRoot())
{
CDiskObjectCompositePtr pDiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(parent);
if (NMT_RAID4 == pDiskObjectComposite->GetNDASMediaType())
{
UINT8 child_status =
pDiskObjectComposite->RMDUnitStatus(pUnitDiskObject->GetLocation()->GetUnitDiskLocation());
if(NDAS_UNIT_META_BIND_STATUS_FAULT & child_status)
{
strTitle.LoadString(IDS_FT_FAULT_CHILD);
}
else if(NDAS_UNIT_META_BIND_STATUS_SPARE & child_status)
{
strTitle.LoadString(IDS_FT_FAULT_SPARE);
}
}
}
else
{
strTitle.LoadString(IDS_FT_UNIT);
}
}
}
else
{
CDiskObjectCompositePtr pDiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(obj);
// check missing member
if(pDiskObjectComposite->IsBroken())
{
strTitle.LoadString(IDS_FT_MISSING);
}
else
{
switch(pDiskObjectComposite->GetNDASMediaType())
{
case NMT_AGGREGATE:
case NMT_RAID0:
case NMT_MIRROR:
if(pDiskObjectComposite->IsBroken())
strTitle.LoadString(IDS_FT_MISSING);
else
strTitle.LoadString(IDS_FT_NOT_FAULT_TOLERANT);
break;
case NMT_RAID1:
{
CMirDiskObjectPtr pMirDiskObject =
boost::dynamic_pointer_cast<CMirDiskObject>(pDiskObjectComposite);
if(pMirDiskObject->IsBroken())
strTitle.LoadString(IDS_FT_NEED_REPAIR);
else if(pMirDiskObject->IsDirty())
strTitle.LoadString(IDS_FT_DIRTY);
else
strTitle.LoadString(IDS_FT_FAULT_TOLERANT);
}
break;
case NMT_RAID4:
{
CRAID4DiskObjectPtr pRAID4DiskObject =
boost::dynamic_pointer_cast<CRAID4DiskObject>(pDiskObjectComposite);
if(pRAID4DiskObject->IsBroken())
{
strTitle.LoadString(IDS_FT_NEED_REPAIR);
}
else
{
switch(pDiskObjectComposite->RMDStatus())
{
case 0:
strTitle.LoadString(IDS_FT_FAULT_TOLERANT);
break;
case 1:
strTitle.LoadString(IDS_FT_DIRTY);
break;
case 2:
strTitle.LoadString(IDS_FT_FAULT);
break;
case 3:
strTitle.LoadString(IDS_FT_IN_SYNC);
break;
default:
break;
}
}
}
break;
default:
break;
}
}
}
return strTitle;
}
///////////////////////////////////////////////////////////////////////////////
// CEmptyDiskUIHandler
///////////////////////////////////////////////////////////////////////////////
UINT CEmptyDiskUIHandler::GetIconID(CDiskObjectPtr obj) const
{
ATLASSERT(dynamic_cast<CEmptyDiskObject*>(obj.get()) != NULL);
return IDI_ND_BADKEY;
}
CCommandSet CUnitDiskUIHandler::GetCommandSet(CDiskObjectPtr obj) const
{
ATLASSERT( dynamic_cast<CUnitDiskObject*>(obj.get()) != NULL);
CCommandSet setCommand;
CUnitDiskObjectPtr unitDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(obj);
CUnitDiskInfoHandlerPtr handler = unitDisk->GetInfoHandler();
BOOL bCanWrite;
if ( handler->IsBound() )
{
CDiskObjectPtr aggrRoot = unitDisk->GetParent();
if ( aggrRoot->IsRoot() )
{
// This can occur when the tree is updated just after
// the disk is bound.
// This additional if code prevents error.
setCommand.push_back( CCommand(IDM_TOOL_UNBIND) );
}
else
{
while ( !aggrRoot->GetParent()->IsRoot() )
aggrRoot = aggrRoot->GetParent();
// To Unbind, we should have write privilege to all the disks in bind
setCommand.push_back( CCommand(IDM_TOOL_UNBIND,
aggrRoot->GetAccessMask() & GENERIC_WRITE) );
}
}
else
{
bCanWrite = unitDisk->GetAccessMask() & GENERIC_WRITE;
setCommand.push_back( CCommand(IDM_TOOL_ADDMIRROR, bCanWrite) );
}
if ( handler->IsMirrored() )
{
CMirDiskObjectPtr parent =
boost::dynamic_pointer_cast<CMirDiskObject>(unitDisk->GetParent());
if ( parent.get() != NULL )
{
// To synchronize, we have write privilege to the two disks in mirroring
setCommand.push_back( CCommand(IDM_TOOL_SYNCHRONIZE,
(parent->GetAccessMask() & GENERIC_WRITE) &&
parent->IsDirty() && !parent->IsBroken() &&
parent->HasWriteAccess()
)
);
}
CDiskObjectPtr aggrRoot = unitDisk->GetParent();
if ( aggrRoot->IsRoot() )
{
// This can occur when the tree is updated just after
// the disk is bound.
// This additional if code prevents error.
setCommand.push_back( CCommand(IDM_TOOL_UNBIND) );
}
else
{
while ( !aggrRoot->GetParent()->IsRoot() )
aggrRoot = aggrRoot->GetParent();
}
}
else if(NMT_RAID4 == handler->GetNDASMediaType())
{
CRAID4DiskObjectPtr parent =
boost::dynamic_pointer_cast<CRAID4DiskObject>(unitDisk->GetParent());
if ( parent.get() != NULL )
{
// To synchronize, we have write privilege to the two disks in mirroring
setCommand.push_back( CCommand(IDM_TOOL_SYNCHRONIZE,
(parent->GetAccessMask() & GENERIC_WRITE)
&& parent->IsDirty() && !parent->IsBroken()
)
);
}
}
if(unitDisk->IsUnitDisk())
{
setCommand.push_back( CCommand(IDM_TOOL_SINGLE) );
}
return setCommand;
}
void CMainFrame::OnRepair(UINT /*wNotifyCode*/, int /*wID*/, HWND /*hwndCtl*/)
{
#ifdef __NEVER_DEFINED__
BOOL bResults;
BOOL bReturn = FALSE;
int iItemSelected = m_viewTreeList.GetSelectedItemData();
if (-1 == iItemSelected)
{
return;
}
CDiskObjectPtr obj = m_mapObject[iItemSelected];
if( dynamic_cast<CDiskObjectComposite *>(obj.get()) == NULL )
{
return;
}
CDiskObjectCompositePtr DiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(obj);
if(!((NMT_RAID1 == DiskObjectComposite->GetNDASMediaType() ||
NMT_RAID4 == DiskObjectComposite->GetNDASMediaType()) &&
1 == DiskObjectComposite->GetMissingMemberCount()))
{
// TODO : No disk is available
CString strMsg;
strMsg.LoadString( IDS_MAINFRAME_NOT_READY_REPAIR );
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONERROR
);
return;
}
CSelectDiskDlg dlgSelect(IDD_REPAIR);
CDiskObjectList singleDisks;
CFindIfVisitor<FALSE> singleDiskFinder;
singleDisks = singleDiskFinder.FindIf(m_pRoot, IsWritableUnitDisk);
if ( singleDisks.size() == 0 )
{
// TODO : No disk is available
CString strMsg;
strMsg.LoadString( IDS_MAINFRAME_NO_DISK_REPAIR );
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return;
}
dlgSelect.SetSingleDisks(singleDisks);
if ( dlgSelect.DoModal() != IDOK )
return;
CUnitDiskObjectPtr replaceDisk, sourceDisk;
sourceDisk = DiskObjectComposite->GetAvailableUnitDisk();
replaceDisk = dlgSelect.GetSelectedDisk();
if(NULL == sourceDisk.get())
return;
NDASCOMM_CONNECTION_INFO ci, ciReplace;
ZeroMemory(&ci, sizeof(NDASCOMM_CONNECTION_INFO));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_DEVICE_ID;
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL;
ci.UnitNo = sourceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
ci.WriteAccess = TRUE;
ci.Protocol = NDASCOMM_TRANSPORT_LPX;
CopyMemory(
ci.DeviceId.Node,
sourceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(ci.DeviceId.Node));
ZeroMemory(&ciReplace, sizeof(NDASCOMM_CONNECTION_INFO));
ciReplace.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ciReplace.AddressType = NDASCOMM_CIT_DEVICE_ID;
ciReplace.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL;
ciReplace.UnitNo = replaceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
ciReplace.WriteAccess = TRUE;
ciReplace.Protocol = NDASCOMM_TRANSPORT_LPX;
CopyMemory(
ciReplace.DeviceId.Node,
replaceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(ciReplace.DeviceId.Node));
AutoCursor l_auto_cursor(IDC_WAIT);
bResults = NdasOpRepair(&ci, &ciReplace);
l_auto_cursor.Release();
if(!bResults)
{
CString strMsg;
DWORD dwLastError = ::GetLastError();
strMsg.LoadString(IDS_REPAIR_FAIL);
ShowErrorMessageBox(strMsg);
return;
}
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
bResults = HixChangeNotify.Initialize();
if(bResults)
{
CUnitDiskObjectPtr UnitDiskObjectPtr;
NDAS_UNITDEVICE_ID unitDeviceId;
CDiskObjectComposite::const_iterator itr;
for ( itr = DiskObjectComposite->begin(); itr != DiskObjectComposite->end(); ++itr )
{
if((dynamic_cast<CEmptyDiskObject*>((*itr).get()) != NULL))
continue;
UnitDiskObjectPtr =
boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
CopyMemory(unitDeviceId.DeviceId.Node,
UnitDiskObjectPtr->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
UnitDiskObjectPtr->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
CopyMemory(unitDeviceId.DeviceId.Node,
replaceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
replaceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
CRecoverDlg dlgRecover(
TRUE,
(NMT_RAID1 == DiskObjectComposite->GetNDASMediaType()) ?
IDS_LOGDEV_TYPE_DISK_RAID1 : IDS_LOGDEV_TYPE_DISK_RAID4,
IDS_RECOVERDLG_TASK_REPAIR);
dlgRecover.SetMemberDevice(sourceDisk);
dlgRecover.DoModal();
OnRefreshStatus(NULL, NULL, NULL);
#endif
return;
}
void CUnitDiskObject::Accept(CDiskObjectPtr _this, CDiskObjectVisitor *v)
{
ATLASSERT( this == _this.get() );
v->Visit(_this);
}
BOOL IsEmptyDisk(CDiskObjectPtr child)
{
return (dynamic_cast<CEmptyDiskObject*>(child.get()) != NULL);
}
void CMainFrame::OnContextMenu(HWND /*hWnd*/, CPoint pos)
{
if(m_bRefreshing)
return;
ENTER_CRITICAL_SECTION(&m_csThreadRefreshStatus);
CRect rect;
CPoint posInView;
CTreeItem itemSelected;
m_view.GetWindowRect( rect );
if ( !rect.PtInRect(pos) )
{
// If clicked point is outside the tree control, do nothing.
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
// Change screen coordinates to client coordinates
posInView = pos - rect.TopLeft();
itemSelected = m_view.HitTest( posInView, NULL );
CMenu menu;
CMenu newSubMenu;
CMenuHandle subMenu;
menu.LoadMenu( MAKEINTRESOURCE(IDR_CONTEXT_MENU) );
subMenu = menu.GetSubMenu(0);
if ( subMenu.IsNull() )
{
newSubMenu.CreatePopupMenu();
subMenu = newSubMenu;
}
if ( itemSelected.IsNull() )
{
// Display default menu
subMenu.TrackPopupMenu(
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
pos.x,
pos.y,
m_hWnd
);
}
else
{
// Change select
m_view.SelectItem(itemSelected);
// Display context menu
CDiskObjectPtr obj = m_mapObject[itemSelected.GetData()];
ATLASSERT( obj.get() != NULL );
CObjectUIHandler::GetUIHandler(obj)->InsertMenu(obj, subMenu);
subMenu.TrackPopupMenu(
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
pos.x,
pos.y,
m_hWnd
);
}
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
}
void CMainFrame::OnContextMenu(HWND /*hWnd*/, CPoint pos)
{
if(m_bRefreshing)
return;
ENTER_CRITICAL_SECTION(&m_csThreadRefreshStatus);
int selectedItemData;
// get selectedItemData
{
CRect rect;
CPoint posInView;
CTreeItem itemSelected;
// if clicked on tree, we need to change selection
if (m_viewTree.GetWindowRect( rect ) && rect.PtInRect(pos) )
{
// clicked point is inside the tree control
// Change screen coordinates to client coordinates
posInView = pos - rect.TopLeft();
itemSelected = m_viewTree.HitTest( posInView, NULL );
if(itemSelected.IsNull())
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
// an item is really selected
// Change select
m_viewTree.SelectItem(itemSelected);
selectedItemData = itemSelected.GetData();
}
else if(m_viewList.GetWindowRect( rect ) && rect.PtInRect(pos))
{
selectedItemData = m_viewList.GetSelectedItemData();
}
if(-1 == selectedItemData)
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
ATLTRACE(_T("selectedItemData = %d\n"), selectedItemData);
}
// Display context menu
{
CMenu menu;
CMenuHandle subMenu;
CDiskObjectPtr obj = m_mapObject[selectedItemData];
ATLASSERT( obj.get() != NULL );
menu.LoadMenu( MAKEINTRESOURCE(IDR_CONTEXT_MENU) );
subMenu = menu.GetSubMenu(0);
CObjectUIHandler::GetUIHandler(obj)->InsertMenu(obj, subMenu);
ATLTRACE(_T("Menu Count : %d"), subMenu.GetMenuItemCount());
subMenu.RemoveMenu(IDM_AGGR_PROPERTY, MF_BYCOMMAND);
// subMenu.RemoveMenu(MF_BYPOSITION, subMenu.GetMenuItemCount());
subMenu.TrackPopupMenu(
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
pos.x,
pos.y,
m_hWnd
);
}
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
void CMainFrame::OnContextMenu(HWND /*hWnd*/, CPoint pos)
{
if(m_bRefreshing)
return;
ENTER_CRITICAL_SECTION(&m_csThreadRefreshStatus);
int selectedItemData;
// get selectedItemData
CRect rect;
CPoint posInView;
HTREEITEM hItemSelected;
// if clicked on tree, we need to change selection
if (m_viewTreeList.GetWindowRect( rect ) && rect.PtInRect(pos) )
{
CTreeViewCtrlEx ctrlTree = m_viewTreeList.GetTreeControl();
CHeaderCtrl ctrlHeader = m_viewTreeList.GetHeaderControl();
CRect rectHeader;
ctrlHeader.GetClientRect(rectHeader);
// clicked point is inside the tree control
// Change screen coordinates to client coordinates
posInView = pos - rect.TopLeft();
posInView.y -= rectHeader.Height();
if(NULL == (hItemSelected = ctrlTree.HitTest(posInView, NULL)))
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
ctrlTree.SelectItem(hItemSelected);
}
selectedItemData = m_viewTreeList.GetSelectedItemData();
// Display context menu
CMenu menu;
CMenuHandle subMenu;
CDiskObjectPtr obj = m_mapObject[selectedItemData];
ATLASSERT( obj.get() != NULL );
menu.LoadMenu( MAKEINTRESOURCE(IDR_CONTEXT_MENU) );
subMenu = menu.GetSubMenu(0);
CObjectUIHandler::GetUIHandler(obj)->InsertMenu(obj, subMenu);
ATLTRACE(_T("Menu Count : %d"), subMenu.GetMenuItemCount());
subMenu.RemoveMenu(IDM_AGGR_PROPERTY, MF_BYCOMMAND);
// subMenu.RemoveMenu(MF_BYPOSITION, subMenu.GetMenuItemCount());
subMenu.TrackPopupMenu(
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
pos.x,
pos.y,
m_hWnd
);
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
///////////////////////////////////////////////////////////////////////////////
// Helper function for CFindIfVisitor
///////////////////////////////////////////////////////////////////////////////
BOOL IsUnitDisk(CDiskObjectPtr obj)
{
CUnitDiskObject *pUnitDisk
= dynamic_cast<CUnitDiskObject*>(obj.get());
return (pUnitDisk != NULL && pUnitDisk->IsUsable() );
}
