haiku.git

/*
 * Copyright 2007, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT license.
 *
 * Author:
 *		François Revol, revol@free.fr.
 */

#include <SupportDefs.h>
#include <string.h>
#include "rom_calls.h"
#include <util/kernel_cpp.h>

#include "Handle.h"
#include "console.h"
#include "keyboard.h"

class ConsoleHandle : public CharHandle {
	public:
		ConsoleHandle();

		virtual ssize_t ReadAt(void *cookie, off_t pos, void *buffer,
			size_t bufferSize);
		virtual ssize_t WriteAt(void *cookie, off_t pos, const void *buffer,
			size_t bufferSize);

		void	Clear();
		void	MoveTo(int16 x, int16 y);
		void	SetColor(int32 foreground, int32 background);
		int		Columns();
		int		Rows();

	private:
		static int16	fX;
		static int16	fY;
		uint16	fPen;
};

class ConsoleDevice : public ExecDevice {
	public:
		ConsoleDevice(const char *title);
		virtual ~ConsoleDevice();

		status_t	Open();

		virtual ssize_t ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize);
		virtual ssize_t WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize);

		void	Clear();
		void	MoveTo(int16 x, int16 y);
		void	SetColor(int32 foreground, int32 background);

		int		Columns();
		int		Rows();

		int	WaitForKey();

	protected:
		const char	*fTitle;
		struct Window	*fWindow;
		int	fRows, fCols;
};

class KeyboardDevice : public ExecDevice {
	public:
		KeyboardDevice();
		virtual ~KeyboardDevice();

		status_t	Open();

		virtual ssize_t ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize);
		virtual ssize_t WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize);

		int	WaitForKey();
		status_t	ReadEvent(struct InputEvent *event);

	protected:
};

class LLKeyboardDevice : public CharHandle {
	public:
		LLKeyboardDevice();
		virtual ~LLKeyboardDevice();

		status_t	Open();

		virtual ssize_t ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize);
		virtual ssize_t WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize);

		int	WaitForKey();

	protected:
};


static const uint16 kPalette[] = {
	0x000,
	0x00a,
	0x0a0,
	0x0aa,
	0xa00,
	0xa0a,
	0xa50,
	0xaaa,
	0x555,
	0x55f,
	0x5f5,
	0x5ff,
	0xf55,
	0xf5f,
	0xff5,
	0xfff
};

struct Screen *gScreen;
static int16 sFontWidth, sFontHeight;
static int sScreenTopOffset = 16;
int16 ConsoleHandle::fX = 0;
int16 ConsoleHandle::fY = 0;

FILE *stdin, *stdout, *stderr, *dbgerr;


//	#pragma mark -

ConsoleHandle::ConsoleHandle()
	: CharHandle()
{
}


ssize_t
ConsoleHandle::ReadAt(void */*cookie*/, off_t /*pos*/, void *buffer,
	size_t bufferSize)
{
	// don't seek in character devices
	// not implemented (and not yet? needed)
	return B_ERROR;
}


ssize_t
ConsoleHandle::WriteAt(void */*cookie*/, off_t /*pos*/, const void *buffer,
	size_t bufferSize)
{
	const char *string = (const char *)buffer;
	size_t i, len;

	// be nice to our audience and replace single "\n" with "\r\n"

	for (i = 0, len = 0; i < bufferSize; i++, len++) {
		if (string[i] == '\0')
			break;
		if (string[i] == '\n') {
			//Text(&gScreen->RastPort, &string[i - len], len);
			fX = 0;
			fY++;
			if (fY >= console_height())
				fY = 0;
			len = 0;
			console_set_cursor(fX, fY);
			continue;
		}
		Text(&gScreen->RastPort, &string[i], 1);
	}

	// not exactly, but we don't care...
	return bufferSize;
}


void
ConsoleHandle::Clear()
{
	Move(&gScreen->RastPort, 0, sScreenTopOffset);
	ClearScreen(&gScreen->RastPort);
}


