frodo-wii/Src/Display_Be.h

/*
 *  Display_Be.h - C64 graphics display, emulator window handling,
 *                 Be specific stuff
 *
 *  Frodo (C) 1994-1997,2002-2005 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <AppKit.h>
#include <InterfaceKit.h>
#include <GameKit.h>
#include <string.h>

#include "C64.h"
#include "main.h"


#ifndef BIT_BANG
#define BIT_BANG 0
#endif
#ifndef MGA_HACK
#define MGA_HACK 0
#endif


// Window thread messages
const uint32 MSG_REDRAW = 1;


// C64 display and window frame
const BRect DisplayFrame = BRect(0, 0, DISPLAY_X-1, DISPLAY_Y-1);
const BRect WindowFrame = BRect(0, 0, DISPLAY_X-1, DISPLAY_Y-1 + 16);


// Background color
const rgb_color fill_gray = {208, 208, 208, 0};
const rgb_color shine_gray = {232, 232, 232, 0};
const rgb_color shadow_gray = {152, 152, 152, 0};


/*
  C64 keyboard matrix:

    Bit 7   6   5   4   3   2   1   0
  0    CUD  F5  F3  F1  F7 CLR RET DEL
  1    SHL  E   S   Z   4   A   W   3
  2     X   T   F   C   6   D   R   5
  3     V   U   H   B   8   G   Y   7
  4     N   O   K   M   0   J   I   9
  5     ,   @   :   .   -   L   P   +
  6     /   ^   =  SHR HOM  ;   *   <EFBFBD>
  7    R/S  Q   C= SPC  2  CTL  <-  1
*/


/*
  Tables for key translation
  Bit 0..2: row/column in C64 keyboard matrix
  Bit 3   : implicit shift
  Bit 5   : joystick emulation (bit 0..4: mask)
*/

const int key_byte[128] = {
	  -1,   7,   0,8+0,   0,8+0,  0, 8+0,
	   0, 8+0,  -1, -1,  -1, -1, -1,  -1,

	   7,   7,   7,  7,   1,  1,  2,   2,
	   3,   3,   4,  4,   5,  5,  0, 8+0,

	   6,   6,  -1, -1,  -1, -1, -1,   7,
	   1,   1,   2,  2,   3,  3,  4,   4,

	   5,   5,   6,  6,   0,  6,  6,0x25,
	0x21,0x29,  -1,  1,   1,  1,  2,   2,

	   3,   3,   4,  4,   5,  5,  6,   0,
	0x24,0x30,0x28,  1,   1,  2,  2,   3,

	   3,   4,   4,  5,   5,  6,  6, 8+0,
	0x26,0x22,0x2a,  0,   7, -1,  7,  -1,

	0x30, 8+0,   0,  0,0x30, -1,  7,   7,
	  -1,  -1,  -1, -1,  -1, -1, -1,  -1,

	  -1,  -1,  -1, -1,  -1, -1, -1,  -1,
	  -1,  -1,  -1, -1,  -1, -1, -1,  -1
};

const int key_bit[128] = {
	-1,  7,  4,  4,  5,  5,  6,  6,
	 3,  3, -1, -1, -1, -1, -1, -1,

	 7,  1,  0,  3,  0,  3,  0,  3,
	 0,  3,  0,  3,  0,  3,  0,  0,

	 3,  0, -1, -1, -1, -1, -1,  6,
	 1,  6,  1,  6,  1,  6,  1,  6,

	 1,  6,  1,  6,  0,  0,  5, -1,
	-1, -1, -1,  7,  2,  5,  2,  5,

	 2,  5,  2,  5,  2,  5,  2,  1,
	-1, -1, -1,  7,  4,  7,  4,  7,

	 4,  7,  4,  7,  4,  7,  4,  7,
	-1, -1, -1,  1,  2, -1,  4, -1,

	 5,  2,  7,  2, -1, -1,  5,  5,
	-1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1,
	-1, -1, -1, -1, -1, -1, -1, -1
};


/*
 *  A simple view class for blitting a bitmap on the screen
 */

class BitmapView : public BView {
public:
	BitmapView(BRect frame, BBitmap *bitmap);
	virtual void Draw(BRect update);
	virtual void KeyDown(const char *bytes, int32 numBytes);
	void ChangeBitmap(BBitmap *bitmap);

private:
	BBitmap *the_bitmap;
};


