ctrllibrarytreeview.cpp

p2p软件

						}
					}
				}
			}
			else if ( LibraryFolders.CheckAlbum( (CAlbumFolder*)nObject ) )
			{
				CAlbumFolder* pFolder = (CAlbumFolder*)nObject;

				if ( pFolder != m_pDropItem->m_pVirtual &&
					 pFolder->m_pParent != m_pDropItem->m_pVirtual &&
					 pFolder->CheckFolder( m_pDropItem->m_pVirtual, TRUE ) == FALSE )
				{
					pFolder->m_pParent->OnFolderDelete( pFolder );
					pFolder->m_pParent = m_pDropItem->m_pVirtual;
					pFolder->m_pParent->m_pFolders.AddTail( pFolder );
					pFolder->m_pParent->m_nUpdateCookie++;
					Library.m_nUpdateCookie++;
				}
			}
		}
	}
	
	m_pDropItem = NULL;
	Invalidate();
	
	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CLibraryTreeView message handlers

int CLibraryTreeView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if ( CLibraryTreeCtrl::OnCreate( lpCreateStruct ) == -1 ) return -1;
	
	m_wndFolderTip.Create( this );
	m_wndAlbumTip.Create( this );

	return 0;
}

BOOL CLibraryTreeView::PreTranslateMessage(MSG* pMsg) 
{
	if ( m_bVirtual )
	{
		if ( pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_DELETE )
		{
			OnLibraryFolderDelete();
			return TRUE;
		}
		else if ( pMsg->message == WM_SYSKEYDOWN && pMsg->wParam == VK_RETURN )
		{
			OnLibraryFolderProperties();
			return TRUE;
		}
	}
	else
	{
		if ( pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_RETURN )
		{
			OnLibraryExplore();
			return TRUE;
		}
	}

	return CLibraryTreeCtrl::PreTranslateMessage( pMsg );
}

void CLibraryTreeView::OnContextMenu(CWnd* pWnd, CPoint point) 
{
	if ( m_bVirtual )
	{
		Skin.TrackPopupMenu( _T("CLibraryTree.Virtual"), point, ID_LIBRARY_FOLDER_PROPERTIES );
	}
	else
	{
		Skin.TrackPopupMenu( _T("CLibraryTree.Physical"), point, ID_LIBRARY_EXPLORE );
	}
}

void CLibraryTreeView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	CLibraryTreeCtrl::OnLButtonDblClk( nFlags, point );
	
	if ( m_pFocus == NULL && ! m_bVirtual )
	{
		SelectAll();
		NotifySelection();
	}
}

void CLibraryTreeView::OnUpdateLibraryParent(CCmdUI* pCmdUI) 
{
	CLibraryFrame* pFrame = (CLibraryFrame*)GetParent();
	ASSERT_KINDOF(CLibraryFrame, pFrame);

	CCoolBarCtrl* pBar = &pFrame->m_wndViewTop;
	CCoolBarItem* pItem = pBar->GetID( ID_LIBRARY_PARENT );

	BOOL bAvailable = ( m_nSelected == 1 );

	if ( pItem == pCmdUI ) pItem->Show( bAvailable );
	pCmdUI->Enable( bAvailable );
}

void CLibraryTreeView::OnLibraryParent() 
{
	CLibraryTreeItem* pNew = NULL;

	if ( m_nSelected == 1 && m_pSelFirst->m_pParent != m_pRoot )
	{
		pNew = m_pSelFirst->m_pParent;
	}

	DeselectAll( pNew );

	if ( pNew != NULL )
	{
		Select( pNew );
		Highlight( pNew );
	}

	Invalidate();
	NotifySelection();
}

/////////////////////////////////////////////////////////////////////////////
// CLibraryTreeView physical command handlers

void CLibraryTreeView::OnUpdateLibraryExplore(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( ! m_bVirtual && m_nSelected == 1 );
}

void CLibraryTreeView::OnLibraryExplore() 
{
	if ( m_bVirtual || m_nSelected != 1 || m_pSelFirst == NULL ) return;
	
	CSingleLock pLock( &Library.m_pSection, TRUE );
	if ( ! LibraryFolders.CheckFolder( m_pSelFirst->m_pPhysical, TRUE ) ) return;
	CString strPath = m_pSelFirst->m_pPhysical->m_sPath;
	pLock.Unlock();
	
	CFileExecutor::Execute( strPath, TRUE );
}

void CLibraryTreeView::OnUpdateLibraryScan(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( ! m_bVirtual && m_nSelected > 0 );
}

void CLibraryTreeView::OnLibraryScan() 
{
	CSingleLock pLock( &Library.m_pSection, TRUE );

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		if ( LibraryFolders.CheckFolder( pItem->m_pPhysical, TRUE ) ) pItem->m_pPhysical->Scan();
	}
}

