/*
* $Logfile: /DescentIII/Main/ddio_lnx/lnxkey_sdl.cpp $
* $Revision: 1.6 $
* $Date: 2001/02/07 09:18:02 $
* $Author: icculus $
*
* Linux Xwindows routines
*
* $Log: lnxkey_sdl.cpp,v $
* Revision 1.6  2001/02/07 09:18:02  icculus
* Fullscreen/windowed toggle keybinding attempts to toggle regardless of
* renderer, now. Otherwise, 2D surfaces (movies) wouldn't toggle. Glide uses
* can just risk it.
*
* Revision 1.5  2001/01/11 11:40:53  icculus
* Added CTRL-G and ALT-Enter keybindings.
*
* Revision 1.4  2000/09/22 19:01:49  icculus
* SDLK_WORLD* support.
*
* Revision 1.3  2000/06/29 09:52:45  hercules
* Don't poll for events twice per frame (already done in mouse driver)
*
* Revision 1.2  2000/06/24 01:15:15  icculus
* patched to compile.
*
* Revision 1.1  2000/04/27 11:16:01  icculus
* First (and hopefully last) commit.
*
* 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 "SDL.h"
#include "pserror.h"
#include "mono.h"
#include "ddio.h"
#include "ddio_lnx.h"
#include "application.h"

#ifdef __PERMIT_GL_LOGGING
void DGL_EnableLogging( int enable );
extern bool __glLog;
#endif

extern bool ddio_mouseGrabbed;

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


int sdlkey_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 sdlkeycode_to_keycode(unsigned int sdlkeycode)
{
// unceremoniously taken from Heretic source code with a few modifications.
//  (by Outrage. Not Loki. We know better.  :)  --ryan.)
    int rc = sdlkeycode;

	switch (rc)
	{
		case SDLK_DELETE:		rc = KEY_DELETE;        break;
		case SDLK_INSERT:		rc = KEY_INSERT;        break;
      	case SDLK_PAGEUP:	    rc = KEY_PAGEUP;        break;
      	case SDLK_PAGEDOWN:	    rc = KEY_PAGEDOWN;      break;
      	case SDLK_HOME:		    rc = KEY_HOME;          break;
      	case SDLK_END:		    rc = KEY_END;           break;
      	case SDLK_LEFT:		    rc = KEY_LEFT;			break;
      	case SDLK_RIGHT:		rc = KEY_RIGHT;			break;
      	case SDLK_DOWN:		    rc = KEY_DOWN;			break;
      	case SDLK_UP:			rc = KEY_UP;			break;
      	case SDLK_ESCAPE:		rc = KEY_ESC;			break;
      	case SDLK_RETURN:		rc = KEY_ENTER;			break;
      	case SDLK_TAB:		    rc = KEY_TAB;			break;
      	case SDLK_F1:			rc = KEY_F1;			break;
      	case SDLK_F2:			rc = KEY_F2;			break;
      	case SDLK_F3:			rc = KEY_F3;			break;
      	case SDLK_F4:			rc = KEY_F4;			break;
      	case SDLK_F5:			rc = KEY_F5;			break;
      	case SDLK_F6:			rc = KEY_F6;			break;
      	case SDLK_F7:			rc = KEY_F7;			break;
      	case SDLK_F8:			rc = KEY_F8;			break;
      	case SDLK_F9:			rc = KEY_F9;			break;
      	case SDLK_F10:		    rc = KEY_F10;			break;
      	case SDLK_F11:		    rc = KEY_F11;			break;
      	case SDLK_F12:		    rc = KEY_F12;			break;
      	case SDLK_BACKSPACE:	rc = KEY_BACKSP;	    break;
      	case SDLK_PAUSE:		rc = KEY_PAUSE;			break;
      	case SDLK_KP_PLUS:		rc = KEY_PADPLUS;		break;
       	case SDLK_KP_MINUS:     rc = KEY_PADMINUS;		break;
       	case SDLK_KP_ENTER:	    rc = KEY_PADENTER;		break;
       	case SDLK_KP_PERIOD:	rc = KEY_PADPERIOD;		break;
       	case SDLK_KP_DIVIDE:	rc = KEY_PADDIVIDE;		break;
       	case SDLK_KP_MULTIPLY:  rc = KEY_PADMULTIPLY;	break;
       	case SDLK_KP0: 		    rc = KEY_PAD0;			break;
       	case SDLK_KP1: 	    	rc = KEY_PAD1;			break;
       	case SDLK_KP2:   		rc = KEY_PAD2;			break;
       	case SDLK_KP3: 		    rc = KEY_PAD3;			break;
       	case SDLK_KP4: 	    	rc = KEY_PAD4;			break;
       	case SDLK_KP5:   		rc = KEY_PAD5;			break;
       	case SDLK_KP6: 		    rc = KEY_PAD6;			break;
       	case SDLK_KP7: 	    	rc = KEY_PAD7;			break;
       	case SDLK_KP8:  		rc = KEY_PAD8;			break;
       	case SDLK_KP9: 		    rc = KEY_PAD9;			break;
       	case SDLK_SPACE:		rc = KEY_SPACEBAR;	    break;
       	case SDLK_1:			rc = KEY_1; 			break;
       	case SDLK_2:			rc = KEY_2; 			break;
       	case SDLK_3:			rc = KEY_3; 			break;
       	case SDLK_4:			rc = KEY_4; 			break;
       	case SDLK_5:			rc = KEY_5; 			break;
       	case SDLK_6:			rc = KEY_6; 			break;
       	case SDLK_7:			rc = KEY_7; 			break;
       	case SDLK_8:			rc = KEY_8; 			break;
       	case SDLK_9:			rc = KEY_9; 			break;
       	case SDLK_0:			rc = KEY_0; 			break;

// modifier keys
		case SDLK_LSHIFT:	    rc = KEY_LSHIFT;		break;
		case SDLK_RSHIFT:   	rc = KEY_RSHIFT;		break;
		case SDLK_LCTRL:	    rc = KEY_LCTRL;			break;
		case SDLK_RCTRL:	    rc = KEY_RCTRL;			break;
      	case SDLK_LALT:
      	case SDLK_LMETA:	    rc = KEY_LALT;			break;
      	case SDLK_RALT:
      	case SDLK_RMETA:   	    rc = KEY_RALT;			break;
       	
// since we look at unmodified keycodes, we don't have to worry about shifted states, I think.
		case SDLK_EQUALS:		rc = KEY_EQUAL;			break;
       	case SDLK_MINUS:		rc = KEY_MINUS;			break;
       	case SDLK_LEFTBRACKET:	rc = KEY_LBRACKET;	    break;
       	case SDLK_RIGHTBRACKET:	rc = KEY_RBRACKET;	    break;
       	case SDLK_BACKSLASH:	rc = KEY_BACKSLASH;		break;
       	case SDLK_BACKQUOTE:	rc = KEY_LAPOSTRO;		break;
       	case SDLK_QUOTE:        rc = KEY_RAPOSTRO;		break;
       	case SDLK_SEMICOLON:	rc = KEY_SEMICOL;		break;
       	case SDLK_PERIOD:		rc = KEY_PERIOD;		break;
       	case SDLK_SLASH:		rc = KEY_SLASH;			break;
       	case SDLK_COMMA:		rc = KEY_COMMA;			break;
		case SDLK_NUMLOCK:	    rc = KEY_NUMLOCK;		break;
		case SDLK_PRINT:		rc = KEY_PRINT_SCREEN;	break;
		case SDLK_SCROLLOCK:    rc = KEY_SCROLLOCK;	    break;
		case SDLK_CAPSLOCK:     rc = KEY_CAPSLOCK;		break;

// world keys. Ugh.
        case SDLK_WORLD_0:      rc = KEY_WORLD0;        break;
        case SDLK_WORLD_1:      rc = KEY_WORLD1;        break;
        case SDLK_WORLD_2:      rc = KEY_WORLD2;        break;
        case SDLK_WORLD_3:      rc = KEY_WORLD3;        break;
        case SDLK_WORLD_4:      rc = KEY_WORLD4;        break;
        case SDLK_WORLD_5:      rc = KEY_WORLD5;        break;
        case SDLK_WORLD_6:      rc = KEY_WORLD6;        break;
        case SDLK_WORLD_7:      rc = KEY_WORLD7;        break;
        case SDLK_WORLD_8:      rc = KEY_WORLD8;        break;
        case SDLK_WORLD_9:      rc = KEY_WORLD9;        break;
        case SDLK_WORLD_10:     rc = KEY_WORLD10;       break;
        case SDLK_WORLD_11:     rc = KEY_WORLD11;       break;
        case SDLK_WORLD_12:     rc = KEY_WORLD12;       break;
        case SDLK_WORLD_13:     rc = KEY_WORLD13;       break;
        case SDLK_WORLD_14:     rc = KEY_WORLD14;       break;
        case SDLK_WORLD_15:     rc = KEY_WORLD15;       break;
        case SDLK_WORLD_16:     rc = KEY_WORLD16;       break;
        case SDLK_WORLD_17:     rc = KEY_WORLD17;       break;
        case SDLK_WORLD_18:     rc = KEY_WORLD18;       break;
        case SDLK_WORLD_19:     rc = KEY_WORLD19;       break;
        case SDLK_WORLD_20:     rc = KEY_WORLD20;       break;
        case SDLK_WORLD_21:     rc = KEY_WORLD21;       break;
        case SDLK_WORLD_22:     rc = KEY_WORLD22;       break;
        case SDLK_WORLD_23:     rc = KEY_WORLD23;       break;
        case SDLK_WORLD_24:     rc = KEY_WORLD24;       break;
        case SDLK_WORLD_25:     rc = KEY_WORLD25;       break;
        case SDLK_WORLD_26:     rc = KEY_WORLD26;       break;
        case SDLK_WORLD_27:     rc = KEY_WORLD27;       break;
        case SDLK_WORLD_28:     rc = KEY_WORLD28;       break;
        case SDLK_WORLD_29:     rc = KEY_WORLD29;       break;
        case SDLK_WORLD_30:     rc = KEY_WORLD30;       break;
        case SDLK_WORLD_31:     rc = KEY_WORLD31;       break;
        case SDLK_WORLD_32:     rc = KEY_WORLD32;       break;
        case SDLK_WORLD_33:     rc = KEY_WORLD33;       break;
        case SDLK_WORLD_34:     rc = KEY_WORLD34;       break;
        case SDLK_WORLD_35:     rc = KEY_WORLD35;       break;
        case SDLK_WORLD_36:     rc = KEY_WORLD36;       break;
        case SDLK_WORLD_37:     rc = KEY_WORLD37;       break;
        case SDLK_WORLD_38:     rc = KEY_WORLD38;       break;
        case SDLK_WORLD_39:     rc = KEY_WORLD39;       break;
        case SDLK_WORLD_40:     rc = KEY_WORLD40;       break;
        case SDLK_WORLD_41:     rc = KEY_WORLD41;       break;
        case SDLK_WORLD_42:     rc = KEY_WORLD42;       break;
        case SDLK_WORLD_43:     rc = KEY_WORLD43;       break;
        case SDLK_WORLD_44:     rc = KEY_WORLD44;       break;
        case SDLK_WORLD_45:     rc = KEY_WORLD45;       break;
        case SDLK_WORLD_46:     rc = KEY_WORLD46;       break;
        case SDLK_WORLD_47:     rc = KEY_WORLD47;       break;
        case SDLK_WORLD_48:     rc = KEY_WORLD48;       break;
        case SDLK_WORLD_49:     rc = KEY_WORLD49;       break;
        case SDLK_WORLD_50:     rc = KEY_WORLD50;       break;
        case SDLK_WORLD_51:     rc = KEY_WORLD51;       break;
        case SDLK_WORLD_52:     rc = KEY_WORLD52;       break;
        case SDLK_WORLD_53:     rc = KEY_WORLD53;       break;
        case SDLK_WORLD_54:     rc = KEY_WORLD54;       break;
        case SDLK_WORLD_55:     rc = KEY_WORLD55;       break;
        case SDLK_WORLD_56:     rc = KEY_WORLD56;       break;
        case SDLK_WORLD_57:     rc = KEY_WORLD57;       break;
        case SDLK_WORLD_58:     rc = KEY_WORLD58;       break;
        case SDLK_WORLD_59:     rc = KEY_WORLD59;       break;
        case SDLK_WORLD_60:     rc = KEY_WORLD60;       break;
        case SDLK_WORLD_61:     rc = KEY_WORLD61;       break;
        case SDLK_WORLD_62:     rc = KEY_WORLD62;       break;
        case SDLK_WORLD_63:     rc = KEY_WORLD63;       break;
        case SDLK_WORLD_64:     rc = KEY_WORLD64;       break;
        case SDLK_WORLD_65:     rc = KEY_WORLD65;       break;
        case SDLK_WORLD_66:     rc = KEY_WORLD66;       break;
        case SDLK_WORLD_67:     rc = KEY_WORLD67;       break;
        case SDLK_WORLD_68:     rc = KEY_WORLD68;       break;
        case SDLK_WORLD_69:     rc = KEY_WORLD69;       break;
        case SDLK_WORLD_70:     rc = KEY_WORLD70;       break;
        case SDLK_WORLD_71:     rc = KEY_WORLD71;       break;
        case SDLK_WORLD_72:     rc = KEY_WORLD72;       break;
        case SDLK_WORLD_73:     rc = KEY_WORLD73;       break;
        case SDLK_WORLD_74:     rc = KEY_WORLD74;       break;
        case SDLK_WORLD_75:     rc = KEY_WORLD75;       break;
        case SDLK_WORLD_76:     rc = KEY_WORLD76;       break;
        case SDLK_WORLD_77:     rc = KEY_WORLD77;       break;
        case SDLK_WORLD_78:     rc = KEY_WORLD78;       break;
        case SDLK_WORLD_79:     rc = KEY_WORLD79;       break;
        case SDLK_WORLD_80:     rc = KEY_WORLD80;       break;
        case SDLK_WORLD_81:     rc = KEY_WORLD81;       break;
        case SDLK_WORLD_82:     rc = KEY_WORLD82;       break;
        case SDLK_WORLD_83:     rc = KEY_WORLD83;       break;
        case SDLK_WORLD_84:     rc = KEY_WORLD84;       break;
        case SDLK_WORLD_85:     rc = KEY_WORLD85;       break;
        case SDLK_WORLD_86:     rc = KEY_WORLD86;       break;
        case SDLK_WORLD_87:     rc = KEY_WORLD87;       break;
        case SDLK_WORLD_88:     rc = KEY_WORLD88;       break;
        case SDLK_WORLD_89:     rc = KEY_WORLD89;       break;
        case SDLK_WORLD_90:     rc = KEY_WORLD90;       break;
        case SDLK_WORLD_91:     rc = KEY_WORLD91;       break;
        case SDLK_WORLD_92:     rc = KEY_WORLD92;       break;
        case SDLK_WORLD_93:     rc = KEY_WORLD93;       break;
        case SDLK_WORLD_94:     rc = KEY_WORLD94;       break;
        case SDLK_WORLD_95:     rc = KEY_WORLD95;       break;

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

    return (ubyte)rc;
}


int sdlKeyFilter(const SDL_Event *event)
{
    ubyte kc = 0;

    if ((event->type != SDL_KEYUP) && (event->type != SDL_KEYDOWN))
        return(1);

   	switch(event->key.state)
   	{
   		case SDL_PRESSED:
   			kc = sdlkeycode_to_keycode(event->key.keysym.sym);
            if (event->key.keysym.mod & KMOD_CTRL)
            {
                switch (kc)
                {
                    case KEY_G:   // toggle grabbed input.
                        if ( ddio_mouseGrabbed )
                        {
                            SDL_WM_GrabInput(SDL_GRAB_OFF);
                            ddio_mouseGrabbed = false;
                        } // if
                        else
                        {
                            SDL_WM_GrabInput(SDL_GRAB_ON);
                            ddio_mouseGrabbed = true;
                        } // else
                        return(0);

                    #ifdef __PERMIT_GL_LOGGING
                    case KEY_INSERT:
                        if (__glLog == false)
                        {
                            DGL_EnableLogging(1);
                            __glLog = true;
                            mprintf((0, "OpenGL: Logging enabled."));
                        } // if
                        return(0);

                    case KEY_DELETE:
                        if (__glLog == true)
                        {
                            DGL_EnableLogging(0);
                            __glLog = false;
                            mprintf((0, "OpenGL: Logging disabled."));
                        } // if
                        return(0);
                    #endif
                } // switch
            } // if

            else if (event->key.keysym.mod & KMOD_ALT)
            {
                if ((kc == KEY_ENTER) || (kc == KEY_PADENTER))
                {
                    SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
                    return(0);
                } // if
            } // else if

   			LKeys[kc].down_time = timer_GetTime();
   			LKeys[kc].status = true;
   			ddio_UpdateKeyState(kc, true);
   			break;

   		case SDL_RELEASED:
   			kc = sdlkeycode_to_keycode(event->key.keysym.sym);
   			if (LKeys[kc].status)
            {
   				LKeys[kc].up_time = timer_GetTime();
   				LKeys[kc].status = false;
   				ddio_UpdateKeyState(kc, false);
   			} // if
   			break;
   	} // switch

    return(0);
} // sdlKeyFilter


bool ddio_sdl_InternalKeyInit(ddio_init_info *init_info)
{
        //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;
  	}

    SDL_EventState(SDL_KEYDOWN, SDL_ENABLE);
    SDL_EventState(SDL_KEYUP, SDL_ENABLE);
	return true;
}

void ddio_sdl_InternalKeyClose()
{
}

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

void ddio_sdl_InternalKeySuspend()
{
}


void ddio_sdl_InternalKeyResume()
{
}

float ddio_sdl_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_sdl_InternalResetKey(ubyte key)
{
	LKeys[key].down_time = 0.0f;
	LKeys[key].up_time = 0.0f;
	LKeys[key].status = false;
}


void ddio_sdl_InternalKeyFrame(void)
{
    // Sam 6/28 - This is already done in the mouse handling code
    //SDL_PumpEvents();
}