uh 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af5af0168ce0db30efde0af41ae1305e659bbef7
+  data.tar.gz: b6da84ea86620308760a08b5d62a3a316044fbdf
+SHA512:
+  metadata.gz: 3ad1c7c95033c4a00d6592bcb1a1cc432431295fe4edeb682471de26c140dfc4953cf41428d25138bb516a929a6aedb3245130c3a8292d050dd6cc3909351a5d
+  data.tar.gz: 0178679a35bd8ff65cf5ef51bf761f87d335009c66b70de2acf27e69ebb745cbfcc2edef0740c401ebbeda36720d5589fbc337f4c568597755c264a37a5e59dc

data/.gitignore

@@ -0,0 +1,4 @@
+/Gemfile-custom.rb
+/Gemfile.lock
+/lib/*.so
+/tmp/

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+eval File.read('Gemfile-custom.rb') if File.exist?('Gemfile-custom.rb')

data/Guardfile

@@ -0,0 +1,7 @@
+directories %w[lib test]
+
+guard :minitest do
+  watch(%r{\Atest/(.*)\/?test_(.*)\.rb$})
+  watch(%r{\Alib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{\Atest/test_helper\.rb$})      { 'test' }
+end

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/extensiontask'
+require 'rake/testtask'
+
+task default: :test
+
+Rake::ExtensionTask.new('uh')
+
+Rake::TestTask.new(test: :compile) do |t|
+  t.libs      << 'lib' << 'test'
+  t.pattern   = 'test/**/test_*.rb'
+end

data/TODO

@@ -0,0 +1,17 @@
+* handle multibyte strings for Pixmap#draw_string
+  check other WM or:
+  https://www.debian.org/doc/manuals/intro-i18n/ch-examples.en.html
+  https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=531036
+
+* check WindowOfEvent in twm
+
+* use rb_block_call()?
+
+* use ALLOC? at least check our allocation and free
+  some free function might not be used
+
+* valgrind suppression file
+  https://github.com/AlekSi/valgrind-suppressions
+
+* http://i3wm.org/
+  https://wiki.archlinux.org/index.php/i3

data/ext/uh/color.c

@@ -0,0 +1,12 @@
+#include "uh.h"
+
+
+VALUE color_make(unsigned long pixel) {
+  VALUE obj;
+  VALUE args[0];
+
+  obj = rb_class_new_instance(0, args, cColor);
+  rb_ivar_set(obj, rb_intern("@pixel"), LONG2NUM(pixel));
+
+  return obj;
+}

data/ext/uh/display.c

