/*+++++++++++++++++++++++++++++++++++++++*/ static void _DtmapCB_keyboardDlg( Widget w, XtPointer client_data, XtPointer call_data ) { static int first_time = 1; int n; Arg args[MAX_ARGS]; Boolean set; if (first_time) { DtWsmRemoveWorkspaceFunctions(style.display, XtWindow(XtParent(w))); if (!save.restoreFlag) putDialog ((Widget)client_data, w); first_time = 0; } /* get keyboard values for click volume */ XGetKeyboardControl(style.display, &kbd.values); kbd.new_key_click_percent = kbd.values.key_click_percent; kbd.new_autoRepeat = kbd.values.global_auto_repeat; n=0; XtSetArg(args[n], XmNvalue, kbd.values.key_click_percent); n++; XtSetValues(kbd.volumeScale, args, n); n=0; set = (kbd.values.global_auto_repeat == AutoRepeatModeOn) ? True : False; XtSetArg(args[n], XmNset, set); n++; XtSetValues(kbd.autoRepeatToggle, args, n); }
/* * fmt consists of uppercase or lowercase 'c' for caps lock and/or 'n' for num * lock, each optionally followed by '?', in the order of indicators desired. * If followed by '?', the letter with case preserved is included in the output * if the corresponding indicator is on. Otherwise, the letter is always * included, lowercase when off and uppercase when on. */ const char * keyboard_indicators(const char *fmt) { Display *dpy; XKeyboardState state; size_t fmtlen, i, n; int togglecase, isset; char key; if (!(dpy = XOpenDisplay(NULL))) { warn("XOpenDisplay: Failed to open display"); return NULL; } XGetKeyboardControl(dpy, &state); XCloseDisplay(dpy); fmtlen = strnlen(fmt, 4); for (i = n = 0; i < fmtlen; i++) { key = tolower(fmt[i]); if (key != 'c' && key != 'n') { continue; } togglecase = (i + 1 >= fmtlen || fmt[i + 1] != '?'); isset = (state.led_mask & (1 << (key == 'n'))); if (togglecase) { buf[n++] = isset ? toupper(key) : key; } else if (isset) { buf[n++] = fmt[i]; } } buf[n] = 0; return buf; }
void KBellConfig::ringBell() { if (!m_useBell->isChecked()) { KNotifyClient::beep(); return; } // store the old state XKeyboardState old_state; XGetKeyboardControl(kapp->getDisplay(), &old_state); // switch to the test state XKeyboardControl kbd; kbd.bell_percent = m_volume->value(); kbd.bell_pitch = m_pitch->value(); if (m_volume->value() > 0) kbd.bell_duration = m_duration->value(); else kbd.bell_duration = 0; XChangeKeyboardControl(kapp->getDisplay(), KBBellPercent | KBBellPitch | KBBellDuration, &kbd); // ring bell XBell(kapp->getDisplay(),0); // restore old state kbd.bell_percent = old_state.bell_percent; kbd.bell_pitch = old_state.bell_pitch; kbd.bell_duration = old_state.bell_duration; XChangeKeyboardControl(kapp->getDisplay(), KBBellPercent | KBBellPitch | KBBellDuration, &kbd); }
/* ============== Sys_IsNumLockDown ============== */ qboolean Sys_IsNumLockDown( void ) { #if !defined(MACOS_X) && defined(BUILD_CLIENT) const char *denv = getenv( "DISPLAY" ); Display *dpy; XKeyboardState x; if ( denv != NULL && strlen( denv ) > 0 ) dpy = XOpenDisplay(denv); else dpy = XOpenDisplay(":0"); if ( dpy == 0 ) { Com_Printf( _("ERROR: cannot determine numlock state as we couldn't\n" "grab your non-standard (e.g. not ':0') X display.\n" "ensure the 'DISPLAY' environment variable is set.\n") ); return qtrue; } else { XGetKeyboardControl(dpy, &x); XCloseDisplay(dpy); } return (x.led_mask & 2) ? qtrue : qfalse; #else return qtrue; // Macs don't have Numlock. #endif }
unsigned int detect_keyboard_layout_from_xkb(void *dpy) { char *layout, *variant; unsigned int keyboard_layout = 0, group = 0; XkbRF_VarDefsRec rules_names; XKeyboardState coreKbdState; XkbStateRec state; DEBUG_KBD("display: %p", dpy); if (dpy && XkbRF_GetNamesProp(dpy, NULL, &rules_names)) { DEBUG_KBD("layouts: %s", rules_names.layout); DEBUG_KBD("variants: %s", rules_names.variant); XGetKeyboardControl(dpy, &coreKbdState); if (XkbGetState(dpy, XkbUseCoreKbd, &state) == Success) group = state.group; DEBUG_KBD("group: %d", state.group); layout = comma_substring(rules_names.layout, group); variant = comma_substring(rules_names.variant, group); DEBUG_KBD("layout: %s", layout); DEBUG_KBD("variant: %s", variant); keyboard_layout = find_keyboard_layout_in_xorg_rules(layout, variant); free(rules_names.model); free(rules_names.layout); free(rules_names.variant); free(rules_names.options); } return keyboard_layout; }
/*+++++++++++++++++++++++++++++++++++++++*/ static void systemDefaultCB( Widget w, XtPointer client_data, XtPointer call_data ) { int n; Arg args[MAX_ARGS]; XKeyboardControl kbdControl; int kbdControlMask; XKeyboardState kbdState; Boolean set; /* set keyboard click volume to system default value */ kbdControlMask = KBKeyClickPercent | KBAutoRepeatMode; kbdControl.key_click_percent = -1; kbdControl.auto_repeat_mode = AutoRepeatModeDefault; XChangeKeyboardControl(style.display, kbdControlMask, &kbdControl); XGetKeyboardControl(style.display, &kbdState); n=0; XtSetArg(args[n], XmNvalue, kbdState.key_click_percent); n++; XtSetValues(kbd.volumeScale, args, n); n=0; set = (kbdState.global_auto_repeat == AutoRepeatModeOn) ? True : False; XtSetArg(args[n], XmNset, set); n++; XtSetValues(kbd.autoRepeatToggle, args, n); kbd.systemDefaultFlag = True; }
void KeyboardConfig::init_keyboard() { KConfig *config = new KConfig("kcminputrc", true); // Read-only, no globals config->setGroup("Keyboard"); XKeyboardState kbd; XKeyboardControl kbdc; XGetKeyboardControl(kapp->getDisplay(), &kbd); bool key = config->readBoolEntry("KeyboardRepeating", true); kbdc.key_click_percent = config->readNumEntry("ClickVolume", kbd.key_click_percent); kbdc.auto_repeat_mode = (key ? AutoRepeatModeOn : AutoRepeatModeOff); XChangeKeyboardControl(kapp->getDisplay(), KBKeyClickPercent | KBAutoRepeatMode, &kbdc); if( key ) { int delay_ = config->readNumEntry("RepeatDelay", 250); double rate_ = config->readDoubleNumEntry("RepeatRate", 30); set_repeatrate(delay_, rate_); } int numlockState = config->readNumEntry( "NumLock", 2 ); if( numlockState != 2 ) numlockx_change_numlock_state( numlockState == 0 ); delete config; }
void Window::OnFocusIn(void) { //FIXME: Hay que volver a obtener el ratón // Guardamos el estado del teclado para poder restaurarlo XGetKeyboardControl(this->dpy, &deskKeyboardState); // Y quitamos el auto_repeat XAutoRepeatOff(this->dpy); };
static guint32 get_keyboard_lock_modifiers(void) { guint32 modifiers = 0; #if GTK_CHECK_VERSION(3,18,0) GdkKeymap *keyboard = gdk_keymap_get_default(); if (gdk_keymap_get_caps_lock_state(keyboard)) { modifiers |= SPICE_INPUTS_CAPS_LOCK; } if (gdk_keymap_get_num_lock_state(keyboard)) { modifiers |= SPICE_INPUTS_NUM_LOCK; } if (gdk_keymap_get_scroll_lock_state(keyboard)) { modifiers |= SPICE_INPUTS_SCROLL_LOCK; } #else #if HAVE_X11_XKBLIB_H Display *x_display = NULL; XKeyboardState keyboard_state; GdkScreen *screen = gdk_screen_get_default(); if (!GDK_IS_X11_DISPLAY(gdk_screen_get_display(screen))) { SPICE_DEBUG("FIXME: gtk backend is not X11"); return 0; } x_display = GDK_SCREEN_XDISPLAY(screen); XGetKeyboardControl(x_display, &keyboard_state); if (keyboard_state.led_mask & 0x01) { modifiers |= SPICE_INPUTS_CAPS_LOCK; } if (keyboard_state.led_mask & 0x02) { modifiers |= SPICE_INPUTS_NUM_LOCK; } if (keyboard_state.led_mask & 0x04) { modifiers |= SPICE_INPUTS_SCROLL_LOCK; } #elif defined(G_OS_WIN32) if (GetKeyState(VK_CAPITAL) & 1) { modifiers |= SPICE_INPUTS_CAPS_LOCK; } if (GetKeyState(VK_NUMLOCK) & 1) { modifiers |= SPICE_INPUTS_NUM_LOCK; } if (GetKeyState(VK_SCROLL) & 1) { modifiers |= SPICE_INPUTS_SCROLL_LOCK; } #else g_warning("get_keyboard_lock_modifiers not implemented"); #endif // HAVE_X11_XKBLIB_H #endif // GTK_CHECK_VERSION(3,18,0) return modifiers; }
bool isNumLockOn() { Display *display = XOpenDisplay( NULL ); bool mumlock_state = false; XKeyboardState x; XGetKeyboardControl( display, &x ); mumlock_state = x.led_mask & 2; XCloseDisplay( display ); return mumlock_state; }
void show_info(Client *c, unsigned int keycode) { XEvent ev; XKeyboardState keyboard; if (XGrabKeyboard(dpy, c->screen->root, False, GrabModeAsync, GrabModeAsync, CurrentTime) != GrabSuccess) return; /* keyboard repeat might not have any effect, newer X servers seem to * only change the keyboard control after all keys have been physically * released. */ XGetKeyboardControl(dpy, &keyboard); XChangeKeyboardControl(dpy, KBAutoRepeatMode, &(XKeyboardControl){.auto_repeat_mode = AutoRepeatModeOff});
void beep(void) { #if 0 XKeyboardControl kb_state; XGetKeyboardControl(dpy, &kb_state); XBell(dpy, kb_state->bell_percent); #endif if (noscreen) (void)putc(BEL, stderr); else XBell(dpy, 0); }
/* ============== Sys_IsNumLockDown ============== */ qboolean Sys_IsNumLockDown( void ) { #if !defined(MACOS_X) && !defined(DEDICATED) && !defined(BUILD_TTY_CLIENT) Display *dpy = XOpenDisplay(":0"); XKeyboardState x; XGetKeyboardControl(dpy, &x); XCloseDisplay(dpy); return (x.led_mask & 2) ? qtrue : qfalse; #else return qtrue; // Macs don't have Numlock. #endif }
void XWindowsKeyState::init(Display* display, bool useXKB) { XGetKeyboardControl(m_display, &m_keyboardState); #if HAVE_XKB_EXTENSION if (useXKB) { m_xkb = XkbGetMap(m_display, XkbKeyActionsMask | XkbKeyBehaviorsMask | XkbAllClientInfoMask, XkbUseCoreKbd); } else { m_xkb = NULL; } #endif setActiveGroup(kGroupPollAndSet); }
void KBellConfig::load( bool useDefaults ) { XKeyboardState kbd; XGetKeyboardControl(kapp->getDisplay(), &kbd); m_volume->setValue(kbd.bell_percent); m_pitch->setValue(kbd.bell_pitch); m_duration->setValue(kbd.bell_duration); KConfig cfg("kdeglobals", false, false); cfg.setReadDefaults( useDefaults ); cfg.setGroup("General"); m_useBell->setChecked(cfg.readBoolEntry("UseSystemBell", false)); useBell(m_useBell->isChecked()); emit changed( useDefaults ); }
static int set_repeat_mode(TriState keyboardRepeatMode) { XKeyboardState kbd; XKeyboardControl kbdc; XGetKeyboardControl(QX11Info::display(), &kbd); int flags = 0; if( keyboardRepeatMode != STATE_UNCHANGED ) { flags |= KBAutoRepeatMode; kbdc.auto_repeat_mode = (keyboardRepeatMode==STATE_ON ? AutoRepeatModeOn : AutoRepeatModeOff); } return XChangeKeyboardControl(QX11Info::display(), flags, &kbdc); }
static void set_bell_vol(Display *dpy, int percent) { XKeyboardControl values; XKeyboardState kbstate; values.bell_percent = percent; if (percent == DEFAULT_ON) values.bell_percent = SERVER_DEFAULT; XChangeKeyboardControl(dpy, KBBellPercent, &values); if (percent == DEFAULT_ON) { XGetKeyboardControl(dpy, &kbstate); if (!kbstate.bell_percent) { values.bell_percent = -percent; XChangeKeyboardControl(dpy, KBBellPercent, &values); } } return; }
KDE_EXPORT void init_bell() { XKeyboardState kbd; XKeyboardControl kbdc; XGetKeyboardControl(kapp->getDisplay(), &kbd); KConfig config("kcmbellrc", true, false); config.setGroup("General"); kbdc.bell_percent = config.readNumEntry("Volume", kbd.bell_percent); kbdc.bell_pitch = config.readNumEntry("Pitch", kbd.bell_pitch); kbdc.bell_duration = config.readNumEntry("Duration", kbd.bell_duration); XChangeKeyboardControl(kapp->getDisplay(), KBBellPercent | KBBellPitch | KBBellDuration, &kbdc); }
void OnLibraryLoad() { // Tell X Threads are OK. XInitThreads(); #ifdef XT XtToolkitInitialize(); app_context = XtCreateApplicationContext(); #endif // Open local display. disp = XOpenDisplay(XDisplayName(NULL)); #ifdef DEBUG if (disp != NULL) { fprintf(stdout, "OnLibraryLoad(): XOpenDisplay successful.\n"); } else { fprintf(stderr, "OnLibraryLoad(): XOpenDisplay failure!\n"); } #endif Bool isAutoRepeat = False; #ifdef XKB // Enable detectable autorepeat. XkbSetDetectableAutoRepeat(disp, True, &isAutoRepeat); #else XAutoRepeatOn(disp); XKeyboardState kb_state; XGetKeyboardControl(disp, &kb_state); isAutoRepeat = (kb_state.global_auto_repeat == AutoRepeatModeOn); #endif #ifdef DEBUG if (isAutoRepeat) { fprintf(stdout, "OnLibraryLoad(): Successfully enabled detectable autorepeat.\n"); } else { fprintf(stderr, "OnLibraryLoad(): Could not enable detectable auto-repeat!\n"); } #endif }
void KeyboardConfig::load() { KConfig config("kcminputrc"); XKeyboardState kbd; XGetKeyboardControl(kapp->getDisplay(), &kbd); config.setGroup("Keyboard"); bool key = config.readBoolEntry("KeyboardRepeating", true); keyboardRepeat = (key ? AutoRepeatModeOn : AutoRepeatModeOff); ui->delay->setValue(config.readNumEntry( "RepeatDelay", 660 )); ui->rate->setValue(config.readDoubleNumEntry( "RepeatRate", 25 )); clickVolume = config.readNumEntry("ClickVolume", kbd.key_click_percent); numlockState = config.readNumEntry( "NumLock", 2 ); setClick(kbd.key_click_percent); setRepeat(kbd.global_auto_repeat, ui->delay->value(), ui->rate->value()); setNumLockState( numlockState ); }
void PCSpeaker::beep(int pitch, int duration) { if (pitch == 0) usleep(duration * 200); else { XKeyboardState s; //zachowuje stare parametry dzwieku XGetKeyboardControl(xdisplay, &s); XKeyboardControl v; //dla 0 nie wysyla zadnego dzwieku tylko odczekuje podany czas v.bell_pitch = pitch; //dzwiek w Hz v.bell_duration = duration; //czas trwania w ms v.bell_percent = 100; //ustawiamy glosnosc na maks XChangeKeyboardControl(xdisplay, (KBBellPitch | KBBellDuration | KBBellPercent), &v); //ustawia parametry dzwieku XBell(xdisplay, volume); //robimy pik skalujac glosnosc wzgledem maksa XFlush(xdisplay); //czysci bufor wywalajac na display i powodujac de facto pik usleep(pitch * 100); //poczeka az skonczy pipac v.bell_pitch = s.bell_pitch; //odzyskuje stare parametry v.bell_duration = s.bell_duration; v.bell_percent = s.bell_percent; XChangeKeyboardControl(xdisplay, (KBBellPitch | KBBellDuration | KBBellPercent), &v); //ustawia poprzednie parametry dzwieku } }
static int set_volume(int clickVolumePercent, TriState keyboardRepeatMode) { XKeyboardState kbd; XKeyboardControl kbdc; XGetKeyboardControl(QX11Info::display(), &kbd); int flags = 0; if( clickVolumePercent != -1 ) { flags |= KBKeyClickPercent; kbdc.key_click_percent = clickVolumePercent; } if( keyboardRepeatMode != STATE_UNCHANGED ) { flags |= KBAutoRepeatMode; kbdc.auto_repeat_mode = (keyboardRepeatMode==STATE_ON ? AutoRepeatModeOn : AutoRepeatModeOff); } return XChangeKeyboardControl(QX11Info::display(), flags, &kbdc); }
void XWindowsKeyState::getKeyMap(synergy::KeyMap& keyMap) { // get autorepeat info. we must use the global_auto_repeat told to // us because it may have modified by synergy. int oldGlobalAutoRepeat = m_keyboardState.global_auto_repeat; XGetKeyboardControl(m_display, &m_keyboardState); m_keyboardState.global_auto_repeat = oldGlobalAutoRepeat; #if HAVE_XKB_EXTENSION if (m_xkb != NULL) { if (XkbGetUpdatedMap(m_display, XkbKeyActionsMask | XkbKeyBehaviorsMask | XkbAllClientInfoMask, m_xkb) == Success) { updateKeysymMapXKB(keyMap); return; } } #endif updateKeysymMap(keyMap); }
void PCSpeakerNotifier::beep(int pitch, int duration) { if (pitch == 0) usleep(static_cast<useconds_t>(duration * 200)); else { XKeyboardState s; //save previous sound config XGetKeyboardControl(xdisplay, &s); XKeyboardControl v; //pause when set to 0 v.bell_pitch = pitch; //sound frequency in Hz v.bell_duration = duration; //sound duration v.bell_percent = 100; //set volume to max XChangeKeyboardControl(xdisplay, (KBBellPitch | KBBellDuration | KBBellPercent), &v); //set sound config XBell(xdisplay, volume); //put sound to buffer XFlush(xdisplay); //flush buffer (beep) usleep(static_cast<useconds_t>(pitch * 100)); //wait until sound is played v.bell_pitch = static_cast<int>(s.bell_pitch); //restore previous sound config v.bell_duration = static_cast<int>(s.bell_duration); v.bell_percent = static_cast<int>(s.bell_percent); XChangeKeyboardControl(xdisplay, (KBBellPitch | KBBellDuration | KBBellPercent), &v); //set restored sound config } }
void X11Device::shutdown() { X11Session *session = static_cast<X11Session *>(getSession()); Log(EDebug, "Shutting down X11 device"); Device::shutdown(); setVisible(false); XDestroyWindow(session->m_display, m_window); XFree(m_visinfo); if (m_fullscreen) { /* Switch back to the previous screen resolution */ XF86VidModeSwitchToMode(session->m_display, session->m_screen, &m_previousMode); XF86VidModeSetViewPort(session->m_display, session->m_screen, 0, 0); } /* In case auto_repeat was left on */ XKeyboardState xkbs; XAutoRepeatOn(session->m_display); XGetKeyboardControl(session->m_display, &xkbs); if (!xkbs.global_auto_repeat) Log(EWarn, "Unable to restore the keyboard auto-repeat flag"); m_initialized = false; }
EIF_BOOLEAN basic_gui_initialize(EIF_POINTER display_name, EIF_BOOLEAN sync, EIF_BOOLEAN no_xshm, EIF_POINTER name, EIF_POINTER progclass, EIF_POINTER gxid_host, EIF_INTEGER gxid_port) { /* Called only once at the very beginning to initialize the Window Manager. */ int synchronize = sync; XKeyboardState keyboard_state; XClassHint *class_hint; X_GETTIMEOFDAY (&start); gdk_display_name = display_name; XSetErrorHandler (gui_x_error); XSetIOErrorHandler (gui_x_io_error); g_get_prgname = name; gdk_display_name = display_name; if (no_xshm) gdk_use_xshm = FALSE; gdk_progclass = progclass; #ifdef XINPUT_GXI gdk_input_gxid_host = gxid_host; gdk_input_gxid_port = gxid_port; #endif gdk_display = XOpenDisplay (gdk_display_name); if (!gdk_display) return FALSE; if (synchronize) XSynchronize (gdk_display, True); gdk_screen = DefaultScreen (gdk_display); gdk_root_window = RootWindow (gdk_display, gdk_screen); gdk_leader_window = XCreateSimpleWindow(gdk_display, gdk_root_window, 10, 10, 10, 10, 0, 0 , 0); class_hint = XAllocClassHint(); class_hint->res_name = g_get_prgname; if (gdk_progclass == NULL) { gdk_progclass = g_get_prgname; } class_hint->res_class = gdk_progclass; XmbSetWMProperties (gdk_display, gdk_leader_window, NULL, NULL, se_argv, se_argc, NULL, NULL, class_hint); XFree (class_hint); gdk_wm_delete_window = XInternAtom (gdk_display, "WM_DELETE_WINDOW", False); gdk_wm_take_focus = XInternAtom (gdk_display, "WM_TAKE_FOCUS", False); gdk_wm_protocols = XInternAtom (gdk_display, "WM_PROTOCOLS", False); gdk_wm_window_protocols[0] = gdk_wm_delete_window; gdk_wm_window_protocols[1] = gdk_wm_take_focus; gdk_selection_property = XInternAtom (gdk_display, "GDK_SELECTION", False); XGetKeyboardControl (gdk_display, &keyboard_state); autorepeat = keyboard_state.global_auto_repeat; timer.tv_sec = 0; timer.tv_usec = 0; timerp = NULL; /* @@@ Keep This ?: gdk_events_init (); gdk_visual_init (); gdk_window_init (); gdk_image_init (); gdk_input_init (); gdk_dnd_init (); #ifdef USE_XIM gdk_im_open (); #endif */ return 1; }
int xnestKeyboardProc(DeviceIntPtr pDev, int onoff) { XModifierKeymap *modifier_keymap; KeySym *keymap; int mapWidth; int min_keycode, max_keycode; KeySymsRec keySyms; CARD8 modmap[MAP_LENGTH]; int i, j; XKeyboardState values; XkbDescPtr xkb; int op, event, error, major, minor; switch (onoff) { case DEVICE_INIT: XDisplayKeycodes(xnestDisplay, &min_keycode, &max_keycode); #ifdef _XSERVER64 { KeySym64 *keymap64; int len; keymap64 = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); len = (max_keycode - min_keycode + 1) * mapWidth; keymap = xallocarray(len, sizeof(KeySym)); for (i = 0; i < len; ++i) keymap[i] = keymap64[i]; XFree(keymap64); } #else keymap = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); #endif memset(modmap, 0, sizeof(modmap)); modifier_keymap = XGetModifierMapping(xnestDisplay); for (j = 0; j < 8; j++) for (i = 0; i < modifier_keymap->max_keypermod; i++) { CARD8 keycode; if ((keycode = modifier_keymap->modifiermap[j * modifier_keymap-> max_keypermod + i])) modmap[keycode] |= 1 << j; } XFreeModifiermap(modifier_keymap); keySyms.minKeyCode = min_keycode; keySyms.maxKeyCode = max_keycode; keySyms.mapWidth = mapWidth; keySyms.map = keymap; if (XkbQueryExtension(xnestDisplay, &op, &event, &error, &major, &minor) == 0) { ErrorF("Unable to initialize XKEYBOARD extension.\n"); goto XkbError; } xkb = XkbGetKeyboard(xnestDisplay, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (xkb == NULL || xkb->geom == NULL) { ErrorF("Couldn't get keyboard.\n"); goto XkbError; } XkbGetControls(xnestDisplay, XkbAllControlsMask, xkb); InitKeyboardDeviceStruct(pDev, NULL, xnestBell, xnestChangeKeyboardControl); XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode, keySyms.maxKeyCode - keySyms.minKeyCode + 1, modmap, serverClient); XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls); XkbFreeKeyboard(xkb, 0, False); free(keymap); break; case DEVICE_ON: xnestEventMask |= XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_OFF: xnestEventMask &= ~XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_CLOSE: break; } return Success; XkbError: XGetKeyboardControl(xnestDisplay, &values); memmove((char *) defaultKeyboardControl.autoRepeats, (char *) values.auto_repeats, sizeof(values.auto_repeats)); InitKeyboardDeviceStruct(pDev, NULL, xnestBell, xnestChangeKeyboardControl); free(keymap); return Success; }
void UXViewport::CaptureInputs() { guard(UXViewport::CaptureInputs); // Check keyboard state. XKeyboardState KeyState; XGetKeyboardControl(XDisplay, &KeyState); if( KeyState.global_auto_repeat == AutoRepeatModeOn ) { RestoreAutoRepeat = true; XAutoRepeatOff( XDisplay ); } // Examine root window. Window RootRoot; int r_x, r_y; unsigned int r_width, r_height, r_border, r_depth; XGetGeometry( XDisplay, DefaultRootWindow(XDisplay), &RootRoot, &r_x, &r_y, &r_width, &r_height, &r_border, &r_depth ); XWarpPointer(XDisplay, None, XWindow, 0, 0, 0, 0, r_width/2, r_height/2); XSync(XDisplay, False); //XDefineCursor(XDisplay, XWindow, GetNullCursor()); // Capture the pointer. XGrabPointer(XDisplay, XWindow, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, XWindow, None, CurrentTime ); // Control acceleration. XChangePointerControl(XDisplay, True, True, 2, 1, 0); XSync(XDisplay, False); // Query DGA capabilities. UXClient* C = GetOuterUXClient(); if (C->DGAMouseEnabled) { INT VersionMajor, VersionMinor; if (!XF86DGAQueryVersion(XDisplay, &VersionMajor, &VersionMinor)) { debugf( TEXT("XF86DGA disabled.") ); UseDGA = false; } else { debugf( TEXT("XF86DGA enabled.") ); UseDGA = true; XF86DGADirectVideo(XDisplay, DefaultScreen(XDisplay), XF86DGADirectMouse); XWarpPointer(XDisplay, None, XWindow, 0, 0, 0, 0, 0, 0); } } else UseDGA = false; XGrabKeyboard(XDisplay, XWindow, False, GrabModeAsync, GrabModeAsync, CurrentTime); XSync(XDisplay, False); unguard; }
int xnestKeyboardProc(DeviceIntPtr pDev, int onoff) { XModifierKeymap *modifier_keymap; KeySym *keymap; int mapWidth; int min_keycode, max_keycode; KeySymsRec keySyms; CARD8 modmap[MAP_LENGTH]; int i, j; XKeyboardState values; switch (onoff) { case DEVICE_INIT: modifier_keymap = XGetModifierMapping(xnestDisplay); XDisplayKeycodes(xnestDisplay, &min_keycode, &max_keycode); #ifdef _XSERVER64 { KeySym64 *keymap64; int i, len; keymap64 = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); len = (max_keycode - min_keycode + 1) * mapWidth; keymap = (KeySym *)xalloc(len * sizeof(KeySym)); for(i = 0; i < len; ++i) keymap[i] = keymap64[i]; XFree(keymap64); } #else keymap = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); #endif for (i = 0; i < MAP_LENGTH; i++) modmap[i] = 0; for (j = 0; j < 8; j++) for(i = 0; i < modifier_keymap->max_keypermod; i++) { CARD8 keycode; if ((keycode = modifier_keymap-> modifiermap[j * modifier_keymap->max_keypermod + i])) modmap[keycode] |= 1<<j; } XFreeModifiermap(modifier_keymap); keySyms.minKeyCode = min_keycode; keySyms.maxKeyCode = max_keycode; keySyms.mapWidth = mapWidth; keySyms.map = keymap; #ifdef XKB if (noXkbExtension) { XkbError: #endif XGetKeyboardControl(xnestDisplay, &values); memmove((char *) defaultKeyboardControl.autoRepeats, (char *) values.auto_repeats, sizeof(values.auto_repeats)); InitKeyboardDeviceStruct(&pDev->public, &keySyms, modmap, xnestBell, xnestChangeKeyboardControl); #ifdef XKB } else { FILE *file; XkbConfigRtrnRec config; XkbComponentNamesRec names; char *rules, *model, *layout, *variants, *options; XkbDescPtr xkb; int op, event, error, major, minor; if (XkbQueryExtension(xnestDisplay, &op, &event, &error, &major, &minor) == 0) { ErrorF("Unable to initialize XKEYBOARD extension.\n"); goto XkbError; } xkb = XkbGetKeyboard(xnestDisplay, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (xkb == NULL || xkb->geom == NULL) { ErrorF("Couldn't get keyboard.\n"); goto XkbError; } XkbGetControls(xnestDisplay, XkbAllControlsMask, xkb); memset(&names, 0, sizeof(XkbComponentNamesRec)); rules = XKB_DFLT_RULES_FILE; model = XKB_DFLT_KB_MODEL; layout = XKB_DFLT_KB_LAYOUT; variants = XKB_DFLT_KB_VARIANT; options = XKB_DFLT_KB_OPTIONS; if (XkbInitialMap) { if ((names.keymap = strchr(XkbInitialMap, '/')) != NULL) ++names.keymap; else names.keymap = XkbInitialMap; } XkbSetRulesDflts(rules, model, layout, variants, options); XkbInitKeyboardDeviceStruct(pDev, &names, &keySyms, modmap, xnestBell, xnestChangeKeyboardControl); XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls); XkbFreeKeyboard(xkb, 0, False); } #endif #ifdef _XSERVER64 xfree(keymap); #else XFree(keymap); #endif break; case DEVICE_ON: xnestEventMask |= XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_OFF: xnestEventMask &= ~XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_CLOSE: break; }
main() { Window w2; Display *dpy = XOpenDisplay(NIL); assert(dpy); Screen *scr = DefaultScreenOfDisplay(dpy); // CreateWindow Window w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL); XDestroyWindow(dpy, w); // CreateWindow with arguments XSetWindowAttributes swa; swa.background_pixel = WhitePixelOfScreen(scr); swa.bit_gravity = NorthWestGravity; swa.border_pixel = BlackPixelOfScreen(scr); swa.colormap = DefaultColormapOfScreen(scr); swa.cursor = None; swa.win_gravity = NorthGravity; w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent, CopyFromParent, CopyFromParent, CWBackPixel | CWBitGravity | CWBorderPixel | CWColormap | CWCursor | CWWinGravity, &swa); // CreateWindow with other arguments XDestroyWindow(dpy, w); Pixmap pixmap = XCreatePixmap(dpy, RootWindowOfScreen(scr), 45, 25, DefaultDepthOfScreen(scr)); assert(pixmap); swa.background_pixmap = pixmap; swa.border_pixmap = pixmap; w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent, CopyFromParent, CopyFromParent, CWBackPixmap | CWBorderPixmap, &swa); // ChangeWindowAttributes swa.backing_planes = 0x1; swa.backing_pixel = WhitePixelOfScreen(scr); swa.save_under = True; swa.event_mask = KeyPressMask | KeyReleaseMask; swa.do_not_propagate_mask = ButtonPressMask | Button4MotionMask; swa.override_redirect = False; XChangeWindowAttributes(dpy, w, CWBackingPlanes | CWBackingPixel | CWSaveUnder | CWEventMask | CWDontPropagate | CWOverrideRedirect, &swa); // GetWindowAttributes XWindowAttributes wa; Status success = XGetWindowAttributes(dpy, w, &wa); // DestroyWindow (done) // DestroySubwindows w2 = XCreateWindow(dpy, w, 20, 30, 40, 50, 3, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL); XDestroySubwindows(dpy, w); // ChangeSaveSet // Display *dpy2 = XOpenDisplay(NIL); // assert(dpy2); // XAddToSaveSet(dpy2, w); // XCloseDisplay(dpy2); // ReparentWindow w2 = XCreateWindow(dpy, RootWindowOfScreen(scr), 20, 30, 40, 50, 3, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL); XReparentWindow(dpy, w2, w, 10, 5); // MapWindow XMapWindow(dpy, w); // MapSubwindows XMapSubwindows(dpy, w); // UnmapWindow XUnmapWindow(dpy, w); // UnmapSubwindows XMapWindow(dpy, w); XUnmapSubwindows(dpy, w2); XMapSubwindows(dpy, w); // ConfigureWindow Window w3 = XCreateWindow(dpy, w, 10, 50, 100, 10, 2, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL); XMapWindow(dpy, w3); XWindowChanges wc; wc.x = -5; wc.y = -10; wc.width = 50; wc.height = 40; wc.border_width = 7; wc.sibling = w2; wc.stack_mode = Opposite; XConfigureWindow(dpy, w3, CWX | CWY | CWWidth | CWHeight | CWBorderWidth | CWSibling | CWStackMode, &wc); // CirculateWindow XCirculateSubwindows(dpy, w, RaiseLowest); // GetGeometry Window root; int x, y; unsigned width, height, border_width, depth; XGetGeometry(dpy, w, &root, &x, &y, &width, &height, &border_width, &depth); // QueryTree Window parent; Window *children; unsigned nchildren; success = XQueryTree(dpy, w, &root, &parent, &children, &nchildren); XFree(children); // InternAtom Atom a = XInternAtom(dpy, "WM_PROTOCOLS", True); // GetAtomName char *string = XGetAtomName(dpy, XA_PRIMARY); XFree(string); // ChangeProperty XStoreName(dpy, w, "test window"); // DeleteProperty XDeleteProperty(dpy, w, XA_WM_NAME); // GetProperty // TODO // ListProperties int num_prop; Atom *list = XListProperties(dpy, w, &num_prop); XFree(list); // SetSelectionOwner XSetSelectionOwner(dpy, XA_PRIMARY, w, 12000); XSetSelectionOwner(dpy, XA_SECONDARY, w, CurrentTime); // GetSelectionOwner Window wx = XGetSelectionOwner(dpy, XA_PRIMARY); // ConvertSelection XConvertSelection(dpy, XA_SECONDARY, XA_CURSOR, XA_POINT, w, CurrentTime); // SendEvent // GrabPointer std::cerr << "Grabbing" << std::endl; int res = XGrabPointer(dpy, w, False, Button5MotionMask | PointerMotionHintMask, GrabModeSync, GrabModeAsync, w, None, CurrentTime); XSync(dpy, False); // sleep(5); // UngrabPointer std::cerr << "Ungrabbing" << std::endl; XUngrabPointer(dpy, CurrentTime); // GrabButton XGrabButton(dpy, 3, ShiftMask | ControlMask, w, False, PointerMotionHintMask | Button2MotionMask, GrabModeAsync, GrabModeSync, None, None); XGrabButton(dpy, 2, AnyModifier, w, False, PointerMotionHintMask | Button2MotionMask, GrabModeAsync, GrabModeSync, None, None); // UngrabButton XUngrabButton(dpy, 2, LockMask, w); // ChangeActivePointerGrab XChangeActivePointerGrab(dpy, ButtonPressMask, None, CurrentTime); // GrabKeyboard XGrabKeyboard(dpy, w, True, GrabModeSync, GrabModeSync, 12000); // UngrabKeyboard XUngrabKeyboard(dpy, 13000); // GrabKey XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Tab), ShiftMask | Mod3Mask, w, True, GrabModeSync, GrabModeSync); // UngrabKey XUngrabKey(dpy, AnyKey, AnyModifier, w); // AllowEvents XAllowEvents(dpy, AsyncPointer, 14000); // GrabServer XGrabServer(dpy); // UngrabServer XUngrabServer(dpy); // QueryPointer Window child; int root_x, root_y, win_x, win_y; unsigned mask; Bool bres = XQueryPointer(dpy, w, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask); // GetMotionEvents int nevents; XGetMotionEvents(dpy, w, 15000, 16000, &nevents); // TranslateCoordinates int dest_x, dest_y; XTranslateCoordinates(dpy, w, w2, 10, 20, &dest_x, &dest_y, &child); // WarpPointer XWarpPointer(dpy, w, w2, 0, 0, 100, 100, 20, 30); // SetInputFocus XSetInputFocus(dpy,w, RevertToPointerRoot, 17000); XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, 17000); // GetInputFocus Window focus; int revert_to; XGetInputFocus(dpy, &focus, &revert_to); // QueryKeymap char keys_return[32]; XQueryKeymap(dpy, keys_return); // OpenFont Font fid = XLoadFont(dpy, "cursor"); // CloseFont XUnloadFont(dpy, fid); // QueryFont XFontStruct *fs = XLoadQueryFont(dpy, "cursor"); assert(fs); // QueryTextExtents int direction, font_ascent, font_descent; XCharStruct overall; XQueryTextExtents(dpy, fs -> fid, "toto", 4, &direction, &font_ascent, &font_descent, &overall); XQueryTextExtents(dpy, fs -> fid, "odd__length", 11, &direction, &font_ascent, &font_descent, &overall); XChar2b c2bs; c2bs.byte1 = '$'; c2bs.byte2 = 'B'; XQueryTextExtents16(dpy, fs -> fid, &c2bs, 1, &direction, &font_ascent, &font_descent, &overall); XQueryTextExtents(dpy, fs -> fid, longString, strlen(longString), &direction, &font_ascent, &font_descent, &overall); // ListFonts int actual_count; char **fontList = XListFonts(dpy, "*", 100, &actual_count); XFree((char *)fontList); // ListFontsWithInfo int count; XFontStruct *info; char **names = XListFontsWithInfo(dpy, "*", 100, &count, &info); XFreeFontInfo(names, info, count); // SetFontPath // GetFontPath int npaths; char **charList = XGetFontPath(dpy, &npaths); char **charList2 = new char *[npaths + 1]; memcpy(charList2, charList, npaths * sizeof(char *)); charList2[npaths] = charList2[0]; XSetFontPath(dpy, charList2, npaths + 1); XSetFontPath(dpy, charList, npaths); // Reset to some reasonnable value XFreeFontPath(charList); delete [] charList2; // CreatePixmap Pixmap pix2 = XCreatePixmap(dpy, w, 100, 200, DefaultDepthOfScreen(scr)); // FreePixmap XFreePixmap(dpy, pix2); // CreateGC Pixmap bitmap = XCreateBitmapFromData(dpy, RootWindowOfScreen(scr), "\000\000\001\000\000\001\000\000\001\377\377\377", 3, 4); XGCValues gcv; gcv.function = GXand; gcv.plane_mask = 0x1; gcv.foreground = WhitePixelOfScreen(scr); gcv.background = BlackPixelOfScreen(scr); gcv.line_width = 2; gcv.line_style = LineDoubleDash; gcv.cap_style = CapProjecting; gcv.join_style = JoinRound; gcv.fill_style = FillStippled; gcv.fill_rule = EvenOddRule; gcv.arc_mode = ArcPieSlice; gcv.tile = pixmap; gcv.stipple = bitmap; gcv.ts_x_origin = 3; gcv.ts_y_origin = 4; gcv.font = fs -> fid; gcv.subwindow_mode = ClipByChildren; gcv.graphics_exposures = True; gcv.clip_x_origin = 5; gcv.clip_y_origin = 6; gcv.clip_mask = bitmap; gcv.dash_offset = 1; gcv.dashes = 0xc2; GC gc = XCreateGC(dpy, w, GCFunction | GCPlaneMask | GCForeground | GCBackground | GCLineWidth | GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle | GCFillRule | GCTile | GCStipple | GCTileStipXOrigin | GCTileStipYOrigin | GCFont | GCSubwindowMode | GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin | GCClipMask | GCDashOffset | GCDashList | GCArcMode, &gcv); // ChangeGC gcv.function = GXandReverse; // Only a few of these should appear, since the values are cached on the client side by the Xlib. XChangeGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, &gcv); // CopyGC GC gc2 = XCreateGC(dpy, w, 0, NIL); XCopyGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, gc2); // SetDashes XSetDashes(dpy, gc, 3, "\001\377\001", 3); // SetClipRectangles XRectangle rectangles[] = { { 10, 20, 30, 40 }, { 100, 200, 5, 3 }, { -5, 1, 12, 24 } }; XSetClipRectangles(dpy, gc, 12, 9, rectangles, SIZEOF(rectangles), Unsorted); // FreeGC // done already // ClearArea XClearArea(dpy, w, 30, 10, 10, 100, False); // CopyArea XCopyArea(dpy, w, pixmap, gc, 0, 0, 100, 100, 10, 10); // CopyPlane // This won't work if the Screen doesn't have at least 3 planes XCopyPlane(dpy, pixmap, w, gc, 20, 10, 40, 30, 0, 0, 0x4); // PolyPoint XDrawPoint(dpy, w, gc, 1, 2); XPoint points[] = { { 3, 4 }, { 5, 6 } }; XDrawPoints(dpy, w, gc, points, SIZEOF(points), CoordModeOrigin); // PolyLine XDrawLines(dpy, w, gc, points, SIZEOF(points), CoordModePrevious); // PolySegment XSegment segments[] = { { 7, 8, 9, 10 }, { 11, 12, 13, 14 }, { 15, 16, 17, 18 } }; XDrawSegments(dpy, w, gc, segments, SIZEOF(segments)); // PolyRectangle XDrawRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles)); // PolyArc XArc arcs[] = { { 10, 20, 30, 40, 50, 60 }, { -70, 80, 90, 100, 110, 120 }, { 10, 20, 30, 40, 50, -30 } }; XDrawArcs(dpy, w, gc, arcs, SIZEOF(arcs)); // FillPoly XFillPolygon(dpy, w, gc, points, SIZEOF(points), Convex, CoordModePrevious); // PolyFillRectangle XFillRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles)); // PolyFillArc XFillArcs(dpy, w, gc, arcs, SIZEOF(arcs)); // PutImage // GetImage XImage *image = XGetImage(dpy, w, 10, 20, 40, 30, AllPlanes, ZPixmap); XPutImage(dpy, w, gc, image, 0, 0, 50, 60, 40, 30); XSync(dpy, False); // Make the next request starts at the beginning of a packet // PolyText8 XTextItem textItems[3]; textItems[0].chars = "toto"; textItems[0].nchars = strlen(textItems[0].chars); textItems[0].delta = -3; textItems[0].font = fs->fid; textItems[1].chars = "titi"; textItems[1].nchars = strlen(textItems[1].chars); textItems[1].delta = 3; textItems[1].font = None; textItems[2].chars = "tutu"; textItems[2].nchars = strlen(textItems[2].chars); textItems[2].delta = 0; textItems[2].font = fs->fid; XDrawText(dpy, w, gc, 10, 10, textItems, 3); XTextItem textItems2[3]; textItems2[0].chars = "totox"; textItems2[0].nchars = strlen(textItems2[0].chars); textItems2[0].delta = -3; textItems2[0].font = fs->fid; textItems2[1].chars = "titi"; textItems2[1].nchars = strlen(textItems2[1].chars); textItems2[1].delta = 3; textItems2[1].font = None; textItems2[2].chars = "tutu"; textItems2[2].nchars = strlen(textItems2[2].chars); textItems2[2].delta = 0; textItems2[2].font = fs->fid; XDrawText(dpy, w, gc, 10, 10, textItems2, 3); // PolyText16 XChar2b c2b2[] = { 0, 't', 0, 'x' }; XTextItem16 items16[] = { { &c2bs, 1, -5, None }, { NULL, 0, 0, None }, { c2b2, 2, 0, fs -> fid } }; XDrawText16(dpy, w, gc, 10, 0, items16, SIZEOF(items16)); // ImageText8 XDrawImageString(dpy, w, gc, 10, 10, "toto", 4); // ImageText16 XDrawImageString16(dpy, w, gc, 10, 10, &c2bs, 1); XDrawImageString16(dpy, w, gc, 10, 20, c2b2, 2); // CreateColormap // Don't forget to tell the kids how it was when we had only 8 bits per pixel. Colormap colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None); // FreeColormap XFreeColormap(dpy, colormap); colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None); // CopyColormapAndFree Colormap colormap2 = XCopyColormapAndFree(dpy, colormap); // InstallColormap XInstallColormap(dpy, colormap2); // UninstallColormap XUninstallColormap(dpy, colormap2); // ListInstalledColormaps int num; Colormap *colormapList = XListInstalledColormaps(dpy, w, &num); // AllocColor XColor screen; screen.red = 0; screen.green = 32767; screen.blue = 65535; screen.flags = DoRed | DoGreen | DoBlue; success = XAllocColor(dpy, colormap, &screen); // AllocNamedColor XColor screen2, exact; success = XAllocNamedColor(dpy, colormap, "Wheat", &screen2, &exact); // AllocColorCells unsigned long plane_masks, pixels; success = XAllocColorCells(dpy, colormap, False, &plane_masks, 1, &pixels, 1); // AllocColorPlanes unsigned long rmask, gmask, bmask; success = XAllocColorPlanes(dpy, colormap, False, &pixels, 1, 0, 0, 0, &rmask, &gmask, &bmask); // FreeColors unsigned long pixels2[2] = { screen.pixel, screen2.pixel }; XFreeColors(dpy, colormap, pixels2, 2, 0); // StoreColors success = XAllocColorCells(dpy, colormap, False, NIL, 0, pixels2, 2); // On many contemporary (that is, year 2000) video cards, you can't allocate read / write cells // I want my requests to be sent, however. if (!success) { XSetErrorHandler(errorHandler); } XColor colors[2]; colors[0] = screen; colors[0].pixel = pixels2[0]; colors[1] = screen2; colors[1].pixel = pixels2[1]; XStoreColors(dpy, colormap, colors, 2); // StoreNamedColor XStoreNamedColor(dpy, colormap, "Wheat", colors[0].pixel, DoBlue); XSync(dpy, False); XSetErrorHandler(NIL); // Restore the default handler // QueryColors screen2.pixel = WhitePixelOfScreen(scr); XQueryColor(dpy, colormap, &screen2); // LookupColor success = XLookupColor(dpy, colormap, "DarkCyan", &exact, &screen); // CreateCursor Cursor cursor = XCreatePixmapCursor(dpy, pixmap, None, &exact, colors, 10, 10); // CreateGlyphCursor Cursor cursor2 = XCreateGlyphCursor(dpy, fs -> fid, fs -> fid, 'X', 0, &exact, colors); // FreeCursor XFreeCursor(dpy, cursor2); // RecolorCursor XRecolorCursor(dpy, cursor, colors, &exact); // QueryBestSize success = XQueryBestSize(dpy, CursorShape, RootWindowOfScreen(scr), 100, 20, &width, &height); // QueryExtension int major_opcode, first_event, first_error; XQueryExtension(dpy, "toto", &major_opcode, &first_event, &first_error); // ListExtensions int nextensions; char **extensionList = XListExtensions(dpy, &nextensions); for(char **p = extensionList; nextensions; nextensions--, p++) std::cout << *p << std::endl; XFree(extensionList); // ChangeKeyboardMapping // GetKeyboardMapping int min_keycodes, max_keycodes; XDisplayKeycodes(dpy, &min_keycodes, &max_keycodes); int keysyms_per_keycode; KeySym *keysyms = XGetKeyboardMapping(dpy, min_keycodes, max_keycodes - min_keycodes + 1, &keysyms_per_keycode); XChangeKeyboardMapping(dpy, min_keycodes, keysyms_per_keycode, keysyms, max_keycodes - min_keycodes + 1); // ChangeKeyboardControl // GetKeyboardControl XKeyboardState keyboardState; XGetKeyboardControl(dpy, &keyboardState); XKeyboardControl keyboardValues; keyboardValues.key_click_percent = keyboardState.key_click_percent; keyboardValues.bell_percent = keyboardState.bell_percent; keyboardValues.bell_pitch = keyboardState.bell_pitch; keyboardValues.bell_duration = keyboardState.bell_duration; keyboardValues.led = 1; keyboardValues.led_mode = LedModeOn; keyboardValues.key = min_keycodes; keyboardValues.auto_repeat_mode = AutoRepeatModeDefault; XChangeKeyboardControl(dpy, KBKeyClickPercent | KBBellPercent | KBBellPitch | KBBellDuration | KBLed | KBLedMode | KBKey | KBAutoRepeatMode, &keyboardValues); // Bell XBell(dpy, 90); // ChangePointerControl // GetPointerControl int accel_numerator, accel_denominator, threshold; XGetPointerControl(dpy, &accel_numerator, &accel_denominator, &threshold); XChangePointerControl(dpy, True, True, accel_numerator, accel_denominator, threshold); // SetScreenSaver // GetScreenSaver int timeout, interval, prefer_blanking, allow_exposures; XGetScreenSaver(dpy, &timeout, &interval, &prefer_blanking, &allow_exposures); XSetScreenSaver(dpy, timeout, interval, prefer_blanking, allow_exposures); // ChangeHosts // ListHosts int nhosts; Bool state; XHostAddress *hostList = XListHosts(dpy, &nhosts, &state); XHostAddress host; host.family = FamilyInternet; host.length = 4; host.address = "\001\002\003\004"; XAddHost(dpy, &host); // SetAccessControl XSetAccessControl(dpy, EnableAccess); // SetCloseDownMode XSetCloseDownMode(dpy, RetainTemporary); // KillClient XKillClient(dpy, AllTemporary); // RotateProperties Atom properties[] = { XInternAtom(dpy, "CUT_BUFFER0", False), XInternAtom(dpy, "CUT_BUFFER1", False), XInternAtom(dpy, "CUT_BUFFER2", False) }; XRotateWindowProperties(dpy, RootWindowOfScreen(scr), properties, SIZEOF(properties), -1); // ForceScreenSaver XForceScreenSaver(dpy, ScreenSaverReset); // SetPointerMapping // GetPointerMapping unsigned char map[64]; int map_length = XGetPointerMapping(dpy, map, 64); XSetPointerMapping(dpy, map, map_length); // SetModifierMapping // GetModifierMapping XModifierKeymap *modmap = XGetModifierMapping(dpy); XSetModifierMapping(dpy, modmap); // NoOperation XNoOp(dpy); for(;;) { XEvent e; XNextEvent(dpy, &e); std::cout << "Got an event of type " << e.type << std::endl; } }