libcaribou: factor out X dependency

This patch adds a new abstract class DisplayAdapter to handle multiple
display backends, other than X.

https://bugzilla.gnome.org/show_bug.cgi?id=705720

6 files changed, 199 insertions, 34 deletions

diff --git a/libcaribou/Makefile.am b/libcaribou/Makefile.am
index 770035b..d7aa36a 100644
--- a/libcaribou/Makefile.am
+++ b/libcaribou/Makefile.am
@@ -32,6 +32,7 @@ libcaribou_la_LIBADD = \
 	$(LIBCARIBOU_LIBS)
 
 libcaribou_la_SOURCES = \
+	display-adapter.vala \
 	xadapter.vala \
 	keyboard-model.vala \
 	keyboard-service.vala \
diff --git a/libcaribou/display-adapter.vala b/libcaribou/display-adapter.vala
new file mode 100644
index 0000000..007d90e
--- /dev/null
+++ b/libcaribou/display-adapter.vala
@@ -0,0 +1,176 @@
+namespace Caribou {
+    public delegate void KeyButtonCallback (uint keybuttoncode, bool pressed);
+
+    /**
+     * Base class of singleton object providing access to the display server.
+     */
+    public abstract class DisplayAdapter : Object {
+        /**
+         * Display instance.
+         */
+        public Gdk.Display display { get; construct; }
+
+        /**
+         * Signal emitted when modifiers have changed.
+         */
+        public signal void modifiers_changed (uint modifiers);
+
+        /**
+         * Signal emitted when the current group has changed.
+         *
+         * @param gid group index
+         * @param group group name
+         * @param variant variant name
+         */
+        public signal void group_changed (uint gid,
+                                          string group,
+                                          string variant);
+
+        /**
+         * Signal emitted when the group configuration has changed.
+         */
+        public signal void config_changed ();
+
+        /**
+         * Send key press event.
+         *
+         * @param keyval keyval
+         */
+        public abstract void keyval_press (uint keyval);
+
+        /**
+         * Send key release event.
+         *
+         * @param keyval keyval
+         */
+        public abstract void keyval_release (uint keyval);
+
+        /**
+         * Lock modifiers.
+         *
+         * @param mask modifiers
+         */
+        public abstract void mod_lock (uint mask);
+
+        /**
+         * Unlock modifiers.
+         *
+         * @param mask modifiers
+         */
+        public abstract void mod_unlock (uint mask);
+
+        /**
+         * Latch modifiers.
+         *
+         * @param mask modifiers
+         */
+        public abstract void mod_latch (uint mask);
+
+        /**
+         * Unlatch modifiers.
+         *
+         * @param mask modifiers
+         */
+        public abstract void mod_unlatch (uint mask);
+
+        /**
+         * Get the current group.
+         *
+         * @param group_name group name
+         * @param variant_name variant name
+         */
+        public abstract uint get_current_group (out string group_name,
+                                                out string variant_name);
+
+        /**
+         * Get available groups.
+         *
+         * @param group_names list of groups
+         * @param variant_names list of variants, indexed same as group_names
+         */
+        public abstract void get_groups (out string[] group_names,
+                                         out string[] variant_names);
+
+        /**
+         * Register key callback.
+         *
+         * @param keyval keyval
+         * @param func callback
+         */
+        public abstract void register_key_func (uint keyval,
+                                                KeyButtonCallback? func);
+
+        /**
+         * Register button callback.
+         *
+         * @param button button
+         * @param func callback
+         */
+        public abstract void register_button_func (uint button,
+                                                   KeyButtonCallback? func);
+
+        static DisplayAdapter instance;
+        public static DisplayAdapter get_default () {
+            if (instance == null) {
+                var display = Gdk.DisplayManager.get ().get_default_display ();
+                var adapter_type = typeof (NullAdapter);
+                if (display != null) {
+                    var adapters = new Gee.HashMap<Type, Type> ();
+                    adapters.set (typeof (Gdk.X11Display), typeof (XAdapter));
+
+                    var display_type = display.get_type ();
+                    if (adapters.has_key (display_type))
+                        adapter_type = adapters.get (display_type);
+                }
+                instance = (DisplayAdapter) Object.new (adapter_type,
+                                                        "display", display);
+            }
+            return instance;
+        }
+    }
+
+    public class NullAdapter : DisplayAdapter {
+        public override void keyval_press (uint keyval) {
+        }
+
+        public override void keyval_release (uint keyval) {
+        }
+
+        public override void mod_lock (uint mask) {
+        }
+
+        public override void mod_unlock (uint mask) {
+        }
+
+        public override void mod_latch (uint mask) {
+        }
+
+        public override void mod_unlatch (uint mask) {
+        } 
+
+        public override uint get_current_group (out string group_name,
+                                                out string variant_name)
+        {
+            group_name = "us";
+            variant_name = "";
+            return 0;
+        }
+
+        public override void get_groups (out string[] group_names,
+                                         out string[] variant_names)
+        {
+            group_names = new string[] { "us" };
+            variant_names = new string[] { "" };
+        }
+
+        public override void register_key_func (uint keyval,
+                                                KeyButtonCallback? func)
+        {
+        }
+
+        public override void register_button_func (uint button,
+                                                   KeyButtonCallback? func)
+        {
+        }
+    }
+}
diff --git a/libcaribou/key-model.vala b/libcaribou/key-model.vala
index ce6315b..d6776da 100644
--- a/libcaribou/key-model.vala
+++ b/libcaribou/key-model.vala
@@ -43,7 +43,7 @@ namespace Caribou {
         }
 
         private uint hold_tid;