@@ -0,0 +1,234 @@
+#include "uh.h"
+
+
+#define DPY display->dpy
+
+
+VALUE rdisplay_error_handler = Qnil;
+
+int display_x_error_handler(Display *dpy, XErrorEvent *e);
+
+
+VALUE display_s_on_error(VALUE klass, VALUE handler) {
+  rdisplay_error_handler = handler;
+  rb_global_variable(&rdisplay_error_handler);
+
+  return Qnil;
+}
+
+
+VALUE display_alloc(VALUE klass) {
+  UhDisplay *display;
+
+  return Data_Make_Struct(klass, UhDisplay, 0, free, display);
+}
+
+
+VALUE display_close(VALUE self) {
+  set_display(self);
+
+  if (DPY) {
+    XCloseDisplay(DPY);
+  }
+  else {
+    rb_raise(eDisplayError, "Can't close display");
+  }
+
+  return self;
+}
+
+VALUE display_color_by_name(VALUE self, VALUE rcolor) {
+  set_display(self);
+  Colormap  map;
+  XColor    color;
+
+  map = DefaultColormap(DPY, SCREEN_DEFAULT);
+
+  if (!XAllocNamedColor(DPY, map, RSTRING_PTR(rcolor), &color, &color))
+    rb_raise(rb_eArgError, "Invalid color name `%s'", RSTRING_PTR(rcolor));
+
+  return color_make(color.pixel);
+}
+
+VALUE display_create_pixmap(VALUE self, VALUE width, VALUE height) {
+  set_display(self);
+  Pixmap pixmap;
+
+  pixmap = XCreatePixmap(DPY, ROOT_DEFAULT, FIX2INT(width), FIX2INT(height),
+    DefaultDepth(DPY, SCREEN_DEFAULT)
+  );
+
+  return pixmap_make(DPY, pixmap, width, height);
+}
+
+VALUE display_fileno(VALUE self) {
+  set_display(self);
+
+  return INT2FIX(XConnectionNumber(DPY));
+}
+
+VALUE display_flush(VALUE self) {
+  set_display(self);
+
+  return INT2FIX(XFlush(DPY));
+}
+
+VALUE display_each_event(VALUE self) {
+  set_display(self);
+  XEvent xev;
+
+  while (1) {
+    XNextEvent(DPY, &xev);
+    rb_yield(event_make(&xev));
+  }
+
+  return Qnil;
+}
+
+VALUE display_grab_key(VALUE self, VALUE key, VALUE modifier) {
+  set_display(self);
+  KeySym      ks;
+  KeyCode     kc;
+
+  ks = XStringToKeysym(RSTRING_PTR(key));
+  if (ks == NoSymbol)
+    rb_raise(rb_eArgError, "Invalid KeySym %s", RSTRING_PTR(key));
+
+  kc = XKeysymToKeycode(DPY, ks);
+  if (kc == 0)
+    rb_raise(rb_eArgError, "KeySym XK_%s has no KeyCode", RSTRING_PTR(key));
+
+  XGrabKey(DPY, kc, FIX2INT(modifier), ROOT_DEFAULT, True,
+    GrabModeAsync, GrabModeAsync);
+
+  return Qnil;
+}
+
+VALUE display_listen_events(int argc, VALUE *argv, VALUE self) {
+  set_display(self);
+  VALUE   arg1;
+  VALUE   arg2;
+  Window  window;
+  long    mask;
+
+  if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {
+    window = window_id(arg1);
+    mask   = FIX2LONG(arg2);
+  }
+  else {
+    window = ROOT_DEFAULT;
+    mask   = FIX2LONG(arg1);
+  }
+
+  XSelectInput(DPY, window, mask);
+
+  return Qnil;
+}
+
+VALUE display_next_event(VALUE self) {
+  set_display(self);
+  XEvent xev;
+
+  XNextEvent(DPY, &xev);
+
+  return event_make(&xev);
+}
+
+VALUE display_open(VALUE self) {
+  set_display(self);
+
+  if (!(DPY = XOpenDisplay(NULL))) {
+    rb_raise(eDisplayError, "Can't open display");
+  }
+
+  XSetErrorHandler(display_x_error_handler);
+
+  return self;
+}
+
+VALUE display_pending(VALUE self) {
+  set_display(self);
+
+  return INT2FIX(XPending(DPY));
+}
+
+VALUE display_query_font(VALUE self) {
+  set_display(self);
+  XFontStruct *xfs;
+  VALUE       font;
+
+  if (!(xfs = XQueryFont(DPY,
+      XGContextFromGC(DefaultGC(DPY, SCREEN_DEFAULT)))))
+    return Qnil;
+
+  font = font_make(xfs->max_bounds.width, xfs->ascent, xfs->descent);
+  XFreeFontInfo(NULL, xfs, 1);
+
+  return font;
+}
+
+VALUE display_root(VALUE self) {
+  set_display(self);
+
+  return window_make(DPY, ROOT_DEFAULT);
+}
+
+VALUE display_screens(VALUE self) {
+  set_display(self);
+  XineramaScreenInfo  *xsi;
+  int                 n;
+  VALUE               screens = rb_ary_new();
+  VALUE               args[5];
+
+  if (XineramaIsActive(DPY)) {
+    xsi = XineramaQueryScreens(DPY, &n);
+
+    for (int i = 0; i < n; i++) {
+      args[0] = INT2FIX(i);
+      args[1] = INT2FIX(xsi[i].x_org);
+      args[2] = INT2FIX(xsi[i].y_org);
+      args[3] = INT2FIX(xsi[i].width);
+      args[4] = INT2FIX(xsi[i].height);
+
+      rb_ary_push(screens, rb_class_new_instance(5, args, cScreen));
+    }
+  }
+  else {
+    args[0] = INT2FIX(SCREEN_DEFAULT);
+    args[1] = INT2FIX(0);
+    args[2] = INT2FIX(0);
+    args[3] = INT2FIX(XDisplayWidth(DPY, SCREEN_DEFAULT));
+    args[4] = INT2FIX(XDisplayHeight(DPY, SCREEN_DEFAULT));
+
+    rb_ary_push(screens, rb_class_new_instance(5, args, cScreen));
+  }
+
+  return screens;
+}
+
+VALUE display_sync(VALUE self, VALUE discard) {
+  set_display(self);
+
+  XSync(display->dpy, RTEST(discard));
+
+  return Qnil;
+}
+
+
+int display_x_error_handler(Display *dpy, XErrorEvent *e) {
+  char msg[80];
+  char req[80];
+  char nb[80];
+
+  XGetErrorText(dpy, e->error_code, msg, sizeof msg);
+  sprintf(nb, "%d", e->request_code);
+  XGetErrorDatabaseText(dpy, "XRequest", nb, "<unknown>", req, sizeof req);
+
+  rb_funcall(rdisplay_error_handler, rb_intern("call"), 3,
+    rb_str_new_cstr(req),
+    LONG2NUM(e->resourceid),
+    rb_str_new_cstr(msg)
+  );
+
+  return 0;
+}

