rlirc 0.3.1

data/INSTALL

@@ -0,0 +1,14 @@
+De-Compress archive and enter its top directory.
+Then type:
+
+    $ ruby setup.rb config
+    $ ruby setup.rb setup
+   ($ su)
+    # ruby setup.rb install
+
+You can also install files into your favorite directory
+by supplying setup.rb some options. Try "ruby setup.rb --help".
+
+There is also a Rakefile for generating packages, rdoc, ...
+just type rake in the top directory to see a list of options
+

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2004, Roeland Moors
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met:
+1. Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in the 
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+

data/README

@@ -0,0 +1,29 @@
+= rlirc README
+
+rlirc is a replacement for irexec (lirc)
+
+== Requirements
+
+* ruby 1.8
+* lirc 
+
+== Install
+
+:include: INSTALL
+
+== Documentation
+
+http://rlirc.rubyforge.org
+
+== Support
+
+The homepage is at http://rlirc.rubyforge.org.
+Go to the project page for more information.
+
+Feel free to submit commits or feature requests.
+
+== License
+
+Gnucap-Ruby is available under a BSD license
+
+:include: LICENSE

data/Rakefile

@@ -0,0 +1,106 @@
+# Rakefile for rlirc
+
+require 'rubygems'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/clean'
+
+#############
+# rake help #
+#############
+
+desc "Default Task (show this help)"
+task :default => :help
+
+desc "Show this help"
+task :help do
+  sh "rake --task"
+end
+
+################
+# rake version #
+################
+
+version = `grep 'REVISION =' #{Dir.pwd}/bin/rlirc`
+PKG_VERSION = version.split('=')[1].chomp.delete(' ').delete("'")
+PKG_NAME = 'rlirc'
+
+desc "Show version of rlirc"
+task :version do
+    puts "Version: #{PKG_VERSION}"
+end
+
+################
+# rake install #
+################
+
+desc "Info about installing rlirc"
+task :install do
+    install_info = <<-EOS
+    Typical installation procedure is:
+      $ ruby setup.rb config
+      $ ruby setup.rb setup
+      # ruby setup.rb install  (may require root privilege)
+    Try 'ruby setup.rb --help' for detailed usage.
+    EOS
+
+    puts install_info
+
+end
+
+#############
+# rake rdoc #
+#############
+
+Rake::RDocTask.new do |rd|
+    rd.rdoc_dir = 'rdoc'
+    rd.main = 'README'
+    rd.rdoc_files.include('README', 'LICENSE', 'lib/**/*.rb')
+    rd.options << '-S'
+end
+
+#################
+# rake packages #
+#################
+
+PKG_FILES = FileList[
+  'setup.rb',
+  '[A-Z]*',
+  'lib/**/*.rb',
+  'data/**/*.rb',
+  'bin/**/*',
+  'ext/**/*'
+]
+
+gemspec = Gem::Specification.new do |s|
+    s.author = "Roeland Moors"
+    s.autorequire = 'rlirc'
+    s.bindir = 'bin'
+    s.default_executable = 'rlirc'
+    s.add_dependency('libxosd2-ruby', '>= 0.4')
+    s.description = "a replacement for irexec and irxevent from lirc"
+    s.email = "roelandmoors@telenet.be"
+    s.executables = ['rlirc']
+    s.extensions << "ext/xevent/extconf.rb"
+    s.extra_rdoc_files = ['README']
+    s.files = PKG_FILES.to_a
+    s.has_rdoc = true
+    s.homepage = "http://rlirc.rubyforge.org"
+    s.name = PKG_NAME
+    #s.platform
+    #s.rdoc_options
+    s.require_path = 'lib'
+    s.required_ruby_version = '>= 1.8.1'
+    s.requirements << 'X dev libs'
+    s.rubyforge_project = "rlirc"
+    s.summary = "a replacement for irexec and irxevent from lirc"
+    #s.test_files
+    s.version = PKG_VERSION
+end
+
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = true
+end
+

