----------------------------------------------------------------------
Patch name: patch.beos-gui-fabo-template
Author: Marton Fabo <morton@eik.bme.hu>
Date: Thu, 6 Dec 2001 19:52:18 +0100 (CET)

Detailed description:
Same as patch.beos-gui-fabo, except this version uses C++ templates.

I grabbed the CVS snapshot of 20011129, started with the BeOS GUI code found in
it, rewrote it totally (almost no original code left), and I now have a Bochs
that runs under BeOS quite nicely. New features compared to the BeOS GUI code
found in the above snapshot:

- color support in text mode (not perfect yet, but not BW at least)
- almost full keyboard capturing (modifier keys work, function keys also,
  keypad, arrow keys work, capslock doesn't work properly, numlock not at all.
  I need some help about how to tell Bochs to switch those properly)
- full mouse capturing, it works quite great!

Also see beos-gui-fabo.capture-filter and the associated README.

Patch was created with:
  cvs diff -u
Apply patch to what version:
  cvs from December 7, 2001
Instructions:
  To patch, go to main bochs directory.
  Type "patch -p0 < THIS_PATCH_FILE".
----------------------------------------------------------------------
Index: gui/beos.cc
===================================================================
RCS file: /cvsroot/bochs/bochs/gui/beos.cc,v
retrieving revision 1.12
diff -u -r1.12 beos.cc
--- gui/beos.cc	2001/12/07 18:52:24	1.12
+++ gui/beos.cc	2001/12/07 19:17:41
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: patch.beos-gui-fabo-template,v 1.1 2001/12/07 19:22:54 bdenney Exp $
+// $Id: patch.beos-gui-fabo-template,v 1.1 2001/12/07 19:22:54 bdenney Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -28,6 +28,7 @@
 #include <app/Application.h>
 #include <interface/Window.h>
 #include <interface/View.h>
+#include <MessageFilter.h>
 #include <interface/Screen.h>
 #include <interface/Bitmap.h>
 #include <interface/GraphicsDefs.h>
@@ -39,1161 +40,1260 @@
 #include <string.h>
 
 #include "bochs.h"
-//#include "icon_bochs.h"
+// #include "icon_bochs.h"
 #include "font/vga.bitmap.h"
 
 #define LOG_THIS bx_gui.
 
-#define PAD_NEAREST(n, quantum) (( ((n) + ((quantum) - 1)) / (n) ) * (n))
+#undef uint8
+#undef int32
+#undef uint32
+
+#define BOCHS_APP_SIG			"application/x-vnd.MandrakeSoft-BeBochs"
+#define SCANCODE_BUFSIZE		20
+#define MOUSE_BUFSIZE			20
+#define MOUSE_L 				0x00000001
+#define MOUSE_R 				0x00000002
+#define INITIAL_SCREEN_WIDTH	640
+#define INITIAL_SCREEN_HEIGHT	350
+
+const uint32 MSG_REQUEST_CAPTURE		= 'CFrq';
+const uint32 MSG_START_CAPTURE			= 'strt';
+const uint32 MSG_ALREADY_CAPTURING		= 'CFac';
+const uint32 MSG_CAPTURE_OK				= 'CFok';
+const uint32 MSG_BAD_MESSAGE			= 'CFbm';
+const uint32 MSG_STOP_CAPTURE			= 'stop';
+
+const uint32 INPUT_TYPE_KEYBOARD		= 0x00000001;
+const uint32 INPUT_TYPE_MOUSE			= 0x00000002;
+
+const uint32 MSG_ENQ_COMMAND			= 'BCec';
+
+// ========== STRUCTS ==========
+
+struct mouse_event
+{
+	mouse_event() { }
+	mouse_event(uint32 X, uint32 Y, uint32 buttons):
+		x(X), y(Y), buttonState(buttons) { }
+	uint32 x;
+	uint32 y;
+	uint32 buttonState;
+};
 
+// ========== CLASSES ==========
 
-
-class BochsApplication : public BApplication {
-
+template <class ContentType> class Queue
+{
 public:
-  BochsApplication();
-  };
+	Queue(uint32 maxItems, const char *name);
+	~Queue();
+	bool Enq(const ContentType &item);
+	bool Deq(ContentType *item);
+	bool QueueEmpty() { return (fHead == fTail); }
+	uint32 ItemCount() { return (fTail > fHead) ? fTail - fHead : fHead + fMaxItems - fTail; }
+	ContentType &ItemAt(uint32 index) { return fItems[(fHead + index) % fMaxItems]; }
+private:
+	ContentType *fItems;
+	uint32 fMaxItems;
+	uint32 fHead;
+	uint32 fTail;
+	const char *fName;
+};
 
-class BochsWindow : public BWindow {
+class BochsApplication: public BApplication
+{
+public:
+	BochsApplication(bx_gui_c *bxGui, int argc, char **argv,
+		uint32 tileWidth, uint32 tileHeight, uint32 headerBarHeight, void (*powerHandlerFunc)());
+	~BochsApplication();
+	static int32 runme(void *data);
+	virtual bool QuitRequested();
+	virtual void Quit();
+	void BxExit();
+private:
+	void (*fPowerHandlerFunc)();
+};
 
+class BochsWindow: public BWindow
+{
 public:
-  BochsWindow(BRect frame);
-  virtual  bool  QuitRequested();
-  virtual  void  FrameResized(float width, float height);
-  };
+	BochsWindow(BRect frame);
+	virtual  bool  QuitRequested();
+};
 
-class BochsView : public BView {
+class BochsView: public BView {
+public:
+	BochsView(BRect frame, char *name, uint32 headerHeight, uint32 tileWidth, uint32 tileHeight);
+	~BochsView();
+	virtual void AttachedToWindow();
+	virtual void DetachedFromWindow();
+	virtual void Draw(BRect updateRect);
+	virtual void KeyDown(const char *bytes, int32 numBytes);
+	virtual void KeyUp(const char *bytes, int32 numBytes);
+	virtual void MouseDown(BPoint point);
+	virtual void MouseUp(BPoint point);
+	virtual void MouseMoved(BPoint point, uint32 transit, const BMessage *message);
+	virtual void MessageReceived(BMessage *msg);
+	virtual void WindowActivated(bool active);
+	virtual void Pulse();
+	void HandleEvents();
+	void ClearScreen();
+	void TextUpdate(uint8 *oldText, uint8 *newText,
+		uint32 cursorX, uint32 cursorY, uint32 rowCount);
+	void GraphicsTileUpdate(uint8 *tile, uint32 xPos, uint32 yPos);
+	bool PaletteChange(uint32 index, uint32 red, uint32 green, uint32 blue);
+	void DimensionUpdate(uint32 x, uint32 y);
+	void HandleEnableMouse(bool enable);
+	uint32 CreateBitmap(const uchar *bitmap, uint32 width, uint32 height);
+	uint32 HeaderbarBitmap(uint32 bitmapID, uint32 alignment, void (*f)(void));
+	void ReplaceBitmap(uint32 headerBarID, uint32 bitmapID);
+	void ShowHeaderbar();
+	void GotCapturedInput(BMessage *msg);
+	//Queue<uint32> *KeyQueue() { return &fKeyQueue; }
+	//Queue<mouse_event> *MouseQueue() { return &fMouseQueue; }
+	//Queue<void (*)(void)> *CommandQueue() { return &fCommandQueue; }
+	static void release_mouse();
+	
 private:
-	BBitmap *backing_store;
-	BView *backing_view;
+	void ShowCursor(bool show);
+	uchar ReverseBitorder(uchar b);
+	void CaptureInput();
+	void ReleaseInput();
 	
-public:
-  BochsView(BRect frame, char *name);
-  ~BochsView();
-  virtual  void  AttachedToWindow();
-  virtual  void  Draw(BRect updateRect);
-  virtual  void  KeyDown(const char *bytes, int32 numBytes);
-  virtual  void  KeyUp(const char *bytes, int32 numBytes);
-  virtual  void  MouseDown(BPoint point);
-  virtual  void  MouseUp(BPoint point);
-  virtual  void  MouseMoved(BPoint point,
-                            uint32 transit, const BMessage *message);
-  void DrawBitmap(const BBitmap *aBitmap, BPoint where);							
-  void FillRect(BRect r, pattern p = B_SOLID_HIGH);
-  void SetHighColor(uchar r, uchar g, uchar b, uchar a = 255);
-  void SetLowColor(uchar r, uchar g, uchar b, uchar a = 255);
-  void SetFont(const BFont *font, uint32 mask = B_FONT_ALL);
-  void set_text_colors(void);
-  void set_inv_text_colors(void);
-  void set_headerbar_colors(void);
-  };
-
-
-void GUI_end(void);
-void   enq_key_event(Bit32u key, Bit32u press_release);
-Bit32u deq_key_event(void);
-#define SCANCODE_BUFSIZE 20
-static Bit32u keyevents[SCANCODE_BUFSIZE];
-static unsigned head=0, tail=0;
-static bool view_attached = 0;
-
-static BochsApplication *myApplication = NULL;
-static BochsWindow      *aWindow = NULL;
-static BochsView        *aView = NULL;
-static BView            *canvas = NULL;
-static uint8 cmap_index[256]; // indeces into system colormap
-
-static BRect rect;
-static BPoint image_origin;
-static BBitmap *image = NULL;
-static BScreen *screen;
-static unsigned long rowsize_padded=0;
-static uint8 *rawdata = NULL;
-
-//static int rows=25, columns=80;
-
-static unsigned font_width, font_height;
-static Bit8u blank_line[80];
-static unsigned dimension_x, dimension_y;
-
-//static unsigned imDepth, imWide, imBPP;
-
-// current cursor coordinates
-//IRA=> Start
-static BPoint current;
-static BPoint previous;
-static Bit8u mouse_button_state = 0;
-//IRA=> End
-//static int prev_x=-1, prev_y=-1;
-//static int current_x=-1, current_y=-1;
-
-static unsigned prev_block_cursor_x=0;
-static unsigned prev_block_cursor_y=0;
-
-static void headerbar_click(int x, int y);
-
-Bit8u ascii_to_scancode[0x7f] = {
-  0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,
-  0x39, 0x02, 0x28, 0x04, 0x05, 0x06, 0x08, 0x28, /*  !"#$%&' */
-  0x0a, 0x0b, 0x09, 0x0d, 0x33, 0x0c, 0x34, 0x35, /* ()*+,-./ */
-  0x0b, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, /* 01234567 */
-  0x09, 0x0a, 0x27, 0x27, 0x33, 0x0d, 0x34, 0x35, /* 89:;<=>? */
-  0x03, 0x1e, 0x30, 0x2e, 0x20, 0x12, 0x21, 0x22, /* @ABCDEFG */
-  0x23, 0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18, /* HIJKLMNO */
-  0x19, 0x10, 0x13, 0x1f, 0x14, 0x16, 0x2f, 0x11, /* PQRSTUVW */
-  0x2d, 0x15, 0x2c, 0x1a, 0x2b, 0x1b, 0x07, 0x0c, /* XYZ[\]^_ */
-  0x29, 0x1e, 0x30, 0x2e, 0x20, 0x12, 0x21, 0x22, /* `abcdefg */
-  0x23, 0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18, /* hijklmno */
-  0x19, 0x10, 0x13, 0x1f, 0x14, 0x16, 0x2f, 0x11, /* pqrstuvw */
-  0x2d, 0x15, 0x2c, 0x1a, 0x2b, 0x1b, 0x29        /* xyz{|}~  */
-  };
-
-extern Bit8u graphics_snapshot[32 * 1024];
-//extern pc_keyb_c *pc_keyboard;
-
-
-
-
-unsigned col_vals[256], curr_foreground, curr_background;
-
-static unsigned x_tilesize, y_tilesize;
-
-struct {
-  BBitmap *bmap;
-  unsigned xdim;
-  unsigned ydim;
-  } bx_bitmaps[BX_MAX_PIXMAPS];
-unsigned bx_bitmap_entries = 0;
-
-static struct {
-  BBitmap   *bitmap;
-  unsigned xdim;
-  unsigned ydim;
-  unsigned xorigin;
-  unsigned yorigin;
-  unsigned alignment;
-  void (*f)(void);
-  } bx_headerbar_entry[BX_MAX_HEADERBAR_ENTRIES];
-static unsigned bx_headerbar_y = 0;
-static unsigned bx_headerbar_entries = 0;
-static unsigned bx_bitmap_left_xorigin = 0;  // pixels from left
-static unsigned bx_bitmap_right_xorigin = 0; // pixels from right
-
-static void headerbar_click(int x, int y);
-static unsigned char reverse_bitorder(unsigned char b);
-static void create_vga_font(void);
-static BBitmap *vgafont[256];
-
-static bx_gui_c *bx_gui_c_ptr;
+	BBitmap *fBackBitmap;
+	BView *fBackView;
+	uint32 fLastModifiers;
+	uint32 fLastMouseX, fLastMouseY;
+	uint32 fCursorX, fCursorY;
+	uint8 fCursorValue[2];
+	bool fCursorVisible;
+	bool fInTextMode;
+	BScreen fScreen;
+	uint8 fColorMap[256]; // indices into system colormap
+	BBitmap *fVgafont[256];
+	BBitmap *fCursorBitmap;
+	uint32 fTileWidth;
+	uint32 fTileHeight;
+	bool fUseStandardInput;
+	bool fMouseEnabled;
+	BHandler *fCaptureTarget;
+	
+	Queue<uint32> fKeyQueue;
+	Queue<mouse_event> fMouseQueue;
+	Queue<void (*)(void)> fCommandQueue;
+	
+	struct
+	{
+		BBitmap *bmap;
+		unsigned xdim;
+		unsigned ydim;
+	} fBitmaps[BX_MAX_PIXMAPS];
+	uint32 fBitmapCount;
+	
+	struct
+	{
+		BBitmap *bitmap;
+		unsigned xdim;
+		unsigned ydim;
+		unsigned xorigin;
+		unsigned yorigin;
+		unsigned alignment;
+		void (*f)(void);
+	} fHeaderEntries[BX_MAX_HEADERBAR_ENTRIES];
+	uint32 fHeaderEntryCount;
+	
+	uint32 fHeaderHeight;
+	uint32 fHeaderLeft;  // pixels from left
+	uint32 fHeaderRight; // pixels from right
+};
 
