source-engine/hammer/FilteredComboBox.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#include "stdafx.h"
#include "FilteredComboBox.h"


BEGIN_MESSAGE_MAP(CFilteredComboBox, CComboBox)
	//{{AFX_MSG_MAP(CFilteredComboBox)
	ON_CONTROL_REFLECT_EX(CBN_SELCHANGE, OnSelChange)
	ON_CONTROL_REFLECT_EX(CBN_EDITCHANGE, OnEditChange)
	ON_CONTROL_REFLECT_EX(CBN_CLOSEUP, OnCloseUp)
	ON_CONTROL_REFLECT_EX(CBN_DROPDOWN, OnDropDown)
	ON_CONTROL_REFLECT_EX(CBN_SELENDOK, OnSelEndOK)
	ON_WM_CTLCOLOR()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


static const char *s_pStringToMatch = NULL;
static int s_iStringToMatchLen;


// This can help debug events in the combo box.
static int g_iFunctionMarkerEvent = 1;
class CFunctionMarker
{
public:
	CFunctionMarker( const char *p )
	{
#if 0
		m_iEvent = g_iFunctionMarkerEvent++;
		
		char str[512];
		Q_snprintf( str, sizeof( str ), "enter %d: %s\n", m_iEvent, p );
		OutputDebugString( str );
		m_p = p;
#endif
	}
	
	~CFunctionMarker()
	{
#if 0
		char str[512];
		Q_snprintf( str, sizeof( str ), "exit %d: %s\n", m_iEvent, m_p );
		OutputDebugString( str );
#endif
	}
	const char *m_p;
	int m_iEvent;
};

// ------------------------------------------------------------------------------------------------------------ //
// CFilteredComboBox implementation.
// ------------------------------------------------------------------------------------------------------------ //
CFilteredComboBox::CFilteredComboBox( CFilteredComboBox::ICallbacks *pCallbacks )
	: m_pCallbacks( pCallbacks )
{
	m_hQueuedFont = NULL;
	m_bInSelChange = false;
	m_bNotifyParent = true;
	m_dwTextColor = RGB(0, 0, 0);
	m_bOnlyProvideSuggestions = true;
	m_hEditControlFont = NULL;
	m_bInEnterKeyPressedHandler = false;
}


void CFilteredComboBox::SetSuggestions( CUtlVector<CString> &suggestions, int flags )
{
	CreateFonts();
	
	// Verify some of the window styles. This class requires these, and it doesn't get a change to set them
	// unless you call Create on it.
	// If we use owner draw variable, we get the bug described here: http://support.microsoft.com/kb/813791.
	Assert( GetStyle() & CBS_OWNERDRAWFIXED );
	Assert( GetStyle() & CBS_HASSTRINGS );
	Assert( !( GetStyle() & CBS_SORT ) );
	
	// Copy the list.
	m_Suggestions = suggestions;

	CString str;
	GetWindowText( str );
	DWORD sel = GetEditSel();

	FillDropdownList( NULL, false );
	
	// Force it to provide the first one if they only want suggestions and the current text in there is not valid.
	bool bSelectFirst = ((flags & SETSUGGESTIONS_SELECTFIRST) != 0);
	bool bCallback = ((flags & SETSUGGESTIONS_CALLBACK) != 0);
	bool bForceFirst = (m_bOnlyProvideSuggestions && FindSuggestion( str ) == -1);
	if ( bSelectFirst || bForceFirst )
	{
		SetCurSel( 0 );
		
		if ( GetCount() > 0 )
		{
			CString strLB;
			GetLBText( 0, strLB );
			if ( bCallback )
				DoTextChangedCallback( strLB );
		}
		else
		{
			m_LastTextChangedValue = "";
		}
	}
	else
	{	
		SetWindowText( str );
		SetEditSel( LOWORD( sel ), HIWORD( sel ) );
		if ( bCallback )
			DoTextChangedCallback( str );
	}
	
	SetRedraw( true );
	Invalidate();
}


void CFilteredComboBox::AddSuggestion( const CString &suggestion )
{
	if ( FindSuggestion( suggestion ) == -1 )
		m_Suggestions.AddToTail( suggestion );
}


