| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2006 Sam Lantinga |
| |
| 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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| |
| Sam Lantinga |
| slouken@libsdl.org |
| */ |
| #include "SDL_config.h" |
| |
| /* Handle the event stream, converting photon events into SDL events */ |
| |
| #include <stdio.h> |
| #include <setjmp.h> |
| #include <sys/time.h> |
| |
| #include <Ph.h> |
| #include <photon/PkKeyDef.h> |
| |
| #include "SDL.h" |
| #include "SDL_syswm.h" |
| #include "../SDL_sysvideo.h" |
| #include "../../events/SDL_sysevents.h" |
| #include "../../events/SDL_events_c.h" |
| #include "SDL_ph_video.h" |
| #include "SDL_ph_modes_c.h" |
| #include "SDL_ph_image_c.h" |
| #include "SDL_ph_events_c.h" |
| #include "SDL_phyuv_c.h" |
| |
| /* The translation tables from a photon keysym to a SDL keysym */ |
| static SDLKey ODD_keymap[256]; |
| static SDLKey MISC_keymap[0xFF + 1]; |
| SDL_keysym *ph_TranslateKey(PhKeyEvent_t * key, SDL_keysym * keysym); |
| |
| /* Check to see if this is a repeated key. |
| (idea shamelessly lifted from GII -- thanks guys! :) */ |
| static int |
| ph_WarpedMotion(_THIS, PhEvent_t * winEvent) |
| { |
| PhRect_t *rect = PhGetRects(winEvent); |
| |
| int centre_x, centre_y; |
| int dx, dy; |
| short abs_x, abs_y; |
| int posted; |
| |
| centre_x = SDL_VideoSurface->w / 2; |
| centre_y = SDL_VideoSurface->h / 2; |
| |
| dx = rect->ul.x - centre_x; |
| dy = rect->ul.y - centre_y; |
| |
| posted = SDL_PrivateMouseMotion(0, 1, dx, dy); |
| |
| /* Move mouse cursor to middle of the window */ |
| PtGetAbsPosition(window, &abs_x, &abs_y); |
| PhMoveCursorAbs(PhInputGroup(NULL), abs_x + centre_x, abs_y + centre_y); |
| |
| return (posted); |
| } |
| |
| /* Control which motion flags the window has set, a flags value of -1 sets |
| * MOTION_BUTTON and MOTION_NOBUTTON */ |
| |
| static void |
| set_motion_sensitivity(_THIS, unsigned int flags) |
| { |
| int rid; |
| int fields = Ph_EV_PTR_MOTION_BUTTON | Ph_EV_PTR_MOTION_NOBUTTON; |
| PhRegion_t region; |
| |
| if (window) { |
| rid = PtWidgetRid(window); |
| if (rid != 0 && PhRegionQuery(rid, ®ion, NULL, NULL, 0) == 0) { |
| region.events_sense = |
| (region.events_sense & ~fields) | (flags & fields); |
| PhRegionChange(Ph_REGION_EV_SENSE, 0, ®ion, NULL, NULL); |
| } |
| } |
| } |
| |
| /* Convert the photon button state value to an SDL value */ |
| static Uint8 |
| ph2sdl_mousebutton(unsigned short button_state) |
| { |
| Uint8 mouse_button = 0; |
| |
| if (button_state & Ph_BUTTON_SELECT) |
| mouse_button |= SDL_BUTTON_LEFT; |
| if (button_state & Ph_BUTTON_MENU) |
| mouse_button |= SDL_BUTTON_RIGHT; |
| if (button_state & Ph_BUTTON_ADJUST) |
| mouse_button |= SDL_BUTTON_MIDDLE; |
| |
| return (mouse_button); |
| } |
| |
| static int |
| ph_DispatchEvent(_THIS) |
| { |
| int posted; |
| PhRect_t *rect; |
| PhPointerEvent_t *pointerEvent; |
| PhKeyEvent_t *keyEvent; |
| PhWindowEvent_t *winEvent; |
| int i, buttons; |
| SDL_Rect sdlrects[PH_SDL_MAX_RECTS]; |
| |
| posted = 0; |
| |
| switch (phevent->type) { |
| case Ph_EV_BOUNDARY: |
| { |
| if (phevent->subtype == Ph_EV_PTR_ENTER) { |
| posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); |
| } else if (phevent->subtype == Ph_EV_PTR_LEAVE) { |
| posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); |
| } |
| } |
| break; |
| |
| case Ph_EV_PTR_MOTION_BUTTON: |
| case Ph_EV_PTR_MOTION_NOBUTTON: |
| { |
| if (SDL_VideoSurface) { |
| pointerEvent = PhGetData(phevent); |
| rect = PhGetRects(phevent); |
| |
| if (mouse_relative) { |
| posted = ph_WarpedMotion(this, phevent); |
| } else { |
| posted = |
| SDL_PrivateMouseMotion(0, 0, rect->ul.x, rect->ul.y); |
| } |
| } |
| } |
| break; |
| |
| case Ph_EV_BUT_PRESS: |
| { |
| pointerEvent = PhGetData(phevent); |
| buttons = ph2sdl_mousebutton(pointerEvent->buttons); |
| if (buttons != 0) { |
| posted = SDL_PrivateMouseButton(SDL_PRESSED, buttons, 0, 0); |
| } |
| } |
| break; |
| |
| case Ph_EV_BUT_RELEASE: |
| { |
| pointerEvent = PhGetData(phevent); |
| buttons = ph2sdl_mousebutton(pointerEvent->buttons); |
| if (phevent->subtype == Ph_EV_RELEASE_REAL && buttons != 0) { |
| posted = SDL_PrivateMouseButton(SDL_RELEASED, buttons, 0, 0); |
| } else if (phevent->subtype == Ph_EV_RELEASE_PHANTOM) { |
| /* If the mouse is outside the window, |
| * only a phantom release event is sent, so |
| * check if the window doesn't have mouse focus. |
| * Not perfect, maybe checking the mouse button |
| * state for Ph_EV_BOUNDARY events would be |
| * better. */ |
| if ((SDL_GetAppState() & SDL_APPMOUSEFOCUS) == 0) { |
| posted = |
| SDL_PrivateMouseButton(SDL_RELEASED, buttons, 0, 0); |
| } |
| } |
| } |
| break; |
| |
| case Ph_EV_WM: |
| { |
| winEvent = PhGetData(phevent); |
| |
| /* losing focus */ |
| if ((winEvent->event_f == Ph_WM_FOCUS) |
| && (winEvent->event_state == Ph_WM_EVSTATE_FOCUSLOST)) { |
| set_motion_sensitivity(this, Ph_EV_PTR_MOTION_BUTTON); |
| posted = SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS); |
| } |
| /* gaining focus */ |
| else if ((winEvent->event_f == Ph_WM_FOCUS) |
| && (winEvent->event_state == Ph_WM_EVSTATE_FOCUS)) { |
| set_motion_sensitivity(this, -1); |
| posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS); |
| } |
| /* request quit */ |
| else if (winEvent->event_f == Ph_WM_CLOSE) { |
| posted = SDL_PrivateQuit(); |
| } |
| /* request hide/unhide */ |
| else if (winEvent->event_f == Ph_WM_HIDE) { |
| if (currently_hided) { |
| /* got unhide window event */ |
| /* TODO: restore application's palette if in palette mode */ |
| currently_hided = 0; |
| } else { |
| /* got hide window event */ |
| /* TODO: restore original palette if in palette mode */ |
| currently_hided = 1; |
| } |
| } |
| /* request to resize */ |
| else if (winEvent->event_f == Ph_WM_RESIZE) { |
| currently_maximized = 0; |
| #if (_NTO_VERSION < 630) |
| SDL_PrivateResize(winEvent->size.w + 1, winEvent->size.h + 1); |
| #else |
| /* QNX 6.3.0 have this bug fixed */ |
| SDL_PrivateResize(winEvent->size.w, winEvent->size.h); |
| #endif /* _NTO_VERSION */ |
| } |
| /* request to move */ |
| else if (winEvent->event_f == Ph_WM_MOVE) { |
| if (current_overlay != NULL) { |
| int lockedstate = current_overlay->hwdata->locked; |
| int chromastate = current_overlay->hwdata->ischromakey; |
| int error; |
| SDL_Rect src, dst; |
| |
| current_overlay->hwdata->locked = 1; |
| src.x = 0; |
| src.y = 0; |
| src.w = current_overlay->w; |
| src.y = current_overlay->h; |
| dst.x = current_overlay->hwdata->CurrentViewPort.pos.x; |
| dst.y = current_overlay->hwdata->CurrentViewPort.pos.y; |
| dst.w = current_overlay->hwdata->CurrentViewPort.size.w; |
| dst.h = current_overlay->hwdata->CurrentViewPort.size.h; |
| current_overlay->hwdata->ischromakey = 0; |
| error = |
| ph_DisplayYUVOverlay(this, current_overlay, |
| &src, &dst); |
| if (!error) { |
| current_overlay->hwdata->ischromakey = chromastate; |
| current_overlay->hwdata->locked = lockedstate; |
| } |
| } |
| } |
| /* maximize request */ |
| else if (winEvent->event_f == Ph_WM_MAX) { |
| /* window already moved and resized here */ |
| currently_maximized = 1; |
| } |
| /* restore request */ |
| else if (winEvent->event_f == Ph_WM_RESTORE) { |
| /* window already moved and resized here */ |
| currently_maximized = 0; |
| } |
| } |
| break; |
| |
| /* window has been resized, moved or removed */ |
| case Ph_EV_EXPOSE: |
| { |
| if (phevent->num_rects != 0) { |
| int numrects; |
| |
| if (SDL_VideoSurface) { |
| rect = PhGetRects(phevent); |
| if (phevent->num_rects > PH_SDL_MAX_RECTS) { |
| /* sorry, buffers underrun, we'll update only first PH_SDL_MAX_RECTS rects */ |
| numrects = PH_SDL_MAX_RECTS; |
| } |
| |
| for (i = 0; i < phevent->num_rects; i++) { |
| sdlrects[i].x = rect[i].ul.x; |
| sdlrects[i].y = rect[i].ul.y; |
| sdlrects[i].w = rect[i].lr.x - rect[i].ul.x + 1; |
| sdlrects[i].h = rect[i].lr.y - rect[i].ul.y + 1; |
| } |
| |
| this->UpdateRects(this, phevent->num_rects, sdlrects); |
| |
| if (current_overlay != NULL) { |
| int lockedstate = current_overlay->hwdata->locked; |
| int error; |
| SDL_Rect src, dst; |
| |
| current_overlay->hwdata->locked = 1; |
| src.x = 0; |
| src.y = 0; |
| src.w = current_overlay->w; |
| src.y = current_overlay->h; |
| dst.x = |
| current_overlay->hwdata->CurrentViewPort.pos.x; |
| dst.y = |
| current_overlay->hwdata->CurrentViewPort.pos.y; |
| dst.w = |
| current_overlay->hwdata->CurrentViewPort.size.w; |
| dst.h = |
| current_overlay->hwdata->CurrentViewPort.size.h; |
| current_overlay->hwdata->forcedredraw = 1; |
| error = |
| ph_DisplayYUVOverlay(this, |
| current_overlay, &src, &dst); |
| if (!error) { |
| current_overlay->hwdata->forcedredraw = 0; |
| current_overlay->hwdata->locked = lockedstate; |
| } |
| } |
| } |
| } |
| } |
| break; |
| |
| case Ph_EV_KEY: |
| { |
| SDL_keysym keysym; |
| |
| posted = 0; |
| |
| keyEvent = PhGetData(phevent); |
| |
| if (Pk_KF_Key_Down & keyEvent->key_flags) { |
| /* split the wheel events from real key events */ |
| if ((keyEvent->key_cap == Pk_Up) |
| && (keyEvent->key_scan == 0) |
| && ((keyEvent->key_flags & Pk_KF_Scan_Valid) == |
| Pk_KF_Scan_Valid)) { |
| posted = |
| SDL_PrivateMouseButton(SDL_PRESSED, |
| SDL_BUTTON_WHEELUP, 0, 0); |
| break; |
| } |
| if ((keyEvent->key_cap == Pk_Down) |
| && (keyEvent->key_scan == 0) |
| && ((keyEvent->key_flags & Pk_KF_Scan_Valid) == |
| Pk_KF_Scan_Valid)) { |
| posted = |
| SDL_PrivateMouseButton(SDL_PRESSED, |
| SDL_BUTTON_WHEELDOWN, 0, 0); |
| break; |
| } |
| posted = |
| SDL_PrivateKeyboard(SDL_PRESSED, |
| ph_TranslateKey(keyEvent, &keysym)); |
| } else { /* must be key release */ |
| |
| /* split the wheel events from real key events */ |
| if ((keyEvent->key_cap == Pk_Up) |
| && (keyEvent->key_scan == 0) |
| && ((keyEvent->key_flags & Pk_KF_Scan_Valid) == |
| Pk_KF_Scan_Valid)) { |
| posted = |
| SDL_PrivateMouseButton(SDL_RELEASED, |
| SDL_BUTTON_WHEELUP, 0, 0); |
| break; |
| } |
| if ((keyEvent->key_cap == Pk_Down) |
| && (keyEvent->key_scan == 0) |
| && ((keyEvent->key_flags & Pk_KF_Scan_Valid) == |
| Pk_KF_Scan_Valid)) { |
| posted = |
| SDL_PrivateMouseButton(SDL_RELEASED, |
| SDL_BUTTON_WHEELDOWN, 0, 0); |
| break; |
| } |
| posted = |
| SDL_PrivateKeyboard(SDL_RELEASED, |
| ph_TranslateKey(keyEvent, &keysym)); |
| } |
| } |
| break; |
| |
| case Ph_EV_INFO: |
| { |
| if (phevent->subtype == Ph_OFFSCREEN_INVALID) { |
| unsigned long *EvInfoData; |
| |
| EvInfoData = (unsigned long *) PhGetData(phevent); |
| |
| switch (*EvInfoData) { |
| case Pg_VIDEO_MODE_SWITCHED: |
| { |
| } |
| break; |
| case Pg_ENTERED_DIRECT: |
| { |
| } |
| break; |
| case Pg_EXITED_DIRECT: |
| { |
| } |
| break; |
| case Pg_DRIVER_STARTED: |
| { |
| } |
| break; |
| } |
| } |
| } |
| break; |
| } |
| |
| return (posted); |
| } |
| |
| /* perform a blocking read if no events available */ |
| int |
| ph_Pending(_THIS) |
| { |
| /* Flush the display connection and look to see if events are queued */ |
| PgFlush(); |
| |
| while (1) { |
| switch (PhEventPeek(phevent, EVENT_SIZE)) { |
| case Ph_EVENT_MSG: |
| return 1; |
| case -1: |
| SDL_SetError("ph_Pending(): PhEventNext failed.\n"); |
| return 0; |
| default: |
| return 0; |
| } |
| } |
| |
| /* Oh well, nothing is ready .. */ |
| return (0); |
| } |
| |
| void |
| ph_PumpEvents(_THIS) |
| { |
| /* Flush the display connection and look to see if events are queued */ |
| PgFlush(); |
| |
| while (ph_Pending(this)) { |
| PtEventHandler(phevent); |
| ph_DispatchEvent(this); |
| } |
| } |
| |
| void |
| ph_InitKeymap(void) |
| { |
| int i; |
| |
| /* Odd keys used in international keyboards */ |
| for (i = 0; i < SDL_arraysize(ODD_keymap); ++i) { |
| ODD_keymap[i] = SDLK_UNKNOWN; |
| } |
| |
| /* Map the miscellaneous keys */ |
| for (i = 0; i < SDL_arraysize(MISC_keymap); ++i) { |
| MISC_keymap[i] = SDLK_UNKNOWN; |
| } |
| |
| MISC_keymap[Pk_BackSpace & 0xFF] = SDLK_BACKSPACE; |
| MISC_keymap[Pk_Tab & 0xFF] = SDLK_TAB; |
| MISC_keymap[Pk_Clear & 0xFF] = SDLK_CLEAR; |
| MISC_keymap[Pk_Return & 0xFF] = SDLK_RETURN; |
| MISC_keymap[Pk_Pause & 0xFF] = SDLK_PAUSE; |
| MISC_keymap[Pk_Escape & 0xFF] = SDLK_ESCAPE; |
| MISC_keymap[Pk_Delete & 0xFF] = SDLK_DELETE; |
| |
| MISC_keymap[Pk_KP_0 & 0xFF] = SDLK_KP0; |
| MISC_keymap[Pk_KP_1 & 0xFF] = SDLK_KP1; |
| MISC_keymap[Pk_KP_2 & 0xFF] = SDLK_KP2; |
| MISC_keymap[Pk_KP_3 & 0xFF] = SDLK_KP3; |
| MISC_keymap[Pk_KP_4 & 0xFF] = SDLK_KP4; |
| MISC_keymap[Pk_KP_5 & 0xFF] = SDLK_KP5; |
| MISC_keymap[Pk_KP_6 & 0xFF] = SDLK_KP6; |
| MISC_keymap[Pk_KP_7 & 0xFF] = SDLK_KP7; |
| MISC_keymap[Pk_KP_8 & 0xFF] = SDLK_KP8; |
| MISC_keymap[Pk_KP_9 & 0xFF] = SDLK_KP9; |
| |
| MISC_keymap[Pk_KP_Decimal & 0xFF] = SDLK_KP_PERIOD; |
| MISC_keymap[Pk_KP_Divide & 0xFF] = SDLK_KP_DIVIDE; |
| MISC_keymap[Pk_KP_Multiply & 0xFF] = SDLK_KP_MULTIPLY; |
| MISC_keymap[Pk_KP_Subtract & 0xFF] = SDLK_KP_MINUS; |
| MISC_keymap[Pk_KP_Add & 0xFF] = SDLK_KP_PLUS; |
| MISC_keymap[Pk_KP_Enter & 0xFF] = SDLK_KP_ENTER; |
| MISC_keymap[Pk_KP_Equal & 0xFF] = SDLK_KP_EQUALS; |
| |
| MISC_keymap[Pk_Up & 0xFF] = SDLK_UP; |
| MISC_keymap[Pk_Down & 0xFF] = SDLK_DOWN; |
| MISC_keymap[Pk_Right & 0xFF] = SDLK_RIGHT; |
| MISC_keymap[Pk_Left & 0xFF] = SDLK_LEFT; |
| MISC_keymap[Pk_Insert & 0xFF] = SDLK_INSERT; |
| MISC_keymap[Pk_Home & 0xFF] = SDLK_HOME; |
| MISC_keymap[Pk_End & 0xFF] = SDLK_END; |
| MISC_keymap[Pk_Pg_Up & 0xFF] = SDLK_PAGEUP; |
| MISC_keymap[Pk_Pg_Down & 0xFF] = SDLK_PAGEDOWN; |
| |
| MISC_keymap[Pk_F1 & 0xFF] = SDLK_F1; |
| MISC_keymap[Pk_F2 & 0xFF] = SDLK_F2; |
| MISC_keymap[Pk_F3 & 0xFF] = SDLK_F3; |
| MISC_keymap[Pk_F4 & 0xFF] = SDLK_F4; |
| MISC_keymap[Pk_F5 & 0xFF] = SDLK_F5; |
| MISC_keymap[Pk_F6 & 0xFF] = SDLK_F6; |
| MISC_keymap[Pk_F7 & 0xFF] = SDLK_F7; |
| MISC_keymap[Pk_F8 & 0xFF] = SDLK_F8; |
| MISC_keymap[Pk_F9 & 0xFF] = SDLK_F9; |
| MISC_keymap[Pk_F10 & 0xFF] = SDLK_F10; |
| MISC_keymap[Pk_F11 & 0xFF] = SDLK_F11; |
| MISC_keymap[Pk_F12 & 0xFF] = SDLK_F12; |
| MISC_keymap[Pk_F13 & 0xFF] = SDLK_F13; |
| MISC_keymap[Pk_F14 & 0xFF] = SDLK_F14; |
| MISC_keymap[Pk_F15 & 0xFF] = SDLK_F15; |
| |
| MISC_keymap[Pk_Num_Lock & 0xFF] = SDLK_NUMLOCK; |
| MISC_keymap[Pk_Caps_Lock & 0xFF] = SDLK_CAPSLOCK; |
| MISC_keymap[Pk_Scroll_Lock & 0xFF] = SDLK_SCROLLOCK; |
| MISC_keymap[Pk_Shift_R & 0xFF] = SDLK_RSHIFT; |
| MISC_keymap[Pk_Shift_L & 0xFF] = SDLK_LSHIFT; |
| MISC_keymap[Pk_Control_R & 0xFF] = SDLK_RCTRL; |
| MISC_keymap[Pk_Control_L & 0xFF] = SDLK_LCTRL; |
| MISC_keymap[Pk_Alt_R & 0xFF] = SDLK_RALT; |
| MISC_keymap[Pk_Alt_L & 0xFF] = SDLK_LALT; |
| MISC_keymap[Pk_Meta_R & 0xFF] = SDLK_RMETA; |
| MISC_keymap[Pk_Meta_L & 0xFF] = SDLK_LMETA; |
| MISC_keymap[Pk_Super_L & 0xFF] = SDLK_LSUPER; |
| MISC_keymap[Pk_Super_R & 0xFF] = SDLK_RSUPER; |
| MISC_keymap[Pk_Mode_switch & 0xFF] = SDLK_MODE; /* "Alt Gr" key */ |
| |
| MISC_keymap[Pk_Help & 0xFF] = SDLK_HELP; |
| MISC_keymap[Pk_Print & 0xFF] = SDLK_PRINT; |
| MISC_keymap[Pk_Break & 0xFF] = SDLK_BREAK; |
| MISC_keymap[Pk_Menu & 0xFF] = SDLK_MENU; /* Windows "Menu" key */ |
| |
| MISC_keymap[Pk_Hyper_R & 0xFF] = SDLK_RSUPER; /* Right "Windows" */ |
| |
| /* Left "Windows" key, but it can't be catched by application */ |
| MISC_keymap[Pk_Hyper_L & 0xFF] = SDLK_LSUPER; |
| } |
| |
| static unsigned long cap; |
| |
| SDL_keysym * |
| ph_TranslateKey(PhKeyEvent_t * key, SDL_keysym * keysym) |
| { |
| /* 'sym' is set to the value of the key with modifiers applied to it. |
| This member is valid only if Pk_KF_Sym_Valid is set in the key_flags. |
| We will assume it is valid. */ |
| |
| /* FIXME: This needs to check whether the cap & scancode is valid */ |
| |
| cap = key->key_cap; |
| |
| switch (cap >> 8) { |
| case 0x00: /* Latin 1 */ |
| case 0x01: /* Latin 2 */ |
| case 0x02: /* Latin 3 */ |
| case 0x03: /* Latin 4 */ |
| case 0x04: /* Katakana */ |
| case 0x05: /* Arabic */ |
| case 0x06: /* Cyrillic */ |
| case 0x07: /* Greek */ |
| case 0x08: /* Technical */ |
| case 0x0A: /* Publishing */ |
| case 0x0C: /* Hebrew */ |
| case 0x0D: /* Thai */ |
| keysym->sym = (SDLKey) (cap & 0xFF); |
| /* Map capital letter syms to lowercase */ |
| if ((keysym->sym >= 'A') && (keysym->sym <= 'Z')) |
| keysym->sym += ('a' - 'A'); |
| break; |
| case 0xF0: |
| keysym->sym = MISC_keymap[cap & 0xFF]; |
| break; |
| default: |
| keysym->sym = SDLK_UNKNOWN; |
| break; |
| } |
| |
| keysym->scancode = key->key_scan; |
| keysym->unicode = 0; |
| |
| if (SDL_TranslateUNICODE) { |
| char utf8[MB_CUR_MAX]; |
| int utf8len; |
| wchar_t unicode; |
| |
| switch (keysym->scancode) { |
| /* Esc key */ |
| case 0x01: |
| keysym->unicode = 27; |
| break; |
| /* BackSpace key */ |
| case 0x0E: |
| keysym->unicode = 127; |
| break; |
| /* Enter key */ |
| case 0x1C: |
| keysym->unicode = 10; |
| break; |
| default: |
| utf8len = PhKeyToMb(utf8, key); |
| if (utf8len > 0) { |
| utf8len = mbtowc(&unicode, utf8, utf8len); |
| if (utf8len > 0) { |
| keysym->unicode = unicode; |
| } |
| } |
| break; |
| } |
| |
| } |
| |
| return (keysym); |
| } |
| |
| void |
| ph_InitOSKeymap(_THIS) |
| { |
| ph_InitKeymap(); |
| } |
| |
| /* vi: set ts=4 sw=4 expandtab: */ |