data/bin/rlirc

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'rlirc'
+
+REVISION = '0.3.1'
+
+begin
+    Rlirc.new(ARGV)
+rescue => e
+    $stderr.puts <<EOS
+-----------------------
+Rlirc just crashed 
+-----------------------
+Timestamp: #{Time.now}
+Message: #{e.message}
+Backtrace:
+#{e.backtrace.join("\n")}
+Release: #{REVISION}
+Uname -a: #{`uname -a`.chomp}
+EOS
+    exit 1
+end
+
+
+    

data/data/examples/rlirc.rb

@@ -0,0 +1,123 @@
+require 'rlirc'
+
+# only needed if you need OSD
+require 'rlirc/osd'
+
+# aumix functions
+require 'rlirc/aumix'
+
+# send x events
+require 'rlirc/xevent'
+
+# lirc device
+$device = '/dev/lircd'
+
+# show debug information
+$debug = false
+
+# prevents unwanted repeated presses 
+# (under construction)
+$delay = 0
+
+# osd settings, look at these webpages for other options:
+# http://rubyforge.org/projects/libxosd-ruby/
+# http://ldots.org/xosd-guide/using_libxosd.html
+$osd.timeout = 2
+
+
+# This is the default class
+class ModeMain < Mode
+    def initialize
+    end
+
+    def button_tv
+        change_mode(ModeTV)
+    end
+
+    def button_radio
+        change_mode(ModeRadio)
+    end
+
+
+end
+
+# a button defined here is always executed
+class ModeGlobal < Mode
+    def button_volup
+        `aumix -v+5`
+    end
+    
+    def button_volup_repeat(count)
+        button_volup
+    end
+    
+    def button_voldown
+        `aumix -v-5`
+    end
+    
+    def button_voldown_repeat(count)
+        button_voldown
+    end
+    
+    def button_mute
+        aumix_mute_toggle
+    end
+end
+
+class ModeRadio < Mode
+    def initialize
+        button_1
+    end
+
+    def button_radio
+        `radio -qm`
+        end_mode  # == change_mode(ModeMain)
+    end
+
+    def button_1
+        osd "StuBru"
+        `radio -qf 96.6`
+    end
+    
+    def button_2
+        osd "Donna"
+        `radio -qf 101.7`
+    end
+
+    def button_tv
+        `radio -qm`
+        change_mode(ModeTV)
+    end
+end
+
+class ModeTV < Mode
+    def initialize
+        system("tvtime &")
+    end
+
+    def button_tv
+        `tvtime-command QUIT`
+        end_mode  # == change_mode(ModeMain)
+    end
+
+    def button_radio
+        `tvtime-command QUIT`
+        change_mode(ModeRadio)
+    end
+
+    def button_chup
+        `tvtime-command UP`
+    end
+    
+    def button_chdown
+        `tvtime-command DOWN`
+    end
+
+    def number(nr)
+        `tvtime-command CHANNEL_#{nr}`
+    end
+
+    def button_full_screen
+        xevent('Key f tvtime')
+    end
+end

data/ext/xevent/MANIFEST

@@ -0,0 +1,2 @@
+extconf.rb
+xevent.c

data/ext/xevent/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+if find_library("X11", "XOpenDisplay", "/usr/X11/lib",
+                "/usr/X11R6/lib", "/usr/openwin/lib")
+then
+    create_makefile("xevent")
+else
+    puts "No X support available"
+end

data/ext/xevent/xevent.c