void CFilteredComboBox::Clear()
{
	m_Suggestions.Purge();
	SetWindowText( "" );
}


void CFilteredComboBox::ForceEditControlText( const char *pStr )
{
	SetWindowText( pStr );
}


void CFilteredComboBox::SelectItem( const char *pStr )
{
	if ( !pStr )
	{
		SetEditControlText( "" );
		return;
	}
	
	// See if we already have this item selected. If so, don't do anything.
	int iCurSel = GetCurSel();
	if ( iCurSel != CB_ERR )
	{
		CString str;
		GetLBText( iCurSel, str );
		if ( Q_stricmp( pStr, str ) == 0 )
		{
			// Make sure the edit control has the right text in there. If they called ForceEditControlText,
			// then it might not.
			CString strWindow;
			GetWindowText( strWindow );
			if ( Q_stricmp( strWindow, pStr ) != 0 )
			{
				SetWindowText( pStr );
			}			
			
			m_LastTextChangedValue = pStr;
			return;
		}
	}
	
	if ( m_bOnlyProvideSuggestions && FindSuggestion( pStr ) == -1 )
	{
		// This item doesn't match any suggestion. We can get rid of this assert
		// if it becomes a nuissance, but for now it's good to note that this
		// is a weird situation.
		Assert( false );
		SetEditControlText( pStr );
		return;
	}
	
	FillDropdownList( pStr );
}


CString CFilteredComboBox::GetCurrentItem()
{
	return m_LastTextChangedValue;
}


void CFilteredComboBox::SetEditControlFont( HFONT hFont )
{
	if ( !hFont )
		return;
	
	if ( m_bInSelChange )
	{
		m_hQueuedFont = hFont;
		return;
	}

	CString str;
	GetWindowText( str );
	DWORD sel = GetEditSel();
	
	InternalSetEditControlFont( hFont, str, sel );
}


void CFilteredComboBox::InternalSetEditControlFont( HFONT hFont, const char *pEditText, DWORD sel )
{	
	if ( hFont != m_hEditControlFont )
	{
		CFunctionMarker marker( "InternalSetEditControlFont" );

		// Don't let it mess with everything here.
		SetRedraw( false );
		
		CRect rcMyRect;
		GetWindowRect( rcMyRect );
		CWnd *pParent = GetParent();
		if ( pParent )
			pParent->ScreenToClient( &rcMyRect );
		
		BOOL bWasDropped = GetDroppedState();
		
		
		m_hEditControlFont = hFont;
		SetFont( CFont::FromHandle( m_hEditControlFont ), false );

		
		SetWindowText( pEditText );
		SetEditSel( LOWORD( sel ), HIWORD( sel ) );
	
		if ( pParent )
			MoveWindow( rcMyRect );

		if ( bWasDropped )
			ShowDropDown( true );
			
					
		SetRedraw( true );
		Invalidate();
	}
}


HFONT CFilteredComboBox::GetEditControlFont() const
{
	return m_hEditControlFont;
}


void CFilteredComboBox::SetEditControlTextColor(COLORREF dwColor)
{
	m_dwTextColor = dwColor;
}


COLORREF CFilteredComboBox::GetEditControlTextColor() const
{
	return m_dwTextColor;
}


void CFilteredComboBox::SetEditControlText( const char *pText )
{
	SetWindowText( pText );
}


CString CFilteredComboBox::GetEditControlText() const
{
	CString ret;
	GetWindowText( ret );
	return ret;
}

bool CFilteredComboBox::IsWindowEnabled() const
{
	return (BaseClass::IsWindowEnabled() == TRUE);
}


void CFilteredComboBox::EnableWindow( bool bEnable )
{
	BaseClass::EnableWindow( bEnable );
}


void CFilteredComboBox::SetOnlyProvideSuggestions( bool bOnlyProvideSuggestions )
{
	m_bOnlyProvideSuggestions = bOnlyProvideSuggestions;
}