-  void
-bx_gui_c::specific_init(bx_gui_c *th, int argc, char **argv,
-                        unsigned tilewidth, unsigned tileheight,
-                        unsigned header_bar_y)
+class ModifierFilter: public BMessageFilter
 {
-  unsigned i;
-#if BX_CPU_LEVEL < 2
-  char *window_name = "Bochs 8086 emulator, http://world.std.com/~bochs";
-#elif BX_CPU_LEVEL == 2
-  char *window_name = "Bochs 80286 emulator, http://world.std.com/~bochs";
-#elif BX_CPU_LEVEL == 3
-  char *window_name = "Bochs 80386 emulator, http://world.std.com/~bochs";
-#else
-  char *window_name = "Bochs 80386+ emulator, http://world.std.com/~bochs";
-#endif
-
-  bx_gui_c_ptr = th;
-UNUSED(argc);
-UNUSED(argv);
-UNUSED(window_name);
-  th->put("BGUI");
-
-if (bx_options.Oprivate_colormap->get ()) {
-  BX_INFO(( "BeOS: private_colormap option not handled yet."));
-  }
-
-  x_tilesize = tilewidth;
-  y_tilesize = tileheight;
-  bx_headerbar_y = header_bar_y;
-
-  for (i=0; i<80; i++) {
-    blank_line[i] = ' ';
-    }
-
-
-  font_width = 8;
-  font_height = 16;
-
-  // width = columns * font_width;
-  // height = rows * font_height;
-
-BX_INFO(("font_width = %u", (unsigned) font_width));
-BX_INFO(("font_height = %u", (unsigned) font_height));
-
-  // Create pixmap of depth 1 (bitmap) for icon
-  // icon_pixmap = XCreateBitmapFromData(bx_x_display, win,
-  //   (char *) bochs_icon_bits, bochs_icon_width, bochs_icon_height);
+public:
+	ModifierFilter(BHandler *target);
+	virtual filter_result Filter(BMessage *msg, BHandler **target);
+private:
+	BHandler *fTarget;
+};
 
-  curr_background = 0;
-  // XSetBackground(bx_x_display, gc, col_vals[curr_background]);
-  curr_foreground = 1;
-  // XSetForeground(bx_x_display, gc, col_vals[curr_foreground]);
-  //XGrabPointer( bx_x_display, win, True, 0, GrabModeAsync, GrabModeAsync,
-  //  win, None, CurrentTime );
-  //XFlush(bx_x_display);
+class CaptureTarget: public BHandler
+{
+public:
+	CaptureTarget(BochsView *myTarget): fMyTarget(myTarget) { }
+	virtual void MessageReceived(BMessage *msg);
+private:
+	BochsView *fMyTarget;
+};
 
-  myApplication = new BochsApplication();
+// ========== GLOBAL DATA ==========
 
-  // wait until window on screen
-  while (1) {
-    aWindow->Lock();
-    if (aWindow->IsHidden()) {
-     aWindow->Unlock();
-     continue;
-     }
-    aWindow->Unlock();
-    break;
-    }
+static BochsApplication *bApp = NULL;
+static BochsView *bView = NULL;
 
-  screen = new BScreen;
-  // start out with all color map indeces pointing to Black
-  cmap_index[0] = screen->IndexForColor(0, 0, 0);
-  for (unsigned i=1; i<256; i++) {
-    cmap_index[i] = cmap_index[0];
-    }
+// ========== keytable ==========
+
+static const uint8 key_to_scancode[] = {
+	0,
+	BX_KEY_ESC,
+	BX_KEY_F1,
+	BX_KEY_F2,
+	BX_KEY_F3,
+	BX_KEY_F4,
+	BX_KEY_F5,
+	BX_KEY_F6,
+	BX_KEY_F7,
+	BX_KEY_F8,
+	BX_KEY_F9,
+	BX_KEY_F10,
+	BX_KEY_F11,
+	BX_KEY_F12,
+	BX_KEY_PRINT,
+	BX_KEY_SCRL_LOCK,
+	BX_KEY_PAUSE, /*0x10*/
+	BX_KEY_GRAVE,
+	BX_KEY_1,
+	BX_KEY_2,
+	BX_KEY_3,
+	BX_KEY_4,
+	BX_KEY_5, 
+	BX_KEY_6,
+	BX_KEY_7,
+	BX_KEY_8,
+	BX_KEY_9,
+	BX_KEY_0,
+	BX_KEY_MINUS,
+	BX_KEY_EQUALS,
+	BX_KEY_BACKSPACE,
+	BX_KEY_INSERT,
+	BX_KEY_HOME, /*0x20*/
+	BX_KEY_PAGE_UP,
+	BX_KEY_NUM_LOCK,
+	BX_KEY_KP_DIVIDE,
+	BX_KEY_KP_MULTIPLY,
+	BX_KEY_KP_SUBTRACT,
+	BX_KEY_TAB,
+	BX_KEY_Q,
+	BX_KEY_W,
+	BX_KEY_E,
+	BX_KEY_R,
+	BX_KEY_T,
+	BX_KEY_Y,
+	BX_KEY_U,
+	BX_KEY_I,
+	BX_KEY_O,
+	BX_KEY_P, /*0x30*/
+	BX_KEY_LEFT_BRACKET,
+	BX_KEY_RIGHT_BRACKET,
+	BX_KEY_BACKSLASH,
+	BX_KEY_DELETE,
+	BX_KEY_END,
+	BX_KEY_PAGE_DOWN,
+	BX_KEY_KP_HOME,
+	BX_KEY_KP_UP, 
+	BX_KEY_KP_PAGE_UP, 
+	BX_KEY_KP_ADD, 
+	BX_KEY_CAPS_LOCK, 
+	BX_KEY_A, 
+	BX_KEY_S, 
+	BX_KEY_D, 
+	BX_KEY_F, 
+	BX_KEY_G, /*0x40*/
+	BX_KEY_H, 
+	BX_KEY_J, 
+	BX_KEY_K, 
+	BX_KEY_L, 
+	BX_KEY_SEMICOLON, 
+	BX_KEY_SINGLE_QUOTE, 
+	BX_KEY_ENTER, 
+	BX_KEY_KP_LEFT, 
+	BX_KEY_KP_5, 
+	BX_KEY_KP_RIGHT, 
+	BX_KEY_SHIFT_L, 
+	BX_KEY_Z, 
+	BX_KEY_X, 
+	BX_KEY_C, 
+	BX_KEY_V, 
+	BX_KEY_B, /*0x50*/
+	BX_KEY_N, 
+	BX_KEY_M, 
+	BX_KEY_COMMA, 
+	BX_KEY_PERIOD, 
+	BX_KEY_SLASH, 
+	BX_KEY_SHIFT_R, 
+	BX_KEY_UP, 
+	BX_KEY_KP_END, 
+	BX_KEY_KP_DOWN, 
+	BX_KEY_KP_PAGE_DOWN, 
+	BX_KEY_KP_ENTER, 
+	BX_KEY_CTRL_L, 
+	BX_KEY_ALT_L, 
+	BX_KEY_SPACE, 
+	BX_KEY_ALT_R,
+	BX_KEY_CTRL_R, /*0x60*/
+	BX_KEY_LEFT, 
+	BX_KEY_DOWN, 
+	BX_KEY_RIGHT, 
+	BX_KEY_KP_INSERT, 
+	BX_KEY_KP_DELETE
+};
+
+// ========== class Queue definitions ==========
+
+template <class ContentType>
+Queue<ContentType>::Queue(uint32 maxItems, const char *name):
+	fMaxItems(maxItems),
+	fHead(0),
+	fTail(0)
+{
+	fItems = new ContentType[fMaxItems];
+	fName = strdup(name);
+}
+
+template <class ContentType>
+Queue<ContentType>::~Queue()
+{
+	delete [] fItems;
+	delete fName;
+}
+
+template <class ContentType>
+bool Queue<ContentType>::Enq(const ContentType &item)
+{
+	if ( ((fTail + 1) % fMaxItems) == fHead )
+	{
+		BX_DEBUG(("%s enqueue: buffer full", fName));
+		return false;
+	}
+	fItems[fTail] = item;
+	fTail = (fTail + 1) % fMaxItems;
+	return true;
+}
+
+template <class ContentType>
+bool Queue<ContentType>::Deq(ContentType *item)
+{
+	if ( fHead == fTail )
+	{
+		BX_DEBUG(("%s dequeue: buffer empty", fName));
+		return false;
+	}
+	*item = fItems[fHead];
+	fHead = (fHead + 1) % fMaxItems;
+	return true;
+}
+
+// ========== class BochsApplication definitions ==========
+
+BochsApplication::BochsApplication(bx_gui_c *bxGui, int argc, char **argv,
+	uint32 tileWidth, uint32 tileHeight, uint32 header_bar_y, void (*powerHandlerFunc)()):
+	BApplication(BOCHS_APP_SIG),
+	fPowerHandlerFunc(powerHandlerFunc)
+{
+	bxGui->put("BGUI");
+
+	if (bx_options.Oprivate_colormap->get ())
+	{
+		BX_INFO(( "BeOS: private_colormap option not handled yet."));
+	}
+	
+	// -------------------------------
+	
+	BRect rect(0, 0, INITIAL_SCREEN_WIDTH - 1, INITIAL_SCREEN_HEIGHT + header_bar_y);
+	
+	BochsWindow *window = new BochsWindow(rect.OffsetToCopy(5, 80));
+	
+	bView = new BochsView(rect, "BochsView", header_bar_y, tileWidth, tileHeight);
 
-  rect.Set(0,0, x_tilesize-1, y_tilesize-1);
-  image = new BBitmap(rect, B_COLOR_8_BIT);
-  rowsize_padded = PAD_NEAREST(x_tilesize, sizeof(int32));
-  rawdata = new uint8[rowsize_padded * y_tilesize];
+	// add view to window
+	window->AddChild(bView);
 
-  create_vga_font();
+	// make window visible
+	window->Show();
 }
