haiku.git

/*
 * Console.cpp - Mimicing the console driver
 * Based on the console driver.
 *
 * Copyright 2005 Michael Lotz. All rights reserved.
 * Distributed under the MIT License.
 *
 * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
 * Distributed under the terms of the NewOS License.
 */

#include "Console.h"
#include "ViewBuffer.h"
#include <stdio.h>

Console::Console(ViewBuffer *output)
	:	fState(CONSOLE_STATE_NORMAL),
		fOutput(output)
{
	fOutput->GetSize(&fColumns, &fLines);
	fOutput->SetResizeCallback(&ResizeCallback, this);
	ResetConsole();
	GotoXY(0, 0);
	SaveCursor(true);
	fOutput->Clear(0x0f);
}


Console::~Console()
{
}


void
Console::ResetConsole()
{
	fAttr = 0x0f;
	fScrollTop = 0;
	fScrollBottom = fLines - 1;
	fBrightAttr = true;
	fReverseAttr = false;
}


void
Console::ResizeCallback(int32 width, int32 height, void *data)
{
	Console *console = (Console *)data;
	
	console->fColumns = width;
	console->fLines = height;
	console->SetScrollRegion(console->fScrollTop, height - 1);
}


void
Console::SetScrollRegion(int top, int bottom)
{
	if (top < 0)
		top = 0;
	if (bottom >= fLines)
		bottom = fLines - 1;
	if (top > bottom)
		return;
	
	fScrollTop = top;
	fScrollBottom = bottom;
}


void
Console::ScrollUp()
{
	// see if cursor is outside of scroll region
	if (fY < fScrollTop || fY > fScrollBottom)
		return;
	
	if (fY - fScrollTop > 1) {
		// move the screen up one
		fOutput->Blit(0, fScrollTop + 1, fColumns, fY - fScrollTop, 0, fScrollTop);
	}
	
	// clear the bottom line
	fOutput->FillGlyph(0, fY, fColumns, 1, ' ', fAttr);
}


void
Console::ScrollDown()
{
	// see if cursor is outside of scroll region
	if (fY < fScrollTop || fY > fScrollBottom)
		return;
	
	if (fScrollBottom - fY > 1) {
		// move the screen down one
		fOutput->Blit(0, fY, fColumns, fScrollBottom - fY, 0, fY + 1);
	}
	
	// clear the top line
	fOutput->FillGlyph(0, fY, fColumns, 1, ' ', fAttr);
}


void
Console::LineFeed()
{
	if (fY == fScrollBottom) {
 		// we hit the bottom of our scroll region
 		ScrollUp();
	} else if (fY < fScrollBottom) {
		fY++;
	}
}


void
Console::RLineFeed()
{
	if (fY == fScrollTop) {
 		// we hit the top of our scroll region
 		ScrollDown();
	} else if (fY > fScrollTop) {
		fY--;
	}
}


void
Console::CariageReturn()
{
	fX = 0;
}


void
Console::Delete()
{
	if (fX > 0) {
		fX--;
	} else if (fY > 0) {
        fY--;
        fX = fColumns - 1;
    } else {
        ScrollDown();
        fY--;
        fX = fColumns - 1;
        return;
    }
	
	fOutput->PutGlyph(fX, fY, ' ', fAttr);
}


void
Console::Tab()
{
	fX = (fX + TAB_SIZE) & ~TAB_MASK;
	if (fX >= fColumns) {
		fX -= fColumns;
		LineFeed();
	}
}


void
Console::EraseLine(erase_line_mode mode)
{
	switch (mode) {
		case LINE_ERASE_WHOLE:
			fOutput->FillGlyph(0, fY, fColumns, 1, ' ', fAttr);
			break;
		case LINE_ERASE_LEFT:
			fOutput->FillGlyph(0, fY, fX + 1, 1, ' ', fAttr);
			break;
		case LINE_ERASE_RIGHT:
			fOutput->FillGlyph(fX, fY, fColumns - fX, 1, ' ', fAttr);
			break;
		default:
			return;
	}
}


void
Console::EraseScreen(erase_screen_mode mode)
{
	switch (mode) {
		case SCREEN_ERASE_WHOLE:
			fOutput->Clear(fAttr);
			break;
		case SCREEN_ERASE_UP:
			fOutput->FillGlyph(0, 0, fColumns, fY + 1, ' ', fAttr);
			break;
		case SCREEN_ERASE_DOWN:
			fOutput->FillGlyph(fY, 0, fColumns, fLines - fY, ' ', fAttr);
			break;
		default:
			return;
	}
}


void
Console::SaveCursor(bool save_attrs)
{
	fSavedX = fX;
	fSavedY = fY;
	
	if (save_attrs)
		fSavedAttr = fAttr;
}


void
Console::RestoreCursor(bool restore_attrs)
{
	fX = fSavedX;
	fY = fSavedY;
	
	if (restore_attrs)
		fAttr = fSavedAttr;
}


void
Console::UpdateCursor(int x, int y)
{
	fOutput->MoveCursor(x, y);
}


