Cronocide/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2025-01-23 03:58:59 +00:00
Code Issues Packages Projects Releases Wiki Activity
44eae3de9d
Descent3/ddio_lnx/lnxkey_xwin.cpp
Azamat H. Hackimov 38128ea134 Additional clang-format
2024-04-17 00:25:04 +03:00

393 lines
7.6 KiB
C++
Raw Blame History

/*
* $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;
}
}
}
Reference in New Issue View Git Blame Copy Permalink