uh 2.0.0.pre3 → 2.0.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 822c274d968c118bede18ca1963d4581d57a50a7
-  data.tar.gz: 70602803d3ef15b5b3af601ae4fc770b606cc36e
+  metadata.gz: 654b2920bafd23793a74fa558b93bdc7e4852af3
+  data.tar.gz: 7407b260cc14024807da1ea16824754d4f87223a
 SHA512:
-  metadata.gz: 85142b605aac3ebbc9937d1a5243e8c4efaa32378fec1c356a410e39c7fd90c558d36d0beac3379cb160ca5777fcaa7e3109d5ce0ccc37e4eb4362c284c782eb
-  data.tar.gz: 87e3ae605479e288ecd2ae0d2ae75b4428bdac14515d7a94a3ebd7dd02d9df4ad494e25c2607455616fcfcc4d8af9b52cca1ebc76808d26efe3b77d312f94b3a
+  metadata.gz: 4f85b085cda9091602508ee84a1c9fdc5d4e4faed56a17091a2aa2a6d9846758dc6ad66a034ab78c526f105c4985fdd25530cec281e8cd141c12ade03321b7df
+  data.tar.gz: 7989dc2e520cb7e38a89b1e7c9742ced939d165723e3b60e14501321ea503414546cc95f05ea69afcc184e612e58dd7a86c30356d617f9a618bb43ced302e339

data/ext/uh/color.c

@@ -0,0 +1,34 @@
+#include "uh.h"
+
+
+VALUE color_make(Display *dpy, char *color_name);
+
+
+VALUE color_s_new(VALUE klass, VALUE rdisplay, VALUE rcolor_name) {
+  VALUE rcolor;
+  SET_DISPLAY(rdisplay);
+
+  rb_funcall(rdisplay, rb_intern("check!"), 0);
+  StringValue(rcolor_name);
+
+  rcolor = color_make(display->dpy, RSTRING_PTR(rcolor_name));
+  rb_ivar_set(rcolor, rb_intern("@name"), rcolor_name);
+
+  return rcolor;
+}
+
+
+VALUE color_make(Display *dpy, char *color_name) {
+  Colormap  map;
+  XColor    color;
+  VALUE     rcolor;
+  VALUE     args[0];
+
+  map = DefaultColormap(dpy, DefaultScreen(dpy));
+  if (!XAllocNamedColor(dpy, map, color_name, &color, &color))
+    rb_raise(eArgumentError, "invalid color name `%s'", color_name);
+  rcolor = rb_class_new_instance(0, args, cColor);
+  rb_ivar_set(rcolor, rb_intern("@pixel"), LONG2NUM(color.pixel));
+
+  return rcolor;
+}

data/ext/uh/display.c