void
ConsoleHandle::MoveTo(int16 x, int16 y)
{
	fX = x;
	fY = y;
	Move(&gScreen->RastPort, sFontWidth * x,
		sFontHeight * y + sScreenTopOffset);
	// why do I have to add this to keep the title ?
	
}


void
ConsoleHandle::SetColor(int32 foreground, int32 background)
{
	SetAPen(&gScreen->RastPort, foreground);
	SetBPen(&gScreen->RastPort, background);
}


int
ConsoleHandle::Columns()
{
	int columnCount = gScreen->Width / sFontWidth;
	return columnCount;
}


int
ConsoleHandle::Rows()
{
	int lineCount = (gScreen->Height - sScreenTopOffset) / sFontHeight;
	return lineCount;
}


// #pragma mark -


ConsoleDevice::ConsoleDevice(const char *title)
	: ExecDevice(),
	fTitle(title),
	fWindow(NULL)
{
}


ConsoleDevice::~ConsoleDevice()
{
}


status_t
ConsoleDevice::Open()
{
	status_t err;
	
	if (fWindow)
		return B_ERROR;

	err = AllocRequest(sizeof(struct IOStdReq));
	if (err < B_OK)
		panic("AllocRequest");;
	if (err < B_OK)
		return err;

	int16 topEdge = gScreen->Height - 60;
	int height = 60;

	if (fTitle == NULL) {
		topEdge = 10;
		height = gScreen->Height - 40;
		fTitle = "Console";
	}

	struct NewWindow newWindow = {
		0, topEdge,
		gScreen->Width, height,
		BLACK, WHITE,
		IDCMP_CLOSEWINDOW,
		WFLG_SIZEGADGET | WFLG_DRAGBAR | WFLG_DEPTHGADGET | WFLG_SIMPLE_REFRESH
			| WFLG_ACTIVATE,
		NULL,
		NULL,
		fTitle,
		gScreen,
		NULL,
		100, 45,
		gScreen->Width, gScreen->Height,
		CUSTOMSCREEN
	};
	
	fWindow = OpenWindow(&newWindow);
	if (fWindow == NULL)
		panic("OpenWindow");;
	if (fWindow == NULL)
		return B_ERROR;
	fIOStdReq->io_Data = fWindow;
	fIOStdReq->io_Length = sizeof(struct Window);
	err = ExecDevice::Open(CONSOLENAME, CONU_STANDARD, 0);
	if (err < B_OK)
		return err;

	MoveTo(0, 0);
	SetColor(WHITE, BLACK);
	Clear();
}


ssize_t
ConsoleDevice::ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize)
{
	return ExecDevice::ReadAt(cookie, pos, buffer, bufferSize);
}


int
ConsoleDevice::WaitForKey()
{
	char ascii;
	
	if (Read(&ascii, 1) < 1)
		return TEXT_CONSOLE_NO_KEY;
	//dprintf("ascii %d %c\n", ascii, ascii);

	if (ascii == (char)0x9b) {
		if (Read(&ascii, 1) < 1)
			return TEXT_CONSOLE_NO_KEY;
		//dprintf(">ascii %d %c\n", ascii, ascii);
		switch (ascii) {
			case 'A':
				return TEXT_CONSOLE_KEY_UP;
			case 'B':
				return TEXT_CONSOLE_KEY_DOWN;
			case 'D':
				return TEXT_CONSOLE_KEY_LEFT;
			case 'C':
				return TEXT_CONSOLE_KEY_RIGHT;
			case '4':
			{
				if (Read(&ascii, 1) < 1)
					return TEXT_CONSOLE_NO_KEY;
				if (ascii == '~')
					return TEXT_CONSOLE_NO_KEY;
				switch (ascii) {
					case '1':
						Read(&ascii, 1); // ~
						return TEXT_CONSOLE_KEY_PAGE_UP;
					case '2':
						Read(&ascii, 1); // ~
						return TEXT_CONSOLE_KEY_PAGE_UP;
					default:
						return TEXT_CONSOLE_NO_KEY;
				}
				return TEXT_CONSOLE_NO_KEY;
			}
			default:
				break;
		}
	}
	return ascii;
}


