ui/beos/sysbeos.cc

/* 
 *      PearPC
 *      sysbeos.cc
 *
 *      Copyright (C) 1999-2002 Stefan Weyergraf (stefan@weyergraf.de)
 *      Copyright (C) 1999-2004 Sebastian Biallas (sb@biallas.net)
 *      Copyright (C) 2004 Francois Revol (revol@free.fr)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <csignal>
#include <cstdlib>
#include <unistd.h>
#include <cstring>

#include <AppDefs.h>
#include <Application.h>
#include <Bitmap.h>
#include <Cursor.h>
#include <GraphicsDefs.h>
#include <InterfaceDefs.h>
#include <List.h>
#include <Locker.h>
#include <Message.h>
#include <Screen.h>
#include <View.h>
#include <Window.h>
#include <WindowScreen.h>

#include "system/display.h"
#include "system/keyboard.h"
#include "system/mouse.h"
#include "system/types.h"
#include "system/systhread.h"
#include "system/sysexcept.h"
#include "tools/data.h"
#include "tools/snprintf.h"

// for stopping the CPU
#include "cpu/cpu.h"

#include "sysbeos.h"

//#define DPRINTF(a...)
#define DPRINTF(a...) ht_printf(a)

//XXX:DEL uint gDamageAreaFirstAddr, gDamageAreaLastAddr;

/*XXX:DEL
struct {
        uint64 r_mask;
        uint64 g_mask;
        uint64 b_mask;
} PACKED gPosixRGBMask;*/

//extern "C" void __attribute__((regparm (3))) posix_vaccel_15_to_15(uint32 pixel, byte *input, byte *output);
//extern "C" void __attribute__((regparm (3))) posix_vaccel_15_to_32(uint32 pixel, byte *input, byte *output);

static uint8 beos_key_to_adb_key[] = {
/* ESC F1-F12                                                                   PRTSCR SLOCK */
0x35,    0x7a,0x78,0x63,0x76,0x60,0x61,0x62,0x64,0x65,0x6d,0x67,0x6f,           0xff,  0x6b,0x71,
/*   `   1-0                                                  -   =    BSPACE   INS  HOME P_UP         NLOCK /   *    -    */
    0x32,0x12,0x13,0x14,0x15,0x17,0x16,0x1a,0x1c,0x19,0x1d,0x1b,0x18,  0x33,    0x72,0x73,0x74,        0x47,0x4b,0x43,0x4e,
/* TAB   qwerty...                                                     \        DEL  END  P_DN         7    8    9    +    */
0x30,    0x0c,0x0d,0x0e,0x0f,0x11,0x10,0x20,0x22,0x1f,0x23,0x21,0x1e,  0x2a,    0x75,0x77,0x79,        0x59,0x5b,0x5c,0x45,
/* CLOCK ...                                                           ENTR                            4    5    6         */
0x39,0x00,0x01,0x02,0x03,0x05,0x04,0x26,0x28,0x25,0x29,0x27,           0x24,                           0x56,0x57,0x58,/*107*/
/* SHIFT ...                                                           SHIFT         UP                1    2    3    ENTR */
0x38,      0x06,0x07,0x08,0x09,0x0b,0x2d,0x2e,0x2b,0x2f,0x2c,          0x38,         0x3e,             0x53,0x54,0x55,0x4c,
/* CTRL /WIN/   ALT  SPACE ALTGR  /WIN MENU/   CTRL                           LEFT   DOWN   RIGHT      0         DEL       */
   0x36,/*0,*/ 0x37, 0x31, 0x3a,  /*0,  0,*/   0x36,                          0x3b,  0x3d,  0x3c,      0x52,     0x41


};


SDWindow::SDWindow(BRect frame, const char *name)
        : BWindow(frame, name, B_TITLED_WINDOW, B_NOT_RESIZABLE|B_NOT_ZOOMABLE)
{
}

SDWindow::~SDWindow()
{
}

bool SDWindow::QuitRequested()
{
        ppc_cpu_stop();
        /*
          SDView *view = dynamic_cast<SDView *>(FindView("framebuffer"));
          
          if (view) {
          BMessage *msg = new BMessage(B_QUIT_REQUESTED);
          view->QueueMessage(msg);
          }
        */
        return false;
}

void SDWindow::Show()
{
        BWindow::Show();
        //gDisplay->setExposed(!IsMinimized() && !IsHidden());
        //gDisplay->setExposed(true);
}