-
-
 
-  void
-bx_gui_c::handle_events(void)
+BochsApplication::~BochsApplication()
 {
-  Bit32u key;
-
-  while ( head != tail ) {
-    key = deq_key_event();
-    bx_devices.keyboard->gen_scancode(key);
-    }
-//IRA=> Start
-  if (aView) {
-      unsigned long buttons;
-      aView->LockLooper();
-	  aView->GetMouse(&current, &buttons, false);    
-	  aView->UnlockLooper();
-
-	  Bit8u newstate = 0; //please note: 2nd and 3rd button are mapped the same
-	  if (buttons & B_PRIMARY_MOUSE_BUTTON)
-	     newstate |= 0x01;
-	  if (buttons & B_SECONDARY_MOUSE_BUTTON)
-	     newstate |= 0x02;
-	  if (buttons & B_TERTIARY_MOUSE_BUTTON)
-	     newstate |= 0x02;
-	  
-	  if (current != previous || 
-	  	  mouse_button_state != newstate) {
-	    int dx = (int)(current.x - previous.x) *2;
-	    int dy = -(int)((current.y - previous.y) *2);
-	    bx_devices.keyboard->mouse_motion( dx, dy, newstate);
-	    mouse_button_state = newstate;
-	    previous = current;
-      }
-   }
-//IRA=> End
+	bApp = NULL;
 }
 
-  void
-bx_gui_c::flush(void)
+int32 BochsApplication::runme(void *data)
 {
-  if (view_attached)
-    aView->Flush();
+	be_app->Lock();
+	be_app->Run();
 }
-
 
-  void
-bx_gui_c::clear_screen(void)
+bool BochsApplication::QuitRequested()
 {
-  aWindow->Lock();
-  aView->FillRect(BRect(0, bx_headerbar_y, dimension_x-1, dimension_y-1), B_SOLID_LOW);
-  aWindow->Unlock();
+	BMessage msg(MSG_ENQ_COMMAND);
+	msg.AddPointer("command", (void*)fPowerHandlerFunc);
+	bView->Window()->PostMessage(&msg, bView);
+	return false;
 }
-
-
 
-  void
-bx_gui_c::text_update(Bit8u *old_text, Bit8u *new_text,
-                      unsigned long cursor_x, unsigned long cursor_y,
-                      unsigned nrows)
+void BochsApplication::Quit()
 {
-  unsigned i, x, y;
-  BPoint point;
-  unsigned char achar;
-  unsigned nchars;
-
-  aWindow->Lock();
-
-  // Number of characters on screen, variable number of rows
-  nchars = 80*nrows;
-
-  // first draw over character at original block cursor location
-  if ( (prev_block_cursor_y*80 + prev_block_cursor_x) < nchars ) {
-    achar = new_text[(prev_block_cursor_y*80 + prev_block_cursor_x)*2];
-    point.Set(prev_block_cursor_x*8, prev_block_cursor_y*16 + bx_headerbar_y);
-    aView->DrawBitmap(vgafont[achar], point );
-    }
-
-  for (i=0; i<nchars*2; i+=2) {
-    if ( (old_text[i]!=new_text[i]) ||
-         (old_text[i+1]!=new_text[i+1]) ) {
-
-      achar = new_text[i];
-
-      x = (i/2) % 80;
-      y = (i/2) / 80;
-
-      point.Set(x*8, y*16 + bx_headerbar_y);
-      aView->DrawBitmap(vgafont[achar], point );
-      }
-    }
-
-  prev_block_cursor_x = cursor_x;
-  prev_block_cursor_y = cursor_y;
-
-  // now draw character at new block cursor location in reverse
-  if ( (cursor_y*80 + cursor_x) < nchars ) {
-    achar = new_text[(cursor_y*80 + cursor_x)*2];
-    point.Set(cursor_x*8, cursor_y*16 + bx_headerbar_y);
-    aView->set_inv_text_colors();
-    aView->DrawBitmap(vgafont[achar], point );
-    aView->set_text_colors();
-    }
-
-  aWindow->Unlock();
+	uint32 lockCount = 0;
+	while (IsLocked())
+	{
+		Unlock();
+		lockCount++;
+	}
+	bView->LockLooper();
+	bView->Window()->Close();
+	while (lockCount--) Lock();
 }
-
 
-  void
-bx_gui_c::graphics_tile_update(Bit8u *tile, unsigned x0, unsigned y0)
+void BochsApplication::BxExit()
 {
-  for (unsigned y=0; y<y_tilesize; y++) {
-    for (unsigned x=0; x<x_tilesize; x++) {
-      rawdata[y*rowsize_padded + x] = cmap_index[ tile[y*x_tilesize + x] ];
-      }
-    }
-  aWindow->Lock();
-  image->SetBits(rawdata, rowsize_padded * y_tilesize, 0, B_COLOR_8_BIT);
-  image_origin.Set(x0, y0 + bx_headerbar_y);
-
-  aView->DrawBitmap( image, image_origin );
-  aWindow->Unlock();
+	if (Lock()) Quit();
 }
 
+// ========== class BochsWindow definitions ==========
 
-  Boolean
-bx_gui_c::palette_change(unsigned index, unsigned red, unsigned green, unsigned blue)
+BochsWindow::BochsWindow(BRect frame):
+	BWindow(frame, "Bochs", B_TITLED_WINDOW, B_NOT_RESIZABLE)
 {
-  cmap_index[index] = screen->IndexForColor(
-    red, green, blue);
-  return(1);
-}
 
-
-  void
-bx_gui_c::dimension_update(unsigned x, unsigned y)
-{
-  aWindow->Lock();
-  aWindow->ResizeTo(x, y + bx_headerbar_y);
-  aWindow->Unlock();
 }
-
-
-//////////////////////////////////////////////////////
-
 
-  void
-GUI_end()
+bool BochsWindow::QuitRequested()
 {
-  //myApplication->Run();
-
-  delete(myApplication);
+	be_app->PostMessage(B_QUIT_REQUESTED);
+	return false;
 }
