void AccessTabActive()
{
int nhosts, i;
Bool access_enabled;
XHostAddress *xhosts;
struct hostent *hp;
struct in_addr in;
XtManageChild( access_frame );
if( info_dpy == NULL ) return;
XmTextClear( access_out );
SetStatus( "Retrieving host access list..." );
SetWidgetCursor( tab_form, XC_watch );
/* get the access control list */
xhosts = XListHosts( info_dpy, &nhosts, &access_enabled );
if( access_enabled == TRUE && nhosts > 0 ) {
for( i=0; i<nhosts; i++ ) {
/* need to output the net number if the hostname is not found */
hp = gethostbyaddr( xhosts[i].address, xhosts[i].length, AF_INET );
if( !hp->h_name )
memcpy( &in.s_addr, hp->h_addr_list[0], sizeof(in.s_addr) );
XmTextPrintf( access_out, "%s %s\n",
hp->h_name ? hp->h_name : inet_ntoa(in),
Lookup(xhosts[i].family, _family_types) );
}
}
else if( access_enabled == TRUE && nhosts == 0 )
XmTextAppend( access_out, "\n-- No hosts in access list! --\n" );
else /* access_enabled == FALSE <all host can connect to display> */
XmTextSetString( access_out,
"Access control disabled, all hosts welcome.\n" );
UnsetWidgetCursor( tab_form );
ClearStatus();
XFree(xhosts);
}
int main(int argc, char **argv)
{
char *consoletty, *p;
char **dmargv, **xargv, **consoleargv = NULL, **loginargv;
char xpidf[256], line[16], buf[256];
fd_set readfds;
int pgrp, file, tries, count, redir = TRUE;
char dpyacl[40];
Display *dpy;
XHostAddress *hosts, localhost;
int nhosts, dpynum = 0;
struct stat hostsinfo;
Bool state;
time_t now, last_console_failure = 0;
struct sigaction sigact;
sigset_t mask;
#if defined(SRIOCSREDIR) || defined(TIOCCONS)
int on;
#endif
int fd;
int conspipe[2];
XIOErrorHandler xioerror_handler;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
(void) sigemptyset(&sig_zero);
/* Create a localhost entity for access control purposes. */
localhost.family = FamilyLocalHost;
localhost.length = 0;
localhost.address = "";
/*
* Note about setting environment variables in dm:
*
* All environment variables passed to dm and set in dm are
* subsequently passed to any children of dm. This is usually
* true of processes that exec in children, so that's not a
* big surprise.
*
* However, xlogin is one of the children dm forks, and it goes
* to lengths to ensure that the environments of users logging in
* are ISOLATED from xlogin's own environment. Therefore, do not
* expect that setting an environment variable here will reach the
* user unless you have gone to lengths to make sure that xlogin
* passes it on. Put another way, if you set a new environment
* variable here, consider whether or not it should be seen by the
* user. If it should, go modify verify.c as well. Consider also
* whether the variable should be seen _only_ by the user. If so,
* make the change only in xlogin, and not here.
*
* As an added complication, xlogin _does_ pass environment variables
* on to the pre-login options. Therefore, if you set an environment
* variable that should _not_ be seen, you must filter it in xlogin.c.
*
* Confused? Too bad. I'm in a nasty, if verbose, mood this year.
*
* General summary:
*
* If you add an environment variable here there are three likely
* possibilities:
*
* 1. It's for the user only, not needed by any of dm's children.
* --> Don't set it here. Set it in verify.c for users and in
* --> xlogin.c for the pre-login options, if appropriate.
*
* 2. It's for dm and its children only, and _should not_ be seen
* by the user or pre-login options.
* --> You must filter the option from the pre-login options
* --> in xlogin.c. No changes to verify.c are required.
*
* 3. It's for dm and the user and the pre-login options.
* --> You must pass the option explicitly to the user in
* --> verify.c. No changes to xlogin.c are required.
*
* --- cfields
*/
#ifdef notdef
putenv("LD_LIBRARY_PATH=/usr/openwin/lib");
putenv("OPENWINHOME=/usr/openwin");
#endif
if (argc < 2)
{
fprintf(stderr, "dm: first argument must be configuration file\n");
sleep(60);
exit(1);
}
conf = argv[1];
if (argc != 4 && (argc != 5 || strcmp(argv[3], "-noconsole")))
{
fprintf(stderr,
"usage: %s configfile logintty [-noconsole] consoletty\n",
argv[0]);
console_login(conf, NULL);
}
if (argc == 5)
redir = FALSE;
/* parse argument lists */
/* ignore argv[2] */
consoletty = argv[argc - 1];
#ifdef SOLARIS
/* On Solaris, use the console tty name for the utmp line field,
* as the Solaris finger requires an actual device name there.
* Elsewhere, we will use the display name (see below).
*/
utmp_line = consoletty;
#endif
openlog("dm", 0, LOG_USER);
/* We use options from the config file rather than taking
* them from the command line because the current command
* line form is gross (why???), and I don't see a good way
* to extend it without making things grosser or breaking
* backwards compatibility. So, we take a line from the
* config file and use real parsing.
*/
p = getconf(conf, "dm");
if (p != NULL)
{
dmargv = parseargs(p, NULL, NULL, NULL);
while (*dmargv)
{
if (!strcmp(*dmargv, "-display"))
{
dmargv++;
if (*dmargv)
{
dpynum = atoi(*(dmargv) + 1);
dmargv++;
}
}
else
dmargv++;
}
}
p = getconf(conf, "X");
if (p == NULL)
console_login(conf, "\ndm: Can't find X command line\n");
xargv = parseargs(p, NULL, NULL, NULL);
p = getconf(conf, "console");
if (p == NULL)
console_login(conf, "\ndm: Can't find console command line\n");
/* We will pass the read side of the pipe created below to console
* on descriptor 3.
*/
consoleargv = parseargs(p, "-inputfd", "3", NULL);
/* Signal Setup */
sigact.sa_handler = SIG_IGN;
sigaction(SIGTSTP, &sigact, NULL);
sigaction(SIGTTIN, &sigact, NULL);
sigaction(SIGTTOU, &sigact, NULL);
/* so that X pipe errors don't nuke us */
sigaction(SIGPIPE, &sigact, NULL);
sigact.sa_handler = shutdown;
sigaction(SIGFPE, &sigact, NULL);
sigact.sa_handler = die;
sigaction(SIGHUP, &sigact, NULL);
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
sigact.sa_handler = child;
sigaction(SIGCHLD, &sigact, NULL);
sigact.sa_handler = catchalarm;
sigaction(SIGALRM, &sigact, NULL);
strcpy(line, "/dev/");
strcat(line, consoletty);
fd = open(line, O_RDWR);
if (fd == -1)
{
syslog(LOG_ERR, "Cannot open %s: %m", line);
/* This probably won't work, but it seems to be the appropriate
punt location. */
console_login(conf, "Cannot open tty.\n");
}
if (login_tty(fd) == -1)
syslog(LOG_ERR, "Cannot set the console as a login terminal (%s)",
strerror(errno));
else
{
/* Set the console characteristics so we don't lose later */
setpgid(0, pgrp = getpid()); /* Reset the tty pgrp */
if (tcsetpgrp(0, pgrp) == -1)
syslog(LOG_ERR, "tcsetpgrp failed for console terminal (%s)",
strerror(errno));
}
/* save our pid file */
writepid(dmpidf, getpid());
/* Fire up X */
xpid = 0;
for (tries = 0; tries < 3; tries++)
{
syslog(LOG_DEBUG, "Starting X, try #%d", tries + 1);
x_running = STARTUP;
sigact.sa_handler = xready;
sigaction(SIGUSR1, &sigact, NULL);
switch (fork_and_store(&xpid))
{
case 0:
if (fcntl(2, F_SETFD, 1) == -1)
close(2);
(void) sigprocmask(SIG_SETMASK, &sig_zero, (sigset_t *) 0);
/* ignoring SIGUSR1 will cause the server to send us a SIGUSR1
* when it is ready to accept connections
*/
sigact.sa_handler = SIG_IGN;
sigaction(SIGUSR1, &sigact, NULL);
p = *xargv;
*xargv = "X";
execv(p, xargv);
fprintf(stderr, "dm: X server failed exec: %s\n", strerror(errno));
_exit(1);
case -1:
fprintf(stderr, "dm: Unable to fork to start X server: %s\n",
strerror(errno));
break;
default:
sprintf(xpidf, xpids, dpynum);
writepid(xpidf, xpid);
if (x_running == STARTUP)
{
alarm(X_START_WAIT);
alarm_running = RUNNING;
sigsuspend(&sig_zero);
}
if (x_running != RUNNING)
{
syslog(LOG_DEBUG, "X failed to start; alarm_running=%d",
alarm_running);
if (alarm_running == NONEXISTENT)
fprintf(stderr, "dm: Unable to start X\n");
else
fprintf(stderr, "dm: X failed to become ready\n");
/* If X wouldn't run, it could be that an existing X
* process hasn't shut down. Wait X_STOP_WAIT seconds
* for that to happen.
*/
x_stop_wait();
}
sigact.sa_handler = SIG_IGN;
sigaction(SIGUSR1, &sigact, NULL);
}
if (x_running == RUNNING)
break;
}
alarm(0);
if (x_running != RUNNING)
{
syslog(LOG_DEBUG, "Giving up on starting X.");
console_login(conf, "\nUnable to start X, doing console login "
"instead.\n");
}
/* Tighten up security a little bit. Remove all hosts from X's
* access control list, assuming /etc/X0.hosts does not exist or
* has zero length. If it does exist with nonzero length, this
* behavior is not wanted. The desired effect of removing all hosts
* is that only connections from the Unix domain socket will be
* allowed.
* More secure code using Xau also exists, but there wasn't
* time to completely flesh it out and resolve a couple of
* issues. This code is probably good enough, but we'll see.
* Maybe next time.
* This code has the added benefit of leaving an X display
* connection open, owned by dm. This provides a less-hacky
* solution to the config_console problem, where if config_console
* is the first program run on user login, it causes the only
* X app running at the time, console, to exit, thus resetting
* the X server. Thus this code also allows the removal of the
* hack in xlogin that attempts to solve the same problem, but
* fails on the RS/6000 for reasons unexplored.
* P.S. Don't run this code under Solaris 2.2- (2.3 is safe).
* Removing all hosts from the acl on that server results in
* no connections, not even from the Unix domain socket, being
* allowed. --- cfields
*/
sprintf(dpyacl, xhosts, dpynum);
sprintf(dpyname, ":%d", dpynum);
#ifndef SOLARIS
/* Use the display name for the utmp line field, except on Solaris. */
utmp_line = dpyname;
#endif
/* Put in our own error handler, open the display, then reset the handler. */
xioerror_handler = XSetIOErrorHandler(handle_xioerror);
dpy = XOpenDisplay(dpyname);
XSetIOErrorHandler(xioerror_handler);
if (dpy != NULL && (stat(dpyacl, &hostsinfo) || hostsinfo.st_size == 0))
{
hosts = XListHosts(dpy, &nhosts, &state);
if (hosts != NULL)
{
XRemoveHosts(dpy, hosts, nhosts);
XFree(hosts);
}
XAddHost(dpy, &localhost);
XFlush(dpy);
}
/* else if (dpy == NULL)
* Could've sworn the X server was running now.
* Follow the original code path. No need introducing new bugs
* to this hairy code, just preserve the old behavior as though
* this code had never been added.
*/
/* set up the console pty */
if (openpty(&console_master_fd, &console_slave_fd, NULL, NULL, NULL) == -1)
console_login(conf, "Cannot allocate pseudo-terminal\n");
if (redir)
{
/* Redirect /dev/console output to the pty slave. */
#ifdef SRIOCSREDIR
on = open("/dev/console", O_RDONLY);
if (on >= 0)
{
ioctl(on, SRIOCSREDIR, console_slave_fd);
close(on);
}
#else
#ifdef TIOCCONS
on = 1;
ioctl(console_slave_fd, TIOCCONS, &on);
#endif
#endif
}
/* Set up the console pipe. */
if (pipe(conspipe) == -1)
console_login(conf, "Cannot create pipe for console\n");
/* start up console */
start_console(console_master_fd, conspipe[0], consoleargv);
/* Set up to invoke xlogin. */
p = getconf(conf, "login");
if (p == NULL)
console_login(conf, "\ndm: Can't find login command line\n");
loginargv = parseargs(p, "-line", utmp_line, NULL);
/* Fire up the X login */
for (tries = 0; tries < 3; tries++)
{
syslog(LOG_DEBUG, "Starting xlogin, try #%d", tries + 1);
login_running = STARTUP;
sigact.sa_handler = loginready;
sigaction(SIGUSR1, &sigact, NULL);
switch (fork_and_store(&loginpid))
{
case 0:
max_fd = sysconf(_SC_OPEN_MAX);
for (file = 3; file < max_fd; file++)
{
if (file != conspipe[1])
close(file);
}
setsid();
file = open("/dev/null", O_RDONLY);
if (file >= 0)
{
dup2(file, 0);
if (file != 0)
close(file);
}
file = conspipe[1];
if (file == -1)
file = open("/dev/null", O_WRONLY);
if (file >= 0)
{
if (file != 1)
dup2(file, 1);
if (file != 2)
dup2(file, 2);
if (file != 1 && file != 2)
close(file);
}
(void) sigprocmask(SIG_SETMASK, &sig_zero, (sigset_t *) 0);
/* ignoring SIGUSR1 will cause xlogin to send us a SIGUSR1
* when it is ready
*/
sigact.sa_handler = SIG_IGN;
sigaction(SIGUSR1, &sigact, NULL);
/* dm ignores sigpipe; because of this, all of the children (ie, */
/* the entire session) inherit this unless we fix it now */
sigact.sa_handler = SIG_DFL;
sigaction(SIGPIPE, &sigact, NULL);
execv(loginargv[0], loginargv);
fprintf(stderr, "dm: X login failed exec: %s\n", strerror(errno));
_exit(1);
case -1:
fprintf(stderr, "dm: Unable to fork to start X login: %s\n",
strerror(errno));
break;
default:
alarm(LOGIN_START_WAIT);
alarm_running = RUNNING;
while (login_running == STARTUP && alarm_running == RUNNING)
sigsuspend(&sig_zero);
if (login_running != RUNNING)
{
syslog(LOG_DEBUG, "xlogin failed to start; alarm_running=%d",
alarm_running);
kill(loginpid, SIGKILL);
if (alarm_running != NONEXISTENT)
fprintf(stderr, "dm: Unable to start Xlogin\n");
else
fprintf(stderr, "dm: Xlogin failed to become ready\n");
}
}
if (login_running == RUNNING)
break;
}
sigact.sa_handler = SIG_IGN;
sigaction(SIGUSR1, &sigact, NULL);
alarm(0);
if (login_running != RUNNING)
{
syslog(LOG_DEBUG, "Giving up on starting xlogin.");
console_login(conf, "\nUnable to start xlogin, doing console login "
"instead.\n");
}
/* main loop. Wait for SIGCHLD, waking up every minute anyway. */
(void) sigemptyset(&sig_cur);
(void) sigaddset(&sig_cur, SIGCHLD);
(void) sigprocmask(SIG_BLOCK, &sig_cur, NULL);
while (1)
{
/* Wait for something to hapen */
if (console_failed)
{
/* if no console is running, we must copy bits from the console
* (master side of pty) to the real console to appear as black
* bar messages.
*/
FD_ZERO(&readfds);
FD_SET(console_master_fd, &readfds);
(void) sigprocmask(SIG_SETMASK, &sig_zero, &mask);
count = select(console_master_fd + 1, &readfds, NULL, NULL, NULL);
(void) sigprocmask(SIG_BLOCK, &mask, NULL);
if (count > 0 && FD_ISSET(console_master_fd, &readfds))
{
file = read(console_master_fd, buf, sizeof(buf));
if (file != -1)
write(1, buf, file);
}
}
else
{
alarm(60);
sigsuspend(&sig_zero);
}
if (login_running == STARTUP)
{
(void) sigprocmask(SIG_SETMASK, &sig_zero, NULL);
console_login(conf, "\nConsole login requested.\n");
}
if (console_running == FAILED)
{
console_running = NONEXISTENT;
time(&now);
if (now - last_console_failure <= 3)
{
/* Give up on console. Set the console characteristics so
* we don't lose later. */
syslog(LOG_ERR, "Giving up on the console");
setpgid(0, pgrp = getpid()); /* Reset the tty pgrp */
tcsetpgrp(0, pgrp);
console_failed = TRUE;
}
else
last_console_failure = now;
}
if (console_running == NONEXISTENT && !console_failed)
start_console(console_master_fd, conspipe[0], consoleargv);
if (login_running == NONEXISTENT || x_running == NONEXISTENT)
{
syslog(LOG_DEBUG, "login_running=%d, x_running=%d, quitting",
login_running, x_running);
(void) sigprocmask(SIG_SETMASK, &sig_zero, NULL);
cleanup(utmp_line);
_exit(0);
}
}
}
int
main(int argc, char *argv[])
{
register char *arg;
int i, nhosts = 0;
char *hostname;
int nfailed = 0;
XHostAddress *list;
Bool enabled = False;
#ifdef DNETCONN
char *dnet_htoa();
struct nodeent *np;
struct dn_naddr *nlist, dnaddr, *dnaddrp, *dnet_addr();
char *cp;
#endif
ProgramName = argv[0];
if ((dpy = XOpenDisplay(NULL)) == NULL) {
fprintf(stderr, "%s: unable to open display \"%s\"\n",
ProgramName, XDisplayName (NULL));
exit(1);
}
XSetErrorHandler(local_xerror);
if (argc == 1) {
#ifdef DNETCONN
setnodeent(1); /* keep the database accessed */
#endif
sethostent(1); /* don't close the data base each time */
list = XListHosts(dpy, &nhosts, &enabled);
if (enabled)
printf ("access control enabled, only authorized clients can connect\n");
else
printf ("access control disabled, clients can connect from any host\n");
if (nhosts != 0) {
for (i = 0; i < nhosts; i++ ) {
hostname = get_hostname(&list[i]);
if (hostname) {
switch (list[i].family) {
case FamilyInternet:
printf("INET:");
break;
case FamilyInternet6:
printf("INET6:");
break;
case FamilyDECnet:
printf("DNET:");
break;
case FamilyNetname:
printf("NIS:");
break;
case FamilyKrb5Principal:
printf("KRB:");
break;
case FamilyLocalHost:
printf("LOCAL:");
break;
}
printf ("%s", hostname);
} else {
printf ("<unknown address in family %d>",
list[i].family);
}
if (nameserver_timedout) {
printf("\t(no nameserver response within %d seconds)\n",
NAMESERVER_TIMEOUT);
nameserver_timedout = 0;
} else
printf("\n");
}
free(list);
endhostent();
}
exit(0);
}
if (argc == 2 && !strcmp(argv[1], "-help")) {
fprintf(stderr, "usage: %s [[+-]hostname ...]\n", argv[0]);
exit(1);
}
for (i = 1; i < argc; i++) {
arg = argv[i];
if (*arg == '-') {
if (!argv[i][1] && ((i+1) == argc)) {
printf ("access control enabled, only authorized clients can connect\n");
XEnableAccessControl(dpy);
} else {
arg = argv[i][1]? &argv[i][1] : argv[++i];
if (!change_host (dpy, arg, False)) {
fprintf (stderr, "%s: bad hostname \"%s\"\n",
ProgramName, arg);
nfailed++;
}
}
} else {
if (*arg == '+' && !argv[i][1] && ((i+1) == argc)) {
printf ("access control disabled, clients can connect from any host\n");
XDisableAccessControl(dpy);
} else {
if (*arg == '+') {
arg = argv[i][1]? &argv[i][1] : argv[++i];
}
if (!change_host (dpy, arg, True)) {
fprintf (stderr, "%s: bad hostname \"%s\"\n",
ProgramName, arg);
nfailed++;
}
}
}
}
XCloseDisplay (dpy); /* does an XSync first */
exit(nfailed);
}
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;
}
}
