wndmain.cpp

p2p软件

	CWaitCursor pCursor;
	SetGUIMode( GUI_TABBED );
}

void CMainWnd::OnUpdateViewWindowed(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.General.GUIMode == GUI_WINDOWED );
}

void CMainWnd::OnViewWindowed() 
{
	if ( Settings.General.GUIMode == GUI_WINDOWED ) return;
	CString strMessage;
	LoadString( strMessage, IDS_VIEW_MODE_CONFIRM );
	if ( AfxMessageBox( strMessage, MB_ICONQUESTION|MB_YESNO ) != IDYES ) return;
	CWaitCursor pCursor;
	SetGUIMode( GUI_WINDOWED );
}

void CMainWnd::OnUpdateViewSystem(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CSystemWnd) ) != NULL );
}

void CMainWnd::OnViewSystem() 
{
	m_pWindows.Open( RUNTIME_CLASS(CSystemWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewNeighbours(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CNeighboursWnd) ) != NULL );
}

void CMainWnd::OnViewNeighbours() 
{
	m_pWindows.Open( RUNTIME_CLASS(CNeighboursWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewTraffic(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CTrafficWnd) ) != NULL );
}

void CMainWnd::OnViewTraffic() 
{
	if ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 )
	{
		new CTrafficWnd();
	}
	else
	{
		m_pWindows.Open( RUNTIME_CLASS(CTrafficWnd), TRUE );
	}
	OpenFromTray();
}

void CMainWnd::OnUpdateViewDownloads(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CDownloadsWnd) ) != NULL );
}

void CMainWnd::OnViewDownloads() 
{
	m_pWindows.Open( RUNTIME_CLASS(CDownloadsWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewUploads(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CUploadsWnd) ) != NULL );
}

void CMainWnd::OnViewUploads() 
{
	m_pWindows.Open( RUNTIME_CLASS(CUploadsWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewLibrary(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CLibraryWnd) ) != NULL );
}

void CMainWnd::OnViewLibrary() 
{
	m_pWindows.Open( RUNTIME_CLASS(CLibraryWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewMedia(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CMediaWnd) ) != NULL );
}

void CMainWnd::OnViewMedia() 
{
	if ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 )
	{
		new CMediaWnd();
	}
	else
	{
		m_pWindows.Open( RUNTIME_CLASS(CMediaWnd), TRUE );
	}
	OpenFromTray();
}

void CMainWnd::OnUpdateViewHosts(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CHostCacheWnd) ) != NULL );
}

void CMainWnd::OnViewHosts() 
{
	m_pWindows.Open( RUNTIME_CLASS(CHostCacheWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewDiscovery(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CDiscoveryWnd) ) != NULL );
}

void CMainWnd::OnViewDiscovery() 
{
	m_pWindows.Open( RUNTIME_CLASS(CDiscoveryWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewPackets(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CPacketWnd) ) != NULL );
}

void CMainWnd::OnViewPackets() 
{
	if ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 )
	{
		new CPacketWnd();
	}
	else
	{
		m_pWindows.Open( RUNTIME_CLASS(CPacketWnd), TRUE );
	}
	OpenFromTray();
}

void CMainWnd::OnUpdateViewSearchMonitor(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CSearchMonitorWnd) ) != NULL );
}

void CMainWnd::OnViewSearchMonitor() 
{
	m_pWindows.Open( RUNTIME_CLASS(CSearchMonitorWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewResultsMonitor(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CHitMonitorWnd) ) != NULL );
}

void CMainWnd::OnViewResultsMonitor() 
{
	m_pWindows.Open( RUNTIME_CLASS(CHitMonitorWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewSecurity(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CSecurityWnd) ) != NULL );
}

void CMainWnd::OnViewSecurity() 
{
	m_pWindows.Open( RUNTIME_CLASS(CSecurityWnd), TRUE );
	OpenFromTray();
}

void CMainWnd::OnUpdateViewHelp(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_pWindows.Find( RUNTIME_CLASS(CHelpWnd) ) != NULL );
}

void CMainWnd::OnViewHelp() 
{
	m_pWindows.Open( RUNTIME_CLASS(CHelpWnd), TRUE );
	OpenFromTray();
}

/////////////////////////////////////////////////////////////////////////////
// CMainWnd tab menu