-
-BochsApplication::BochsApplication()
-            : BApplication("application/x-vnd.Be-Bochs")
-{
-  BRect      aRect;
-
-  int left, right, top, bottom;
-  left = 5;
-  top = 80;
-  dimension_x = 640;
-  dimension_y = 480 + bx_headerbar_y;
-  right = left + dimension_x - 1;
-  bottom = top + dimension_y - 1;
 
-  // set up a rectangle and instantiate a new window
-  aRect.Set(left, top, right, bottom);
-  aWindow = new BochsWindow(aRect);
+// ========== class BochsView definitions ==========
 
-  // set up a rectangle and instantiate a new view
-  // view rect should be same size as window rect but with left top at (0, 0)
-  aRect.OffsetTo(B_ORIGIN);
-  aView = new BochsView(aRect, "BochsView");
-  aView->SetViewColor(0, 0, 0);
-
-  aView->set_text_colors();
-
-  // add view to window
-  aWindow->AddChild(aView);
-
-  // make window visible
-  aWindow->Show();
+BochsView::BochsView(BRect rect, char *name, uint32 headerHeight, uint32 tileWidth, uint32 tileHeight):
+	BView(rect, name, B_FOLLOW_ALL, B_WILL_DRAW | B_PULSE_NEEDED),
+	fLastModifiers(0),
+	fCursorX(0), fCursorY(0),
+	fCursorVisible(false),
+	fInTextMode(true), 
+	fTileWidth(tileWidth),
+	fTileHeight(tileHeight),
+	fUseStandardInput(true),
+	fMouseEnabled(false), 
+	fKeyQueue(SCANCODE_BUFSIZE, "keyboard queue"),
+	fMouseQueue(MOUSE_BUFSIZE, "mouse queue"),
+	fCommandQueue(10, "headerbar queue"), 
+	fBitmapCount(0),
+	fHeaderEntryCount(0),
+	fHeaderHeight(headerHeight),
+	fHeaderLeft(0),
+	fHeaderRight(0)
+{
+	SetViewColor(0, 0, 0);
+	fBackBitmap = new BBitmap(rect, B_BITMAP_ACCEPTS_VIEWS, B_CMAP8);
+	fBackView = new BView(rect,"BackView", B_FOLLOW_ALL, B_WILL_DRAW);
+	fBackView->SetViewColor(0, 0, 0);
+	fBackBitmap->AddChild(fBackView);
+	
+	fCaptureTarget = new CaptureTarget(this);
+	
+	// start out with all color map indeces pointing to Black
+	fColorMap[0] = fScreen.IndexForColor(0, 0, 0);
+	for (unsigned i=1; i<256; i++)
+	{
+		fColorMap[i] = fColorMap[0];
+	}
+
+	BX_INFO(( "BeOS: creating VGA font from bitmaps" ));
+
+	// VGA font is 8wide x 16high
+	uint8 *bits;
+	for (uint32 c = 0; c < 256; c++)
+	{
+		fVgafont[c] = new BBitmap(BRect(0,0, 7,15), B_MONOCHROME_1_BIT);
+		if (!fVgafont[c])
+		{
+			BX_PANIC(("beos: could not create bitmap"));
+		}
+
+		int32 bytesPerRow = fVgafont[c]->BytesPerRow();
+		bits = (uint8*)fVgafont[c]->Bits();
+		memset(bits, 0, fVgafont[c]->BitsLength());
+		for (uint32 i = 0; i < 16; i++)
+		{
+			bits[i * bytesPerRow] = ReverseBitorder(bx_vgafont[c].data[i]);
+		}
+	}
 }
 
-//void set_palette_entry(long i,rgb_color c);
-
-BochsWindow::BochsWindow(BRect frame)
-        : BWindow(frame, "BeBochs V1.3.pre compiled Bernd Korz", B_TITLED_WINDOW, B_NOT_RESIZABLE)
+BochsView::~BochsView()
 {
+	delete fBackBitmap;
+	for (int32 i = 0; i < 256; i++) delete fVgafont[i];
+	delete fCursorBitmap;
+	delete fCaptureTarget;
+	bView = NULL;
 }
 
-bool BochsWindow::QuitRequested()
+void BochsView::AttachedToWindow()
 {
-  be_app->PostMessage(B_QUIT_REQUESTED);
-  return(TRUE);
+	SetViewColor(B_TRANSPARENT_COLOR);
+	MakeFocus(true);
+	Window()->AddFilter(new ModifierFilter(this));
+	be_app->AddHandler(fCaptureTarget);
+	BMessage modifiersMessage(B_MODIFIERS_CHANGED);
+	modifiersMessage.AddInt32("modifiers", (int32)modifiers());
+	Window()->PostMessage(&modifiersMessage, this);
+	BPoint p;
+	uint32 buttons;
+	GetMouse(&p, &buttons);
+	fLastMouseX = (uint32)p.x;
+	fLastMouseY = (uint32)p.y;
+}
+
+void BochsView::DetachedFromWindow()
+{
+	if (be_app->Lock())
+	{
+		be_app->RemoveHandler(fCaptureTarget);
+		be_app->Unlock();
+	}
 }
 
-
-  void
-BochsWindow::FrameResized(float width, float height)
+void BochsView::Draw(BRect rect)
 {
-  dimension_x = unsigned(width);
-  dimension_y = unsigned(height) + bx_headerbar_y;
-  if ( bx_gui_c_ptr )
-    bx_gui_c_ptr->show_headerbar();
+	if (fBackBitmap->Lock())
+	{
+		fBackView->Sync();
+		fBackBitmap->Unlock();
+	}
+	DrawBitmapAsync(fBackBitmap, rect, rect);
+}
+
+void BochsView::MouseDown(BPoint point)
+{
+	if (point.y < fHeaderHeight)
+	{
+		int xorigin;
+		for (unsigned i = 0; i < fHeaderEntryCount; i++)
+		{
+			if (fHeaderEntries[i].alignment == BX_GRAVITY_LEFT)
+				xorigin = fHeaderEntries[i].xorigin;
+			else
+				xorigin = bView->Bounds().IntegerWidth() - fHeaderEntries[i].xorigin;
+			if ( (point.x >= xorigin) && (point.x < (xorigin + int(fHeaderEntries[i].xdim))) )
+			{
+				fCommandQueue.Enq(fHeaderEntries[i].f);
+				break;
+			}
+		}
+		return;
+	}
+	uint32 buttons;
+	Window()->CurrentMessage()->FindInt32("buttons", (int32*)&buttons);
+	
+	fMouseQueue.Enq(mouse_event(0, 0,
+		((buttons & B_PRIMARY_MOUSE_BUTTON) ? MOUSE_L : 0) |
+		((buttons & B_SECONDARY_MOUSE_BUTTON) ? MOUSE_R : 0)));
+		
+	BX_DEBUG(("mousedown()"));
 }
-
-
-//------------------------------
 
-
-BochsView::BochsView(BRect rect, char *name)
-          : BView(rect, name, B_FOLLOW_ALL, B_WILL_DRAW)
+void BochsView::MouseUp(BPoint point)
 {
-	backing_store = new BBitmap(rect, B_BITMAP_ACCEPTS_VIEWS, B_COLOR_8_BIT);
-	backing_view = new BView(rect,"backing store", B_FOLLOW_ALL, B_WILL_DRAW);
-	backing_store->AddChild(backing_view);
+	uint32 buttons;
+	Window()->CurrentMessage()->FindInt32("buttons", (int32*)&buttons);
+	
+	fMouseQueue.Enq(mouse_event(0, 0,
+		((buttons & B_PRIMARY_MOUSE_BUTTON) ? MOUSE_L : 0) |
+		((buttons & B_SECONDARY_MOUSE_BUTTON) ? MOUSE_R : 0)));
+		
+	BX_DEBUG(( "mouseup()" ));
+}
+
+void BochsView::MouseMoved(BPoint point, uint32 transit, const BMessage *message)
+{
+	if (!fUseStandardInput && fMouseEnabled)
+	{
+		be_app->ObscureCursor();
+		return;
+	}
+	uint32 buttons;
+	Window()->CurrentMessage()->FindInt32("buttons", (int32*)&buttons);
+	fMouseQueue.Enq(mouse_event((uint32)point.x - fLastMouseX, fLastMouseY - (uint32)point.y, 
+		((buttons & B_PRIMARY_MOUSE_BUTTON) ? MOUSE_L : 0) |
+		((buttons & B_SECONDARY_MOUSE_BUTTON) ? MOUSE_R : 0)));
+	fLastMouseX = (uint32)point.x;
+	fLastMouseY = (uint32)point.y;
+	BX_DEBUG(( "mousemoved()" ));
 }
 
-  void
-BochsView::set_text_colors(void)
+void BochsView::KeyDown(const char *bytes, int32 numBytes)
 {
-  aView->SetHighColor(255, 255, 255);
-  aView->SetLowColor(0, 0, 0);
+	int32 key;
+	Window()->CurrentMessage()->FindInt32("key", &key);
+	fKeyQueue.Enq(key_to_scancode[key] | BX_KEY_PRESSED);
 }
 
-  void
-BochsView::set_inv_text_colors(void)
+void BochsView::KeyUp(const char *bytes, int32 numBytes)
 {
-  aView->SetHighColor(0, 0, 0);
-  aView->SetLowColor(255, 255, 255);
+	int32 key;
+	Window()->CurrentMessage()->FindInt32("key", &key);
+	fKeyQueue.Enq(key_to_scancode[key] | BX_KEY_RELEASED);
+}
+
+void BochsView::MessageReceived(BMessage *msg)
+{
+	switch (msg->what)
+	{
+	case MSG_ENQ_COMMAND:
+		{
+			void (*command)(void);
+			msg->FindPointer("command", (void**)&command);
+			fCommandQueue.Enq(command);
+		}
+		break;
+	case B_MODIFIERS_CHANGED:
+		{
+			uint32 modifiers = 0;
+			msg->FindInt32("modifiers", (int32*)&modifiers);
+ 			//fprintf(stderr, "# modifiers: %08x -> %08x\n", fLastModifiers, modifiers);
+			if (!(fLastModifiers & B_LEFT_SHIFT_KEY) && (modifiers & B_LEFT_SHIFT_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_SHIFT_L | BX_KEY_PRESSED);
+				//fprintf(stderr, "# left shift down\n");
+			}
+			else if ((fLastModifiers & B_LEFT_SHIFT_KEY) && !(modifiers & B_LEFT_SHIFT_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_SHIFT_L | BX_KEY_RELEASED);
+				//fprintf(stderr, "# left shift up\n");
+			}
+				
+			if (!(fLastModifiers & B_RIGHT_SHIFT_KEY) && (modifiers & B_RIGHT_SHIFT_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_SHIFT_R | BX_KEY_PRESSED);
+				//fprintf(stderr, "# right shift down\n");
+			}
+			else if ((fLastModifiers & B_RIGHT_SHIFT_KEY) && !(modifiers & B_RIGHT_SHIFT_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_SHIFT_R | BX_KEY_RELEASED);
+				//fprintf(stderr, "# right shift up\n");
+			}
+				
+			if (!(fLastModifiers & B_CONTROL_KEY) && (modifiers & B_CONTROL_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_CTRL_L | BX_KEY_PRESSED);
+				//fprintf(stderr, "# left ctrl down\n");
+			}
+			else if ((fLastModifiers & B_CONTROL_KEY) && !(modifiers & B_CONTROL_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_CTRL_L | BX_KEY_RELEASED);
+				//fprintf(stderr, "# left ctrl up\n");
+			}
+				
+			if (!(fLastModifiers & B_OPTION_KEY) && (modifiers & B_OPTION_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_CTRL_R | BX_KEY_PRESSED);
+				//fprintf(stderr, "# right ctrl down\n");
+			}
+			else if ((fLastModifiers & B_OPTION_KEY) && !(modifiers & B_OPTION_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_CTRL_R | BX_KEY_RELEASED);
+				//fprintf(stderr, "# right ctrl up\n");
+			}
+				
+			if (!(fLastModifiers & B_LEFT_COMMAND_KEY) && (modifiers & B_LEFT_COMMAND_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_ALT_L | BX_KEY_PRESSED);
+				//fprintf(stderr, "# left alt down\n");
+			}
+			else if ((fLastModifiers & B_LEFT_COMMAND_KEY) && !(modifiers & B_LEFT_COMMAND_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_ALT_L | BX_KEY_RELEASED);
+				//fprintf(stderr, "# left alt up\n");
+			}
+				
+			if (!(fLastModifiers & B_RIGHT_COMMAND_KEY) && (modifiers & B_RIGHT_COMMAND_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_ALT_R | BX_KEY_PRESSED);
+				//fprintf(stderr, "# right alt down\n");
+			}
+			else if ((fLastModifiers & B_RIGHT_COMMAND_KEY) && !(modifiers & B_RIGHT_COMMAND_KEY))
+			{
+				fKeyQueue.Enq(BX_KEY_ALT_R | BX_KEY_RELEASED);
+				//fprintf(stderr, "# right alt up\n");
+			}
+				
+			if (!(fLastModifiers & B_CAPS_LOCK) && (modifiers & B_CAPS_LOCK))
+			{
+				fKeyQueue.Enq(BX_KEY_CAPS_LOCK | BX_KEY_PRESSED);
+				fKeyQueue.Enq(BX_KEY_CAPS_LOCK | BX_KEY_RELEASED);
+				//fprintf(stderr, "# caps down\n");
+			}
+			else if ((fLastModifiers & B_CAPS_LOCK) && !(modifiers & B_CAPS_LOCK))
+			{
+				fKeyQueue.Enq(BX_KEY_CAPS_LOCK | BX_KEY_PRESSED);
+				fKeyQueue.Enq(BX_KEY_CAPS_LOCK | BX_KEY_RELEASED);
+				//fprintf(stderr, "# caps up\n");
+			}
+				
+			if (!(fLastModifiers & B_SCROLL_LOCK) && (modifiers & B_SCROLL_LOCK))
+			{
+				fKeyQueue.Enq(BX_KEY_SCRL_LOCK | BX_KEY_PRESSED);
+				fKeyQueue.Enq(BX_KEY_SCRL_LOCK | BX_KEY_RELEASED);
+				//fprintf(stderr, "# scrollock down\n");
+			}
+			else if ((fLastModifiers & B_SCROLL_LOCK) && !(modifiers & B_SCROLL_LOCK))
+			{
+				fKeyQueue.Enq(BX_KEY_SCRL_LOCK | BX_KEY_PRESSED);
+				fKeyQueue.Enq(BX_KEY_SCRL_LOCK | BX_KEY_RELEASED);
+				//fprintf(stderr, "# scrollock up\n");
+			}
+				
+			if (!(fLastModifiers & B_NUM_LOCK) && (modifiers & B_NUM_LOCK))
+			{
+				fKeyQueue.Enq(BX_KEY_NUM_LOCK | BX_KEY_PRESSED);
+				fKeyQueue.Enq(BX_KEY_NUM_LOCK | BX_KEY_RELEASED);
+				//fprintf(stderr, "# num down\n");
+			}
+			else if ((fLastModifiers & B_NUM_LOCK) && !(modifiers & B_NUM_LOCK))
+			{
+				fKeyQueue.Enq(BX_KEY_NUM_LOCK | BX_KEY_PRESSED);
+				fKeyQueue.Enq(BX_KEY_NUM_LOCK | BX_KEY_RELEASED);
+				//fprintf(stderr, "# num up\n");
+			}
+			fLastModifiers = modifiers;
+		}
+		break;
+	default:
+		BView::MessageReceived(msg);
+	}
+}
+
+void BochsView::GotCapturedInput(BMessage *msg)
+{
+	switch (msg->what)
+	{
+	case B_MOUSE_MOVED:
+		{
+			uint32 buttons;
+			msg->FindInt32("buttons", (int32*)&buttons);
+			BPoint motion;
+			msg->FindPoint("motion", &motion);
+			fMouseQueue.Enq(mouse_event((uint32)motion.x, -(uint32)motion.y, 
+				((buttons & B_PRIMARY_MOUSE_BUTTON) ? MOUSE_L : 0) |
+				((buttons & B_SECONDARY_MOUSE_BUTTON) ? MOUSE_R : 0)));
+			BX_DEBUG(( "mousemoved()" ));
+		}
+		break;
+	case B_MOUSE_DOWN:
+	case B_MOUSE_UP:
+		{
+			uint32 buttons;
+			msg->FindInt32("buttons", (int32*)&buttons);
+			if (buttons & B_PRIMARY_MOUSE_BUTTON && buttons & B_SECONDARY_MOUSE_BUTTON)
+			{
+				fCommandQueue.Enq(release_mouse);
+				break;
+			}
+			
+			fMouseQueue.Enq(mouse_event(0, 0,
+				((buttons & B_PRIMARY_MOUSE_BUTTON) ? MOUSE_L : 0) |
+				((buttons & B_SECONDARY_MOUSE_BUTTON) ? MOUSE_R : 0)));
+				
+			//BX_DEBUG(("mousedown()"));
+		}
+		break;
+	case B_KEY_DOWN:
+	case B_UNMAPPED_KEY_DOWN:
+		{
+			int32 key;
+			msg->FindInt32("key", &key);
+			fKeyQueue.Enq(key_to_scancode[key] | BX_KEY_PRESSED);
+		}
+		break;
+	case B_KEY_UP:
+	case B_UNMAPPED_KEY_UP:
+		{
+			int32 key;
+			msg->FindInt32("key", &key);
+			fKeyQueue.Enq(key_to_scancode[key] | BX_KEY_RELEASED);
+		}
+	}
+}
+
+void BochsView::WindowActivated(bool active)
+{
+	if (active) CaptureInput();
+	else ReleaseInput();
+}
+
+void BochsView::CaptureInput()
+{
+	BMessenger inputServer("application/x-vnd.Be-input_server");
+	BMessage msg(MSG_REQUEST_CAPTURE);
+	msg.AddMessenger("target", BMessenger(fCaptureTarget));
+	msg.AddInt32("command", MSG_START_CAPTURE);
+	msg.AddInt32("input", (fMouseEnabled ? INPUT_TYPE_MOUSE : 0) | INPUT_TYPE_KEYBOARD);
+	inputServer.SendMessage(&msg, &msg);
+	if (msg.what == MSG_CAPTURE_OK)
+	{
+		BX_INFO(( "capturing keyboard%s input", (fMouseEnabled ? " and mouse" : "")));
+		fUseStandardInput = false;
+		if (fMouseEnabled) be_app->ObscureCursor();
+		else be_app->ShowCursor();
+	}
+	else 
+	{
+		BX_ERROR(( "couldn't set up input capturing, using loser method" ));
+		fUseStandardInput = true;
+		BMessage modifiersMessage(B_MODIFIERS_CHANGED);
+		modifiersMessage.AddInt32("modifiers", (int32)modifiers());
+		Window()->PostMessage(&modifiersMessage, this);
+	}
+}
+
+void BochsView::ReleaseInput()
+{
+	BMessenger inputServer("application/x-vnd.Be-input_server");
+	BMessage msg(MSG_REQUEST_CAPTURE);
+	msg.AddInt32("command", MSG_STOP_CAPTURE);
+	inputServer.SendMessage(&msg);
+	be_app->ShowCursor();
+	fUseStandardInput = true;
+}
+
+void BochsView::Pulse()
+{
+	if (!fInTextMode) return;
+	if (fBackView->LockLooper())
+	{
+		ShowCursor(!fCursorVisible);
+		fBackView->UnlockLooper();
+	}
+}
+
+void BochsView::HandleEvents()
+{
+	if (LockLooper())
+	{
+		//Queue<uint32> *keyQueue = bView->KeyQueue();
+		while (!fKeyQueue.QueueEmpty())
+		{
+			uint32 key;
+			fKeyQueue.Deq(&key);
+			bx_devices.keyboard->gen_scancode(key);
+		}
+		
+		//Queue<mouse_event> *mouseQueue = bView->MouseQueue();
+		while (!fMouseQueue.QueueEmpty())
+		{
+			mouse_event event;
+			fMouseQueue.Deq(&event);
+			if (fMouseEnabled) bx_devices.keyboard->mouse_motion(event.x,
+				event.y, event.buttonState);
+		}
+		
+		//Queue<void (*)(void)> *commandQueue = bView->CommandQueue();
+		while (!fCommandQueue.QueueEmpty())
+		{
+			void (*f)(void);
+			fCommandQueue.Deq(&f);
+			f();
+		}
+		UnlockLooper();
+	}
+}
+
+void BochsView::ClearScreen()
+{
+	if (fBackBitmap->Lock())
+	{
+		fBackView->SetLowColor(0, 0, 0);
+		BRect rect(fBackView->Bounds());
+		rect.top += fHeaderHeight;
+		fBackView->FillRect(rect, B_SOLID_LOW);
+		fBackBitmap->Unlock();
+	}
+	if (LockLooper())
+	{
+		Invalidate();
+		UnlockLooper();
+	}
+}
+
+void BochsView::TextUpdate(uint8 *oldText, uint8 *newText,
+	uint32 cursorX, uint32 cursorY, uint32 rowCount)
+{
+	if (LockLooper() && fBackBitmap->Lock())
+	{
+		fInTextMode = true;
+		bool cursorWasShown = fCursorVisible;
+		ShowCursor(false);
+		for (uint32 i = 0; i < rowCount * 80 * 2; i += 2)
+		{
+			if ( (oldText[i] != newText[i]) ||
+				(oldText[i+1]!=newText[i+1]) )
+			{
+				uint8 achar = newText[i];
+				uint8 acolor = newText[i + 1];
+				
+				fBackView->SetLowColor(fScreen.ColorForIndex(fColorMap[acolor >> 4]));
+				fBackView->SetHighColor(fScreen.ColorForIndex(fColorMap[acolor & 0x0F]));
+				
+				BPoint point(((i / 2) % 80) * 8, (i/2) / 80 * 16 + fHeaderHeight);
+				fBackView->DrawBitmapAsync(fVgafont[achar], point);
+				Invalidate(fVgafont[achar]->Bounds().OffsetToSelf(point));
+			}
+		}
+	
+		fCursorX = cursorX;
+		fCursorY = cursorY;
+		
+		if ( (cursorY * 80 + cursorX) < rowCount * 80 )
+		{
+			fCursorValue[0] = newText[(cursorY * 80 + cursorX) * 2];
+			fCursorValue[1] = newText[(cursorY * 80 + cursorX) * 2 + 1];
+		}
+		ShowCursor(cursorWasShown);
+		fBackBitmap->Unlock();
+		UnlockLooper();
+	}
+}
+
+void BochsView::GraphicsTileUpdate(uint8 *tile, uint32 x0, uint32 y0)
+{
+	if (LockLooper())
+	{
+		fInTextMode = false;
+		ShowCursor(false);
+		uint8 *bits = (uint8*)fBackBitmap->Bits();
+		int32 bytesPerRow = fBackBitmap->BytesPerRow();
+		bits += (y0 + fHeaderHeight) * bytesPerRow + x0;
+		if (fBackBitmap->Lock())
+		{
+			fBackView->Sync();
+			for (uint32 y = 0; y < fTileHeight; y++)
+			{
+				for (uint32 x = 0; x < fTileWidth; x++)
+				{
+					*(bits + x) = fColorMap[ tile[y*fTileWidth + x] ];
+				}
+				bits += bytesPerRow;
+			}
+			fBackBitmap->Unlock();
+		}
+		Invalidate(BRect(x0, y0 + fHeaderHeight, x0 + fTileWidth - 1, y0 + fHeaderHeight + fTileHeight -1));
+		UnlockLooper();
+	}
+}
+
+bool BochsView::PaletteChange(uint32 index, uint32 red, uint32 green, uint32 blue)
+{
+	if (LockLooper())
+	{
+		fColorMap[index] = fScreen.IndexForColor(red, green, blue);
+		UnlockLooper();
+	}
+	return true;
+}
+
+void BochsView::DimensionUpdate(uint32 x, uint32 y)
+{
+	if (LockLooper())
+	{
+		BRect rect(Bounds().OffsetToSelf(0, 0));
+		if (x !=  (uint32)rect.IntegerWidth() || y + fHeaderHeight != (uint32)rect.IntegerHeight())
+		{
+			Window()->ResizeTo(x, y + fHeaderHeight);
+			delete fBackBitmap;
+			rect.Set(0, 0, x, y + fHeaderHeight);
+			fBackBitmap = new BBitmap(rect, B_BITMAP_ACCEPTS_VIEWS, B_CMAP8);
+			fBackView = new BView(rect,"BackView", B_FOLLOW_NONE, B_WILL_DRAW);
+			fBackBitmap->AddChild(fBackView);
+			ShowHeaderbar();
+		}
+		UnlockLooper();
+	}
+}
+
+void BochsView::HandleEnableMouse(bool enable)
+{
+	if (LockLooper())
+	{
+		fMouseEnabled = enable;
+		if (Window()->IsActive()) CaptureInput();
+		UnlockLooper();
+	}
+}
+
+uint32 BochsView::CreateBitmap(const uchar *bmap, uint32 xdim, uint32 ydim)
+{
+	if (LockLooper())
+	{
+		if (fBitmapCount >= BX_MAX_PIXMAPS)
+		{
+			BX_PANIC(("beos: too many pixmaps, increase BX_MAX_PIXMAPS"));
+		}
+		
+		uint32 bmpIndex = fBitmapCount++;
+		
+		fBitmaps[bmpIndex].bmap =
+			new BBitmap(BRect(0, 0, xdim-1, ydim-1), B_MONOCHROME_1_BIT);
+		if (!fBitmaps[bmpIndex].bmap)
+		{
+			BX_PANIC(("beos: could not create bitmap"));
+		}
+	
+		int32 bitsLength = fBitmaps[bmpIndex].bmap->BitsLength();
+		uchar *bits = (uchar *) fBitmaps[bmpIndex].bmap->Bits();
+		for (int32 i = 0; i < bitsLength; i++)
+		{
+			bits[i] = ReverseBitorder(bmap[i]);
+		}
+	
+		fBitmaps[bmpIndex].xdim = xdim;
+		fBitmaps[bmpIndex].ydim = ydim;
+		UnlockLooper();
+		return bmpIndex;
+	}
+	return 0;
+}
+
+uint32 BochsView::HeaderbarBitmap(uint32 bmap_id, uint32 alignment, void (*f)(void))
+{
+	if (LockLooper())
+	{
+		if ( (fHeaderEntryCount + 1) > BX_MAX_HEADERBAR_ENTRIES )
+			BX_PANIC(("beos: too many headerbar entries, increase BX_MAX_HEADERBAR_ENTRIES"));
+		
+		
+		uint32 hbIndex = fHeaderEntryCount++;
+	
+		fHeaderEntries[hbIndex].bitmap = fBitmaps[bmap_id].bmap;
+		fHeaderEntries[hbIndex].xdim = fBitmaps[bmap_id].xdim;
+		fHeaderEntries[hbIndex].ydim = fBitmaps[bmap_id].ydim;
+		fHeaderEntries[hbIndex].alignment = alignment;
+		fHeaderEntries[hbIndex].f = f;
+		if (alignment == BX_GRAVITY_LEFT)
+		{
+			fHeaderEntries[hbIndex].xorigin = fHeaderLeft;
+			fHeaderEntries[hbIndex].yorigin = 0;
+			fHeaderLeft += fBitmaps[bmap_id].xdim;
+		}
+		else // BX_GRAVITY_RIGHT
+		{
+			fHeaderRight += fBitmaps[bmap_id].xdim;
+			fHeaderEntries[hbIndex].xorigin = fHeaderRight;
+			fHeaderEntries[hbIndex].yorigin = 0;
+		}
+		UnlockLooper();
+		return(hbIndex);
+	}
+	return 0;
+}
+
+void BochsView::ReplaceBitmap(uint32 hbar_id, uint32 bmap_id)
+{
+	if (LockLooper() && fBackBitmap->Lock())
+	{
+		uint32 xorigin;
+	
+		fHeaderEntries[hbar_id].bitmap = fBitmaps[bmap_id].bmap;
+	
+		if (fHeaderEntries[hbar_id].alignment == BX_GRAVITY_LEFT)
+			xorigin = fHeaderEntries[hbar_id].xorigin;
+		else
+			xorigin = Bounds().IntegerWidth() - fHeaderEntries[hbar_id].xorigin;
+		fBackView->SetLowColor(0, 0, 0);
+		fBackView->SetHighColor(0, 100, 0);
+		fBackView->DrawBitmapAsync(fHeaderEntries[hbar_id].bitmap, BPoint(xorigin, 0));
+		fBackBitmap->Unlock();
+		Invalidate(fHeaderEntries[hbar_id].bitmap->Bounds().OffsetToSelf(xorigin, 0));
+		UnlockLooper();
+	}
 }
 
-  void
-BochsView::set_headerbar_colors(void)
+void BochsView::ShowHeaderbar()
 {
-  aView->SetHighColor(0, 0, 0);
-  aView->SetLowColor(255, 255, 255);
+	if (LockLooper() && fBackBitmap->Lock())
+	{
+		uint32 xorigin;
+		fBackView->SetLowColor(0, 0, 0);
+		fBackView->SetHighColor(0, 100, 0);
+		BRect rect(Bounds());
+		rect.bottom = rect.top + fHeaderHeight - 1;
+		fBackView->FillRect(rect, B_SOLID_LOW);
+		for (unsigned i = 0; i < fHeaderEntryCount; i++)
+		{
+			if (fHeaderEntries[i].alignment == BX_GRAVITY_LEFT)
+				xorigin = fHeaderEntries[i].xorigin;
+			else
+				xorigin = rect.IntegerWidth() - fHeaderEntries[i].xorigin;
+			fBackView->DrawBitmapAsync( fHeaderEntries[i].bitmap, BPoint(xorigin, 0) );
+		}
+		fBackBitmap->Unlock();
+		Invalidate(rect);
+		UnlockLooper();
+	}
 }
 
-void BochsView::AttachedToWindow()
+void BochsView::ShowCursor(bool show)
 {
-  BFont font(be_fixed_font);
-
-  aWindow->Lock();
-  font.SetSize(16);
-  font.SetFlags(B_DISABLE_ANTIALIASING);
-  aView->SetFont(&font);
-
-  aView->MakeFocus(true);
-  aWindow->Unlock();
-
-  view_attached = 1;
+	if (fBackBitmap->Lock())
+	{
+		fCursorVisible = show;
+		BRect rect;
+		if (show)
+		{
+			BPoint point(fCursorX * 8, fHeaderHeight + fCursorY * 16 + 14);
+			rect.Set(point.x, point.y, point.x + 7, point.y + 1);
+			fBackView->SetHighColor(fScreen.ColorForIndex(fColorMap[fCursorValue[1] & 0x0F]));
+			fBackView->FillRect(rect, B_SOLID_HIGH);
+			Invalidate(rect);
+		}
+		else
+		{
+			BPoint point(fCursorX * 8, fHeaderHeight + fCursorY * 16);
+			rect.Set(point.x, point.y, point.x + 7, point.y + 15);
+			fBackView->SetHighColor(fScreen.ColorForIndex(fColorMap[fCursorValue[1] & 0x0F]));
+			fBackView->SetLowColor(fScreen.ColorForIndex(fColorMap[fCursorValue[1] >> 4]));
+			fBackView->DrawBitmapAsync(fVgafont[fCursorValue[0]], point);
+		}
+		Invalidate(rect);
+		fBackBitmap->Unlock();
+	}
 }
 
-void  BochsView::MouseDown(BPoint point)
+uchar BochsView::ReverseBitorder(uchar b)
 {
-  UNUSED(point);
-  if (point.y < BX_HEADER_BAR_Y) {
-    headerbar_click(int(point.x), int(point.y));
-    return;
-    }
-   BX_DEBUG(("mousedown()"));
+	uchar ret=0;
+	for (uint32 i=0; i<8; i++)
+	{
+		ret |= (b & 0x01) << (7-i);
+		b >>= 1;
+	}
+	return ret;
 }
 
-void  BochsView::MouseUp(BPoint point)
+void BochsView::release_mouse()
 {
-  UNUSED(point);
-  // currently a place holder function
-  BX_DEBUG(( "mouseup()" ));
-  BView::MouseUp(point);
+	bx_options.Omouse_enabled->set(false);
 }
 
-void  BochsView::MouseMoved(BPoint point,
-                          uint32 transit, const BMessage *message)
-{
-  UNUSED(point);
-  UNUSED(transit);
-  UNUSED(message);
-  BX_DEBUG(( "mousemoved()" ));
-}
+// ========== class ModifierFilter definitions ==========
 
-void BochsView::KeyDown(const char *bytes, int32 numBytes)
+ModifierFilter::ModifierFilter(BHandler *target):
+	BMessageFilter(B_MODIFIERS_CHANGED),
+	fTarget(target)
 {
-  BMessage *msg;
-  //int32 key;
-  int32 modifiers;
-
-  uint8 byte;
-
-  msg = Window()->CurrentMessage();
-  if ( !msg ) {
-    BX_DEBUG(( "keydown() msg NULL" ));
-    return;
-    }
-  modifiers = msg->FindInt32("modifiers");
-#if 0
-  B_SHIFT_KEY          = 0x00000001,
-  B_COMMAND_KEY        = 0x00000002,
-  B_CONTROL_KEY        = 0x00000004,
-  B_CAPS_LOCK          = 0x00000008,
-  B_SCROLL_LOCK        = 0x00000010,
-  B_NUM_LOCK           = 0x00000020,
-  B_OPTION_KEY         = 0x00000040,
-  B_MENU_KEY           = 0x00000080,
-  B_LEFT_SHIFT_KEY     = 0x00000100,
-  B_RIGHT_SHIFT_KEY    = 0x00000200,
-  B_LEFT_COMMAND_KEY   = 0x00000400,
-  B_RIGHT_COMMAND_KEY  = 0x00000800,
-  B_LEFT_CONTROL_KEY   = 0x00001000,
-  B_RIGHT_CONTROL_KEY  = 0x00002000,
-  B_LEFT_OPTION_KEY    = 0x00004000,
-  B_RIGHT_OPTION_KEY   = 0x00008000
-#endif
-//if (modifiers) {
-//  fprintf(stderr, "# modifiers = %08x\n", (unsigned) modifiers);
-//  }
-
-  if (numBytes == 1) {
-    //fprintf(stderr, "# down: char %02xh\n", (unsigned) bytes[0]);
-    byte = bytes[0];
-    if ( byte == 0x00 ) {
-      // Ctrl-Space
-      enq_key_event(BX_KEY_CTRL_L,  BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_SPACE, BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_SPACE, BX_KEY_RELEASED);
-      enq_key_event(BX_KEY_CTRL_L,  BX_KEY_RELEASED);
-      return;
-      }
-    if ( byte == 0x1b ) {
-      // Esc
-      if (modifiers & B_CONTROL_KEY)
-        enq_key_event(BX_KEY_CTRL_L,  BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_ESC, BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_ESC, BX_KEY_RELEASED);
-      if (modifiers & B_CONTROL_KEY)
-        enq_key_event(BX_KEY_CTRL_L,  BX_KEY_RELEASED);
-      return;
-      }
-    if ( (byte >= 0x30) && (byte <= 0x39) ) {
-      // 0 .. 9
-      byte -= 0x30;
-      enq_key_event(BX_KEY_0 + byte, BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_0 + byte, BX_KEY_RELEASED);
-      return;
-      }
-    if ( (byte >= 0x41) && (byte <= 0x5A) ) {
-      // A .. Z
-      byte -= 0x41;
-      enq_key_event(BX_KEY_SHIFT_L,    BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_A + byte, BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_A + byte, BX_KEY_RELEASED);
-      enq_key_event(BX_KEY_SHIFT_L,    BX_KEY_RELEASED);
-      return;
-      }
-    if ( (byte >= 0x61) && (byte <= 0x7A) ) {
-      // a .. z
-      byte -= 0x61;
-      enq_key_event(BX_KEY_A + byte, BX_KEY_PRESSED);
-      enq_key_event(BX_KEY_A + byte, BX_KEY_RELEASED);
-      return;
-      }
-    switch (byte) {
-      case 0x20: // Space
-        enq_key_event(BX_KEY_SPACE, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SPACE, BX_KEY_RELEASED);
-        break;
-      case 0x21: // Exclamation Point
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_1,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_1,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x22: // Double Quotes
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x23: // Pound Sign
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_3,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_3,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x24: // Dollar Sign
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_4,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_4,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x25: // Percent
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_5,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_5,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x26: // Ampersand
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_7,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_7,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x27: // Single Quote
-        enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_RELEASED);
-        break;
-      case 0x28: // Left Paren
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_9,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_9,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x29: // Right Paren
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_0,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_0,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x2a: // Multiply
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_8,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_8,     BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x2b: // Add
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_EQUALS, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_EQUALS, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_RELEASED);
-        break;
-      case 0x2c: // Comma
-        enq_key_event(BX_KEY_COMMA, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_COMMA, BX_KEY_RELEASED);
-        break;
-      case 0x2d: // Minus
-        enq_key_event(BX_KEY_MINUS, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_MINUS, BX_KEY_RELEASED);
-        break;
-      case 0x2e: // Period
-        enq_key_event(BX_KEY_PERIOD, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_PERIOD, BX_KEY_RELEASED);
-        break;
-      case 0x2f: // Slash
-        enq_key_event(BX_KEY_SLASH, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SLASH, BX_KEY_RELEASED);
-        break;
-
-      case 0x3a: // Colon
-        enq_key_event(BX_KEY_SHIFT_L,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SEMICOLON, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SEMICOLON, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,     BX_KEY_RELEASED);
-        break;
-      case 0x3b: // Semi-Colon
-        enq_key_event(BX_KEY_SEMICOLON, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SEMICOLON, BX_KEY_RELEASED);
-        break;
-      case 0x3c: // Less Than
-        enq_key_event(BX_KEY_SHIFT_L,     BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_COMMA, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_COMMA, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,     BX_KEY_RELEASED);
-        break;
-      case 0x3d: // Equals
-        enq_key_event(BX_KEY_EQUALS, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_EQUALS, BX_KEY_RELEASED);
-        break;
-      case 0x3e: // Greater Than
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_PERIOD, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_PERIOD, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_RELEASED);
-        break;
-      case 0x3f: // Question Mark
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SLASH, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_SLASH, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_RELEASED);
-        break;
-      case 0x40: // At Sign
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_2,      BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_2,      BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_RELEASED);
-        break;
-
-      case 0x5b: // Left Bracket
-        enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_RELEASED);
-        break;
-      case 0x5c: // Back Slash
-        enq_key_event(BX_KEY_BACKSLASH, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_BACKSLASH, BX_KEY_RELEASED);
-        break;
-      case 0x5d: // Right Bracket
-        enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_RELEASED);
-        break;
-      case 0x5e: // Caret
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_6,      BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_6,      BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_RELEASED);
-        break;
-      case 0x5f: // Underscore
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_MINUS, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_MINUS, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-      case 0x60: // Grave Accent
-        enq_key_event(BX_KEY_GRAVE, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_GRAVE, BX_KEY_RELEASED);
-        break;
-
-      case 0x7b: // Left Brace
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_RELEASED);
-        break;
-      case 0x7c: // Verticle Bar
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_BACKSLASH, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_BACKSLASH, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,  BX_KEY_RELEASED);
-        break;
-      case 0x7d: // Right Brace
-        enq_key_event(BX_KEY_SHIFT_L,         BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L,         BX_KEY_RELEASED);
-        break;
-      case 0x7e: // Tilde
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_GRAVE, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_GRAVE, BX_KEY_RELEASED);
-        enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
-        break;
-
-      case B_BACKSPACE:
-        enq_key_event(BX_KEY_BACKSPACE, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_BACKSPACE, BX_KEY_RELEASED);
-        break;
-      case B_ENTER: //case B_RETURN:
-        enq_key_event(BX_KEY_ENTER, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_ENTER, BX_KEY_RELEASED);
-        break;
-      case B_TAB:
-        enq_key_event(BX_KEY_TAB, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_TAB, BX_KEY_RELEASED);
-        break;
-      case B_LEFT_ARROW:
-        enq_key_event(BX_KEY_LEFT, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_LEFT, BX_KEY_RELEASED);
-        break;
-      case B_RIGHT_ARROW:
-        enq_key_event(BX_KEY_RIGHT, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_RIGHT, BX_KEY_RELEASED);
-        break;
-      case B_UP_ARROW:
-        enq_key_event(BX_KEY_UP, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_UP, BX_KEY_RELEASED);
-        break;
-      case B_DOWN_ARROW:
-        enq_key_event(BX_KEY_DOWN, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_DOWN, BX_KEY_RELEASED);
-        break;
-#if 0
-      case B_FUNCTION_KEY: break;
-        msg->FindInt32("key", &key);
-        switch ( key ) {
-          case B_F1_KEY: break;
-          case B_F2_KEY: break;
-          case B_F3_KEY: break;
-          case B_F4_KEY: break;
-          case B_F5_KEY: break;
-          case B_F6_KEY: break;
-          case B_F7_KEY: break;
-          case B_F8_KEY: break;
-          case B_F9_KEY: break;
-          case B_F10_KEY: break;
-          case B_F11_KEY: break;
-          case B_F12_KEY: break;
-          case B_PRINT_KEY: break;
-          case B_SCROLL_KEY: break;
-          case B_PAUSE_KEY: break;
-          default:
-            fprintf(stderr, "# keydown() unknown function key %08xh\n",
-              (unsigned) key);
-          }
-#endif
-      case B_INSERT: break;
-        enq_key_event(BX_KEY_INSERT, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_INSERT, BX_KEY_RELEASED);
-        break;
-      case B_DELETE: break;
-        enq_key_event(BX_KEY_DELETE, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_DELETE, BX_KEY_RELEASED);
-        break;
-      case B_HOME: break;
-        enq_key_event(BX_KEY_HOME, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_HOME, BX_KEY_RELEASED);
-        break;
-      case B_END: break;
-        enq_key_event(BX_KEY_END, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_END, BX_KEY_RELEASED);
-        break;
-      case B_PAGE_UP: break;
-        enq_key_event(BX_KEY_PAGE_UP, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_PAGE_UP, BX_KEY_RELEASED);
-        break;
-      case B_PAGE_DOWN: break;
-        enq_key_event(BX_KEY_PAGE_DOWN, BX_KEY_PRESSED);
-        enq_key_event(BX_KEY_PAGE_DOWN, BX_KEY_RELEASED);
-        break;
-
-      default:
-        if ( (byte >= 0x01) && (byte <= 0x1a) ) {
-          // If the above keys dont catch this case, synthesize a
-          // Ctrl-A .. Ctrl-Z event
-          byte -= 1;
-          enq_key_event(BX_KEY_CTRL_L,     BX_KEY_PRESSED);
-          enq_key_event(BX_KEY_A + byte, BX_KEY_PRESSED);
-          enq_key_event(BX_KEY_A + byte, BX_KEY_RELEASED);
-          enq_key_event(BX_KEY_CTRL_L,     BX_KEY_RELEASED);
-          return;
-          }
-        fprintf(stderr, "# keydown: char %02xh unhandled\n",
-          (unsigned) bytes[0]);
-        return;
-      }
-    return;
-    }
-  else {
-    // ignore for now
-    fprintf(stderr, "# keydown() ignoring multibyte key\n");
-    }
-}
-
-void BochsView::KeyUp(const char *bytes, int32 numBytes)
-{
-  UNUSED(bytes);
-  UNUSED(numBytes);
-}
 
