Пример #1
0
static int get_screen_selection(void)
{
    static KeyCode lshift_code, rshift_code;
    static int first_time = 1;
    char keys[32];

    if (first_time) {
	first_time = 0;
	lshift_code = XKeysymToKeycode(GDK_WINDOW_XDISPLAY(bm.win),
				       XStringToKeysym("Shift_L"));
	rshift_code = XKeysymToKeycode(GDK_WINDOW_XDISPLAY(bm.win),
				       XStringToKeysym("Shift_R"));
    }

    XQueryKeymap(GDK_WINDOW_XDISPLAY(bm.win), keys);

#if 0
    if (0) {			/* debug */
	int i = 0;
	printf("lshift_code = 0x%x (index = %d, bit = %d\n", lshift_code,
	       lshift_code >> 3, lshift_code % 8);
	printf("rshift_code = 0x%x (index = %d, bit = %d\n", rshift_code,
	       rshift_code >> 3, rshift_code % 8);
	for (i = 0; i < (sizeof(keys) / sizeof(keys[0])); i++) {
	    if (0 == (i % 8)) {
		printf("\n%2d:", i);
	    }
	    printf(" %2d", keys[i]);
	}
	printf("\n");
    }
Пример #2
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;
}
Пример #3
0
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;
			}
		}
	}
}
Пример #4
0
Bool listen_init(Listen* obj, Display* display, Bool modifiers,
		int idle_time, int poll_time) {
	int i;
	KeyCode kc;
	XModifierKeymap* modmap;
	
	obj->modifiers = modifiers;
	obj->idle_time = ((double)idle_time)/1000.0;
	obj->poll_time = poll_time*1000;
	obj->display = display;
	memset(obj->mask, 0xff, MTRACKD_KEYMAP_SIZE);

	modmap = XGetModifierMapping(obj->display);

	for (i = 0; i < 8 * modmap->max_keypermod; i++) {
		kc = modmap->modifiermap[i];
		if (kc != 0)
			clear_bit(obj->mask, kc);
	}

	XFreeModifiermap(modmap);

	XQueryKeymap(obj->display, (char*)obj->current);
	memcpy(obj->previous, obj->current,
		sizeof(unsigned char)*MTRACKD_KEYMAP_SIZE);
	return True;
}
Пример #5
0
void iupdrvGetKeyState(char* key)
{
  char keys[32];
  Display* display = (Display*)iupdrvGetDisplay();
  XModifierKeymap *modMap = XGetModifierMapping(display);
  XQueryKeymap(display, keys);

  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, ShiftMapIndex, keys))
    key[0] = 'S';
  else
    key[0] = ' ';
  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, ControlMapIndex, keys))
    key[1] = 'C';
  else
    key[1] = ' ';
  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod1MapIndex, keys) ||
      xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod5MapIndex, keys))
    key[2] = 'A';
  else
    key[2] = ' ';
  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod4MapIndex, keys))
    key[3] = 'Y';
  else
    key[3] = ' ';

  key[4] = 0;

  XFreeModifiermap(modMap);
}
Пример #6
0
static enum KeyboardActivity
keyboard_activity(Display * display)
{
    static unsigned char old_key_state[KEYMAP_SIZE];
    unsigned char key_state[KEYMAP_SIZE];
    int i;
    int ret = ActivityNone;

    XQueryKeymap(display, (char *) key_state);

    for (i = 0; i < KEYMAP_SIZE; i++) {
        if ((key_state[i] & ~old_key_state[i]) & keyboard_mask[i]) {
            ret = ActivityNew;
            break;
        }
    }
    if (ignore_modifier_combos) {
        for (i = 0; i < KEYMAP_SIZE; i++) {
            if (key_state[i] & ~keyboard_mask[i]) {
                if (old_key_state[i] & ~keyboard_mask[i])
                    ret = ActivityNone;
                else
                    ret = ActivityReset;
                break;
            }
        }
    }
    for (i = 0; i < KEYMAP_SIZE; i++)
        old_key_state[i] = key_state[i];
    return ret;
}
Пример #7
0
i32 xwl_pollevent( xwl_event_t *event )
{
#ifdef _WIN32
	MSG msg;

	while ( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
	{
		TranslateMessage( &msg );
		DispatchMessage( &msg );
	}
#endif

#if LINUX
    XEvent ev;
    i32 i;
    xwl_window_handle_t *wh = 0;
    XEvent lastKeyReleaseEvent;

    for( i = 0; i < XWL_MAX_WINDOW_HANDLES; ++i )
    {
        wh = &xwl_windowHandles[i];
        if ( wh->handle.handle != 0 )
        {
            while (XCheckIfEvent( currentDisplay, &ev, &CheckEvent, wh->handle.handle) )
            {
                if ((ev.type == KeyPress) || (ev.type == KeyRelease) )
                {
                    if ( ev.xkey.keycode < 256 )
                    {
                        // To detect if it is a repeated key event, we check the current state of the key.
                        // - If the state is "down", KeyReleased events must obviously be discarded.
                        // - KeyPress events are a little bit harder to handle: they depend on the EnableKeyRepeat state,
                        //   and we need to properly forward the first one.
                        char keys[32];
                        XQueryKeymap(currentDisplay, keys);
                        if (keys[ev.xkey.keycode >> 3] & (1 << (ev.xkey.keycode % 8)))
                        {
                            // KeyRelease event + key down = repeated event --> discard
                            if (ev.type == KeyRelease)
                            {
                                lastKeyReleaseEvent = ev;
                                continue;
                            }

                            // KeyPress event + key repeat disabled + matching KeyRelease event = repeated event --> discard
                            if ((ev.type == KeyPress) &&
                                (lastKeyReleaseEvent.xkey.keycode == ev.xkey.keycode) &&
                                (lastKeyReleaseEvent.xkey.time == ev.xkey.time))
                            {
                                continue;
                            }
                        }
                    }
                }

                ProcessEvent( ev, wh );
            }
        }
    }
Пример #8
0
void Input::PollKeyboard(char* keyboardState)
{
#if defined(_WIN32)
	GetKeyboardState((PBYTE) keyboardState);
#elif defined(X11)
	XQueryKeymap(display, keyboardState);
#endif
}
Пример #9
0
bool GetXlibKeyState(int key)
{
  if(CurrentXDisplay == NULL)
    return false;

  KeySym ks = 0;

  if(key >= eRENDERDOC_Key_A && key <= eRENDERDOC_Key_Z)
    ks = key;
  if(key >= eRENDERDOC_Key_0 && key <= eRENDERDOC_Key_9)
    ks = key;

  switch(key)
  {
    case eRENDERDOC_Key_Divide: ks = XK_KP_Divide; break;
    case eRENDERDOC_Key_Multiply: ks = XK_KP_Multiply; break;
    case eRENDERDOC_Key_Subtract: ks = XK_KP_Subtract; break;
    case eRENDERDOC_Key_Plus: ks = XK_KP_Add; break;
    case eRENDERDOC_Key_F1: ks = XK_F1; break;
    case eRENDERDOC_Key_F2: ks = XK_F2; break;
    case eRENDERDOC_Key_F3: ks = XK_F3; break;
    case eRENDERDOC_Key_F4: ks = XK_F4; break;
    case eRENDERDOC_Key_F5: ks = XK_F5; break;
    case eRENDERDOC_Key_F6: ks = XK_F6; break;
    case eRENDERDOC_Key_F7: ks = XK_F7; break;
    case eRENDERDOC_Key_F8: ks = XK_F8; break;
    case eRENDERDOC_Key_F9: ks = XK_F9; break;
    case eRENDERDOC_Key_F10: ks = XK_F10; break;
    case eRENDERDOC_Key_F11: ks = XK_F11; break;
    case eRENDERDOC_Key_F12: ks = XK_F12; break;
    case eRENDERDOC_Key_Home: ks = XK_Home; break;
    case eRENDERDOC_Key_End: ks = XK_End; break;
    case eRENDERDOC_Key_Insert: ks = XK_Insert; break;
    case eRENDERDOC_Key_Delete: ks = XK_Delete; break;
    case eRENDERDOC_Key_PageUp: ks = XK_Prior; break;
    case eRENDERDOC_Key_PageDn: ks = XK_Next; break;
    case eRENDERDOC_Key_Backspace: ks = XK_BackSpace; break;
    case eRENDERDOC_Key_Tab: ks = XK_Tab; break;
    case eRENDERDOC_Key_PrtScrn: ks = XK_Print; break;
    case eRENDERDOC_Key_Pause: ks = XK_Pause; break;
    default: break;
  }

  if(ks == 0)
    return false;

  KeyCode kc = XKeysymToKeycode(CurrentXDisplay, ks);

  char keyState[32];
  XQueryKeymap(CurrentXDisplay, keyState);

  int byteIdx = (kc / 8);
  int bitMask = 1 << (kc % 8);

  uint8_t keyByte = (uint8_t)keyState[byteIdx];

  return (keyByte & bitMask) != 0;
}
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;
}
Пример #11
0
/* 
Input: Display, Array of keycodes, length of both arrays
Output: Array of ints. (no bools because sizeof(bool,vala) != sizeof(bool, stdbool.h)
*/
void checkModifier(Display* display, int* keycodes, int nkeycodes, int* pressed){
	XQueryKeymap(display, keymap);
	int i;
	for (i=0; i<nkeycodes; i++) {
		pressed[i] = keyPressed(keycodes[i], keymap)?1:0;
		//printf("%i Pressed? %i\n", keycodes[i], (pressed[i]) );
	}

}
static gboolean
is_key_released (long code)
{
  char keys[32];
  int down;

  XQueryKeymap (spi_get_display (), keys);
  down = BIT (keys, code);
  return (down == 0);
}
Пример #13
0
Bool is_key_pressed(Display *display, KeySym sym) {
    // determine if the key "sym" is pressed or not
    // this routine from "Introduction to the X Window System", 1989, p. 388

    KeyCode code = XKeysymToKeycode(display, sym);
    if (code == NoSymbol) return false;
    char key_vector[32];
    XQueryKeymap(display, key_vector);
    return (key_vector[code/8] >> (code&7)) & 1;
}
Пример #14
0
  void poll(vector<HID::Device*>& devices) {
    char state[32];
    XQueryKeymap(display, state);

    for(unsigned n = 0; n < keys.size(); n++) {
      bool value = state[keys[n].keycode >> 3] & (1 << (keys[n].keycode & 7));
      assign(n, value);
    }

    devices.append(&hid);
  }
Пример #15
0
static void x_input_poll(void *data)
{
   x11_input_t *x11 = (x11_input_t*)data;

   if (video_focus_func())
      XQueryKeymap(x11->display, x11->state);
   else
      memset(x11->state, 0, sizeof(x11->state));

   x_input_poll_mouse(x11);
   input_joypad_poll(x11->joypad);
}
Пример #16
0
void
XWindowsKeyState::pollPressedKeys(KeyButtonSet& pressedKeys) const
{
	char keys[32];
	XQueryKeymap(m_display, keys);
	for (UInt32 i = 0; i < 32; ++i) {
		for (UInt32 j = 0; j < 8; ++j) {
			if ((keys[i] & (1u << j)) != 0) {
				pressedKeys.insert(8 * i + j);
			}
		}
	}
}
bool InputDeviceProvider_X11Keyboard::get_keycode(int keycode) const
{
    // Ignore all key events when we don't have focus
    if(!window->has_focus())
        return false;

    char keyboard_state[32];

    InputCode code = (InputCode)XKeysymToKeycode(window->get_display(), keycode);
    XQueryKeymap(window->get_display(), keyboard_state);

    return keyboard_state[code/8] & (1 << code%8);
}
Пример #18
0
// check whether our modkeys are currently pressed
int modkey_is_down()
{
	char keys[32];	int i, j;
	XQueryKeymap(display, keys);
	for (i = 0; i < 32; i++)
	{
		if (!keys[i]) continue;
		unsigned int bits = keys[i];
		for (j = 0; j < 8; j++)
			if (bits & 1<<j && keycode_is_mod((i*8)+j))
				return 1;
	}
	return 0;
}
Пример #19
0
bool InputUtils::Update(Display *display)
{
  //Assign the X-Display
  xDisplay = display;  

  //Update the bit array of what keys are down  
  if(display != NULL)
  {
    XQueryKeymap(xDisplay,keyState);  
    return true;
  }
  
  return false;
}
Пример #20
0
/* This name doesn't really cover this function, since it also sets up mouse
   and keyboard. This is done over here, since on most display targets the
   mouse and keyboard can't be setup before the display has. */
int xf86_dga2_open_display(int reopen)
{
	int i;
	/* only have todo the fork's the first time we go DGA, otherwise people
	   who do a lott of dga <-> window switching will get a lott of
	   children */
	static int first_time  = 1;
	xf86_dga_first_click   = 0;
	
        if (reopen)
        {
          sysdep_display_effect_close();
          return xf86_dga2_set_mode();
        }

	window  = RootWindow(display,xf86ctx.screen);
	
	if (first_time)
	{
		if(xf86_dga_vidmode_setup_mode_restore())
			return 1;
		first_time = 0;
	}

	/* HACK HACK HACK, keys get stuck when they are pressed when
	   XDGASetMode is called, so wait for all keys to be released */
	do {
	  char keys[32];
	  XQueryKeymap(display, keys);
	  for (i=0; (i<32) && (keys[i]==0); i++) {}
	} while(i<32);

        /* Grab keyb and mouse ! */
	if(xinput_open(1, 0))
	{
	    fprintf(stderr,"XGrabKeyboard failed\n");
	    return 1;
	}

	if(xf86_dga2_set_mode())
	    return 1;
	    
	/* setup the colormap */
	xf86ctx.cmap = XDGACreateColormap(display, xf86ctx.screen,
					  xf86ctx.device, AllocNone);
	XDGAInstallColormap(display,xf86ctx.screen,xf86ctx.cmap);
	
	return 0;
}
Пример #21
0
bool KeyboardMouse::UpdateInput()
{
	XQueryKeymap(m_display, m_state.keyboard);

	int root_x, root_y, win_x, win_y;
	Window root, child;
	XQueryPointer(m_display, m_window, &root, &child, &root_x, &root_y, &win_x, &win_y, &m_state.buttons);

	// update mouse cursor
	XWindowAttributes win_attribs;
	XGetWindowAttributes(m_display, m_window, &win_attribs);

	// the mouse position as a range from -1 to 1
	m_state.cursor.x = (float)win_x / (float)win_attribs.width * 2 - 1;
	m_state.cursor.y = (float)win_y / (float)win_attribs.height * 2 - 1;

	return true;
}
Пример #22
0
bool wxGetKeyState(wxKeyCode key)
{
    wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
        WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));

    Display *pDisplay = (Display*) wxGetDisplay();

    int iKey = wxCharCodeWXToX(key);
    int          iKeyMask = 0;
    Window       wDummy1, wDummy2;
    int          iDummy3, iDummy4, iDummy5, iDummy6;
    unsigned int iMask;
    KeyCode keyCode = XKeysymToKeycode(pDisplay,iKey);
    if (keyCode == NoSymbol)
        return false;

    if ( IsModifierKey(iKey) )  // If iKey is a modifier key, use a different method
    {
        XModifierKeymap *map = XGetModifierMapping(pDisplay);
        wxCHECK_MSG( map, false, wxT("failed to get X11 modifiers map") );

        for (int i = 0; i < 8; ++i)
        {
            if ( map->modifiermap[map->max_keypermod * i] == keyCode)
            {
                iKeyMask = 1 << i;
            }
        }

        XQueryPointer(pDisplay, DefaultRootWindow(pDisplay), &wDummy1, &wDummy2,
                        &iDummy3, &iDummy4, &iDummy5, &iDummy6, &iMask );
        XFreeModifiermap(map);
        return (iMask & iKeyMask) != 0;
    }

    // From the XLib manual:
    // The XQueryKeymap() function returns a bit vector for the logical state of the keyboard,
    // where each bit set to 1 indicates that the corresponding key is currently pressed down.
    // The vector is represented as 32 bytes. Byte N (from 0) contains the bits for keys 8N to 8N + 7
    // with the least-significant bit in the byte representing key 8N.
    char key_vector[32];
    XQueryKeymap(pDisplay, key_vector);
    return key_vector[keyCode >> 3] & (1 << (keyCode & 7));
}
Пример #23
0
bool ofGetModifierPressed(unsigned int mod)
{
	unsigned int t = 0;

	//return false;
	Display* disp = glXGetCurrentDisplay();
	char key_map_stat[32];
	XQueryKeymap(disp, key_map_stat);

	if ((OF_KEY_ALT & mod) == OF_KEY_ALT){
		const KeyCode alt_l = XKeysymToKeycode(disp,XK_Alt_L);
		const KeyCode alt_r = XKeysymToKeycode(disp,XK_Alt_R);

		return (((key_map_stat[alt_l >> 3] >> (alt_l & 7)) & 1)
			  ||((key_map_stat[alt_r >> 3] >> (alt_r & 7)) & 1));
	}

	if ((OF_KEY_CONTROL & mod) == OF_KEY_CONTROL){
		const KeyCode control_l = XKeysymToKeycode(disp,XK_Control_L);
		const KeyCode control_r = XKeysymToKeycode(disp,XK_Control_R);

		return (((key_map_stat[control_l >> 3] >> (control_l & 7)) & 1)
			  ||((key_map_stat[control_r >> 3] >> (control_r & 7)) & 1));
	}

	if((OF_KEY_SHIFT & mod) == OF_KEY_SHIFT){
		const KeyCode shift_l = XKeysymToKeycode(disp,XK_Shift_L);
		const KeyCode shift_r = XKeysymToKeycode(disp,XK_Shift_R);

		return (((key_map_stat[shift_l >> 3] >> (shift_l & 7)) & 1)
			  ||((key_map_stat[shift_r >> 3] >> (shift_r & 7)) & 1));
	}

	if ((OF_KEY_SPECIAL & mod) == OF_KEY_SPECIAL){
		const KeyCode control_l = XKeysymToKeycode(disp,XK_Super_L);
		const KeyCode control_r = XKeysymToKeycode(disp,XK_Super_R);

		return (((key_map_stat[control_l >> 3] >> (control_l & 7)) & 1)
			  ||((key_map_stat[control_r >> 3] >> (control_r & 7)) & 1));
	}


	return false;
}
Пример #24
0
static Bool listen_activity(Listen* obj) {
	int i;
	Bool res = False;
	XQueryKeymap(obj->display, (char*)obj->current);

	for (i = 0; i < MTRACKD_KEYMAP_SIZE; i++) {
		if ((obj->current[i] & ~obj->previous[i]) & obj->mask[i]) {
			res = True;
			break;
		} else if (obj->modifiers && (obj->current[i] & ~obj->mask[i])) {
			res = True;
			break;
		}
	}

	memcpy(obj->previous, obj->current,
		sizeof(unsigned char)*MTRACKD_KEYMAP_SIZE);
	return res;
}
Пример #25
0
void tick(const xen::TickContext& tick){
	//////////////////////////////////////////////////////////////////
	// Update the cached state of the keyboard
	XQueryKeymap(xwn::state->display, xwn::state->keymap_state);

	//////////////////////////////////////////////////////////////////
	// Update modifier key state
	// :TODO: we should really update this in response to actual events as well,
	// but issue is that the press or release of one of the keys does not
	// guarentee state (eg, if holding both shift keys simultaneously)
	// This is rare, but possible...
	xen::setBitState(xwn::state->modifier_keys,
	                 (xen::ModifierKeyState)xen::ModifierKeys::Control,
	                 xwn::isKeyPressed(xen::Key::RCtrl) || xwn::isKeyPressed(xen::Key::LCtrl));
	xen::setBitState(xwn::state->modifier_keys,
	                 (xen::ModifierKeyState)xen::ModifierKeys::Alt,
	                 xwn::isKeyPressed(xen::Key::RAlt) || xwn::isKeyPressed(xen::Key::LAlt));
	xen::setBitState(xwn::state->modifier_keys,
	                 (xen::ModifierKeyState)xen::ModifierKeys::Shift,
	                 xwn::isKeyPressed(xen::Key::RShift) || xwn::isKeyPressed(xen::Key::LShift));
	xen::setBitState(xwn::state->modifier_keys,
	                 (xen::ModifierKeyState)xen::ModifierKeys::System,
	                 xwn::isKeyPressed(xen::Key::RSystem) || xwn::isKeyPressed(xen::Key::LSystem));

	//////////////////////////////////////////////////////////////////
	// Process window events
  XEvent event;
  for(uint i = 0; i < xwn::state->windows.size; ++i){
	  xen::Window* win = &xwn::state->windows[i];

	  while(XCheckIfEvent(xwn::state->display, &event,
	                      &checkEventMatchesWindow,
	                      reinterpret_cast<XPointer>(win->xwindow))
	  ){
		  processWindowEvent(win, &event);
	  }
  }

  //while(XPending(xwn::state->display)){
  //  XNextEvent(xwn::state->display, &event);
  //  printf("Found pending event\n");
  //}
}
Пример #26
0
void* gstate_update_func(void* arg)
{
    KeyboardUGenGlobalState* gstate;
    Window r;
    struct timespec requested_time , remaining_time;

    requested_time.tv_sec = 0;
    requested_time.tv_nsec = 17000 * 1000;

    d = XOpenDisplay ( NULL );
    if (!d) return 0;

    gstate = &gKeyStateGlobals;

    for (;;) {
        XQueryKeymap ( d , (char *) (gstate->keys) );
        nanosleep ( &requested_time , &remaining_time );
    }

    return 0;
}
Пример #27
0
void gstate_update_func()
{
	Window r;
	struct timespec requested_time , remaining_time;
	// NOTE: should not be required as this is the only thread accessing the x11 API
	//       but omitting seems to cause troubles.
	XInitThreads();

	d = XOpenDisplay ( NULL );
	if (!d) return;

	Window rep_root, rep_child;
	XWindowAttributes attributes;
	int rep_rootx, rep_rooty ;
	unsigned int rep_mask;
	int dx, dy;
	float r_width;
	float r_height;

	r = DefaultRootWindow ( d );
	XGetWindowAttributes ( d, r, &attributes );
	r_width = 1.0 / (float)attributes.width;
	r_height = 1.0 / (float)attributes.height;

	while ( inputThreadRunning.load( std::memory_order_relaxed ) ) {
		XQueryKeymap ( d , (char *) (gKeyStateGlobals.keys) );
		XQueryPointer ( d, r,
						&rep_root, &rep_child,
				  &rep_rootx, &rep_rooty,
				  &dx, &dy,
				  &rep_mask);

		gMouseUGenGlobals.mouseX = (float)dx * r_width;
		gMouseUGenGlobals.mouseY = 1.f - ( (float)dy * r_height );

		gMouseUGenGlobals.mouseButton = (bool) ( rep_mask & Button1Mask );

		std::this_thread::sleep_for( std::chrono::milliseconds( 17 ) );
	}
}
Пример #28
0
bool
ManglerSettings::settingsPTTKeyDetect(void) {/*{{{*/
    char        pressed_keys[32];
    Glib::ustring ptt_keylist;
    GdkWindow   *rootwin = gdk_get_default_root_window();

    // TODO: window close event needs to set isDetectingKey
    if (!isDetectingKey) {
        return false;
    }
    /*
     * Query the X keymap and get a list of all the keys are pressed.  Convert
     * keycodes to keysyms to keynames and build a human readable string that
     * will be the actual value stored in the settings file
     */
    XQueryKeymap(GDK_WINDOW_XDISPLAY(rootwin), pressed_keys);
    for (int ctr = 0; ctr < 256; ctr++) {
        if ((pressed_keys[ctr >> 3] >> (ctr & 0x07)) & 0x01) {
            char *keystring = XKeysymToString(XKeycodeToKeysym(GDK_WINDOW_XDISPLAY(rootwin), ctr, 0));
            if (keystring == NULL)
                continue;
            std::string keyname = keystring;

            if (keyname.length() > 1) {
                ptt_keylist.insert(0, "<" + keyname + ">" + (ptt_keylist.empty() ? "" : "+"));
            } else {
                keyname[0] = toupper(keyname[0]);
                ptt_keylist.append((ptt_keylist.empty() ? "" : "+") + keyname);
            }
        }
    }
    builder->get_widget("settingsPTTKeyValueLabel", label);
    if (ptt_keylist.empty()) {
        label->set_markup(PTT_KEY_SET);
    } else {
        label->set_text(ptt_keylist);
    }
    return(true);
}/*}}}*/
Пример #29
0
void simulateKeyPress(Display *display, const QList<int> &modCodes, unsigned int key)
{
    // Find modifiers to release.
    static QList<int> mods = QList<int>()
            << XK_Shift_L << XK_Shift_R
            << XK_Control_L << XK_Control_R
            << XK_Meta_L << XK_Meta_R
            << XK_Alt_L << XK_Alt_R
            << XK_Super_L << XK_Super_R
            << XK_Hyper_L << XK_Hyper_R;

    char keyMap[32];
    XQueryKeymap(display, keyMap);

    QList<KeyCode> modsToRelease;
    foreach (int mod, mods) {
        if ( isPressed(XKeysymToKeycode(display, mod), keyMap) )
            modsToRelease << XKeysymToKeycode(display, mod);
    }

    // Release currently pressed modifiers.
    foreach (KeyCode mod, modsToRelease)
        FakeKeyEvent(display, mod, False);

    simulateModifierKeyPress(display, modCodes, True);

    KeyCode keyCode = XKeysymToKeycode(display, key);

    FakeKeyEvent(display, keyCode, True);
    FakeKeyEvent(display, keyCode, False);

    simulateModifierKeyPress(display, modCodes, False);

    // Press modifiers again.
    foreach (KeyCode mod, modsToRelease)
        FakeKeyEvent(display, mod, True);

    XSync(display, False);
}
Пример #30
0
bool Sys_ShiftDown(){
#ifdef _WIN32
	return ( GetKeyState( VK_SHIFT ) & 0x8000 ) != 0;
#endif

#if defined ( __linux__ ) || defined ( __APPLE__ )
	char keys[32];
	int x;

	XQueryKeymap( GDK_DISPLAY(), keys );

	x = XKeysymToKeycode( GDK_DISPLAY(), XK_Shift_L );
	if ( keys[x / 8] & ( 1 << ( x % 8 ) ) ) {
		return true;
	}

	x = XKeysymToKeycode( GDK_DISPLAY(), XK_Shift_R );
	if ( keys[x / 8] & ( 1 << ( x % 8 ) ) ) {
		return true;
	}

	return false;
#endif
}