@@ -0,0 +1,222 @@
+#include "uh.h"
+
+
+#define SET_DISPLAY(x) \
+  UhDisplay *display;\
+  Data_Get_Struct(x, UhDisplay, display);
+
+#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) {
+  if (!rb_block_given_p()) {
+    rb_raise(rb_eArgError, "no block given");
+  }
+
+  rdisplay_error_handler = rb_block_proc();
+  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);
+    DPY = NULL;
+  }
+  else {
+    rb_raise(eDisplayError, "cannot close display");
+  }
+
+  return self;
+}
+
+VALUE display_each_event(VALUE self) {
+  XEvent xev;
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+  while (1) {
+    XNextEvent(DPY, &xev);
+    rb_yield(event_make(&xev));
+  }
+
+  return Qnil;
+}
+
+VALUE display_fileno(VALUE self) {
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+
+  return INT2FIX(XConnectionNumber(DPY));
+}
+
+VALUE display_flush(VALUE self) {
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+
+  return INT2FIX(XFlush(DPY));
+}
+
+VALUE display_grab_key(VALUE self, VALUE rkey, VALUE rmodifier) {
+  KeySym      ks;
+  KeyCode     kc;
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+  StringValue(rkey);
+  ks = XStringToKeysym(RSTRING_PTR(rkey));
+  if (ks == NoSymbol)
+    rb_raise(eArgumentError, "invalid KeySym %s", RSTRING_PTR(rkey));
+
+  kc = XKeysymToKeycode(DPY, ks);
+  if (kc == 0)
+    rb_raise(eArgumentError, "keysym XK_%s has no keycode", RSTRING_PTR(rkey));
+
+  XGrabKey(DPY, kc, FIX2INT(rmodifier), ROOT_DEFAULT, True,
+    GrabModeAsync, GrabModeAsync);
+
+  return Qnil;
+}
+
+VALUE display_listen_events(int argc, VALUE *argv, VALUE self) {
+  VALUE   arg1;
+  VALUE   arg2;
+  Window  window;
+  long    mask;
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+  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) {
+  XEvent xev;
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+  XNextEvent(DPY, &xev);
+
+  return event_make(&xev);
+}
+
+VALUE display_open(VALUE self) {
+  SET_DISPLAY(self);
+
+  if (!(DPY = XOpenDisplay(NULL))) {
+    rb_raise(eDisplayError, "cannot open display");
+  }
+
+  XSetErrorHandler(display_x_error_handler);
+
+  return self;
+}
+
+VALUE display_opened_p(VALUE self) {
+  SET_DISPLAY(self);
+
+  return DPY ? Qtrue : Qfalse;
+}
+
+VALUE display_pending_p(VALUE self) {
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+
+  return INT2FIX(XPending(DPY));
+}
+
+VALUE display_root(VALUE self) {
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+
+  return window_make(DPY, ROOT_DEFAULT);
+}
+
+VALUE display_screens(VALUE self) {
+  XineramaScreenInfo  *xsi;
+  int                 n;
+  VALUE               screens = rb_ary_new();
+  VALUE               args[5];
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+  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 rdiscard) {
+  SET_DISPLAY(self);
+
+  rb_funcall(self, rb_intern("check!"), 0);
+  XSync(display->dpy, RTEST(rdiscard));
+
+  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,168 @@
+#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}
+  };
+  unsigned 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) {
+  const 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])));
+  rb_ivar_set(event, rb_intern("@send_event"),
+    xev->xany.send_event ? Qtrue : Qfalse);
+
+  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) {
+  KeySym ks;
+  SET_XEV(self);
+
+  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) {
+  Window window;
+  SET_XEV(self);
+
+  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:
+      rb_ivar_set(self, rb_intern("@event_window"),
+        window_make(xev->xany.display, xev->xunmap.event));
+      window = xev->xunmap.window;
+      break;
+    default:
+      window = xev->xany.window;
+      break;
+  }
+
+  rb_ivar_set(self, rb_intern("@window"),
+    window_make(xev->xany.display, window));
+}

data/ext/uh/font.c

@@ -0,0 +1,31 @@
+#include "uh.h"
+
+
+VALUE font_make(Display *dpy);
+
+
+VALUE font_s_new(VALUE klass, VALUE rdisplay) {
+  SET_DISPLAY(rdisplay);
+
+  rb_funcall(rdisplay, rb_intern("check!"), 0);
+
+  return font_make(display->dpy);
+}
+
+
+VALUE font_make(Display *dpy) {
+  XFontStruct *xfs;
+  VALUE       rfont;
+  VALUE       args[0];
+
+  if (!(xfs = XQueryFont(dpy,
+      XGContextFromGC(DefaultGC(dpy, DefaultScreen(dpy))))))
+    rb_raise(eDisplayError, "cannot query font");
+  rfont = rb_class_new_instance(0, args, cFont);
+  rb_ivar_set(rfont, rb_intern("@width"), INT2FIX(xfs->max_bounds.width));
+  rb_ivar_set(rfont, rb_intern("@ascent"), INT2FIX(xfs->ascent));
+  rb_ivar_set(rfont, rb_intern("@descent"), INT2FIX(xfs->descent));
+  XFreeFontInfo(NULL, xfs, 1);
+
+  return rfont;
+}

data/ext/uh/pixmap.c

