/*

SDL - Simple DirectMedia Layer

Copyright (C) 1997-2004 Sam Lantinga

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Library 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

Library General Public License for more details.

You should have received a copy of the GNU Library General Public

License along with this library; if not, write to the Free

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Sam Lantinga

slouken@libsdl.org

*/

#ifdef SAVE_RCSID

static char rcsid =

"@(#) $Id$";

#endif

/* Handle the event stream, converting photon events into SDL events */

#define DISABLE_X11

#include <stdio.h>

#include <setjmp.h>

#include <sys/time.h>

#include <sys/neutrino.h>

#include <Ph.h>

#include <photon/PkKeyDef.h>

#include "SDL.h"

#include "SDL_syswm.h"

#include "SDL_sysevents.h"

#include "SDL_sysvideo.h"

#include "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, &region, NULL, NULL, 0) == 0 )

{

region.events_sense=(region.events_sense & ~fields)|(flags & fields);

PhRegionChange(Ph_REGION_EV_SENSE, 0, &region, 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 (event->type)

{

case Ph_EV_BOUNDARY:

{

if (event->subtype == Ph_EV_PTR_ENTER)

{

posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);

}

else if (event->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(event);

rect = PhGetRects(event);

if (mouse_relative)

{

posted = ph_WarpedMotion(this, event);

}

else

{

posted = SDL_PrivateMouseMotion(0, 0, rect->ul.x, rect->ul.y);

}

}

}

break;

case Ph_EV_BUT_PRESS:

{

pointerEvent = PhGetData( event );

buttons = ph2sdl_mousebutton( pointerEvent->buttons );

if (buttons != 0)

{

posted = SDL_PrivateMouseButton(SDL_PRESSED, buttons, 0, 0);

}

}

break;

case Ph_EV_BUT_RELEASE:

{

pointerEvent = PhGetData(event);

buttons = ph2sdl_mousebutton(pointerEvent->buttons);

if (event->subtype == Ph_EV_RELEASE_REAL && buttons != 0)

{

posted = SDL_PrivateMouseButton(SDL_RELEASED, buttons, 0, 0);

}

else if(event->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(event);

/* 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 target;

current_overlay->hwdata->locked=1;

target.x=current_overlay->hwdata->CurrentViewPort.pos.x;

target.y=current_overlay->hwdata->CurrentViewPort.pos.y;

target.w=current_overlay->hwdata->CurrentViewPort.size.w;

target.h=current_overlay->hwdata->CurrentViewPort.size.h;

current_overlay->hwdata->ischromakey=0;

error=ph_DisplayYUVOverlay(this, current_overlay, &target);

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 (event->num_rects!=0)

{

int numrects;

if (SDL_VideoSurface)

{

rect = PhGetRects(event);

if (event->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<event->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, event->num_rects, sdlrects);

if (current_overlay!=NULL)

{

int lockedstate=current_overlay->hwdata->locked;

int error;

SDL_Rect target;

current_overlay->hwdata->locked=1;

target.x=current_overlay->hwdata->CurrentViewPort.pos.x;

target.y=current_overlay->hwdata->CurrentViewPort.pos.y;

target.w=current_overlay->hwdata->CurrentViewPort.size.w;

target.h=current_overlay->hwdata->CurrentViewPort.size.h;

current_overlay->hwdata->forcedredraw=1;

error=ph_DisplayYUVOverlay(this, current_overlay, &target);

if (!error)

{

current_overlay->hwdata->forcedredraw=0;

current_overlay->hwdata->locked=lockedstate;

}

}

}

}

}

break;

case Ph_EV_KEY:

{

SDL_keysym keysym;

posted = 0;

keyEvent = PhGetData( event );

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 (event->subtype==Ph_OFFSCREEN_INVALID)

{

unsigned long* EvInfoData;

EvInfoData=(unsigned long*)PhGetData(event);

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(event, 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(event);

ph_DispatchEvent(this);

}

}

void ph_InitKeymap(void)

{

int i;

/* Odd keys used in international keyboards */

for (i=0; i<SDL_TABLESIZE(ODD_keymap); ++i)

{

ODD_keymap[i] = SDLK_UNKNOWN;

}

/* Map the miscellaneous keys */

for (i=0; i<SDL_TABLESIZE(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();

}