/*
* $Logfile: /DescentIII/Main/ddio_lnx/lnxkey_xwin.cpp $
* $Revision: 1.1.1.1 $
* $Date: 2000/04/18 00:00:33 $
* $Author: icculus $
*
* Linux Xwindows routines
*
* $Log: lnxkey_xwin.cpp,v $
* Revision 1.1.1.1  2000/04/18 00:00:33  icculus
* initial checkin
*
 * 
 * 6     8/19/99 3:45p Jeff
 * commented out mprintfs
 * 
 * 5     8/19/99 1:32p Jeff
 * fixed o key. Added scroll lock, caps lock and print screen keys.
 * 
 * 4     7/15/99 11:37a Jeff
 * moved autorepeat calls to lnxapp.cpp
 * 
 * 3     7/14/99 9:06p Jeff
 * added comment header
*
* $NoKeywords: $
*/

#include "pserror.h"
#include "mono.h"
#include "ddio.h"
#include "ddio_lnx.h"
#include "application.h"
#include "../lib/linux/dyna_xwin.h"
#include "../lib/linux/dyna_xext.h"

//#include <X11/Xlib.h>
//#include <X11/Xutil.h>
#include <X11/keysym.h>

extern volatile struct tLnxKeys
{
	union{
		int up_ticks;
		float up_time;
	};
	union{
		int down_ticks;
		float down_time;
	};
	bool status;
}LKeys[DDIO_MAX_KEYS];

// we need this for our XWindows calls.
static Display *X_display = NULL; 

bool ddio_xwin_InternalKeyInit(ddio_init_info *init_info)
{
	oeLnxApplication *app = (oeLnxApplication *)init_info->obj;

	X_display = app->m_Display;
	
//reset key list
	for(int i=0;i<DDIO_MAX_KEYS; i++)
	{
		LKeys[i].down_ticks = 0;
  		LKeys[i].up_ticks = 0;
  		LKeys[i].status = false;
  	}
  
	return true;
}

void ddio_xwin_InternalKeyClose()
{
	//Don't call any X functions here! At this point the XLib has been unloaded
	if (X_display) {		
		X_display = NULL;
	}
}

bool ddio_xwin_InternalKeyState(ubyte key)
{
	return LKeys[key].status;
}

void ddio_xwin_InternalKeySuspend()
{
}


void ddio_xwin_InternalKeyResume()
{
}

float ddio_xwin_InternalKeyDownTime(ubyte key)
{
	float down_time = 0.0f;
	if(LKeys[key].status)
	{
		float timer = timer_GetTime();
		down_time = timer - LKeys[key].down_time;
		LKeys[key].down_time = timer;
	}else
	{
		down_time = LKeys[key].up_time - LKeys[key].down_time;
		LKeys[key].down_time = LKeys[key].up_time = 0.0f;
	}

	return down_time;
}

void ddio_xwin_InternalResetKey(ubyte key)
{
	LKeys[key].down_time = 0.0f;
	LKeys[key].up_time = 0.0f;
	LKeys[key].status = false;
}

int xkey_to_ddiocode[27] = { 0, KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J, KEY_K, KEY_L, KEY_M, KEY_N,
			KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T, KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z
};