void SDWindow::Hide()
{
        BWindow::Hide();
        //gDisplay->setExposed(!IsMinimized() && !IsHidden());
}

void SDWindow::Minimize(bool minimize)
{
        BWindow::Minimize(minimize);
        gDisplay->setExposed(!minimize && !IsHidden());
}

SDView::SDView(BeOSSystemDisplay *sd, BRect frame, const char *name)
        : BView(frame, name, B_FOLLOW_ALL_SIDES, B_PULSE_NEEDED|B_WILL_DRAW)
{
        fSystemDisplay = sd;
        sd->fbBitmap;
        fMsgList.MakeEmpty();
        //SetViewColor(0,255,0);
        SetViewColor(B_TRANSPARENT_32_BIT);
        fMsgSem = create_sem(1, "PearPC MessageList sem");
        // here we don't use the View's looper to lock the msg list,
        // so the window thread and main thread aren't interleaved 
        // just because they are playing with the msg list.
        // much better on my dual :))
        fMsgListLock = new BLocker("PearPC MessageList lock", true);
}

SDView::~SDView()
{
        delete_sem(fMsgSem);
        delete fMsgListLock;
}

void SDView::MessageReceived(BMessage *msg)
{
        BMessage *event;
        switch (msg->what) {
        case B_UNMAPPED_KEY_DOWN:
        case B_UNMAPPED_KEY_UP:
                event = Window()->DetachCurrentMessage();
                QueueMessage(event);
                return;
        }
        BView::MessageReceived(msg);
}

void SDView::Draw(BRect updateRect)
{
        //fSystemDisplay->convertDisplayClientToServer();
#ifdef BMP_MENU
        BRect r(updateRect);
        r.bottom = MIN(fSystemDisplay->mMenuHeight-1, r.bottom);
        if (fSystemDisplay->fMenuBitmap && (r.top <= fSystemDisplay->mMenuHeight))
                DrawBitmap(fSystemDisplay->fMenuBitmap, r, r);
        BRect src(updateRect);
        src.OffsetBySelf(0,-fSystemDisplay->mMenuHeight);
        //src.top = MAX(0, src.top);
        DrawBitmap(fSystemDisplay->fbBitmap, src, updateRect);
#else
        DrawBitmap(fSystemDisplay->fbBitmap, updateRect, updateRect);
#endif
        if (fSystemDisplay->mHWCursorVisible) {
                //XPutImage(gXDisplay, gXWindow, gGC, gMouseXImage, 0, 0, 
                //      mHWCursorX, mHWCursorY, 2, 2);
        }
}

void SDView::MouseDown(BPoint where)
{
        BMessage *event = Window()->CurrentMessage();
        SystemEvent ev;
        int32 buttons;
        ev.type = sysevMouse;
        //if (!mMouseEnabled) break;
        if (event->FindInt32("buttons", (int32 *)&buttons) < B_OK)
                buttons = 0;
        ev.mouse.type = sme_buttonPressed;
        ev.mouse.x = gDisplay->mCurMouseX;
        ev.mouse.y = gDisplay->mCurMouseY;
        ev.mouse.relx = 0;
        ev.mouse.rely = 0;
        ev.mouse.button1 = (buttons & B_PRIMARY_MOUSE_BUTTON) != 0;
        ev.mouse.button2 = (buttons & B_SECONDARY_MOUSE_BUTTON) != 0;
        ev.mouse.button3 = (buttons & B_TERTIARY_MOUSE_BUTTON) != 0;
        
        gMouse->handleEvent(ev);
}

void SDView::MouseUp(BPoint where)
{
        BMessage *event = Window()->CurrentMessage();
        SystemEvent ev;
        int32 buttons;
        ev.type = sysevMouse;
        //if (!mMouseEnabled) break;
        if (event->FindInt32("buttons", (int32 *)&buttons) < B_OK)
                buttons = 0;
        ev.mouse.type = sme_buttonReleased;
        ev.mouse.x = gDisplay->mCurMouseX;
        ev.mouse.y = gDisplay->mCurMouseY;
        ev.mouse.relx = 0;
        ev.mouse.rely = 0;
        ev.mouse.button1 = (buttons & B_PRIMARY_MOUSE_BUTTON) != 0;
        ev.mouse.button2 = (buttons & B_SECONDARY_MOUSE_BUTTON) != 0;
        ev.mouse.button3 = (buttons & B_TERTIARY_MOUSE_BUTTON) != 0;
        
        gMouse->handleEvent(ev);
}