data/ext/uh/event.c

@@ -0,0 +1,161 @@
+#include "uh.h"
+
+
+#define set_xev(x) \
+  XEvent *xev;\
+  Data_Get_Struct(x, XEvent, xev);
+
+
+VALUE event_make_event(VALUE klass, XEvent *xev);
+void event_make_configure_request(VALUE self);
+void event_make_key_any(VALUE self);
+void event_make_win_any(VALUE self);
+
+
+VALUE event_make(XEvent *xev) {
+  typedef struct {
+    int   type;
+    VALUE klass;
+    void  (*function)(VALUE self);
+  } EvClass;
+  EvClass ev_classes[] = {
+    {ConfigureRequest,  cConfigureRequest,  event_make_configure_request},
+    {DestroyNotify,     cDestroyNotify,     NULL},
+    {Expose,            cExpose,            NULL},
+    {KeyPress,          cKeyPress,          event_make_key_any},
+    {KeyRelease,        cKeyRelease,        event_make_key_any},
+    {MapRequest,        cMapRequest,        NULL},
+    {PropertyNotify,    cPropertyNotify,    NULL},
+    {UnmapNotify,       cUnmapNotify,       NULL}
+  };
+  int   i;
+  VALUE event;
+
+  for (i = 0; i < (sizeof ev_classes / sizeof ev_classes[0]); i++) {
+    if (ev_classes[i].type == xev->type) {
+      event = event_make_event(ev_classes[i].klass, xev);
+      event_make_win_any(event);
+      if (ev_classes[i].function)
+        ev_classes[i].function(event);
+
+      return event;
+    }
+  }
+
+  return event_make_event(cEvent, xev);
+}
+
+VALUE event_make_event(VALUE klass, XEvent *xev) {
+  char *type_descs[LASTEvent];
+  VALUE event;
+
+  type_descs[KeyPress]          = "key_press";
+  type_descs[KeyRelease]        = "key_release";
+  type_descs[ButtonPress]       = "button_press";
+  type_descs[ButtonRelease]     = "button_release";
+  type_descs[MotionNotify]      = "motion_notify";
+  type_descs[EnterNotify]       = "enter_notify";
+  type_descs[LeaveNotify]       = "leave_notify";
+  type_descs[FocusIn]           = "focus_in";
+  type_descs[FocusOut]          = "focus_out";
+  type_descs[KeymapNotify]      = "keymap_notify";
+  type_descs[Expose]            = "expose";
+  type_descs[GraphicsExpose]    = "graphics_expose";
+  type_descs[NoExpose]          = "no_expose";
+  type_descs[VisibilityNotify]  = "visibility_notify";
+  type_descs[CreateNotify]      = "create_notify";
+  type_descs[DestroyNotify]     = "destroy_notify";
+  type_descs[UnmapNotify]       = "unmap_notify";
+  type_descs[MapNotify]         = "map_notify";
+  type_descs[MapRequest]        = "map_request";
+  type_descs[ReparentNotify]    = "reparent_notify";
+  type_descs[ConfigureNotify]   = "configure_notify";
+  type_descs[ConfigureRequest]  = "configure_request";
+  type_descs[GravityNotify]     = "gravity_notify";
+  type_descs[ResizeRequest]     = "resize_request";
+  type_descs[CirculateNotify]   = "circulate_notify";
+  type_descs[CirculateRequest]  = "circulate_request";
+  type_descs[PropertyNotify]    = "property_notify";
+  type_descs[SelectionClear]    = "selection_clear";
+  type_descs[SelectionRequest]  = "selection_request";
+  type_descs[SelectionNotify]   = "selection_notify";
+  type_descs[ColormapNotify]    = "colormap_notify";
+  type_descs[ClientMessage]     = "client_message";
+  type_descs[MappingNotify]     = "mapping_notify";
+  type_descs[GenericEvent]      = "generic";
+
+  event = Data_Wrap_Struct(klass, 0, 0, xev);
+  rb_ivar_set(event, rb_intern("@type"),
+    ID2SYM(rb_intern(type_descs[xev->type])));
+
+  return event;
+}
+
+void event_make_configure_request(VALUE self) {
+  set_xev(self);
+
+  if (xev->xconfigurerequest.value_mask & CWX)
+    rb_ivar_set(self, rb_intern("@x"), INT2FIX(xev->xconfigurerequest.x));
+
+  if (xev->xconfigurerequest.value_mask & CWY)
+    rb_ivar_set(self, rb_intern("@y"), INT2FIX(xev->xconfigurerequest.y));
+
+  if (xev->xconfigurerequest.value_mask & CWWidth)
+    rb_ivar_set(self, rb_intern("@width"),
+      INT2FIX(xev->xconfigurerequest.width));
+
+  if (xev->xconfigurerequest.value_mask & CWHeight)
+    rb_ivar_set(self, rb_intern("@height"),
+      INT2FIX(xev->xconfigurerequest.height));
+
+  rb_ivar_set(self, rb_intern("@above_window_id"),
+    LONG2NUM(xev->xconfigurerequest.above));
+  rb_ivar_set(self, rb_intern("@detail"),
+    INT2FIX(xev->xconfigurerequest.detail));
+  rb_ivar_set(self, rb_intern("@value_mask"),
+    LONG2NUM(xev->xconfigurerequest.detail));
+}
+
+void event_make_key_any(VALUE self) {
+  set_xev(self);
+  KeySym ks;
+
+  ks = XkbKeycodeToKeysym(xev->xany.display, xev->xkey.keycode, 0, 0);
+  if (ks == NoSymbol)
+    return;
+
+  rb_ivar_set(self, rb_intern("@key"), rb_str_new_cstr(XKeysymToString(ks)));
+  rb_ivar_set(self, rb_intern("@modifier_mask"), INT2FIX(xev->xkey.state));
+}
+
+void event_make_win_any(VALUE self) {
+  set_xev(self);
+  Window window;
+
+  switch (xev->type) {
+    case ConfigureRequest:
+      window = xev->xconfigurerequest.window;
+      break;
+    case DestroyNotify:
+      window = xev->xdestroywindow.window;
+      break;
+    case Expose:
+      window = xev->xexpose.window;
+      break;
+    case KeyPress:
+      window = xev->xkey.window;
+      break;
+    case MapRequest:
+      window = xev->xmaprequest.window;
+      break;
+    case PropertyNotify:
+      window = xev->xproperty.window;
+      break;
+    case UnmapNotify:
+      window = xev->xunmap.window;
+      break;
+  }
+
+  rb_ivar_set(self, rb_intern("@window"),
+    window_make(xev->xany.display, window));
+}