tf2/tf2_src/dedicated/console/TextConsoleWin32.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
// CTextConsoleWin32.cpp: Win32 implementation of the TextConsole class.
//
//////////////////////////////////////////////////////////////////////

#include "TextConsoleWin32.h"
#include "tier0/dbg.h"
#include "utlvector.h"

// Could possibly switch all this code over to using readline. This:
//   http://mingweditline.sourceforge.net/?Description
// readline() / add_history(char *)

#ifdef _WIN32

BOOL WINAPI ConsoleHandlerRoutine( DWORD CtrlType )
{
	NOTE_UNUSED( CtrlType );
	/* TODO ?
	if ( CtrlType != CTRL_C_EVENT && CtrlType != CTRL_BREAK_EVENT )
		m_System->Stop();	 // don't quit on break or ctrl+c
	*/

	return TRUE;
}

// GetConsoleHwnd() helper function from MSDN Knowledge Base Article Q124103
// needed, because HWND GetConsoleWindow(VOID) is not avaliable under Win95/98/ME

HWND GetConsoleHwnd(void)
{
	typedef HWND (WINAPI *PFNGETCONSOLEWINDOW)( VOID );
	static PFNGETCONSOLEWINDOW s_pfnGetConsoleWindow = (PFNGETCONSOLEWINDOW) GetProcAddress( GetModuleHandle("kernel32"), "GetConsoleWindow" );
	if ( s_pfnGetConsoleWindow )
		return s_pfnGetConsoleWindow();

	HWND hwndFound;         // This is what is returned to the caller.
	char pszNewWindowTitle[1024]; // Contains fabricated WindowTitle
	char pszOldWindowTitle[1024]; // Contains original WindowTitle

	// Fetch current window title.
	GetConsoleTitle( pszOldWindowTitle, 1024 );

	// Format a "unique" NewWindowTitle.
	wsprintf( pszNewWindowTitle,"%d/%d", GetTickCount(), GetCurrentProcessId() );

	// Change current window title.
	SetConsoleTitle(pszNewWindowTitle);

	// Ensure window title has been updated.
	Sleep(40);

	// Look for NewWindowTitle.
	hwndFound = FindWindow( NULL, pszNewWindowTitle );

	// Restore original window title.

	SetConsoleTitle( pszOldWindowTitle );

	return hwndFound;
} 

CTextConsoleWin32::CTextConsoleWin32()
{
	hinput	= NULL;
	houtput = NULL;
	Attrib = 0;
	statusline[0] = '\0';
}

bool CTextConsoleWin32::Init()
{
	(void) AllocConsole();
	SetTitle( "SOURCE DEDICATED SERVER" );

	hinput = GetStdHandle ( STD_INPUT_HANDLE );
	houtput = GetStdHandle ( STD_OUTPUT_HANDLE );
	
	if ( !SetConsoleCtrlHandler( &ConsoleHandlerRoutine, TRUE) )
	{
		Print( "WARNING! TextConsole::Init: Could not attach console hook.\n" );
	}

	Attrib = FOREGROUND_GREEN | FOREGROUND_INTENSITY | BACKGROUND_INTENSITY ;

	SetWindowPos( GetConsoleHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW );

	memset( m_szConsoleText, 0, sizeof( m_szConsoleText ) );
	m_nConsoleTextLen	= 0;
	m_nCursorPosition	= 0;

	memset( m_szSavedConsoleText, 0, sizeof( m_szSavedConsoleText ) );
	m_nSavedConsoleTextLen = 0;

	memset( m_aszLineBuffer, 0, sizeof( m_aszLineBuffer ) );
	m_nTotalLines	= 0;
	m_nInputLine	= 0;
	m_nBrowseLine	= 0;

	// these are log messages, not related to console
	Msg( "\n" );
	Msg( "Console initialized.\n" );

	return CTextConsole::Init();
}

void CTextConsoleWin32::ShutDown( void )
{
	FreeConsole();
}

void CTextConsoleWin32::SetVisible( bool visible )
{
	ShowWindow ( GetConsoleHwnd(), visible ? SW_SHOW : SW_HIDE );
	m_ConsoleVisible = visible;
}

