void ungrab_button(guint button, guint state, Window win)
{
guint i;
for (i = 0; i < MASK_LIST_SIZE; ++i)
XUngrabButton(ob_display, button, state | mask_list[i], win);
}
void DockContainer::embed( WId id )
{
if( id == _embeddedWinId || id == 0)
return;
QRect geom = KWin::windowInfo(id,NET::WMKDEFrameStrut).frameGeometry();
// does the same as KWM::prepareForSwallowing()
XWithdrawWindow( qt_xdisplay(), id, qt_xscreen() );
while( KWin::windowInfo(id, NET::XAWMState).mappingState() != NET::Withdrawn );
XReparentWindow( qt_xdisplay(), id, winId(), 0, 0 );
// resize if window is bigger than frame
if( (geom.width() > width()) ||
(geom.height() > height()) )
XResizeWindow( qt_xdisplay(), id, width(), height() );
else
XMoveWindow(qt_xdisplay(), id,
(sz() - geom.width())/2 - border(),
(sz() - geom.height())/2 - border());
XMapWindow( qt_xdisplay(), id );
XUngrabButton( qt_xdisplay(), AnyButton, AnyModifier, winId() );
_embeddedWinId = id;
}
void Gesture::grab_mouse( bool grab_P )
{
if( grab_P )
{
KXErrorHandler handler;
static int mask[] = { 0, Button1MotionMask, Button2MotionMask, Button3MotionMask,
Button4MotionMask, Button5MotionMask, ButtonMotionMask, ButtonMotionMask,
ButtonMotionMask, ButtonMotionMask };
#define XCapL KKeyNative::modXLock()
#define XNumL KKeyNative::modXNumLock()
#define XScrL KKeyNative::modXScrollLock()
unsigned int mods[ 8 ] =
{
0, XCapL, XNumL, XNumL | XCapL,
XScrL, XScrL | XCapL,
XScrL | XNumL, XScrL | XNumL | XCapL
};
#undef XCapL
#undef XNumL
#undef XScrL
for( int i = 0;
i < 8;
++i )
XGrabButton( qt_xdisplay(), button, mods[ i ], qt_xrootwin(), False,
ButtonPressMask | ButtonReleaseMask | mask[ button ], GrabModeAsync, GrabModeAsync,
None, None );
bool err = handler.error( true );
kdDebug( 1217 ) << "Gesture grab:" << err << endl;
}
else
{
kdDebug( 1217 ) << "Gesture ungrab" << endl;
XUngrabButton( qt_xdisplay(), button, AnyModifier, qt_xrootwin());
}
}
/** Grab buttons
* \param c Client pointer
* \param focused For know if c is or not focused
*/
void
mouse_grabbuttons(Client *c, Bool focused)
{
size_t i;
uint but[] = {Button1, Button2, Button3, Button4, Button5};
XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
if(focused)
for(i = 0; i < LEN(but); ++i)
{
XGrabButton(dpy, but[i], conf.client.mod, c->win, False,
ButtonMask, GrabModeAsync,GrabModeSync, None, None);
XGrabButton(dpy, but[i], conf.client.mod|LockMask, c->win, False,
ButtonMask, GrabModeAsync,GrabModeSync, None, None);
XGrabButton(dpy, but[i], conf.client.mod|numlockmask, c->win, False,
ButtonMask, GrabModeAsync,GrabModeSync, None, None);
XGrabButton(dpy, but[i], conf.client.mod|LockMask|numlockmask, c->win, False,
ButtonMask, GrabModeAsync,GrabModeSync, None, None);
}
else
XGrabButton(dpy, AnyButton, AnyModifier, c->win, False,
ButtonMask, GrabModeAsync, GrabModeSync, None, None);
return;
}
static void __focus_grab_one_button(
FvwmWindow *fw, int button, int grab_buttons)
{
Bool do_grab;
do_grab = (grab_buttons & (1 << button));
if ((do_grab & (1 << button)) == (fw->grabbed_buttons & (1 << button)))
{
return;
}
if (do_grab)
{
XGrabButton(
dpy, button + 1, AnyModifier, FW_W_PARENT(fw), True,
ButtonPressMask, GrabModeSync, GrabModeAsync, None,
None);
/* Set window flags accordingly as we grab or ungrab. */
fw->grabbed_buttons |= (1 << button);
}
else
{
XUngrabButton(dpy, button + 1, AnyModifier, FW_W_PARENT(fw));
fw->grabbed_buttons &= ~(1 << button);
}
return;
}
static void
removePassiveButtonGrab (CompScreen *s,
CompButtonBinding *button)
{
unsigned int modifiers, mask;
int i;
modifiers = button->modifiers & ~(CompPressMask | CompReleaseMask);
if (modifiers == button->modifiers)
return;
for (i = 0; i < s->nButtonGrab; i++)
{
if (button->button == s->buttonGrab[i].button &&
modifiers == s->buttonGrab[i].modifiers)
{
s->buttonGrab[i].count--;
if (s->buttonGrab[i].count)
return;
s->nButtonGrab--;
s->buttonGrab = realloc (s->buttonGrab,
sizeof (CompButtonGrab) * s->nButtonGrab);
mask = virtualToRealModMask (s->display, modifiers);
if (!(mask & CompNoMask))
{
XUngrabButton (s->display->display,
button->button,
mask,
s->root);
}
}
}
}
static void
updatePassiveButtonGrabs (CompScreen *s)
{
unsigned int mask;
int i;
XUngrabButton (s->display->display, AnyButton, AnyModifier, s->root);
for (i = 0; i < s->nButtonGrab; i++)
{
mask = virtualToRealModMask (s->display, s->buttonGrab[i].modifiers);
if (!(mask & CompNoMask))
{
XGrabButton (s->display->display,
s->buttonGrab[i].button,
mask,
s->root,
TRUE,
POINTER_GRAB_MASK,
GrabModeAsync,
GrabModeAsync,
None,
None);
}
}
}
void client_focus(struct WM_t *W, struct wmclient *C)
{
int oldidx;
struct wmclient *old;
/* Don't do anything if there's nothing to focus */
if (W->nclients == 0)
return;
oldidx = get_client_index(W, C->win);
old = W->clients[0];
move_down_client_list(W, 0, oldidx);
W->clients[0] = C;
/* Unfocus the old window */
/* Re-enable grabbing for click events */
XGrabButton(W->XDisplay, Button1, 0, old->win, 0, ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
GrabModeAsync, GrabModeSync, None, None);
/* Make the border boring */
set_border_colour(W, old, 0);
set_border_colour(W, C, 1);
XRaiseWindow(W->XDisplay, C->win);
XSetInputFocus(W->XDisplay, C->win, RevertToPointerRoot, CurrentTime);
XUngrabButton(W->XDisplay, Button1, 0, C->win);
refresh_current_head(W);
}
int main(int argc, char * argv[]) {
Window root;
Display * display;
XEvent xev;
int screenWidth;
int screenHeight;
display = XOpenDisplay(NULL);
if (display == NULL) {
if (debug) printf("Could not open display\n");
return 1;
}
root = DefaultRootWindow(display);
screenWidth = WidthOfScreen(DefaultScreenOfDisplay(display));
screenHeight = HeightOfScreen(DefaultScreenOfDisplay(display));
if (debug) printf("Screen width: %i\n", screenWidth);
if (debug) printf("Screen height: %i\n", screenHeight);
XAllowEvents(display, AsyncBoth, CurrentTime);
bool go = true;
// We grab
XGrabButton(display, AnyButton, AnyModifier, root, true, ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None);
while (go) {
XNextEvent(display, &xev);
switch(xev.type) {
case ButtonPress:
if (debug) printf("Button press - %i\n", xev.xbutton.button);
if (debug) printf("Coordinates - %i, %i\n", xev.xbutton.x, xev.xbutton.y);
break;
case ButtonRelease:
if (debug) printf("Button release - %i\n", xev.xbutton.button);
if (xev.xbutton.y>screenHeight-400)
// If we touch on the bottom side of the screen, we go to the next page
pageForward(display);
else if (xev.xbutton.x>screenWidth-200 && xev.xbutton.y<200)
// If we touch the upper right corner, we quit
go = false;
else
// If touched anywhere else let's apply a simple touch where we are
// It's not perfect, because it will disable gestures
SendMouseEvent(display, Button1, xev.xbutton.x, xev.xbutton.y, true);
usleep(10000);
SendMouseEvent(display, Button1, xev.xbutton.x, xev.xbutton.y, false);
break;
}
}
XUngrabButton(display, AnyButton, AnyModifier, root);
XCloseDisplay(display);
return 0;
}
void
xu_btn_ungrab(Window win, int mask, u_int btn)
{
u_int i;
for (i = 0; i < nitems(ign_mods); i++)
XUngrabButton(X_Dpy, btn, (mask | ign_mods[i]), win);
}
void
GrabButtonRelease(unsigned int button, unsigned int modifiers, Win win)
{
int i;
#if USE_XI2
XIGrabModifiers modifiers_inouts[8];
int num_modifiers;
if (modifiers == AnyModifier)
{
num_modifiers = 1;
modifiers_inouts[0].modifiers = XIAnyModifier;
modifiers_inouts[0].status = 0;
}
else
{
num_modifiers = 0;
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
modifiers_inouts[num_modifiers].modifiers =
modifiers | Mode.masks.mod_combos[i];
modifiers_inouts[num_modifiers].status = 0;
num_modifiers++;
}
}
XIUngrabButton(disp, DEV_PTR, button, WinGetXwin(win),
num_modifiers, modifiers_inouts);
#else
if (modifiers == AnyModifier)
{
XUngrabButton(disp, button, modifiers, WinGetXwin(win));
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XUngrabButton(disp, button, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win));
}
#endif
}
void
GrabButtonRelease(unsigned int button, unsigned int modifiers, Win win)
{
int i;
if (modifiers == AnyModifier)
{
XUngrabButton(disp, button, modifiers, WinGetXwin(win));
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XUngrabButton(disp, button, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win));
}
}
static int
spi_dec_ungrab_mouse (gpointer data)
{
Display *display = spi_get_display ();
if (display)
{
XUngrabButton (spi_get_display (), AnyButton, AnyModifier,
XDefaultRootWindow (spi_get_display ()));
}
return FALSE;
}
void x11_hotkeys::ungrabkeys()
{
if (grab_key.key.sym==0)
return;
Display *d=display;
for (int screen = 0; screen<ScreenCount(d); screen++) {
XUngrabKey(d, AnyKey, AnyModifier, RootWindow (d, screen));
XUngrabButton(d, AnyButton, AnyModifier, RootWindow (d, screen));
}
}
void grab_client_buttons(HSClient* client, bool focused) {
update_numlockmask();
XUngrabButton(g_display, AnyButton, AnyModifier, client->window);
if (focused) {
g_list_foreach(g_mouse_binds, (GFunc)grab_client_button, client);
}
unsigned int btns[] = { Button1, Button2, Button3 };
for (int i = 0; i < LENGTH(btns); i++) {
XGrabButton(g_display, btns[i], AnyModifier, client->window, False,
ButtonPressMask|ButtonReleaseMask, GrabModeSync,
GrabModeSync, None, None);
}
}
void rmclient(Client *c)
{
Client *cc;
if (c == clients)
clients = c->next;
else
if((cc = clients))
for (; cc->next; cc = cc->next)
if (cc->next == c) {
cc->next = cc->next->next;
break;
}
if(c->active) {
if(!menuactive)
setfocus(None);
c->active=False;
activeclient = NULL;
XInstallColormap(dpy, scr->cmap);
} else if(prefs.focus==FOC_CLICKTOTYPE)
XUngrabButton(dpy, Button1, AnyModifier, c->parent);
#ifdef USE_FONTSETS
if(c->title)
free(c->title);
#else
if(c->title.value)
XFree(c->title.value);
#endif
if(c->parent != c->scr->root) {
XDestroyWindow(dpy, c->parent);
XDeleteContext(dpy, c->parent, client_context);
}
if(c->close)
XDeleteContext(dpy, c->close, client_context);
if(c->drag)
XDeleteContext(dpy, c->drag, client_context);
if(c->iconify)
XDeleteContext(dpy, c->iconify, client_context);
if(c->zoom)
XDeleteContext(dpy, c->zoom, client_context);
if(c->depth)
XDeleteContext(dpy, c->depth, client_context);
if(c->resize)
XDeleteContext(dpy, c->resize, client_context);
if(c->icon)
rmicon(c->icon);
if(c->window)
XDeleteContext(dpy, c->window, client_context);
free(c);
}
static
void UngrabKeyOrButton (
Widget widget,
int keyOrButton,
Modifiers modifiers,
Boolean isKeyboard)
{
XtServerGrabRec tempGrab;
XtPerWidgetInput pwi;
XtCheckSubclass(widget, coreWidgetClass,
"in XtUngrabKey or XtUngrabButton");
/* Build a temporary grab list entry */
tempGrab.widget = widget;
tempGrab.modifiers = modifiers;
tempGrab.keybut = keyOrButton;
tempGrab.hasExt = False;
LOCK_PROCESS;
pwi = _XtGetPerWidgetInput(widget, FALSE);
UNLOCK_PROCESS;
/*
* if there is no entry in the context manager then somethings wrong
*/
if (!pwi)
{
XtAppWarningMsg(XtWidgetToApplicationContext(widget),
"invalidGrab", "ungrabKeyOrButton", XtCXtToolkitError,
"Attempt to remove nonexistent passive grab",
(String *)NULL, (Cardinal *)NULL);
return;
}
if (XtIsRealized(widget))
{
if (isKeyboard)
XUngrabKey(widget->core.screen->display,
keyOrButton, (unsigned int)modifiers,
widget->core.window);
else
XUngrabButton(widget->core.screen->display,
keyOrButton, (unsigned int)modifiers,
widget->core.window);
}
/* Delete all entries which are encompassed by the specified grab. */
DeleteServerGrabFromList(isKeyboard ? &pwi->keyList : &pwi->ptrList,
&tempGrab);
}
void cfg_reinitialize(void) {
int i;
#ifdef USE_XFT
int xft = xftfont ? 1 : 0;
#endif
/* free things from old configuration */
XFreeGC(dpy, gc);
XFreeGC(dpy, igc);
XFreeGC(dpy, bgc);
XFreeGC(dpy, ibgc);
keys_free();
/* read config again */
cfg_read(0);
/* update some things */
p_attr.background_pixel = fg.pixel;
p_attr.border_pixel = ibfg.pixel;
select_root_events();
/* update clients */
for(i = 0; i < cn; i++) {
#ifdef USE_XFT
if(xftfont && !xft)
clients[i]->wlist_draw = XftDrawCreate(dpy, clients[i]->wlist_item, visual, colormap);
if(!xftfont && xft) {
XftDrawDestroy(clients[i]->title_draw);
XftDrawDestroy(clients[i]->wlist_draw);
}
#endif
XDestroyWindow(dpy, clients[i]->button_parent_left);
XDestroyWindow(dpy, clients[i]->button_parent_right);
free((void *) clients[i]->buttons);
clients[i]->flags ^= clients[i]->flags & HAS_BUTTONS;
buttons_create(clients[i]); /* buttons are now on top of the client window */
XRaiseWindow(dpy, clients[i]->window); /* hence this line */
client_update(clients[i]);
client_update_name(clients[i]);
(clients[i] == current) ? client_set_bg(clients[i], bg, fg) : client_set_bg(clients[i], ibg, ifg);
if(clients[i]->flags & IS_TASKBAR)
client_set_layer(clients[i], taskbar_ontop ? TOP : NORMAL);
XUngrabButton(dpy, AnyButton, AnyModifier, clients[i]->parent);
client_grab_buttons(clients[i]);
if(clients[i]->flags & FULLSCREEN && clients[i]->layer <= NORMAL && fullscreen_stacking != FS_NORMAL)
client_update_layer(clients[i], (fullscreen_stacking == FS_ALWAYS_ONTOP) ? NORMAL : TOP);
if(clients[i]->flags & HAS_BORDER)
XSetWindowBorderWidth(dpy, clients[i]->parent, border_width);
ewmh_update_extents(clients[i]);
}
ewmh_update_number_of_desktops();
ewmh_update_geometry();
ewmh_update_strut();
}
void Client::activate()
{
// fprintf(stderr, "Client::activate (this = %p, window = %x, parent = %x)\n",
// this, m_window, parent());
if (parent() == root()) {
fprintf(stderr, "wm2: warning: bad parent in Client::activate\n");
return;
}
if (!m_managed || isHidden() || isWithdrawn()) return;
if (isActive()) {
decorate(True);
if (CONFIG_AUTO_RAISE || CONFIG_RAISE_ON_FOCUS) mapRaised();
return;
}
if (activeClient()) {
activeClient()->deactivate();
// & some other-screen business
}
XUngrabButton(display(), AnyButton, AnyModifier, parent());
XSetInputFocus(display(), m_window, RevertToPointerRoot,
windowManager()->timestamp(False));
if (m_protocol & PtakeFocus) {
sendMessage(Atoms::wm_protocols, Atoms::wm_takeFocus);
}
// now set revert of window that reverts to this one so as to
// revert to the window this one used to revert to (huh?)
windowManager()->skipInRevert(this, m_revert);
m_revert = activeClient();
while (m_revert && !m_revert->isNormal()) m_revert = m_revert->revertTo();
windowManager()->setActiveClient(this);
// if (CONFIG_AUTO_RAISE || CONFIG_RAISE_ON_FOCUS) mapRaised();
decorate(True);
installColormap(); // new!
}
void
data_listfree(void) {
Win *w;
List *l;
for(l = list_first(data.wins); l;) {
w = (Win*)l->ptr;
l = l->next;
XSetWindowBorderWidth(data.dpy, w->win, 0);
XSelectInput(data.dpy, w->win, NoEventMask);
XUngrabButton(data.dpy, AnyButton, AnyModifier, w->win);
if(!(w->tag & data.tag))
XMoveWindow(data.dpy, w->win, w->x, w->y);
data.wins = list_remove(data.wins, w);
data.stack = list_remove(data.stack, w);
free(w);
}
}
void unmanage_client(Window win) {
Client* client = get_client_from_window(win);
if (!client) return;
// remove from tag
frame_remove_window(client->tag->frame, win);
// and arrange monitor
Monitor* m = find_monitor_with_tag(client->tag);
if (m) monitor_apply_layout(m);
// ignore events from it
XSelectInput(gDisplay, win, 0);
XUngrabButton(gDisplay, AnyButton, AnyModifier, win);
// permanently remove it
for(int i=0; i<g_clients->len; i++){
if(g_array_index(g_clients, Client*, i) == client)
g_array_remove_index(g_clients, i);
}
}
void
x11_init (int argc, char ** argv)
{
int i;
if (display_name == NULL) display_name = XDisplayName (NULL);
printf ("Display name: %s\n", display_name);
d = XOpenDisplay (display_name);
if(d == NULL) {
fprintf (stderr,"%s: could not open display \"%s\".\n", progname, display_name);
exit(1);
}
XAllowEvents (d, AsyncBoth, CurrentTime);
#if 1
if (0) {
for (i=1; i<9; i++) {
XUngrabButton (d, 8, AnyModifier, DefaultRootWindow (d));
}
} else {
/*
XGrabKey (d,
162,
AnyModifier,
DefaultRootWindow (d),
False,
GrabModeAsync,
GrabModeAsync);
*/
/* XGrabButton (d,
7,
AnyModifier,
DefaultRootWindow (d),
False, ButtonReleaseMask | ButtonPressMask,
GrabModeAsync, GrabModeAsync,
None,
None);*/
}
#endif
}
void grab_button(int is_grab)
{
Window rw = RootWindow(main_window->display, DefaultScreen(main_window->display));
int status;
if (is_grab)
{
status = XGrabButton(main_window->display, Button1, AnyModifier, rw, FALSE, ButtonPressMask|ButtonReleaseMask, GrabModeSync, GrabModeAsync, None, None);
XSync (main_window->display, FALSE);
}
else
status = XUngrabButton(main_window->display, AnyButton, AnyModifier, rw);
if (status == BadCursor)
log_message(ERROR, _("Failed to %s mouse with error BadCursor"), grab_ungrab[is_grab]);
else if (status == BadValue)
log_message(ERROR, _("Failed to %s mouse with error BadValue"), grab_ungrab[is_grab]);
else if (status == BadWindow)
log_message(ERROR, _("Failed to %s mouse with error BadWindow"), grab_ungrab[is_grab]);
}
void
run(void) {
for(int scr=0;scr < ScreenCount(dpy); scr++) {
XUngrabButton(dpy, AnyButton, AnyModifier, RootWindow (dpy, scr));
}
for(int scr=0;scr < ScreenCount(dpy); scr++) {
XGrabButton(dpy, button, AnyModifier, RootWindow(dpy, scr),
False, ButtonPressMask | ButtonReleaseMask,
GrabModeAsync, GrabModeAsync, None, None);
}
for(;;) {
XEvent ev;
XNextEvent(dpy, &ev);
if(ev.xbutton.button == button && ev.xbutton.type == btype) {
spawn();
}
}
}
void
unmanage(Client *c) {
Client *nc;
/* The server grab construct avoids race conditions. */
XGrabServer(dpy);
XSetErrorHandler(xerrordummy);
detachstack(c);
detachclient(c);
if(sel == c) {
for(nc = stack; nc && (nc->view != view); nc = nc->snext);
focus(nc);
}
XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
setclientstate(c, WithdrawnState);
free(c);
XSync(dpy, False);
XSetErrorHandler(xerror);
XUngrabServer(dpy);
arrange();
}
void Gesture::grab_mouse( bool grab_P )
{
kDebug() << grab_P;
if( grab_P )
{
kDebug() << "gesture grab";
Q_ASSERT( button != 0 );
KXErrorHandler handler;
static int mask[] = { 0, Button1MotionMask, Button2MotionMask, Button3MotionMask,
Button4MotionMask, Button5MotionMask, ButtonMotionMask, ButtonMotionMask,
ButtonMotionMask, ButtonMotionMask
};
#define XCapL KKeyServer::modXLock()
#define XNumL KKeyServer::modXNumLock()
#define XScrL KKeyServer::modXScrollLock()
unsigned int mods[ 8 ] =
{
0, XCapL, XNumL, XNumL | XCapL,
XScrL, XScrL | XCapL,
XScrL | XNumL, XScrL | XNumL | XCapL
};
#undef XCapL
#undef XNumL
#undef XScrL
for( int i = 0;
i < 8;
++i )
XGrabButton( QX11Info::display(), button, mods[ i ], QX11Info::appRootWindow(), False,
ButtonPressMask | ButtonReleaseMask | mask[ button ], GrabModeAsync, GrabModeAsync,
None, None );
bool err = handler.error( true );
kDebug() << "Gesture grab:" << err;
}
else
{
kDebug() << "Gesture ungrab";
XUngrabButton( QX11Info::display(), button, AnyModifier, QX11Info::appRootWindow());
}
}
void
xfwm_device_ungrab_button (XfwmDevices *devices, Display *display,
guint button, guint modifiers, Window grab_window)
{
#ifdef HAVE_XI2
XIGrabModifiers xi2_modifiers;
#endif
#ifdef HAVE_XI2
if (devices->xi2_available)
{
xi2_modifiers.modifiers = xi2_modifier_mask (modifiers);
xi2_modifiers.status = 0;
XIUngrabButton (display, devices->pointer.xi2_device, button,
grab_window, 1, &xi2_modifiers);
}
else
#endif
{
XUngrabButton (display, button, modifiers, grab_window);
}
}
static void up_x11uninitX(void)
{
fprintf(stderr, "Uninitalizing X\n");
if (g_x11initialized)
{
#ifndef CONFIG_SIM_X11NOSHM
if (g_shmcheckpoint > 4)
{
XShmDetach(g_display, &g_xshminfo);
}
if (g_shmcheckpoint > 3)
{
shmdt(g_xshminfo.shmaddr);
}
if (g_shmcheckpoint > 2)
{
shmctl(g_xshminfo.shmid, IPC_RMID, 0);
}
#endif
if (g_shmcheckpoint > 1)
{
XDestroyImage(g_image);
}
/* Un-grab the mouse buttons */
#ifdef CONFIG_SIM_TOUCHSCREEN
XUngrabButton(g_display, Button1, AnyModifier, g_window);
#endif
g_x11initialized = 0;
}
XCloseDisplay(g_display);
}
/* grab required keys */
static void ungrab_key(HotkeyConfiguration *hotkey, Display* xdisplay, Window x_root_window)
{
unsigned int modifier = hotkey->mask & ~(numlock_mask | capslock_mask | scrolllock_mask);
if (hotkey->key == 0) return;
if (hotkey->type == TYPE_KEY)
{
XUngrabKey (xdisplay, hotkey->key, modifier, x_root_window);
if (modifier == AnyModifier)
return;
if (numlock_mask)
XUngrabKey (xdisplay, hotkey->key, modifier | numlock_mask, x_root_window);
if (capslock_mask)
XUngrabKey (xdisplay, hotkey->key, modifier | capslock_mask, x_root_window);
if (scrolllock_mask)
XUngrabKey (xdisplay, hotkey->key, modifier | scrolllock_mask, x_root_window);
if (numlock_mask && capslock_mask)
XUngrabKey (xdisplay, hotkey->key, modifier | numlock_mask | capslock_mask, x_root_window);
if (numlock_mask && scrolllock_mask)
XUngrabKey (xdisplay, hotkey->key, modifier | numlock_mask | scrolllock_mask, x_root_window);
if (capslock_mask && scrolllock_mask)
XUngrabKey (xdisplay, hotkey->key, modifier | capslock_mask | scrolllock_mask, x_root_window);
if (numlock_mask && capslock_mask && scrolllock_mask)
XUngrabKey (xdisplay, hotkey->key, modifier | numlock_mask | capslock_mask | scrolllock_mask, x_root_window);
}
if (hotkey->type == TYPE_MOUSE)
{
XUngrabButton (xdisplay, hotkey->key, modifier, x_root_window);
if (modifier == AnyModifier)
return;
if (numlock_mask)
XUngrabButton (xdisplay, hotkey->key, modifier | numlock_mask, x_root_window);
if (capslock_mask)
XUngrabButton (xdisplay, hotkey->key, modifier | capslock_mask, x_root_window);
if (scrolllock_mask)
XUngrabButton (xdisplay, hotkey->key, modifier | scrolllock_mask, x_root_window);
if (numlock_mask && capslock_mask)
XUngrabButton (xdisplay, hotkey->key, modifier | numlock_mask | capslock_mask, x_root_window);
if (numlock_mask && scrolllock_mask)
XUngrabButton (xdisplay, hotkey->key, modifier | numlock_mask | scrolllock_mask, x_root_window);
if (capslock_mask && scrolllock_mask)
XUngrabButton (xdisplay, hotkey->key, modifier | capslock_mask | scrolllock_mask, x_root_window);
if (numlock_mask && capslock_mask && scrolllock_mask)
XUngrabButton (xdisplay, hotkey->key, modifier | numlock_mask | capslock_mask | scrolllock_mask, x_root_window);
}
}
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;
}
}
