/*

    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"

#include <qpe/qpeapplication.h>

#include <stdio.h>

#include <string.h>

#include "SDL_error.h"

#include "SDL_events.h"

#include "SDL_QWin.h"

#include "SDL_lowvideo.h"

#include "SDL_timer.h"

extern "C" {

#include "../../events/SDL_sysevents.h"

#include "../../events/SDL_events_c.h"

#include "SDL_sysevents_c.h"

  //  static SDLKey keymap[128];

/* This is special because we know it will be run in a loop in a separate

   thread.  Normally this function should loop as long as there are input

   states changing, i.e. new events arriving.

*/

void QT_PumpEvents(_THIS)

{

  if(!qApp) {

    return; 

  }

  //  printf("processing events: %p\n", qApp);

  //qApp->processOneEvent(); // wait for a event

  qApp->processEvents(); // and process all outstanding ones

#if 0

  BView *view;

	BRect bounds;

	BPoint point;

	uint32 buttons;

	const uint32 button_masks[3] = {

		B_PRIMARY_MOUSE_BUTTON,

		B_TERTIARY_MOUSE_BUTTON, 

		B_SECONDARY_MOUSE_BUTTON,

	};

	unsigned int    i, j;

	/* Check out the mouse buttons and position (slight race condition) */

	if ( SDL_Win->Lock() ) {

		/* Don't do anything if we have no view */

		view = SDL_Win->View();

		if ( ! view ) {

			SDL_Win->Unlock();

			return;

		}

		bounds = view->Bounds();

		/* Get new input state, if still active */

		if ( SDL_Win->IsActive() ) {

			key_flip = !key_flip;

			get_key_info(&keyinfo[key_flip]);

			view->GetMouse(&point, &buttons, true);

		} else {

			key_flip = key_flip;

			point = last_point;

			buttons = last_buttons;

		}

		SDL_Win->Unlock();

	} else {

		return;

	}

	/* If our view is active, we'll find key changes here */

	if ( SDL_memcmp(keyinfo[0].key_states, keyinfo[1].key_states, 16) != 0 ) {

		for ( i=0; i<16; ++i ) {

			Uint8 new_state, transition;

			new_state = keyinfo[key_flip].key_states[i];

			transition = keyinfo[!key_flip].key_states[i] ^

					keyinfo[ key_flip].key_states[i];

			for ( j=0; j<8; ++j ) {

				if ( transition&0x80 )

					QueueKey(i*8+j, new_state&0x80);

				transition <<= 1;

				new_state <<= 1;

			}

		}

	}

	/* We check keyboard, but not mouse if mouse isn't in window */

	if ( ! bounds.Contains(point) ) {

		/* Mouse moved outside our view? */

		if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {

			SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);

			be_app->SetCursor(B_HAND_CURSOR);

		}

		return;

	}

	/* Has the mouse moved back into our view? */

	if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {

		/* Reset the B_HAND_CURSOR to our own */

		SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);

		SDL_SetCursor(NULL);

	}

	/* Check for mouse motion */

	if ( point != last_point ) {

		int x, y;

		SDL_Win->GetXYOffset(x, y);

		x = (int)point.x - x;

		y = (int)point.y - y;

		SDL_PrivateMouseMotion(0, 0, x, y);

	}

	last_point = point;

	/* Add any mouse button events */

	for ( i=0; i<SDL_TABLESIZE(button_masks); ++i ) {

		if ( (buttons ^ last_buttons) & button_masks[i] ) {

			if ( buttons & button_masks[i] ) {

				SDL_PrivateMouseButton(SDL_PRESSED, 1+i, 0, 0);

			} else {

				SDL_PrivateMouseButton(SDL_RELEASED, 1+i, 0, 0);

			}

		}

	}

	last_buttons = buttons;

#endif

}

void QT_InitOSKeymap(_THIS)