/*
 *  Class for the main C64 display window
 */

class SpeedoView;
class LEDView;

class C64Window : public BDirectWindow {
public:
	C64Window();

	virtual bool QuitRequested(void);
	virtual void MessageReceived(BMessage *msg);
	virtual void DirectConnected(direct_buffer_info *info);

	BBitmap *TheBitmap[2];
	SpeedoView *Speedometer;
	LEDView *LED[4];

#if BIT_BANG
	uint8 *bits;
	int bytes_per_row;
#endif

private:
	BitmapView *main_view;
};


/*
 *  Class for the main C64 display using the GameKit
 */

class C64Screen : public BWindowScreen {
public:
	C64Screen(C64Display *display) : BWindowScreen("Frodo", B_8_BIT_640x480, &error), the_display(display)
	{
		Lock();
		TheBitmap = new BBitmap(DisplayFrame, B_COLOR_8_BIT);
		main_view = new BitmapView(Bounds(), TheBitmap);
		AddChild(main_view);
		main_view->MakeFocus();
		Connected = false;
		first_connected = true;
#if MGA_HACK
		mga_ready = false;
#endif
		Unlock();
	}
	~C64Screen()
	{
		delete TheBitmap;
	}

	virtual void ScreenConnected(bool active);
	virtual void DispatchMessage(BMessage *msg, BHandler *handler);
	void DrawLED(int i, int state);
	void DrawSpeedometer(void);
	void FillRect(int x1, int y1, int x2, int y2, int color);

	bool Connected;			// Flag: screen connected
	int Speed;
	char SpeedoStr[16];		// Speedometer value converted to a string
	BBitmap *TheBitmap;

private:
	C64Display *the_display;
	BitmapView *main_view;
	bool first_connected;
	status_t error;

#if MGA_HACK
	area_id mga_clone_area;
	volatile uint8 *isa_io;
	bool mga_ready;

	void CRTC_out(int reg, uint8 val) {isa_io[0x3d4] = reg; __eieio(); isa_io[0x3d5] = val; __eieio();}
	uint8 CRTC_in(int reg) {isa_io[0x3d4] = reg; __eieio(); return isa_io[0x3d5];}
	void SEQ_out(int reg, uint8 val) {isa_io[0x3c4] = reg; __eieio(); isa_io[0x3c5] = val; __eieio();}
	uint8 SEQ_in(int reg) {isa_io[0x3c4] = reg; __eieio(); return isa_io[0x3c5];}
	void GDC_out(int reg, uint8 val) {isa_io[0x3ce] = reg; __eieio(); isa_io[0x3cf] = val; __eieio();}
	uint8 GDC_in(int reg) {isa_io[0x3ce] = reg; __eieio(); return isa_io[0x3cf];}
	void ATC_out(int reg, uint8 val) {isa_io[0x3c0] = reg; __eieio(); isa_io[0x3c0] = val; __eieio();}
#endif
};


/*
 *  Class for speedometer
 */

class SpeedoView : public BView {
public:
	SpeedoView(BRect frame);
	virtual void Draw(BRect update);
	virtual void Pulse(void);
	void SetValue(int percent);

private:
	char speedostr[16];		// Speedometer value converted to a string
	BRect bounds;
};


/*
 *  Class for drive LED
 */

class LEDView : public BView {
public:
	LEDView(BRect frame, const char *label);
	virtual void Draw(BRect update);
	virtual void Pulse(void);
	void DrawLED(void);
	void SetState(int state);

private:
	int current_state;
	const char *the_label;
	BRect bounds;
};


/*
 *  Display constructor: Create window/screen
 */

C64Display::C64Display(C64 *the_c64) : TheC64(the_c64)
{
	// LEDs off
	for (int i=0; i<4; i++)
		led_state[i] = old_led_state[i] = LED_OFF;

	// Open window/screen
	draw_bitmap = 1;
	if (ThePrefs.DisplayType == DISPTYPE_SCREEN) {
		using_screen = true;
		the_screen = new C64Screen(this);
		the_screen->Show();
		while (!the_screen->Connected)
			snooze(20000);
	} else {
		using_screen = false;
		the_window = new C64Window();
		the_window->Show();
	}

	// Prepare key_info buffer
	get_key_info(&old_key_info);
}