@@ -0,0 +1,110 @@
+#include "uh.h"
+
+
+#define SET_PIXMAP(x) \
+  UhPixmap *pixmap;\
+  Data_Get_Struct(x, UhPixmap, pixmap);
+
+#define DPY           pixmap->dpy
+#define PIXMAP        pixmap->pixmap
+#define GC            pixmap->gc
+#define DEPTH_DEFAULT DefaultDepth(DPY, SCREEN_DEFAULT)
+
+
+void pixmap_deallocate(UhPixmap *p);
+
+
+VALUE pixmap_s_new(VALUE klass, VALUE rdisplay, VALUE rwidth, VALUE rheight) {
+  VALUE rpixmap;
+  SET_DISPLAY(rdisplay);
+
+  rb_funcall(rdisplay, rb_intern("check!"), 0);
+
+  rpixmap = pixmap_make(display->dpy, FIX2INT(rwidth), FIX2INT(rheight));
+  rb_ivar_set(rpixmap, rb_intern("@width"), rwidth);
+  rb_ivar_set(rpixmap, rb_intern("@height"), rheight);
+
+  return rpixmap;
+}
+
+
+VALUE pixmap_draw_rect(VALUE self, VALUE rx, VALUE ry, VALUE rw, VALUE rh) {
+  SET_PIXMAP(self)
+
+  XFillRectangle(DPY, PIXMAP, GC,
+    FIX2INT(rx), FIX2INT(ry), FIX2INT(rw), FIX2INT(rh)
+  );
+
+  return Qnil;
+}
+
+VALUE pixmap_draw_string(VALUE self, VALUE rx, VALUE ry, VALUE rstr) {
+  SET_PIXMAP(self)
+
+  StringValue(rstr);
+  XDrawString(DPY, PIXMAP, GC,
+    FIX2INT(rx), FIX2INT(ry), RSTRING_PTR(rstr), RSTRING_LEN(rstr)
+  );
+
+  return Qnil;
+}
+
+VALUE pixmap_gc_black(VALUE self) {
+  SET_PIXMAP(self)
+
+  XSetForeground(DPY, GC, BlackPixel(DPY, SCREEN_DEFAULT));
+
+  return Qnil;
+}
+
+VALUE pixmap_gc_color(VALUE self, VALUE rcolor) {
+  SET_PIXMAP(self)
+
+  XSetForeground(DPY, GC, NUM2LONG(rb_funcall(rcolor, rb_intern("pixel"), 0)));
+
+  return Qnil;
+}
+
+VALUE pixmap_gc_white(VALUE self) {
+  SET_PIXMAP(self)
+
+  XSetForeground(DPY, GC, WhitePixel(DPY, SCREEN_DEFAULT));
+
+  return Qnil;
+}
+
+
+VALUE pixmap_copy(VALUE self, VALUE rwindow) {
+  SET_PIXMAP(self)
+
+  XCopyArea(DPY, PIXMAP,
+    FIX2INT(rb_funcall(rwindow, rb_intern("id"), 0)),
+    GC,
+    0, 0,
+    FIX2INT(rb_ivar_get(self, rb_intern("@width"))),
+    FIX2INT(rb_ivar_get(self, rb_intern("@height"))),
+    0, 0
+  );
+
+  return Qnil;
+}
+
+
+VALUE pixmap_make(Display *dpy, int w, int h) {
+  UhPixmap  *pixmap;
+  VALUE     rpixmap;
+
+  rpixmap = Data_Make_Struct(cPixmap, UhPixmap, 0, pixmap_deallocate, pixmap);
+  pixmap->dpy     = dpy;
+  pixmap->pixmap  = XCreatePixmap(dpy, ROOT_DEFAULT, w, h, DEPTH_DEFAULT);
+  pixmap->gc      = XCreateGC(dpy, ROOT_DEFAULT, 0, NULL);
+
+  return rpixmap;
+}
+
+
+void pixmap_deallocate(UhPixmap *pixmap) {
+  XFreePixmap(DPY, PIXMAP);
+  XFreeGC(DPY, GC);
+  free(pixmap);
+}

data/ext/uh/screen.c

@@ -0,0 +1,12 @@
+#include "uh.h"
+
+
+VALUE screen_init(VALUE self, VALUE rid, VALUE rx, VALUE ry, VALUE rw, VALUE rh) {
+  rb_ivar_set(self, rb_intern("@id"), rid);
+  rb_ivar_set(self, rb_intern("@x"), rx);
+  rb_ivar_set(self, rb_intern("@y"), ry);
+  rb_ivar_set(self, rb_intern("@width"), rw);
+  rb_ivar_set(self, rb_intern("@height"), rh);
+
+  return self;
+}

data/ext/uh/uh.c

