?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- compilation fixes for MSVC toolkit 2003
[bochs-mirror.git] / gui / beos.cc
blob240667773874cc8dfc32ce54b2a53789d6fabdf7
1 /////////////////////////////////////////////////////////////////////////
2 // $Id: beos.cc,v 1.32 2008/02/15 22:05:40 sshwarts Exp $
3 /////////////////////////////////////////////////////////////////////////
4 //
5 // Copyright (C) 2001 MandrakeSoft S.A.
6 //
7 // MandrakeSoft S.A.
8 // 43, rue d'Aboukir
9 // 75002 Paris - France
10 // http://www.linux-mandrake.com/
11 // http://www.mandrakesoft.com/
12 //
13 // This library is free software; you can redistribute it and/or
14 // modify it under the terms of the GNU Lesser General Public
15 // License as published by the Free Software Foundation; either
16 // version 2 of the License, or (at your option) any later version.
17 //
18 // This library is distributed in the hope that it will be useful,
19 // but WITHOUT ANY WARRANTY; without even the implied warranty of
20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 // Lesser General Public License for more details.
22 //
23 // You should have received a copy of the GNU Lesser General Public
24 // License along with this library; if not, write to the Free Software
25 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26
27
28 // Define BX_PLUGGABLE in files that can be compiled into plugins. For
29 // platforms that require a special tag on exported symbols, BX_PLUGGABLE
30 // is used to know when we are exporting symbols and when we are importing.
31 #define BX_PLUGGABLE
32
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <ctype.h>
36 #include <string.h>
37
38 #include "bochs.h"
39 #include "iodev.h"
40 #if BX_WITH_BEOS
41
42 #include <app/Application.h>
43 #include <interface/Window.h>
44 #include <interface/View.h>
45 #include <interface/Screen.h>
46 #include <interface/Bitmap.h>
47 #include <interface/GraphicsDefs.h>
48
49 //#include "icon_bochs.h"
50 #include "font/vga.bitmap.h"
51
52 class bx_beos_gui_c : public bx_gui_c {
53 public:
54 bx_beos_gui_c (void) {}
55 DECLARE_GUI_VIRTUAL_METHODS()
56 };
57
58 // declare one instance of the gui object and call macro to insert the
59 // plugin code
60 static bx_beos_gui_c *theGui = NULL;
61 IMPLEMENT_GUI_PLUGIN_CODE(beos)
62
63 #define LOG_THIS theGui->
64
65 #define PAD_NEAREST(n, quantum) ((((n) + ((quantum) - 1)) / (n)) * (n))
66
67 class BochsApplication : public BApplication {
68 public:
69 BochsApplication();
70 };
71
72 class BochsWindow : public BWindow {
73 public:
74 BochsWindow(BRect frame);
75 virtual bool QuitRequested();
76 virtual void FrameResized(float width, float height);
77 };
78
79 class BochsView : public BView {
80 private:
81 BBitmap *backing_store;
82 BView *backing_view;
83
84 public:
85 BochsView(BRect frame, char *name);
86 ~BochsView();
87 virtual void AttachedToWindow();
88 virtual void Draw(BRect updateRect);
89 virtual void KeyDown(const char *bytes, int32 numBytes);
90 virtual void KeyUp(const char *bytes, int32 numBytes);
91 virtual void MouseDown(BPoint point);
92 virtual void MouseUp(BPoint point);
93 virtual void MouseMoved(BPoint point,
94 uint32 transit, const BMessage *message);
95 void DrawBitmap(const BBitmap *aBitmap, BPoint where);
96 void FillRect(BRect r, pattern p = B_SOLID_HIGH);
97 void SetHighColor(uchar r, uchar g, uchar b, uchar a = 255);
98 void SetLowColor(uchar r, uchar g, uchar b, uchar a = 255);
99 void SetFont(const BFont *font, uint32 mask = B_FONT_ALL);
100 void set_text_colors(void);
101 void set_inv_text_colors(void);
102 void set_headerbar_colors(void);
103 };
104
105
106 void GUI_end(void);
107 void enq_key_event(Bit32u key, Bit32u press_release);
108 Bit32u deq_key_event(void);
109 #define SCANCODE_BUFSIZE 20
110 static Bit32u keyevents[SCANCODE_BUFSIZE];
111 static unsigned head=0, tail=0;
112 static bool view_attached = 0;
113
114 static BochsApplication *myApplication = NULL;
115 static BochsWindow *aWindow = NULL;
116 static BochsView *aView = NULL;
117 static BView *canvas = NULL;
118 static uint8 cmap_index[256]; // indeces into system colormap
119
120 static BRect rect;
121 static BPoint image_origin;
122 static BBitmap *image = NULL;
123 static BScreen *screen;
124 static unsigned long rowsize_padded=0;
125 static uint8 *rawdata = NULL;
126
127 static unsigned int text_rows=25, text_cols=80;
128 static unsigned font_width, font_height;
129 static Bit8u blank_line[80];
130 static unsigned dimension_x, dimension_y;
131
132 //static unsigned imDepth, imWide, imBPP;
133
134 // current cursor coordinates
135 //IRA=> Start
136 static BPoint current;
137 static BPoint previous;
138 static Bit8u mouse_button_state = 0;
139 //IRA=> End
140 //static int prev_x=-1, prev_y=-1;
141 //static int current_x=-1, current_y=-1;
142
143 static unsigned prev_block_cursor_x=0;
144 static unsigned prev_block_cursor_y=0;
145
146 static void headerbar_click(int x, int y);
147
148 Bit8u ascii_to_scancode[0x7f] = {
149 0, 0, 0, 0, 0, 0, 0, 0,
150 0, 0, 0, 0, 0, 0, 0, 0,
151 0, 0, 0, 0, 0, 0, 0, 0,
152 0, 0, 0, 0, 0, 0, 0, 0,
153 0x39, 0x02, 0x28, 0x04, 0x05, 0x06, 0x08, 0x28, /* !"#$%&' */
154 0x0a, 0x0b, 0x09, 0x0d, 0x33, 0x0c, 0x34, 0x35, /* ()*+,-./ */
155 0x0b, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, /* 01234567 */
156 0x09, 0x0a, 0x27, 0x27, 0x33, 0x0d, 0x34, 0x35, /* 89:;<=>? */
157 0x03, 0x1e, 0x30, 0x2e, 0x20, 0x12, 0x21, 0x22, /* @ABCDEFG */
158 0x23, 0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18, /* HIJKLMNO */
159 0x19, 0x10, 0x13, 0x1f, 0x14, 0x16, 0x2f, 0x11, /* PQRSTUVW */
160 0x2d, 0x15, 0x2c, 0x1a, 0x2b, 0x1b, 0x07, 0x0c, /* XYZ[\]^_ */
161 0x29, 0x1e, 0x30, 0x2e, 0x20, 0x12, 0x21, 0x22, /* `abcdefg */
162 0x23, 0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18, /* hijklmno */
163 0x19, 0x10, 0x13, 0x1f, 0x14, 0x16, 0x2f, 0x11, /* pqrstuvw */
164 0x2d, 0x15, 0x2c, 0x1a, 0x2b, 0x1b, 0x29 /* xyz{|}~ */
165 };
166
167 extern Bit8u graphics_snapshot[32 * 1024];
168 //extern pc_keyb_c *pc_keyboard;
169
170
171
172
173 unsigned col_vals[256], curr_foreground, curr_background;
174
175 static unsigned x_tilesize, y_tilesize;
176
177 struct {
178 BBitmap *bmap;
179 unsigned xdim;
180 unsigned ydim;
181 } bx_bitmaps[BX_MAX_PIXMAPS];
182 unsigned bx_bitmap_entries = 0;
183
184 static struct {
185 BBitmap *bitmap;
186 unsigned xdim;
187 unsigned ydim;
188 unsigned xorigin;
189 unsigned yorigin;
190 unsigned alignment;
191 void (*f)(void);
192 } bx_headerbar_entry[BX_MAX_HEADERBAR_ENTRIES];
193 static unsigned bx_headerbar_y = 0;
194 static unsigned bx_headerbar_entries = 0;
195 static unsigned bx_bitmap_left_xorigin = 0; // pixels from left
196 static unsigned bx_bitmap_right_xorigin = 0; // pixels from right
197
198 static void headerbar_click(int x, int y);
199 static unsigned char reverse_bitorder(unsigned char b);
200 static void create_vga_font(void);
201 static BBitmap *vgafont[256];
202
203 void
204 bx_beos_gui_c::specific_init(int argc, char **argv,
205 unsigned tilewidth, unsigned tileheight,
206 unsigned header_bar_y)
207 {
208 UNUSED(argc);
209 UNUSED(argv);
210
211 put("BGUI");
212
213 if (SIM->get_param_bool(BXPN_PRIVATE_COLORMAP)->get()) {
214 BX_INFO(("BeOS: private_colormap option not handled yet."));
215 }
216
217 x_tilesize = tilewidth;
218 y_tilesize = tileheight;
219 bx_headerbar_y = header_bar_y;
220
221 for (int i=0; i<80; i++) {
222 blank_line[i] = ' ';
223 }
224
225 font_width = 8;
226 font_height = 16;
227
228 // width = columns * font_width;
229 // height = rows * font_height;
230
231 BX_INFO(("font_width = %u", (unsigned) font_width));
232 BX_INFO(("font_height = %u", (unsigned) font_height));
233
234 // Create pixmap of depth 1 (bitmap) for icon
235 // icon_pixmap = XCreateBitmapFromData(bx_x_display, win,
236 // (char *) bochs_icon_bits, bochs_icon_width, bochs_icon_height);
237
238 curr_background = 0;
239 // XSetBackground(bx_x_display, gc, col_vals[curr_background]);
240 curr_foreground = 1;
241 // XSetForeground(bx_x_display, gc, col_vals[curr_foreground]);
242 //XGrabPointer(bx_x_display, win, True, 0, GrabModeAsync, GrabModeAsync,
243 // win, None, CurrentTime);
244 //XFlush(bx_x_display);
245
246 myApplication = new BochsApplication();
247
248 // wait until window on screen
249 while (1) {
250 aWindow->Lock();
251 if (aWindow->IsHidden()) {
252 aWindow->Unlock();
253 continue;
254 }
255 aWindow->Unlock();
256 break;
257 }
258
259 screen = new BScreen;
260 // start out with all color map indeces pointing to Black
261 cmap_index[0] = screen->IndexForColor(0, 0, 0);
262 for (unsigned i=1; i<256; i++) {
263 cmap_index[i] = cmap_index[0];
264 }
265
266 rect.Set(0,0, x_tilesize-1, y_tilesize-1);
267 image = new BBitmap(rect, B_COLOR_8_BIT);
268 rowsize_padded = PAD_NEAREST(x_tilesize, sizeof(int32));
269 rawdata = new uint8[rowsize_padded * y_tilesize];
270
271 create_vga_font();
272 }
273
274 void bx_beos_gui_c::handle_events(void)
275 {
276 Bit32u key;
277
278 while (head != tail) {
279 key = deq_key_event();
280 DEV_kbd_gen_scancode(key);
281 }
282 //IRA=> Start
283 if (aView) {
284 unsigned long buttons;
285 aView->LockLooper();
286 aView->GetMouse(&current, &buttons, false);
287 aView->UnlockLooper();
288
289 Bit8u newstate = 0; //please note: 2nd and 3rd button are mapped the same
290 if (buttons & B_PRIMARY_MOUSE_BUTTON)
291 newstate |= 0x01;
292 if (buttons & B_SECONDARY_MOUSE_BUTTON)
293 newstate |= 0x02;
294 if (buttons & B_TERTIARY_MOUSE_BUTTON)
295 newstate |= 0x02;
296
297 if (current != previous || mouse_button_state != newstate) {
298 int dx = (int)(current.x - previous.x) *2;
299 int dy = -(int)((current.y - previous.y) *2);
300 DEV_mouse_motion(dx, dy, newstate);
301 mouse_button_state = newstate;
302 previous = current;
303 }
304 }
305 //IRA=> End
306 }
307
308 void bx_beos_gui_c::flush(void)
309 {
310 if (view_attached) aView->Flush();
311 }
312
313 void bx_beos_gui_c::clear_screen(void)
314 {
315 aWindow->Lock();
316 aView->FillRect(BRect(0, bx_headerbar_y, dimension_x-1, dimension_y-1), B_SOLID_LOW);
317 aWindow->Unlock();
318 }
319
320 void bx_beos_gui_c::text_update(Bit8u *old_text, Bit8u *new_text,
321 unsigned long cursor_x, unsigned long cursor_y,
322 bx_vga_tminfo_t tm_info)
323 {
324 unsigned i, x, y;
325 BPoint point;
326 unsigned char achar;
327 unsigned nchars;
328
329 aWindow->Lock();
330
331 // Number of characters on screen, variable number of rows
332 nchars = text_cols * text_rows;
333
334 // first draw over character at original block cursor location
335 if ((prev_block_cursor_y*text_cols + prev_block_cursor_x) < nchars) {
336 achar = new_text[(prev_block_cursor_y*text_cols + prev_block_cursor_x)*2];
337 point.Set(prev_block_cursor_x*8, prev_block_cursor_y*16 + bx_headerbar_y);
338 aView->DrawBitmap(vgafont[achar], point);
339 }
340
341 for (i=0; i<nchars*2; i+=2) {
342 if ((old_text[i]!=new_text[i]) ||
343 (old_text[i+1]!=new_text[i+1]))
344 {
345 achar = new_text[i];
346
347 x = (i/2) % text_cols;
348 y = (i/2) / text_cols;
349
350 point.Set(x*8, y*16 + bx_headerbar_y);
351 aView->DrawBitmap(vgafont[achar], point);
352 }
353 }
354
355 prev_block_cursor_x = cursor_x;
356 prev_block_cursor_y = cursor_y;
357
358 // now draw character at new block cursor location in reverse
359 if ((cursor_y*text_cols + cursor_x) < nchars) {
360 achar = new_text[(cursor_y*text_cols + cursor_x)*2];
361 point.Set(cursor_x*8, cursor_y*16 + bx_headerbar_y);
362 aView->set_inv_text_colors();
363 aView->DrawBitmap(vgafont[achar], point);
364 aView->set_text_colors();
365 }
366
367 aWindow->Unlock();
368 }
369
370 int bx_beos_gui_c::get_clipboard_text(Bit8u **bytes, Bit32s *nbytes)
371 {
372 return 0;
373 }
374
375 int bx_beos_gui_c::set_clipboard_text(char *text_snapshot, Bit32u len)
376 {
377 return 0;
378 }
379
380 void bx_beos_gui_c::graphics_tile_update(Bit8u *tile, unsigned x0, unsigned y0)
381 {
382 for (unsigned y=0; y<y_tilesize; y++) {
383 for (unsigned x=0; x<x_tilesize; x++) {
384 rawdata[y*rowsize_padded + x] = cmap_index[ tile[y*x_tilesize + x] ];
385 }
386 }
387 aWindow->Lock();
388 image->SetBits(rawdata, rowsize_padded * y_tilesize, 0, B_COLOR_8_BIT);
389 image_origin.Set(x0, y0 + bx_headerbar_y);
390
391 aView->DrawBitmap(image, image_origin);
392 aWindow->Unlock();
393 }
394
395 bx_bool bx_beos_gui_c::palette_change(unsigned index, unsigned red, unsigned green, unsigned blue)
396 {
397 cmap_index[index] = screen->IndexForColor(red, green, blue);
398 return(1);
399 }
400
401 void bx_beos_gui_c::dimension_update(unsigned x, unsigned y, unsigned fheight, unsigned fwidth, unsigned bpp)
402 {
403 if (bpp > 8) {
404 BX_PANIC(("%d bpp graphics mode not supported yet", bpp));
405 }
406 if (fheight > 0) {
407 text_cols = x / fwidth;
408 text_rows = y / fheight;
409 if (fwidth != 8) {
410 x = x * 8 / fwidth;
411 }
412 if (fheight != 16) {
413 y = y * 16 / fheight;
414 }
415 }
416 aWindow->Lock();
417 aWindow->ResizeTo(x, y + bx_headerbar_y);
418 aWindow->Unlock();
419 }
420
421
422 //////////////////////////////////////////////////////
423
424 void GUI_end()
425 {
426 //myApplication->Run();
427 delete(myApplication);
428 }
429
430 BochsApplication::BochsApplication()
431 : BApplication("application/x-vnd.Be-Bochs")
432 {
433 BRect aRect;
434
435 int left, right, top, bottom;
436 left = 5;
437 top = 80;
438 dimension_x = 640;
439 dimension_y = 480 + bx_headerbar_y;
440 right = left + dimension_x - 1;
441 bottom = top + dimension_y - 1;
442
443 // set up a rectangle and instantiate a new window
444 aRect.Set(left, top, right, bottom);
445 aWindow = new BochsWindow(aRect);
446
447 // set up a rectangle and instantiate a new view
448 // view rect should be same size as window rect but with left top at (0, 0)
449 aRect.OffsetTo(B_ORIGIN);
450 aView = new BochsView(aRect, "BochsView");
451 aView->SetViewColor(0, 0, 0);
452
453 aView->set_text_colors();
454
455 // add view to window
456 aWindow->AddChild(aView);
457
458 // make window visible
459 aWindow->Show();
460 }
461
462 //void set_palette_entry(long i,rgb_color c);
463
464 BochsWindow::BochsWindow(BRect frame)
465 : BWindow(frame, "BeBochs V1.3.pre compiled Bernd Korz", B_TITLED_WINDOW, B_NOT_RESIZABLE)
466 {
467 }
468
469 bool BochsWindow::QuitRequested()
470 {
471 be_app->PostMessage(B_QUIT_REQUESTED);
472 return(TRUE);
473 }
474
475 void BochsWindow::FrameResized(float width, float height)
476 {
477 dimension_x = unsigned(width);
478 dimension_y = unsigned(height) + bx_headerbar_y;
479 theGui->show_headerbar();
480 }
481
482 //------------------------------
483
484 BochsView::BochsView(BRect rect, char *name)
485 : BView(rect, name, B_FOLLOW_ALL, B_WILL_DRAW)
486 {
487 backing_store = new BBitmap(rect, B_BITMAP_ACCEPTS_VIEWS, B_COLOR_8_BIT);
488 backing_view = new BView(rect,"backing store", B_FOLLOW_ALL, B_WILL_DRAW);
489 backing_store->AddChild(backing_view);
490 }
491
492 void BochsView::set_text_colors(void)
493 {
494 aView->SetHighColor(255, 255, 255);
495 aView->SetLowColor(0, 0, 0);
496 }
497
498 void BochsView::set_inv_text_colors(void)
499 {
500 aView->SetHighColor(0, 0, 0);
501 aView->SetLowColor(255, 255, 255);
502 }
503
504 void BochsView::set_headerbar_colors(void)
505 {
506 aView->SetHighColor(0, 0, 0);
507 aView->SetLowColor(255, 255, 255);
508 }
509
510 void BochsView::AttachedToWindow()
511 {
512 BFont font(be_fixed_font);
513
514 aWindow->Lock();
515 font.SetSize(16);
516 font.SetFlags(B_DISABLE_ANTIALIASING);
517 aView->SetFont(&font);
518
519 aView->MakeFocus(true);
520 aWindow->Unlock();
521
522 view_attached = 1;
523 }
524
525 void BochsView::MouseDown(BPoint point)
526 {
527 UNUSED(point);
528 if (point.y < BX_HEADER_BAR_Y) {
529 headerbar_click(int(point.x), int(point.y));
530 return;
531 }
532 BX_DEBUG(("mousedown()"));
533 }
534
535 void BochsView::MouseUp(BPoint point)
536 {
537 UNUSED(point);
538 // currently a place holder function
539 BX_DEBUG(("mouseup()"));
540 BView::MouseUp(point);
541 }
542
543 void BochsView::MouseMoved(BPoint point,
544 uint32 transit, const BMessage *message)
545 {
546 UNUSED(point);
547 UNUSED(transit);
548 UNUSED(message);
549 BX_DEBUG(("mousemoved()"));
550 }
551
552 void BochsView::KeyDown(const char *bytes, int32 numBytes)
553 {
554 BMessage *msg;
555 //int32 key;
556 int32 modifiers;
557
558 uint8 byte;
559
560 msg = Window()->CurrentMessage();
561 if (!msg) {
562 BX_DEBUG(("keydown() msg NULL"));
563 return;
564 }
565 modifiers = msg->FindInt32("modifiers");
566 #if 0
567 B_SHIFT_KEY = 0x00000001,
568 B_COMMAND_KEY = 0x00000002,
569 B_CONTROL_KEY = 0x00000004,
570 B_CAPS_LOCK = 0x00000008,
571 B_SCROLL_LOCK = 0x00000010,
572 B_NUM_LOCK = 0x00000020,
573 B_OPTION_KEY = 0x00000040,
574 B_MENU_KEY = 0x00000080,
575 B_LEFT_SHIFT_KEY = 0x00000100,
576 B_RIGHT_SHIFT_KEY = 0x00000200,
577 B_LEFT_COMMAND_KEY = 0x00000400,
578 B_RIGHT_COMMAND_KEY = 0x00000800,
579 B_LEFT_CONTROL_KEY = 0x00001000,
580 B_RIGHT_CONTROL_KEY = 0x00002000,
581 B_LEFT_OPTION_KEY = 0x00004000,
582 B_RIGHT_OPTION_KEY = 0x00008000
583 #endif
584 //if (modifiers) {
585 // fprintf(stderr, "# modifiers = %08x\n", (unsigned) modifiers);
586 //}
587
588 if (numBytes == 1) {
589 //fprintf(stderr, "# down: char %02xh\n", (unsigned) bytes[0]);
590 byte = bytes[0];
591 if (byte == 0x00) {
592 // Ctrl-Space
593 enq_key_event(BX_KEY_CTRL_L, BX_KEY_PRESSED);
594 enq_key_event(BX_KEY_SPACE, BX_KEY_PRESSED);
595 enq_key_event(BX_KEY_SPACE, BX_KEY_RELEASED);
596 enq_key_event(BX_KEY_CTRL_L, BX_KEY_RELEASED);
597 return;
598 }
599 if (byte == 0x1b) {
600 // Esc
601 if (modifiers & B_CONTROL_KEY)
602 enq_key_event(BX_KEY_CTRL_L, BX_KEY_PRESSED);
603 enq_key_event(BX_KEY_ESC, BX_KEY_PRESSED);
604 enq_key_event(BX_KEY_ESC, BX_KEY_RELEASED);
605 if (modifiers & B_CONTROL_KEY)
606 enq_key_event(BX_KEY_CTRL_L, BX_KEY_RELEASED);
607 return;
608 }
609 if ((byte >= 0x30) && (byte <= 0x39)) {
610 // 0 .. 9
611 byte -= 0x30;
612 enq_key_event(BX_KEY_0 + byte, BX_KEY_PRESSED);
613 enq_key_event(BX_KEY_0 + byte, BX_KEY_RELEASED);
614 return;
615 }
616 if ((byte >= 0x41) && (byte <= 0x5A)) {
617 // A .. Z
618 byte -= 0x41;
619 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
620 enq_key_event(BX_KEY_A + byte, BX_KEY_PRESSED);
621 enq_key_event(BX_KEY_A + byte, BX_KEY_RELEASED);
622 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
623 return;
624 }
625 if ((byte >= 0x61) && (byte <= 0x7A)) {
626 // a .. z
627 byte -= 0x61;
628 enq_key_event(BX_KEY_A + byte, BX_KEY_PRESSED);
629 enq_key_event(BX_KEY_A + byte, BX_KEY_RELEASED);
630 return;
631 }
632 switch (byte) {
633 case 0x20: // Space
634 enq_key_event(BX_KEY_SPACE, BX_KEY_PRESSED);
635 enq_key_event(BX_KEY_SPACE, BX_KEY_RELEASED);
636 break;
637 case 0x21: // Exclamation Point
638 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
639 enq_key_event(BX_KEY_1, BX_KEY_PRESSED);
640 enq_key_event(BX_KEY_1, BX_KEY_RELEASED);
641 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
642 break;
643 case 0x22: // Double Quotes
644 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
645 enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_PRESSED);
646 enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_RELEASED);
647 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
648 break;
649 case 0x23: // Pound Sign
650 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
651 enq_key_event(BX_KEY_3, BX_KEY_PRESSED);
652 enq_key_event(BX_KEY_3, BX_KEY_RELEASED);
653 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
654 break;
655 case 0x24: // Dollar Sign
656 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
657 enq_key_event(BX_KEY_4, BX_KEY_PRESSED);
658 enq_key_event(BX_KEY_4, BX_KEY_RELEASED);
659 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
660 break;
661 case 0x25: // Percent
662 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
663 enq_key_event(BX_KEY_5, BX_KEY_PRESSED);
664 enq_key_event(BX_KEY_5, BX_KEY_RELEASED);
665 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
666 break;
667 case 0x26: // Ampersand
668 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
669 enq_key_event(BX_KEY_7, BX_KEY_PRESSED);
670 enq_key_event(BX_KEY_7, BX_KEY_RELEASED);
671 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
672 break;
673 case 0x27: // Single Quote
674 enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_PRESSED);
675 enq_key_event(BX_KEY_SINGLE_QUOTE, BX_KEY_RELEASED);
676 break;
677 case 0x28: // Left Paren
678 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
679 enq_key_event(BX_KEY_9, BX_KEY_PRESSED);
680 enq_key_event(BX_KEY_9, BX_KEY_RELEASED);
681 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
682 break;
683 case 0x29: // Right Paren
684 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
685 enq_key_event(BX_KEY_0, BX_KEY_PRESSED);
686 enq_key_event(BX_KEY_0, BX_KEY_RELEASED);
687 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
688 break;
689 case 0x2a: // Multiply
690 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
691 enq_key_event(BX_KEY_8, BX_KEY_PRESSED);
692 enq_key_event(BX_KEY_8, BX_KEY_RELEASED);
693 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
694 break;
695 case 0x2b: // Add
696 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
697 enq_key_event(BX_KEY_EQUALS, BX_KEY_PRESSED);
698 enq_key_event(BX_KEY_EQUALS, BX_KEY_RELEASED);
699 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
700 break;
701 case 0x2c: // Comma
702 enq_key_event(BX_KEY_COMMA, BX_KEY_PRESSED);
703 enq_key_event(BX_KEY_COMMA, BX_KEY_RELEASED);
704 break;
705 case 0x2d: // Minus
706 enq_key_event(BX_KEY_MINUS, BX_KEY_PRESSED);
707 enq_key_event(BX_KEY_MINUS, BX_KEY_RELEASED);
708 break;
709 case 0x2e: // Period
710 enq_key_event(BX_KEY_PERIOD, BX_KEY_PRESSED);
711 enq_key_event(BX_KEY_PERIOD, BX_KEY_RELEASED);
712 break;
713 case 0x2f: // Slash
714 enq_key_event(BX_KEY_SLASH, BX_KEY_PRESSED);
715 enq_key_event(BX_KEY_SLASH, BX_KEY_RELEASED);
716 break;
717
718 case 0x3a: // Colon
719 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
720 enq_key_event(BX_KEY_SEMICOLON, BX_KEY_PRESSED);
721 enq_key_event(BX_KEY_SEMICOLON, BX_KEY_RELEASED);
722 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
723 break;
724 case 0x3b: // Semi-Colon
725 enq_key_event(BX_KEY_SEMICOLON, BX_KEY_PRESSED);
726 enq_key_event(BX_KEY_SEMICOLON, BX_KEY_RELEASED);
727 break;
728 case 0x3c: // Less Than
729 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
730 enq_key_event(BX_KEY_COMMA, BX_KEY_PRESSED);
731 enq_key_event(BX_KEY_COMMA, BX_KEY_RELEASED);
732 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
733 break;
734 case 0x3d: // Equals
735 enq_key_event(BX_KEY_EQUALS, BX_KEY_PRESSED);
736 enq_key_event(BX_KEY_EQUALS, BX_KEY_RELEASED);
737 break;
738 case 0x3e: // Greater Than
739 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
740 enq_key_event(BX_KEY_PERIOD, BX_KEY_PRESSED);
741 enq_key_event(BX_KEY_PERIOD, BX_KEY_RELEASED);
742 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
743 break;
744 case 0x3f: // Question Mark
745 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
746 enq_key_event(BX_KEY_SLASH, BX_KEY_PRESSED);
747 enq_key_event(BX_KEY_SLASH, BX_KEY_RELEASED);
748 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
749 break;
750 case 0x40: // At Sign
751 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
752 enq_key_event(BX_KEY_2, BX_KEY_PRESSED);
753 enq_key_event(BX_KEY_2, BX_KEY_RELEASED);
754 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
755 break;
756
757 case 0x5b: // Left Bracket
758 enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_PRESSED);
759 enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_RELEASED);
760 break;
761 case 0x5c: // Back Slash
762 enq_key_event(BX_KEY_BACKSLASH, BX_KEY_PRESSED);
763 enq_key_event(BX_KEY_BACKSLASH, BX_KEY_RELEASED);
764 break;
765 case 0x5d: // Right Bracket
766 enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_PRESSED);
767 enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_RELEASED);
768 break;
769 case 0x5e: // Caret
770 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
771 enq_key_event(BX_KEY_6, BX_KEY_PRESSED);
772 enq_key_event(BX_KEY_6, BX_KEY_RELEASED);
773 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
774 break;
775 case 0x5f: // Underscore
776 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
777 enq_key_event(BX_KEY_MINUS, BX_KEY_PRESSED);
778 enq_key_event(BX_KEY_MINUS, BX_KEY_RELEASED);
779 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
780 break;
781 case 0x60: // Grave Accent
782 enq_key_event(BX_KEY_GRAVE, BX_KEY_PRESSED);
783 enq_key_event(BX_KEY_GRAVE, BX_KEY_RELEASED);
784 break;
785
786 case 0x7b: // Left Brace
787 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
788 enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_PRESSED);
789 enq_key_event(BX_KEY_LEFT_BRACKET, BX_KEY_RELEASED);
790 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
791 break;
792 case 0x7c: // Verticle Bar
793 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
794 enq_key_event(BX_KEY_BACKSLASH, BX_KEY_PRESSED);
795 enq_key_event(BX_KEY_BACKSLASH, BX_KEY_RELEASED);
796 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
797 break;
798 case 0x7d: // Right Brace
799 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
800 enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_PRESSED);
801 enq_key_event(BX_KEY_RIGHT_BRACKET, BX_KEY_RELEASED);
802 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
803 break;
804 case 0x7e: // Tilde
805 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_PRESSED);
806 enq_key_event(BX_KEY_GRAVE, BX_KEY_PRESSED);
807 enq_key_event(BX_KEY_GRAVE, BX_KEY_RELEASED);
808 enq_key_event(BX_KEY_SHIFT_L, BX_KEY_RELEASED);
809 break;
810
811 case B_BACKSPACE:
812 enq_key_event(BX_KEY_BACKSPACE, BX_KEY_PRESSED);
813 enq_key_event(BX_KEY_BACKSPACE, BX_KEY_RELEASED);
814 break;
815 case B_ENTER: //case B_RETURN:
816 enq_key_event(BX_KEY_ENTER, BX_KEY_PRESSED);
817 enq_key_event(BX_KEY_ENTER, BX_KEY_RELEASED);
818 break;
819 case B_TAB:
820 enq_key_event(BX_KEY_TAB, BX_KEY_PRESSED);
821 enq_key_event(BX_KEY_TAB, BX_KEY_RELEASED);
822 break;
823 case B_LEFT_ARROW:
824 enq_key_event(BX_KEY_LEFT, BX_KEY_PRESSED);
825 enq_key_event(BX_KEY_LEFT, BX_KEY_RELEASED);
826 break;
827 case B_RIGHT_ARROW:
828 enq_key_event(BX_KEY_RIGHT, BX_KEY_PRESSED);
829 enq_key_event(BX_KEY_RIGHT, BX_KEY_RELEASED);
830 break;
831 case B_UP_ARROW:
832 enq_key_event(BX_KEY_UP, BX_KEY_PRESSED);
833 enq_key_event(BX_KEY_UP, BX_KEY_RELEASED);
834 break;
835 case B_DOWN_ARROW:
836 enq_key_event(BX_KEY_DOWN, BX_KEY_PRESSED);
837 enq_key_event(BX_KEY_DOWN, BX_KEY_RELEASED);
838 break;
839 #if 0
840 case B_FUNCTION_KEY: break;
841 msg->FindInt32("key", &key);
842 switch (key) {
843 case B_F1_KEY: break;
844 case B_F2_KEY: break;
845 case B_F3_KEY: break;
846 case B_F4_KEY: break;
847 case B_F5_KEY: break;
848 case B_F6_KEY: break;
849 case B_F7_KEY: break;
850 case B_F8_KEY: break;
851 case B_F9_KEY: break;
852 case B_F10_KEY: break;
853 case B_F11_KEY: break;
854 case B_F12_KEY: break;
855 case B_PRINT_KEY: break;
856 case B_SCROLL_KEY: break;
857 case B_PAUSE_KEY: break;
858 default:
859 fprintf(stderr, "# keydown() unknown function key %08xh\n",
860 (unsigned) key);
861 }
862 #endif
863 case B_INSERT: break;
864 enq_key_event(BX_KEY_INSERT, BX_KEY_PRESSED);
865 enq_key_event(BX_KEY_INSERT, BX_KEY_RELEASED);
866 break;
867 case B_DELETE: break;
868 enq_key_event(BX_KEY_DELETE, BX_KEY_PRESSED);
869 enq_key_event(BX_KEY_DELETE, BX_KEY_RELEASED);
870 break;
871 case B_HOME: break;
872 enq_key_event(BX_KEY_HOME, BX_KEY_PRESSED);
873 enq_key_event(BX_KEY_HOME, BX_KEY_RELEASED);
874 break;
875 case B_END: break;
876 enq_key_event(BX_KEY_END, BX_KEY_PRESSED);
877 enq_key_event(BX_KEY_END, BX_KEY_RELEASED);
878 break;
879 case B_PAGE_UP: break;
880 enq_key_event(BX_KEY_PAGE_UP, BX_KEY_PRESSED);
881 enq_key_event(BX_KEY_PAGE_UP, BX_KEY_RELEASED);
882 break;
883 case B_PAGE_DOWN: break;
884 enq_key_event(BX_KEY_PAGE_DOWN, BX_KEY_PRESSED);
885 enq_key_event(BX_KEY_PAGE_DOWN, BX_KEY_RELEASED);
886 break;
887
888 default:
889 if ((byte >= 0x01) && (byte <= 0x1a)) {
890 // If the above keys dont catch this case, synthesize a
891 // Ctrl-A .. Ctrl-Z event
892 byte -= 1;
893 enq_key_event(BX_KEY_CTRL_L, BX_KEY_PRESSED);
894 enq_key_event(BX_KEY_A + byte, BX_KEY_PRESSED);
895 enq_key_event(BX_KEY_A + byte, BX_KEY_RELEASED);
896 enq_key_event(BX_KEY_CTRL_L, BX_KEY_RELEASED);
897 return;
898 }
899 fprintf(stderr, "# keydown: char %02xh unhandled\n",
900 (unsigned) bytes[0]);
901 return;
902 }
903 return;
904 }
905 else {
906 // ignore for now
907 fprintf(stderr, "# keydown() ignoring multibyte key\n");
908 }
909 }
910
911 void BochsView::KeyUp(const char *bytes, int32 numBytes)
912 {
913 UNUSED(bytes);
914 UNUSED(numBytes);
915 }
916
917 void BochsView::Draw(BRect rect)
918 {
919 DrawBitmapAsync(backing_store, rect, rect);
920 }
921
922 BochsView::~BochsView()
923 {
924 delete backing_store;
925 delete backing_view;
926 }
927
928 void BochsView::SetFont(const BFont *font, uint32 mask)
929 {
930 backing_store->Lock();
931 backing_view->SetFont(font,mask);
932 backing_store->Unlock();
933 }
934
935 void BochsView::SetHighColor(uchar r, uchar g, uchar b, uchar a)
936 {
937 backing_store->Lock();
938 backing_view->SetHighColor(r,g,b,a);
939 backing_store->Unlock();
940 }
941
942 void BochsView::SetLowColor(uchar r, uchar g, uchar b, uchar a)
943 {
944 backing_store->Lock();
945 backing_view->SetLowColor(r,g,b,a);
946 backing_store->Unlock();
947 }
948
949 void BochsView::DrawBitmap(const BBitmap *aBitmap, BPoint where)
950 {
951 backing_store->Lock();
952 backing_view->DrawBitmap(aBitmap,where);
953 backing_store->Unlock();
954 BRect r = aBitmap->Bounds();
955 r.OffsetBy(where);
956 Invalidate(r);
957 }
958
959 void BochsView::FillRect(BRect r, pattern p)
960 {
961 backing_store->Lock();
962 backing_view->FillRect(r,p);
963 backing_store->Unlock();
964 Invalidate(r);
965 }
966
967 void enq_key_event(Bit32u key, Bit32u press_release)
968 {
969 if (((tail+1) % SCANCODE_BUFSIZE) == head) {
970 fprintf(stderr, "# enq_key_event: buffer full\n");
971 return;
972 }
973 keyevents[tail] = key | press_release;
974 tail = (tail + 1) % SCANCODE_BUFSIZE;
975 }
976
977 Bit32u deq_key_event(void)
978 {
979 Bit32u key;
980
981 if (head == tail) {
982 fprintf(stderr, "# deq_key_event: buffer empty\n");
983 return(0);
984 }
985 key = keyevents[head];
986 head = (head + 1) % SCANCODE_BUFSIZE;
987 return(key);
988 }
989
990 unsigned char reverse_bitorder(unsigned char b)
991 {
992 unsigned char ret=0;
993 for (unsigned i=0; i<8; i++) {
994 ret |= (b & 0x01) << (7-i);
995 b >>= 1;
996 }
997 return(ret);
998 }
999
1000 unsigned bx_beos_gui_c::create_bitmap(const unsigned char *bmap,
1001 unsigned xdim, unsigned ydim)
1002 {
1003 BRect rect(0.0, 0.0, xdim-1, ydim-1);
1004 int32 bitslength;
1005 //int32 bytesperrow;
1006 unsigned char *data;
1007
1008 if (bx_bitmap_entries >= BX_MAX_PIXMAPS) {
1009 BX_PANIC(("beos: too many pixmaps, increase BX_MAX_PIXMAPS"));
1010 }
1011
1012 bx_bitmaps[bx_bitmap_entries].bmap =
1013 new BBitmap(rect, B_MONOCHROME_1_BIT);
1014
1015 bitslength = bx_bitmaps[bx_bitmap_entries].bmap->BitsLength();
1016 //bytesperrow = bx_bitmaps[bx_bitmap_entries].bmap->BytesPerRow();
1017 data = (unsigned char *) bx_bitmaps[bx_bitmap_entries].bmap->Bits();
1018 for (int32 i=0; i<bitslength; i++) {
1019 data[i] = reverse_bitorder(bmap[i]);
1020 }
1021
1022 bx_bitmaps[bx_bitmap_entries].xdim = xdim;
1023 bx_bitmaps[bx_bitmap_entries].ydim = ydim;
1024 if (!bx_bitmaps[bx_bitmap_entries].bmap) {
1025 BX_PANIC(("beos: could not create bitmap"));
1026 }
1027 bx_bitmap_entries++;
1028 return(bx_bitmap_entries-1); // return index as handle
1029 }
1030
1031 unsigned bx_beos_gui_c::headerbar_bitmap(unsigned bmap_id, unsigned alignment,
1032 void (*f)(void))
1033 {
1034 unsigned hb_index;
1035
1036 if ((bx_headerbar_entries+1) > BX_MAX_HEADERBAR_ENTRIES)
1037 BX_PANIC(("beos: too many headerbar entries, increase BX_MAX_HEADERBAR_ENTRIES"));
1038
1039 bx_headerbar_entries++;
1040 hb_index = bx_headerbar_entries - 1;
1041
1042 bx_headerbar_entry[hb_index].bitmap = bx_bitmaps[bmap_id].bmap;
1043 bx_headerbar_entry[hb_index].xdim = bx_bitmaps[bmap_id].xdim;
1044 bx_headerbar_entry[hb_index].ydim = bx_bitmaps[bmap_id].ydim;
1045 bx_headerbar_entry[hb_index].alignment = alignment;
1046 bx_headerbar_entry[hb_index].f = f;
1047 if (alignment == BX_GRAVITY_LEFT) {
1048 bx_headerbar_entry[hb_index].xorigin = bx_bitmap_left_xorigin;
1049 bx_headerbar_entry[hb_index].yorigin = 0;
1050 bx_bitmap_left_xorigin += bx_bitmaps[bmap_id].xdim;
1051 }
1052 else { // BX_GRAVITY_RIGHT
1053 bx_bitmap_right_xorigin += bx_bitmaps[bmap_id].xdim;
1054 bx_headerbar_entry[hb_index].xorigin = bx_bitmap_right_xorigin;
1055 bx_headerbar_entry[hb_index].yorigin = 0;
1056 }
1057 return(hb_index);
1058 }
1059
1060 void bx_beos_gui_c::replace_bitmap(unsigned hbar_id, unsigned bmap_id)
1061 {
1062 unsigned xorigin;
1063
1064 bx_headerbar_entry[hbar_id].bitmap = bx_bitmaps[bmap_id].bmap;
1065
1066 if (bx_headerbar_entry[hbar_id].alignment == BX_GRAVITY_LEFT)
1067 xorigin = bx_headerbar_entry[hbar_id].xorigin;
1068 else
1069 xorigin = dimension_x - bx_headerbar_entry[hbar_id].xorigin;
1070 aWindow->Lock();
1071 aView->set_headerbar_colors();
1072 aView->DrawBitmap(bx_headerbar_entry[hbar_id].bitmap, BPoint(xorigin, 0));
1073 aView->set_text_colors();
1074 aWindow->Unlock();
1075 }
1076
1077 void bx_beos_gui_c::show_headerbar(void)
1078 {
1079 unsigned xorigin;
1080 BPoint origin;
1081
1082 // clear header bar area to white
1083
1084 aWindow->Lock();
1085 aView->set_headerbar_colors();
1086 aView->FillRect(BRect(0, 0, dimension_x-1, bx_headerbar_y-1), B_SOLID_LOW);
1087 for (unsigned i=0; i<bx_headerbar_entries; i++) {
1088 if (bx_headerbar_entry[i].alignment == BX_GRAVITY_LEFT)
1089 xorigin = bx_headerbar_entry[i].xorigin;
1090 else
1091 xorigin = dimension_x - bx_headerbar_entry[i].xorigin;
1092 origin.Set(xorigin, 0);
1093 aView->DrawBitmap(bx_headerbar_entry[i].bitmap, origin);
1094 }
1095 aView->set_text_colors();
1096 aWindow->Unlock();
1097 }
1098
1099 void headerbar_click(int x, int y)
1100 {
1101 int xorigin;
1102
1103 // assuming y is in bounds
1104 UNUSED(y);
1105 for (unsigned i=0; i<bx_headerbar_entries; i++) {
1106 if (bx_headerbar_entry[i].alignment == BX_GRAVITY_LEFT)
1107 xorigin = bx_headerbar_entry[i].xorigin;
1108 else
1109 xorigin = dimension_x - bx_headerbar_entry[i].xorigin;
1110 if ((x>=xorigin) && (x<(xorigin+int(bx_headerbar_entry[i].xdim)))) {
1111 bx_headerbar_entry[i].f();
1112 return;
1113 }
1114 }
1115 }
1116
1117 void create_vga_font(void)
1118 {
1119 int32 bitslength;
1120 int32 bytesperrow;
1121 unsigned char *data;
1122 BRect brect(0,0, 7,15);
1123
1124 BX_INFO(("BeOS: creating VGA font from bitmaps"));
1125
1126 // VGA font is 8wide x 16high
1127 for (unsigned c=0; c<256; c++) {
1128 vgafont[c] = new BBitmap(brect, B_MONOCHROME_1_BIT);
1129 if (!vgafont[c]) {
1130 BX_PANIC(("beos: could not create bitmap"));
1131 }
1132
1133 bitslength = vgafont[c]->BitsLength();
1134 bytesperrow = vgafont[c]->BytesPerRow();
1135 data = (unsigned char *) vgafont[c]->Bits();
1136 memset(data, 0, bitslength);
1137 for (unsigned i=0; i<16; i++) {
1138 data[i*bytesperrow] = reverse_bitorder(bx_vgafont[c].data[i]);
1139 }
1140 }
1141 }
1142
1143 void bx_beos_gui_c::exit(void)
1144 {
1145 fprintf(stderr, "# WARNING: BEOS: bx_beos_gui_c::exit() not implemented yet.\n");
1146 }
1147
1148 //IRA=> Start
1149 // This is called whenever the mouse_enabled parameter changes. It
1150 // can change because of a gui event such as clicking on the mouse-enable
1151 // bitmap or pressing the middle button, or from the configuration interface.
1152 // In all those cases, setting the parameter value will get you here.
1153
1154 void bx_beos_gui_c::mouse_enabled_changed_specific (bx_bool val)
1155 {
1156 BX_DEBUG (("mouse_enabled=%d, BeOS specific code", val?1:0));
1157 if (val) {
1158 BX_INFO(("[x] Mouse on"));
1159 // mouse_enable_x = current_x;
1160 // mouse_enable_y = current_y;
1161 be_app->HideCursor();
1162 // Move the cursor to a 'safe' place
1163 // warp_cursor(warp_home_x-current_x, warp_home_y-current_y);
1164 } else {
1165 BX_INFO(("[x] Mouse off"));
1166 be_app->ShowCursor();
1167 // warp_cursor(mouse_enable_x-current_x, mouse_enable_y-current_y);
1168 }
1169 }
1170 //IRA=> End
1171
1172 #endif /* if BX_WITH_BEOS */
Mirror of Bochs CVS