-void BochsView::Draw(BRect rect)
-{
-	DrawBitmapAsync(backing_store, rect, rect);
 }
 
-BochsView::~BochsView()
+filter_result ModifierFilter::Filter(BMessage *msg, BHandler **target)
 {
-	delete backing_store;
-	delete backing_view;
+	*target = fTarget;
+	return B_DISPATCH_MESSAGE;
 }
 
-void 
-BochsView::SetFont(const BFont *font, uint32 mask)
+void CaptureTarget::MessageReceived(BMessage *msg)
 {
-	backing_store->Lock();
-	backing_view->SetFont(font,mask);
-	backing_store->Unlock();
+	if (fMyTarget->LockLooper())
+	{
+		fMyTarget->GotCapturedInput(msg); 
+		fMyTarget->UnlockLooper();
+	}
 }
 
-void 
-BochsView::SetHighColor(uchar r, uchar g, uchar b, uchar a)
-{
-	backing_store->Lock();
-	backing_view->SetHighColor(r,g,b,a);
-	backing_store->Unlock();
-}
+// ========== class bx_gui_c definitions ==========
 
-void 
-BochsView::SetLowColor(uchar r, uchar g, uchar b, uchar a)
+void bx_gui_c::specific_init(bx_gui_c *th, int argc, char **argv,
+	unsigned tilewidth, unsigned tileheight,
+	unsigned header_bar_y)
 {
-	backing_store->Lock();
-	backing_view->SetLowColor(r,g,b,a);
-	backing_store->Unlock();
+	BX_DEBUG(("init"));
+	bApp = new BochsApplication(th, argc, argv, tilewidth, tileheight, header_bar_y, power_handler);
+	be_app->Unlock();
+	thread_id appThread = spawn_thread(BochsApplication::runme, "App thread", B_NORMAL_PRIORITY, NULL);
+	resume_thread(appThread);
 }
 
