1namespace Caribou {
2    public delegate void KeyButtonCallback (uint keybuttoncode, bool pressed);
3
4    /**
5     * Base class of singleton object providing access to the display server.
6     */
7    public abstract class DisplayAdapter : Object {
8        /**
9         * Display instance.
10         */
11        public Gdk.Display display { get; construct; }
12
13        /**
14         * Signal emitted when modifiers have changed.
15         */
16        public signal void modifiers_changed (uint modifiers);
17
18        /**
19         * Signal emitted when the current group has changed.
20         *
21         * @param gid group index
22         * @param group group name
23         * @param variant variant name
24         */
25        public signal void group_changed (uint gid,
26                                          string group,
27                                          string variant);
28
29        /**
30         * Signal emitted when the group configuration has changed.
31         */
32        public signal void config_changed ();
33
34        /**
35         * Send key press event.
36         *
37         * @param keyval keyval
38         */
39        public abstract void keyval_press (uint keyval);
40
41        /**
42         * Send key release event.
43         *
44         * @param keyval keyval
45         */
46        public abstract void keyval_release (uint keyval);
47
48        /**
49         * Lock modifiers.
50         *
51         * @param mask modifiers
52         */
53        public abstract void mod_lock (uint mask);
54
55        /**
56         * Unlock modifiers.
57         *
58         * @param mask modifiers
59         */
60        public abstract void mod_unlock (uint mask);
61
62        /**
63         * Latch modifiers.
64         *
65         * @param mask modifiers
66         */
67        public abstract void mod_latch (uint mask);
68
69        /**
70         * Unlatch modifiers.
71         *
72         * @param mask modifiers
73         */
74        public abstract void mod_unlatch (uint mask);
75
76        /**
77         * Get the current group.
78         *
79         * @param group_name group name
80         * @param variant_name variant name
81         */
82        public abstract uint get_current_group (out string group_name,
83                                                out string variant_name);
84
85        /**
86         * Get available groups.
87         *
88         * @param group_names list of groups
89         * @param variant_names list of variants, indexed same as group_names
90         */
91        public abstract void get_groups (out string[] group_names,
92                                         out string[] variant_names);
93
94        /**
95         * Register key callback.
96         *
97         * @param keyval keyval
98         * @param func callback
99         */
100        public abstract void register_key_func (uint keyval,
101                                                KeyButtonCallback? func);
102
103        /**
104         * Register button callback.
105         *
106         * @param button button
107         * @param func callback
108         */
109        public abstract void register_button_func (uint button,
110                                                   KeyButtonCallback? func);
111
112        static DisplayAdapter instance;
113        public static bool set_default (DisplayAdapter adapter) {
114            if (instance != null)
115                return false;
116
117            instance = adapter;
118            return true;
119        }
120        public static DisplayAdapter get_default () {
121            if (instance == null) {
122                var display = Gdk.DisplayManager.get ().get_default_display ();
123                var adapter_type = typeof (NullAdapter);
124                if (display != null) {
125                    var adapters = new Gee.HashMap<Type, Type> ();
126                    adapters.set (typeof (Gdk.X11Display), typeof (XAdapter));
127
128                    var display_type = display.get_type ();
129                    if (adapters.has_key (display_type))
130                        adapter_type = adapters.get (display_type);
131                }
132                instance = (DisplayAdapter) Object.new (adapter_type,
133                                                        "display", display);
134            }
135            return instance;
136        }
137    }
138
139    public class NullAdapter : DisplayAdapter {
140        public override void keyval_press (uint keyval) {
141        }
142
143        public override void keyval_release (uint keyval) {
144        }
145
146        public override void mod_lock (uint mask) {
147        }
148
149        public override void mod_unlock (uint mask) {
150        }
151
152        public override void mod_latch (uint mask) {
153        }
154
155        public override void mod_unlatch (uint mask) {
156        }
157
158        public override uint get_current_group (out string group_name,
159                                                out string variant_name)
160        {
161            group_name = "us";
162            variant_name = "";
163            return 0;
164        }
165
166        public override void get_groups (out string[] group_names,
167                                         out string[] variant_names)
168        {
169            group_names = new string[] { "us" };
170            variant_names = new string[] { "" };
171        }
172
173        public override void register_key_func (uint keyval,
174                                                KeyButtonCallback? func)
175        {
176        }
177
178        public override void register_button_func (uint button,
179                                                   KeyButtonCallback? func)
180        {
181        }
182    }
183}
184