Descent3/win32/wincon.cpp

/*
 * $Logfile: /DescentIII/Main/win32/wincon.cpp $
 * $Revision: 11 $
 * $Date: 4/07/99 10:56a $
 * $Author: Matt $
 *
 * 
 *
 * $Log: /DescentIII/Main/win32/wincon.cpp $
 * 
 * 11    4/07/99 10:56a Matt
 * Fixed compile warning.
 * 
 * 10    3/24/99 3:54p Jeff
 * handle backspaces in the Printf
 * 
 * 9     11/01/98 1:58a Jeff
 * converted the vsprintf calls to use the Pvsprintf, which is a safe
 * vsprintf, no buffer overflows allowed
 * 
 * 8     10/30/98 5:52p Jeff
 * implemented up arrow for last command, and esc to clear the line
 * 
 * 7     10/24/98 2:18p Samir
 * make close box inactive.
 * 
 * 6     10/21/98 4:49p Jeff
 * filter garbage out of strings to console
 * 
 * 5     10/02/98 11:15a Jeff
 * added HBITMAP, HFONT and HBRUSH type casts where needed to satisfy the
 * compiler
 * 
 * 4     9/16/98 6:39p Samir
 * make sure window isn't off screen.
 * 
 * 3     9/16/98 6:24p Samir
 * slightly improved.
 * 
 * 2     9/16/98 5:02p Samir
 * reimplemented X style console.
 * 
 * 1     9/14/98 4:02p Samir
 * new console library.
 *
 * $NoKeywords: $
 */

#include "DDAccess.h"
#include "Application.h"
#include "AppConsole.h"
#include "TaskSystem.h"

#define WIN32_LEAN_AND_MEAN
#include "pstring.h"
#include <windows.h>
#include <stdarg.h>
#include <string.h>
#include <process.h>
#include <stdio.h>

#define CON_SCROLL_ROWS 25
#define CON_SCROLL_COLS 80


static bool Con_init = false;
static bool Con_newline = false;
static char *Con_buffer = NULL;
static int Con_row, Con_col;
static char Con_read_buf[CON_SCROLL_COLS+4];
static char Con_inp_buf[CON_SCROLL_COLS+4], Con_inp_pos=0;
static char Con_last_command[CON_MAX_STRINGLEN];
static int Con_ch_w, Con_ch_h;
static HWND hConWnd = NULL;

void con_Create(HWND hWnd, LPCREATESTRUCT lpcs);
void con_Paint(HWND hWnd);
void con_Destroy(HWND hWnd);
void con_Puts(const char *str);
void con_Scroll();
int con_KeyDown(HWND hWnd, UINT vkey);
int con_Char(HWND hWnd, UINT vkey);


void con_Printf(const char *fmt, ...)
{
	char buf[CON_MAX_STRINGLEN];
	va_list args;

//	filter out messages
	va_start(args, fmt );
	Pvsprintf(buf,CON_MAX_STRINGLEN,fmt,args);

	int len = strlen(buf);
	if(len >= CON_MAX_STRINGLEN )
	{
		//we overflowed our buffer!!!
		//we need to do some sort of error here!!!!
		buf[CON_MAX_STRINGLEN-1] = '\0';
	}

//	filter out unprintable characters
	char *p,*fp,filter_buf[CON_MAX_STRINGLEN];
	p = buf;
	fp = filter_buf;

	while( *p )
	{
		if( *p == 0x01 )
		{
			//this is a color, skip the next 3
			p+=4;
		}else
		{
			if( isalnum (*p) || ispunct(*p) || (*p==' ') || (*p=='\n') || (*p=='\r') || (*p=='\b'))
			{
				*fp = *p;
				fp++;
			}
			p++;
		}
	}
	*fp = '\0';

	con_Puts(filter_buf);

	if (hConWnd) {
		InvalidateRect(hConWnd, NULL, TRUE);
		UpdateWindow(hConWnd);
	}
}


bool con_Input(char *buf, int buflen)
{
	if (Con_read_buf[0]) {
		strncpy(buf, Con_read_buf, buflen-1);
		buf[buflen-1] = 0;
		Con_read_buf[0] = 0;
		return true;
	}

	return false;
}


