Move symbol-index property per-element instead of per-keyboard.

eek/eek-element.c

@@ -34,15 +34,25 @@
 
 #include "eek-element.h"
 #include "eek-container.h"
+#include "eek-marshalers.h"
 #include "eek-serializable.h"
 
 enum {
     PROP_0,
     PROP_NAME,
     PROP_BOUNDS,
+    PROP_GROUP,
+    PROP_LEVEL,
     PROP_LAST
 };
 
+enum {
+    SYMBOL_INDEX_CHANGED,
+    LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0, };
+
 static void eek_serializable_iface_init (EekSerializableIface *iface);
 
 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (EekElement, eek_element, G_TYPE_OBJECT,
@@ -58,6 +68,8 @@ struct _EekElementPrivate
     gchar *name;
     EekBounds bounds;
     EekElement *parent;
+    gint group;
+    gint level;
 };
 
 static GVariant *
@@ -182,6 +194,41 @@ eek_element_real_get_bounds (EekElement *self,
     g_object_notify (G_OBJECT(self), "bounds");
 }
 
+static void
+eek_element_real_set_symbol_index (EekElement *self,
+                                   gint        group,
+                                   gint        level)
+{
+    EekElementPrivate *priv = EEK_ELEMENT_GET_PRIVATE(self);
+
+    if (priv->group != group || priv->level != level) {
+        priv->group = group;
+        priv->level = level;
+        g_signal_emit_by_name (self, "symbol-index-changed", group, level);
+    }
+}
+
+static void
+eek_element_real_get_symbol_index (EekElement *self,
+                                   gint       *group,
+                                   gint       *level)
+{
+    EekElementPrivate *priv = EEK_ELEMENT_GET_PRIVATE(self);
+
+    if (group)
+        *group = priv->group;
+    if (level)
+        *level = priv->level;
+}
+
+static void
+eek_element_real_symbol_index_changed (EekElement *self,
+                                       gint        group,
+                                       gint        level)
+{
+    // g_debug ("symbol-index-changed");
+}
+
 static void
 eek_element_finalize (GObject *object)
 {
@@ -206,6 +253,13 @@ eek_element_set_property (GObject      *object,
         eek_element_set_bounds (EEK_ELEMENT(object),
                                 g_value_get_boxed (value));
         break;
+    case PROP_GROUP:
+        eek_element_set_group (EEK_ELEMENT(object),
+                               g_value_get_int (value));
+        break;
+    case PROP_LEVEL:
+        eek_element_set_level (EEK_ELEMENT(object),
+                               g_value_get_int (value));
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -228,6 +282,12 @@ eek_element_get_property (GObject    *object,
         eek_element_get_bounds (EEK_ELEMENT(object), &bounds);
         g_value_set_boxed (value, &bounds);
         break;
+    case PROP_GROUP:
+        g_value_set_int (value, eek_element_get_group (EEK_ELEMENT(object)));
+        break;
+    case PROP_LEVEL:
+        g_value_set_int (value, eek_element_get_level (EEK_ELEMENT(object)));
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -249,6 +309,11 @@ eek_element_class_init (EekElementClass *klass)
     klass->get_name = eek_element_real_get_name;
     klass->set_bounds = eek_element_real_set_bounds;
     klass->get_bounds = eek_element_real_get_bounds;
+    klass->set_symbol_index = eek_element_real_set_symbol_index;
+    klass->get_symbol_index = eek_element_real_get_symbol_index;
+
+    /* signals */
+    klass->symbol_index_changed = eek_element_real_symbol_index_changed;
 
     gobject_class->set_property = eek_element_set_property;
     gobject_class->get_property = eek_element_get_property;
@@ -281,6 +346,56 @@ eek_element_class_init (EekElementClass *klass)
     g_object_class_install_property (gobject_class,
                                      PROP_BOUNDS,
                                      pspec);
+
+    /**
+     * EekElement:group:
+     *
+     * The group value of the symbol index of #EekElement.
+     */
+    pspec = g_param_spec_int ("group",
+                              "Group",
+                              "Group value of the symbol index",
+                              -1, G_MAXINT, -1,
+                              G_PARAM_READWRITE);
+    g_object_class_install_property (gobject_class,
+                                     PROP_GROUP,
+                                     pspec);
+
+    /**
+     * EekElement:level:
+     *
+     * The level value of the symbol index of #EekElement.
+     */
+    pspec = g_param_spec_int ("level",
+                              "Level",
+                              "Level value of the symbol index",
+                              -1, G_MAXINT, -1,
+                              G_PARAM_READWRITE);
+    g_object_class_install_property (gobject_class,
+                                     PROP_LEVEL,
+                                     pspec);
+
+    /**
+     * EekElement::symbol-index-changed:
+     * @element: an #EekElement
+     * @group: row index of the symbol matrix of keys on @element
+     * @level: column index of the symbol matrix of keys on @element
+     *
+     * The ::symbol-index-changed signal is emitted each time the
+     * global configuration of group/level index changes.
+     */
+    signals[SYMBOL_INDEX_CHANGED] =
+        g_signal_new (I_("symbol-index-changed"),
+                      G_TYPE_FROM_CLASS(gobject_class),
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(EekElementClass, symbol_index_changed),
+                      NULL,
+                      NULL,
+                      _eek_marshal_VOID__INT_INT,
+                      G_TYPE_NONE,
+                      2,
+                      G_TYPE_INT,
+                      G_TYPE_INT);
 }
 
 static void
@@ -291,6 +406,8 @@ eek_element_init (EekElement *self)
     priv = self->priv = EEK_ELEMENT_GET_PRIVATE(self);
     priv->name = NULL;
     memset (&priv->bounds, 0, sizeof priv->bounds);
+    priv->group = -1;
+    priv->level = -1;
 }
 
 /**
@@ -452,3 +569,117 @@ eek_element_set_size (EekElement  *element,
     bounds.height = height;
     eek_element_set_bounds (element, &bounds);
 }
+
+/**
+ * eek_element_set_symbol_index:
+ * @element: an #EekElement
+ * @group: row index of the symbol matrix
+ * @level: column index of the symbol matrix
+ *
+ * Set the default index of the symbol matrices of @element.  The
+ * setting affects the child, if child does not have the index set, as
+ * well as this element.  To unset, pass -1 as group/level.
+ */
+void
+eek_element_set_symbol_index (EekElement *element,
+                              gint        group,
+                              gint        level)
+{
+    g_return_if_fail (EEK_IS_ELEMENT(element));
+    EEK_ELEMENT_GET_CLASS(element)->set_symbol_index (element, group, level);
+}
+
+/**
+ * eek_element_get_symbol_index:
+ * @element: an #EekElement
+ * @group: a pointer where the group value of the symbol index will be stored
+ * @level: a pointer where the level value of the symbol index will be stored
+ *
+ * Get the default index of the symbol matrices of @element.
+ * If the index is not set, -1 will be returned.
+ */
+void
+eek_element_get_symbol_index (EekElement *element,
+                              gint       *group,
+                              gint       *level)
+{
+    g_return_if_fail (EEK_IS_ELEMENT(element));
+    g_return_if_fail (group || level);
+    EEK_ELEMENT_GET_CLASS(element)->get_symbol_index (element, group, level);
+}
+
+/**
+ * eek_element_set_group:
+ * @element: an #EekElement
+ * @group: group index of @element
+ *
+ * Set the group value of the default symbol index of @element.  To
+ * unset, pass -1 as @group.
+ *
+ * See also: eek_element_set_symbol_index()
+ */
+void
+eek_element_set_group (EekElement *element,
+                       gint        group)
+{
+    gint level;
+
+    level = eek_element_get_level (element);
+    eek_element_set_symbol_index (element, group, level);
+}
+
+/**
+ * eek_element_set_level:
+ * @element: an #EekElement
+ * @level: level index of @element
+ *
+ * Set the level value of the default symbol index of @element.  To
+ * unset, pass -1 as @level.
+ *
+ * See also: eek_element_set_symbol_index()
+ */
+void
+eek_element_set_level (EekElement *element,
+                       gint        level)
+{
+    gint group;
+
+    group = eek_element_get_group (element);
+    eek_element_set_symbol_index (element, group, level);
+}
+
+/**
+ * eek_element_get_group:
+ * @element: an #EekElement
+ *
+ * Return the group value of the default symbol index of @element.
+ * If the value is not set, -1 will be returned.
+ *
+ * See also: eek_element_get_symbol_index()
+ */
+gint
+eek_element_get_group (EekElement *element)
+{
+    gint group;
+
+    eek_element_get_symbol_index (element, &group, NULL);
+    return group;
+}
+
+/**
+ * eek_element_get_level:
+ * @element: an #EekElement
+ *
+ * Return the level value of the default symbol index of @element.
+ * If the value is not set, -1 will be returned.
+ *
+ * See also: eek_element_get_symbol_index()
+ */
+gint
+eek_element_get_level (EekElement *element)
+{
+    gint level;
+
+    eek_element_get_symbol_index (element, NULL, &level);
+    return level;
+}

eek/eek-element.h

@@ -60,9 +60,21 @@ struct _EekElementClass
     void                  (* get_bounds)           (EekElement  *self,
                                                     EekBounds   *bounds);
 
+    void                  (* set_symbol_index)     (EekElement  *self,
+                                                    gint         group,
+                                                    gint         level);
+    void                  (* get_symbol_index)     (EekElement  *self,
+                                                    gint        *group,
+                                                    gint        *level);
+
+    /* signals */
+    void                  (* symbol_index_changed) (EekElement  *self,
+                                                    gint         group,
+                                                    gint         level);
+
     /*< private >*/
     /* padding */
-    gpointer pdummy[24];
+    gpointer pdummy[21];
 };
 
 GType                 eek_element_get_type              (void) G_GNUC_CONST;
