source: trunk/third/gtk/gdk/gxid.c @ 14810

/* 
 * gxid version 0.3
 *
 * Copyright 1997 Owen Taylor <owt1@cornell.edu>
*/
#undef  G_LOG_DOMAIN

#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 its 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);
}