void CFilteredComboBox::FillDropdownList( const char *pInitialSel, bool bEnableRedraw )
{
	CFunctionMarker marker( "FillDropdownList" );

	SetRedraw( FALSE );
	ResetContent();
	
	// Fill the box with the initial set of values.
	CUtlVector<CString> items;
	GetItemsMatchingString( "", items );
	
	for ( int i=0; i < items.Count(); i++ )
		AddString( items[i] );

	if ( pInitialSel )
	{
		CString str = pInitialSel;
		if ( m_bOnlyProvideSuggestions )
		{
			str = GetBestSuggestion( pInitialSel );
			if ( !InternalSelectItemByName( pInitialSel) )
			{
				Assert( false );
			}
		}
		else
		{
			// Make sure we're putting the item they requested in there.
			if ( !InternalSelectItemByName( str ) )
			{
				// Add the typed text to the combobox here otherwise it'll select the nearest match when they drop it down with the mouse.
				AddString( str );
				InternalSelectItemByName( str );
			}
		}

		DoTextChangedCallback( str );
	}

	if ( bEnableRedraw )
	{
		SetRedraw( TRUE );
		Invalidate();
	}
}


LRESULT CFilteredComboBox::DefWindowProc(
   UINT message,
   WPARAM wParam,
   LPARAM lParam 
)
{
	// We handle the enter key specifically because the default combo box behavior is to
	// reset the text and all this stuff we don't want.
	if ( message == WM_KEYDOWN )
	{
		if ( wParam == '\r' )
		{
			OnEnterKeyPressed( NULL );
			return 0;
		}
		else if ( wParam == 27 )
		{
			// Escape..
			OnEscapeKeyPressed();
			return 0;
		}
	}
	
	return BaseClass::DefWindowProc( message, wParam, lParam );
}


BOOL CFilteredComboBox::PreCreateWindow( CREATESTRUCT& cs )
{
	// We need these styles in order for owner draw to work.
	// If we use CBS_OWNERDRAWVARIABLE, then we run into this bug: http://support.microsoft.com/kb/813791.
	cs.style |= CBS_OWNERDRAWFIXED | CBS_HASSTRINGS;
	cs.style &= ~CBS_SORT;
	return BaseClass::PreCreateWindow( cs );
}

void CFilteredComboBox::OnEnterKeyPressed( const char *pForceText )
{
	if ( m_bInEnterKeyPressedHandler )
		return;

	CFunctionMarker marker( "OnEnterKeyPressed" );
		
	m_bInEnterKeyPressedHandler = true;
	
	// Must do this before ShowDropDown because that will change these variables underneath us.
	CString szTypedText;
	DWORD sel;
	if ( pForceText )
	{
		szTypedText = pForceText;
		sel = 0;
	}
	else
	{
		GetWindowText( szTypedText );
		sel = GetEditSel();
	}

	CRect rcMyRect;
	GetWindowRect( rcMyRect );
	CWnd *pParent = GetParent();
	if ( pParent )
		pParent->ScreenToClient( &rcMyRect );

	SetRedraw( false );	
	ShowDropDown( FALSE );

	// They can get into here a variety of ways. Editing followed by enter. Editing+arrow keys, followed by enter, etc.
	if ( m_bOnlyProvideSuggestions )
	{
		CString str;
		if ( FindSuggestion( szTypedText ) == -1 && m_pCallbacks->OnUnknownEntry( szTypedText ) )
		{
			// They want us to KEEP this unknown entry, so add it to our list and select it.
			m_Suggestions.AddToTail( szTypedText );
			str = szTypedText;
		}
		else
		{
			// They returned false, so do the default behavior: go to the best match we can find.
			str = GetBestSuggestion( szTypedText );
		}
		
		DoTextChangedCallback( str );
		FillDropdownList( str, false );

		if ( GetCurSel() == CB_ERR )
			SetCurSel( 0 );
	}
	else
	{
		FillDropdownList( szTypedText, false );
		SetWindowText( szTypedText );
		SetEditSel( LOWORD(sel), HIWORD(sel) );
	}

	// Restore our window if necessary.
	if ( pParent )
		MoveWindow( &rcMyRect );
	SetRedraw( true );
	Invalidate();

	DoTextChangedCallback( GetEditControlText() );
	m_bInEnterKeyPressedHandler = false;
}


void CFilteredComboBox::OnEscapeKeyPressed()
{
	// Fill it with everything and force it to select whatever we last selected.
	m_bInEnterKeyPressedHandler = true;
	ShowDropDown( FALSE );
	m_bInEnterKeyPressedHandler = false;
	
	FillDropdownList( m_LastTextChangedValue, true );
}