@@ -0,0 +1,147 @@
+#include "uh.h"
+
+
+void uh_color();
+void uh_display();
+void uh_events();
+void uh_font();
+void uh_pixmap();
+void uh_screen();
+void uh_window();
+
+
+void Init_uh(void) {
+  mUh = rb_define_module("Uh");
+
+  eError          = rb_define_class_under(mUh, "Error", rb_eStandardError);
+  eRuntimeError   = rb_define_class_under(mUh, "RuntimeError", rb_eRuntimeError);
+  eArgumentError  = rb_define_class_under(mUh, "ArgumentError", eError);
+  eDisplayError   = rb_define_class_under(mUh, "DisplayError", eRuntimeError);
+
+  uh_color();
+  uh_display();
+  uh_events();
+  uh_font();
+  uh_pixmap();
+  uh_screen();
+  uh_window();
+}
+
+void uh_color() {
+  cColor = rb_define_class_under(mUh, "Color", rb_cObject);
+  rb_define_singleton_method(cColor, "new", color_s_new, 2);
+  rb_define_attr(cColor, "name", 1, 0);
+  rb_define_attr(cColor, "pixel", 1, 0);
+}
+
+void uh_display() {
+  cDisplay = rb_define_class_under(mUh, "Display", rb_cObject);
+  rb_define_singleton_method(cDisplay, "on_error", display_s_on_error, 0);
+  rb_define_alloc_func(cDisplay, display_alloc);
+  rb_define_attr(cDisplay, "name", 1, 0);
+  rb_define_method(cDisplay, "close", display_close, 0);
+  rb_define_method(cDisplay, "fileno", display_fileno, 0);
+  rb_define_method(cDisplay, "flush", display_flush, 0);
+  rb_define_method(cDisplay, "grab_key", display_grab_key, 2);
+  rb_define_method(cDisplay, "listen_events", display_listen_events, -1);
+  rb_define_method(cDisplay, "each_event", display_each_event, 0);
+  rb_define_method(cDisplay, "next_event", display_next_event, 0);
+  rb_define_method(cDisplay, "open", display_open, 0);
+  rb_define_method(cDisplay, "opened?", display_opened_p, 0);
+  rb_define_method(cDisplay, "pending", display_pending_p, 0);
+  rb_define_method(cDisplay, "root", display_root, 0);
+  rb_define_method(cDisplay, "screens", display_screens, 0);
+  rb_define_method(cDisplay, "sync", display_sync, 1);
+}
+
+void uh_events() {
+  mEvents = rb_define_module_under(mUh, "Events");
+
+  cEvent = rb_define_class_under(mEvents, "Event", rb_cObject);
+  rb_define_attr(cEvent, "type", 1, 0);
+  rb_define_attr(cEvent, "window", 1, 0);
+
+  cConfigureRequest = rb_define_class_under(mEvents, "ConfigureRequest", cEvent);
+  rb_define_attr(cConfigureRequest, "x", 1, 0);
+  rb_define_attr(cConfigureRequest, "y", 1, 0);
+  rb_define_attr(cConfigureRequest, "width", 1, 0);
+  rb_define_attr(cConfigureRequest, "height", 1, 0);
+  rb_define_attr(cConfigureRequest, "above_window_id", 1, 0);
+  rb_define_attr(cConfigureRequest, "detail", 1, 0);
+  rb_define_attr(cConfigureRequest, "value_mask", 1, 0);
+
+  cDestroyNotify = rb_define_class_under(mEvents, "DestroyNotify", cEvent);
+
+  cExpose = rb_define_class_under(mEvents, "Expose", cEvent);
+
+  cKeyPress = rb_define_class_under(mEvents, "KeyPress", cEvent);
+  rb_define_attr(cKeyPress, "key", 1, 0);
+  rb_define_attr(cKeyPress, "modifier_mask", 1, 0);
+
+  cKeyRelease = rb_define_class_under(mEvents, "KeyRelease", cEvent);
+  rb_define_attr(cKeyRelease, "key", 1, 0);
+  rb_define_attr(cKeyRelease, "modifier_mask", 1, 0);
+
+  cMapRequest = rb_define_class_under(mEvents, "MapRequest", cEvent);
+
+  cPropertyNotify = rb_define_class_under(mEvents, "PropertyNotify", cEvent);
+
+  cUnmapNotify = rb_define_class_under(mEvents, "UnmapNotify", cEvent);
+}
+
+void uh_font() {
+  cFont = rb_define_class_under(mUh, "Font", rb_cObject);
+  rb_define_singleton_method(cFont, "new", font_s_new, 1);
+  rb_define_attr(cFont, "width", 1, 0);
+  rb_define_attr(cFont, "ascent", 1, 0);
+  rb_define_attr(cFont, "descent", 1, 0);
+}
+
+void uh_pixmap() {
+  cPixmap = rb_define_class_under(mUh, "Pixmap", rb_cObject);
+  rb_define_singleton_method(cPixmap, "new", pixmap_s_new, 3);
+  rb_define_attr(cPixmap, "width", 1, 0);
+  rb_define_attr(cPixmap, "height", 1, 0);
+  rb_define_method(cPixmap, "copy", pixmap_copy, 1);
+  rb_define_method(cPixmap, "draw_rect", pixmap_draw_rect, 4);
+  rb_define_method(cPixmap, "draw_string", pixmap_draw_string, 3);
+  rb_define_method(cPixmap, "gc_black", pixmap_gc_black, 0);
+  rb_define_method(cPixmap, "gc_color", pixmap_gc_color, 1);
+  rb_define_method(cPixmap, "gc_white", pixmap_gc_white, 0);
+}
+
+void uh_screen() {
+  cScreen = rb_define_class_under(mUh, "Screen", rb_cObject);
+  rb_define_method(cScreen, "initialize", screen_init, 5);
+  rb_define_attr(cScreen, "id", 1, 0);
+  rb_define_attr(cScreen, "x", 1, 0);
+  rb_define_attr(cScreen, "y", 1, 0);
+  rb_define_attr(cScreen, "width", 1, 0);
+  rb_define_attr(cScreen, "height", 1, 0);
+}
+
+void uh_window() {
+  cWindow = rb_define_class_under(mUh, "Window", rb_cObject);
+  rb_define_singleton_method(cWindow, "new", window_s_new, 2);
+  rb_define_attr(cWindow, "id", 1, 0);
+  rb_define_method(cWindow, "configure", window_configure, 1);
+  rb_define_method(cWindow, "configure_event", window_configure_event, 1);
+  rb_define_method(cWindow, "create", window_create, 1);
+  rb_define_method(cWindow, "create_sub", window_create_sub, 1);
+  rb_define_method(cWindow, "destroy", window_destroy, 0);
+  rb_define_method(cWindow, "focus", window_focus, 0);
+  rb_define_method(cWindow, "icccm_wm_delete", window_icccm_wm_delete, 0);
+  rb_define_method(cWindow, "icccm_wm_protocols", window_icccm_wm_protocols, 0);
+  rb_define_method(cWindow, "kill", window_kill, 0);
+  rb_define_method(cWindow, "map", window_map, 0);
+  rb_define_alias(cWindow, "show", "map");
+  rb_define_method(cWindow, "mask", window_mask, 0);
+  rb_define_method(cWindow, "mask=", window_mask_set, 1);
+  rb_define_method(cWindow, "moveresize", window_moveresize, 1);
+  rb_define_method(cWindow, "name", window_name, 0);
+  rb_define_method(cWindow, "name=", window_name_set, 1);
+  rb_define_method(cWindow, "override_redirect?", window_override_redirect, 0);
+  rb_define_method(cWindow, "raise", window_raise, 0);
+  rb_define_method(cWindow, "unmap", window_unmap, 0);
+  rb_define_method(cWindow, "wclass", window_wclass, 0);
+}