/*
 *  Display destructor
 */

C64Display::~C64Display()
{
	if (using_screen) {
		the_screen->Lock();
		the_screen->Quit();
	} else {
		the_window->Lock();
		the_window->Quit();
	}
}


/*
 *  Prefs may have changed
 */

void C64Display::NewPrefs(Prefs *prefs)
{
	if (prefs->DisplayType == DISPTYPE_SCREEN) {
		if (!using_screen) {
			// Switch to full screen display
			using_screen = true;
			the_window->Lock();
			the_window->Quit();
			the_screen = new C64Screen(this);
			the_screen->Show();
			while (!the_screen->Connected)
				snooze(20000);
		}
	} else {
		if (using_screen) {
			// Switch to window display
			using_screen = false;
			the_screen->Lock();
			the_screen->Quit();
			the_window = new C64Window();
			the_window->Show();
		}
	}
}


/*
 *  Redraw bitmap (let the window thread do it)
 */

void C64Display::Update(void)
{
	if (using_screen) {

		// Update LEDs/speedometer
		for (int i=0; i<4; i++)
			the_screen->DrawLED(i, led_state[i]);
		the_screen->DrawSpeedometer();

		// Update C64 display in dobule scan mode
		if (ThePrefs.DoubleScan) {
			uint8 *src = (uint8 *)the_screen->TheBitmap->Bits();
			uint32 src_xmod = the_screen->TheBitmap->BytesPerRow();
			src += src_xmod * 16 + 32;
			uint8 *dest = (uint8 *)the_screen->CardInfo()->frame_buffer;
			uint32 dest_xmod = the_screen->CardInfo()->bytes_per_row;
#ifdef __POWERPC__
			double tmp[1];
			for (int y=0; y<240; y++) {
				uint32 *p = (uint32 *)src - 1;
				double *q1 = (double *)dest - 1;
				double *q2 = q1 + dest_xmod / sizeof(double);
				for (int x=0; x<80; x++) {
					uint32 val = *(++p);
					uint8 *r = (uint8 *)&tmp[1];
					*(--r) = val;
					*(--r) = val;
					val >>= 8;
					*(--r) = val;
					*(--r) = val;
					val >>= 8;
					*(--r) = val;
					*(--r) = val;
					val >>= 8;
					*(--r) = val;
					*(--r) = val;
					double tmp2 = tmp[0];
					*(++q1) = tmp2;
					*(++q2) = tmp2;
				}
				src += src_xmod;
				dest += dest_xmod * 2;
			}
#else
			for (int y=0; y<240; y++) {
				uint32 *p = (uint32 *)src;
				uint32 *q1 = (uint32 *)dest;
				uint32 *q2 = q1 + dest_xmod / sizeof(uint32);
				for (int x=0; x<80; x++) {
					uint32 val = *p++;
					uint32 tmp = val & 0x000000ff;
					tmp |= (val << 8) & 0x0000ff00;
					tmp |= (val << 8) & 0x00ff0000;
					tmp |= (val << 16) & 0xff000000;
					*q1++ = tmp;
					*q2++ = tmp;
					tmp = (val >> 16) & 0x000000ff;
					tmp |= (val >> 8) & 0x0000ff00;
					tmp |= (val >> 8) & 0x00ff0000;
					tmp |= val & 0xff000000;
					*q1++ = tmp;
					*q2++ = tmp;
				}
				src += src_xmod;
				dest += dest_xmod * 2;
			}
#endif
		}

	} else {

#if !BIT_BANG
		// Update C64 display
		BMessage msg(MSG_REDRAW);
		msg.AddInt32("bitmap", draw_bitmap);
		the_window->PostMessage(&msg);
		draw_bitmap ^= 1;
#endif

		// Update LEDs
		for (int i=0; i<4; i++)
			if (led_state[i] != old_led_state[i]) {
				the_window->LED[i]->SetState(led_state[i]);
				old_led_state[i] = led_state[i];
			}
	}
}


/*
 *  Set value displayed by the speedometer
 */

void C64Display::Speedometer(int speed)
{
	if (using_screen) {
		the_screen->Speed = speed;
		sprintf(the_screen->SpeedoStr, "%3d%%", speed);
	} else
		the_window->Speedometer->SetValue(speed);
}


/*
 *  Return pointer to bitmap data
 */