BOOL CFilteredComboBox::OnDropDown()
{
	CFunctionMarker marker( "OnDropDown" );
	// This is necessary to keep the cursor from disappearing.
	SendMessage( WM_SETCURSOR, 0, 0 );
	return !m_bNotifyParent;
}

//-----------------------------------------------------------------------------
// Purpose: Attaches this object to the given dialog item.
//-----------------------------------------------------------------------------
void CFilteredComboBox::SubclassDlgItem(UINT nID, CWnd *pParent)
{
	//
	// Disable parent notifications for CControlBar-derived classes. This is
	// necessary because these classes result in multiple message reflections
	// unless we return TRUE from our message handler.
	//
	if (pParent->IsKindOf(RUNTIME_CLASS(CControlBar)))
	{
		m_bNotifyParent = false;
	}
	else
	{
		m_bNotifyParent = true;
	}

	BaseClass::SubclassDlgItem(nID, pParent);
}

BOOL CFilteredComboBox::OnSelChange()
{
	if ( !m_bInSelChange )
	{
		CFunctionMarker marker( "OnSelChange" );

		CString strOriginalText;
		GetWindowText( strOriginalText );
		DWORD dwOriginalEditSel = GetEditSel();
		
		
		m_bInSelChange = true;
		
		int iSel = GetCurSel();
		if ( iSel != CB_ERR )
		{
			CString str;
			GetLBText( iSel, str );
			strOriginalText = str;
			DoTextChangedCallback( str );
		}

		m_bInSelChange = false;

		if ( m_hQueuedFont )
		{
			HFONT hFont = m_hQueuedFont;
			m_hQueuedFont = NULL;
			m_bInSelChange = false;
			InternalSetEditControlFont( hFont, strOriginalText, dwOriginalEditSel );
		}
	}
	
	//
	// Despite MSDN's lies, returning FALSE here allows the parent
	// window to hook the notification message as well, not TRUE.
	//
	return !m_bNotifyParent;
}

BOOL CFilteredComboBox::OnCloseUp()
{
	if ( !m_bInEnterKeyPressedHandler )
	{
		CFunctionMarker marker( "OnCloseUp" );

		CString str;
		if ( GetCurSel() == CB_ERR || GetCount() == 0 )
			str = m_LastTextChangedValue;
		else
			GetLBText( GetCurSel(), str );
		OnEnterKeyPressed( str );
	}

	//
	// Despite MSDN's lies, returning FALSE here allows the parent
	// window to hook the notification message as well, not TRUE.
	//
	return !m_bNotifyParent;
}

BOOL CFilteredComboBox::OnSelEndOK()
{
	//
	// Despite MSDN's lies, returning FALSE here allows the parent
	// window to hook the notification message as well, not TRUE.
	//
	return !m_bNotifyParent;
}

BOOL CFilteredComboBox::OnEditChange()
{
	CFunctionMarker marker( "OnEditChange" );

	// Remember the text in the edit control because we're going to slam the
	// contents of the list and we'll want to put the text back in.
	CString szTypedText;
	DWORD dwEditSel;
	GetWindowText( szTypedText );
	dwEditSel = GetEditSel();

	// Show all the matching autosuggestions.
	CUtlVector<CString> items;
	GetItemsMatchingString( szTypedText, items );

	SetRedraw( FALSE );
	ResetContent();

	for ( int i=0; i < items.Count(); i++ )
	{
		AddString( items[i] );
	}

	// Add the typed text to the combobox here otherwise it'll select the nearest match when they drop it down with the mouse.
	if ( !m_bOnlyProvideSuggestions && FindSuggestion( szTypedText ) == -1 )
		AddString( szTypedText );

	// Note: for arcane and unspeakable MFC reasons, the placement of this call is VERY sensitive.
	// For example, if CTargetNameComboBox changes from a bold font to a normal font, then if this
	// call comes before ResetContent(), it will resize the dropdown listbox to a small size and not
	// size it back until it is cloesd and opened again.
	ShowDropDown();

	SetRedraw( TRUE );
	Invalidate();

	// Possibly tell the app about this change.
	if ( m_bOnlyProvideSuggestions )
	{
		if ( FindSuggestion( szTypedText ) != -1 )
			DoTextChangedCallback( szTypedText );
	}
	else
	{
		DoTextChangedCallback( szTypedText );
	}

	// Put the text BACK in there.
	SetWindowText( szTypedText );
	SetEditSel( LOWORD( dwEditSel ), HIWORD( dwEditSel ) );

	//
	// Despite MSDN's lies, returning FALSE here allows the parent
	// window to hook the notification message as well, not TRUE.
	//
	return !m_bNotifyParent;
}

