wndsearch.cpp

p2p软件

	return TRUE;
}

void CSearchWnd::OnUpdateSearchSearch(CCmdUI* pCmdUI) 
{
	// pCmdUI->Enable( Network.IsWellConnected() );
	pCmdUI->Enable( TRUE );
}

void CSearchWnd::OnSearchSearch() 
{
	CSingleLock pLock( &m_pMatches->m_pSection );
	CManagedSearch* pSearch = NULL;
	
	if ( ! Network.IsWellConnected() ) Network.Connect( TRUE );
	
	if ( m_pMatches->m_nFiles > 0 )
	{
		CString strMessage;
		LoadString( strMessage, IDS_SEARCH_CLEAR_PREVIOUS );
		
		if ( AfxMessageBox( strMessage, MB_ICONQUESTION|MB_YESNO ) == IDYES )
		{
			pLock.Lock();
			m_pMatches->Clear();
			m_bUpdate = TRUE;
			PostMessage( WM_TIMER, 2 );
			pLock.Unlock();
		}
	}
	
	if ( m_wndPanel.m_bSendSearch )
	{
		pSearch = m_wndPanel.GetSearch();
		if ( pSearch == NULL ) return;
		
		if ( m_pMatches->m_nFiles == 0 && pSearch->m_pSearch->m_pSchema != NULL )
		{
			CPtrList pColumns;
			CSchemaColumnsDlg::LoadColumns( pSearch->m_pSearch->m_pSchema, &pColumns );
			m_wndList.SelectSchema( pSearch->m_pSearch->m_pSchema, &pColumns );
		}
	}
	else
	{
		CQuerySearch* pCriteria = GetLastSearch();
		
		if ( pCriteria != NULL ) pCriteria = new CQuerySearch( pCriteria );
		
		CNewSearchDlg dlg( NULL, pCriteria, FALSE, TRUE );
		if ( dlg.DoModal() != IDOK ) return;
		
		pCriteria = dlg.GetSearch();
		pSearch = new CManagedSearch( pCriteria );
	}
	
	Network.CreateID( &pSearch->m_pSearch->m_pGUID );
	
	pLock.Lock();
	
	if ( ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) != 0x8000 )
	{
		for ( POSITION pos = m_pSearches.GetHeadPosition() ; pos ; )
		{
			CManagedSearch* pManaged = (CManagedSearch*)m_pSearches.GetNext( pos );
			pManaged->Stop();
		}
	}
	
	m_pSearches.AddTail( pSearch );
	
	pLock.Unlock();
	
	ExecuteSearch();
}

void CSearchWnd::OnUpdateSearchClear(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( m_pMatches->m_nFiles > 0 );
}

void CSearchWnd::OnSearchClear() 
{
	m_wndList.DestructiveUpdate();
	m_pMatches->Clear();
	m_bUpdate = TRUE;
	PostMessage( WM_TIMER, 2 );
	
	OnSearchStop();
}

void CSearchWnd::OnUpdateSearchStop(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( ! m_bPaused );
}

void CSearchWnd::OnSearchStop() 
{
	CSingleLock pLock( &m_pMatches->m_pSection, TRUE );
	
	for ( POSITION pos = m_pSearches.GetHeadPosition() ; pos ; )
	{
		CManagedSearch* pManaged = (CManagedSearch*)m_pSearches.GetNext( pos );
		pManaged->Stop();
		pManaged->m_bReceive = FALSE;
	}

	m_bPaused = TRUE;

	UpdateMessages();
}

void CSearchWnd::OnUpdateSearchPanel(CCmdUI* pCmdUI) 
{
	CCoolBarItem* pItem = m_wndToolBar.GetID( ID_SEARCH_PANEL );
	pItem->SetCheck( m_bPanel );
	pItem->SetTip( m_bPanel ? _T("Hide the Search Panel") : _T("Show the Search Panel") );
}

void CSearchWnd::OnSearchPanel() 
{
	Settings.Search.SearchPanel = m_bPanel = ! m_bPanel;
	OnSkinChange();
}

void CSearchWnd::OnUpdateSearchDetails(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_bDetails );
}

void CSearchWnd::OnSearchDetails() 
{
	Settings.Search.DetailPanelVisible = m_bDetails = ! m_bDetails;
	OnSkinChange();
}