uint8 *C64Display::BitmapBase(void)
{
	if (using_screen) {
		if (ThePrefs.DoubleScan)
			return (uint8 *)the_screen->TheBitmap->Bits();
		else
			return (uint8 *)the_screen->CardInfo()->frame_buffer;
	} else
#if BIT_BANG
		return (uint8 *)the_window->bits;
#else
		return (uint8 *)the_window->TheBitmap[draw_bitmap]->Bits();
#endif
}


/*
 *  Return number of bytes per row
 */

int C64Display::BitmapXMod(void)
{
	if (using_screen) {
		if (ThePrefs.DoubleScan)
			return the_screen->TheBitmap->BytesPerRow();
		else
			return the_screen->CardInfo()->bytes_per_row;
	} else
#if BIT_BANG
		return the_window->bytes_per_row;
#else
		return the_window->TheBitmap[draw_bitmap]->BytesPerRow();
#endif
}


/*
 *  Poll the keyboard
 */

void C64Display::PollKeyboard(uint8 *key_matrix, uint8 *rev_matrix, uint8 *joystick)
{
	key_info the_key_info;
	int be_code, be_byte, be_bit, c64_byte, c64_bit;
	bool shifted;

	// Window must be active, command key must be up
	if (using_screen) {
		if (!the_screen->Connected)
			return;
	} else
		if (!the_window->IsActive())
			return;
	if (!(modifiers() & B_COMMAND_KEY)) {

		// Read the state of all keys
		get_key_info(&the_key_info);

		// Did anything change at all?
		if (!memcmp(&old_key_info, &the_key_info, sizeof(key_info)))
			return;

		// Loop to convert BeOS keymap to C64 keymap
		for (be_code=0; be_code<0x68; be_code++) {
			be_byte = be_code >> 3;
			be_bit = 1 << (~be_code & 7);

			// Key state changed?
			if ((the_key_info.key_states[be_byte] & be_bit)
			     != (old_key_info.key_states[be_byte] & be_bit)) {

				c64_byte = key_byte[be_code];
				c64_bit = key_bit[be_code];
				if (c64_byte != -1) {
					if (!(c64_byte & 0x20)) {

						// Normal keys
						shifted = c64_byte & 8;
						c64_byte &= 7;
						if (the_key_info.key_states[be_byte] & be_bit) {

							// Key pressed
							if (shifted) {
								key_matrix[6] &= 0xef;
								rev_matrix[4] &= 0xbf;
							}
							key_matrix[c64_byte] &= ~(1 << c64_bit);
							rev_matrix[c64_bit] &= ~(1 << c64_byte);
						} else {

							// Key released
							if (shifted) {
								key_matrix[6] |= 0x10;
								rev_matrix[4] |= 0x40;
							}
							key_matrix[c64_byte] |= (1 << c64_bit);
							rev_matrix[c64_bit] |= (1 << c64_byte);
						}
					} else {

						// Joystick emulation
						c64_byte &= 0x1f;
						if (the_key_info.key_states[be_byte] & be_bit)
							*joystick &= ~c64_byte;
						else
							*joystick |= c64_byte;
					}
				}
			}
		}

		old_key_info = the_key_info;
	}
}


/*
 *  Check if NumLock is down (for switching the joystick keyboard emulation)
 */

bool C64Display::NumLock(void)
{
	return modifiers() & B_NUM_LOCK;
}


/*
 *  Allocate C64 colors
 */

void C64Display::InitColors(uint8 *colors)
{
	BScreen scr(using_screen ? (BWindow *)the_screen : the_window);
	for (int i=0; i<256; i++)
		colors[i] = scr.IndexForColor(palette_red[i & 0x0f], palette_green[i & 0x0f], palette_blue[i & 0x0f]);
}


/*
 *  Pause display (GameKit only)
 */

void C64Display::Pause(void)
{
	if (using_screen)
		the_screen->Hide();
}


/*
 *  Resume display (GameKit only)
 */

void C64Display::Resume(void)
{
	if (using_screen)
		the_screen->Show();
}


/*
 *  Window constructor
 */