void CMainWnd::OnUpdateTabConnect(CCmdUI* pCmdUI) 
{
	CCoolBarItem* pItem = m_wndToolBar.GetID( ID_TAB_CONNECT );
	
	UINT nTextID = 0;
	UINT nTipID = 0;
	
	if ( Network.IsWellConnected() )
	{
		if ( pItem ) pItem->SetCheck( FALSE );
		if ( pItem ) pItem->SetTextColour( RGB( 255, 0, 0 ) );
		m_wndTabBar.SetMessage( IDS_TABBAR_CONNECTED );
		nTextID	= IDS_NETWORK_DISCONNECT;
		nTipID	= ID_NETWORK_DISCONNECT;
	}
	else if ( Network.IsConnected() )
	{
		if ( pItem ) pItem->SetCheck( TRUE );
		if ( pItem ) pItem->SetTextColour( CoolInterface.m_crCmdText == 0 ? RGB( 0, 127, 0 ) : CoolInterface.m_crCmdText );
		m_wndTabBar.SetMessage( (UINT)0 );
		nTextID	= IDS_NETWORK_CONNECTING;
		nTipID	= ID_NETWORK_DISCONNECT;
	}
	else
	{
		if ( pItem ) pItem->SetCheck( FALSE );
		if ( pItem ) pItem->SetTextColour( CoolInterface.m_crCmdText == 0 ? RGB( 0, 127, 0 ) : CoolInterface.m_crCmdText );
		m_wndTabBar.SetMessage( IDS_TABBAR_NOT_CONNECTED );
		nTextID	= IDS_NETWORK_CONNECT;
		nTipID	= ID_NETWORK_CONNECT;
	}
	
	CString strText;
	
	LoadString( strText, nTextID );
	if ( pItem ) pItem->SetText( strText );
	
	LoadString( strText, nTipID );
	if ( pItem ) pItem->SetTip( strText );
	
	if ( pItem ) pItem->SetImage( nTipID );
}

void CMainWnd::OnTabConnect() 
{
	if ( Network.IsConnected() )
	{
		CString strMessage;
		LoadString( strMessage, IDS_NETWORK_DISCONNECT_CONFIRM );

		if ( ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) ||
			 ! Network.IsWellConnected() ||
			AfxMessageBox( strMessage, MB_ICONQUESTION|MB_YESNO ) == IDYES )
		{
			Network.Disconnect();
		}
	}
	else
	{
		Network.Connect( TRUE );

		CChildWnd* pActive = m_pWindows.GetActive();

		if ( ! pActive || ! pActive->IsKindOf( RUNTIME_CLASS(CHomeWnd) ) )
		{
			m_pWindows.Open( RUNTIME_CLASS(CNeighboursWnd) );
		}
	}
}

void CMainWnd::OnUpdateTabHome(CCmdUI* pCmdUI) 
{
	CChildWnd* pChild = m_pWindows.GetActive();
	pCmdUI->SetCheck( pChild && pChild->IsKindOf( RUNTIME_CLASS(CHomeWnd) ) );
}

void CMainWnd::OnTabHome() 
{
	m_pWindows.Open( RUNTIME_CLASS(CHomeWnd) );
	OpenFromTray();
}

void CMainWnd::OnUpdateTabLibrary(CCmdUI* pCmdUI) 
{
	CChildWnd* pChild = m_pWindows.GetActive();
	pCmdUI->SetCheck( pChild && pChild->IsKindOf( RUNTIME_CLASS(CLibraryWnd) ) );
}

void CMainWnd::OnTabLibrary() 
{
	m_pWindows.Open( RUNTIME_CLASS(CLibraryWnd) );
	OpenFromTray();
}

void CMainWnd::OnUpdateTabMedia(CCmdUI* pCmdUI) 
{
	CMediaWnd* pChild = (CMediaWnd*)m_pWindows.GetActive();
	pCmdUI->SetCheck( pChild && pChild->IsKindOf( RUNTIME_CLASS(CMediaWnd) ) );

	if ( CCoolBarItem* pItem = m_wndToolBar.GetID( ID_TAB_MEDIA ) )
	{
		if ( pChild = (CMediaWnd*)m_pWindows.Find( RUNTIME_CLASS(CMediaWnd) ) )
		{
			pItem->SetTextColour( pChild->IsPlaying() ? RGB( 0, 0x80, 0 ) : CoolInterface.m_crCmdText );
		}
		else
		{
			pItem->SetTextColour( CoolInterface.m_crCmdText );
		}
	}
}

void CMainWnd::OnTabMedia() 
{
	m_pWindows.Open( RUNTIME_CLASS(CMediaWnd) );
	OpenFromTray();
}

void CMainWnd::OnUpdateTabSearch(CCmdUI* pCmdUI) 
{
	CChildWnd* pChild = m_pWindows.GetActive();
	// pCmdUI->SetCheck( pChild && pChild->IsKindOf( RUNTIME_CLASS(CSearchPadWnd) ) );
	pCmdUI->SetCheck( pChild && pChild->IsKindOf( RUNTIME_CLASS(CSearchWnd) ) );
}

void CMainWnd::OnTabSearch() 
{
	if ( Settings.General.GUIMode != GUI_WINDOWED )
	{
		// m_pWindows.Open( RUNTIME_CLASS(CSearchPadWnd) );
		m_pWindows.OpenNewSearchWindow();
		OpenFromTray();
	}
	else
	{
		PostMessage( WM_COMMAND, ID_NETWORK_SEARCH );
	}
}