void CSearchWnd::OnSysCommand(UINT nID, LPARAM lParam) 
{
	if ( ( ( nID & 0xFFF0 ) == SC_MAXIMIZE ) && m_bPanelMode )
	{
		PostMessage( WM_COMMAND, ID_SEARCH_SEARCH );
	}
	else
	{
		CBaseMatchWnd::OnSysCommand( nID, lParam );
	}
}

/////////////////////////////////////////////////////////////////////////////
// CSearchWnd operations

CManagedSearch* CSearchWnd::GetLastManager()
{
	CSingleLock pLock( &m_pMatches->m_pSection, TRUE );
	return m_pSearches.GetCount() ? (CManagedSearch*)m_pSearches.GetTail() : NULL;
}

CQuerySearch* CSearchWnd::GetLastSearch()
{
	CManagedSearch* pManaged = GetLastManager();
	return pManaged ? pManaged->m_pSearch : NULL;
}

void CSearchWnd::ExecuteSearch()
{
	CManagedSearch* pManaged = GetLastManager();
	
	if ( pManaged )
	{
		m_bPaused = FALSE;
		m_tSearch = GetTickCount();
		
		pManaged->m_pSearch->BuildWordList();
		
		pManaged->Stop();
		pManaged->Start();
		
		m_wndPanel.ShowSearch( pManaged );
	}
	
	UpdateMessages();
}