C64Window::C64Window() : BDirectWindow(WindowFrame, "Frodo", B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE)
{
	// Move window to right position
	Lock();
	MoveTo(80, 60);

	// Set up menus
	BMenuBar *bar = new BMenuBar(Bounds(), "");
	BMenu *menu = new BMenu("Frodo");
	menu->AddItem(new BMenuItem("About Frodo" B_UTF8_ELLIPSIS, new BMessage(B_ABOUT_REQUESTED)));
	menu->AddItem(new BSeparatorItem);
	menu->AddItem(new BMenuItem("Preferences" B_UTF8_ELLIPSIS, new BMessage(MSG_PREFS), 'P'));
	menu->AddItem(new BSeparatorItem);
	menu->AddItem(new BMenuItem("Reset C64", new BMessage(MSG_RESET)));
	menu->AddItem(new BMenuItem("Insert next disk", new BMessage(MSG_NEXTDISK), 'D'));
	menu->AddItem(new BMenuItem("SAM" B_UTF8_ELLIPSIS, new BMessage(MSG_SAM), 'M'));
	menu->AddItem(new BSeparatorItem);
	menu->AddItem(new BMenuItem("Load snapshot" B_UTF8_ELLIPSIS, new BMessage(MSG_OPEN_SNAPSHOT), 'O'));
	menu->AddItem(new BMenuItem("Save snapshot" B_UTF8_ELLIPSIS, new BMessage(MSG_SAVE_SNAPSHOT), 'S'));
	menu->AddItem(new BSeparatorItem);
	menu->AddItem(new BMenuItem("Quit Frodo", new BMessage(B_QUIT_REQUESTED), 'Q'));
	menu->SetTargetForItems(be_app);
	bar->AddItem(menu);
	AddChild(bar);
	SetKeyMenuBar(bar);
	int mbar_height = int(bar->Frame().bottom) + 1;

	// Resize window to fit menu bar
	ResizeBy(0, mbar_height);

	// Allocate bitmaps
	TheBitmap[0] = new BBitmap(DisplayFrame, B_COLOR_8_BIT);
	TheBitmap[1] = new BBitmap(DisplayFrame, B_COLOR_8_BIT);

	// Create top view
	BRect b = Bounds();
	BView *top = new BView(BRect(0, mbar_height, b.right, b.bottom), "top", B_FOLLOW_NONE, 0);
	AddChild(top);

	// Create bitmap view
	main_view = new BitmapView(DisplayFrame, TheBitmap[0]);
	top->AddChild(main_view);
	main_view->MakeFocus();

	// Create speedometer
	Speedometer = new SpeedoView(BRect(0, DISPLAY_Y, DISPLAY_X/5-1, DISPLAY_Y+15));
	top->AddChild(Speedometer);

	// Create drive LEDs
	LED[0] = new LEDView(BRect(DISPLAY_X/5, DISPLAY_Y, DISPLAY_X*2/5-1, DISPLAY_Y+15), "Drive 8");
	top->AddChild(LED[0]);
	LED[1] = new LEDView(BRect(DISPLAY_X*2/5, DISPLAY_Y, DISPLAY_X*3/5-1, DISPLAY_Y+15), "Drive 9");
	top->AddChild(LED[1]);
	LED[2] = new LEDView(BRect(DISPLAY_X*3/5, DISPLAY_Y, DISPLAY_X*4/5-1, DISPLAY_Y+15), "Drive 10");
	top->AddChild(LED[2]);
	LED[3] = new LEDView(BRect(DISPLAY_X*4/5, DISPLAY_Y, DISPLAY_X-1, DISPLAY_Y+15), "Drive 11");
	top->AddChild(LED[3]);

	// Set pulse rate to 0.4 seconds for blinking drive LEDs
	SetPulseRate(400000);
	Unlock();
}


/*
 *  Closing the window quits Frodo
 */

bool C64Window::QuitRequested(void)
{
	be_app->PostMessage(B_QUIT_REQUESTED);
	return false;
}


/*
 *  Handles redraw messages
 */

void C64Window::MessageReceived(BMessage *msg)
{
	BMessage *msg2;

	switch (msg->what) {
		case MSG_REDRAW:  // Redraw bitmap
			MessageQueue()->Lock();
			while ((msg2 = MessageQueue()->FindMessage(MSG_REDRAW, 0)) != NULL) {
				MessageQueue()->RemoveMessage(msg2);
				delete msg2;
			}
			MessageQueue()->Unlock();
			main_view->ChangeBitmap(TheBitmap[msg->FindInt32("bitmap")]);
			Lock();
			main_view->Draw(DisplayFrame);
			Unlock();
			break;

		default:
			BWindow::MessageReceived(msg);
	}
}