int CFilteredComboBox::FindSuggestion( const char *pTest ) const
{
	for ( int i=0; i < m_Suggestions.Count(); i++ )
	{
		if ( Q_stricmp( m_Suggestions[i], pTest ) == 0 )
			return i;
	}
	return -1;
}


CString CFilteredComboBox::GetBestSuggestion( const char *pTest )
{
	// If it's an exact match, use that.
	if ( FindSuggestion( pTest ) != -1 )
		return pTest;

	// Look for the first autocomplete suggestion.
	CUtlVector<CString> matches;
	GetItemsMatchingString( pTest, matches );
	if ( matches.Count() > 0 )
		return matches[0];
	
	// Ok, fall back to the last known good one.
	return m_LastTextChangedValue;
}


CFont& CFilteredComboBox::GetNormalFont()
{
	CreateFonts();
	return m_NormalFont;
}


void CFilteredComboBox::GetItemsMatchingString( const char *pStringToMatch, CUtlVector<CString> &matchingItems )
{
	for ( int i=0; i < m_Suggestions.Count(); i++ )
	{
		if ( MatchString( pStringToMatch, m_Suggestions[i] ) )
			matchingItems.AddToTail( m_Suggestions[i] );
	}

	s_pStringToMatch = pStringToMatch;	
	s_iStringToMatchLen = V_strlen( pStringToMatch );
	matchingItems.Sort( &CFilteredComboBox::SortFn );
	s_pStringToMatch = NULL;
}


int CFilteredComboBox::SortFn( const CString *pItem1, const CString *pItem2 )
{
	// If one of them matches the prefix we're looking at, then that one should be listed first.
	// Otherwise, just do an alphabetical sort.
	bool bPrefixMatch1=false, bPrefixMatch2=false;
	if ( s_pStringToMatch )
	{
		bPrefixMatch1 = ( V_strnistr( *pItem1, s_pStringToMatch, s_iStringToMatchLen ) != NULL );
		bPrefixMatch2 = ( V_strnistr( *pItem2, s_pStringToMatch, s_iStringToMatchLen ) != NULL );
	}
	
	if ( bPrefixMatch1 == bPrefixMatch2 )
	{
		return Q_stricmp( *pItem1, *pItem2 );
	}
	else
	{
		return bPrefixMatch1 ? -1 : 1;
	}
}


