mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f24624f27a
Bochs/bochs/gui/beos.cc
Bryce Denney 26385f2866 - I've added lots of comments in siminterface.h, and tried to clean up 
the terminology a bit.  In particular, the term "gui" has started
  to mean different things in different contexts, so I've defined
  some more specific names for the parts of the user interface, and
  updated comments and some variable names to reflect it.  See
  siminterface.h for a more complete description of all of these.

    VGAW: VGA display window and toolbar buttons, the traditional Bochs
      display which is ported to X, win32, MacOS X, etc.  Implemented
      in gui/gui.* and platform dependent gui/*.cc files.
    CI: configuration interface that lets the user change settings such
      as floppy disk image, ne2k settings, log options.  The CI consists
      of two parts: configuration user interface (CUI) which does the
      actual rendering to the screen and handles key/mouse/menu events,
      and the siminterface object.
    CUI: configuration user interface.  This handles the user interactions
      that allow the user to configure Bochs.  To actually change any
      values it talks to the siminterface object.  One implementation of
      the CUI is the text-mode menus in gui/control.cc.  Another
      implementation is (will be) the wxWindows menus and dialogs in
      gui/wxmain.cc.
    siminterface: the glue between the CUI and the simulation code,
      accessible throughout the code by the global variable
        bx_simulator_interface_c *SIM;
      Among other things, siminterface methods allow the simulator to ask the
      CUI to display things or ask for user input, and allows the CUI
      to query and modify variables in the simulation code.


    GUI: Literally, "graphical user interface".  Until the configuration menus
      and wxWindows came along, everyone understood that "gui" referred to the
      VGA display window and the toolbar buttons because that's all there
      was.  Now that we have the wxWindows code, which implements both the VGAW
      and the CUI, while all other platforms implement only the VGAW, it's not
      so clear.  So, I'm trying to use VGAW, CI, and CUI consistently since
      they are more specific.
    control panel: This has been used as another name for the configuration
      interface.  "control panel" is also somewhat unspecific and it sounds
      like it would be graphical with buttons and sliders, but our text-mode
      thing is not graphical at all.  I've replaced "control panel" with
      "configuration interface" wherever I could find it.  In configure script,
      the --disable-control-panel option is still supported, but it politely
      suggests that you use --disable-config-interface instead.
- clean up comments in siminterface,wx* code
- add comments and examples for bx_param_* and BxEvents
- remove some obsolete stuff: notify_*_args,
  bx_simulator_interface_c::[sg]et_enabled() methods
- in siminterface.cc, move a few bx_real_sim_c methods to where they belong,
  with the rest of the methods.  No changes to the actual methods.
- remove some DOS ^M's which crept in and confused my editor.
2002-08-26 15:31:23 +00:00

1218 lines
34 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////
// $Id: beos.cc,v 1.17 2002-08-26 15:31:19 bdenney Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
//
// MandrakeSoft S.A.
// 43, rue d'Aboukir
// 75002 Paris - France
// http://www.linux-mandrake.com/
// http://www.mandrakesoft.com/
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include <app/Application.h>
#include <interface/Window.h>
#include <interface/View.h>
#include <interface/Screen.h>
#include <interface/Bitmap.h>
#include <interface/GraphicsDefs.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "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))
class BochsApplication : public BApplication {
public:
BochsApplication();
};
class BochsWindow : public BWindow {
public:
BochsWindow(BRect frame);
virtual bool QuitRequested();
virtual void FrameResized(float width, float height);
};
class BochsView : public BView {
private:
BBitmap *backing_store;
BView *backing_view;
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;
void
bx_gui_c::specific_init(bx_gui_c *th, int argc, char **argv,
unsigned tilewidth, unsigned tileheight,
unsigned header_bar_y)
{
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);
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);
myApplication = new BochsApplication();
// wait until window on screen
while (1) {
aWindow->Lock();
if (aWindow->IsHidden()) {
aWindow->Unlock();
continue;
}
aWindow->Unlock();
break;
}
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];
}
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];
create_vga_font();
}
void
bx_gui_c::handle_events(void)
{
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
}
void
bx_gui_c::flush(void)
{
if (view_attached)
aView->Flush();
}
void
bx_gui_c::clear_screen(void)
{
aWindow->Lock();
aView->FillRect(BRect(0, bx_headerbar_y, dimension_x-1, dimension_y-1), B_SOLID_LOW);
aWindow->Unlock();
}
void
bx_gui_c::text_update(Bit8u *old_text, Bit8u *new_text,
unsigned long cursor_x, unsigned long cursor_y,
Bit16u cursor_state, unsigned nrows)
{
unsigned i, x, y;
BPoint point;
unsigned char achar;
unsigned nchars, ncols;
aWindow->Lock();
// Number of characters on screen, variable number of rows
ncols = dimension_x/8;
nchars = ncols*nrows;
// first draw over character at original block cursor location
if ( (prev_block_cursor_y*ncols + prev_block_cursor_x) < nchars ) {
achar = new_text[(prev_block_cursor_y*ncols + 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) % ncols;
y = (i/2) / ncols;
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*ncols + cursor_x) < nchars ) {
achar = new_text[(cursor_y*ncols + 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();
}
int
bx_gui_c::get_clipboard_text(Bit8u **bytes, Bit32s *nbytes)
{
return 0;
}
int
bx_gui_c::set_clipboard_text(char *text_snapshot, Bit32u len)
{
return 0;
}
void
bx_gui_c::graphics_tile_update(Bit8u *tile, unsigned x0, unsigned y0)
{
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();
}
Boolean
bx_gui_c::palette_change(unsigned index, unsigned red, unsigned green, unsigned blue)
{
cmap_index[index] = screen->IndexForColor(
red, green, blue);
return(1);
}
void
bx_gui_c::dimension_update(unsigned x, unsigned y, unsigned fheight)
{
if (fheight > 0) {
if (fheight != 16) {
y = y * 16 / fheight;
}
}
aWindow->Lock();
aWindow->ResizeTo(x, y + bx_headerbar_y);
aWindow->Unlock();
}
//////////////////////////////////////////////////////
void
GUI_end()
{
//myApplication->Run();
delete(myApplication);
}
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);
// 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();
}
//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)
{
}
bool BochsWindow::QuitRequested()
{
be_app->PostMessage(B_QUIT_REQUESTED);
return(TRUE);
}
void
BochsWindow::FrameResized(float width, float height)
{
dimension_x = unsigned(width);
dimension_y = unsigned(height) + bx_headerbar_y;
if ( bx_gui_c_ptr )
bx_gui_c_ptr->show_headerbar();
}
//------------------------------
BochsView::BochsView(BRect rect, char *name)
: BView(rect, name, B_FOLLOW_ALL, B_WILL_DRAW)
{
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);
}
void
BochsView::set_text_colors(void)
{
aView->SetHighColor(255, 255, 255);
aView->SetLowColor(0, 0, 0);
}
void
BochsView::set_inv_text_colors(void)
{
aView->SetHighColor(0, 0, 0);
aView->SetLowColor(255, 255, 255);
}
void
BochsView::set_headerbar_colors(void)
{
aView->SetHighColor(0, 0, 0);
aView->SetLowColor(255, 255, 255);
}
void BochsView::AttachedToWindow()
{
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;
}
void BochsView::MouseDown(BPoint point)
{
UNUSED(point);
if (point.y < BX_HEADER_BAR_Y) {
headerbar_click(int(point.x), int(point.y));
return;
}
BX_DEBUG(("mousedown()"));
}
void BochsView::MouseUp(BPoint point)
{
UNUSED(point);
// currently a place holder function
BX_DEBUG(( "mouseup()" ));
BView::MouseUp(point);
}
void BochsView::MouseMoved(BPoint point,
uint32 transit, const BMessage *message)
{
UNUSED(point);
UNUSED(transit);
UNUSED(message);
BX_DEBUG(( "mousemoved()" ));
}
void BochsView::KeyDown(const char *bytes, int32 numBytes)
{
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()
{
delete backing_store;
delete backing_view;
}
void
BochsView::SetFont(const BFont *font, uint32 mask)
{
backing_store->Lock();
backing_view->SetFont(font,mask);
backing_store->Unlock();
}
void
BochsView::SetHighColor(uchar r, uchar g, uchar b, uchar a)
{
backing_store->Lock();
backing_view->SetHighColor(r,g,b,a);
backing_store->Unlock();
}
void
BochsView::SetLowColor(uchar r, uchar g, uchar b, uchar a)
{
backing_store->Lock();
backing_view->SetLowColor(r,g,b,a);
backing_store->Unlock();
}
void
BochsView::DrawBitmap(const BBitmap *aBitmap, BPoint where)
{
backing_store->Lock();
backing_view->DrawBitmap(aBitmap,where);
backing_store->Unlock();
BRect r = aBitmap->Bounds();
r.OffsetBy(where);
Invalidate(r);
}
void
BochsView::FillRect(BRect r, pattern p)
{
backing_store->Lock();
backing_view->FillRect(r,p);
backing_store->Unlock();
Invalidate(r);
}
void
enq_key_event(Bit32u key, Bit32u press_release)
{
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;
}
Bit32u
deq_key_event(void)
{
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);
}
unsigned char
reverse_bitorder(unsigned char b)
{
unsigned char ret=0;
for (unsigned i=0; i<8; i++) {
ret |= (b & 0x01) << (7-i);
b >>= 1;
}
return(ret);
}
unsigned
bx_gui_c::create_bitmap(const unsigned char *bmap,
unsigned xdim, unsigned ydim)
{
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
}
unsigned
bx_gui_c::headerbar_bitmap(unsigned bmap_id, unsigned alignment,
void (*f)(void))
{
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);
}
void
bx_gui_c::replace_bitmap(unsigned hbar_id, unsigned bmap_id)
{
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();
}
void
bx_gui_c::show_headerbar(void)
{
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();
}
void
headerbar_click(int x, int y)
{
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;
}
}
}
void
create_vga_font(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]);
}
}
}
void
bx_gui_c::exit(void)
{
fprintf(stderr, "# WARNING: BEOS: bx_gui_c::exit() not implemented yet.\n");
}
//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 configuration interface.
// In all those cases, setting the parameter value will get you here.
void
bx_gui_c::mouse_enabled_changed_specific (Boolean val)
{
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);
}
}
//IRA=> End
Reference in New Issue View Git Blame Copy Permalink