/*
 *  Window connected/disconnected
 */

void C64Window::DirectConnected(direct_buffer_info *info)
{
#if BIT_BANG
	switch (info->buffer_state & B_DIRECT_MODE_MASK) {
		case B_DIRECT_STOP:
//			acquire_sem(drawing_sem);
			break;
		case B_DIRECT_MODIFY:
//			acquire_sem(drawing_sem);
		case B_DIRECT_START:
			bits = ((uint8 *)info->bits + info->window_bounds.top * info->bytes_per_row + info->window_bounds.left * info->bits_per_pixel / 8);
			bytes_per_row = info->bytes_per_row;
//			release_sem(drawing_sem);
			break;
	}
#endif
}


/*
 *  Workspace activated/deactivated
 */

void C64Screen::ScreenConnected(bool active)
{
	if (active) {
		if (first_connected) {
			first_connected = false;

#if MGA_HACK
			mga_clone_area = -1;

			// Construct register area name
			char mga_area_name[64];
			int bus = 0, device = 13, function = 0;
			sprintf(mga_area_name, "102B_0519_%02X%02X%02X regs", bus, device, function);

			// Find MGA register area
			area_id mga_area = find_area(mga_area_name);
			if (mga_area > 0) {

				// Clone area, remove write protection
				volatile uint8 *mga_io;
				mga_clone_area = clone_area("mga registers", (void **)&mga_io, B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, mga_area);
				if (mga_clone_area > 0) {
					isa_io = mga_io + 0x1c00;
					mga_ready = true;
				}
			}
#endif
		}

#if MGA_HACK
		if (mga_ready) {
			CRTC_out(0x09, 1);			// Enable double scan
			int a = 4 * 640;
			CRTC_out(0x0c, a >> 8);		// Center screen vertically
			CRTC_out(0x0d, a);
			// defaults:
			//  total		0x67
			//  display end	0x4f
			//  blank start	0x4f
			//  blank end	  2b
			//  sync start	0x53
			//  sync end	  1f
			CRTC_out(0x00, 0x3f);		// Horizontal timing
			CRTC_out(0x01, 0x2f);
			CRTC_out(0x02, 0x2f);
			CRTC_out(0x03, 0x83);
			CRTC_out(0x04, 0x32);
			CRTC_out(0x05, 0x1a);
		}
#endif

		FillRect(0, 0, 639, 479, 0);	// Clear screen
		the_display->TheC64->Resume();
		Connected = true;
	} else {
		the_display->TheC64->Pause();
		Connected = false;
	}
	BWindowScreen::ScreenConnected(active);
}


/*
 *  Simulate menu commands
 */

void C64Screen::DispatchMessage(BMessage *msg, BHandler *handler)
{
	switch (msg->what) {
		case B_KEY_DOWN: {
			uint32 mods = msg->FindInt32("modifiers");
			if (mods & B_COMMAND_KEY) {
				uint32 key = msg->FindInt32("raw_char");
				switch (key) {
					case 'p':
						be_app->PostMessage(MSG_PREFS);
						break;
					case 'd':
						be_app->PostMessage(MSG_NEXTDISK);
						break;
					case 'm':
						be_app->PostMessage(MSG_SAM);
						break;
				}
			}
			BWindowScreen::DispatchMessage(msg, handler);
			break;
		}

		default:
			BWindowScreen::DispatchMessage(msg, handler);
	}
}


/*
 *  Draw drive LEDs
 */

void C64Screen::DrawLED(int i, int state)
{
	int maxy;
	if (ThePrefs.DoubleScan)
		maxy = 480;
	else
		maxy = DISPLAY_Y;

	switch (state) {
		case LED_ON:
			FillRect(10+i*20, maxy-20, 20+i*20, maxy-12, 54);
			break;
		case LED_ERROR_ON:
			FillRect(10+i*20, maxy-20, 20+i*20, maxy-12, 44);
			break;
	}
}


/*
 *  Draw speedometer
 */