char * CTextConsoleWin32::GetLine( int index, char *buf, int buflen )
{
	while ( 1 )
	{
		INPUT_RECORD	recs[ 1024 ];
		unsigned long	numread;
		unsigned long	numevents;

		if ( !GetNumberOfConsoleInputEvents( hinput, &numevents ) )
		{
			Error("CTextConsoleWin32::GetLine: !GetNumberOfConsoleInputEvents");
			return NULL;
		}

		if ( numevents <= 0 )
			break;

		if ( !ReadConsoleInput( hinput, recs, ARRAYSIZE( recs ), &numread ) )
		{
			Error("CTextConsoleWin32::GetLine: !ReadConsoleInput");
			return NULL;
		}

		if ( numread == 0 )
			return NULL;

		for ( int i=0; i < (int)numread; i++ )
		{
			INPUT_RECORD *pRec = &recs[i];
			if ( pRec->EventType != KEY_EVENT )
				continue;

			if ( pRec->Event.KeyEvent.bKeyDown )
			{
				// check for cursor keys
				if ( pRec->Event.KeyEvent.wVirtualKeyCode == VK_UP )
				{
					ReceiveUpArrow();
				}
				else if ( pRec->Event.KeyEvent.wVirtualKeyCode == VK_DOWN )
				{
					ReceiveDownArrow();
				}
				else if ( pRec->Event.KeyEvent.wVirtualKeyCode == VK_LEFT )
				{
					ReceiveLeftArrow();
				}
				else if ( pRec->Event.KeyEvent.wVirtualKeyCode == VK_RIGHT )
				{
					ReceiveRightArrow();
				}
				else
				{
					char	ch;
					int		nLen;

					ch = pRec->Event.KeyEvent.uChar.AsciiChar;
					switch ( ch )
					{
					case '\r':	// Enter
						nLen = ReceiveNewline();
						if ( nLen )
						{
							strncpy( buf, m_szConsoleText, buflen );
							buf[ buflen - 1 ] = 0;
							return buf;
						}
						break;

					case '\b':	// Backspace
						ReceiveBackspace();
						break;

					case '\t':	// TAB
						ReceiveTab();
						break;

					default:
						if ( ( ch >= ' ') && ( ch <= '~' ) )	// dont' accept nonprintable chars
						{
							ReceiveStandardChar( ch );
						}
						break;
					}
				}
			}
		}
	}

	return NULL;
}

void CTextConsoleWin32::Print( char * pszMsg )
{
	if ( m_nConsoleTextLen )
	{
		int nLen;

		nLen = m_nConsoleTextLen;

		while ( nLen-- )
		{
			PrintRaw( "\b \b" );
		}
	}

	PrintRaw( pszMsg );

	if ( m_nConsoleTextLen )
	{
		PrintRaw( m_szConsoleText, m_nConsoleTextLen );
	}

	UpdateStatus();
}

void CTextConsoleWin32::PrintRaw( const char * pszMsg, int nChars )
{
	unsigned long dummy;

	if ( houtput == NULL )
	{
		houtput = GetStdHandle ( STD_OUTPUT_HANDLE );
		if ( houtput == NULL )
			return;
	}
	
	if ( nChars <= 0 )
	{
		nChars = strlen( pszMsg );
		if ( nChars <= 0 )
			return;
	}

	// filter out ASCII BEL characters because windows actually plays a
	// bell sound, which can be used to lag the server in a DOS attack.
	char * pTempBuf = NULL;
	for ( int i = 0; i < nChars; ++i )
	{
		if ( pszMsg[i] == 0x07 /*BEL*/ )
		{
			if ( !pTempBuf )
			{
				pTempBuf = ( char * ) malloc( nChars );
				memcpy( pTempBuf, pszMsg, nChars );
			}
			pTempBuf[i] = '.';
		}
	}
	
	WriteFile( houtput, pTempBuf ? pTempBuf : pszMsg, nChars, &dummy, NULL );

	free( pTempBuf ); // usually NULL
}

int CTextConsoleWin32::GetWidth( void )
{
	CONSOLE_SCREEN_BUFFER_INFO	csbi;
	int							nWidth;

	nWidth = 0;

	if ( GetConsoleScreenBufferInfo( houtput, &csbi ) )
	{
		nWidth = csbi.dwSize.X;
	}

	if ( nWidth <= 1 )
		nWidth = 80;

	return nWidth;
} 

void CTextConsoleWin32::SetStatusLine( char * pszStatus )
{
	strncpy( statusline, pszStatus, 80 );
	statusline[ 79 ] = '\0';
	UpdateStatus();
}

void CTextConsoleWin32::UpdateStatus( void )
{
	COORD	coord;
	DWORD	dwWritten = 0;
	WORD	wAttrib[ 80 ];
	
	for ( int i = 0; i < 80; i++ )
	{
		wAttrib[i] = Attrib; //FOREGROUND_GREEN | FOREGROUND_INTENSITY | BACKGROUND_INTENSITY ;
	}

	coord.X = coord.Y = 0;

	WriteConsoleOutputAttribute( houtput, wAttrib, 80, coord, &dwWritten );
	WriteConsoleOutputCharacter( houtput, statusline, 80, coord, &dwWritten );	
}


