/////////////////////////////////////////////////////////////////////////////// // CUnitDiskUIHandler /////////////////////////////////////////////////////////////////////////////// UINT CUnitDiskUIHandler::GetIconID(CDiskObjectPtr obj) const { ATLASSERT(dynamic_cast<CUnitDiskObject*>(obj.get()) != NULL); CUnitDiskObjectPtr unitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(obj); CUnitDiskInfoHandlerPtr handler = unitDisk->GetInfoHandler(); if ( !obj->IsUsable() ) return IDI_ND_BADKEY; if ( handler->IsHDD() ) { if ( handler->IsBound() ) { if ( handler->IsMaster() ) { return IDI_ND_INUSE; } else { return IDI_ND_SLAVE; } } else { return IDI_ND_INUSE; } } else { // TODO : We need a new icon for this type(DVD, FLASH, MO.. ETC) return IDI_ND_INUSE; } }
void CMirrorWorkThread::RebindMirror() { // Get list of disks involved in the previous mirroring. // NOTE : Because disks aggregated can also be mirrored, // there can be more than two disks involved in the mirroring. CDiskObjectPtr aggregationRoot; aggregationRoot = m_pSource->GetParent(); while ( !aggregationRoot->GetParent()->IsRoot() ) { aggregationRoot = aggregationRoot->GetParent(); } // Mark all the bitmaps dirty. m_pSource->OpenExclusive(); m_pDest->OpenExclusive(); m_pSource->MarkAllBitmap(); CUnitDiskInfoHandlerPtr pHandler = m_pSource->GetInfoHandler(); aggregationRoot->Rebind( m_pDest, pHandler->GetPosInBind() ^ 0x01 ); aggregationRoot->CommitDiskInfo(TRUE); // Write binding information to the destination disk m_pDest->Mirror(m_pSource); m_pDest->CommitDiskInfo(TRUE); m_bRebound = TRUE; m_pSource->Close(); m_pDest->Close(); }
void CMainFrame::OnCommand(UINT /*wNotifyCode*/, int wID, HWND /*hwndCtl*/) { ENTER_CRITICAL_SECTION(&m_csThreadRefreshStatus); // Commands which do not change the tree are sent to the object directly. CTreeItem itemSelected = m_view.GetSelectedItem(); if ( itemSelected.IsNull() ) { LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus); return; } CDiskObjectPtr obj; const CObjectUIHandler *phandler; obj = m_mapObject[m_view.GetItemData(itemSelected)]; ATLASSERT( obj.get() != NULL ); phandler = CObjectUIHandler::GetUIHandler( obj ); phandler->OnCommand( obj, wID ); m_view.UpdateDiskObject( obj ); OnSelChanged(NULL); LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus); }
/////////////////////////////////////////////////////////////////////////////// // CDiskObjectComposite /////////////////////////////////////////////////////////////////////////////// void CDiskObjectComposite::AddChild(CDiskObjectPtr _this, CDiskObjectPtr child) { ATLASSERT( this == _this.get() ); child->SetParent(_this); CDiskObjectList::push_back(child); }
void CNBTreeView::Visit(CDiskObjectPtr o) { const CObjectUIHandler *pHandler = CObjectUIHandler::GetUIHandler(o); switch ( m_nAction ) { case NDASBINDVIEW_INSERT_OBJECT: { m_htiLast = CTreeViewCtrlEx::InsertItem( pHandler->GetTitle(o), pHandler->GetIconIndex(o), pHandler->GetSelectedIconIndex(o), m_htiParent, TVI_LAST ); m_htiLast.SetData( o->GetUniqueID() ); m_mapIDToTreeItem[o->GetUniqueID()] = m_htiLast; Expand(m_htiParent, TVE_EXPAND); } break; case NDASBINDVIEW_UPDATE_OBJECT: { CTreeItem htiUpdate = m_mapIDToTreeItem[o->GetUniqueID()]; htiUpdate.SetText( pHandler->GetTitle(o) ); htiUpdate.SetImage( pHandler->GetIconIndex(o), pHandler->GetSelectedIconIndex(o) ); } } };
LRESULT CNBBindListViewCtrl::OnGetDispInfo(LPNMHDR lParam) { NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(lParam); CDiskObjectPtr obj; const CObjectUIHandler *phandler; obj = m_mapObject[static_cast<UINT>(pDispInfo->item.lParam)]; ATLASSERT( obj.get() != NULL ); phandler = CObjectUIHandler::GetUIHandler( obj ); switch ( pDispInfo->item.iSubItem ) { case 0: // Index ::_stprintf( pDispInfo->item.pszText, _T("%d"), pDispInfo->item.iItem ); break; case 1: // Name ::_tcsncpy( pDispInfo->item.pszText, obj->GetTitle(), pDispInfo->item.cchTextMax-1 ); break; case 2: // ID /* ::_tcsncpy( pDispInfo->item.pszText, phandler->GetStringID( obj ), pDispInfo->item.cchTextMax-1 ); break; case 3: // Size */ { WTL::CString strSize; strSize.FormatMessage( IDS_LISTVIEW_SIZE_IN_GB, phandler->GetSizeInMB( obj ) / 1024, (phandler->GetSizeInMB( obj ) % 1024) / 10 ); ::_tcsncpy( pDispInfo->item.pszText, strSize, pDispInfo->item.cchTextMax-1 ); } default: break; } pDispInfo->item.pszText[pDispInfo->item.cchTextMax-1] = '\0'; return 0; }
/////////////////////////////////////////////////////////////////////////////// // CUnsupportedDiskUIHandler /////////////////////////////////////////////////////////////////////////////// CCommandSet CUnsupportedDiskUIHandler::GetCommandSet(CDiskObjectPtr obj) const { ATLASSERT( dynamic_cast<CUnitDiskObject*>(obj.get()) != NULL); CCommandSet setCommand; setCommand.push_back ( CCommand( IDM_TOOL_CLEARDIB, (obj->GetAccessMask() & GENERIC_WRITE) ) ); return setCommand; }
BOOL CUnsupportedDiskUIHandler::OnClearDIB(CDiskObjectPtr obj) const { ATLASSERT( dynamic_cast<CUnitDiskObject*>(obj.get()) != NULL); WTL::CString strWarning; strWarning.FormatMessage( IDS_UIHANDLER_CLEARDIB_CONFIRM, obj->GetTitle() ); WTL::CString strTitle; strTitle.LoadString(IDS_APPLICATION); if ( MessageBox(::GetFocus(), strWarning, strTitle, MB_YESNO | MB_ICONWARNING) != IDYES ) { return TRUE; } CUnitDiskObjectPtr unitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(obj); if ( !unitDisk->CanAccessExclusive() ) { WTL::CString strMsg; strMsg.LoadString( IDS_FAIL_TO_ACCESS_EXCLUSIVELY ); MessageBox( ::GetFocus(), strMsg, strTitle, MB_OK | MB_ICONWARNING ); return TRUE; } try { unitDisk->Open( TRUE ); unitDisk->Initialize( unitDisk ); unitDisk->CommitDiskInfo(); unitDisk->Close(); } catch( CNDASException & ) { unitDisk->Close(); WTL::CString strMsg; strMsg.LoadString ( IDS_UIHANDLER_CLEARDIB_FAIL ); MessageBox( ::GetFocus(), strMsg, strTitle, MB_OK | MB_ICONERROR ); return TRUE; } WTL::CString strMsg; strMsg.LoadString( IDS_UIHANDLER_CLEARDIB_SUCCESS ); return TRUE; }
void CNBListViewCtrl::DeleteDiskObject(CDiskObjectPtr o) { int nItemCount = CListViewCtrl::GetItemCount(); for (int i=0; i < nItemCount; i++ ) { if ( GetItemData(i) == o->GetUniqueID() ) { CListViewCtrl::DeleteItem( i ); break; } } m_mapObject.erase( o->GetUniqueID() ); }
void CUnitDiskObject::Initialize(CDiskObjectPtr _this) { ATLASSERT( this == _this.get() ); m_pHandler->Initialize( boost::dynamic_pointer_cast<CUnitDiskObject>(_this) ); }
CDiskObjectList CLanUnitDiskObject::UnBind(CDiskObjectPtr _this) { ATLASSERT( this == _this.get() ); CDiskObjectList listUnbound; // If the disk is aggregated, the MBR block of the disk should be cleaned // to prevent unexpected behavior of disks after unbinding. CDataSector dataSector( SECTOR_MBR_COUNT ); dataSector.SetLocation( 0 ); if ( m_pHandler->IsBoundAndNotSingleMirrored() ) { try{ dataSector.WriteAccept( &m_session ); } catch( CNDASException &e ) { NDAS_THROW_EXCEPTION_CHAIN_STR( CDiskException, CDiskException::ERROR_FAIL_TO_INITIALIZE, _T("Fail to clean MBR"), e); } } // Clear bind information m_pHandler->UnBind( boost::dynamic_pointer_cast<CUnitDiskObject>(_this) ); listUnbound.push_back(_this); return listUnbound; }
UINT CObjectUIHandler::GetSizeInMB(CDiskObjectPtr obj) const { _int64 nSize; nSize = obj->GetUserSectorCount() / ( 1024 / NDAS_BLOCK_SIZE ) / 1024; /* KB per sector */ /* MB per KB */ return static_cast<UINT>(nSize); }
int CNBListViewCtrl::FindDiskObjectItem(CDiskObjectPtr o) { LVFINDINFO info; info.flags = LVFI_PARAM; info.lParam = o->GetUniqueID(); return CListViewCtrl::FindItem(&info, -1); }
void CNBTreeView::InsertDiskObject(CDiskObjectPtr o, CDiskObjectPtr parent) { if ( parent.get() == NULL ) { m_htiParent = TVI_ROOT; m_htiLast = m_htiParent; } else { m_htiParent = m_mapIDToTreeItem[parent->GetUniqueID()]; if ( m_htiParent.IsNull() ) m_htiParent = TVI_ROOT; m_htiLast = m_htiParent; } m_nAction = NDASBINDVIEW_INSERT_OBJECT; o->Accept( o, this ); }
CCommandSet CEmptyDiskUIHandler::GetCommandSet(CDiskObjectPtr obj) const { ATLASSERT( dynamic_cast<CEmptyDiskObject*>(obj.get()) != NULL); CCommandSet setCommand; CEmptyDiskObjectPtr unitDisk = boost::dynamic_pointer_cast<CEmptyDiskObject>(obj); return setCommand; }
BOOL CRAID4DiskUIHandler::OnRecover(CDiskObjectPtr obj) const { ATLASSERT( dynamic_cast<CRAID4DiskObject*>(obj.get()) != NULL ); CRAID4DiskObjectPtr raid4Disk = boost::dynamic_pointer_cast<CRAID4DiskObject>(obj); if(!raid4Disk->IsDirty()) { 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; } std::list<CDiskObjectPtr>::iterator it; CUnitDiskObjectPtr pUnitDisk; it = raid4Disk->begin(); INT32 iDirty; for(iDirty = raid4Disk->GetDirtyDisk(); iDirty > 0; iDirty--) it++; pUnitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(*it); CRecoverDlg dlgRecover(FALSE, IDS_LOGDEV_TYPE_DISK_RAID4, IDS_RECOVERDLG_TASK_RECOVER); dlgRecover.SetMemberDevice(pUnitDisk); dlgRecover.DoModal(); CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid()); BOOL bResults = HixChangeNotify.Initialize(); if(bResults) { NDAS_UNITDEVICE_ID unitDeviceId; for(it = raid4Disk->begin(); it != raid4Disk->end(); ++it) { pUnitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(*it); CopyMemory(unitDeviceId.DeviceId.Node, pUnitDisk->GetLocation()->GetUnitDiskLocation()->MACAddr, sizeof(unitDeviceId.DeviceId.Node)); unitDeviceId.UnitNo = pUnitDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber; HixChangeNotify.Notify(unitDeviceId); } } return TRUE; }
CCommandSet CAggrDiskUIHandler::GetCommandSet(CDiskObjectPtr obj) const { CCommandSet setCommand; setCommand.push_back( CCommand(IDM_TOOL_UNBIND, obj->GetAccessMask() & GENERIC_WRITE) ); return setCommand; }
BOOL CUnitDiskUIHandler::OnCommand(CDiskObjectPtr obj, UINT nCommandID) const { ATLASSERT( dynamic_cast<CUnitDiskObject*>(obj.get()) != NULL); switch( nCommandID ) { case IDM_TOOL_SYNCHRONIZE: { // Delegate command to parent const CObjectUIHandler *phandler = CObjectUIHandler::GetUIHandler( obj->GetParent() ); return phandler->OnCommand( obj->GetParent(), nCommandID ); } case IDM_TOOL_PROPERTY: return OnProperty( obj ); } return FALSE; }
CCommandSet CRAID0DiskUIHandler::GetCommandSet(CDiskObjectPtr obj) const { CCommandSet setCommand; // AING_TO_DO : add IDM_RAID0_UNBIND setCommand.push_back( CCommand(IDM_TOOL_UNBIND, obj->GetAccessMask() & GENERIC_WRITE) ); return setCommand; }
BOOL CAggrDiskUIHandler::OnCommand(CDiskObjectPtr obj, UINT nCommandID) const { ATLASSERT( dynamic_cast<CAggrDiskObject*>(obj.get()) != NULL ); switch( nCommandID ) { case IDM_TOOL_PROPERTY: return OnProperty( obj ); } return FALSE; }
/////////////////////////////////////////////////////////////////////////////// // CRootDiskObject /////////////////////////////////////////////////////////////////////////////// void CRootDiskObject::Accept(CDiskObjectPtr _this, CDiskObjectVisitor *v) { ATLASSERT( this == _this.get() ); //v->IncDepth(); iterator itr; for ( itr = begin(); itr != end(); itr++ ) { (*itr)->Accept(*itr, v); } //v->DecDepth(); }
void CNBListViewCtrl::AddDiskObject(CDiskObjectPtr o) { LVITEM lvItem = { 0 }; const CObjectUIHandler *pHandler = CObjectUIHandler::GetUIHandler(o); WTL::CString strName = pHandler->GetTitle(o); WTL::CString strCapacity; strCapacity.FormatMessage( IDS_DISKPROPERTYPAGE_SIZE_IN_GB, pHandler->GetSizeInMB( o ) / 1024, (pHandler->GetSizeInMB( o ) % 1024) / 10 ); lvItem.mask = LVIF_TEXT | LVIF_PARAM; lvItem.iItem = GetItemCount(); lvItem.pszText = strName.LockBuffer(); //LPSTR_TEXTCALLBACK; lvItem.lParam = static_cast<LPARAM>(o->GetUniqueID()); CListViewCtrl::InsertItem( &lvItem ); CListViewCtrl::SetItemText(lvItem.iItem, 1, strCapacity.LockBuffer() ); m_mapObject[o->GetUniqueID()] = o; }
int CNBListViewCtrl::CompareItems(CDiskObjectPtr obj1, CDiskObjectPtr obj2) { int signAsc = m_abSortAsc[m_iColSort]? 1 : -1; switch(m_iColSort) { case 0: return signAsc * obj1->GetTitle().Compare( obj2->GetTitle() ); break; case 1: return signAsc * obj1->GetStringDeviceID().Compare( obj2->GetStringDeviceID() ); break; case 2: { _int64 size1, size2; size1 = obj1->GetUserSectorCount(); size2 = obj2->GetUserSectorCount(); if ( size1 > size2 ) return signAsc; else if ( size1 == size2 ) return 0; else return (-1) * signAsc; } break; default: break; } return 0; }
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; }
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() ); } } }
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; }
PropertyList CRAID4DiskUIHandler::GetPropertyList(CDiskObjectPtr obj) const { PropertyList propList; PropertyListItem propItem; WTL::CString strBuffer; //propItem[0] = _T("Binding type"); propItem.strName.LoadString( IDS_UIHANDLER_PROPERTY_NUM_BOUND_DISK ); strBuffer.Format( _T("%d"), obj->GetDiskCountInBind() ); propItem.strValue = strBuffer; propItem.strToolTip.LoadString( IDS_UIHANDLER_PROPERTY_NUM_BOUND_DISK_TOOLTIP ); propList.push_back( propItem ); return propList; }
CCommandSet CRAID4DiskUIHandler::GetCommandSet(CDiskObjectPtr obj) const { CCommandSet setCommand; BOOL bCanWrite; CRAID4DiskObjectPtr disk = boost::dynamic_pointer_cast<CRAID4DiskObject>(obj); setCommand.push_back( CCommand(IDM_TOOL_UNBIND, obj->GetAccessMask() & GENERIC_WRITE) ); setCommand.push_back( CCommand(IDM_TOOL_SYNCHRONIZE, disk->IsDirty() && disk->HasWriteAccess())); setCommand.push_back( CCommand(IDM_TOOL_REPAIR, 1 == disk->GetMissingMemberCount())); setCommand.push_back( CCommand(IDM_TOOL_SPAREADD, obj->GetAccessMask() & GENERIC_WRITE) ); return setCommand; }
BOOL CMirDiskUIHandler::OnCommand(CDiskObjectPtr obj, UINT nCommandID) const { ATLASSERT( dynamic_cast<CMirDiskObject*>(obj.get()) != NULL ); switch ( nCommandID ) { case IDM_TOOL_SYNCHRONIZE: return OnSynchronize( obj ); case IDM_TOOL_PROPERTY: return OnProperty( obj ); case IDM_TOOL_MIGRATE: return OnMigrate( obj ); } return FALSE; }