void CLibraryTreeView::OnUpdateLibraryShared(CCmdUI* pCmdUI) 
{
	CSingleLock pLock( &Library.m_pSection );
	if ( ! pLock.Lock( 50 ) ) return;

	TRISTATE bShared = TS_UNKNOWN;

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		if ( LibraryFolders.CheckFolder( pItem->m_pPhysical, TRUE ) )
		{
			if ( bShared == TS_UNKNOWN )
			{
				bShared = pItem->m_pPhysical->IsShared() ? TS_TRUE : TS_FALSE;
			}
			else if ( ( bShared == TS_TRUE ) != pItem->m_pPhysical->IsShared() )
			{
				pCmdUI->Enable( FALSE );
				return;
			}
		}
	}

	pCmdUI->Enable( m_nSelected > 0 );
	pCmdUI->SetCheck( bShared == TS_TRUE );
}

void CLibraryTreeView::OnLibraryShared() 
{
	Library.Lock();

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		if ( LibraryFolders.CheckFolder( pItem->m_pPhysical, TRUE ) )
		{
			BOOL bShared = pItem->m_pPhysical->IsShared();
			pItem->m_pPhysical->m_bShared = TS_UNKNOWN;
			
			if ( bShared )
				pItem->m_pPhysical->m_bShared = pItem->m_pPhysical->IsShared() ? TS_FALSE : TS_UNKNOWN;
			else
				pItem->m_pPhysical->m_bShared = pItem->m_pPhysical->IsShared() ? TS_UNKNOWN : TS_TRUE;
			pItem->m_pPhysical->m_nUpdateCookie++;
		}
	}

	Library.Unlock( TRUE );
	PostUpdate();
}

void CLibraryTreeView::OnUpdateLibraryRemove(CCmdUI* pCmdUI) 
{
	CSingleLock pLock( &Library.m_pSection );
	if ( ! pLock.Lock( 50 ) ) return;

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		if ( LibraryFolders.CheckFolder( pItem->m_pPhysical, TRUE ) )
		{
			if ( pItem->m_pPhysical->m_pParent == NULL )
			{
				pCmdUI->Enable( TRUE );
				return;
			}
		}
	}

	pCmdUI->Enable( FALSE );
}

void CLibraryTreeView::OnLibraryRemove() 
{
	CSingleLock pLock( &Library.m_pSection, TRUE );

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		if ( LibraryFolders.CheckFolder( pItem->m_pPhysical, TRUE ) )
		{
			if ( pItem->m_pPhysical->m_pParent == NULL )
			{
				LibraryFolders.RemoveFolder( pItem->m_pPhysical );
			}
		}
	}

	Library.Save();
	PostUpdate();
}

void CLibraryTreeView::OnLibraryAdd() 
{
	TCHAR szPath[MAX_PATH];
	LPITEMIDLIST pPath;
	LPMALLOC pMalloc;
	BROWSEINFO pBI;
		
	ZeroMemory( &pBI, sizeof(pBI) );
	pBI.hwndOwner		= AfxGetMainWnd()->GetSafeHwnd();
	pBI.pszDisplayName	= szPath;
	pBI.lpszTitle		= _T("Select folder to share:");
	pBI.ulFlags			= BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;
	
	pPath = SHBrowseForFolder( &pBI );

	if ( pPath == NULL ) return;

	SHGetPathFromIDList( pPath, szPath );
	SHGetMalloc( &pMalloc );
	pMalloc->Free( pPath );

	CFolderScanDlg dlgScan;

	LibraryFolders.AddFolder( szPath );

	dlgScan.DoModal();
}

/////////////////////////////////////////////////////////////////////////////
// CLibraryTreeView virtual command handlers

void CLibraryTreeView::OnUpdateLibraryFolderEnqueue(CCmdUI* pCmdUI) 
{
	if ( ! Library.Lock( 50 ) ) return;

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		if ( LibraryFolders.CheckAlbum( pItem->m_pVirtual ) && pItem->m_pVirtual->GetFileCount() > 0 )
		{
			pCmdUI->Enable( TRUE );
			Library.Unlock();
			return;
		}
	}

	pCmdUI->Enable( FALSE );
	Library.Unlock();
}

void CLibraryTreeView::OnLibraryFolderEnqueue() 
{
	CStringList pList;

	if ( ! Library.Lock( 50 ) ) return;

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		if ( LibraryFolders.CheckAlbum( pItem->m_pVirtual ) )
		{
			for ( POSITION pos = pItem->m_pVirtual->GetFileIterator() ; pos ; )
			{
				CLibraryFile* pFile = pItem->m_pVirtual->GetNextFile( pos );
				pList.AddTail( pFile->GetPath() );
			}
		}
	}

	Library.Unlock();

	for ( POSITION pos = pList.GetHeadPosition() ; pos ; )
	{
		CString strPath = pList.GetNext( pos );
		CFileExecutor::Enqueue( strPath );
	}
}

void CLibraryTreeView::OnUpdateLibraryFolderMetadata(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( m_nSelected > 0 && m_pSelFirst->m_pVirtual != NULL );
}