-void 
-BochsView::DrawBitmap(const BBitmap *aBitmap, BPoint where)
+void bx_gui_c::handle_events(void)
 {
-	backing_store->Lock();
-	backing_view->DrawBitmap(aBitmap,where);
-	backing_store->Unlock();
-	BRect r = aBitmap->Bounds();
-	r.OffsetBy(where);
-	Invalidate(r);
+	bView->HandleEvents();
 }
 
-void 
-BochsView::FillRect(BRect r, pattern p)
+void bx_gui_c::flush(void)
 {
-	backing_store->Lock();
-	backing_view->FillRect(r,p);
-	backing_store->Unlock();
-	Invalidate(r);
+	BX_DEBUG(("flush"));
+	if (!bView)
+	{
+		BX_DEBUG(("flush called before init"));
+		return;
+	}
+	bView->Flush();
 }
 
-
-
-  void
-enq_key_event(Bit32u key, Bit32u press_release)
+void bx_gui_c::clear_screen(void)
 {
-  if ( ((tail+1) % SCANCODE_BUFSIZE) == head ) {
-    fprintf(stderr, "# enq_key_event: buffer full\n");
-    return;
-    }
-  keyevents[tail] = key | press_release;
-  tail = (tail + 1) % SCANCODE_BUFSIZE;
+	BX_DEBUG(("clear_screen"));
+	bView->ClearScreen();
 }
 
