gtk/gdk/gxid.c
Owen Taylor 4851efe296 configure.in acheader.h gdk/gdkwindow.c Check for Shape extension both on
Sun May  3 13:38:22 1998  Owen Taylor  <otaylor@gtk.org>

	* configure.in acheader.h gdk/gdkwindow.c
	Check for Shape extension both on the client and server
	side. (And, more importantly, check for the shape extension
	so we may include -lXext even when compiling with --disable-xshm)

	Don't set override_redirect on all shaped windows. It isn't
	necessary.

	* gdk/gdkwindow.c: Set ->colormap to NULL for root
	and foreign windows. Use this to check if we
	need to get the colormap from X.

Fri May  1 22:32:47 1998  Owen Taylor  <otaylor@gtk.org>

	* gtk/gtkbutton.c (gtk_button_paint): Draw the areas
	between the default and the button always in GTK_STATE_NORMAL.

	* gtk/gtkrange.c (gtk_range_style_set): Added a style_set
	callback.

Fri May  1 16:40:57 1998  Owen Taylor  <otaylor@gtk.org>

	* gdk/gdkpixmap.c (gdk_pixmap_colormap_create_from_xpmp[_d]):
	  Fix a buffer overflow on pixmaps that claim to have
	  more than 31 characters per pixel.

	  (gdk_pixmap_read_string): Don't wrap around strings longer
 	  than half of address space ;-)

	* gtk/gtk[vh]ruler.c gtk/gtkinputdialog.c: Expand some buffers
	that were used for printing integers.

	* */* (almost):

	Style: All
	  int foo () { ... }
	changed to
	  int foo (void) { ... }

^^^^^^^ This is why some many files changed

	Even where there were proper prototypes elsewhere.

	* gdk/gxid.c (handle_claim_device): Some extra checks.
	It isn't safe against being fed bad X id's, but at
	least it should be safe against deleting all your
	files.
1998-05-03 22:41:32 +00:00

864 lines
18 KiB
C

/*
* gxid version 0.3
*
* Copyright 1997 Owen Taylor <owt1@cornell.edu>
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <X11/Xlib.h>
#include <X11/extensions/XInput.h>
#include "gxid_proto.h"
/* #define DEBUG_CLIENTS */
/* #define DEBUG_EVENTS */
char *program_name;
Display *dpy;
Window root_window; /* default root window of dpy */
int port = 0; /* port to listen on */
int socket_fd = 0; /* file descriptor of socket */
typedef struct GxidWindow_ GxidWindow;
typedef struct GxidDevice_ GxidDevice;
struct GxidDevice_ {
XID id;
int exclusive;
int ispointer;
XDevice *xdevice;
int motionnotify_type;
int changenotify_type;
};
struct GxidWindow_ {
Window xwindow;
/* Immediate child of root that is ancestor of window */
Window root_child;
int num_devices;
GxidDevice **devices;
};
GxidDevice **devices = NULL;
int num_devices = 0;
GxidWindow **windows = NULL;
int num_windows = 0;
void
handler(int signal)
{
fprintf(stderr,"%s: dying on signal %d\n",program_name,signal);
if (socket_fd)
close(socket_fd);
exit(1);
}
void
init_socket(void)
{
struct sockaddr_in sin;
socket_fd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if (socket_fd < 0)
{
fprintf (stderr, "%s: error getting socket\n",
program_name);
exit(1);
}
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
sin.sin_addr.s_addr = INADDR_ANY;
if (bind(socket_fd,(struct sockaddr *)(&sin),
sizeof(struct sockaddr_in)) < 0)
{
fprintf (stderr,"%s: cannot bind to port %d\n",
program_name,port);
exit(1);
}
if (listen(socket_fd,5) < 0)
{
fprintf (stderr,"%s: error listening on socket\n",
program_name);
exit(1);
};
}
#define NUM_EVENTC 2
static void
enable_device(GxidDevice *dev)
{
XEventClass xevc[NUM_EVENTC];
int num_eventc = NUM_EVENTC;
int i,j;
if (!dev->xdevice)
{
if (dev->ispointer) return;
dev->xdevice = XOpenDevice(dpy, dev->id);
if (!dev->xdevice) return;
DeviceMotionNotify (dev->xdevice, dev->motionnotify_type,
xevc[0]);
ChangeDeviceNotify (dev->xdevice, dev->changenotify_type,
xevc[1]);
/* compress out zero event classes */
for (i=0,j=0;i<NUM_EVENTC;i++)
{
if (xevc[i]) {
xevc[j] = xevc[i];
j++;
}
}
num_eventc = j;
XSelectExtensionEvent (dpy, root_window, xevc, num_eventc);
}
}
/* switch the core pointer from whatever it is now to something else,
return true on success, false otherwise */
static int
switch_core_pointer(void)
{
GxidDevice *old_pointer = 0;
GxidDevice *new_pointer = 0;
int result;
int i;
for (i=0;i<num_devices;i++)
{
if (devices[i]->ispointer)
old_pointer = devices[i];
else
if (!new_pointer && !devices[i]->exclusive)
new_pointer = devices[i];
}
if (!old_pointer || !new_pointer)
return 0;
#ifdef DEBUG_EVENTS
fprintf(stderr,"gxid: Switching core from %ld to %ld\n",
old_pointer->id,new_pointer->id);
#endif
result = XChangePointerDevice(dpy,new_pointer->xdevice, 0, 1);
if (result != Success)
{
fprintf(stderr,"gxid: Error %d switching core from %ld to %ld\n",
result, old_pointer->id, new_pointer->id);
}
else
{
new_pointer->ispointer = 1;
old_pointer->ispointer = 0;
if (!old_pointer->xdevice)
enable_device(old_pointer);
}
return 1;
}
void
disable_device(GxidDevice *dev)
{
if (dev->xdevice)
{
if (dev->ispointer)
return;
XCloseDevice(dpy,dev->xdevice);
dev->xdevice = 0;
}
}
GxidDevice *
init_device(XDeviceInfo *xdevice)
{
GxidDevice *dev = (GxidDevice *)malloc(sizeof(GxidDevice));
XAnyClassPtr class;
int num_axes, i;
dev->id = xdevice->id;
dev->exclusive = 0;
dev->xdevice = NULL;
dev->ispointer = (xdevice->use == IsXPointer);
/* step through the classes */
num_axes = 0;
class = xdevice->inputclassinfo;
for (i=0;i<xdevice->num_classes;i++)
{
if (class->class == ValuatorClass)
{
XValuatorInfo *xvi = (XValuatorInfo *)class;
num_axes = xvi->num_axes;
}
class = (XAnyClassPtr)(((char *)class) + class->length);
}
/* return NULL if insufficient axes */
if (num_axes < 2)
{
free((void *)dev);
return NULL;
}
if (!dev->ispointer)
enable_device(dev);
return dev;
}
void
init_xinput(void)
{
char **extensions;
XDeviceInfo *xdevices;
int num_xdevices;
int num_extensions;
int i;
extensions = XListExtensions(dpy, &num_extensions);
for (i = 0; i < num_extensions &&
(strcmp(extensions[i], "XInputExtension") != 0); i++);
XFreeExtensionList(extensions);
if (i == num_extensions) /* XInput extension not found */
{
fprintf(stderr,"XInput extension not found\n");
exit(1);
}
xdevices = XListInputDevices(dpy, &num_xdevices);
devices = (GxidDevice **)malloc(num_xdevices * sizeof(GxidDevice *));
num_devices = 0;
for(i=0; i<num_xdevices; i++)
{
GxidDevice *dev = init_device(&xdevices[i]);
if (dev)
devices[num_devices++] = dev;
}
XFreeDeviceList(xdevices);
}
/* If this routine needs fixing, the corresponding routine
in gdkinputgxi.h will need it too. */
Window
gxi_find_root_child(Display *dpy, Window w)
{
Window root,parent;
Window *children;
int nchildren;
parent = w;
do
{
w = parent;
XQueryTree(dpy,w,&root,&parent,&children,&nchildren);
if (children) XFree(children);
}
while (parent != root);
return w;
}
int
handle_claim_device(GxidClaimDevice *msg)
{
int i,j;
XID devid;
XID winid;
int exclusive;
GxidDevice *device = NULL;
GxidWindow *window = NULL;
if (msg->length != sizeof(GxidClaimDevice))
{
fprintf(stderr,"Bad length for ClaimDevice message\n");
return GXID_RETURN_ERROR;
}
devid = ntohl(msg->device);
winid = ntohl(msg->window);
exclusive = ntohl(msg->exclusive);
#ifdef DEBUG_CLIENTS
fprintf(stderr,"device %ld claimed (window 0x%lx)\n",devid,winid);
#endif
for (i=0;i<num_devices;i++)
{
if (devices[i]->id == devid)
{
device = devices[i];
break;
}
}
if (!device)
{
fprintf(stderr,"%s: Unknown device id %ld\n",program_name,devid);
return GXID_RETURN_ERROR;
}
if (device->exclusive)
{
/* already in use */
fprintf(stderr,
"%s: Device %ld already claimed in exclusive mode\n",
program_name,devid);
return GXID_RETURN_ERROR;
}
if (exclusive)
{
for (i=0;i<num_windows;i++)
{
for (j=0;j<windows[i]->num_devices;j++)
if (windows[i]->devices[j]->id == devid)
{
/* already in use */
fprintf(stderr,
"%s: Can't establish exclusive use of device %ld\n",
program_name,devid);
return GXID_RETURN_ERROR;
}
}
if (device->ispointer)
if (!switch_core_pointer())
{
fprintf(stderr,
"%s: Can't free up core pointer %ld\n",
program_name,devid);
return GXID_RETURN_ERROR;
}
device->exclusive = 1;
disable_device(device);
XSelectInput(dpy,winid,StructureNotifyMask);
}
else /* !exclusive */
{
/* FIXME: this is a bit improper. We probably should do this only
when a window is first claimed. But we might be fooled if
an old client died without releasing it's windows. So until
we look for client-window closings, do it here
(We do look for closings now...)
*/
XSelectInput(dpy,winid,EnterWindowMask|StructureNotifyMask);
}
for (i=0;i<num_windows;i++)
{
if (windows[i]->xwindow == winid)
{
window = windows[i];
break;
}
}
/* Create window structure if no devices have been previously
claimed on it */
if (!window)
{
num_windows++;
windows = (GxidWindow **)realloc(windows,
sizeof(GxidWindow*)*num_windows);
window = (GxidWindow *)malloc(sizeof(GxidWindow));
windows[num_windows-1] = window;
window->xwindow = winid;
window->root_child = gxi_find_root_child(dpy,winid);
window->num_devices = 0;
window->devices = 0;
}
for (i=0;i<window->num_devices;i++)
{
if (window->devices[i] == device)
return GXID_RETURN_OK;
}
window->num_devices++;
window->devices = (GxidDevice **)realloc(window->devices,
sizeof(GxidDevice*)*num_devices);
/* we need add the device to the window */
window->devices[i] = device;
return GXID_RETURN_OK;
}
int
handle_release_device(GxidReleaseDevice *msg)
{
int i,j;
XID devid;
XID winid;
GxidDevice *device = NULL;
if (msg->length != sizeof(GxidReleaseDevice))
{
fprintf(stderr,"Bad length for ReleaseDevice message\n");
return GXID_RETURN_ERROR;
}
devid = ntohl(msg->device);
winid = ntohl(msg->window);
#ifdef DEBUG_CLIENTS
fprintf(stderr,"device %ld released (window 0x%lx)\n",devid,winid);
#endif
for (i=0;i<num_devices;i++)
{
if (devices[i]->id == devid)
{
device = devices[i];
break;
}
}
if (!device)
{
fprintf(stderr,"%s: Unknown device id %ld\n",program_name,devid);
return GXID_RETURN_ERROR;
}
for (i=0;i<num_windows;i++)
{
GxidWindow *w = windows[i];
if (w->xwindow == winid)
for (j=0;j<w->num_devices;j++)
if (w->devices[j]->id == devid)
{
if (j<w->num_devices-1)
w->devices[j] = w->devices[w->num_devices-1];
w->num_devices--;
if (w->num_devices == 0)
{
if (i<num_windows-1)
windows[i] = windows[num_windows-1];
num_windows--;
free((void *)w);
/* FIXME: should we deselect input? But what
what if window is already destroyed */
}
if (device->exclusive)
{
device->exclusive = 0;
enable_device(device);
}
return GXID_RETURN_OK;
}
}
/* device/window combination not found */
fprintf(stderr,
"%s: Device %ld not claimed for window 0x%lx\n",
program_name,devid,winid);
return GXID_RETURN_ERROR;
}
void
handle_connection (void)
{
GxidMessage msg;
GxidU32 type;
GxidU32 length;
GxidI32 retval;
int conn_fd;
struct sockaddr_in sin;
int sin_length;
int count;
sin_length = sizeof(struct sockaddr_in);
conn_fd = accept(socket_fd,(struct sockaddr *)&sin,&sin_length);
if (conn_fd < 0)
{
fprintf(stderr,"%s: Error accepting connection\n",
program_name);
exit(1);
}
/* read type and length of message */
count = read(conn_fd,(char *)&msg,2*sizeof(GxidU32));
if (count != 2*sizeof(GxidU32))
{
fprintf(stderr,"%s: Error reading message header\n",
program_name);
close(conn_fd);
return;
}
type = ntohl(msg.any.type);
length = ntohl(msg.any.length);
/* read rest of message */
if ((length > sizeof(GxidMessage)) || (length < 2*sizeof(GxidU32)))
{
fprintf(stderr,"%s: Bad message length\n",
program_name);
close(conn_fd);
return;
}
count = read(conn_fd,2*sizeof(GxidU32) + (char *)&msg,
length - 2*sizeof(GxidU32));
if (count != length - 2*sizeof(GxidU32))
{
fprintf(stderr,"%s: Error reading message body\n",
program_name);
close(conn_fd);
return;
}
switch (type)
{
case GXID_CLAIM_DEVICE:
retval = handle_claim_device((GxidClaimDevice *)&msg);
break;
case GXID_RELEASE_DEVICE:
retval = handle_release_device((GxidReleaseDevice *)&msg);
break;
default:
fprintf(stderr,"%s: Unknown message type: %ld (ignoring)\n",
program_name,type);
close(conn_fd);
return;
}
count = write(conn_fd,&retval,sizeof(GxidI32));
if (count != sizeof(GxidI32))
{
fprintf(stderr,"%s: Error writing return code\n",
program_name);
}
close(conn_fd);
}
void
handle_motion_notify(XDeviceMotionEvent *event)
{
int i,j;
GxidDevice *old_device = NULL;
GxidDevice *new_device = NULL;
Window w, root, child;
int root_x, root_y, x, y, mask;
for (j=0;j<num_devices;j++)
{
if (devices[j]->ispointer)
old_device = devices[j];
if (devices[j]->id == event->deviceid)
new_device = devices[j];
}
if (new_device && !new_device->exclusive && !new_device->ispointer)
{
/* make sure we aren't stealing the pointer back from a slow
client */
child = root_window;
do
{
w = child;
/* FIXME: this fails disasterously if child vanishes between
calls. (Which is prone to happening since we get events
on root just as the client exits) */
XQueryPointer(dpy,w,&root,&child,&root_x,&root_y,
&x,&y,&mask);
}
while (child != None);
for (i=0;i<num_windows;i++)
if (windows[i]->xwindow == w)
for (j=0;j<windows[i]->num_devices;j++)
if (windows[i]->devices[j] == new_device)
return;
/* FIXME: do something smarter with axes */
XChangePointerDevice(dpy,new_device->xdevice, 0, 1);
new_device->ispointer = 1;
old_device->ispointer = 0;
if (!old_device->xdevice)
enable_device(old_device);
}
}
void
handle_change_notify(XChangeDeviceNotifyEvent *event)
{
int j;
GxidDevice *old_device = NULL;
GxidDevice *new_device = NULL;
for (j=0;j<num_devices;j++)
{
if (devices[j]->ispointer)
old_device = devices[j];
if (devices[j]->id == event->deviceid)
new_device = devices[j];
}
#ifdef DEBUG_EVENTS
fprintf(stderr,"gxid: ChangeNotify event; old = %ld; new = %ld\n",
old_device->id, new_device->id);
#endif
if (old_device != new_device)
{
new_device->ispointer = 1;
old_device->ispointer = 0;
if (!old_device->xdevice)
enable_device(old_device);
}
}
void
handle_enter_notify(XEnterWindowEvent *event, GxidWindow *window)
{
int i;
GxidDevice *old_pointer = NULL;
for (i=0;i<num_devices;i++)
{
if (devices[i]->ispointer)
{
old_pointer = devices[i];
break;
}
}
#ifdef DEBUG_EVENTS
fprintf(stderr,"gxid: Enter event; oldpointer = %ld\n",
old_pointer->id);
#endif
if (old_pointer)
for (i=0;i<window->num_devices;i++)
{
if (window->devices[i] == old_pointer)
{
switch_core_pointer();
break;
}
}
}
void
handle_destroy_notify(XDestroyWindowEvent *event)
{
int i,j;
for (i=0;i<num_windows;i++)
if (windows[i]->xwindow == event->window)
{
GxidWindow *w = windows[i];
for (j=0;j<w->num_devices;j++)
{
#ifdef DEBUG_CLIENTS
fprintf(stderr,"device %ld released on destruction of window 0x%lx.\n",
w->devices[j]->id,w->xwindow);
#endif
if (w->devices[j]->exclusive)
{
w->devices[j]->exclusive = 0;
enable_device(devices[j]);
}
}
if (i<num_windows-1)
windows[i] = windows[num_windows-1];
num_windows--;
if (w->devices)
free((void *)w->devices);
free((void *)w);
/* FIXME: should we deselect input? But what
what if window is already destroyed */
return;
}
}
void
handle_xevent(void)
{
int i;
XEvent event;
XNextEvent (dpy, &event);
#ifdef DEBUG_EVENTS
fprintf(stderr,"Event - type = %d; window = 0x%lx\n",
event.type,event.xany.window);
#endif
if (event.type == ConfigureNotify)
{
#ifdef DEBUG_EVENTS
XConfigureEvent *xce = (XConfigureEvent *)&event;
fprintf(stderr," configureNotify: window = 0x%lx\n",xce->window);
#endif
}
else if (event.type == EnterNotify)
{
/* pointer entered a claimed window */
for (i=0;i<num_windows;i++)
{
if (event.xany.window == windows[i]->xwindow)
handle_enter_notify((XEnterWindowEvent *)&event,windows[i]);
}
}
else if (event.type == DestroyNotify)
{
/* A claimed window was destroyed */
for (i=0;i<num_windows;i++)
{
if (event.xany.window == windows[i]->xwindow)
handle_destroy_notify((XDestroyWindowEvent *)&event);
}
}
else
for (i=0;i<num_devices;i++)
{
if (event.type == devices[i]->motionnotify_type)
{
handle_motion_notify((XDeviceMotionEvent *)&event);
break;
}
else if (event.type == devices[i]->changenotify_type)
{
handle_change_notify((XChangeDeviceNotifyEvent *)&event);
break;
}
}
}
void
usage(void)
{
fprintf(stderr,"Usage: %s [-d display] [-p --gxid-port port]\n",
program_name);
exit(1);
}
int
main(int argc, char **argv)
{
int i;
char *display_name = NULL;
fd_set readfds;
program_name = argv[0];
for (i=1;i<argc;i++)
{
if (!strcmp(argv[i],"-d"))
{
if (++i >= argc) usage();
display_name = argv[i];
}
else if (!strcmp(argv[i],"--gxid-port") ||
!strcmp(argv[i],"-p"))
{
if (++i >= argc) usage();
port = atoi(argv[i]);
break;
}
else
usage();
}
if (!port)
{
char *t = getenv("GXID_PORT");
if (t)
port = atoi(t);
else
port = 6951;
}
/* set up a signal handler so we can clean up if killed */
signal(SIGTERM,handler);
signal(SIGINT,handler);
/* initialize the X connection */
dpy = XOpenDisplay (display_name);
if (!dpy)
{
fprintf (stderr, "%s: unable to open display '%s'\n",
program_name, XDisplayName (display_name));
exit (1);
}
root_window = DefaultRootWindow(dpy);
/* We'll want to do this in the future if we are to support
gxid monitoring visibility information for clients */
#if 0
XSelectInput(dpy,root_window,SubstructureNotifyMask);
#endif
init_xinput();
/* set up our server connection */
init_socket();
/* main loop */
if (XPending(dpy)) /* this seems necessary to get things
in sync */
handle_xevent();
while (1)
{
FD_ZERO(&readfds);
FD_SET(ConnectionNumber(dpy),&readfds);
FD_SET(socket_fd,&readfds);
if (select(8*sizeof(readfds),&readfds,
(fd_set *)0,(fd_set *)0, (struct timeval *)0) < 0)
{
fprintf(stderr,"Error in select\n");
exit(1);
}
if (FD_ISSET(socket_fd,&readfds))
handle_connection();
while (XPending(dpy))
handle_xevent();
}
XCloseDisplay (dpy);
exit (0);
}