void event_callback(XPointer priv, XRecordInterceptData *hook)
{
/* FIXME: we need use XQueryPointer to get the first location */
static int cur_x = 0;
static int cur_y = 0;
if (hook->category != XRecordFromServer) {
XRecordFreeData (hook);
return;
}
XRecordDatum *data = (XRecordDatum*) hook->data;
int event_type = data->type;
BYTE btncode, keycode;
btncode = keycode = data->event.u.u.detail;
int rootx = data->event.u.keyButtonPointer.rootX;
int rooty = data->event.u.keyButtonPointer.rootY;
int time = hook->server_time;
switch (event_type) {
case KeyPress:
/* if escape is pressed, stop the loop and clean up, then exit */
if (keycode == 9) stop = 1;
/* Note: you should not use data_disp to do normal X operations !!!*/
printf ("KeyPress: \t%s\n", XKeysymToString(XKeycodeToKeysym(ctrl_disp, keycode, 0)));
break;
case KeyRelease:
printf ("KeyRelease: \t%s\n", XKeysymToString(XKeycodeToKeysym(ctrl_disp, keycode, 0)));
break;
case ButtonPress:
/* printf ("ButtonPress: /t%d, rootX=%d, rootY=%d", btncode, cur_x, cur_y); */
break;
case ButtonRelease:
/* printf ("ButtonRelease: /t%d, rootX=%d, rootY=%d", btncode, cur_x, cur_y); */
break;
case MotionNotify:
/* printf ("MouseMove: /trootX=%d, rootY=%d",rootx, rooty); */
cur_x = rootx;
cur_y = rooty;
break;
case CreateNotify:
break;
case DestroyNotify:
break;
case NoExpose:
break;
case Expose:
break;
default:
break;
}
printf (", time=%d\n", time);
XRecordFreeData (hook);
}
EAPI int
ecore_x_test_fake_key_press(const char *key)
{
#ifdef ECORE_XTEST
KeyCode keycode = 0;
KeySym keysym = 0;
int shift = 0;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
if (!strncmp(key, "Keycode-", 8))
keycode = atoi(key + 8);
else
{
keysym = XStringToKeysym(key);
if (keysym == NoSymbol) return 0;
keycode = XKeysymToKeycode(_ecore_x_disp, keysym);
if (XKeycodeToKeysym(_ecore_x_disp, keycode, 0) != keysym)
{
if (XKeycodeToKeysym(_ecore_x_disp, keycode, 1) == keysym)
shift = 1;
else
keycode = 0;
}
else
shift = 0;
}
if (keycode == 0)
{
static int mod = 0;
KeySym *keysyms;
int keycode_min, keycode_max, keycode_num;
int i;
XDisplayKeycodes(_ecore_x_disp, &keycode_min, &keycode_max);
keysyms = XGetKeyboardMapping(_ecore_x_disp, keycode_min,
keycode_max - keycode_min + 1,
&keycode_num);
mod = (mod + 1) & 0x7;
i = (keycode_max - keycode_min - mod - 1) * keycode_num;
keysyms[i] = keysym;
XChangeKeyboardMapping(_ecore_x_disp, keycode_min, keycode_num,
keysyms, (keycode_max - keycode_min));
XFree(keysyms);
XSync(_ecore_x_disp, False);
keycode = keycode_max - mod - 1;
}
if (shift)
XTestFakeKeyEvent(_ecore_x_disp,
XKeysymToKeycode(_ecore_x_disp, XK_Shift_L), 1, 0);
XTestFakeKeyEvent(_ecore_x_disp, keycode, 1, 0);
XTestFakeKeyEvent(_ecore_x_disp, keycode, 0, 0);
if (shift)
XTestFakeKeyEvent(_ecore_x_disp,
XKeysymToKeycode(_ecore_x_disp, XK_Shift_L), 0, 0);
return 1;
#else
return 0;
#endif
}
// returned een string gemaakt van key en add (shift)
char *key2string (int key, int add) {
char soort[15], ascii[10];
if (XKeycodeToKeysym(display, key, 0) == XK_BackSpace)
strcpy(ascii, "Backspace");
else
sprintf(ascii, "%c", (int) XKeycodeToKeysym(display, key, 0));
switch (XKeycodeToKeysym(display, add, 0)) {
case GDK_Control_L:
case GDK_Control_R:
strcpy(soort, "control - ");
break;
case GDK_Shift_L:
case GDK_Shift_R:
strcpy(soort, "shift - ");
break;
case GDK_Alt_L:
strcpy(soort, "alt - ");
break;
default:
strcpy(soort, "");
}
sprintf(toetsen, "%s%s", soort, ascii);
return toetsen;
}
void MCScreenDC::getkeysdown(MCExecPoint &ep)
{
char kstring[U4L];
char km[32];
ep.clear();
MCmodifierstate = querymods();
XQueryKeymap(dpy, km);
bool first = true;
uint2 i;
KeySym ksym;
for (i = 0; i < 256; i++)
{
if (isKeyPressed(km, i))
{
ksym = i;
if (MCmodifierstate & MS_SHIFT || MCmodifierstate & MS_CAPS_LOCK)
ksym = XKeycodeToKeysym(dpy, i, 1);
else
ksym = XKeycodeToKeysym(dpy, i, 0);
if (ksym > 0)
{
ep.concatuint(ksym, EC_COMMA, first);
first = false;
}
}
}
}
int HandleEvents()
{
#if 0
XEvent event;
int ret = 0;
if (XPending(dpy)) {
do {
XNextEvent(dpy, &event);
switch(event.type) {
case KeyPress:
keyboard_handler(XKeycodeToKeysym(dpy, event.xkey.keycode, 0), 1);
ret = 1;
break;
case KeyRelease:
keyboard_handler(XKeycodeToKeysym(dpy, event.xkey.keycode, 0), 0);
ret = 0;
break;
case Expose:
BlastScreen();
break;
case ClientMessage:
if (event.xclient.data.l[0] == wmDeleteWindow)
Quit(NULL);
break;
default:
break;
}
} while (XPending(dpy));
}
return ret;
#else
return 0;
#endif
}
void ungrab_key (int key_code)
{
GdkWindow *root=gdk_get_default_root_window();
gdk_error_trap_push ();
XUngrabKey (GDK_DISPLAY (), key_code, AnyModifier,
(GDK_WINDOW_XID (root) ? GDK_WINDOW_XID (root) : DefaultRootWindow (GDK_DISPLAY())));
XUngrabKey (GDK_DISPLAY (), AnyKey, AnyModifier, (GDK_WINDOW_XID (root) ? GDK_WINDOW_XID (root) : DefaultRootWindow (GDK_DISPLAY())));
gdk_flush ();
if (gdk_error_trap_pop ())
{
gchar *error;
gchar *key;
key=g_strdup_printf ("%s",(XKeysymToString (XKeycodeToKeysym (GDK_DISPLAY (), key_code, 0)) != NULL)?
XKeysymToString (XKeycodeToKeysym (GDK_DISPLAY (),key_code, 0)):
g_strdup_printf ("%d",key_code));
error = g_strdup_printf
(_("It seems that another application already has"
" access to the multimedia keys.\n"
"Key %s couldn't be bound.\n"
"Is another daemon already running ?\n"),
key);
show_error(error);
printf("[Sven][ERROR]:%s",error);
g_free (key);
g_free (error);
}
}
void
update_key_ring (XPointer priv, XRecordInterceptData *data)
{
static int meta = 0;
static int ctrl = 0;
static int shift = 0;
xEvent *event;
KeySym ks;
char *display_string;
char *ksname;
if (data->category==XRecordFromServer) {
event=(xEvent *)data->data;
/* display_keystack(keystack); */
switch (event->u.u.type) {
case KeyPress:
ks = XKeycodeToKeysym(d0, event->u.u.detail, 0);
ksname = XKeysymToString (ks); /* TBD: Might have to handle no symbol keys */
if (! process_modifiers(ks, &meta, &ctrl, &shift, 1)) {
display_string = create_emacs_keyname(ksname, meta, ctrl, shift);
push(keystack, display_string);
display_keystrokes(osd, keystack);
}
break;
case KeyRelease:
ks = XKeycodeToKeysym(d0, event->u.u.detail, 0);
process_modifiers(ks, &meta, &ctrl, &shift, 0);
break;
}
}
}
bool KKeyNative::init(const KKey &key)
{
// Get any extra mods required by the sym.
// E.g., XK_Plus requires SHIFT on the en layout.
m_sym = key.sym();
uint modExtra = KKeyServer::Sym(m_sym).getModsRequired();
// Get the X modifier equivalent.
if(!m_sym || !KKeyServer::modToModX(key.modFlags() | modExtra, m_mod))
{
m_sym = m_mod = 0;
m_code = 0;
return false;
}
// XKeysymToKeycode returns the wrong keycode for XK_Print and XK_Break.
// Specifically, it returns the code for SysReq instead of Print
// Only do this for the default Xorg layout, other keycode mappings
// (e.g. evdev) don't need or want it.
if(m_sym == XK_Print && !(m_mod & Mod1Mask) && XKeycodeToKeysym(qt_xdisplay(), 111, 0) == XK_Print)
m_code = 111; // code for Print
else if(m_sym == XK_Break || ((m_sym == XK_Pause && (m_mod & ControlMask)) && XKeycodeToKeysym(qt_xdisplay(), 114, 0) == XK_Pause))
m_code = 114;
else
m_code = XKeysymToKeycode(qt_xdisplay(), m_sym);
if(!m_code && m_sym)
kdDebug(125) << "Couldn't get code for sym" << endl;
// Now get the true sym formed by the modifiers
// E.g., Shift+Equal => Plus on the en layout.
if(key.modFlags() && ((m_sym < XK_Home || m_sym > XK_Begin) && m_sym != XK_Insert && m_sym != XK_Delete))
KKeyServer::codeXToSym(m_code, m_mod, m_sym);
return true;
}
bool GLWindow::GetEvent(Event &event){
if(XPending(dpy)){
XEvent xev;
// Keyboard Key Press (Keysym code available in /usr/include/X11/keysymdef.h)
if( XCheckWindowEvent(dpy, glWin, KeyPressMask, &xev) )
{
event.type = TMGL_Press;
KeySym ks = XKeycodeToKeysym(dpy, xev.xkey.keycode, 0);
MapKey(ks, event.input);
}
// Keyboard Key Release (Keysym code available in /usr/include/X11/keysymdef.h)
else if(XCheckWindowEvent(dpy, glWin, KeyReleaseMask, &xev))
{
event.type = TMGL_Release;
KeySym ks = XKeycodeToKeysym(dpy, xev.xkey.keycode, 0);
MapKey(ks, event.input);
}
// Mouse Button Press
else if(XCheckWindowEvent(dpy, glWin, ButtonPressMask, &xev))
{
event.type = TMGL_Press;
MapMouse(xev.xbutton.button, event.input);
}
// Mouse Button Release
else if(XCheckWindowEvent(dpy, glWin, ButtonReleaseMask, &xev))
{
event.type = TMGL_Release;
MapMouse(xev.xbutton.button, event.input);
}
// Mouse Motion
else if(XCheckWindowEvent(dpy, glWin, PointerMotionMask, &xev))
{
event.type = TMGL_Motion;
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
}
// Window Exposure
else if(XCheckWindowEvent(dpy, glWin, ExposureMask, &xev))
{
XWindowAttributes gwa;
event.type = TMGL_Expose;
XGetWindowAttributes(dpy, glWin, &gwa);
event.expose.width = gwa.width;
event.expose.height = gwa.height;
}
// Other Events
else
{
return false;
}
return true;
}
return false;
}
ENTRYPOINT Bool hypertorus_handle_event(ModeInfo *mi, XEvent *event)
{
Display *display = MI_DISPLAY(mi);
hypertorusstruct *hp = &hyper[MI_SCREEN(mi)];
KeySym sym;
if (event->xany.type == ButtonPress &&
event->xbutton.button == Button1)
{
hp->button_pressed = True;
gltrackball_start(hp->trackballs[hp->current_trackball],
event->xbutton.x, event->xbutton.y,
MI_WIDTH(mi), MI_HEIGHT(mi));
return True;
}
else if (event->xany.type == ButtonRelease &&
event->xbutton.button == Button1)
{
hp->button_pressed = False;
return True;
}
else if (event->xany.type == KeyPress)
{
sym = XKeycodeToKeysym(display,event->xkey.keycode,0);
if (sym == XK_Shift_L || sym == XK_Shift_R)
{
hp->current_trackball = 1;
if (hp->button_pressed)
gltrackball_start(hp->trackballs[hp->current_trackball],
event->xbutton.x, event->xbutton.y,
MI_WIDTH(mi), MI_HEIGHT(mi));
return True;
}
}
else if (event->xany.type == KeyRelease)
{
sym = XKeycodeToKeysym(display,event->xkey.keycode,0);
if (sym == XK_Shift_L || sym == XK_Shift_R)
{
hp->current_trackball = 0;
if (hp->button_pressed)
gltrackball_start(hp->trackballs[hp->current_trackball],
event->xbutton.x, event->xbutton.y,
MI_WIDTH(mi), MI_HEIGHT(mi));
return True;
}
}
else if (event->xany.type == MotionNotify && hp->button_pressed)
{
gltrackball_track(hp->trackballs[hp->current_trackball],
event->xmotion.x, event->xmotion.y,
MI_WIDTH(mi), MI_HEIGHT(mi));
return True;
}
return False;
}
int main(int argc, char **argv)
{
Display *display;
XEvent xevent;
Window window;
if( (display = XOpenDisplay(NULL)) == NULL )
return -1;
window = DefaultRootWindow(display);
XAllowEvents(display, AsyncBoth, CurrentTime);
XGrabPointer(display,
window,
1,
PointerMotionMask | ButtonPressMask | ButtonReleaseMask ,
GrabModeAsync,
GrabModeAsync,
None,
None,
CurrentTime);
XGrabKeyboard(display, window, false, GrabModeAsync, GrabModeAsync, CurrentTime);
while(1) {
XNextEvent(display, &xevent);
int mykey;
switch (xevent.type) {
case MotionNotify:
printf("Mouse move : [%d, %d]\n", xevent.xmotion.x_root, xevent.xmotion.y_root);
break;
case ButtonPress:
printf("Button pressed : %s, %d\n", key_name[xevent.xbutton.button - 1], xevent.xbutton.button);
break;
case ButtonRelease:
printf("Button released : %s, %d\n", key_name[xevent.xbutton.button - 1], xevent.xbutton.button);
break;
case KeyPress:
mykey = XKeycodeToKeysym(display, xevent.xkey.keycode, 0);
printf("KeyPress : %s, %d\n", XKeysymToString(mykey), mykey);
if (xevent.xkey.keycode == 27 || xevent.xkey.keycode == 9) {
return 0;
}
break;
case KeyRelease:
mykey = XKeycodeToKeysym(display, xevent.xkey.keycode, 0);
printf("KeyRelease : %s, %d\n", XKeysymToString(mykey), mykey);
break;
}
}
return 0;
}
int main(void) {
Display *d;
Window w;
XEvent e;
KeySym key;
int s;
d = XOpenDisplay(NULL);
if (d == NULL) {
fprintf(stderr, "Cannot open display\n");
exit(1);
}
s = DefaultScreen(d);
w = XCreateSimpleWindow(d, RootWindow(d, s), 10, 10, 200, 200, 1,
BlackPixel(d, s), WhitePixel(d, s));
XSelectInput(d, w, ExposureMask | KeyPressMask | KeyReleaseMask);
XMapWindow(d, w);
XGrabKeyboard(d, DefaultRootWindow(d), True, GrabModeAsync, GrabModeAsync, CurrentTime);
while (1) {
XNextEvent(d, &e);
if (e.type == KeyPress) {
key = XKeycodeToKeysym(d, e.xkey.keycode, 0);
} else if (e.type == KeyRelease) {
key = XKeycodeToKeysym(d, e.xkey.keycode, 0);
printf("Release: %c\n", key);
// This is really a hack since it does not correctly handle non-alnum keys.
if(txtidx > 0) {
txtidx--;
}
memmove(txtbuf, txtbuf+1, sizeof(txtbuf)-2);
txtbuf[sizeof(txtbuf)-2] = (char)key;
TrySpellcheck(d, key);
}
if (e.type == KeyPress) {
key = XKeycodeToKeysym(d, e.xkey.keycode, 0);
if (key == XK_Alt_L) {
// Exit on pressing Alt
break;
}
}
}
XUngrabKeyboard(d, CurrentTime);
XCloseDisplay(d);
return 0;
}
void tela_processa_eventos(tela_t *tela)
{
/* processa eventos do servidor X, atualizando a posicao do mouse
* e ultima tecla pressionada na variavel da tela-> */
XEvent evento;
XButtonEvent *be = (XButtonEvent *) & evento;
XMotionEvent *me = (XMotionEvent *) & evento;
XKeyEvent *ke = (XKeyEvent *) & evento;
while (XCheckMaskEvent(tela->display, EVENT_MASK, &evento) == True) {
switch (evento.type) {
case ButtonPress:
if (be->button == 1) tela->botao = true;
break;
case ButtonRelease:
if (be->button == 1) tela->botao = false;
break;
case MotionNotify:
tela->rato.x = XX2U(me->x);
tela->rato.y = YX2U(me->y);
break;
case KeyPress:
// se a tecla anterior nao foi lida, e' perdida
tela->tecla = XKeycodeToKeysym(tela->display, ke->keycode, 0);
break;
case KeyRelease:
break;
}
}
}
static void
translate_key_event (ClutterBackend *backend,
ClutterEvent *event,
XEvent *xevent)
{
char buffer[256+1];
int n;
CLUTTER_NOTE (EVENT, "Translating key %s event",
xevent->xany.type == KeyPress ? "press" : "release");
event->key.time = xevent->xkey.time;
event->key.modifier_state = (ClutterModifierType) xevent->xkey.state;
event->key.hardware_keycode = xevent->xkey.keycode;
/* keyval is the key ignoring all modifiers ('1' vs. '!') */
event->key.keyval =
XKeycodeToKeysym (xevent->xkey.display,
xevent->xkey.keycode,
0);
/* unicode_value is the printable representation */
n = XLookupString (&xevent->xkey, buffer, sizeof (buffer) - 1, NULL, NULL);
if (n != NoSymbol)
{
event->key.unicode_value = g_utf8_get_char_validated (buffer, n);
if ((event->key.unicode_value != -1) &&
(event->key.unicode_value != -2))
return;
}
event->key.unicode_value = (gunichar)'\0';
}
static void
mapping_busy_key(int timeout)
{
int i;
unsigned char keymap[32];
static unsigned int masktable[8] = {
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
};
XQueryKeymap (dpy, (char *) keymap);
fprintf (stderr,
"%s: please release the following keys within %d seconds:\n",
ProgramName, timeout);
for (i = 0; i < 256; i++) {
if (keymap[i >> 3] & masktable[i & 7]) {
KeySym ks = XKeycodeToKeysym (dpy, (KeyCode) i, 0);
char *cp = XKeysymToString (ks);
fprintf (stderr, " %s (keysym 0x%x, keycode %d)\n",
cp ? cp : "UNNAMED", (unsigned int)ks, i);
}
}
sleep (timeout);
return;
}
Bool keydown(wm_t *wm, wm_event_t *event) {
XKeyEvent kev = event->xevent->xkey;
KeySym sym;
wm_log(wm, LOG_INFO, "%s", __func__);
sym = XKeycodeToKeysym(wm->dpy, kev.keycode, 0);
wm_log(wm, LOG_INFO, "%s: key %d / %d", __func__, sym, XK_j);
if (kev.state == Mod1Mask) {
switch (sym) {
case XK_j:
container_split(current_container, SPLIT_VERTICAL);
break;
case XK_h:
container_split(current_container, SPLIT_HORIZONTAL);
break;
default:
wm_log(wm, LOG_WARN, "%s: unexpected keysym %d", __func__, sym);
}
}
switch (sym) {
case XK_Return:
run("xterm -bg black -fg white");
break;
}
XUngrabServer(wm->dpy);
return True;
}
std::string keypress_str()
{
if (e.type == KeyPress)
return XKeysymToString(XKeycodeToKeysym(dpy,e.xkey.keycode,0));
return "0";
}
/*
* Fetch one entry from the device's keymap if supported.
* this does a fake mapping based on the orginal DFB code
*/
static DFBResult
driver_get_keymap_entry( CoreInputDevice *device,
void *driver_data,
DFBInputDeviceKeymapEntry *entry )
{
int i;
X11InputData *data = driver_data;
DFBX11 *x11 = data->x11;
XLockDisplay( x11->display );
for (i=0; i<4; i++) {
KeySym xSymbol = XKeycodeToKeysym( x11->display, entry->code, i );
if (i == 0)
entry->identifier = xsymbol_to_id( xSymbol );
entry->symbols[i] = xsymbol_to_symbol( xSymbol );
}
XUnlockDisplay( x11->display );
/* is CapsLock effective? */
if (entry->identifier >= DIKI_A && entry->identifier <= DIKI_Z)
entry->locks |= DILS_CAPS;
/* is NumLock effective? */
if (entry->identifier >= DIKI_KP_DECIMAL && entry->identifier <= DIKI_KP_9)
entry->locks |= DILS_NUM;
return DFB_OK;
}
int GetKey(void)
{
long keysym;
lastKey=NO_KEY;
handleEvents();
if (lastKey!=NO_KEY)
{
keysym=(long)XKeycodeToKeysym(display,lastKey,0);
switch (keysym & 0x0000FFFF)
{
case 65505: // left shift
case 65506: // right shift
case 65507: // left ctrl
case 65508: // right ctrl
case 65513: // left alt
case 65514: // right alt
return NO_KEY;
case 65293: // enter
case 65421: // num enter
return 13;
case 65288: // backspace
return 8;
case 65289: // tab
return 9;
}
return (int)(keysym & 0x0000FFFF);
} else {
return NO_KEY;
}
}
/* we need a keycode + modifier to generate the proper keysym (such as
@). Return 1 if successful, 0 otherwise. This function can fail if a
keysym doesn't map to a keycode. */
static int
keysym_to_keycode_mod (KeySym keysym, KeyCode *code, unsigned int *mod)
{
KeySym lower, upper;
*mod = 0;
*code = XKeysymToKeycode (dpy, keysym);
lower = XKeycodeToKeysym (dpy, *code, 0);
upper = XKeycodeToKeysym (dpy, *code, 1);
/* If you need to press shift to get the keysym, add the shift
mask. */
if (upper == keysym && lower != keysym)
*mod = ShiftMask;
return *code != 0;
}
void UModifier::mapKeys(UDisp* d) {
static bool mods_init = false;
if (mods_init) return;
mods_init = true;
Display* sysdisp = ((UDispX11*)d)->getSysDisp();
_MetaDown = Mod1Mask; // valeur qui peut varier suivant les plateformes
_AltDown = Mod2Mask; // idem
_ModeSwitch = 0; // cf a la fin
_MetaDown = _AltDown = _ModeSwitch = 0;
XModifierKeymap* modmap = XGetModifierMapping(sysdisp);
if (!modmap) return;
// 8 modifiers dans tous les cas de figures (definis ou pas)
for (int m = 0; m < 8; m++) {
// plusieurs keycodes par modifiers, de 0 a max_keypermod
for (int c = 0; c < modmap->max_keypermod; c++) {
KeyCode keycode = modmap->modifiermap[m * modmap->max_keypermod + c];
if (keycode != 0) {
KeySym keysym = XKeycodeToKeysym(sysdisp, keycode, 0);
if (keysym == XK_Meta_L || keysym == XK_Meta_R)
_MetaDown = (1 << m);
else if (keysym == XK_Alt_L || keysym == XK_Alt_R)
_AltDown = (1 << m);
else if (keysym == XK_Mode_switch)
_ModeSwitch = (1 << m);
}
}
}
XFreeModifiermap(modmap);
}
void Window::Run(){
running = true;
while (running)
{
//struct timeval timeNow;
while (XPending(display))
{
XEvent ev;
XNextEvent(display, &ev);
switch (ev.type)
{
case KeyPress:
{
unsigned int keycode, keysym;
keycode = ((XKeyEvent *)&ev)->keycode;
keysym = XKeycodeToKeysym(display, keycode, 0);
if (keysym == XK_Return || keysym == XK_Escape)
running = false;
}
break;
}
}
if (running)
{
//gettimeofday(&timeNow, NULL);
//appRender(timeNow.tv_sec * 1000 + timeNow.tv_usec / 1000,
// sWindowWidth, sWindowHeight);
//checkGLErrors();
//eglSwapBuffers(sEglDisplay, sEglSurface);
//checkEGLErrors();
}
}
}
void
print_key (Display * d, Keys_t * key)
{
char str[STR_KEY_LEN];
if (verbose)
{
if (key->type == SYM)
{
modifier_to_string (key->modifier, str);
printf ("\"%s\"\n %s%s%s%s\n",
key->command != NULL ? key->command : ( key->function != 0 ? "(Scheme function)" : "NoCommand" ),
key->event_type == PRESS ? "" : "Release + ",
str, str[0] ? " + " : "", XKeysymToString (key->key.sym));
}
else if (key->type == BUTTON)
{
printf ("\"%s\"\n %sm:0x%x + b:%d (mouse)\n",
key->command != NULL ? key->command : ( key->function != 0 ? "(Scheme function)" : "NoCommand" ),
key->event_type == PRESS ? "" : "Release + ",
key->modifier, key->key.button);
}
else
{
printf ("\"%s\"\n %sm:0x%x + c:%d\n",
key->command != NULL ? key->command : ( key->function != 0 ? "(Scheme function)" : "NoCommand" ),
key->event_type == PRESS ? "" : "Release + ",
key->modifier, key->key.code);
if (d != NULL)
{
modifier_to_string (key->modifier, str);
printf (" %s%s%s%s\n",
str,
str[0] ? " + " : "",
key->event_type == PRESS ? "" : "Release + ",
(XKeysymToString
(XKeycodeToKeysym (d, key->key.code, 0)) !=
NULL) ? XKeysymToString (XKeycodeToKeysym (d,
key->key.
code,
0)) :
"NoSymbol");
}
}
}
}
uint32_t GLXEventHandler::_getKey( XEvent& event )
{
int index = 0;
if( event.xkey.state & ShiftMask )
index = 1;
const KeySym key = XKeycodeToKeysym( event.xany.display,
event.xkey.keycode, index );
switch( key )
{
case XK_Escape: return KC_ESCAPE;
case XK_BackSpace: return KC_BACKSPACE;
case XK_Return: return KC_RETURN;
case XK_Tab: return KC_TAB;
case XK_Home: return KC_HOME;
case XK_Left: return KC_LEFT;
case XK_Up: return KC_UP;
case XK_Right: return KC_RIGHT;
case XK_Down: return KC_DOWN;
case XK_Page_Up: return KC_PAGE_UP;
case XK_Page_Down: return KC_PAGE_DOWN;
case XK_End: return KC_END;
case XK_F1: return KC_F1;
case XK_F2: return KC_F2;
case XK_F3: return KC_F3;
case XK_F4: return KC_F4;
case XK_F5: return KC_F5;
case XK_F6: return KC_F6;
case XK_F7: return KC_F7;
case XK_F8: return KC_F8;
case XK_F9: return KC_F9;
case XK_F10: return KC_F10;
case XK_F11: return KC_F11;
case XK_F12: return KC_F12;
case XK_F13: return KC_F13;
case XK_F14: return KC_F14;
case XK_F15: return KC_F15;
case XK_F16: return KC_F16;
case XK_F17: return KC_F17;
case XK_F18: return KC_F18;
case XK_F19: return KC_F19;
case XK_F20: return KC_F20;
case XK_Shift_L: return KC_SHIFT_L;
case XK_Shift_R: return KC_SHIFT_R;
case XK_Control_L: return KC_CONTROL_L;
case XK_Control_R: return KC_CONTROL_R;
case XK_Alt_L: return KC_ALT_L;
case XK_Alt_R: return KC_ALT_R;
default:
if( (key >= XK_space && key <= XK_asciitilde ) ||
(key >= XK_nobreakspace && key <= XK_ydiaeresis))
{
return key;
}
EQWARN << "Unrecognized X11 key code " << key << std::endl;
return KC_VOID;
}
}
unsigned long wrapXkbKeycodeToKeysym(Display *pDisplay, unsigned char cCode,
unsigned int cGroup, unsigned int cIndex)
{
KeySym cSym = XkbKeycodeToKeysym(pDisplay, cCode, cGroup, cIndex);
if (cSym != NoSymbol)
return cSym;
return XKeycodeToKeysym(pDisplay, cCode, cGroup * 2 + cIndex % 2);
}
// Determine if an X11 keycode is currently mapped to one or more keysyms.
static bool keycodeInUse(Display *dpy, int keycode)
{
for (int index = 0; index < 8; ++index) {
if (XKeycodeToKeysym(dpy, keycode, index) != NoSymbol)
return true;
}
return false;
}
bool
CXWindowsPrimaryScreen::isLockedToScreen() const
{
CDisplayLock display(m_screen);
// query the pointer to get the button state
Window root, window;
int xRoot, yRoot, xWindow, yWindow;
unsigned int state;
if (XQueryPointer(display, m_window, &root, &window,
&xRoot, &yRoot, &xWindow, &yWindow, &state)) {
if ((state & (Button1Mask | Button2Mask | Button3Mask |
Button4Mask | Button5Mask)) != 0) {
LOG((CLOG_DEBUG "locked by mouse button"));
return true;
}
}
// get logical keyboard state
char keyMap[32];
memset(keyMap, 0, sizeof(keyMap));
XQueryKeymap(display, keyMap);
// locked if any key is down
for (unsigned int i = 0; i < sizeof(keyMap); ++i) {
if (keyMap[i] != 0) {
for (unsigned int j = 0; j < 8; ++j) {
if ((keyMap[i] & (1 << j)) != 0) {
const KeyCode keycode = 8 * i + j;
const KeySym keysym = XKeycodeToKeysym(display,
keycode, 0);
// if any key is half-duplex then it'll be down when
// toggled on but shouldn't count as a reason to lock
// to the screen.
if (m_numLockHalfDuplex && keysym == XK_Num_Lock) {
continue;
}
if (m_capsLockHalfDuplex && keysym == XK_Caps_Lock) {
continue;
}
// non-half-duplex key down
char* name = XKeysymToString(keysym);
if (name == NULL) {
LOG((CLOG_DEBUG "locked by keycode %d", keycode));
}
else {
LOG((CLOG_DEBUG "locked by \"%s\"", name));
}
return true;
}
}
}
}
// not locked
return false;
}
VisKeySym *lv_x11_key_lookup (LVX11Key *x11key, Display *display, XKeyEvent *xkey, KeyCode kc, VisKeySym *keysym,
int pressed)
{
KeySym xsym;
/* Get the raw keyboard scancode */
// keysym->scancode = kc;
xsym = XKeycodeToKeysym(display, kc, 0);
#ifdef DEBUG_KEYS
fprintf(stderr, "Translating key 0x%.4x (%d)\n", xsym, kc);
#endif
/* Get the translated SDL virtual keysym */
keysym->sym = VKEY_UNKNOWN;
if ( xsym ) {
switch (xsym>>8) {
case 0x1005FF:
#ifdef SunXK_F36
if ( xsym == SunXK_F36 )
keysym->sym = VKEY_F11;
#endif
#ifdef SunXK_F37
if ( xsym == SunXK_F37 )
keysym->sym = VKEY_F12;
#endif
break;
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 = (VisKey)(xsym&0xFF);
/* Map capital letter syms to lowercase */
if ((keysym->sym >= 'A')&&(keysym->sym <= 'Z'))
keysym->sym += ('a'-'A');
break;
case 0xFE:
keysym->sym = x11key->ODD_keymap[xsym&0xFF];
break;
case 0xFF:
keysym->sym = x11key->MISC_keymap[xsym&0xFF];
break;
default:
fprintf(stderr,
"X11: Unknown xsym, sym = 0x%04x\n",
(unsigned int)xsym);
break;
}
} else {
/* X11 doesn't know how to translate the key! */
switch (kc) {
/* static */ KeySym
nsKeyCode::ConvertKeyCodeToKeySym(Display * aDisplay, KeyCode aKeyCode)
{
KeySym keysym = 0;
keysym = XKeycodeToKeysym(aDisplay, aKeyCode, 0);
return keysym;
}
void
ParseKeyBinding( ConfigItem *item, FreeStorageElem *func_elem, struct FuncKey **keyboard )
{
KeySym keysym;
KeyCode keycode;
int context, mods ;
int min = 0, max = 0 ;
if( item == NULL )
return ;
item->ok_to_free = 1;
if( item == NULL || func_elem == NULL || keyboard == NULL )
return ;
if( func_elem->term == NULL || func_elem->term->type != TT_FUNCTION )
return ;
/*
* Don't let a 0 keycode go through, since that means AnyKey to the
* XGrabKey call in GrabKeys().
*/
if( (keysym = XStringToKeysym (item->data.binding.sym)) == NoSymbol ||
(keycode = XKeysymToKeycode (dpy, keysym)) == 0)
return ;
XDisplayKeycodes (dpy, &min, &max);
for (keycode = min; keycode <= max; keycode++)
if (XKeycodeToKeysym (dpy, keycode, 0) == keysym)
break;
if (keycode > max)
return ;
context = item->data.binding.context ;
mods = item->data.binding.mods ;
if( !ReadConfigItem( item, func_elem ) )
return ;
if( item->data.function )
{ /* gotta add it to the keyboard hash */
FuncKey *tmp ;
tmp = (FuncKey *) safecalloc (1, sizeof (FuncKey));
tmp->next = *keyboard;
*keyboard = tmp ;
tmp->name = mystrdup(item->data.binding.sym);
tmp->keycode = keycode;
tmp->cont = context;
tmp->mods = mods;
tmp->fdata = item->data.function;
item->data.function = NULL ;
}
item->ok_to_free = (item->data.function != NULL);
}