-  Bit32u
-deq_key_event(void)
+void bx_gui_c::text_update(Bit8u *old_text, Bit8u *new_text,
+	unsigned long cursor_x, unsigned long cursor_y,
+	unsigned nrows)
 {
-  Bit32u key;
-
-  if ( head == tail ) {
-    fprintf(stderr, "# deq_key_event: buffer empty\n");
-    return(0);
-    }
-  key = keyevents[head];
-  head = (head + 1) % SCANCODE_BUFSIZE;
-  return(key);
+	BX_DEBUG(("text_update"));
+	bView->TextUpdate(old_text, new_text, cursor_x, cursor_y, nrows);
 }
 
-  unsigned char
-reverse_bitorder(unsigned char b)
+void bx_gui_c::graphics_tile_update(Bit8u *tile, unsigned x0, unsigned y0)
 {
-  unsigned char ret=0;
-  for (unsigned i=0; i<8; i++) {
-    ret |= (b & 0x01) << (7-i);
-    b >>= 1;
-    }
-  return(ret);
+	//fprintf(stderr, "# gui: graphics_update\n");
+	bView->GraphicsTileUpdate(tile, x0, y0);
 }
 
-  unsigned
-bx_gui_c::create_bitmap(const unsigned char *bmap,
-                        unsigned xdim, unsigned ydim)
+Boolean bx_gui_c::palette_change(unsigned index, unsigned red, unsigned green, unsigned blue)
 {
-  BRect rect(0.0, 0.0, xdim-1, ydim-1);
-  int32 bitslength;
-  //int32 bytesperrow;
-  unsigned char *data;
-
-  if (bx_bitmap_entries >= BX_MAX_PIXMAPS) {
-    BX_PANIC(("beos: too many pixmaps, increase BX_MAX_PIXMAPS"));
-    }
-
-  bx_bitmaps[bx_bitmap_entries].bmap =
-    new BBitmap(rect, B_MONOCHROME_1_BIT);
-
-  bitslength = bx_bitmaps[bx_bitmap_entries].bmap->BitsLength();
-  //bytesperrow = bx_bitmaps[bx_bitmap_entries].bmap->BytesPerRow();
-  data = (unsigned char *) bx_bitmaps[bx_bitmap_entries].bmap->Bits();
-  for (int32 i=0; i<bitslength; i++) {
-    data[i] = reverse_bitorder(bmap[i]);
-    }
-
-  bx_bitmaps[bx_bitmap_entries].xdim = xdim;
-  bx_bitmaps[bx_bitmap_entries].ydim = ydim;
-  if (!bx_bitmaps[bx_bitmap_entries].bmap) {
-    BX_PANIC(("beos: could not create bitmap"));
-    }
-  bx_bitmap_entries++;
-  return(bx_bitmap_entries-1); // return index as handle
+	BX_DEBUG(("palette_change"));
+	return bView->PaletteChange(index, red, green, blue);
 }
 
