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);
}
void
xnestChangeKeyboardControl(DeviceIntPtr pDev, KeybdCtrl * ctrl)
{
#if 0
unsigned long value_mask;
XKeyboardControl values;
int i;
value_mask = KBKeyClickPercent |
KBBellPercent | KBBellPitch | KBBellDuration | KBAutoRepeatMode;
values.key_click_percent = ctrl->click;
values.bell_percent = ctrl->bell;
values.bell_pitch = ctrl->bell_pitch;
values.bell_duration = ctrl->bell_duration;
values.auto_repeat_mode = ctrl->autoRepeat ?
AutoRepeatModeOn : AutoRepeatModeOff;
XChangeKeyboardControl(xnestDisplay, value_mask, &values);
/*
value_mask = KBKey | KBAutoRepeatMode;
At this point, we need to walk through the vector and compare it
to the current server vector. If there are differences, report them.
*/
value_mask = KBLed | KBLedMode;
for (i = 1; i <= 32; i++) {
values.led = i;
values.led_mode =
(ctrl->leds & (1 << (i - 1))) ? LedModeOn : LedModeOff;
XChangeKeyboardControl(xnestDisplay, value_mask, &values);
}
#endif
}
void Window::Close(void)
{
if (this->ctx)
{
if (!glXMakeCurrent(this->dpy, None, NULL))
std::cout << "Could not release drawing context." << std::endl;
glXDestroyContext(this->dpy, this->ctx);
this->ctx = NULL;
}
if (this->fs)
{
XF86VidModeSwitchToMode(this->dpy, this->screen, &this->deskMode);
XF86VidModeSetViewPort(this->dpy, this->screen, 0, 0);
}
else
XUngrabPointer(this->dpy, CurrentTime);
XKeyboardControl _kb;
_kb.auto_repeat_mode = this->deskKeyboardState.global_auto_repeat;
XChangeKeyboardControl(this->dpy, KBAutoRepeatMode, &_kb);
XCloseDisplay(this->dpy);
};
static void
set_bell_pitch(Display *dpy, int pitch) {
XKeyboardControl values;
values.bell_pitch = pitch;
XChangeKeyboardControl(dpy, KBBellPitch, &values);
return;
}
static void
set_bell_dur(Display *dpy, int duration) {
XKeyboardControl values;
values.bell_duration = duration;
XChangeKeyboardControl(dpy, KBBellDuration, &values);
return;
}
void Window::OnFocusOut(void)
{
//FIXME: Hay que liberar el ratón
XKeyboardControl _kb;
_kb.auto_repeat_mode = this->deskKeyboardState.global_auto_repeat;
XChangeKeyboardControl(this->dpy, KBAutoRepeatMode, &_kb);
};
void KeyboardConfig::save()
{
KConfig config("kcminputrc");
XKeyboardControl kbd;
clickVolume = getClick();
keyboardRepeat = ui->repeatBox->isChecked() ? AutoRepeatModeOn : AutoRepeatModeOff;
numlockState = getNumLockState();
kbd.key_click_percent = clickVolume;
kbd.auto_repeat_mode = keyboardRepeat;
XChangeKeyboardControl(kapp->getDisplay(),
KBKeyClickPercent | KBAutoRepeatMode,
&kbd);
if( keyboardRepeat ) {
set_repeatrate(ui->delay->value(), ui->rate->value());
}
config.setGroup("Keyboard");
config.writeEntry("ClickVolume",clickVolume);
config.writeEntry("KeyboardRepeating", (keyboardRepeat == AutoRepeatModeOn));
config.writeEntry("RepeatRate", ui->rate->value() );
config.writeEntry("RepeatDelay", ui->delay->value() );
config.writeEntry("NumLock", numlockState );
config.sync();
}
void
grab_keys ( KTKeySettingsList *key_list,
Display *display )
/*
Input:
key_list - The list of keys to grab
display - Specifies the connection to the X server
Output:
-
Returns:
-
Desciption:
This function establishes a passive grab on the keyboard for every key in
key_list. For each key in key_list auto repeat mode is turned on for those
keys with auto_repeat_on member equal to TRUE.
*/
{
KTKeySettings *key;
XKeyboardControl keyboard_control;
/* Set our own error handler so that the program continues after grabbing
* a key failed.
*/
XSetErrorHandler ((XErrorHandler) x_error_handler);
for (key = key_list->head; key != NULL; key = key->next)
{
XGrabKey (display, key->keycode, AnyModifier, DefaultRootWindow(display),
False, GrabModeAsync, GrabModeAsync);
keyboard_control.key = key->keycode;
keyboard_control.auto_repeat_mode = key->auto_repeat_on ? AutoRepeatModeOn : AutoRepeatModeOff;
/* Turn for the current key auto repeat on/off */
XChangeKeyboardControl (display, KBKey|KBAutoRepeatMode, &keyboard_control);
}
}
static void xinput_set_leds(int leds)
{
if (xinput_old_leds != leds)
{
XKeyboardControl values;
int i;
for (i=0;i<32;i++)
{
values.led_mode = -1;
if ((xinput_old_leds & (0x01 << i)) &&
!(leds & (0x01 << i)) )
values.led_mode = LedModeOff;
if (!(xinput_old_leds & (0x01 << i)) &&
(leds & (0x01 << i)) )
values.led_mode = LedModeOn;
if (values.led_mode != -1)
{
values.led = i + 1;
/* GRR leds 1 and 2 are swapped in X */
if (values.led == 1)
values.led = 2;
else if (values.led == 2)
values.led = 1;
XChangeKeyboardControl(display, KBLed|KBLedMode, &values);
}
}
xinput_old_leds = leds;
}
}
static void on_kb_beep_toggle(GtkToggleButton* btn, gpointer user_data)
{
XKeyboardControl values;
beep = gtk_toggle_button_get_active(btn);
values.bell_percent = beep ? -1 : 0;
XChangeKeyboardControl(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), KBBellPercent, &values);
}
int iupdrvSetGlobal(const char *name, const char *value)
{
if (iupStrEqual(name, "LANGUAGE"))
{
iupStrMessageUpdateLanguage(value);
return 1;
}
if (iupStrEqual(name, "AUTOREPEAT"))
{
XKeyboardControl values;
if (iupStrBoolean(value))
values.auto_repeat_mode = 1;
else
values.auto_repeat_mode = 0;
XChangeKeyboardControl(iupmot_display, KBAutoRepeatMode, &values);
return 0;
}
if (iupStrEqual(name, "CURSORPOS"))
{
int x, y;
if (iupStrToIntInt(value, &x, &y, 'x') == 2)
XWarpPointer(iupmot_display,None,RootWindow(iupmot_display, iupmot_screen),0,0,0,0,x,y);
return 0;
}
return 1;
}
/*+++++++++++++++++++++++++++++++++++++++*/
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;
}
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;
}
value caml_gr_sound(value vfreq, value vdur)
{
XKeyboardControl kbdcontrol;
caml_gr_check_open();
kbdcontrol.bell_pitch = Int_val(vfreq);
kbdcontrol.bell_duration = Int_val(vdur);
XChangeKeyboardControl(caml_gr_display, KBBellPitch | KBBellDuration,
&kbdcontrol);
XBell(caml_gr_display, 0);
kbdcontrol.bell_pitch = -1; /* restore default value */
kbdcontrol.bell_duration = -1; /* restore default value */
XChangeKeyboardControl(caml_gr_display, KBBellPitch | KBBellDuration,
&kbdcontrol);
XFlush(caml_gr_display);
return Val_unit;
}
static void apply_values(void) {
unsigned long v = KBBellPercent | KBBellPitch | KBBellDuration;
XKeyboardControl kc;
kc.bell_percent = vol_val;
kc.bell_pitch = pitch_val;
kc.bell_duration = dur_val;
XChangeKeyboardControl(fl_display, v, &kc);
}
void GLUTAPIENTRY
glutSetKeyRepeat(int repeatMode)
{
#if !defined(_WIN32)
XKeyboardControl values;
/* GLUT's repeatMode #define's match the Xlib API values. */
values.auto_repeat_mode = repeatMode;
XChangeKeyboardControl(__glutDisplay, KBAutoRepeatMode, &values);
#endif
}
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 gboolean
toggle_leds (GisPage *page)
{
XKeyboardControl values;
GisFinishedPage *summary = GIS_FINISHED_PAGE (page);
GisFinishedPagePrivate *priv = gis_finished_page_get_instance_private (summary);
values.led_mode = priv->led_state;
XChangeKeyboardControl(GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(GTK_WIDGET(page))), KBLedMode, &values);
priv->led_state = priv->led_state == 1 ? 0 : 1;
return TRUE;
}
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
}
}
/* x_set_leds:
* Update the keyboard LEDs.
*/
static void x_set_leds(int leds)
{
XKeyboardControl values;
ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
ASSERT(xkeyboard_installed);
_al_mutex_lock(&system->lock);
values.led = 1;
values.led_mode = leds & ALLEGRO_KEYMOD_NUMLOCK ? LedModeOn : LedModeOff;
XChangeKeyboardControl(system->x11display, KBLed | KBLedMode, &values);
values.led = 2;
values.led_mode = leds & ALLEGRO_KEYMOD_CAPSLOCK ? LedModeOn : LedModeOff;
XChangeKeyboardControl(system->x11display, KBLed | KBLedMode, &values);
values.led = 3;
values.led_mode = leds & ALLEGRO_KEYMOD_SCROLLLOCK ? LedModeOn : LedModeOff;
XChangeKeyboardControl(system->x11display, KBLed | KBLedMode, &values);
_al_mutex_unlock(&system->lock);
}
/* x_set_leds:
* Update the keyboard LEDs.
*/
static void x_set_leds(int leds)
{
XKeyboardControl values;
if (!xkeyboard_installed)
return;
XLOCK();
values.led = 1;
values.led_mode = leds & KB_NUMLOCK_FLAG ? LedModeOn : LedModeOff;
XChangeKeyboardControl(_xwin.display, KBLed | KBLedMode, &values);
values.led = 2;
values.led_mode = leds & KB_CAPSLOCK_FLAG ? LedModeOn : LedModeOff;
XChangeKeyboardControl(_xwin.display, KBLed | KBLedMode, &values);
values.led = 3;
values.led_mode = leds & KB_SCROLOCK_FLAG ? LedModeOn : LedModeOff;
XChangeKeyboardControl(_xwin.display, KBLed | KBLedMode, &values);
XUNLOCK();
}
void QIrrlichtWidget::setAutoRepeatKeys(bool mode)
{
qDebug() << "QIrrlichtWidget::setAutoRepeatKeys";
XKeyboardControl control;
control.auto_repeat_mode = (mode ? 1 : 0); // Set mode to 1 for
// autorepeat, 0 to disable
control.key = -1; // We want to change the behaviour for all keys
QList<QScreen*> screens = QGuiApplication::screens();
QXcbScreen *xcbscreen = static_cast<QXcbScreen*>(screens.at(0)->handle());
Display *display = static_cast<Display*>(xcbscreen->connection()->xlib_display());
XChangeKeyboardControl(display, KBAutoRepeatMode, &control);
}
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);
}
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);
}
/*+++++++++++++++++++++++++++++++++++++++*/
static void
valueChangedCB(
Widget w,
XtPointer client_data,
XtPointer call_data )
{
XKeyboardControl kbdControl;
int kbdControlMask;
/* set keyboard click volume to scale value */
kbdControlMask = KBKeyClickPercent;
kbdControl.key_click_percent = kbd.new_key_click_percent =
getValue(kbd.volumeScale);
XChangeKeyboardControl(style.display, kbdControlMask, &kbdControl);
kbd.systemDefaultFlag = False;
}
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 KBellConfig::save()
{
XKeyboardControl kbd;
int bellVolume = m_volume->value();
int bellPitch = m_pitch->value();
int bellDuration = m_duration->value();
kbd.bell_percent = bellVolume;
kbd.bell_pitch = bellPitch;
kbd.bell_duration = bellDuration;
XChangeKeyboardControl(kapp->getDisplay(),
KBBellPercent | KBBellPitch | KBBellDuration,
&kbd);
KConfig config("kcmbellrc", false, false);
config.setGroup("General");
config.writeEntry("Volume",bellVolume);
config.writeEntry("Pitch",bellPitch);
config.writeEntry("Duration",bellDuration);
config.sync();
KConfig cfg("kdeglobals", false, false);
cfg.setGroup("General");
cfg.writeEntry("UseSystemBell", m_useBell->isChecked());
cfg.sync();
if (!m_useBell->isChecked())
{
KConfig config("kaccessrc", false);
config.setGroup("Bell");
config.writeEntry("SystemBell", false);
config.writeEntry("ArtsBell", false);
config.writeEntry("VisibleBell", false);
}
}
void led (int led, LedMode mode, ActionMode doAction)
/* Only LED_NUM can be ActionMode DELAYED */
{
static ulong ledReminder = 0x00;
ulong ledVal;
#if (! REMOVE_X_CODE)
XKeyboardControl values;
#endif
#ifdef DEBUG
printf("led(%d, %d)\n", led, (int)mode);
#endif
#if (! REMOVE_X_CODE)
if (myDisplay) {
switch (mode) {
case SET:
values.led_mode = LedModeOn;
break;
case CLEAR:
values.led_mode = LedModeOff;
break;
case TOGGLE:
values.led_mode = LedModeOn;
}
}
values.led = led;
#endif
if (myDisplay) {
#if (! REMOVE_X_CODE)
XChangeKeyboardControl(myDisplay, KBLed | KBLedMode, &values);
if (doAction != DELAYED)
XSync(myDisplay, FALSE);
#endif
} else {
if (doAction != FINISH) {
if (ioctl(keyboardDevice, KDGETLED, &ledVal)) {
perror("tleds: KDGETLED");
exit(1);
}
} else {
ledVal = 0L;
}
switch (led) {
case SCROLLLOCKLED:
if (mode == SET)
ledVal |= LED_SCR;
else
ledVal &= ~LED_SCR;
break;
case NUMLOCKLED:
if (mode == SET)
ledVal |= LED_NUM;
else
ledVal &= ~LED_NUM;
break;
default:
perror("tleds: wrong led-value");
exit(1);
}
if (opt_c && doAction != FINISH) {
ledVal = correct_caps(ledVal);
}
if (doAction) { /* FINISH or NOW */
if (doAction == FINISH)
ledVal |= ledReminder;
if (ioctl(keyboardDevice, KDSETLED, (char)ledVal)) {
perror("tleds: KDSETLED");
exit(1);
}
ledReminder = 0x00;
} else {
/* Well, we know from report_traffic(), LED_SCR is
processed later. OK, kludge. */
ledReminder = ledVal & ~LED_SCR;
}
}
}
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;
}
}