uh 0.1.1

data/ext/uh/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+fail 'libX11 is required'       unless have_library 'X11'
+fail 'libXinerama is required'  unless have_library 'Xinerama'
+
+# FIXME: -pendantic will warn "named variadic macros are a GNU extension"
+#$CFLAGS << ' -std=c99 -pedantic -Wall'
+$CFLAGS << ' -std=c99 -Wall'
+if %w[DEBUG VALGRIND].any? { |e| ENV.key? e }
+  $CFLAGS.gsub! /-O\d\s/, '-g '
+end
+
+create_makefile 'uh'

data/ext/uh/font.c

@@ -0,0 +1,14 @@
+#include "uh.h"
+
+
+VALUE font_make(int width, int ascent, int descent) {
+  VALUE obj;
+  VALUE args[0];
+
+  obj = rb_class_new_instance(0, args, cFont);
+  rb_ivar_set(obj, rb_intern("@width"), INT2FIX(width));
+  rb_ivar_set(obj, rb_intern("@ascent"), INT2FIX(ascent));
+  rb_ivar_set(obj, rb_intern("@descent"), INT2FIX(descent));
+
+  return obj;
+}

data/ext/uh/pixmap.c

@@ -0,0 +1,92 @@
+#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
+
+
+void pixmap_deallocate(UhPixmap *p);
+
+
+VALUE pixmap_draw_rect(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h) {
+  set_pixmap(self);
+
+  XFillRectangle(DPY, PIXMAP, GC,
+    FIX2INT(x), FIX2INT(y), FIX2INT(w), FIX2INT(h)
+  );
+
+  return Qnil;
+}
+
+VALUE pixmap_draw_string(VALUE self, VALUE x, VALUE y, VALUE str) {
+  set_pixmap(self);
+
+  XDrawString(DPY, PIXMAP, GC,
+    FIX2INT(x), FIX2INT(y), RSTRING_PTR(str), RSTRING_LEN(str)
+  );
+
+  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_ivar_get(rcolor, rb_intern("@pixel"))));
+
+  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_id, VALUE rwidth, VALUE rheight) {
+  set_pixmap(self);
+
+  XCopyArea(DPY, PIXMAP, FIX2INT(rwindow_id), GC,
+    0, 0, FIX2INT(rwidth), FIX2INT(rheight), 0, 0
+  );
+
+  return Qnil;
+}
+
+
+VALUE pixmap_make(Display *display, Pixmap xpixmap, VALUE width, VALUE height) {
+  UhPixmap  *pixmap;
+  VALUE     obj;
+
+  obj = Data_Make_Struct(cPixmap, UhPixmap, 0, pixmap_deallocate, pixmap);
+  pixmap->dpy     = display;
+  pixmap->pixmap  = xpixmap;
+  pixmap->gc      = XCreateGC(display, DefaultRootWindow(display), 0, NULL);
+
+  rb_ivar_set(obj, rb_intern("@width"), width);
+  rb_ivar_set(obj, rb_intern("@height"), height);
+
+  return obj;
+}
+
+
+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 id, VALUE x, VALUE y, VALUE w, VALUE h) {
+  rb_ivar_set(self, rb_intern("@id"), id);
+  rb_ivar_set(self, rb_intern("@x"), x);
+  rb_ivar_set(self, rb_intern("@y"), y);
+  rb_ivar_set(self, rb_intern("@width"), w);
+  rb_ivar_set(self, rb_intern("@height"), h);
+
+  return self;
+}

data/ext/uh/uh.c

@@ -0,0 +1,139 @@
+#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");
+
+  eDisplayError = rb_define_class_under(
+    mUh, "DisplayError", rb_eStandardError
+  );
+
+  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_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, 1);
+  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, "color_by_name", display_color_by_name, 1);
+  rb_define_method(cDisplay, "create_pixmap", display_create_pixmap, 2);
+  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, "pending", display_pending, 0);
+  rb_define_method(cDisplay, "query_font", display_query_font, 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_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_attr(cPixmap, "width", 1, 0);
+  rb_define_attr(cPixmap, "height", 1, 0);
+  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);
+  rb_define_private_method(cPixmap, "_copy", pixmap__copy, 3);
+}
+
+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_attr(cWindow, "id", 1, 0);
+  rb_define_method(cWindow, "focus", window_focus, 0);
+  rb_define_method(cWindow, "kill", window_kill, 0);
+  rb_define_method(cWindow, "map", window_map, 0);
+  rb_define_method(cWindow, "mask=", window_mask_set, 1);
+  rb_define_method(cWindow, "name", window_name, 0);
+  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);
+  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_private_method(cWindow, "_configure", window__configure, 4);
+  rb_define_private_method(cWindow, "_configure_event",
+    window__configure_event, 4);
+  rb_define_private_method(cWindow, "_create_sub", window__create_sub, 4);
+  rb_define_private_method(cWindow, "_moveresize", window__moveresize, 4);
+}

data/ext/uh/uh.h