void CMainWnd::OnUpdateTabTransfers(CCmdUI* pCmdUI) 
{
	CChildWnd* pChild = m_pWindows.GetActive();
	
	if ( pChild != NULL && pChild->m_pGroupParent != NULL )
	{
		pChild = pChild->m_pGroupParent;
		if ( ! m_pWindows.Check( pChild ) ) pChild = NULL;
	}
	
	pCmdUI->SetCheck( pChild != NULL && pChild->IsKindOf( RUNTIME_CLASS(CDownloadsWnd) ) );
}

void CMainWnd::OnTabTransfers() 
{
	m_pWindows.Open( RUNTIME_CLASS(CDownloadsWnd) );
	OpenFromTray();
}

void CMainWnd::OnUpdateTabNetwork(CCmdUI* pCmdUI) 
{
	CChildWnd* pChild = m_pWindows.GetActive();
	
	if ( pChild != NULL && pChild->m_pGroupParent != NULL )
	{
		pChild = pChild->m_pGroupParent;
		if ( ! m_pWindows.Check( pChild ) ) pChild = NULL;
	}
	
	pCmdUI->SetCheck( pChild != NULL && pChild->IsKindOf( RUNTIME_CLASS(CNeighboursWnd) ) );
}

void CMainWnd::OnTabNetwork() 
{
	m_pWindows.Open( RUNTIME_CLASS(CNeighboursWnd) );
	OpenFromTray();
}

void CMainWnd::OnUpdateTabHelp(CCmdUI* pCmdUI) 
{
	CChildWnd* pChild = m_pWindows.GetActive();
	pCmdUI->SetCheck( pChild && pChild->IsKindOf( RUNTIME_CLASS(CHelpWnd) ) );
}

void CMainWnd::OnTabHelp() 
{
	m_pWindows.Open( RUNTIME_CLASS(CHelpWnd) );
	OpenFromTray();
}

/////////////////////////////////////////////////////////////////////////////
// CMainWnd tools menu

void CMainWnd::OnUpdateToolsDownload(CCmdUI* pCmdUI)
{
	pCmdUI->Enable( IsWindowEnabled() );
}

void CMainWnd::OnToolsDownload() 
{
	CDownloadDlg dlg;
	if ( dlg.DoModal() != IDOK ) return;

	if ( dlg.m_pURL->m_nAction == CShareazaURL::uriDownload )
	{
		Downloads.Add( dlg.m_pURL );
		if ( ! Network.IsWellConnected() ) Network.Connect( TRUE );
		m_pWindows.Open( RUNTIME_CLASS(CDownloadsWnd) );
	}
	else if ( dlg.m_pURL->m_nAction == CShareazaURL::uriSource )
	{
		Downloads.Add( dlg.m_pURL );
		m_pWindows.Open( RUNTIME_CLASS(CDownloadsWnd) );
	}
	else
	{
		PostMessage( WM_URL, (WPARAM)dlg.GetURL() );
	}
}

void CMainWnd::OnToolsSkin() 
{
	if ( ! IsWindowEnabled() ) return;
	CSettingsManagerDlg::Run( _T("CSkinsSettingsPage") );
}

void CMainWnd::OnToolsLanguage() 
{
	if ( ! IsWindowEnabled() ) return;
	theApp.WriteProfileInt( _T("Windows"), _T("RunLanguage"), TRUE );
	
	CLanguageDlg dlg;
	
	if ( dlg.DoModal() == IDOK )
	{
		CWaitCursor pCursor;
		OnSkinChanged( 0, 0 );
		SetGUIMode( Settings.General.GUIMode );
	}
	
	if ( theApp.GetProfileInt( _T("Windows"), _T("RunWizard"), FALSE ) == FALSE )
	{
		PostMessage( WM_COMMAND, ID_TOOLS_WIZARD );
	}
}

void CMainWnd::OnToolsMercora()
{
	if ( CWnd* pWnd = FindWindow( _T("MercoraClient"), NULL ) )
	{
		pWnd->ShowWindow( SW_SHOWNORMAL );
		pWnd->BringWindowToTop();
		pWnd->SetForegroundWindow();
		return;
	}
	
	HKEY hKey = NULL;
	RegOpenKeyEx( HKEY_LOCAL_MACHINE, _T("Software\\Mercora\\MercoraClient"), 0, KEY_READ, &hKey );
	
	if ( hKey != NULL )
	{
		DWORD nType = REG_SZ, nEXE = sizeof(TCHAR) * MAX_PATH;
		TCHAR szEXE[MAX_PATH+1];
		RegQueryValueEx( hKey, _T("EXE"), NULL, &nType, (PBYTE)szEXE, &nEXE );
		szEXE[ nEXE ] = 0;
		RegCloseKey( hKey );
		int nResult = (int)ShellExecute( GetSafeHwnd(), NULL, szEXE, NULL, NULL, SW_SHOWNORMAL );
		if ( nResult > 32 ) return;
	}
	
	ShellExecute( GetSafeHwnd(), NULL, _T("http://www.mercora.com/"), NULL, NULL, SW_SHOWNORMAL );
}

void CMainWnd::OnToolsProfile() 
{
	CProfileManagerDlg dlg;
	dlg.DoModal();
}

void CMainWnd::OnLibraryFolders()