data/ext/uh/uh.h

@@ -0,0 +1,110 @@
+#ifndef RUBY_UH
+#define RUBY_UH
+
+#include <ruby.h>
+
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xinerama.h>
+
+
+#define SET_DISPLAY(x) \
+  UhDisplay *display;\
+  Data_Get_Struct(x, UhDisplay, display);
+
+#define ROOT_DEFAULT    DefaultRootWindow(DPY)
+#define SCREEN_DEFAULT  DefaultScreen(DPY)
+
+
+typedef struct s_display  UhDisplay;
+typedef struct s_pixmap   UhPixmap;
+typedef struct s_window   UhWindow;
+
+struct s_display {
+  Display *dpy;
+};
+
+struct s_pixmap {
+  Display *dpy;
+  Pixmap  pixmap;
+  GC      gc;
+};
+
+struct s_window {
+  Display *dpy;
+  Window  id;
+};
+
+
+VALUE mUh, mEvents,
+  cColor,
+  cDisplay,
+  cEvent, cConfigureRequest, cDestroyNotify, cExpose, cKeyPress, cKeyRelease,
+    cMapRequest, cPropertyNotify, cUnmapNotify,
+  cFont,
+  cPixmap,
+  cScreen,
+  cWindow,
+  eError, eRuntimeError, eArgumentError, eDisplayError;
+
+
+VALUE color_s_new(VALUE klass, VALUE display, VALUE color_name);
+
+VALUE display_s_on_error(VALUE klass);
+VALUE display_alloc(VALUE klass);
+VALUE display_close(VALUE self);
+VALUE display_each_event(VALUE self);
+VALUE display_fileno(VALUE self);
+VALUE display_flush(VALUE self);
+VALUE display_grab_key(VALUE self, VALUE key, VALUE modifier);
+VALUE display_listen_events(int argc, VALUE *argv, VALUE self);
+VALUE display_next_event(VALUE self);
+VALUE display_open(VALUE self);
+VALUE display_opened_p(VALUE self);
+VALUE display_pending_p(VALUE self);
+VALUE display_root(VALUE self);
+VALUE display_root_change_attributes(VALUE self, VALUE mask);
+VALUE display_screens(VALUE self);
+VALUE display_sync(VALUE self, VALUE discard);
+
+VALUE event_make(XEvent *xev);
+
+VALUE font_s_new(VALUE klass, VALUE rdisplay);
+
+VALUE pixmap_s_new(VALUE klass, VALUE rdisplay, VALUE rwidth, VALUE rheight);
+VALUE pixmap_copy(VALUE self, VALUE rwindow);
+VALUE pixmap_draw_rect(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h);
+VALUE pixmap_draw_string(VALUE self, VALUE x, VALUE y, VALUE str);
+VALUE pixmap_gc_black(VALUE self);
+VALUE pixmap_gc_color(VALUE self, VALUE rcolor);
+VALUE pixmap_gc_white(VALUE self);
+VALUE pixmap_make(Display *dpy, int w, int h);
+
+VALUE screen_init(VALUE self, VALUE id, VALUE x, VALUE y, VALUE w, VALUE h);
+
+VALUE window_s_new(VALUE klass, VALUE rdisplay, VALUE rwindow_id);
+VALUE window_configure(VALUE self, VALUE rgeo);
+VALUE window_configure_event(VALUE self, VALUE rgeo);
+VALUE window_create(VALUE self, VALUE rgeo);
+VALUE window_create_sub(VALUE self, VALUE rgeo);
+VALUE window_destroy(VALUE self);
+VALUE window_focus(VALUE self);
+VALUE window_icccm_wm_delete(VALUE self);
+VALUE window_icccm_wm_protocols(VALUE self);
+VALUE window_kill(VALUE self);
+VALUE window_map(VALUE self);
+VALUE window_mask(VALUE self);
+VALUE window_mask_set(VALUE self, VALUE mask);
+VALUE window_moveresize(VALUE self, VALUE rgeo);
+VALUE window_name(VALUE self);
+VALUE window_name_set(VALUE self, VALUE name);
+VALUE window_override_redirect(VALUE self);
+VALUE window_raise(VALUE self);
+VALUE window_unmap(VALUE self);
+VALUE window_wclass(VALUE self);
+int window_id(VALUE window);
+VALUE window_make(Display *display, Window window_id);
+
+
+#endif