inline ubyte xkeycode_to_keycode(unsigned int xkeycode)
{
	int rc =  XKeycodeToKeysym(X_display, xkeycode, 0);

// unceremoniously taken from Heretic source code with a few modifications.
	switch (rc)
	{
		case XK_Delete:		rc = KEY_DELETE;        break; 
		case XK_Insert:		rc = KEY_INSERT;        break;
      	case XK_Page_Up:	rc = KEY_PAGEUP;        break; 
      	case XK_Page_Down:	rc = KEY_PAGEDOWN;      break; 
      	case XK_Home:		rc = KEY_HOME;          break; 
      	case XK_End:		rc = KEY_END;           break;
      	case XK_Left:		rc = KEY_LEFT;			break;
      	case XK_Right:		rc = KEY_RIGHT;			break;
      	case XK_Down:		rc = KEY_DOWN;			break;
      	case XK_Up:			rc = KEY_UP;			break;
      	case XK_Escape:		rc = KEY_ESC;			break;
      	case XK_Return:		rc = KEY_ENTER;			break;
      	case XK_Tab:		rc = KEY_TAB;			break;
      	case XK_F1:			rc = KEY_F1;			break;
      	case XK_F2:			rc = KEY_F2;			break;
      	case XK_F3:			rc = KEY_F3;			break;
      	case XK_F4:			rc = KEY_F4;			break;
      	case XK_F5:			rc = KEY_F5;			break;
      	case XK_F6:			rc = KEY_F6;			break;
      	case XK_F7:			rc = KEY_F7;			break;
      	case XK_F8:			rc = KEY_F8;			break;
      	case XK_F9:			rc = KEY_F9;			break;
      	case XK_F10:		rc = KEY_F10;			break;
      	case XK_F11:		rc = KEY_F11;			break;
      	case XK_F12:		rc = KEY_F12;			break;
      	case XK_BackSpace:	rc = KEY_BACKSP;	    break;
      	case XK_Pause:		rc = KEY_PAUSE;			break;
      	case XK_KP_Add:		rc = KEY_PADPLUS;		break;
       	case XK_KP_Subtract: rc = KEY_PADMINUS;		break;
       	case XK_KP_Enter:	rc = KEY_PADENTER;		break;
       	case XK_KP_Decimal:	rc = KEY_PADPERIOD;		break;
       	case XK_KP_Divide:	rc = KEY_PADDIVIDE;		break;
       	case XK_KP_Multiply: rc = KEY_PADMULTIPLY;	break;
       	case XK_KP_0: 		rc = KEY_PAD0;			break;
       	case XK_KP_1: 		rc = KEY_PAD1;			break;
       	case XK_KP_2: 		rc = KEY_PAD2;			break;       	       	
       	case XK_KP_3: 		rc = KEY_PAD3;			break;
       	case XK_KP_4: 		rc = KEY_PAD4;			break;
       	case XK_KP_5: 		rc = KEY_PAD5;			break;
       	case XK_KP_6: 		rc = KEY_PAD6;			break;
       	case XK_KP_7: 		rc = KEY_PAD7;			break;       	       	       	       	       	
       	case XK_KP_8: 		rc = KEY_PAD8;			break;
       	case XK_KP_9: 		rc = KEY_PAD9;			break;
       	case XK_space:		rc = KEY_SPACEBAR;	break;
       	case XK_1:			rc = KEY_1; 			break;
       	case XK_2:			rc = KEY_2; 			break;
       	case XK_3:			rc = KEY_3; 			break;
       	case XK_4:			rc = KEY_4; 			break;
       	case XK_5:			rc = KEY_5; 			break;
       	case XK_6:			rc = KEY_6; 			break;
       	case XK_7:			rc = KEY_7; 			break;
       	case XK_8:			rc = KEY_8; 			break;
       	case XK_9:			rc = KEY_9; 			break;
       	case XK_0:			rc = KEY_0; 			break;
       	
// since we look at unmodified keycodes, we don't have to worry about shifted states, I think.
		case XK_equal:		rc = KEY_EQUAL;			break;
       	case XK_minus:		rc = KEY_MINUS;			break;
       	case XK_bracketleft:	rc = KEY_LBRACKET;	break;
       	case XK_bracketright:	rc = KEY_RBRACKET;	break;
       	case XK_backslash:	rc = KEY_BACKSLASH;		break;
       	case XK_quoteleft:	rc = KEY_LAPOSTRO;		break;
       	case XK_quoteright: rc = KEY_RAPOSTRO;		break;
       	case XK_semicolon:	rc = KEY_SEMICOL;		break;
       	case XK_period:		rc = KEY_PERIOD;		break;
       	case XK_slash:		rc = KEY_SLASH;			break;
       	case XK_comma:		rc = KEY_COMMA;			break;
		case XK_Num_Lock:	rc = KEY_NUMLOCK;		break;
		case XK_Print:		rc = KEY_PRINT_SCREEN;	break;
		case XK_Scroll_Lock: rc = KEY_SCROLLOCK;	break;
		case XK_Caps_Lock:
		case XK_Shift_Lock: rc = KEY_CAPSLOCK;		break;

// modifier keys	
		case XK_Shift_L:	rc = KEY_LSHIFT;		break;
		case XK_Shift_R:	rc = KEY_RSHIFT;		break;
		case XK_Control_L:	rc = KEY_LCTRL;			break;
		case XK_Control_R:	rc = KEY_RCTRL;			break;
      	case XK_Alt_L:
      	case XK_Meta_L:		rc = KEY_LALT;			break;
      	case XK_Alt_R:
      	case XK_Meta_R:		rc = KEY_RALT;			break;

// convert 'a' - 'z' to 0-27, and then convert to ddio format.
	default:
		if (rc >= XK_a && rc <= XK_z) {
			rc = (rc - XK_a)+1;  
		}
		else if (rc >= XK_A && rc <= XK_Z) {
			rc = (rc - XK_A)+1;
		}
		else {
			rc = 0;
		}
		ASSERT(rc >= 0 && rc <=26);
		rc = xkey_to_ddiocode[rc];
		break;
    }

    return (ubyte)rc;
}


void ddio_xwin_InternalKeyFrame(void)
{
	XEvent evt;
	
//	this is the big function.  
//	we'll grab all the keyboard events from the event queue currently
//	and process them accordingly.

	while (XCheckMaskEvent(X_display,KeyPressMask|KeyReleaseMask,&evt))
	{
		ubyte kc;
		
		switch(evt.type)
		{
			case KeyPress:
				kc =  xkeycode_to_keycode(evt.xkey.keycode);
				LKeys[kc].down_time = timer_GetTime();
				LKeys[kc].status = true;
				ddio_UpdateKeyState(kc, true);	
				//mprintf((0, "key %x down (state=%d).\n", (int)kc, (int)evt.xkey.state));
				break;

			case KeyRelease:
				kc = xkeycode_to_keycode(evt.xkey.keycode);
				if (LKeys[kc].status) {
					LKeys[kc].up_time = timer_GetTime();
					LKeys[kc].status = false;
					ddio_UpdateKeyState(kc, false);
					//mprintf((0, "key %x up (state=%d).\n", (int)kc, (int)evt.xkey.state));
				}
				break;
		}	
	}
}