@@ -0,0 +1,106 @@
+#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,
+  eDisplayError;
+
+
+VALUE color_make(unsigned long pixel);
+
+VALUE display_s_on_error(VALUE klass, VALUE handler);
+VALUE display_alloc(VALUE klass);
+VALUE display_close(VALUE self);
+VALUE display_color_by_name(VALUE self, VALUE rcolor);
+VALUE display_create_pixmap(VALUE self, VALUE w, VALUE h);
+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_pending(VALUE self);
+VALUE display_query_font(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_make(int width, int ascent, int descent);
+
+VALUE pixmap__copy(VALUE self, VALUE rwindow_id, VALUE rwidth, VALUE rheight);
+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 *display, Pixmap xpixmap, VALUE width, VALUE height);
+
+VALUE screen_init(VALUE self, VALUE id, VALUE x, VALUE y, VALUE w, VALUE h);
+
+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_set(VALUE self, VALUE mask);
+VALUE window_name(VALUE self);
+VALUE window_override_redirect(VALUE self);
+VALUE window_raise(VALUE self);
+VALUE window_unmap(VALUE self);
+VALUE window_wclass(VALUE self);
+VALUE window__configure(VALUE self, VALUE rx, VALUE ry, VALUE rw, VALUE rh);
+VALUE window__configure_event(VALUE self, VALUE rx, VALUE ry, VALUE rw, VALUE rh);
+VALUE window__create_sub(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h);
+VALUE window__moveresize(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height);
+int window_id(VALUE window);
+VALUE window_make(Display *display, Window window_id);
+
+
+#endif

data/ext/uh/window.c

@@ -0,0 +1,222 @@
+#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_focus(VALUE self) {
+  set_window(self);
+
+  XSetInputFocus(DPY, WINDOW, RevertToPointerRoot, CurrentTime);
+
+  return Qnil;
+}
+
+VALUE window_icccm_wm_delete(VALUE self) {
+  set_window(self);
+  XEvent xev;
+
+  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) {
+  set_window(self);
+  Atom  *win_protocols;
+  int   count;
+  int   i;
+  char  *atom_name;
+  VALUE 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 Qnil;
+}
+
+VALUE window_mask_set(VALUE self, VALUE mask) {
+  set_window(self);
+  XSetWindowAttributes attrs;
+
+  attrs.event_mask = FIX2LONG(mask);
+  XChangeWindowAttributes(DPY, WINDOW, CWEventMask, &attrs);
+
+  return Qnil;
+}
+
+VALUE window_name(VALUE self) {
+  set_window(self);
+  char        *wxname;
+  VALUE       wname;
+
+  if (!XFetchName(DPY, WINDOW, &wxname))
+    return Qnil;
+
+  wname = rb_str_new_cstr(wxname);
+  XFree(wxname);
+
+  return wname;
+}
+
+VALUE window_override_redirect(VALUE self) {
+  set_window(self);
+  XWindowAttributes wa;
+
+  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 Qnil;
+}
+
+VALUE window_unmap(VALUE self) {
+  set_window(self);
+
+  XUnmapWindow(DPY, WINDOW);
+
+  return Qnil;
+}
+
+VALUE window_wclass(VALUE self) {
+  set_window(self);
+  XClassHint  ch;
+  VALUE       wclass;
+
+  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;
+}
+
+
+VALUE window__configure(VALUE self, VALUE rx, VALUE ry, VALUE rw, VALUE rh) {
+  set_window(self);
+  XWindowChanges  wc;
+  unsigned int    mask;
+
+  mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth | CWStackMode;
+  wc.x            = FIX2INT(rx);
+  wc.y            = FIX2INT(ry);
+  wc.width        = FIX2INT(rw);
+  wc.height       = FIX2INT(rh);
+  wc.border_width = 0;
+  wc.stack_mode   = Above;
+  XConfigureWindow(DPY, WINDOW, mask, &wc);
+
+  return Qnil;
+}
+
+VALUE window__configure_event(VALUE self, VALUE rx, VALUE ry, VALUE rw, VALUE rh) {
+  set_window(self);
+  XConfigureEvent ev;
+
+  ev.type               = ConfigureNotify;
+  ev.display            = DPY;
+  ev.event              = WINDOW;
+  ev.window             = WINDOW;
+  ev.x                  = FIX2INT(rx);
+  ev.y                  = FIX2INT(ry);
+  ev.width              = FIX2INT(rw);
+  ev.height             = FIX2INT(rh);
+  ev.border_width       = 0;
+  ev.above              = None;
+  ev.override_redirect  = False;
+  XSendEvent(DPY, WINDOW, False, StructureNotifyMask, (XEvent *)&ev);
+
+  return Qnil;
+}
+
+VALUE window__create_sub(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h) {
+  set_window(self);
+  XSetWindowAttributes  wa;
+  Window                sub_win;
+
+  wa.override_redirect  = True;
+  wa.background_pixmap  = ParentRelative;
+  wa.event_mask         = ExposureMask;
+
+  sub_win = XCreateWindow(DPY, WINDOW,
+    FIX2INT(x), FIX2INT(y), FIX2INT(w), FIX2INT(h), 0,
+    CopyFromParent, CopyFromParent, CopyFromParent,
+    CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa
+  );
+
+  return window_make(DPY, sub_win);
+}
+
+VALUE window__moveresize(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height) {
+  set_window(self);
+  XWindowChanges wc;
+
+  wc.x      = NUM2INT(x);
+  wc.y      = NUM2INT(y);
+  wc.width  = NUM2INT(width);
+  wc.height = NUM2INT(height);
+  XConfigureWindow(DPY, WINDOW, CWX | CWY | CWWidth | CWHeight, &wc);
+
+  return Qnil;
+}
+
+
+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;
+}