ssize_t
ConsoleDevice::WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize)
{
	return ExecDevice::WriteAt(cookie, pos, buffer, bufferSize);
}


void
ConsoleDevice::Clear()
{
	char buff[] = "\x0c";
	WriteAt(NULL, 0LL, buff, sizeof(buff) - 1);
}


void
ConsoleDevice::MoveTo(int16 x, int16 y)
{
	char buff[32];
	x = MIN(79,MAX(0,x));
	y = MIN(24,MAX(0,y));
	sprintf(buff, "\x9b%02d;%02d\x48", y + 1, x + 1);
	//buff[4] += (char)x;
	//buff[2] += (char)y;
	WriteAt(NULL, 0LL, buff, strlen(buff));
}


void
ConsoleDevice::SetColor(int32 foreground, int32 background)
{
	//char buff[] = "\x9b37;40m";
	char buff[] = "\2330;30;40m";

	
	if (foreground >= 8) {
		foreground -= 8;
		//buff[1] = '1'; // bold
	}
	
	// else
	//	buff[1] = '2';
	//if (background >= 8)
	//	background -= 8;

	if (foreground == background) {
		foreground = 7 - background;
	}

	if (foreground < 8)
		buff[4] += foreground;

	if (background < 8)
		buff[7] += background;

	WriteAt(NULL, 0LL, buff, sizeof(buff) - 1);
}


int
ConsoleDevice::Columns()
{
	struct ConUnit *unit = (struct ConUnit *)fIOStdReq->io_Unit;
	return unit->cu_XMax;
}


int
ConsoleDevice::Rows()
{
	struct ConUnit *unit = (struct ConUnit *)fIOStdReq->io_Unit;
	return unit->cu_YMax - 1;
}


// #pragma mark -


KeyboardDevice::KeyboardDevice()
	: ExecDevice()
{
}


KeyboardDevice::~KeyboardDevice()
{
}


status_t
KeyboardDevice::Open()
{
	return ExecDevice::Open("keyboard.device");
}


status_t
KeyboardDevice::ReadEvent(struct InputEvent *event)
{
	fIOStdReq->io_Command = KBD_READEVENT;
	fIOStdReq->io_Flags = IOF_QUICK;
	fIOStdReq->io_Length = sizeof(struct InputEvent);
	fIOStdReq->io_Data = event;
	status_t err = Do();
	if (err < B_OK)
		return err;
	/*
	dprintf("key: class %d sclass %d code %d 0x%02x qual 0x%04x\n", 
		event->ie_Class, event->ie_SubClass,
		event->ie_Code, event->ie_Code, event->ie_Qualifier);
	*/
	return B_OK;
}


ssize_t
KeyboardDevice::ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize)
{
	struct InputEvent event;
	ssize_t actual;
	status_t err;
	
	do {
		err = ReadEvent(&event);
		if (err < B_OK)
			return err;
	} while (event.ie_Code > IECODE_UP_PREFIX);

	actual = MapRawKey(&event, (char *)buffer, bufferSize, NULL);
	//dprintf("%s actual %d\n", __FUNCTION__, actual);
	if (actual > 0) {
		return actual;
	}
	return B_ERROR;
}