void
Console::GotoXY(int new_x, int new_y)
{
	if (new_x >= fColumns)
		new_x = fColumns - 1;
	if (new_x < 0)
		new_x = 0;
	if (new_y >= fLines)
		new_y = fLines - 1;
	if (new_y < 0)
		new_y = 0;
	
	fX = new_x;
	fY = new_y;
}


void
Console::PutChar(const char c)
{
	fOutput->PutGlyph(fX, fY, c, fAttr);
	if (++fX >= fColumns) {
		CariageReturn();
		LineFeed();
	}
}


void
Console::SetVT100Attributes(int32 *args, int32 argCount)
{
	if (argCount == 0) {
		// that's the default (attributes off)
		argCount++;
		args[0] = 0;
	}
	
	for (int32 i = 0; i < argCount; i++) {
		switch (args[i]) {
			case 0: // reset
				fAttr = 0x0f;
				fBrightAttr = true;
				fReverseAttr = false;
				break;
			case 1: // bright
				fBrightAttr = true;
				fAttr |= 0x08; // set the bright bit
				break;
			case 2: // dim
				fBrightAttr = false;
				fAttr &= ~0x08; // unset the bright bit
				break;
			case 4: // underscore we can't do
				break;
			case 5: // blink
				fAttr |= 0x80; // set the blink bit
				break;
			case 7: // reverse
				fReverseAttr = true;
				fAttr = ((fAttr & BMASK) >> 4) | ((fAttr & FMASK) << 4);
				if (fBrightAttr)
					fAttr |= 0x08;
				break;
			case 8: // hidden?
				break;
			
			/* foreground colors */
			case 30: fAttr = (fAttr & ~FMASK) | 0 | (fBrightAttr ? 0x08 : 0); break; // black
			case 31: fAttr = (fAttr & ~FMASK) | 4 | (fBrightAttr ? 0x08 : 0); break; // red
			case 32: fAttr = (fAttr & ~FMASK) | 2 | (fBrightAttr ? 0x08 : 0); break; // green
			case 33: fAttr = (fAttr & ~FMASK) | 6 | (fBrightAttr ? 0x08 : 0); break; // yellow
			case 34: fAttr = (fAttr & ~FMASK) | 1 | (fBrightAttr ? 0x08 : 0); break; // blue
			case 35: fAttr = (fAttr & ~FMASK) | 5 | (fBrightAttr ? 0x08 : 0); break; // magenta
			case 36: fAttr = (fAttr & ~FMASK) | 3 | (fBrightAttr ? 0x08 : 0); break; // cyan
			case 37: fAttr = (fAttr & ~FMASK) | 7 | (fBrightAttr ? 0x08 : 0); break; // white
			
			/* background colors */
			case 40: fAttr = (fAttr & ~BMASK) | (0 << 4); break; // black
			case 41: fAttr = (fAttr & ~BMASK) | (4 << 4); break; // red
			case 42: fAttr = (fAttr & ~BMASK) | (2 << 4); break; // green
			case 43: fAttr = (fAttr & ~BMASK) | (6 << 4); break; // yellow
			case 44: fAttr = (fAttr & ~BMASK) | (1 << 4); break; // blue
			case 45: fAttr = (fAttr & ~BMASK) | (5 << 4); break; // magenta
			case 46: fAttr = (fAttr & ~BMASK) | (3 << 4); break; // cyan
			case 47: fAttr = (fAttr & ~BMASK) | (7 << 4); break; // white
		}
	}
}