void CTextConsoleWin32::SetTitle( char * pszTitle )
{
	SetConsoleTitle( pszTitle );
}

void CTextConsoleWin32::SetColor(WORD attrib) 
{
	Attrib = attrib;
}	

int CTextConsoleWin32::ReceiveNewline( void )
{
	int nLen = 0;

	PrintRaw( "\n" );

	if ( m_nConsoleTextLen )
	{
		nLen = m_nConsoleTextLen;

		m_szConsoleText[ m_nConsoleTextLen ] = 0;
		m_nConsoleTextLen = 0;
		m_nCursorPosition = 0;

		// cache line in buffer, but only if it's not a duplicate of the previous line
		if ( ( m_nInputLine == 0 ) || ( strcmp( m_aszLineBuffer[ m_nInputLine - 1 ], m_szConsoleText ) ) )
		{
			strncpy( m_aszLineBuffer[ m_nInputLine ], m_szConsoleText, MAX_CONSOLE_TEXTLEN );
			
			m_nInputLine++;

			if ( m_nInputLine > m_nTotalLines )
				m_nTotalLines = m_nInputLine;

			if ( m_nInputLine >= MAX_BUFFER_LINES )
				m_nInputLine = 0;

		}

		m_nBrowseLine = m_nInputLine;
	}

	return nLen;
}


void CTextConsoleWin32::ReceiveBackspace( void )
{
	int nCount;

	if ( m_nCursorPosition == 0 )
	{
		return;
	}

	m_nConsoleTextLen--;
	m_nCursorPosition--;

	PrintRaw( "\b" );

	for ( nCount = m_nCursorPosition; nCount < m_nConsoleTextLen; nCount++ )
	{
		m_szConsoleText[ nCount ] = m_szConsoleText[ nCount + 1 ];
		PrintRaw( m_szConsoleText + nCount, 1 );
	}

	PrintRaw( " " );

	nCount = m_nConsoleTextLen;
	while ( nCount >= m_nCursorPosition )
	{
		PrintRaw( "\b" );
		nCount--;
	}

	m_nBrowseLine = m_nInputLine;
}


void CTextConsoleWin32::ReceiveTab( void )
{
	CUtlVector<char *> matches;

	m_szConsoleText[ m_nConsoleTextLen ] = 0;

	if ( matches.Count() == 0 )
	{
		return;
	}

	if ( matches.Count() == 1 )
	{
		char * pszCmdName;
		char * pszRest;

		pszCmdName	= matches[0];
		pszRest		= pszCmdName + strlen( m_szConsoleText );

		if ( pszRest )
		{
			PrintRaw( pszRest );
			strcat( m_szConsoleText, pszRest );
			m_nConsoleTextLen += strlen( pszRest );

			PrintRaw( " " );
			strcat( m_szConsoleText, " " );
			m_nConsoleTextLen++;
		}
	}
	else
	{
		int		nLongestCmd;
		int		nTotalColumns;
		int		nCurrentColumn;
		char *	pszCurrentCmd;
		int i = 0;

		nLongestCmd = 0;

		pszCurrentCmd = matches[0];
		while ( pszCurrentCmd )
		{
			if ( (int)strlen( pszCurrentCmd) > nLongestCmd )
			{
				nLongestCmd = strlen( pszCurrentCmd);
			}

			i++;
			pszCurrentCmd = (char *)matches[i];
		}

		nTotalColumns	= ( GetWidth() - 1 ) / ( nLongestCmd + 1 );
		nCurrentColumn	= 0;

		PrintRaw( "\n" );

		// Would be nice if these were sorted, but not that big a deal
		pszCurrentCmd = matches[0];
		i = 0;
		while ( pszCurrentCmd )
		{
			char szFormatCmd[ 256 ];

			nCurrentColumn++;

			if ( nCurrentColumn > nTotalColumns )
			{
				PrintRaw( "\n" );
				nCurrentColumn = 1;
			}

			Q_snprintf( szFormatCmd, sizeof(szFormatCmd), "%-*s ", nLongestCmd, pszCurrentCmd );
			PrintRaw( szFormatCmd );

			i++;
			pszCurrentCmd = matches[i];
		}

		PrintRaw( "\n" );
		PrintRaw( m_szConsoleText );
		// TODO: Tack on 'common' chars in all the matches, i.e. if I typed 'con' and all the
		//       matches begin with 'connect_' then print the matches but also complete the
		//       command up to that point at least.
	}

	m_nCursorPosition	= m_nConsoleTextLen;
	m_nBrowseLine		= m_nInputLine;
}