-  unsigned
-bx_gui_c::headerbar_bitmap(unsigned bmap_id, unsigned alignment,
-                           void (*f)(void))
+void bx_gui_c::dimension_update(unsigned x, unsigned y)
 {
-  unsigned hb_index;
-
-  if ( (bx_headerbar_entries+1) > BX_MAX_HEADERBAR_ENTRIES )
-    BX_PANIC(("beos: too many headerbar entries, increase BX_MAX_HEADERBAR_ENTRIES"));
-
-  bx_headerbar_entries++;
-  hb_index = bx_headerbar_entries - 1;
-
-  bx_headerbar_entry[hb_index].bitmap = bx_bitmaps[bmap_id].bmap;
-  bx_headerbar_entry[hb_index].xdim   = bx_bitmaps[bmap_id].xdim;
-  bx_headerbar_entry[hb_index].ydim   = bx_bitmaps[bmap_id].ydim;
-  bx_headerbar_entry[hb_index].alignment = alignment;
-  bx_headerbar_entry[hb_index].f = f;
-  if (alignment == BX_GRAVITY_LEFT) {
-    bx_headerbar_entry[hb_index].xorigin = bx_bitmap_left_xorigin;
-    bx_headerbar_entry[hb_index].yorigin = 0;
-    bx_bitmap_left_xorigin += bx_bitmaps[bmap_id].xdim;
-    }
-  else { // BX_GRAVITY_RIGHT
-    bx_bitmap_right_xorigin += bx_bitmaps[bmap_id].xdim;
-    bx_headerbar_entry[hb_index].xorigin = bx_bitmap_right_xorigin;
-    bx_headerbar_entry[hb_index].yorigin = 0;
-    }
-  return(hb_index);
+	//fprintf(stderr, "dimension_update %d x %d\n", x, y);
+	bView->DimensionUpdate(x, y);
 }
 
-  void
-bx_gui_c::replace_bitmap(unsigned hbar_id, unsigned bmap_id)
+void bx_gui_c::exit(void)
 {
-  unsigned xorigin;
-
-  bx_headerbar_entry[hbar_id].bitmap = bx_bitmaps[bmap_id].bmap;
-
-  if (bx_headerbar_entry[hbar_id].alignment == BX_GRAVITY_LEFT)
-    xorigin = bx_headerbar_entry[hbar_id].xorigin;
-  else
-    xorigin = dimension_x - bx_headerbar_entry[hbar_id].xorigin;
-  aWindow->Lock();
-  aView->set_headerbar_colors();
-  aView->DrawBitmap(bx_headerbar_entry[hbar_id].bitmap, BPoint(xorigin, 0));
-  aView->set_text_colors();
-  aWindow->Unlock();
+	BX_DEBUG(("exit"));
+	bApp->BxExit();
 }
 
-  void
-bx_gui_c::show_headerbar(void)
+void bx_gui_c::mouse_enabled_changed_specific(Boolean val)
 {
-  unsigned xorigin;
-  BPoint origin;
-
-  // clear header bar area to white
-
-  aWindow->Lock();
-  aView->set_headerbar_colors();
-  aView->FillRect(BRect(0, 0, dimension_x-1, bx_headerbar_y-1), B_SOLID_LOW);
-  for (unsigned i=0; i<bx_headerbar_entries; i++) {
-    if (bx_headerbar_entry[i].alignment == BX_GRAVITY_LEFT)
-      xorigin = bx_headerbar_entry[i].xorigin;
-    else
-      xorigin = dimension_x - bx_headerbar_entry[i].xorigin;
-    origin.Set(xorigin, 0);
-    aView->DrawBitmap( bx_headerbar_entry[i].bitmap, origin );
-    }
-  aView->set_text_colors();
-  aWindow->Unlock();
+	//fprintf(stderr, "mouse_enabled_changed to %s\n", val ? "enabled" : "disabled");
+	bView->HandleEnableMouse(val);
 }
-
 
-  void
-headerbar_click(int x, int y)
+unsigned bx_gui_c::create_bitmap(const unsigned char *bmap,
+	unsigned xdim, unsigned ydim)
 {
-  int xorigin;
-
-  // assuming y is in bounds
-  UNUSED(y);
-  for (unsigned i=0; i<bx_headerbar_entries; i++) {
-    if (bx_headerbar_entry[i].alignment == BX_GRAVITY_LEFT)
-      xorigin = bx_headerbar_entry[i].xorigin;
-    else
-      xorigin = dimension_x - bx_headerbar_entry[i].xorigin;
-    if ( (x>=xorigin) && (x<(xorigin+int(bx_headerbar_entry[i].xdim))) ) {
-      bx_headerbar_entry[i].f();
-      return;
-      }
-    }
+	BX_DEBUG(("create_bitmap"));
+	return bView->CreateBitmap(bmap, xdim, ydim);
 }
 
-
-  void
-create_vga_font(void)
+unsigned bx_gui_c::headerbar_bitmap(unsigned bmap_id, unsigned alignment, void (*f)(void))
 {
-  int32 bitslength;
-  int32 bytesperrow;
-  unsigned char *data;
-  BRect brect(0,0, 7,15);
-
-  BX_INFO(( "BeOS: creating VGA font from bitmaps" ));
-
-  // VGA font is 8wide x 16high
-  for (unsigned c=0; c<256; c++) {
-    vgafont[c] = new BBitmap(brect, B_MONOCHROME_1_BIT);
-    if (!vgafont[c]) {
-      BX_PANIC(("beos: could not create bitmap"));
-      }
-
-    bitslength = vgafont[c]->BitsLength();
-    bytesperrow = vgafont[c]->BytesPerRow();
-    data = (unsigned char *) vgafont[c]->Bits();
-    memset(data, 0, bitslength);
-    for (unsigned i=0; i<16; i++) {
-      data[i*bytesperrow] = reverse_bitorder(bx_vgafont[c].data[i]);
-      }
-    }
+	BX_DEBUG(("headerbar_bitmap"));
+	return bView->HeaderbarBitmap(bmap_id, alignment, f);
 }
 
-
-  void
-bx_gui_c::exit(void)
+void bx_gui_c::replace_bitmap(unsigned hbar_id, unsigned bmap_id)
 {
-  fprintf(stderr, "# WARNING: BEOS: bx_gui_c::exit() not implemented yet.\n");
+	BX_DEBUG(("replace_bitmap"));
+	bView->ReplaceBitmap(hbar_id, bmap_id);
 }
-
-//IRA=> Start
-// This is called whenever the mouse_enabled parameter changes.  It
-// can change because of a gui event such as clicking on the mouse-enable
-// bitmap or pressing the middle button, or from the control panel.
-// In all those cases, setting the parameter value will get you here.
 
-  void
-bx_gui_c::mouse_enabled_changed_specific (Boolean val)
+void bx_gui_c::show_headerbar(void)
 {
-  BX_DEBUG (("mouse_enabled=%d, BeOS specific code", val?1:0));
-  if (val) {
-    BX_INFO(("[x] Mouse on"));
-//    mouse_enable_x = current_x;
-//    mouse_enable_y = current_y;
-    be_app->HideCursor();
-    // Move the cursor to a 'safe' place
-//    warp_cursor(warp_home_x-current_x, warp_home_y-current_y);
-  } else {
-    BX_INFO(("[x] Mouse off"));
-    be_app->ShowCursor();
-//    warp_cursor(mouse_enable_x-current_x, mouse_enable_y-current_y);
-  }
+	BX_DEBUG(("show_headrebar"));
+	bView->ShowHeaderbar();
 }
-//IRA=> End