@@ -92,5 +104,18 @@ void                  eek_element_get_absolute_position (EekElement  *element,
                                                          gdouble     *x,
                                                          gdouble     *y);
 
+void                  eek_element_set_symbol_index      (EekElement  *element,
+                                                         gint         group,
+                                                         gint         level);
+void                  eek_element_get_symbol_index      (EekElement  *element,
+                                                         gint        *group,
+                                                         gint        *level);
+void                  eek_element_set_group             (EekElement  *element,
+                                                         gint         group);
+void                  eek_element_set_level             (EekElement  *element,
+                                                         gint         level);
+gint                  eek_element_get_group             (EekElement  *element);
+gint                  eek_element_get_level             (EekElement  *element);
+
 G_END_DECLS
 #endif  /* EEK_ELEMENT_H */

eek/eek-key.c

@@ -550,20 +550,6 @@ eek_key_get_symbol_matrix (EekKey *key)
     return EEK_KEY_GET_CLASS(key)->get_symbol_matrix (key);
 }
 
-static EekKeyboard *
-get_keyboard (EekKey *key)
-{
-    EekElement *parent;
-
-    parent = eek_element_get_parent (EEK_ELEMENT(key));
-    g_return_val_if_fail (EEK_IS_SECTION(parent), NULL);
-
-    parent = eek_element_get_parent (parent);
-    g_return_val_if_fail (EEK_IS_KEYBOARD(parent), NULL);
-
-    return EEK_KEYBOARD(parent);
-}
-
 /**
  * eek_key_get_symbol:
  * @key: an #EekKey
@@ -592,14 +578,38 @@ eek_key_get_symbol_with_fallback (EekKey *key,
                                   gint    fallback_level)
 {
     gint group, level;
-    EekKeyboard *keyboard;
 
     g_return_val_if_fail (EEK_IS_KEY (key), NULL);
+    g_return_val_if_fail (fallback_group >= 0, NULL);
+    g_return_val_if_fail (fallback_level >= 0, NULL);
 
-    keyboard = get_keyboard (key);
+    eek_element_get_symbol_index (EEK_ELEMENT(key), &group, &level);
-    g_return_val_if_fail (keyboard, NULL);
+
+    if (group < 0 || level < 0) {
+        EekElement *section;
+
+        section = eek_element_get_parent (EEK_ELEMENT(key));
+        g_return_val_if_fail (EEK_IS_SECTION (section), NULL);
+
+        if (group < 0)
+            group = eek_element_get_group (section);
+
+        if (level < 0)
+            level = eek_element_get_level (section);
+
+        if (group < 0 || level < 0) {
+            EekElement *keyboard;
+
+            keyboard = eek_element_get_parent (section);
+            g_return_val_if_fail (EEK_IS_KEYBOARD (keyboard), NULL);
+
+            if (group < 0)
+                group = eek_element_get_group (keyboard);
+            if (level < 0)
+                level = eek_element_get_level (keyboard);
+        }
+    }
 
-    eek_keyboard_get_symbol_index (keyboard, &group, &level);
     return eek_key_get_symbol_at_index (key,
                                         group,
                                         level,
@@ -628,8 +638,13 @@ eek_key_get_symbol_at_index (EekKey *key,
     EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(key);
     gint num_symbols;
 
-    g_return_val_if_fail (group >= 0, NULL);
+    g_return_val_if_fail (fallback_group >= 0, NULL);
-    g_return_val_if_fail (level >= 0, NULL);
+    g_return_val_if_fail (fallback_level >= 0, NULL);
+
+    if (group < 0)
+        group = fallback_group;
+    if (level < 0)
+        level = fallback_level;
 
     if (!priv->symbol_matrix)
         return NULL;

eek/eek-keyboard.c

@@ -35,13 +35,10 @@
 #include "eek-section.h"
 #include "eek-key.h"
 #include "eek-symbol.h"
-#include "eek-marshalers.h"
 #include "eek-serializable.h"
 
 enum {
     PROP_0,
-    PROP_GROUP,
-    PROP_LEVEL,
     PROP_LAYOUT,
     PROP_MODIFIER_BEHAVIOR,
     PROP_LAST
@@ -50,7 +47,6 @@ enum {
 enum {
     KEY_PRESSED,
     KEY_RELEASED,
-    SYMBOL_INDEX_CHANGED,
     LAST_SIGNAL
 };
 
@@ -68,8 +64,6 @@ G_DEFINE_TYPE_WITH_CODE (EekKeyboard, eek_keyboard, EEK_TYPE_CONTAINER,
 
 struct _EekKeyboardPrivate
 {
-    gint group;
-    gint level;
     EekLayout *layout;
     EekModifierBehavior modifier_behavior;
     EekModifierType modifiers;
@@ -184,35 +178,6 @@ eek_serializable_iface_init (EekSerializableIface *iface)
     iface->deserialize = eek_keyboard_real_deserialize;
 }
 
-static void
-eek_keyboard_real_set_symbol_index (EekKeyboard *self,
-                                    gint         group,
-                                    gint         level)
-{
-    EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(self);
-
-    if (priv->group != group || priv->level != level) {
-        priv->group = group;
-        priv->level = level;
-
-        g_signal_emit_by_name (self, "symbol-index-changed", group, level);
-    }
-}
-
-void
-eek_keyboard_real_get_symbol_index (EekKeyboard *self,
-                                    gint        *group,
-                                    gint        *level)
-{
-    EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(self);
-
-    g_return_if_fail (group || level);
-    if (group)
-        *group = priv->group;
-    if (level)
-        *level = priv->level;
-}
-
 static void
 on_key_pressed (EekSection  *section,
                 EekKey      *key,
@@ -283,12 +248,6 @@ eek_keyboard_set_property (GObject      *object,
     EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(object);
 
     switch (prop_id) {
-    case PROP_GROUP:
-        eek_keyboard_set_group (EEK_KEYBOARD(object), g_value_get_int (value));
-        break;
-    case PROP_LEVEL:
-        eek_keyboard_set_level (EEK_KEYBOARD(object), g_value_get_int (value));
-        break;
     case PROP_LAYOUT:
         priv->layout = g_value_get_object (value);
         if (priv->layout)
@@ -315,14 +274,6 @@ eek_keyboard_get_property (GObject    *object,
     EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(object);
 
     switch (prop_id) {
-    case PROP_GROUP:
-        g_value_set_int (value,
-                         eek_keyboard_get_group (EEK_KEYBOARD(object)));
-        break;
-    case PROP_LEVEL:
-        g_value_set_int (value,
-                         eek_keyboard_get_level (EEK_KEYBOARD(object)));
-        break;
     case PROP_LAYOUT:
         g_value_set_object (value, priv->layout);
         break;
@@ -338,25 +289,17 @@ eek_keyboard_get_property (GObject    *object,
     }
 }
 
-static void
-eek_keyboard_real_symbol_index_changed (EekKeyboard *self,
-                                        gint         group,
-                                        gint         level)
-{
-    /* g_debug ("symbol-index-changed"); */
-}
-
 static void
 set_level_from_modifiers (EekKeyboard *self)
 {
     EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(self);
-    guint level = 0;
+    gint level = 0;
 
     if (priv->modifiers & EEK_MOD5_MASK)
         level |= 2;
     if (priv->modifiers & EEK_SHIFT_MASK)
         level |= 1;
-    eek_keyboard_set_level (self, level);
+    eek_element_set_level (EEK_ELEMENT(self), level);
 }
 
 static void