-        private XAdapter xadapter;
+        private DisplayAdapter xadapter;
         private Gee.ArrayList<KeyModel> extended_keys;
 
         public signal void key_hold_end ();
@@ -122,7 +122,7 @@ namespace Caribou {
                 }
             }
 
-            xadapter = XAdapter.get_default();
+            xadapter = DisplayAdapter.get_default();
             extended_keys = new Gee.ArrayList<KeyModel> ();
         }
 
diff --git a/libcaribou/keyboard-model.vala b/libcaribou/keyboard-model.vala
index be00b5c..f1c8dbb 100644
--- a/libcaribou/keyboard-model.vala
+++ b/libcaribou/keyboard-model.vala
@@ -10,7 +10,7 @@ namespace Caribou {
         public string active_group { get; private set; default = ""; }
         public string keyboard_type { get; construct; }
 
-        private XAdapter xadapter;
+        private DisplayAdapter xadapter;
         private Gee.HashMap<string, GroupModel> groups;
         private KeyModel last_activated_key;
         private Gee.HashSet<KeyModel> active_mod_keys;
@@ -21,7 +21,7 @@ namespace Caribou {
         construct {
             assert (keyboard_type != null);
 
-            xadapter = XAdapter.get_default ();
+            xadapter = DisplayAdapter.get_default ();
             xadapter.group_changed.connect (on_group_changed);
             xadapter.config_changed.connect (on_config_changed);
 
diff --git a/libcaribou/scanner.vala b/libcaribou/scanner.vala
index 7d14a0a..c2b2b94 100644
--- a/libcaribou/scanner.vala
+++ b/libcaribou/scanner.vala
@@ -225,7 +225,7 @@ namespace Caribou {
             
             unconfigure_switch ();
 
-            XAdapter xadapter = XAdapter.get_default();
+            DisplayAdapter xadapter = DisplayAdapter.get_default();
             if (switch_device == "keyboard" && keyboard_key != null) {
                 uint keyval = Gdk.keyval_from_name (keyboard_key);
                 xadapter.register_key_func (keyval, switch_pressed);
diff --git a/libcaribou/xadapter.vala b/libcaribou/xadapter.vala
index dbc34f9..92fba5e 100644
--- a/libcaribou/xadapter.vala
+++ b/libcaribou/xadapter.vala
@@ -2,15 +2,8 @@ namespace Caribou {
     /**
      * Singleton object providing access to the X Window facility.
      */
-    public class XAdapter : Object {
-
-        /* Signals */
-        public signal void modifiers_changed (uint modifiers);
-        public signal void group_changed (uint gid, string group, string variant);
-        public signal void config_changed ();
-
+    public class XAdapter : DisplayAdapter {
         /* Private properties */
-        static XAdapter instance;
         unowned X.Display xdisplay;
         X.ID xid;
         Xkb.Desc xkbdesc;
@@ -21,8 +14,6 @@ namespace Caribou {
         uchar group;
         uint[] level_switch_modifiers;
 
-        public delegate void KeyButtonCallback (uint keybuttoncode, bool pressed);
-
         private class KeyButtonHandler {
             public unowned KeyButtonCallback cb { get; private set; }
             public KeyButtonHandler (KeyButtonCallback cb) {
@@ -81,12 +72,6 @@ namespace Caribou {
             Xkb.free_keyboard(this.xkbdesc, Xkb.GBN_AllComponentsMask, true);
         }
 
-        public static XAdapter get_default() {
-            if (instance == null)
-                instance = new XAdapter ();
-            return instance;
-        }
-
         private Gdk.FilterReturn x_event_filter (Gdk.XEvent xevent, Gdk.Event event) {
             // After the following commit, Vala changed the definition
             // of Gdk.XEvent from struct to class:
@@ -103,7 +88,7 @@ namespace Caribou {
             Xkb.Event* xkbev = (Xkb.Event *) pointer;
             X.Event* xev = (X.Event *) pointer;
 
-			this.xkl_engine.filter_events(xev);
+            this.xkl_engine.filter_events(xev);
 
             if (xev.type == X.EventType.ButtonPress ||
                 xev.type == X.EventType.ButtonRelease) {
@@ -122,7 +107,7 @@ namespace Caribou {
                                 xev.type == X.EventType.KeyPress);
             } else if (xkbev.any.xkb_type == Xkb.StateNotify) {
                 Xkb.StateNotifyEvent *sevent = &xkbev.state;
-				if ((sevent.changed & Xkb.ModifierStateMask) != 0) {
+                if ((sevent.changed & Xkb.ModifierStateMask) != 0) {
                     this.modifiers = (uchar) sevent.mods;
                 }
             }
@@ -254,7 +239,7 @@ namespace Caribou {
             return keycode;
         }
 
-        public void keyval_press (uint keyval) {
+        public override void keyval_press (uint keyval) {
             uint mask;
             uchar keycode = keycode_for_keyval (keyval, out mask);
 
@@ -265,34 +250,34 @@ namespace Caribou {
             this.xdisplay.flush ();
         }
 
-        public void keyval_release (uint keyval) {
+        public override void keyval_release (uint keyval) {
             uchar keycode = keycode_for_keyval (keyval, null);
 
             XTest.fake_key_event (this.xdisplay, keycode, false, X.CURRENT_TIME);
             this.xdisplay.flush ();
         }
 
-        public void mod_lock (uint mask) {
+        public override void mod_lock (uint mask) {
             Xkb.lock_modifiers (this.xdisplay, Xkb.UseCoreKbd, mask, mask);
             this.xdisplay.flush ();
         }
 
-        public void mod_unlock (uint mask) {
+        public override void mod_unlock (uint mask) {
             Xkb.lock_modifiers (this.xdisplay, Xkb.UseCoreKbd, mask, 0);
             this.xdisplay.flush();
         }
 
-        public void mod_latch (uint mask) {
+        public override void mod_latch (uint mask) {
             Xkb.latch_modifiers (this.xdisplay, Xkb.UseCoreKbd, mask, mask);
             this.xdisplay.flush ();
         }
 
-        public void mod_unlatch (uint mask) {
+        public override void mod_unlatch (uint mask) {
             Xkb.latch_modifiers (this.xdisplay, Xkb.UseCoreKbd, mask, 0);
             this.xdisplay.flush ();
         }
 
-        public uint get_current_group (out string group_name,
+        public override uint get_current_group (out string group_name,
                                        out string variant_name) {
             Xkl.ConfigRec config_rec = new Xkl.ConfigRec ();
             config_rec.get_from_server (this.xkl_engine);
@@ -304,7 +289,7 @@ namespace Caribou {
             return this.group;
         }
 
-        public void get_groups (out string[] group_names,
+        public override void get_groups (out string[] group_names,
                                 out string[] variant_names) {
             int i;
             Xkl.ConfigRec config_rec = new Xkl.ConfigRec ();
@@ -328,7 +313,9 @@ namespace Caribou {
             }
         }
 
-        public void register_key_func (uint keyval, KeyButtonCallback? func) {
+        public override void register_key_func (uint keyval,
+                                                KeyButtonCallback? func)
+        {
             uchar keycode;
             uint modmask;
 
@@ -349,7 +336,9 @@ namespace Caribou {
             }
         }
 
-        public void register_button_func (uint button, KeyButtonCallback? func) {
+        public override void register_button_func (uint button,
+                                                   KeyButtonCallback? func)
+        {
             if (func != null) {
                 var handler = new KeyButtonHandler (func);
                 button_funcs.set (button, handler);
@@ -363,6 +352,5 @@ namespace Caribou {
                 xdisplay.ungrab_button (button, 0, xid);
             }
         }
-
     }
 }