bool
Console::ProcessVT100Command(const char c, bool seen_bracket, int32 *args, int32 argCount)
{
	bool ret = true;
	
	if (seen_bracket) {
		switch(c) {
			case 'H': /* set cursor position */
			case 'f': {
				int32 row = argCount > 0 ? args[0] : 1;
				int32 col = argCount > 1 ? args[1] : 1;
				if (row > 0)
					row--;
				if (col > 0)
					col--;
				GotoXY(col, row);
				break;
			}
			case 'A': { /* move up */
				int32 deltay = argCount > 0 ? -args[0] : -1;
				if (deltay == 0)
					deltay = -1;
				GotoXY(fX, fY + deltay);
				break;
			}
			case 'e':
			case 'B': { /* move down */
				int32 deltay = argCount > 0 ? args[0] : 1;
				if (deltay == 0)
					deltay = 1;
				GotoXY(fX, fY + deltay);
				break;
			}
			case 'D': { /* move left */
				int32 deltax = argCount > 0 ? -args[0] : -1;
				if (deltax == 0)
					deltax = -1;
				GotoXY(fX + deltax, fY);
				break;
			}
			case 'a':
			case 'C': { /* move right */
				int32 deltax = argCount > 0 ? args[0] : 1;
				if (deltax == 0)
					deltax = 1;
				GotoXY(fX + deltax, fY);
				break;
			}
			case '`':
			case 'G': { /* set X position */
				int32 newx = argCount > 0 ? args[0] : 1;
				if (newx > 0)
					newx--;
				GotoXY(newx, fY);
				break;
			}
			case 'd': { /* set y position */
				int32 newy = argCount > 0 ? args[0] : 1;
				if (newy > 0)
					newy--;
				GotoXY(fX, newy);
				break;
			}
			case 's': /* save current cursor */
				SaveCursor(false);
				break;
			case 'u': /* restore cursor */
				RestoreCursor(false);
				break;
			case 'r': { /* set scroll region */
				int32 low = argCount > 0 ? args[0] : 1;
				int32 high = argCount > 1 ? args[1] : fLines;
				if (low <= high)
					SetScrollRegion(low - 1, high - 1);
				break;
			}
			case 'L': { /* scroll virtual down at cursor */
				int32 lines = argCount > 0 ? args[0] : 1;
				while (lines > 0) {
					ScrollDown();
					lines--;
				}
				break;
			}
			case 'M': { /* scroll virtual up at cursor */
				int32 lines = argCount > 0 ? args[0] : 1;
				while (lines > 0) {
					ScrollUp();
					lines--;
				}
				break;
			}
			case 'K':
				if (argCount == 0 || args[0] == 0) {
					// erase to end of line
					EraseLine(LINE_ERASE_RIGHT);
				} else if (argCount > 0) {
					if (args[0] == 1)
						EraseLine(LINE_ERASE_LEFT);
					else if (args[0] == 2)
						EraseLine(LINE_ERASE_WHOLE);
				}
				break;
			case 'J':
				if (argCount == 0 || args[0] == 0) {
					// erase to end of screen
					EraseScreen(SCREEN_ERASE_DOWN);
				} else if (argCount > 0) {
					if (args[0] == 1)
						EraseScreen(SCREEN_ERASE_UP);
					else if (args[0] == 2)
						EraseScreen(SCREEN_ERASE_WHOLE);
				}
				break;
			case 'm':
				if (argCount >= 0)
					SetVT100Attributes(args, argCount);
				break;
			default:
				ret = false;
		}
	} else {
		switch (c) {
			case 'c':
				ResetConsole();
				break;
			case 'D':
				RLineFeed();
				break;
			case 'M':
				LineFeed();
				break;
			case '7':
				SaveCursor(true);
				break;
			case '8':
				RestoreCursor(true);
				break;
			default:
				ret = false;
		}
	}
	
	return ret;
}


void
Console::Write(const void *buf, size_t len)
{
	UpdateCursor(-1, -1); // hide the cursor
	
	const char *c;
	size_t pos = 0;
	
	while (pos < len) {
		c = &((const char *)buf)[pos++];
		
		switch (fState) {
			case CONSOLE_STATE_NORMAL:
				// just output the stuff
				switch (*c) {
					case '\n':
						LineFeed();
						break;
					case '\r':
						CariageReturn();
						break;
					case 0x8: // backspace
						Delete();
						break;
					case '\t':
						Tab();
						break;
					case '\a':
						// beep
						//printf("<BEEP>\n");
						break;
					case '\0':
						break;
					case 0x1b:
						// escape character
						fArgCount = -1;
						fState = CONSOLE_STATE_GOT_ESCAPE;
						break;
					default:
						PutChar(*c);
				}
				break;
			case CONSOLE_STATE_GOT_ESCAPE:
				// look for either commands with no argument, or the '[' character
				switch (*c) {
					case '[':
						fState = CONSOLE_STATE_SEEN_BRACKET;
						break;
					default:
						fArgs[fArgCount] = 0;
						ProcessVT100Command(*c, false, fArgs, fArgCount + 1);
						fState = CONSOLE_STATE_NORMAL;
				}
				break;
			case CONSOLE_STATE_SEEN_BRACKET:
				switch (*c) {
					case '0'...'9':
						fArgCount = 0;
						fArgs[fArgCount] = *c - '0';
						fState = CONSOLE_STATE_PARSING_ARG;
						break;
					case '?':
						// private DEC mode parameter follows - we ignore those anyway
						// ToDo: check if it was really used in combination with a mode command
						break;
					default:
						ProcessVT100Command(*c, true, fArgs, fArgCount + 1);
						fState = CONSOLE_STATE_NORMAL;
				}
				break;
			case CONSOLE_STATE_NEW_ARG:
				switch (*c) {
					case '0'...'9':
						fArgCount++;
						if (fArgCount == MAX_ARGS) {
							fState = CONSOLE_STATE_NORMAL;
							break;
						}
						fArgs[fArgCount] = *c - '0';
						fState = CONSOLE_STATE_PARSING_ARG;
						break;
					default:
						ProcessVT100Command(*c, true, fArgs, fArgCount + 1);
						fState = CONSOLE_STATE_NORMAL;
				}
				break;
			case CONSOLE_STATE_PARSING_ARG:
				// parse args
				switch (*c) {
					case '0'...'9':
						fArgs[fArgCount] *= 10;
						fArgs[fArgCount] += *c - '0';
						break;
					case ';':
						fState = CONSOLE_STATE_NEW_ARG;
						break;
					default:
						ProcessVT100Command(*c, true, fArgs, fArgCount + 1);
						fState = CONSOLE_STATE_NORMAL;
				}
			}
	}
	
	UpdateCursor(fX, fY); // show it again
}