@@ -0,0 +1,574 @@
+/*
+ * The most of this is code is from irxevent.c in the lirc package
+ * I used the code from lirc version 0.7.0pre7.
+ * This means this code is under the same license (GPL)
+ *
+ * Here is the copyright stuff from the original file:
+ * ---
+ * Heinrich Langos  <heinrich@null.net>
+ * small modifications by Christoph Bartelmus <lirc@bartelmus.de>
+ *
+ * irxevent is based on irexec (Copyright (C) 1998 Trent Piepho)
+ * and irx.c (no copyright notice found)
+ * ---
+ *
+ * Here is the changelog
+ *
+ * 0.1: (Roeland Moors)
+ *      removed the lirc config stuff
+ *      added ruby stuff
+*/
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include <ruby.h>
+
+#define DEBUG
+#ifdef DEBUG
+void debugprintf(char *format_str, ...)
+{
+        va_list ap;
+        va_start(ap,format_str);
+        vfprintf(stderr,format_str,ap);
+        va_end(ap);
+}
+#else
+void debugprintf(char *format_str, ...)
+{
+}
+#endif
+
+
+struct keymodlist_t {
+        char *name;
+        Mask mask;
+};
+static struct keymodlist_t keymodlist[]=
+{
+  {"SHIFT",   ShiftMask},
+  {"CAPS",    LockMask},
+  {"CTRL",    ControlMask},
+  {"ALT",     Mod1Mask},{"META",    Mod1Mask},
+  {"NUMLOCK", Mod2Mask},
+  {"MOD3",    Mod3Mask},  /* I don't have a clue what key maps to this. */
+  {"MOD4",    Mod4Mask},  /* I don't have a clue what key maps to this. */
+  {"SCRLOCK", Mod5Mask},
+  {NULL,0},
+};
+
+const char *key_delimiter ="-";
+const char *active_window_name ="CurrentWindow";
+const char *root_window_name ="RootWindow";
+
+
+char *progname;
+Display *dpy;
+Window root;
+XEvent xev;
+Window w,subw;
+
+Time fake_timestamp()
+     /*seems that xfree86 computes the timestamps like this     */
+     /*strange but it relies on the *1000-32bit-wrap-around     */
+     /*if anybody knows exactly how to do it, please contact me */
+{
+  int  tint;
+  struct timeval  tv;
+  struct timezone tz; /* is not used since ages */
+  gettimeofday(&tv,&tz);
+  tint=(int)tv.tv_sec*1000;
+  tint=tint/1000*1000;
+  tint=tint+tv.tv_usec/1000;
+  return (Time)tint;
+}
+
+Window find_window(Window top,char *name)
+{
+  char *wname,*iname;
+  XClassHint xch;
+  Window *children,foo;
+  int revert_to_return;
+  unsigned int nc;
+  if (!strcmp(active_window_name,name)){
+    XGetInputFocus(dpy, &foo, &revert_to_return);
+    return(foo);
+  }  else if (!strcmp(root_window_name,name)){
+    return(root);
+  }
+  /* First the base case */
+  if (XFetchName(dpy,top,&wname)){
+    if (!strncmp(wname,name,strlen(name)))  {
+      XFree(wname);
+      debugprintf("found it by wname 0x%x \n",top);
+      return(top);  /* found it! */
+    };
+    XFree(wname);
+  };
+
+  if(XGetIconName(dpy,top,&iname)){
+    if (!strncmp(iname,name,strlen(name)))  {
+      XFree(iname);
+      debugprintf("found it by iname 0x%x \n",top);
+      return(top);  /* found it! */
+    };
+    XFree(iname);
+  };
+
+  if(XGetClassHint(dpy,top,&xch))  {
+    if(!strcmp(xch.res_class,name))  {
+      XFree(xch.res_name); XFree(xch.res_class);
+      debugprintf("res_class '%s' res_name '%s' 0x%x \n", xch.res_class,xch.res_name,top);
+      return(top);  /* found it! */
+    };
+    if(!strcmp(xch.res_name,name))  {
+      XFree(xch.res_name); XFree(xch.res_class);
+      debugprintf("res_class '%s' res_name '%s' 0x%x \n", xch.res_class,xch.res_name,top);
+      return(top);  /* found it! */
+    };
+    XFree(xch.res_name); XFree(xch.res_class);
+  };
+
+  if(!XQueryTree(dpy,top,&foo,&foo,&children,&nc) || children==NULL) {
+    return(0);  /* no more windows here */
+  };
+
+  /* check all the sub windows */
+  for(;nc>0;nc--)  {
+    top = find_window(children[nc-1],name);
+    if(top) break;  /* we found it somewhere */
+  };
+  if(children!=NULL) XFree(children);
+  return(top);
+}
+
+Window find_sub_sub_window(Window top,int *x, int *y)
+{
+  Window base;
+  Window *children,foo,target=0;
+  unsigned int nc,
+    rel_x,rel_y,width,height,border,depth,
+    new_x=1,new_y=1,
+    targetsize=1000000;
+
+  base=top;
+  if (!base) {return base;};
+  if(!XQueryTree(dpy,base,&foo,&foo,&children,&nc) || children==NULL) {
+    return(base);  /* no more windows here */
+  };
+  debugprintf("found subwindows %d\n",nc);
+
+  /* check if we hit a sub window and find the smallest one */
+  for(;nc>0;nc--)  {
+    if(XGetGeometry(dpy, children[nc-1], &foo, &rel_x, &rel_y, 
+		    &width, &height, &border, &depth)){
+      if ((rel_x<=*x)&&(*x<=rel_x+width)&&(rel_y<=*y)&&(*y<=rel_y+height)){
+	debugprintf("found a subwindow 0x%x +%d +%d  %d x %d   \n",children[nc-1], rel_x,rel_y,width,height);
+	if ((width*height)<targetsize){
+	  target=children[nc-1];
+	  targetsize=width*height;
+	  new_x=*x-rel_x;
+	  new_y=*y-rel_y;
+	  /*bull's eye ...*/
+	  target=find_sub_sub_window(target,&new_x,&new_y);
+	}
+      }	
+    }
+  };
+  if(children!=NULL) XFree(children);
+  if (target){
+    *x=new_x;
+    *y=new_y;
+    return target;
+  }else
+    return base;
+}
+
+
+
+Window find_sub_window(Window top,char *name,int *x, int *y)
+{
+  Window base;
+  Window *children,foo,target=0;
+  unsigned int nc,
+    rel_x,rel_y,width,height,border,depth,
+    new_x=1,new_y=1,
+    targetsize=1000000;
+
+  base=find_window(top, name);
+  if (!base) {return base;};
+  if(!XQueryTree(dpy,base,&foo,&foo,&children,&nc) || children==NULL) {
+    return(base);  /* no more windows here */
+  };
+  debugprintf("found subwindows %d\n",nc);
+
+  /* check if we hit a sub window and find the smallest one */
+  for(;nc>0;nc--)  {
+    if(XGetGeometry(dpy, children[nc-1], &foo, &rel_x, &rel_y, 
+		    &width, &height, &border, &depth)){
+      if ((rel_x<=*x)&&(*x<=rel_x+width)&&(rel_y<=*y)&&(*y<=rel_y+height)){
+	debugprintf("found a subwindow 0x%x +%d +%d  %d x %d   \n",children[nc-1], rel_x,rel_y,width,height);
+	if ((width*height)<targetsize){
+	  target=children[nc-1];
+	  targetsize=width*height;
+	  new_x=*x-rel_x;
+	  new_y=*y-rel_y;
+	  /*bull's eye ...*/
+	  target=find_sub_sub_window(target,&new_x,&new_y);
+	}
+      }	
+    }
+  };
+  if(children!=NULL) XFree(children);
+  if (target){
+    *x=new_x;
+    *y=new_y;
+    return target;
+  }else
+    return base;
+}
+
+
+Window find_window_focused(Window top,char *name) 
+{
+  int tmp;
+  Window w, cur, *children, foo;
+  unsigned int n;
+
+ 
+  /* return the currently focused window if it is a direct match or a
+     subwindow of the named window */
+
+  if((w=find_window(top,name))) {
+    XGetInputFocus(dpy, &cur, &tmp);
+    debugprintf("current window: 0x%x named window: 0x%x\n",cur,w);
+
+    if( w == cur ) {
+      /* window matched */
+      return(cur);
+    } 
+    else if(XQueryTree(dpy,w,&foo,&foo,&children,&n) && children!=NULL) {
+      /* check all the sub windows of named window */
+      for(;n>0;n--)  {
+	if(children[n-1] == cur ) {
+	  XFree(children);
+	  return(cur);
+	}
+      }
+      XFree(children);
+    } 
+  }
+  
+  return(0);
+}
+
+void make_button(int button,int x,int y,XButtonEvent *xev)
+{
+  xev->type = ButtonPress;
+  xev->display=dpy;
+  xev->root=root;
+  xev->subwindow=None;
+  xev->time=fake_timestamp();
+  xev->x=x;xev->y=y;
+  xev->x_root=1; xev->y_root=1;
+  xev->state=0;
+  xev->button=button;
+  xev->same_screen=True;
+
+  return;
+}
+
+void make_key(char *keyname,int x, int y,XKeyEvent *xev)
+{
+  char *part, *part2;
+  struct keymodlist_t *kmlptr;
+
+  part2=malloc(128);
+
+  xev->type = KeyPress;
+  xev->display=dpy;
+  xev->root=root;
+  xev->subwindow = None;
+  xev->time=fake_timestamp();
+  xev->x=x; xev->y=y;
+  xev->x_root=1; xev->y_root=1;
+  xev->same_screen = True;
+
+  xev->state=0;
+#ifdef HAVE_STRSEP
+  while ((part=strsep(&keyname, key_delimiter)))
+#else
+  while ((part=strtok(keyname, key_delimiter)) && ((keyname=NULL)==NULL))
+#endif
+    {
+      part2=strncpy(part2,part,128);
+      //      debugprintf("-   %s \n",part);
+      kmlptr=keymodlist;
+      while (kmlptr->name)
+	{
+	  //	  debugprintf("--  %s %s \n", kmlptr->name, part);
+	  if (!strcasecmp(kmlptr->name, part))
+	    xev->state|=kmlptr->mask;
+	  kmlptr++;
+	}
+      //      debugprintf("--- %s \n",part);
+    } 
+  //  debugprintf("*** %s \n",part);
+  //  debugprintf("*** %s \n",part2);
+  xev->keycode=XKeysymToKeycode(dpy,XStringToKeysym(part2));
+  debugprintf("state 0x%x, keycode 0x%x\n",xev->state, xev->keycode);
+  free(part2);
+  return ;
+}
+
+void sendfocus(Window w,int in_out)
+{
+  XFocusChangeEvent focev;
+
+  focev.display=dpy;
+  focev.type=in_out;
+  focev.window=w;
+  focev.mode=NotifyNormal;
+  focev.detail=NotifyPointer;
+  XSendEvent(dpy,w,True,FocusChangeMask,(XEvent*)&focev);
+  XSync(dpy,True);
+  
+  return;
+}
+
+void sendpointer_enter_or_leave(Window w,int in_out)
+{
+  XCrossingEvent crossev;
+  crossev.type=in_out;
+  crossev.display=dpy;
+  crossev.window=w;
+  crossev.root=root;
+  crossev.subwindow=None;
+  crossev.time=fake_timestamp();
+  crossev.x=1;
+  crossev.y=1;
+  crossev.x_root=1;
+  crossev.y_root=1;
+  crossev.mode=NotifyNormal;
+  crossev.detail=NotifyNonlinear;
+  crossev.same_screen=True;
+  crossev.focus=True;
+  crossev.state=0;
+  XSendEvent(dpy,w,True,EnterWindowMask|LeaveWindowMask,(XEvent*)&crossev);
+  XSync(dpy,True);
+  return;
+}
+
+void sendkey(char *keyname,int x,int y,Window w,Window s)
+{
+  make_key(keyname ,x,y,(XKeyEvent*)&xev);
+  xev.xkey.window=w;
+  xev.xkey.subwindow=s;
+
+  if (s) sendfocus(s,FocusIn);
+
+  XSendEvent(dpy,w,True,KeyPressMask,&xev);
+  xev.type = KeyRelease;
+  usleep(2000);
+  xev.xkey.time = fake_timestamp();
+  if (s) sendfocus(s,FocusOut);
+  XSendEvent(dpy,w,True,KeyReleaseMask,&xev);
+  XSync(dpy,True);
+  return;
+}
+
+void sendbutton(int button, int x, int y, Window w,Window s)
+{
+  make_button(button,x,y,(XButtonEvent*)&xev);
+  xev.xbutton.window=w;
+  xev.xbutton.subwindow=s;
+  sendpointer_enter_or_leave(w,EnterNotify);
+  sendpointer_enter_or_leave(s,EnterNotify);
+
+  XSendEvent(dpy,w,True,ButtonPressMask,&xev);
+  XSync(dpy,True);
+  xev.type = ButtonRelease;
+  xev.xkey.state|=0x100;
+  usleep(1000);
+  xev.xkey.time = fake_timestamp(); 
+  XSendEvent(dpy,w,True,ButtonReleaseMask,&xev);
+  sendpointer_enter_or_leave(s,LeaveNotify);
+  sendpointer_enter_or_leave(w,LeaveNotify);
+  XSync(dpy,True);
+
+  return;
+}
+
+
+int check(char *s)
+{
+  int d;
+  char *buffer;
+
+  buffer=malloc(strlen(s));
+  if(buffer==NULL)
+    {
+      fprintf(stderr,"%s: out of memory\n",progname);
+      return 0;
+    }
+
+  if(2!=sscanf(s,"Key %s Focus %s %s",buffer,buffer,buffer) &&
+     2!=sscanf(s,"Key %s WindowID %i %s",buffer,&d,buffer) &&
+     2!=sscanf(s,"Key %s Focus WindowID %i %s",buffer,&d,buffer) &&
+     2!=sscanf(s,"Key %s %s %s",buffer,buffer,buffer) &&
+     4!=sscanf(s,"Button %d %d %d Focus %s %s",&d,&d,&d,buffer,buffer) &&
+     4!=sscanf(s,"Button %d %d %d WindowID %i %s",&d,&d,&d,&d,buffer) &&
+     4!=sscanf(s,"Button %d %d %d Focus WindowID %i %s",&d,&d,&d,&d,buffer) &&
+     4!=sscanf(s,"Button %d %d %d %s %s",&d,&d,&d,buffer,buffer) &&
+     4!=sscanf(s,"xy_Key %d %d %s Focus %s %s",&d,&d,buffer,buffer,buffer) &&
+     4!=sscanf(s,"xy_Key %d %d %s WindowID %i %s",&d,&d,buffer,&d,buffer) &&
+     4!=sscanf(s,"xy_Key %d %d %s Focus WindowID %i %s",&d,&d,buffer,&d,buffer) &&
+     4!=sscanf(s,"xy_Key %d %d %s %s",&d,&d,buffer,buffer))
+    {
+      fprintf(stderr,"%s: bad config string \"%s\"\n",progname,s);
+      free(buffer);
+      return 0;
+    }
+  free(buffer);  
+  return 1;
+}
+
+void xevent_init()
+{    
+  dpy=XOpenDisplay(NULL);
+  if(dpy==NULL) {
+    fprintf(stderr,"Can't open DISPLAY.\n");
+  }
+  root=RootWindow(dpy,DefaultScreen(dpy));
+}
+
+int xevent(char *cmd)
+{
+    char keyname[128];
+    int pointer_button,pointer_x,pointer_y;
+    char windowname[64];
+    int WindowID;
+
+    *windowname=0;
+	      
+    if(2==sscanf(cmd,"Key %s Focus WindowID %i",keyname,&WindowID) ||
+	   4==sscanf(cmd,"Button %d %d %d Focus WindowID %i",
+           &pointer_button,&pointer_x,&pointer_y,&WindowID) ||
+	   4==sscanf(cmd,"xy_Key %d %d %s Focus WindowID %i",
+           &pointer_x,&pointer_y,keyname,&WindowID) ||
+	   2==sscanf(cmd,"Key %s Focus %s",keyname,windowname) ||
+	   4==sscanf(cmd,"Button %d %d %d Focus %s",
+           &pointer_button,&pointer_x,&pointer_y,windowname) ||
+	   4==sscanf(cmd,"xy_Key %d %d %s Focus %s",
+           &pointer_x,&pointer_y,keyname,windowname))
+	{
+	    debugprintf("Focus\n");
+		/* focussed ? */
+		if(*windowname) {
+		  WindowID=find_window_focused(root,windowname);
+		  if(!WindowID) {
+		    debugprintf("target window '%s' doesn't have focus\n",windowname);
+		    return -1;
+		  }
+		  debugprintf("focused:  %s\n",windowname);
+		} else {
+		  Window cur;
+		  int tmp;
+		  
+		  XGetInputFocus(dpy, &cur, &tmp);
+		  if(WindowID != cur) {
+		    debugprintf("target window '0x%x' doesn't have focus\n",WindowID);
+		    return -1;
+		  }
+		  debugprintf("focused:  0x%x\n",WindowID);
+		}
+	} else if(2==sscanf(cmd,"Key %s WindowID %i",keyname,&WindowID) ||
+			  4==sscanf(cmd,"Button %d %d %d WindowID %i",
+                  &pointer_button,&pointer_x,&pointer_y,&WindowID) ||
+			  4==sscanf(cmd,"xy_Key %d %d %s WindowID %i",
+                  &pointer_x,&pointer_y,keyname,&WindowID)) {
+	    debugprintf("WindowID:  0x%x\n",WindowID);
+		/* WindowID passed */
+	} else if(2==sscanf(cmd,"Key %s %s",keyname,windowname) || 
+			  4==sscanf(cmd,"Button %d %d %d %s",
+                  &pointer_button,&pointer_x,&pointer_y,windowname) ||
+			4==sscanf(cmd,"xy_Key %d %d %s %s\n",
+                &pointer_x,&pointer_y,keyname,windowname)) {
+	    debugprintf("name: %s\n",windowname);
+		WindowID=find_window(root,windowname);
+	}
+	      
+	switch(cmd[0])
+	{
+	    case 'K': // Key
+		debugprintf("keyname: %s \t WindowID: 0x%x\n",keyname,WindowID);
+		debugprintf("%s\n",cmd);
+		sendkey(keyname,1,1,(Window)WindowID,0);
+		break;
+		
+	    case 'B': // Button
+	    case 'x': // xy_Key
+		subw=find_sub_window(root,windowname,&pointer_x,&pointer_y);
+		if(subw) {
+		  if (WindowID==subw) subw=0;
+		  debugprintf("%s\n",cmd);
+		  switch(cmd[0])
+		  {
+		  case 'B':
+		    sendbutton(pointer_button,pointer_x,pointer_y,WindowID,subw);
+		    break;
+		  case 'x':
+		    sendkey(keyname,pointer_x,pointer_y,WindowID,subw);
+		    break;
+		  }
+		}
+		break;
+		
+	}
+    return 1;
+}
+
+
+/*
+ * Ruby stuff
+ */
+
+VALUE cXevent;
+
+/*
+void xevent_rb_new(VALUE class) {
+    xevent_init();
+}
+*/
+
+VALUE xevent_rb_do(VALUE self, VALUE cmd) {
+    xevent_init();
+    xevent(RSTRING(cmd)->ptr);
+    return self;
+}
+
+void Init_xevent() {
+    cXevent = rb_define_class("Xevent", rb_cObject);
+    //rb_define_singleton_method(cXevent, "new", xevent_rb_new, 0);
+    rb_define_method(cXevent, "do", xevent_rb_do, 1);
+}
+    
+