void CTextConsoleWin32::ReceiveStandardChar( const char ch )
{
	int nCount;

	// If the line buffer is maxed out, ignore this char
	if ( m_nConsoleTextLen >= ( sizeof( m_szConsoleText ) - 2 ) )
	{
		return;
	}

	nCount = m_nConsoleTextLen;
	while ( nCount > m_nCursorPosition )
	{
		m_szConsoleText[ nCount ] = m_szConsoleText[ nCount - 1 ];
		nCount--;
	}

	m_szConsoleText[ m_nCursorPosition ] = ch;

	PrintRaw( m_szConsoleText + m_nCursorPosition, m_nConsoleTextLen - m_nCursorPosition + 1 );

	m_nConsoleTextLen++;
	m_nCursorPosition++;

	nCount = m_nConsoleTextLen;
	while ( nCount > m_nCursorPosition )
	{
		PrintRaw( "\b" );
		nCount--;
	}

	m_nBrowseLine = m_nInputLine;
}


void CTextConsoleWin32::ReceiveUpArrow( void )
{
	int nLastCommandInHistory;

	nLastCommandInHistory = m_nInputLine + 1;
	if ( nLastCommandInHistory > m_nTotalLines )
	{
		nLastCommandInHistory = 0;
	}

	if ( m_nBrowseLine == nLastCommandInHistory )
	{
		return;
	}

	if ( m_nBrowseLine == m_nInputLine )
	{
		if ( m_nConsoleTextLen > 0 )
		{
			// Save off current text
			strncpy( m_szSavedConsoleText, m_szConsoleText, m_nConsoleTextLen );
			// No terminator, it's a raw buffer we always know the length of
		}

		m_nSavedConsoleTextLen = m_nConsoleTextLen;
	}

	m_nBrowseLine--;
	if ( m_nBrowseLine < 0 )
	{
		m_nBrowseLine = m_nTotalLines - 1;
	}

	while ( m_nConsoleTextLen-- )	// delete old line
	{
		PrintRaw( "\b \b" );
	}

	// copy buffered line
	PrintRaw( m_aszLineBuffer[ m_nBrowseLine ] );

	strncpy( m_szConsoleText, m_aszLineBuffer[ m_nBrowseLine ], MAX_CONSOLE_TEXTLEN );
	m_nConsoleTextLen = strlen( m_aszLineBuffer[ m_nBrowseLine ] );

	m_nCursorPosition = m_nConsoleTextLen;
}


void CTextConsoleWin32::ReceiveDownArrow( void )
{
	if ( m_nBrowseLine == m_nInputLine )
	{
		return;
	}

	m_nBrowseLine++;
	if ( m_nBrowseLine > m_nTotalLines )
	{
		m_nBrowseLine = 0;
	}

	while ( m_nConsoleTextLen-- )	// delete old line
	{
		PrintRaw( "\b \b" );
	}

	if ( m_nBrowseLine == m_nInputLine )
	{
		if ( m_nSavedConsoleTextLen > 0 )
		{
			// Restore current text
			strncpy( m_szConsoleText, m_szSavedConsoleText, m_nSavedConsoleTextLen );
			// No terminator, it's a raw buffer we always know the length of

			PrintRaw( m_szConsoleText, m_nSavedConsoleTextLen );
		}

		m_nConsoleTextLen = m_nSavedConsoleTextLen;
	}
	else
	{
		// copy buffered line
		PrintRaw( m_aszLineBuffer[ m_nBrowseLine ] );

		strncpy( m_szConsoleText, m_aszLineBuffer[ m_nBrowseLine ], MAX_CONSOLE_TEXTLEN );

		m_nConsoleTextLen = strlen( m_aszLineBuffer[ m_nBrowseLine ] );
	}

	m_nCursorPosition = m_nConsoleTextLen;
}


void CTextConsoleWin32::ReceiveLeftArrow( void )
{
	if ( m_nCursorPosition == 0 )
	{
		return;
	}

	PrintRaw( "\b" );
	m_nCursorPosition--;
}


void CTextConsoleWin32::ReceiveRightArrow( void )
{
	if ( m_nCursorPosition == m_nConsoleTextLen )
	{
		return;
	}

	PrintRaw( m_szConsoleText + m_nCursorPosition, 1 );
	m_nCursorPosition++;
}

#endif // _WIN32