void con_Defer()
{
	if (Con_newline) {
		Con_newline = false;
		con_Puts("%");
		if (hConWnd) {
			InvalidateRect(hConWnd, NULL, TRUE);
			UpdateWindow(hConWnd);
		}
	}
}


// console window.
LRESULT WINAPI MyConProc( HWND hWnd,UINT msg,UINT wParam,LPARAM lParam)
{
	HDC hdc;

	switch (msg)
	{
	case WM_CREATE:
		{
			LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
			con_Create(hWnd, lpcs);
			break;
		}

	case WM_PAINT:
		con_Paint(hWnd);
		break;

	case WM_SYSCOMMAND:
		if (wParam == SC_CLOSE) {
			return 0;
		}
		break;

	case WM_SETFOCUS:
		{
		// The window has the input focus. Load the 
		// application-defined caret resource. 
			HFONT oldfont;

			hdc = GetDC(hWnd);
			
			oldfont = (HFONT)SelectObject(hdc, (HFONT)GetStockObject(ANSI_FIXED_FONT));
			SelectObject(hdc, oldfont);
			CreateCaret(hWnd, NULL, Con_ch_w, Con_ch_h); 
			SetCaretPos(Con_col * Con_ch_w, Con_row * Con_ch_h); 
			ShowCaret(hWnd); 

			ReleaseDC(hWnd, hdc);
			break; 
		}

	case WM_KILLFOCUS: 
		// The window is losing the input focus, 
		// so destroy the caret. 
		DestroyCaret(); 
		break; 	

	case WM_KEYDOWN:
		return con_KeyDown(hWnd, wParam);

	case WM_CHAR:
		return con_Char(hWnd, wParam);
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}


// console window helper functions
void con_Create(HWND hWnd, LPCREATESTRUCT lpcs)
{
	oeWin32Application *app = (oeWin32Application *)lpcs->lpCreateParams;
	HDC hdc;
	HFONT oldfont;
	RECT rect;
	TEXTMETRIC tm;

// create console region
	Con_row = 0;
	Con_col = 0;
	Con_buffer = new char[CON_SCROLL_ROWS * (CON_SCROLL_COLS+1)];
	Con_read_buf[0] = 0;
	Con_inp_pos = 0;
	memset(Con_inp_buf, 0, sizeof(Con_inp_buf));
	memset(Con_buffer, 0, CON_SCROLL_ROWS*(CON_SCROLL_COLS+1));
	memset(Con_last_command, 0, sizeof(Con_last_command));

	con_Puts("Outrage PC Console v1.0\n");

	Con_newline = true;

// get font width and height
	hdc = GetDC(hWnd);
	oldfont = (HFONT)SelectObject(hdc, (HFONT)GetStockObject(ANSI_FIXED_FONT));
	GetTextMetrics(hdc, &tm);
	Con_ch_w = tm.tmMaxCharWidth;
	Con_ch_h = tm.tmHeight;
	rect.left = lpcs->x;
	rect.top = lpcs->y;
	rect.right = rect.left + Con_ch_w*CON_SCROLL_COLS;
	rect.bottom = rect.top + Con_ch_h*CON_SCROLL_ROWS;
	
	AdjustWindowRect(&rect, lpcs->style, FALSE);
	MoveWindow(hWnd, lpcs->x, lpcs->y, rect.right-rect.left, rect.bottom-rect.top, TRUE);

	app->m_X = lpcs->x;
	app->m_Y = lpcs->y;
	app->m_W = rect.right - rect.left;
	app->m_H = rect.bottom - rect.top;

	SelectObject(hdc, oldfont);
	ReleaseDC(hWnd, hdc);

	EnableMenuItem(GetSystemMenu(hWnd, FALSE), SC_CLOSE,MF_BYCOMMAND | MF_GRAYED);

	hConWnd = hWnd;
}


void con_Paint(HWND hWnd)
{
	PAINTSTRUCT ps;
	HDC hdc = BeginPaint(hWnd, &ps);
	int i;
	HFONT hfont;

// use a fixed font.
	hfont = (HFONT)SelectObject(hdc, (HFONT)GetStockObject(ANSI_FIXED_FONT));

// draw buffer at 0 to Con_row to end of buffer.
	for (i = 0; i < CON_SCROLL_ROWS; i++)
	{
		char *ptr = &Con_buffer[i*(CON_SCROLL_COLS+1)];
		TextOut(hdc, 0, i*Con_ch_h, ptr, strlen(ptr));
	}

// end
	SelectObject(hdc, hfont);
	EndPaint(hWnd, &ps);
}


void con_Destroy(HWND hWnd)
{
	if (Con_buffer)
		delete[] Con_buffer;

	hConWnd = NULL;
}


void con_Puts(const char *str)
{
	int i,len = strlen(str);
	char *row = &Con_buffer[Con_row * (CON_SCROLL_COLS+1)];
	bool endline = false;

	for (i = 0; i < len; i++)
	{
		switch(str[i])
		{
		case '\n':
			endline = true;
			break;
		case '\b':
			if(Con_col>0)
			{
				row[Con_col] = ' ';
				Con_col--;
			}
			break;
		default:
			row[Con_col] = str[i];
			Con_col++;
			break;
		}

		if (Con_col == CON_SCROLL_COLS) {
			endline = true;
		}

		if (endline) {
			Con_row++;
			if (Con_row == CON_SCROLL_ROWS) {
				con_Scroll();
				Con_row--;
			}
			row = &Con_buffer[Con_row * (CON_SCROLL_COLS+1)];
			memset(row, 0, CON_SCROLL_COLS+1);
			Con_col = 0;
			endline = false;
		}
	}

	SetCaretPos(Con_ch_w * Con_col, Con_ch_h * Con_row);
}


void con_Scroll()
{
	int i;

	for (i = 1; i < CON_SCROLL_ROWS; i++)
		memcpy(&Con_buffer[(i-1)*(CON_SCROLL_COLS+1)], &Con_buffer[i*(CON_SCROLL_COLS+1)], CON_SCROLL_COLS+1);
	memset(&Con_buffer[(i-1)*(CON_SCROLL_COLS+1)], 0, CON_SCROLL_COLS+1);
}


int con_KeyDown(HWND hWnd, UINT vkey)
{
	//HDC hdc;
	int x;
	char *ptr = &Con_buffer[Con_row * (CON_SCROLL_COLS+1)];

	switch (vkey) 
	{ 
	case VK_LEFT:       // Left arrow 
  		Con_col = max(Con_col - 1, 0); 
		Con_inp_pos = max(Con_inp_pos-1,0);
  		break; 

	case VK_RIGHT:      // Right arrow 
  		Con_col = min(Con_col+1, CON_SCROLL_COLS-1);
  		Con_inp_pos = min(Con_inp_pos+1, CON_SCROLL_COLS-1);
  		break; 

	case VK_UP:			// Up arrow
		// Replace the current buffer that is being typed with the last completed command (if there was one)
		if(Con_last_command[0]!=0){
			memset(Con_inp_buf, 0, sizeof(Con_inp_buf));

			strcpy(Con_inp_buf,Con_last_command);

			ptr[0] = '%';
			strcpy(&ptr[1],Con_last_command);	//add for %

			Con_inp_pos = strlen(Con_last_command);
			Con_col = Con_inp_pos + 1;	//add for % prompt

		// The application will draw outside the 
		// WM_PAINT message processing, so hide the caret. 
			HideCaret(hWnd); 

		// Redraw the line, adjusted for the 
		// deleted character. 
			InvalidateRect(hWnd, NULL, TRUE);
			UpdateWindow(hWnd);

		// Display the caret. 
			ShowCaret(hWnd); 
		}
		break;

	case VK_DELETE:     // Delete 
	// Move all the characters that followed the 
	// deleted character (on the same line) one 
	// space back (to the left) in the matrix. 
		for (x = Con_inp_pos; x < CON_SCROLL_COLS; x++) 
			Con_inp_buf[x] = Con_inp_buf[x+1];
		
		for (x = Con_col; x < CON_SCROLL_COLS; x++) 
			ptr[x] = ptr[x+1];

	// The application will draw outside the 
	// WM_PAINT message processing, so hide the caret. 
		HideCaret(hWnd); 

	// Redraw the line, adjusted for the 
	// deleted character. 
		InvalidateRect(hWnd, NULL, TRUE);
		UpdateWindow(hWnd);

	// Display the caret. 
		ShowCaret(hWnd); 
		break; 
	}

// Adjust the caret position based on the 
// virtual-key processing. 
	SetCaretPos(Con_ch_w * Con_col, Con_ch_h * Con_row);

	return 0; 
}


int con_Char(HWND hWnd, UINT vkey)
{
	HDC hdc;
	char *ptr = &Con_buffer[Con_row * (CON_SCROLL_COLS+1)];

	switch (vkey) 
	{ 
	case 0x08:          // Backspace 
	// Move the caret back one space, and then 
	// process this like the DEL key. 
		if (Con_inp_pos > 0)
			Con_inp_pos--;
		
		if (Con_col > 0) {
			Con_col--; 
			SendMessage(hWnd, WM_KEYDOWN, VK_DELETE, 1L); 
		} 
		break; 

	case 0x0D:          // Carriage return 
		{
		// Go to the beginning of the next line. 
		// The bottom line wraps around to the top. 
			strcpy(Con_read_buf, Con_inp_buf);
			Con_col = 0;
			Con_row++;
			if (Con_row == CON_SCROLL_ROWS) {
				con_Scroll();
				Con_row--;
			}
			ptr = &Con_buffer[Con_row * (CON_SCROLL_COLS+1)];
			memset(ptr, 0, CON_SCROLL_COLS+1);

			//only save the buffer if there is text in the buffer
			char *p = Con_inp_buf;
			while( *p ){
				if(isalnum(*p)){
					strcpy(Con_last_command,Con_inp_buf);
					break;
				}
				p++;
			}

			memset(Con_inp_buf, 0, sizeof(Con_inp_buf));
			Con_inp_pos = 0;
	//		con_Printf("Command is %s.\n", Con_read_buf);
			Con_newline = true;
		}break; 

	case 0x1B:        // Escape 
		{
			memset(Con_inp_buf, 0, sizeof(Con_inp_buf));
			memset(ptr, 0, CON_SCROLL_COLS+1);

			ptr[0] = '%';			

			Con_inp_pos = 0;
			Con_col = 1;	//for % sign

		// The application will draw outside the 
		// WM_PAINT message processing, so hide the caret. 
			HideCaret(hWnd); 

		// Redraw the line, adjusted for the 
		// deleted character. 
			InvalidateRect(hWnd, NULL, TRUE);
			UpdateWindow(hWnd);

		// Display the caret. 
			ShowCaret(hWnd); 

		}break;
	case 0x0A:        // Linefeed 
		break; 

	default: 
		if (Con_inp_pos < (CON_SCROLL_COLS-2)) {
		// Add the character to the text buffer. 
			int oldcol = Con_col, oldrow = Con_row;
			char str[2];

			str[0] = (char)vkey;
			str[1] = 0;

			con_Puts(str);
			Con_inp_buf[Con_inp_pos] = (char)vkey;

		// The application will draw outside the 
		// WM_PAINT message processing, so hide the caret. 
			HideCaret(hWnd); 

		// Draw the character on the screen. 
			hdc = GetDC(hWnd); 
			SelectObject(hdc, GetStockObject(ANSI_FIXED_FONT)); 
			TextOut(hdc, Con_ch_w*oldcol, Con_ch_h*oldrow, str, 1);
			ReleaseDC(hWnd, hdc); 

		// Display the caret. 
			ShowCaret(hWnd); 
			Con_inp_pos++;
		}


		break; 
	}

	SetCaretPos(Con_col*Con_ch_w, Con_row*Con_ch_h);

	return 0; 
}