void SDView::MouseMoved(BPoint where, uint32 code, const BMessage *a_message)
{
        BMessage *event = Window()->CurrentMessage();
        SystemEvent ev;
        int32 buttons;
        if (code == B_OUTSIDE_VIEW)
                return;
        if (event->FindInt32("buttons", (int32 *)&buttons) < B_OK)
                buttons = 0;
        gDisplay->mCurMouseX = ev.mouse.x = (int)where.x;
        gDisplay->mCurMouseY = ev.mouse.y = (int)where.y;
        if (gDisplay->mCurMouseX == gDisplay->mHomeMouseX && gDisplay->mCurMouseY == gDisplay->mHomeMouseY) return;
        if (gDisplay->mCurMouseX == -1) return;
        ev.type = sysevMouse;
        ev.mouse.type = sme_motionNotify;
        ev.mouse.button1 = (buttons & B_PRIMARY_MOUSE_BUTTON) != 0;
        ev.mouse.button2 = (buttons & B_SECONDARY_MOUSE_BUTTON) != 0;
        ev.mouse.button3 = (buttons & B_TERTIARY_MOUSE_BUTTON) != 0;
        ev.mouse.dbutton = 0;
        ev.mouse.relx = gDisplay->mCurMouseX - gDisplay->mHomeMouseX;
        ev.mouse.rely = gDisplay->mCurMouseY - gDisplay->mHomeMouseY;
        if (gDisplay->isMouseGrabbed()) {
                BPoint p(gDisplay->mHomeMouseX, gDisplay->mHomeMouseY);
                //printf("nukemouse %f %f\n", p.x, p.y);
                ConvertToScreen(&p);
                //printf("nukemouses %f %f\n", p.x, p.y);
                set_mouse_position((int32)p.x, (int32)p.y);
        }
        if (code == B_EXITED_VIEW) {
                if (gDisplay->isMouseGrabbed()) gDisplay->setMouseGrab(false);
        }
        gMouse->handleEvent(ev);
}

void SDView::KeyDown(const char *bytes, int32 numBytes)
{
        BMessage *event = Window()->CurrentMessage();
        char buffer[4];
        uint32 modifiers;
        int32 key;
        int32 raw_char;
        SystemEvent ev;
        if (event->FindInt32("key", &key) < B_OK)
                key = 0;
        if (event->FindInt32("raw_char", &raw_char) < B_OK)
                raw_char = 0;
        if (!key || (key > 255)) return;
        ev.key.keycode = beos_key_to_adb_key[key-1];
        DPRINTF("keys[%d-1]=%d, 0x%x\n", key, beos_key_to_adb_key[key-1], beos_key_to_adb_key[key-1]);
        if (ev.key.keycode == KEY_F12) return;
        if ((ev.key.keycode & 0xff) == 0xff) return;
        ev.type = sysevKey;
        ev.key.pressed = true;
        ev.key.chr = (char)raw_char;
        gKeyboard->handleEvent(ev);
}

void SDView::KeyUp(const char *bytes, int32 numBytes)
{
        BMessage *event = Window()->CurrentMessage();
        char buffer[4];
        uint32 modifiers;
        int32 key;
        int32 raw_char;
        SystemEvent ev;
        if (event->FindInt32("key", &key) < B_OK)
                key = 0;
        if (event->FindInt32("raw_char", &raw_char) < B_OK)
                raw_char = 0;
        if (!key || (key > 255)) return;
        ev.key.keycode = beos_key_to_adb_key[key-1];
        DPRINTF("keys[%d-1]=%d, 0x%x\n", key, beos_key_to_adb_key[key-1], beos_key_to_adb_key[key-1]);
        if (ev.key.keycode == KEY_F12) return;
        if ((ev.key.keycode & 0xff) == 0xff) return;
        ev.type = sysevKey;
        ev.key.pressed = false;
        ev.key.chr = (char)raw_char;
        gKeyboard->handleEvent(ev);
}

void SDView::Pulse()
{
        BWindow *w = Window();
        if (w && !w->IsHidden() && !w->IsMinimized())
                fSystemDisplay->displayShow();
        //Invalidate(Bounds()); /* cause a redraw */
}