{

#if 0

  unsigned int i;

  /* Initialize all the key states as "up" */

  key_flip = 0;

  SDL_memset(keyinfo[key_flip].key_states, 0, 16);

  /* Initialize the key translation table */

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

    keymap[i] = SDLK_UNKNOWN;

  //  keymap[0x01]		= SDLK_ESCAPE;

  //  keymap[B_F1_KEY]	= SDLK_F1;

  //  keymap[B_F2_KEY]	= SDLK_F2;

  //  keymap[B_F3_KEY]	= SDLK_F3;

  //  keymap[B_F4_KEY]	= SDLK_F4;

  //  keymap[B_F5_KEY]	= SDLK_F5;

  //  keymap[B_F6_KEY]	= SDLK_F6;

  //  keymap[B_F7_KEY]	= SDLK_F7;

  //  keymap[B_F8_KEY]	= SDLK_F8;

  //  keymap[B_F9_KEY]	= SDLK_F9;

  //  keymap[B_F10_KEY]	= SDLK_F10;

  //  keymap[B_F11_KEY]	= SDLK_F11;

  //  keymap[B_F12_KEY]	= SDLK_F12;

  //  keymap[B_PRINT_KEY]	= SDLK_PRINT;

  //keymap[B_SCROLL_KEY]	= SDLK_SCROLLOCK;

  //  keymap[B_PAUSE_KEY]	= SDLK_PAUSE;

  keymap[0x11]		= SDLK_BACKQUOTE;

  keymap[0x12]		= SDLK_1;

  keymap[0x13]		= SDLK_2;

  keymap[0x14]		= SDLK_3;

  keymap[0x15]		= SDLK_4;

  keymap[0x16]		= SDLK_5;

  keymap[0x17]		= SDLK_6;

  keymap[0x18]		= SDLK_7;

  keymap[0x19]		= SDLK_8;

  keymap[0x1a]		= SDLK_9;

  keymap[0x1b]		= SDLK_0;

  keymap[0x1c]		= SDLK_MINUS;

  keymap[0x1d]		= SDLK_EQUALS;

  keymap[0x1e]		= SDLK_BACKSPACE;

  keymap[0x1f]		= SDLK_INSERT;

  keymap[0x20]		= SDLK_HOME;

  keymap[0x21]		= SDLK_PAGEUP;

  //keymap[0x22]		= SDLK_NUMLOCK;

  keymap[0x23]		= SDLK_KP_DIVIDE;

  keymap[0x24]		= SDLK_KP_MULTIPLY;

  keymap[0x25]		= SDLK_KP_MINUS;

  keymap[0x26]		= SDLK_TAB;

  keymap[0x27]		= SDLK_q;

  keymap[0x28]		= SDLK_w;

  keymap[0x29]		= SDLK_e;

  keymap[0x2a]		= SDLK_r;

  keymap[0x2b]		= SDLK_t;

  keymap[0x2c]		= SDLK_y;

  keymap[0x2d]		= SDLK_u;

  keymap[0x2e]		= SDLK_i;

  keymap[0x2f]		= SDLK_o;

  keymap[0x30]		= SDLK_p;

  keymap[0x31]		= SDLK_LEFTBRACKET;

  keymap[0x32]		= SDLK_RIGHTBRACKET;

  keymap[0x33]		= SDLK_BACKSLASH;

  keymap[0x34]		= SDLK_DELETE;

  keymap[0x35]		= SDLK_END;

  keymap[0x36]		= SDLK_PAGEDOWN;

  keymap[0x37]		= SDLK_KP7;

  keymap[0x38]		= SDLK_KP8;

  keymap[0x39]		= SDLK_KP9;

  keymap[0x3a]		= SDLK_KP_PLUS;

  //keymap[0x3b]		= SDLK_CAPSLOCK;

  keymap[0x3c]		= SDLK_a;

  keymap[0x3d]		= SDLK_s;

  keymap[0x3e]		= SDLK_d;

  keymap[0x3f]		= SDLK_f;

  keymap[0x40]		= SDLK_g;

  keymap[0x41]		= SDLK_h;

  keymap[0x42]		= SDLK_j;

  keymap[0x43]		= SDLK_k;

  keymap[0x44]		= SDLK_l;

  keymap[0x45]		= SDLK_SEMICOLON;

  keymap[0x46]		= SDLK_QUOTE;

  keymap[0x47]		= SDLK_RETURN;

  keymap[0x48]		= SDLK_KP4;

  keymap[0x49]		= SDLK_KP5;

  keymap[0x4a]		= SDLK_KP6;

  keymap[0x4b]		= SDLK_LSHIFT;

  keymap[0x4c]		= SDLK_z;

  keymap[0x4d]		= SDLK_x;

  keymap[0x4e]		= SDLK_c;

  keymap[0x4f]		= SDLK_v;

  keymap[0x50]		= SDLK_b;

  keymap[0x51]		= SDLK_n;

  keymap[0x52]		= SDLK_m;

  keymap[0x53]		= SDLK_COMMA;

  keymap[0x54]		= SDLK_PERIOD;

  keymap[0x55]		= SDLK_SLASH;

  keymap[0x56]		= SDLK_RSHIFT;

  keymap[0x57]		= SDLK_UP;

  keymap[0x58]		= SDLK_KP1;

  keymap[0x59]		= SDLK_KP2;

  keymap[0x5a]		= SDLK_KP3;

  keymap[0x5b]		= SDLK_KP_ENTER;

  //keymap[0x5c]		= SDLK_LCTRL;

  //keymap[0x5d]		= SDLK_LALT;

  keymap[0x5e]		= SDLK_SPACE;

  //keymap[0x5f]		= SDLK_RALT;

  //keymap[0x60]		= SDLK_RCTRL;

  keymap[0x61]		= SDLK_LEFT;

  keymap[0x62]		= SDLK_DOWN;

  keymap[0x63]		= SDLK_RIGHT;

  keymap[0x64]		= SDLK_KP0;

  keymap[0x65]		= SDLK_KP_PERIOD;

  //keymap[0x66]		= SDLK_LMETA;

  //keymap[0x67]		= SDLK_RMETA;

  //keymap[0x68]		= SDLK_MENU;

  keymap[0x69]		= SDLK_EURO;

  keymap[0x6a]		= SDLK_KP_EQUALS;

  keymap[0x6b]		= SDLK_POWER;

#endif

}

}; /* Extern C */