static const int8 Digits[11][8] = {	// Digit images
	{0x3c, 0x66, 0x6e, 0x76, 0x66, 0x66, 0x3c, 0x00},
	{0x18, 0x18, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00},
	{0x3c, 0x66, 0x06, 0x0c, 0x30, 0x60, 0x7e, 0x00},
	{0x3c, 0x66, 0x06, 0x1c, 0x06, 0x66, 0x3c, 0x00},
	{0x06, 0x0e, 0x1e, 0x66, 0x7f, 0x06, 0x06, 0x00},
	{0x7e, 0x60, 0x7c, 0x06, 0x06, 0x66, 0x3c, 0x00},
	{0x3c, 0x66, 0x60, 0x7c, 0x66, 0x66, 0x3c, 0x00},
	{0x7e, 0x66, 0x0c, 0x18, 0x18, 0x18, 0x18, 0x00},
	{0x3c, 0x66, 0x66, 0x3c, 0x66, 0x66, 0x3c, 0x00},
	{0x3c, 0x66, 0x66, 0x3e, 0x06, 0x66, 0x3c, 0x00},
	{0x62, 0x66, 0x0c, 0x18, 0x30, 0x66, 0x46, 0x00},
};

void C64Screen::DrawSpeedometer()
{
	// Don't display speedometer if we're running at about 100%
	if (Speed >= 50 && Speed <= 101)
		return;

	int maxx, maxy;
	if (ThePrefs.DoubleScan) {
		maxx = 640;
		maxy = 480;
	} else {
		maxx = DISPLAY_X;
		maxy = DISPLAY_Y;
	}

	char *s = SpeedoStr;
	char c;
	long xmod = CardInfo()->bytes_per_row;
	uint8 *p = (uint8 *)CardInfo()->frame_buffer + maxx - 8*8 + (maxy-20) * xmod;
	while ((c = *s++) != 0) {
		if (c == ' ')
			continue;
		if (c == '%')
			c = 10;
		else
			c -= '0';
		uint8 *q = p;
		for (int y=0; y<8; y++) {
			uint8 data = Digits[c][y];
			for (int x=0; x<8; x++) {
				if (data & (1 << (7-x)))
					q[x] = 255;
				else
					q[x] = 0;
			}
			q += xmod;
		}
		p += 8;
	}
}


/*
 *  Fill rectangle
 */

void C64Screen::FillRect(int x1, int y1, int x2, int y2, int color)
{
	long xmod = CardInfo()->bytes_per_row;
	uint8 *p = (uint8 *)CardInfo()->frame_buffer + y1 * xmod + x1;
	int n = x2 - x1 + 1;
	for(int y=y1; y<=y2; y++) {
#ifdef __POWERPC__
		memset_nc(p, color, n);
#else
		memset(p, color, n);
#endif
		p += xmod;
	}
}


/*
 *  Bitmap view constructor
 */

BitmapView::BitmapView(BRect frame, BBitmap *bitmap) : BView(frame, "", B_FOLLOW_NONE, B_WILL_DRAW)
{
	ChangeBitmap(bitmap);
}


/*
 *  Blit the bitmap
 */

void BitmapView::Draw(BRect update)
{
	if (the_bitmap != NULL)
		DrawBitmapAsync(the_bitmap, update, update);
}


/*
 *  Receive special key-down events (main C64 keyboard handling is done in PollKeyboard)
 */

void BitmapView::KeyDown(const char *bytes, int32 numBytes)
{
	if (bytes[0] == B_FUNCTION_KEY || bytes[0] == '+' || bytes[0] == '-' || bytes[0] == '*' || bytes[0] == '/') {
		BMessage *msg = Window()->CurrentMessage();
		long key;
		if (msg->FindInt32("key", &key) == B_NO_ERROR) {
			switch (key) {

				case B_F11_KEY:	// F11: NMI (Restore)
					be_app->PostMessage(MSG_NMI);
					break;

				case B_F12_KEY:	// F12: Reset
					be_app->PostMessage(MSG_RESET);
					break;

				case 0x3a:		// '+' on keypad: Increase SkipFrames
					ThePrefs.SkipFrames++;
					break;

				case 0x25:		// '-' on keypad: Decrease SkipFrames
					if (ThePrefs.SkipFrames > 1)
						ThePrefs.SkipFrames--;
					break;

				case 0x24:		// '*' on keypad: Toggle speed limiter
					ThePrefs.LimitSpeed = !ThePrefs.LimitSpeed;
					break;

				case 0x23:		// '/' on keypad: Toggle processor-level 1541 emulation
					be_app->PostMessage(MSG_TOGGLE_1541);
					break;
			}
		}
	}
}