void SDView::QueueMessage(BMessage *msg)
{
        fMsgListLock->Lock(); /* BList not threadsafe */
        fMsgList.AddItem(msg, fMsgList.CountItems());
        fMsgListLock->Unlock();
        release_sem(fMsgSem);
}

BMessage *SDView::UnqueueMessage(bool sync)
{
        BMessage *msg;
        acquire_sem_etc(fMsgSem, 1, sync?0:B_RELATIVE_TIMEOUT, 0LL);
        //LockLooper();
        fMsgListLock->Lock(); /* BList not threadsafe */
        msg = (BMessage *)fMsgList.RemoveItem(0L);
        //UnlockLooper();
        fMsgListLock->Unlock();
/*      if (msg)
                msg->PrintToStream();*/
        return msg;
}

extern SystemDisplay *allocSystemDisplay(const char *title, const DisplayCharacteristics &chr, int redraw_ms);
extern SystemMouse *allocSystemMouse();
extern SystemKeyboard *allocSystemKeyboard();


void initUI(const char *title, const DisplayCharacteristics &aCharacteristics, int redraw_ms, KeyboardCharacteristics const &keyConfig, bool fullscreen)
{
        gDisplay = allocSystemDisplay(title, aCharacteristics, redraw_ms);
        gMouse = allocSystemMouse();
        gKeyboard = allocSystemKeyboard();
        if(!gKeyboard->setKeyConfig(keyConfig)) {
                ht_printf("no keyConfig, or is empty");
                exit(1);
        }
        gDisplay->updateTitle();
}

