/*+++++++++++++++++++++++++++++++++++++++*/
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;
}
}