/*
 *  Change view bitmap
 */

void BitmapView::ChangeBitmap(BBitmap *bitmap)
{
	the_bitmap = bitmap;
}


/*
 *  Speedometer constructor
 */

SpeedoView::SpeedoView(BRect frame) : BView(frame, "", B_FOLLOW_NONE, B_WILL_DRAW | B_PULSE_NEEDED)
{
	speedostr[0] = 0;
	bounds = Bounds();
	SetViewColor(fill_gray);
	SetLowColor(fill_gray);
	SetFont(be_plain_font);
}


/*
 *  Draw speedometer
 */

void SpeedoView::Draw(BRect update)
{
	// Draw bevelled border
	SetHighColor(shine_gray);
	StrokeLine(BPoint(0, bounds.bottom), BPoint(0, 0));
	StrokeLine(BPoint(bounds.right, 0));
	SetHighColor(shadow_gray);
	StrokeLine(BPoint(bounds.right, bounds.bottom), BPoint(bounds.right, 1));

	// Draw text
	SetHighColor(0, 0, 0);
	DrawString(speedostr, BPoint(24, 12));
}


/*
 *  Update speedometer at regular intervals
 */

void SpeedoView::Pulse(void)
{
	Invalidate(BRect(1, 1, bounds.right-1, 15));
}


/*
 *  Set new speedometer value
 */

void SpeedoView::SetValue(int speed)
{
	sprintf(speedostr, "%d%%", speed);
}


/*
 *  LED view constructor
 */

LEDView::LEDView(BRect frame, const char *label) : BView(frame, "", B_FOLLOW_NONE, B_WILL_DRAW | B_PULSE_NEEDED)
{
	current_state = 0;
	the_label = label;
	bounds = Bounds();
	SetViewColor(fill_gray);
	SetFont(be_plain_font);
}


/*
 *  Draw drive LED
 */

void LEDView::Draw(BRect update)
{
	// Draw bevelled border
	SetHighColor(shine_gray);
	StrokeLine(BPoint(0, bounds.bottom), BPoint(0, 0));
	StrokeLine(BPoint(bounds.right, 0));
	SetHighColor(shadow_gray);
	StrokeLine(BPoint(bounds.right, bounds.bottom), BPoint(bounds.right, 1));

	// Draw label
	SetHighColor(0, 0, 0);
	SetLowColor(fill_gray);
	DrawString(the_label, BPoint(8, 12));

	// Draw LED
	SetHighColor(shadow_gray);
	StrokeLine(BPoint(bounds.right-24, 12), BPoint(bounds.right-24, 4));
	StrokeLine(BPoint(bounds.right-8, 4));
	SetHighColor(shine_gray);
	StrokeLine(BPoint(bounds.right-23, 12), BPoint(bounds.right-8, 12));
	StrokeLine(BPoint(bounds.right-8, 5));
	DrawLED();
}


/*
 *  Redraw just the LED
 */

void LEDView::DrawLED(void)
{
	Window()->Lock();
	switch (current_state) {
		case LED_OFF:
		case LED_ERROR_OFF:
			SetHighColor(32, 32, 32);
			break;
		case LED_ON:
			SetHighColor(0, 240, 0);
			break;
		case LED_ERROR_ON:
			SetHighColor(240, 0, 0);
			break;
	}
	FillRect(BRect(bounds.right-23, 5, bounds.right-9, 11));
	Window()->Unlock();
}


/*
 *  Set LED state
 */

void LEDView::SetState(int state)
{
	if (state != current_state) {
		current_state = state;
		DrawLED();
	}
}


/*
 *  Toggle red error LED
 */

void LEDView::Pulse(void)
{
	switch (current_state) {
		case LED_ERROR_ON:
			current_state = LED_ERROR_OFF;
			DrawLED();
			break;
		case LED_ERROR_OFF:
			current_state = LED_ERROR_ON;
			DrawLED();
			break;
	}
}


/*
 *  Show a requester
 */

long ShowRequester(char *str, char *button1, char *button2)
{
	BAlert *the_alert;
	
	the_alert = new BAlert("", str, button1, button2, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
	return the_alert->Go();
}