bool CFilteredComboBox::MatchString( const char *pStringToMatchStart, const char *pTestStringStart )
{
	if ( !pStringToMatchStart || pStringToMatchStart[0] == 0 )
		return true;
	
	while ( *pTestStringStart )
	{
		const char *pStringToMatch = pStringToMatchStart;
		const char *pTestString = pTestStringStart;
		
		while ( 1 )
		{
			// Skip underscores in both strings.
			while ( *pStringToMatch == '_' )
				++pStringToMatch;
			
			while ( *pTestString == '_' )
				++pTestString;
			
			// If we're at the end of pStringToMatch with no mismatch, then treat this as a prefix match.
			// If we're at the end of pTestString, but pStringToMatch has more to go, then it's not a match.
			if ( *pStringToMatch == 0 )
				return true;
			else if ( *pTestString == 0 )
				break;
			
			// Match this character.
			if ( toupper( *pStringToMatch ) != toupper( *pTestString ) )
				break;
			
			++pStringToMatch;
			++pTestString;
		}
		
		++pTestStringStart;
	}
	
	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Called before painting to override default colors.
// Input  : pDC - DEvice context being painted into.
//			pWnd - Control asking for color.
//			nCtlColor - Type of control asking for color.
// Output : Returns the handle of a brush to use as the background color.
//-----------------------------------------------------------------------------
HBRUSH CFilteredComboBox::OnCtlColor(CDC *pDC, CWnd *pWnd, UINT nCtlColor)
{
	HBRUSH hBrush = CComboBox::OnCtlColor(pDC, pWnd, nCtlColor);

	if (nCtlColor == CTLCOLOR_EDIT)
	{
		pDC->SetTextColor(m_dwTextColor);
	}

	return(hBrush);
}


void CFilteredComboBox::DoTextChangedCallback( const char *pText )
{
	// Sometimes it'll call here from a few places in a row. Only pass the result
	// to the owner once.
	if ( Q_stricmp( pText, m_LastTextChangedValue ) == 0 )
		return;
		
	m_LastTextChangedValue = pText;
	m_pCallbacks->OnTextChanged( pText );
}


void CFilteredComboBox::CreateFonts()
{
	//
	// Create a normal and bold font.
	//
	if (!m_NormalFont.m_hObject)
	{
		CFont *pFont = GetFont();
		if (pFont)
		{
			LOGFONT LogFont;
			pFont->GetLogFont(&LogFont);
			m_NormalFont.CreateFontIndirect(&LogFont);
		}
	}
}


void CFilteredComboBox::MeasureItem(LPMEASUREITEMSTRUCT pStruct)
{
	HFONT hFont;
	CFont *pFont = GetFont();
	if ( pFont )
		hFont = *pFont;
	else
		hFont = (HFONT)GetStockObject( DEFAULT_GUI_FONT );

	CFont *pActualFont = CFont::FromHandle( hFont );
	if ( pActualFont )
	{
		LOGFONT logFont;
		pActualFont->GetLogFont( &logFont );
		pStruct->itemHeight = abs( logFont.lfHeight ) + 5;
	}
	else
	{
		pStruct->itemHeight = 16;
	}
}


void CFilteredComboBox::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
{
	if ( GetCount() == 0 )
		return;
		
	CString str;
	GetLBText( lpDrawItemStruct->itemID, str );

	CDC dc;
	dc.Attach( lpDrawItemStruct->hDC );

	// Save these values to restore them when done drawing.
	COLORREF crOldTextColor = dc.GetTextColor();
	COLORREF crOldBkColor = dc.GetBkColor();

	// If this item is selected, set the background color 
	// and the text color to appropriate values. Erase
	// the rect by filling it with the background color.
	// The left side of this expression was originally
	// "(lpDrawItemStruct->itemAction | ODA_SELECT)", which is always true.
	// To suppress the associated /analyze warning without changing
	// behavior the expression was fixed but commented out.
	if ( /*(lpDrawItemStruct->itemAction & ODA_SELECT) &&*/ (lpDrawItemStruct->itemState & ODS_SELECTED) )
	{
		dc.SetTextColor( ::GetSysColor(COLOR_HIGHLIGHTTEXT) );
		dc.SetBkColor( ::GetSysColor(COLOR_HIGHLIGHT) );
		dc.FillSolidRect( &lpDrawItemStruct->rcItem, ::GetSysColor(COLOR_HIGHLIGHT) );
	}
	else
	{
		dc.FillSolidRect(&lpDrawItemStruct->rcItem, crOldBkColor);
	}

	CFont *pOldFont = dc.SelectObject( &m_NormalFont );

	// Draw the text.
	RECT rcDraw = lpDrawItemStruct->rcItem;
	rcDraw.left += 1;
	dc.DrawText( str, -1, &rcDraw, DT_LEFT|DT_SINGLELINE|DT_VCENTER );

	// Restore stuff.
	dc.SelectObject( pOldFont );
	dc.SetTextColor(crOldTextColor);
	dc.SetBkColor(crOldBkColor);

	dc.Detach();
}


bool CFilteredComboBox::InternalSelectItemByName( const char *pName )
{
	int i = FindStringExact( -1, pName );
	if ( i == CB_ERR )
	{
		return false;
	}
	else
	{
		SetCurSel( i );
		
		CString str;
		GetWindowText( str );
		if ( Q_stricmp( str, pName ) != 0 )
			SetWindowText( pName );
		
		return true;
	}
}