void CSearchWnd::UpdateMessages(BOOL bActive)
{
	CManagedSearch* pManaged	= GetLastManager();
	CQuerySearch* pSearch		= pManaged ? pManaged->m_pSearch : NULL;
	
	CString strCaption;
	Skin.LoadString( strCaption, IDR_SEARCHFRAME );
	
	if ( pSearch != NULL )
	{
		strCaption += _T(" : ");

		if ( pSearch->m_sSearch.GetLength() )
		{
			strCaption += pSearch->m_sSearch;
		}
		else if ( pSearch->m_pSchema != NULL && pSearch->m_pXML != NULL )
		{
			strCaption += pSearch->m_pSchema->GetIndexedWords( pSearch->m_pXML->GetFirstElement() );
		}
		else if ( pSearch->m_bSHA1 ) 
		{
			strCaption += CSHA::HashToString( &pSearch->m_pSHA1, TRUE );
		}
		
		if ( pSearch->m_pSchema )
		{
			strCaption += _T(" (") + pSearch->m_pSchema->m_sTitle + _T(")");
		}
		
		if ( m_pMatches->m_nFilteredFiles || m_pMatches->m_nFilteredHits )
		{
			CString strStats;
			strStats.Format( _T(" [%lu/%lu]"), m_pMatches->m_nFilteredFiles, m_pMatches->m_nFilteredHits );
			strCaption += strStats;
			pManaged->m_nHits = m_pMatches->m_nFilteredHits;
		}
	}
	
	CString strOld;
	GetWindowText( strOld );
	
	if ( strOld != strCaption )
	{
		SetWindowText( strCaption );
		m_sCaption = strCaption;
	}
	
	if ( pManaged != NULL )
	{
		if ( m_nCacheHubs != pManaged->m_nHubs ||
			 m_nCacheLeaves != pManaged->m_nLeaves )
		{
			m_nCacheHubs = pManaged->m_nHubs;
			m_nCacheLeaves = pManaged->m_nLeaves;
			bActive = TRUE;
		}
	}

	if ( bActive )
	{
		m_wndPanel.ShowStatus( ! m_bPaused,
			m_pMatches->m_nFilteredFiles,
			m_pMatches->m_nFilteredHits,
			m_nCacheHubs, m_nCacheLeaves );
		
		CRect rcList;
		m_wndList.GetWindowRect( &rcList );
		ScreenToClient( &rcList );
		if ( ( rcList.top == 0 ) != m_bPaused ) OnSize( SIZE_INTERNAL, 0, 0 );
	}

	if ( m_pMatches->m_nFilteredFiles == 0 )
	{
		if ( m_pMatches->m_nFiles > 0 )
		{
			m_wndList.SetMessage( IDS_SEARCH_FILTERED, ! m_bPanel );
		}
		else if ( m_bPaused )
		{
			m_wndList.SetMessage( IDS_SEARCH_NONE, ! m_bPanel );
		}
		else if ( GetTickCount() - m_tSearch < 16000 )
		{
			m_wndList.SetMessage( IDS_SEARCH_WORKING, FALSE );
		}
		else
		{
			m_wndList.SetMessage( IDS_SEARCH_EMPTY, ! m_bPanel );
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
// CSearchWnd event handlers

BOOL CSearchWnd::OnQueryHits(CQueryHit* pHits)
{
	if ( m_bPaused || m_hWnd == NULL ) return FALSE;
	
	CSingleLock pLock( &m_pMatches->m_pSection );
	if ( ! pLock.Lock( 100 ) || m_bPaused ) return FALSE;
	
	for ( POSITION pos = m_pSearches.GetTailPosition() ; pos ; )
	{
		CManagedSearch* pManaged = (CManagedSearch*)m_pSearches.GetPrev( pos );
		BOOL bNull = FALSE;
		
		if ( pManaged->m_bReceive &&
			 (	pManaged->m_pSearch->m_pGUID == pHits->m_pSearchID ||
				( bNull = ( pHits->m_pSearchID == (GGUID&)GUID_NULL ) ) ) )
		{
			m_pMatches->AddHits( pHits, pManaged->m_pSearch, bNull );
			m_bUpdate = TRUE;
			
			if ( m_pMatches->m_nFilteredHits >= (DWORD)min( 201, Settings.eDonkey.MaxResults ) )
				pManaged->m_tLastED2K = 0xFFFFFFFF;
			
			if ( m_pMatches->m_nFilteredHits >= Settings.Gnutella.MaxResults )
				pManaged->Stop();
			
			return TRUE;
		}
	}
	
	return FALSE;
}

void CSearchWnd::OnTimer(UINT nIDEvent) 
{
	if ( nIDEvent == 1 )
	{
		if ( m_bSetFocus )
		{
			if ( m_bPanel && m_bPaused ) m_wndPanel.SetSearchFocus();
			else m_wndList.SetFocus();
			m_bSetFocus = FALSE;
		}
		
		if ( CManagedSearch* pManaged = GetLastManager() )
		{
			if ( m_nCacheHubs   != pManaged->m_nHubs ||
				 m_nCacheLeaves != pManaged->m_nLeaves )
			{
				UpdateMessages();
			}
		}
	}
	
	CBaseMatchWnd::OnTimer( nIDEvent );
	
	if ( m_pMatches->m_nFilteredHits == 0 ) m_wndDetails.Update( NULL );
}

void CSearchWnd::OnSelChangeMatches()
{
	CSingleLock pLock( &m_pMatches->m_pSection, TRUE );
	m_wndDetails.Update( m_pMatches->GetSelectedFile( TRUE ) );
}

/////////////////////////////////////////////////////////////////////////////
// CSearchWnd serialize

void CSearchWnd::Serialize(CArchive& ar)
{
	CSingleLock pLock( &m_pMatches->m_pSection, TRUE );
	CString strSchema;
	int nVersion = 1;
	
	if ( ar.IsStoring() )
	{
		ar << nVersion;
		
		ar.WriteCount( m_pSearches.GetCount() );
		
		for ( POSITION pos = m_pSearches.GetHeadPosition() ; pos ; )
		{
			CManagedSearch* pSearch = (CManagedSearch*)m_pSearches.GetNext( pos );
			pSearch->Serialize( ar );
		}
		
		if ( m_pMatches->m_pSchema )
		{
			ar << m_pMatches->m_pSchema->m_sURI;
		}
		else
		{
			ar << strSchema;
		}
	}
	else
	{
		ar >> nVersion;
		if ( nVersion != 1 ) AfxThrowUserException();
		
		m_bPaused = TRUE;
		
		for ( int nCount = ar.ReadCount() ; nCount > 0 ; nCount-- )
		{
			CManagedSearch* pSearch = new CManagedSearch();
			pSearch->Serialize( ar );
			m_pSearches.AddTail( pSearch );
		}
		
		ar >> strSchema;
		
		if ( CSchema* pSchema = SchemaCache.Get( strSchema ) )
		{
			CPtrList pColumns;
			CSchemaColumnsDlg::LoadColumns( pSchema, &pColumns );
			m_wndList.SelectSchema( pSchema, &pColumns );
		}
		
		if ( m_pSearches.GetCount() ) m_wndPanel.ShowSearch( GetLastManager() );
	}
	
	try
	{
		m_pMatches->Serialize( ar );
	}
	catch ( CException* pException )
	{
		pException->Delete();
		m_pMatches->Clear();
	}
	
	if ( ar.IsLoading() )
	{
		m_bUpdate = TRUE;
		PostMessage( WM_TIMER, 1 );
		SendMessage( WM_TIMER, 2 );
		SetAlert( FALSE );
	}
}