int
KeyboardDevice::WaitForKey()
{
	struct InputEvent event;
	char ascii;
	ssize_t actual;
	status_t err;
	
	do {
		err = ReadEvent(&event);
		if (err < B_OK)
			return err;
	} while (event.ie_Code < IECODE_UP_PREFIX);

	event.ie_Code &= ~IECODE_UP_PREFIX;

	switch (event.ie_Code) {
		case IECODE_KEY_UP:
			return TEXT_CONSOLE_KEY_UP;
		case IECODE_KEY_DOWN:
			return TEXT_CONSOLE_KEY_DOWN;
		case IECODE_KEY_LEFT:
			return TEXT_CONSOLE_KEY_LEFT;
		case IECODE_KEY_RIGHT:
			return TEXT_CONSOLE_KEY_RIGHT;
		case IECODE_KEY_PAGE_UP:
			return TEXT_CONSOLE_KEY_PAGE_UP;
		case IECODE_KEY_PAGE_DOWN:
			return TEXT_CONSOLE_KEY_PAGE_DOWN;
		default:
			break;
	}
	
	actual = MapRawKey(&event, &ascii, 1, NULL);
	//dprintf("%s actual %d\n", __FUNCTION__, actual);
	if (actual > 0)
		return ascii;
	return TEXT_CONSOLE_NO_KEY;
}


ssize_t
KeyboardDevice::WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize)
{
	return B_ERROR;
}


// #pragma mark -


LLKeyboardDevice::LLKeyboardDevice()
	: CharHandle()
{
}


LLKeyboardDevice::~LLKeyboardDevice()
{
}


status_t
LLKeyboardDevice::Open()
{
	if (LowLevelBase == NULL)
		LowLevelBase = (Library *)OldOpenLibrary(LOWLEVELNAME);
	return (LowLevelBase == NULL) ? B_ERROR : B_OK;
}


ssize_t
LLKeyboardDevice::ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize)
{
	struct InputEvent event;
	ssize_t actual;
	status_t err;
	uint32 key;
	
	
	key = GetKey();
	if (key & 0x0000ffff == 0x0ff)
		return B_ERROR;
	event.ie_Class = IECLASS_RAWKEY;
	event.ie_SubClass = IESUBCLASS_RAWKEY;
	event.ie_Code = (uint16)(key & 0x0000ffff);
	event.ie_Qualifier = (key & 0xffff0000) >> 16;

	actual = MapRawKey(&event, (char *)buffer, bufferSize, NULL);
	//dprintf("%s actual %d\n", __FUNCTION__, actual);
	if (actual > 0) {
		return actual;
	}
	return B_ERROR;
}


int
LLKeyboardDevice::WaitForKey()
{
	struct InputEvent event;
	uint32 key;
	char ascii;
	ssize_t actual;
	status_t err;
	
	do {
		key = GetKey();
	} while (key & 0x0000ffff == 0x0ff);

	event.ie_Class = IECLASS_RAWKEY;
	event.ie_SubClass = IESUBCLASS_RAWKEY;
	event.ie_Code = (uint16)(key & 0x0000ffff);
	event.ie_Qualifier = (key & 0xffff0000) >> 16;

	switch (event.ie_Code) {
		case IECODE_KEY_UP:
			return TEXT_CONSOLE_KEY_UP;
		case IECODE_KEY_DOWN:
			return TEXT_CONSOLE_KEY_DOWN;
		case IECODE_KEY_LEFT:
			return TEXT_CONSOLE_KEY_LEFT;
		case IECODE_KEY_RIGHT:
			return TEXT_CONSOLE_KEY_RIGHT;
		case IECODE_KEY_PAGE_UP:
			return TEXT_CONSOLE_KEY_PAGE_UP;
		case IECODE_KEY_PAGE_DOWN:
			return TEXT_CONSOLE_KEY_PAGE_DOWN;
		default:
			break;
	}
	
	actual = MapRawKey(&event, &ascii, 1, NULL);
	//dprintf("%s actual %d\n", __FUNCTION__, actual);
	if (actual > 0)
		return ascii;
	return TEXT_CONSOLE_NO_KEY;
}


ssize_t
LLKeyboardDevice::WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize)
{
	return B_ERROR;
}


//	#pragma mark -


static ConsoleDevice sOutput(NULL);
//static ConsoleHandle sOutput;
//static ConsoleHandle sErrorOutput;
//static ConsoleHandle sDebugOutput;
static ConsoleDevice sDebugOutput("Debug");

//static KeyboardDevice sInput;
static ConsoleDevice &sInput = sOutput;