void doneUI()
{
        delete gDisplay;
        delete gKeyboard;
        delete gMouse;
}
1	dpavlin	1	/*
2			* PearPC
3			* sysbeos.cc
4			*
5			* Copyright (C) 1999-2002 Stefan Weyergraf (stefan@weyergraf.de)
6			* Copyright (C) 1999-2004 Sebastian Biallas (sb@biallas.net)
7			* Copyright (C) 2004 Francois Revol (revol@free.fr)
8			*
9			* This program is free software; you can redistribute it and/or modify
10			* it under the terms of the GNU General Public License version 2 as
11			* published by the Free Software Foundation.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21			*/
22
23			#include <csignal>
24			#include <cstdlib>
25			#include <unistd.h>
26			#include <cstring>
27
28			#include <AppDefs.h>
29			#include <Application.h>
30			#include <Bitmap.h>
31			#include <Cursor.h>
32			#include <GraphicsDefs.h>
33			#include <InterfaceDefs.h>
34			#include <List.h>
35			#include <Locker.h>
36			#include <Message.h>
37			#include <Screen.h>
38			#include <View.h>
39			#include <Window.h>
40			#include <WindowScreen.h>
41
42			#include "system/display.h"
43			#include "system/keyboard.h"
44			#include "system/mouse.h"
45			#include "system/types.h"
46			#include "system/systhread.h"
47			#include "system/sysexcept.h"
48			#include "tools/data.h"
49			#include "tools/snprintf.h"
50
51			// for stopping the CPU
52			#include "cpu/cpu.h"
53
54			#include "sysbeos.h"
55
56			//#define DPRINTF(a...)
57			#define DPRINTF(a...) ht_printf(a)
58
59			//XXX:DEL uint gDamageAreaFirstAddr, gDamageAreaLastAddr;
60
61			/*XXX:DEL
62			struct {
63			uint64 r_mask;
64			uint64 g_mask;
65			uint64 b_mask;
66			} PACKED gPosixRGBMask;*/
67
68			//extern "C" void __attribute__((regparm (3))) posix_vaccel_15_to_15(uint32 pixel, byte input, byte output);
69			//extern "C" void __attribute__((regparm (3))) posix_vaccel_15_to_32(uint32 pixel, byte input, byte output);
70
71			static uint8 beos_key_to_adb_key[] = {
72			/* ESC F1-F12 PRTSCR SLOCK */
73			0x35, 0x7a,0x78,0x63,0x76,0x60,0x61,0x62,0x64,0x65,0x6d,0x67,0x6f, 0xff, 0x6b,0x71,
74			/* ` 1-0 - = BSPACE INS HOME P_UP NLOCK / * - */
75			0x32,0x12,0x13,0x14,0x15,0x17,0x16,0x1a,0x1c,0x19,0x1d,0x1b,0x18, 0x33, 0x72,0x73,0x74, 0x47,0x4b,0x43,0x4e,
76			/* TAB qwerty... \ DEL END P_DN 7 8 9 + */
77			0x30, 0x0c,0x0d,0x0e,0x0f,0x11,0x10,0x20,0x22,0x1f,0x23,0x21,0x1e, 0x2a, 0x75,0x77,0x79, 0x59,0x5b,0x5c,0x45,
78			/* CLOCK ... ENTR 4 5 6 */
79			0x39,0x00,0x01,0x02,0x03,0x05,0x04,0x26,0x28,0x25,0x29,0x27, 0x24, 0x56,0x57,0x58,/107/
80			/* SHIFT ... SHIFT UP 1 2 3 ENTR */
81			0x38, 0x06,0x07,0x08,0x09,0x0b,0x2d,0x2e,0x2b,0x2f,0x2c, 0x38, 0x3e, 0x53,0x54,0x55,0x4c,
82			/* CTRL /WIN/ ALT SPACE ALTGR /WIN MENU/ CTRL LEFT DOWN RIGHT 0 DEL */
83			0x36,/0,/ 0x37, 0x31, 0x3a, /0, 0,/ 0x36, 0x3b, 0x3d, 0x3c, 0x52, 0x41
84
85
86			};
87
88
89
90			SDWindow::SDWindow(BRect frame, const char *name)
91			: BWindow(frame, name, B_TITLED_WINDOW, B_NOT_RESIZABLE\|B_NOT_ZOOMABLE)
92			{
93			}
94
95			SDWindow::~SDWindow()
96			{
97			}
98
99			bool SDWindow::QuitRequested()
100			{
101			ppc_cpu_stop();
102			/*
103			SDView view = dynamic_cast<SDView >(FindView("framebuffer"));
104
105			if (view) {
106			BMessage *msg = new BMessage(B_QUIT_REQUESTED);
107			view->QueueMessage(msg);
108			}
109			*/
110			return false;
111			}
112
113			void SDWindow::Show()
114			{
115			BWindow::Show();
116			//gDisplay->setExposed(!IsMinimized() && !IsHidden());
117			//gDisplay->setExposed(true);
118			}
119
120			void SDWindow::Hide()
121			{
122			BWindow::Hide();
123			//gDisplay->setExposed(!IsMinimized() && !IsHidden());
124			}
125
126			void SDWindow::Minimize(bool minimize)
127			{
128			BWindow::Minimize(minimize);
129			gDisplay->setExposed(!minimize && !IsHidden());
130			}
131
132			SDView::SDView(BeOSSystemDisplay sd, BRect frame, const char name)
133			: BView(frame, name, B_FOLLOW_ALL_SIDES, B_PULSE_NEEDED\|B_WILL_DRAW)
134			{
135			fSystemDisplay = sd;
136			sd->fbBitmap;
137			fMsgList.MakeEmpty();
138			//SetViewColor(0,255,0);
139			SetViewColor(B_TRANSPARENT_32_BIT);
140			fMsgSem = create_sem(1, "PearPC MessageList sem");
141			// here we don't use the View's looper to lock the msg list,
142			// so the window thread and main thread aren't interleaved
143			// just because they are playing with the msg list.
144			// much better on my dual :))
145			fMsgListLock = new BLocker("PearPC MessageList lock", true);
146			}
147
148			SDView::~SDView()
149			{
150			delete_sem(fMsgSem);
151			delete fMsgListLock;
152			}
153
154			void SDView::MessageReceived(BMessage *msg)
155			{
156			BMessage *event;
157			switch (msg->what) {
158			case B_UNMAPPED_KEY_DOWN:
159			case B_UNMAPPED_KEY_UP:
160			event = Window()->DetachCurrentMessage();
161			QueueMessage(event);
162			return;
163			}
164			BView::MessageReceived(msg);
165			}
166
167			void SDView::Draw(BRect updateRect)
168			{
169			//fSystemDisplay->convertDisplayClientToServer();
170			#ifdef BMP_MENU
171			BRect r(updateRect);
172			r.bottom = MIN(fSystemDisplay->mMenuHeight-1, r.bottom);
173			if (fSystemDisplay->fMenuBitmap && (r.top <= fSystemDisplay->mMenuHeight))
174			DrawBitmap(fSystemDisplay->fMenuBitmap, r, r);
175			BRect src(updateRect);
176			src.OffsetBySelf(0,-fSystemDisplay->mMenuHeight);
177			//src.top = MAX(0, src.top);
178			DrawBitmap(fSystemDisplay->fbBitmap, src, updateRect);
179			#else
180			DrawBitmap(fSystemDisplay->fbBitmap, updateRect, updateRect);
181			#endif
182			if (fSystemDisplay->mHWCursorVisible) {
183			//XPutImage(gXDisplay, gXWindow, gGC, gMouseXImage, 0, 0,
184			// mHWCursorX, mHWCursorY, 2, 2);
185			}
186			}
187
188			void SDView::MouseDown(BPoint where)
189			{
190			BMessage *event = Window()->CurrentMessage();
191			SystemEvent ev;
192			int32 buttons;
193			ev.type = sysevMouse;
194			//if (!mMouseEnabled) break;
195			if (event->FindInt32("buttons", (int32 *)&buttons) < B_OK)
196			buttons = 0;
197			ev.mouse.type = sme_buttonPressed;
198			ev.mouse.x = gDisplay->mCurMouseX;
199			ev.mouse.y = gDisplay->mCurMouseY;
200			ev.mouse.relx = 0;
201			ev.mouse.rely = 0;
202			ev.mouse.button1 = (buttons & B_PRIMARY_MOUSE_BUTTON) != 0;
203			ev.mouse.button2 = (buttons & B_SECONDARY_MOUSE_BUTTON) != 0;
204			ev.mouse.button3 = (buttons & B_TERTIARY_MOUSE_BUTTON) != 0;
205
206			gMouse->handleEvent(ev);
207			}
208
209			void SDView::MouseUp(BPoint where)
210			{
211			BMessage *event = Window()->CurrentMessage();
212			SystemEvent ev;
213			int32 buttons;
214			ev.type = sysevMouse;
215			//if (!mMouseEnabled) break;
216			if (event->FindInt32("buttons", (int32 *)&buttons) < B_OK)
217			buttons = 0;
218			ev.mouse.type = sme_buttonReleased;
219			ev.mouse.x = gDisplay->mCurMouseX;
220			ev.mouse.y = gDisplay->mCurMouseY;
221			ev.mouse.relx = 0;
222			ev.mouse.rely = 0;
223			ev.mouse.button1 = (buttons & B_PRIMARY_MOUSE_BUTTON) != 0;
224			ev.mouse.button2 = (buttons & B_SECONDARY_MOUSE_BUTTON) != 0;
225			ev.mouse.button3 = (buttons & B_TERTIARY_MOUSE_BUTTON) != 0;
226
227			gMouse->handleEvent(ev);
228			}
229
230			void SDView::MouseMoved(BPoint where, uint32 code, const BMessage *a_message)
231			{
232			BMessage *event = Window()->CurrentMessage();
233			SystemEvent ev;
234			int32 buttons;
235			if (code == B_OUTSIDE_VIEW)
236			return;
237			if (event->FindInt32("buttons", (int32 *)&buttons) < B_OK)
238			buttons = 0;
239			gDisplay->mCurMouseX = ev.mouse.x = (int)where.x;
240			gDisplay->mCurMouseY = ev.mouse.y = (int)where.y;
241			if (gDisplay->mCurMouseX == gDisplay->mHomeMouseX && gDisplay->mCurMouseY == gDisplay->mHomeMouseY) return;
242			if (gDisplay->mCurMouseX == -1) return;
243			ev.type = sysevMouse;
244			ev.mouse.type = sme_motionNotify;
245			ev.mouse.button1 = (buttons & B_PRIMARY_MOUSE_BUTTON) != 0;
246			ev.mouse.button2 = (buttons & B_SECONDARY_MOUSE_BUTTON) != 0;
247			ev.mouse.button3 = (buttons & B_TERTIARY_MOUSE_BUTTON) != 0;
248			ev.mouse.dbutton = 0;
249			ev.mouse.relx = gDisplay->mCurMouseX - gDisplay->mHomeMouseX;
250			ev.mouse.rely = gDisplay->mCurMouseY - gDisplay->mHomeMouseY;
251			if (gDisplay->isMouseGrabbed()) {
252			BPoint p(gDisplay->mHomeMouseX, gDisplay->mHomeMouseY);
253			//printf("nukemouse %f %f\n", p.x, p.y);
254			ConvertToScreen(&p);
255			//printf("nukemouses %f %f\n", p.x, p.y);
256			set_mouse_position((int32)p.x, (int32)p.y);
257			}
258			if (code == B_EXITED_VIEW) {
259			if (gDisplay->isMouseGrabbed()) gDisplay->setMouseGrab(false);
260			}
261			gMouse->handleEvent(ev);
262			}
263
264			void SDView::KeyDown(const char *bytes, int32 numBytes)
265			{
266			BMessage *event = Window()->CurrentMessage();
267			char buffer[4];
268			uint32 modifiers;
269			int32 key;
270			int32 raw_char;
271			SystemEvent ev;
272			if (event->FindInt32("key", &key) < B_OK)
273			key = 0;
274			if (event->FindInt32("raw_char", &raw_char) < B_OK)
275			raw_char = 0;
276			if (!key \|\| (key > 255)) return;
277			ev.key.keycode = beos_key_to_adb_key[key-1];
278			DPRINTF("keys[%d-1]=%d, 0x%x\n", key, beos_key_to_adb_key[key-1], beos_key_to_adb_key[key-1]);
279			if (ev.key.keycode == KEY_F12) return;
280			if ((ev.key.keycode & 0xff) == 0xff) return;
281			ev.type = sysevKey;
282			ev.key.pressed = true;
283			ev.key.chr = (char)raw_char;
284			gKeyboard->handleEvent(ev);
285			}
286
287			void SDView::KeyUp(const char *bytes, int32 numBytes)
288			{
289			BMessage *event = Window()->CurrentMessage();
290			char buffer[4];
291			uint32 modifiers;
292			int32 key;
293			int32 raw_char;
294			SystemEvent ev;
295			if (event->FindInt32("key", &key) < B_OK)
296			key = 0;
297			if (event->FindInt32("raw_char", &raw_char) < B_OK)
298			raw_char = 0;
299			if (!key \|\| (key > 255)) return;
300			ev.key.keycode = beos_key_to_adb_key[key-1];
301			DPRINTF("keys[%d-1]=%d, 0x%x\n", key, beos_key_to_adb_key[key-1], beos_key_to_adb_key[key-1]);
302			if (ev.key.keycode == KEY_F12) return;
303			if ((ev.key.keycode & 0xff) == 0xff) return;
304			ev.type = sysevKey;
305			ev.key.pressed = false;
306			ev.key.chr = (char)raw_char;
307			gKeyboard->handleEvent(ev);
308			}
309
310			void SDView::Pulse()
311			{
312			BWindow *w = Window();
313			if (w && !w->IsHidden() && !w->IsMinimized())
314			fSystemDisplay->displayShow();
315			//Invalidate(Bounds()); /* cause a redraw */
316			}
317
318			void SDView::QueueMessage(BMessage *msg)
319			{
320			fMsgListLock->Lock(); /* BList not threadsafe */
321			fMsgList.AddItem(msg, fMsgList.CountItems());
322			fMsgListLock->Unlock();
323			release_sem(fMsgSem);
324			}
325
326			BMessage *SDView::UnqueueMessage(bool sync)
327			{
328			BMessage *msg;
329			acquire_sem_etc(fMsgSem, 1, sync?0:B_RELATIVE_TIMEOUT, 0LL);
330			//LockLooper();
331			fMsgListLock->Lock(); /* BList not threadsafe */
332			msg = (BMessage *)fMsgList.RemoveItem(0L);
333			//UnlockLooper();
334			fMsgListLock->Unlock();
335			/* if (msg)
336			msg->PrintToStream();*/
337			return msg;
338			}
339
340			extern SystemDisplay allocSystemDisplay(const char title, const DisplayCharacteristics &chr, int redraw_ms);
341			extern SystemMouse *allocSystemMouse();
342			extern SystemKeyboard *allocSystemKeyboard();
343
344
345			void initUI(const char *title, const DisplayCharacteristics &aCharacteristics, int redraw_ms, KeyboardCharacteristics const &keyConfig, bool fullscreen)
346			{
347			gDisplay = allocSystemDisplay(title, aCharacteristics, redraw_ms);
348			gMouse = allocSystemMouse();
349			gKeyboard = allocSystemKeyboard();
350			if(!gKeyboard->setKeyConfig(keyConfig)) {
351			ht_printf("no keyConfig, or is empty");
352			exit(1);
353			}
354			gDisplay->updateTitle();
355			}
356
357			void doneUI()
358			{
359			delete gDisplay;
360			delete gKeyboard;
361			delete gMouse;
362			}