@@ -366,12 +309,10 @@ eek_keyboard_real_key_pressed (EekKeyboard *self,
     EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(self);
     EekSymbol *symbol;
     EekModifierType modifier;
+    gint group, level;
 
-    symbol = eek_key_get_symbol_at_index (key,
+    eek_element_get_symbol_index (EEK_ELEMENT(self), &group, &level);
-                                          priv->group,
+    symbol = eek_key_get_symbol_at_index (key, group, level, 0, 0);
-                                          priv->level,
-                                          0,
-                                          0);
     if (!symbol)
         return;
 
@@ -397,12 +338,10 @@ eek_keyboard_real_key_released (EekKeyboard *self,
     EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(self);
     EekSymbol *symbol;
     EekModifierType modifier;
+    gint group, level;
 
-    symbol = eek_key_get_symbol_at_index (key,
+    eek_element_get_symbol_index (EEK_ELEMENT(self), &group, &level);
-                                          priv->group,
+    symbol = eek_key_get_symbol_at_index (key, group, level, 0, 0);
-                                          priv->level,
-                                          0,
-                                          0);
     if (!symbol)
         return;
 
@@ -473,15 +412,12 @@ eek_keyboard_class_init (EekKeyboardClass *klass)
     g_type_class_add_private (gobject_class,
                               sizeof (EekKeyboardPrivate));
 
-    klass->set_symbol_index = eek_keyboard_real_set_symbol_index;
-    klass->get_symbol_index = eek_keyboard_real_get_symbol_index;
     klass->create_section = eek_keyboard_real_create_section;
     klass->find_key_by_keycode = eek_keyboard_real_find_key_by_keycode;
 
     /* signals */
     klass->key_pressed = eek_keyboard_real_key_pressed;
     klass->key_released = eek_keyboard_real_key_released;
-    klass->symbol_index_changed = eek_keyboard_real_symbol_index_changed;
 
     container_class->child_added = eek_keyboard_real_child_added;
     container_class->child_removed = eek_keyboard_real_child_removed;
@@ -491,34 +427,6 @@ eek_keyboard_class_init (EekKeyboardClass *klass)
     gobject_class->dispose = eek_keyboard_dispose;
     gobject_class->finalize = eek_keyboard_finalize;
 
-    /**
-     * EekKeyboard:group:
-     *
-     * The group (row) index of symbol matrix of #EekKeyboard.
-     */
-    pspec = g_param_spec_int ("group",
-                              "Group",
-                              "Group index of symbol matrix of the keyboard",
-                              0, G_MAXINT, 0,
-                              G_PARAM_READWRITE);
-    g_object_class_install_property (gobject_class,
-                                     PROP_GROUP,
-                                     pspec);
-
-    /**
-     * EekKeyboard:level:
-     *
-     * The level (row) index of symbol matrix of #EekKeyboard.
-     */
-    pspec = g_param_spec_int ("level",
-                              "Level",
-                              "Level index of symbol matrix of the keyboard",
-                              0, G_MAXINT, 0,
-                              G_PARAM_READWRITE);
-    g_object_class_install_property (gobject_class,
-                                     PROP_LEVEL,
-                                     pspec);
-
     /**
      * EekKeyboard:layout:
      *
@@ -586,28 +494,6 @@ eek_keyboard_class_init (EekKeyboardClass *klass)
                       G_TYPE_NONE,
                       1,
                       EEK_TYPE_KEY);
-
-    /**
-     * EekKeyboard::symbol-index-changed:
-     * @keyboard: an #EekKeyboard
-     * @group: row index of the symbol matrix of keys on @keyboard
-     * @level: column index of the symbol matrix of keys on @keyboard
-     *
-     * The ::symbol-index-changed signal is emitted each time the
-     * global configuration of group/level index changes.
-     */
-    signals[SYMBOL_INDEX_CHANGED] =
-        g_signal_new (I_("symbol-index-changed"),
-                      G_TYPE_FROM_CLASS(gobject_class),
-                      G_SIGNAL_RUN_LAST,
-                      G_STRUCT_OFFSET(EekKeyboardClass, symbol_index_changed),
-                      NULL,
-                      NULL,
-                      _eek_marshal_VOID__INT_INT,
-                      G_TYPE_NONE,
-                      2,
-                      G_TYPE_INT,
-                      G_TYPE_INT);
 }
 
 static void
@@ -616,11 +502,11 @@ eek_keyboard_init (EekKeyboard *self)
     EekKeyboardPrivate *priv;
 
     priv = self->priv = EEK_KEYBOARD_GET_PRIVATE(self);
-    priv->group = priv->level = 0;
     priv->layout = NULL;
     priv->modifier_behavior = EEK_MODIFIER_BEHAVIOR_NONE;
     priv->modifiers = 0;
     priv->outline_array = g_array_new (FALSE, TRUE, sizeof (EekOutline));
+    eek_element_set_symbol_index (EEK_ELEMENT(self), 0, 0);
 }
 
 /**
@@ -629,7 +515,10 @@ eek_keyboard_init (EekKeyboard *self)
  * @group: row index of the symbol matrix of keys on @keyboard
  * @level: column index of the symbol matrix of keys on @keyboard
  *
- * Select a cell of the symbol matrix of each key on @keyboard.
+ * Set the default index of the symbol matrices of keys in @keyboard.
+ * To unset, pass -1 as group/level.
+ *
+ * Deprecated: 1.0: Use eek_element_set_symbol_index()
  */
 void
 eek_keyboard_set_symbol_index (EekKeyboard *keyboard,
@@ -637,18 +526,19 @@ eek_keyboard_set_symbol_index (EekKeyboard *keyboard,
                                gint         level)
 {
     g_return_if_fail (EEK_IS_KEYBOARD(keyboard));
-    EEK_KEYBOARD_GET_CLASS(keyboard)->set_symbol_index (keyboard, group, level);
+    eek_element_set_symbol_index (EEK_ELEMENT(keyboard), group, level);
 }
 
 /**
  * eek_keyboard_get_symbol_index:
  * @keyboard: an #EekKeyboard
- * @group: a pointer where row index of the symbol matrix of keys on
+ * @group: a pointer where the group value of the symbol index will be stored
- * @keyboard will be stored
+ * @level: a pointer where the level value of the symbol index will be stored
- * @level: a pointer where column index of the symbol matrix of keys
- * on @keyboard will be stored
  *
- * Get the current cell position of the symbol matrix of each key on @keyboard.
+ * Get the default index of the symbol matrices of keys in @keyboard.
+ * If the index is not set, -1 will be returned.
+ *
+ * Deprecated: 1.0: Use eek_element_get_symbol_index()
  */
 void
 eek_keyboard_get_symbol_index (EekKeyboard *keyboard,
@@ -656,7 +546,7 @@ eek_keyboard_get_symbol_index (EekKeyboard *keyboard,
                                gint        *level)
 {
     g_return_if_fail (EEK_IS_KEYBOARD(keyboard));
-    EEK_KEYBOARD_GET_CLASS(keyboard)->get_symbol_index (keyboard, group, level);
+    eek_element_get_symbol_index(EEK_ELEMENT(keyboard), group, level);
 }
 
 /**
@@ -664,14 +554,17 @@ eek_keyboard_get_symbol_index (EekKeyboard *keyboard,
  * @keyboard: an #EekKeyboard
  * @group: group index of @keyboard
  *
- * Set the group index of symbol matrix of @keyboard.
+ * Set the group value of the default symbol index of @keyboard.  To
+ * unset, pass -1 as @group.
+ *
+ * See also: eek_keyboard_set_symbol_index()
+ * Deprecated: 1.0: Use eek_element_set_group()
  */
 void
 eek_keyboard_set_group (EekKeyboard *keyboard,
                         gint         group)
 {
-    gint level = eek_keyboard_get_level (keyboard);
+    eek_element_set_group (EEK_ELEMENT(keyboard), group);
-    eek_keyboard_set_symbol_index (keyboard, group, level);
 }
 
 /**
@@ -679,42 +572,49 @@ eek_keyboard_set_group (EekKeyboard *keyboard,
  * @keyboard: an #EekKeyboard
  * @level: level index of @keyboard
  *
- * Set the level index of symbol matrix of @keyboard.
+ * Set the level value of the default symbol index of @keyboard.  To
+ * unset, pass -1 as @level.
+ *
+ * See also: eek_keyboard_set_symbol_index()
+ * Deprecated: 1.0: Use eek_element_set_level()
  */
 void
 eek_keyboard_set_level (EekKeyboard *keyboard,
                         gint         level)
 {
-    gint group = eek_keyboard_get_group (keyboard);
+    eek_element_set_level (EEK_ELEMENT(keyboard), level);
-    eek_keyboard_set_symbol_index (keyboard, group, level);
 }
 
 /**
  * eek_keyboard_get_group:
  * @keyboard: an #EekKeyboard
  *
- * Return the group index of @keyboard.
+ * Return the group value of the default symbol index of @keyboard.
+ * If the value is not set, -1 will be returned.
+ *
+ * See also: eek_keyboard_get_symbol_index()
+ * Deprecated: 1.0: Use eek_element_get_group()
  */
 gint
 eek_keyboard_get_group (EekKeyboard *keyboard)
 {
-    gint group;
+    return eek_element_get_group (EEK_ELEMENT(keyboard));
-    eek_keyboard_get_symbol_index (keyboard, &group, NULL);
-    return group;
 }
 
 /**
  * eek_keyboard_get_level:
  * @keyboard: an #EekKeyboard
  *
- * Return the level index of @keyboard.
+ * Return the level value of the default symbol index of @keyboard.
+ * If the value is not set, -1 will be returned.
+ *
+ * See also: eek_keyboard_get_symbol_index()
+ * Deprecated: 1.0: Use eek_element_get_level()
  */
 gint
 eek_keyboard_get_level (EekKeyboard *keyboard)
 {
-    gint level;
+    return eek_element_get_level (EEK_ELEMENT(keyboard));
-    eek_keyboard_get_symbol_index (keyboard, NULL, &level);
-    return level;
 }
 
 /**

eek/eek-keyboard.h

@@ -53,30 +53,22 @@ struct _EekKeyboard
 
 /**
  * EekKeyboardClass:
- * @set_symbol_index: virtual function for setting group and level of
- * the entire keyboard
- * @get_symbol_index: virtual function for getting group and level of
- * the entire keyboard
  * @create_section: virtual function for creating a section
  * @find_key_by_keycode: virtual function for finding a key in the
  * keyboard by keycode
  * @key_pressed: class handler for #EekKeyboard::key-pressed signal
  * @key_released: class handler for #EekKeyboard::key-released signal
- * @symbol_index_changed: class handler for #EekKeyboard::symbol-index-changed signal
  */
 struct _EekKeyboardClass
 {
     /*< private >*/
     EekContainerClass parent_class;
 
-    /*< public >*/
+    /* obsolete members moved to EekElement */
-    void        (* set_symbol_index)     (EekKeyboard *self,
+    gpointer set_symbol_index;
-                                          gint         group,
+    gpointer get_symbol_index;
-                                          gint         level);
-    void        (* get_symbol_index)     (EekKeyboard *self,
-                                          gint        *group,
-                                          gint        *level);
 
+    /*< public >*/
     EekSection *(* create_section)       (EekKeyboard *self);
 
     EekKey     *(* find_key_by_keycode)  (EekKeyboard *self,
@@ -87,11 +79,11 @@ struct _EekKeyboardClass
                                           EekKey      *key);
     void        (* key_released)         (EekKeyboard *self,
                                           EekKey      *key);
-    void        (* symbol_index_changed) (EekKeyboard *self,
-                                          gint         group,
-                                          gint         level);
 
     /*< private >*/
+    /* obsolete members moved to EekElement */
+    gpointer symbol_index_changed;
+
     /* padding */
     gpointer pdummy[24];
 };

eekboard/eekboard-context.c

@@ -501,9 +501,8 @@ eekboard_context_set_group (EekboardContext *context,
     priv = EEKBOARD_CONTEXT_GET_PRIVATE (context);
 
     g_return_if_fail (priv->keyboard);
-    g_return_if_fail (group >= 0);
 
-    eek_keyboard_set_group (priv->keyboard, group);
+    eek_element_set_group (EEK_ELEMENT(priv->keyboard), group);
     g_dbus_proxy_call (G_DBUS_PROXY(context),
                        "SetGroup",
                        g_variant_new ("(i)", group),

src/desktop-client.c

@@ -504,7 +504,7 @@ on_xkl_state_changed (XklEngine           *xklengine,
     EekboardDesktopClient *client = user_data;
 
     if (type == GROUP_CHANGED && client->keyboard) {
-        gint group = eek_keyboard_get_group (client->keyboard);
+        gint group = eek_element_get_group (EEK_ELEMENT(client->keyboard));
         if (group != value) {
             eekboard_context_set_group (client->context, value, NULL);
         }

src/server-context.c

@@ -574,7 +574,7 @@ handle_method_call (GDBusConnection       *connection,
         }
 
         g_variant_get (parameters, "(i)", &group);
-        eek_keyboard_set_group (context->keyboard, group);
+        eek_element_set_group (EEK_ELEMENT(context->keyboard), group);
 
         if (context->window) {
             gboolean was_visible = gtk_widget_get_visible (context->window);

src/xml-main.c

@@ -113,7 +113,7 @@ main (int argc, char **argv)
         keyboard = eek_keyboard_new (layout, 640, 480);
         g_object_unref (layout);
 
-        eek_keyboard_set_group (keyboard, opt_group);
+        eek_element_set_group (EEK_ELEMENT(keyboard), opt_group);
 
         widget = eek_gtk_keyboard_new (keyboard);
         g_object_unref (keyboard);