status_t
console_init(void)
{
	status_t err;
	
	GRAPHICS_BASE_NAME = (GfxBase *)OldOpenLibrary(GRAPHICSNAME);
	if (GRAPHICS_BASE_NAME == NULL)
		panic("Cannot open %s", GRAPHICSNAME);
	
	static NewScreen newScreen = {
		0, 0,
		640, -1,
		4,
		BLACK, WHITE,
		0x8000,
		0x11,
		NULL,
		"Haiku Loader",
		NULL,
		NULL
	};
	
	gScreen = OpenScreen(&newScreen);
	if (gScreen == NULL)
		panic("OpenScreen()\n");
	
	LoadRGB4(&gScreen->ViewPort, kPalette, 16);
	
	SetDrMd(&gScreen->RastPort, JAM2);
	
	// seems not necessary, there is a default font already set.
	/*
	TextAttr attrs = { "Topaz", 8, 0, 0};
	TextFont *font = OpenFont(&attrs);
	*/
	TextFont *font = OpenFont(gScreen->Font);
	if (font == NULL)
		panic("OpenFont()\n");
	sFontHeight = gScreen->Font->ta_YSize;
	sFontWidth = font->tf_XSize;
	
	sScreenTopOffset = gScreen->BarHeight * 2; // ???

	
	//ClearScreen(&gScreen->RastPort);

	
	err = sDebugOutput.Open();
	if (err < B_OK)
		panic("sDebugOutput.Open() 0x%08lx\n", err);
	dbgerr = stderr = (FILE *)&sDebugOutput;


	err = sOutput.Open();
	if (err < B_OK)
		panic("sOutput.Open() 0x%08lx\n", err);

	stdout = (FILE *)&sOutput;

	console_set_cursor(0, 0);
	
	/*
	dprintf("LeftEdge %d\n", gScreen->LeftEdge);
	dprintf("TopEdge %d\n", gScreen->TopEdge);
	dprintf("Width %d\n", gScreen->Width);
	dprintf("Height %d\n", gScreen->Height);
	dprintf("MouseX %d\n", gScreen->MouseX);
	dprintf("MouseY %d\n", gScreen->MouseY);
	dprintf("Flags 0x%08x\n", gScreen->Flags);
	dprintf("BarHeight %d\n", gScreen->BarHeight);
	dprintf("BarVBorder %d\n", gScreen->BarVBorder);
	dprintf("BarHBorder %d\n", gScreen->BarHBorder);
	dprintf("MenuVBorder %d\n", gScreen->MenuVBorder);
	dprintf("MenuHBorder %d\n", gScreen->MenuHBorder);
	dprintf("WBorTop %d\n", gScreen->WBorTop);
	dprintf("WBorLeft %d\n", gScreen->WBorLeft);
	dprintf("WBorRight %d\n", gScreen->WBorRight);
	dprintf("WBorBottom %d\n", gScreen->WBorBottom);
	*/

	KEYMAP_BASE_NAME = (Library *)OldOpenLibrary(KEYMAPNAME);
	if (KEYMAP_BASE_NAME == NULL)
		panic("Cannot open %s", KEYMAPNAME);

	
	/*
	err = sInput.Open();
	if (err < B_OK)
		panic("sInput.Open() 0x%08lx\n", err);
	*/
	stdin = (FILE *)&sInput;
	
	return B_OK;
}


// #pragma mark -


void
console_clear_screen(void)
{
	sOutput.Clear();
}


int32
console_width(void)
{
	return sOutput.Columns();
}


int32
console_height(void)
{
	return sOutput.Rows();
}


void
console_set_cursor(int32 x, int32 y)
{
	sOutput.MoveTo(x, y);
}


void
console_set_color(int32 foreground, int32 background)
{
	sOutput.SetColor(foreground, background);
}


void
console_show_cursor(void)
{
}


void
console_hide_cursor(void)
{
}


int
console_wait_for_key(void)
{
	int key = sInput.WaitForKey();
	//dprintf("k: %08x '%c'\n", key, key);
	return key;
}