void CLibraryTreeView::OnLibraryFolderMetadata() 
{
	Library.Lock();
	
	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		CAlbumFolder* pFolder = pItem->m_pVirtual;
		if ( LibraryFolders.CheckAlbum( pFolder ) ) pFolder->MetaToFiles( TRUE );
	}

	Library.Unlock( TRUE );
}

void CLibraryTreeView::OnUpdateLibraryFolderDelete(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( m_nSelected > 0 && m_pSelFirst->m_pVirtual != NULL );
}

void CLibraryTreeView::OnLibraryFolderDelete() 
{
	if ( m_pSelFirst == NULL || m_pSelFirst->m_pVirtual == NULL ) return;
	
	CString strFormat, strMessage;
	Skin.LoadString( strFormat, IDS_LIBRARY_FOLDER_DELETE );
	strMessage.Format( strFormat, m_nSelected );

	if ( AfxMessageBox( strMessage, MB_ICONQUESTION|MB_OKCANCEL ) != IDOK ) return;

	Library.Lock();

	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		CAlbumFolder* pFolder = pItem->m_pVirtual;
		if ( LibraryFolders.CheckAlbum( pFolder ) ) pFolder->Delete();
	}

	Library.Unlock();

	NotifySelection();
}

void CLibraryTreeView::OnUpdateLibraryFolderNew(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( m_nSelected == 0 || ( m_nSelected == 1 && m_pSelFirst->m_pVirtual != NULL ) );
}

void CLibraryTreeView::OnLibraryFolderNew() 
{
	if ( m_pSelFirst != NULL && m_pSelFirst->m_pVirtual == NULL ) return;

	Library.Lock();

	CAlbumFolder* pFolder = Library.GetAlbumRoot();

	if ( m_pSelFirst ) pFolder = m_pSelFirst->m_pVirtual;
		
	pFolder = pFolder->AddFolder( NULL, _T("New Folder") );

	if ( m_pSelFirst ) Expand( m_pSelFirst, TS_TRUE, FALSE );

	NotifySelection();

	if ( CLibraryTreeItem* pItem = GetFolderItem( pFolder ) )
	{
		Select( pItem, TS_TRUE, FALSE );
		DeselectAll( pItem, NULL, FALSE );
	}

	Library.Unlock( TRUE );

	Invalidate();

	if ( pFolder ) PostMessage( WM_COMMAND, ID_LIBRARY_FOLDER_PROPERTIES );
}

void CLibraryTreeView::OnUpdateLibraryRebuild(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( m_nSelected > 0 );
}

void CLibraryTreeView::OnLibraryRebuild() 
{
	if ( ! Library.Lock( 50 ) ) return;
	
	CLibraryList pList;
	
	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		pItem->GetFileList( &pList, TRUE );
	}
	
	for ( POSITION pos = pList.GetIterator() ; pos ; )
	{
		if ( CLibraryFile* pFile = pList.GetNextFile( pos ) )
		{
			pFile->Rebuild();
		}
	}
	
	Library.Unlock( TRUE );
}

void CLibraryTreeView::OnUpdateLibraryFolderProperties(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( m_nSelected == 1 && m_pSelFirst->m_pVirtual != NULL );
}

void CLibraryTreeView::OnLibraryFolderProperties() 
{
	if ( m_pSelFirst == NULL || m_pSelFirst->m_pVirtual == NULL ) return;

	CAlbumFolder* pFolder = m_pSelFirst->m_pVirtual;

	CFolderPropertiesDlg dlg( NULL, pFolder );

	if ( dlg.DoModal() == IDOK )
	{
		NotifySelection();

		if ( CLibraryTreeItem* pItem = GetFolderItem( pFolder ) )
		{
			Select( pItem, TS_TRUE, FALSE );
			DeselectAll( pItem, NULL, FALSE );
			Invalidate();
			NotifySelection();
		}
	}
}

void CLibraryTreeView::OnUpdateLibraryFolderFileProperties(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( m_nSelected > 0 );
}

void CLibraryTreeView::OnLibraryFolderFileProperties() 
{
	CSingleLock pLock( &Library.m_pSection, TRUE );
	CLibraryList pList;
	
	for ( CLibraryTreeItem* pItem = m_pSelFirst ; pItem ; pItem = pItem->m_pSelNext )
	{
		pItem->GetFileList( &pList, TRUE );
	}
	
	pLock.Unlock();
	
	CFilePropertiesSheet dlg;
	dlg.Add( &pList );
	dlg.DoModal();
}

void CLibraryTreeView::OnUpdateLibraryExportCollection(CCmdUI *pCmdUI)
{
	pCmdUI->Enable( m_bVirtual && m_nSelected == 1 );
}

void CLibraryTreeView::OnLibraryExportCollection()
{
	if ( m_pSelFirst == NULL || m_pSelFirst->m_pSelNext != NULL ) return;
	if ( m_pSelFirst->m_pVirtual == NULL ) return;
	if ( m_pSelFirst->m_pVirtual->m_pXML == NULL ) return;
	
	CCollectionExportDlg dlg( m_pSelFirst->m_pVirtual );
	dlg.DoModal();
}