data/ext/uh/window.c

@@ -0,0 +1,278 @@
+#include "uh.h"
+
+
+#define SET_WINDOW(x) \
+  UhWindow *window;\
+  Data_Get_Struct(x, UhWindow, window);
+
+#define DPY     window->dpy
+#define WINDOW  window->id
+
+
+VALUE window_s_new(VALUE klass, VALUE rdisplay, VALUE rwindow_id) {
+  VALUE rwindow;
+  SET_DISPLAY(rdisplay);
+
+  rwindow = window_make(display->dpy, NUM2LONG(rwindow_id));
+
+  return rwindow;
+}
+
+
+VALUE window_configure(VALUE self, VALUE rgeo) {
+  XWindowChanges  wc;
+  unsigned int    mask;
+  SET_WINDOW(self);
+
+  mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth | CWStackMode;
+  wc.x            = FIX2INT(rb_funcall(rgeo, rb_intern("x"), 0));
+  wc.y            = FIX2INT(rb_funcall(rgeo, rb_intern("y"), 0));
+  wc.width        = FIX2INT(rb_funcall(rgeo, rb_intern("width"), 0));
+  wc.height       = FIX2INT(rb_funcall(rgeo, rb_intern("height"), 0));
+  wc.border_width = 0;
+  wc.stack_mode   = Above;
+  XConfigureWindow(DPY, WINDOW, mask, &wc);
+
+  return self;
+}
+
+VALUE window_configure_event(VALUE self, VALUE rgeo) {
+  XConfigureEvent ev;
+  SET_WINDOW(self);
+
+  ev.type               = ConfigureNotify;
+  ev.display            = DPY;
+  ev.event              = WINDOW;
+  ev.window             = WINDOW;
+  ev.x                  = FIX2INT(rb_funcall(rgeo, rb_intern("x"), 0));
+  ev.y                  = FIX2INT(rb_funcall(rgeo, rb_intern("y"), 0));
+  ev.width              = FIX2INT(rb_funcall(rgeo, rb_intern("width"), 0));
+  ev.height             = FIX2INT(rb_funcall(rgeo, rb_intern("height"), 0));
+  ev.border_width       = 0;
+  ev.above              = None;
+  ev.override_redirect  = False;
+  XSendEvent(DPY, WINDOW, False, StructureNotifyMask, (XEvent *)&ev);
+
+  return self;
+}
+
+VALUE window_create(VALUE self, VALUE rgeo) {
+  Window win;
+  SET_WINDOW(self);
+
+  win = XCreateSimpleWindow(DPY, WINDOW,
+    FIX2INT(rb_funcall(rgeo, rb_intern("x"), 0)),
+    FIX2INT(rb_funcall(rgeo, rb_intern("y"), 0)),
+    FIX2INT(rb_funcall(rgeo, rb_intern("width"), 0)),
+    FIX2INT(rb_funcall(rgeo, rb_intern("height"), 0)),
+    0, BlackPixel(DPY, SCREEN_DEFAULT), BlackPixel(DPY, SCREEN_DEFAULT)
+  );
+
+  return window_make(DPY, win);
+}
+
+VALUE window_create_sub(VALUE self, VALUE rgeo) {
+  XSetWindowAttributes  wa;
+  Window                sub_win;
+  SET_WINDOW(self);
+
+  wa.override_redirect  = True;
+  wa.background_pixmap  = ParentRelative;
+  wa.event_mask         = ExposureMask;
+
+  sub_win = XCreateWindow(DPY, WINDOW,
+    FIX2INT(rb_funcall(rgeo, rb_intern("x"), 0)),
+    FIX2INT(rb_funcall(rgeo, rb_intern("y"), 0)),
+    FIX2INT(rb_funcall(rgeo, rb_intern("width"), 0)),
+    FIX2INT(rb_funcall(rgeo, rb_intern("height"), 0)),
+    0, CopyFromParent, CopyFromParent, CopyFromParent,
+    CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa
+  );
+
+  return window_make(DPY, sub_win);
+}
+
+VALUE window_destroy(VALUE self) {
+  SET_WINDOW(self);
+
+  XDestroyWindow(DPY, WINDOW);
+
+  return Qnil;
+}
+
+VALUE window_focus(VALUE self) {
+  SET_WINDOW(self);
+
+  XSetInputFocus(DPY, WINDOW, RevertToPointerRoot, CurrentTime);
+
+  return self;
+}
+
+VALUE window_icccm_wm_delete(VALUE self) {
+  XEvent xev;
+  SET_WINDOW(self);
+
+  xev.type = ClientMessage;
+  xev.xclient.window = WINDOW;
+  xev.xclient.message_type = XInternAtom(DPY, "WM_PROTOCOLS", False);
+  xev.xclient.format = 32;
+  xev.xclient.data.l[0] = XInternAtom(DPY, "WM_DELETE_WINDOW", False);
+  xev.xclient.data.l[1] = CurrentTime;
+  XSendEvent(DPY, WINDOW, False, NoEventMask, &xev);
+
+  return Qnil;
+}
+
+VALUE window_icccm_wm_protocols(VALUE self) {
+  Atom  *win_protocols;
+  int   count;
+  int   i;
+  char  *atom_name;
+  VALUE protocols;
+  SET_WINDOW(self);
+  protocols = rb_ary_new();
+
+  if (XGetWMProtocols(DPY, WINDOW, &win_protocols, &count)) {
+    for (i = 0; i < count; i++) {
+      atom_name = XGetAtomName(DPY, win_protocols[i]);
+      rb_ary_push(protocols, ID2SYM(rb_intern(atom_name)));
+      XFree(atom_name);
+    }
+  }
+
+  return protocols;
+}
+
+VALUE window_kill(VALUE self) {
+  SET_WINDOW(self);
+
+  XKillClient(DPY, WINDOW);
+
+  return Qnil;
+}
+
+VALUE window_map(VALUE self) {
+  SET_WINDOW(self);
+
+  XMapWindow(DPY, WINDOW);
+
+  return self;
+}
+
+VALUE window_mask(VALUE self) {
+  XWindowAttributes wa;
+  SET_WINDOW(self);
+
+  if (!XGetWindowAttributes(DPY, WINDOW, &wa)) {
+    rb_raise(rb_eArgError, "cannot get window attributes for `0x%08lx'", WINDOW);
+  }
+
+  return LONG2FIX(wa.your_event_mask);
+}
+
+VALUE window_mask_set(VALUE self, VALUE mask) {
+  XSetWindowAttributes attrs;
+  SET_WINDOW(self);
+
+  attrs.event_mask = FIX2LONG(mask);
+  XChangeWindowAttributes(DPY, WINDOW, CWEventMask, &attrs);
+
+  return Qnil;
+}
+
+VALUE window_moveresize(VALUE self, VALUE rgeo) {
+  XWindowChanges wc;
+  SET_WINDOW(self);
+
+  wc.x      = FIX2INT(rb_funcall(rgeo, rb_intern("x"), 0));
+  wc.y      = FIX2INT(rb_funcall(rgeo, rb_intern("y"), 0));
+  wc.width  = FIX2INT(rb_funcall(rgeo, rb_intern("width"), 0));
+  wc.height = FIX2INT(rb_funcall(rgeo, rb_intern("height"), 0));
+  XConfigureWindow(DPY, WINDOW, CWX | CWY | CWWidth | CWHeight, &wc);
+
+  return self;
+}
+
+VALUE window_name(VALUE self) {
+  char        *wxname;
+  VALUE       wname;
+  SET_WINDOW(self);
+
+  if (!XFetchName(DPY, WINDOW, &wxname))
+    return Qnil;
+
+  wname = rb_str_new_cstr(wxname);
+  XFree(wxname);
+
+  return wname;
+}
+
+VALUE window_name_set(VALUE self, VALUE rname) {
+  SET_WINDOW(self);
+
+  StringValue(rname);
+  XStoreName(DPY, WINDOW, RSTRING_PTR(rname));
+
+  return Qnil;
+}
+
+VALUE window_override_redirect(VALUE self) {
+  XWindowAttributes wa;
+  SET_WINDOW(self);
+
+  if (!XGetWindowAttributes(DPY, WINDOW, &wa))
+    return Qnil;
+
+  return wa.override_redirect ? Qtrue : Qfalse;
+}
+
+VALUE window_raise(VALUE self) {
+  SET_WINDOW(self);
+
+  XRaiseWindow(DPY, WINDOW);
+
+  return self;
+}
+
+VALUE window_unmap(VALUE self) {
+  SET_WINDOW(self);
+
+  XUnmapWindow(DPY, WINDOW);
+
+  return self;
+}
+
+VALUE window_wclass(VALUE self) {
+  XClassHint  ch;
+  VALUE       wclass;
+  SET_WINDOW(self);
+
+  if (!XGetClassHint(DPY, WINDOW, &ch))
+    return Qnil;
+
+  wclass = rb_str_new_cstr(ch.res_class);
+  XFree(ch.res_name);
+  XFree(ch.res_class);
+
+  return wclass;
+}
+
+
+int window_id(VALUE self) {
+  SET_WINDOW(self);
+
+  return WINDOW;
+}
+
+VALUE window_make(Display *display, Window window_id) {
+  UhWindow    *window;
+  VALUE       obj;
+
+  obj = Data_Make_Struct(cWindow, UhWindow, 0, free, window);
+  window->dpy = display;
+  window->id  = window_id;
+
+  rb_ivar_set(obj, rb_intern("@id"), LONG2NUM(window_id));
+
+  return obj;
+}

data/lib/uh/version.rb

@@ -1,3 +1,3 @@
 module Uh
-  VERSION = '2.0.0.pre3'.freeze
+  VERSION = '2.0.0.pre4'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uh
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre3
+  version: 2.0.0.pre4
 platform: ruby
 authors:
 - Thibault Jouan
@@ -89,7 +89,16 @@ extra_rdoc_files:
 - README.md
 files:
 - README.md
+- ext/uh/color.c
+- ext/uh/display.c
+- ext/uh/event.c
 - ext/uh/extconf.rb
+- ext/uh/font.c
+- ext/uh/pixmap.c
+- ext/uh/screen.c
+- ext/uh/uh.c
+- ext/uh/uh.h
+- ext/uh/window.c
 - lib/uh.rb
 - lib/uh/display.rb
 - lib/uh/events.rb