s3rius/squeekboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrite.

Browse Source
This commit is contained in:
Daiki Ueno
2010-06-09 16:44:26 +09:00
parent 9e61919384
commit 662f619ba2
53 changed files with 2653 additions and 4894 deletions
Download Patch File Download Diff File Expand all files Collapse all files

797
eek/eek-key.c
View File

@ -20,408 +20,549 @@
/**
* SECTION:eek-key
* @short_description: Base interface of a key
* @see_also: #EekSection
* @short_description: Base class of a key
*
* The #EekKeyIface interface represents a key, which is parented to
* #EekSectionIface.
* The #EekKeyClass class represents a key.
*/
#include <string.h>
#define DEBUG 0
#if DEBUG
#include <stdio.h>
#endif
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#include "eek-key.h"
#include "eek-keysym.h"
enum {
PROP_0,
PROP_KEYCODE,
PROP_KEYSYMS,
PROP_COLUMN,
PROP_ROW,
PROP_OUTLINE,
PROP_GROUP,
PROP_LEVEL,
PROP_LAST
};
enum {
PRESSED,
RELEASED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE (EekKey, eek_key, EEK_TYPE_ELEMENT);
#define EEK_KEY_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), EEK_TYPE_KEY, EekKeyPrivate))
struct _EekKeyPrivate
{
guint keycode;
EekKeysymMatrix keysyms;
gint column;
gint row;
EekOutline *outline;
gint group;
gint level;
};
static void
eek_key_base_init (gpointer g_iface)
eek_key_real_set_keycode (EekKey *self, guint keycode)
{
static gboolean is_initialized = FALSE;
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
priv->keycode = keycode;
}
if (!is_initialized) {
GParamSpec *pspec;
static guint
eek_key_real_get_keycode (EekKey *self)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
return priv->keycode;
}
/**
* EekKey:name:
*
* The name of #EekKey.
*/
pspec = g_param_spec_string ("name",
"Name",
"Name",
NULL,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
static void
eek_key_real_set_keysyms (EekKey *self,
guint *keysyms,
gint num_groups,
gint num_levels)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
gint num_keysyms = num_groups * num_levels;
if (num_keysyms > 0) {
priv->keysyms.data =
g_slice_alloc (num_keysyms * sizeof(guint));
memcpy (priv->keysyms.data, keysyms,
num_keysyms * sizeof(guint));
}
priv->keysyms.num_groups = num_groups;
priv->keysyms.num_levels = num_levels;
/**
* EekKey:keycode:
*
* The keycode of #EekKey.
*/
pspec = g_param_spec_uint ("keycode",
"Keycode",
"Keycode of the key",
0, G_MAXUINT, 0,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
#if DEBUG
{
const gchar *name;
gint i;
/**
* EekKey:keysyms:
*
* The symbol matrix of #EekKey.
*/
pspec = g_param_spec_boxed ("keysyms",
"Keysyms",
"Symbol matrix of the key",
EEK_TYPE_KEYSYM_MATRIX,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
name = eek_element_get_name (EEK_ELEMENT(self));
fprintf (stderr, "%s: ", name);
for (i = 0; i < priv->keysyms.num_groups * priv->keysyms.num_levels; i++)
fprintf (stderr, "\"%s\" ", eek_keysym_to_string (priv->keysyms.data[i]));
fprintf (stderr, "\n");
}
#endif
}
/**
* EekKey:column:
*
* The column index of #EekKey in the parent #EekSection.
*/
pspec = g_param_spec_int ("column",
"Column",
"Column index of the key in section",
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
static void
eek_key_real_get_keysyms (EekKey *self,
guint **keysyms,
gint *num_groups,
gint *num_levels)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
gint num_keysyms = priv->keysyms.num_groups * priv->keysyms.num_levels;
/**
* EekKey:row:
*
* The row index of #EekKey in the parent #EekSection.
*/
pspec = g_param_spec_int ("row",
"Row",
"Row index of the key in section",
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
/**
* EekKey:outline:
*
* The pointer to the outline shape of #EekKey.
*/
/* Use pointer instead of boxed to avoid copy, since we can
assume that only a few outline shapes are used in a whole
keyboard (unlike keysyms and bounds). */
pspec = g_param_spec_pointer ("outline",
"Outline",
"Pointer to outline shape of the key",
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
/**
* EekKey:bounds:
*
* The bounding box of #EekKey.
*/
pspec = g_param_spec_boxed ("bounds",
"Bounds",
"Bounding box of the key",
EEK_TYPE_BOUNDS,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
/**
* EekKey:group:
*
* The column index of #EekKey in the symbol matrix #EekKey:keysyms.
*/
pspec = g_param_spec_int ("group",
"Group",
"Current group of the key",
0, 64, 0,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
/**
* EekKey:level:
*
* The row index of #EekKey in the symbol matrix #EekKey:keysyms.
*/
pspec = g_param_spec_int ("level",
"Level",
"Current level of the key",
0, 3, 0,
G_PARAM_READWRITE);
g_object_interface_install_property (g_iface, pspec);
is_initialized = TRUE;
if (num_groups)
*num_groups = priv->keysyms.num_groups;
if (num_levels)
*num_levels = priv->keysyms.num_levels;
if (keysyms && num_keysyms > 0) {
*keysyms = g_slice_alloc (num_keysyms * sizeof(guint));
memcpy (*keysyms, priv->keysyms.data, num_keysyms * sizeof(guint));
}
}
GType
eek_key_get_type (void)
static guint
eek_key_real_get_keysym (EekKey *self)
{
static GType iface_type = 0;
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
gint num_keysyms = priv->keysyms.num_groups * priv->keysyms.num_levels;
if (iface_type == 0) {
static const GTypeInfo info = {
sizeof (EekKeyIface),
eek_key_base_init, /* iface_base_init */
NULL /* iface_base_finalize */
};
iface_type = g_type_register_static (G_TYPE_INTERFACE,
"EekKey",
&info,
0);
}
return iface_type;
if (num_keysyms == 0)
return EEK_INVALID_KEYSYM;
return priv->keysyms.data[priv->group * priv->keysyms.num_levels +
priv->level];
}
static void
eek_key_real_set_index (EekKey *self,
gint column,
gint row)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
g_return_if_fail (0 <= column);
g_return_if_fail (0 <= row);
priv->column = column;
priv->row = row;
}
static void
eek_key_real_get_index (EekKey *self,
gint *column,
gint *row)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
if (column)
*column = priv->column;
if (row)
*row = priv->row;
}
static void
eek_key_real_set_outline (EekKey *self, EekOutline *outline)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
priv->outline = outline;
}
static EekOutline *
eek_key_real_get_outline (EekKey *self)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
return priv->outline;
}
static void
eek_key_real_set_keysym_index (EekKey *self,
gint group,
gint level)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
g_return_if_fail (0 <= group);
if (group >= priv->keysyms.num_groups)
group = 0;
g_return_if_fail (0 <= level && level < priv->keysyms.num_levels);
priv->group = group;
priv->level = level;
}
static void
eek_key_real_get_keysym_index (EekKey *self,
gint *group,
gint *level)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
g_return_if_fail (group);
g_return_if_fail (level);
if (group)
*group = priv->group;
if (level)
*level = priv->level;
}
static void
eek_key_finalize (GObject *object)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(object);
gint num_keysyms = priv->keysyms.num_groups * priv->keysyms.num_levels;
g_slice_free1 (num_keysyms * sizeof (guint), priv->keysyms.data);
G_OBJECT_CLASS (eek_key_parent_class)->finalize (object);
}
static void
eek_key_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
EekKeysymMatrix *matrix;
gint column, row;
gint group, level;
g_return_if_fail (EEK_IS_KEY(object));
switch (prop_id) {
case PROP_KEYCODE:
eek_key_set_keycode (EEK_KEY(object), g_value_get_uint (value));
break;
case PROP_KEYSYMS:
matrix = g_value_get_boxed (value);
eek_key_set_keysyms (EEK_KEY(object),
matrix->data,
matrix->num_groups,
matrix->num_levels);
break;
case PROP_COLUMN:
eek_key_get_index (EEK_KEY(object), &column, &row);
eek_key_set_index (EEK_KEY(object), g_value_get_int (value), row);
break;
case PROP_ROW:
eek_key_get_index (EEK_KEY(object), &column, &row);
eek_key_set_index (EEK_KEY(object), column, g_value_get_int (value));
break;
case PROP_OUTLINE:
eek_key_set_outline (EEK_KEY(object), g_value_get_pointer (value));
break;
case PROP_GROUP:
eek_key_get_keysym_index (EEK_KEY(object), &group, &level);
eek_key_set_keysym_index (EEK_KEY(object), g_value_get_int (value),
level);
break;
case PROP_LEVEL:
eek_key_get_keysym_index (EEK_KEY(object), &group, &level);
eek_key_set_keysym_index (EEK_KEY(object), group,
g_value_get_int (value));
break;
default:
g_object_set_property (object,
g_param_spec_get_name (pspec),
value);
break;
}
}
static void
eek_key_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
EekKeysymMatrix matrix;
gint column, row;
gint group, level;
g_return_if_fail (EEK_IS_KEY(object));
switch (prop_id) {
case PROP_KEYCODE:
g_value_set_uint (value, eek_key_get_keycode (EEK_KEY(object)));
break;
case PROP_KEYSYMS:
eek_key_get_keysyms (EEK_KEY(object), &matrix.data, &matrix.num_groups,
&matrix.num_levels);
g_value_set_boxed (value, &matrix);
break;
case PROP_COLUMN:
eek_key_get_index (EEK_KEY(object), &column, &row);
g_value_set_int (value, column);
break;
case PROP_ROW:
eek_key_get_index (EEK_KEY(object), &column, &row);
g_value_set_int (value, row);
break;
case PROP_OUTLINE:
g_value_set_pointer (value, eek_key_get_outline (EEK_KEY(object)));
break;
case PROP_GROUP:
eek_key_get_keysym_index (EEK_KEY(object), &group, &level);
g_value_set_int (value, group);
break;
case PROP_LEVEL:
eek_key_get_keysym_index (EEK_KEY(object), &group, &level);
g_value_set_int (value, level);
break;
default:
g_object_get_property (object,
g_param_spec_get_name (pspec),
value);
break;
}
}
static void
eek_key_class_init (EekKeyClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GParamSpec *pspec;
g_type_class_add_private (gobject_class,
sizeof (EekKeyPrivate));
klass->get_keycode = eek_key_real_get_keycode;
klass->set_keycode = eek_key_real_set_keycode;
klass->set_keysyms = eek_key_real_set_keysyms;
klass->get_keysyms = eek_key_real_get_keysyms;
klass->get_keysym = eek_key_real_get_keysym;
klass->set_index = eek_key_real_set_index;
klass->get_index = eek_key_real_get_index;
klass->set_outline = eek_key_real_set_outline;
klass->get_outline = eek_key_real_get_outline;
klass->set_keysym_index = eek_key_real_set_keysym_index;
klass->get_keysym_index = eek_key_real_get_keysym_index;
gobject_class->set_property = eek_key_set_property;
gobject_class->get_property = eek_key_get_property;
gobject_class->finalize = eek_key_finalize;
/**
* EekKey:keycode:
*
* The keycode of #EekKey.
*/
pspec = g_param_spec_uint ("keycode",
"Keycode",
"Keycode of the key",
0, G_MAXUINT, 0,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_KEYCODE, pspec);
/**
* EekKey:keysyms:
*
* The symbol matrix of #EekKey.
*/
pspec = g_param_spec_boxed ("keysyms",
"Keysyms",
"Symbol matrix of the key",
EEK_TYPE_KEYSYM_MATRIX,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_KEYSYMS, pspec);
/**
* EekKey:column:
*
* The column index of #EekKey in the parent #EekSection.
*/
pspec = g_param_spec_int ("column",
"Column",
"Column index of the key in section",
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_COLUMN, pspec);
/**
* EekKey:row:
*
* The row index of #EekKey in the parent #EekSection.
*/
pspec = g_param_spec_int ("row",
"Row",
"Row index of the key in section",
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_ROW, pspec);
/**
* EekKey:outline:
*
* The pointer to the outline shape of #EekKey.
*/
/* Use pointer instead of boxed to avoid copy, since we can
assume that only a few outline shapes are used in a whole
keyboard (unlike keysyms and bounds). */
pspec = g_param_spec_pointer ("outline",
"Outline",
"Pointer to outline shape of the key",
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_OUTLINE, pspec);
/**
* EekKey:group:
*
* The column index of #EekKey in the symbol matrix #EekKey:keysyms.
*/
pspec = g_param_spec_int ("group",
"Group",
"Current group of the key",
0, 64, 0,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_GROUP, pspec);
/**
* EekKey:level:
*
* The row index of #EekKey in the symbol matrix #EekKey:keysyms.
*/
pspec = g_param_spec_int ("level",
"Level",
"Current level of the key",
0, 3, 0,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_LEVEL, pspec);
signals[PRESSED] =
g_signal_new ("pressed",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[RELEASED] =
g_signal_new ("released",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
eek_key_init (EekKey *self)
{
EekKeyPrivate *priv;
priv = self->priv = EEK_KEY_GET_PRIVATE(self);
priv->keycode = 0;
memset (&priv->keysyms, 0, sizeof priv->keysyms);
priv->column = priv->row = 0;
priv->outline = NULL;
priv->group = priv->level = 0;
}
void
eek_key_set_keycode (EekKey *key,
guint keycode)
{
g_return_if_fail (EEK_IS_KEY (key));
EEK_KEY_GET_CLASS(key)->set_keycode (key, keycode);
}
/**
* eek_key_get_keycode:
* @key: an #EekKey
*
* Get the keycode of @key.
*/
guint
eek_key_get_keycode (EekKey *key)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_val_if_fail (iface, EEK_INVALID_KEYCODE);
g_return_val_if_fail (iface->get_keycode, EEK_INVALID_KEYCODE);
return (*iface->get_keycode) (key);
g_return_val_if_fail (EEK_IS_KEY (key), EEK_INVALID_KEYCODE);
return EEK_KEY_GET_CLASS(key)->get_keycode (key);
}
/**
* eek_key_set_keysyms:
* @key: an #EekKey
* @keysyms: symbol matrix of @key
* @num_groups: the number of groups (rows) of @keysyms
* @num_levels: the number of levels (columns) of @keysyms
*
* Set the symbol matrix of @key to @keysyms. @keysyms is an array of
* symbols (unsigned int) and the length must match with @num_groups *
* @num_levels.
*/
void
eek_key_set_keysyms (EekKey *key,
guint *keysyms,
gint num_groups,
gint num_levels)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->set_keysyms);
(*iface->set_keysyms) (key, keysyms, num_groups, num_levels);
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->set_keysyms (key, keysyms, num_groups, num_levels);
}
/**
* eek_key_get_keysyms:
* @key: an #EekKey
* @keysyms: pointer where symbol matrix of @key will be stored
* @num_groups: pointer where the number of groups (rows) of @keysyms
* will be stored
* @num_levels: pointer where the number of levels (columns) of
* @keysyms will be stored
*
* Get the symbol matrix of @key to @keysyms. @keysyms is an array of
* symbols (unsigned int) and the length must match with @num_groups *
* @num_levels.
*/
void
eek_key_get_keysyms (EekKey *key,
guint **keysyms,
gint *num_groups,
gint *num_levels)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->get_keysyms);
(*iface->get_keysyms) (key, keysyms, num_groups, num_levels);
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->get_keysyms (key, keysyms, num_groups, num_levels);
}
/**
* eek_key_get_groups:
* @key: an #EekKey
*
* Get the number of groups (rows) of the symbol matrix of @key.
*/
gint
eek_key_get_groups (EekKey *key)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_val_if_fail (iface, -1);
g_return_val_if_fail (iface->get_groups, -1);
return (*iface->get_groups) (key);
}
/**
* eek_key_get_keysym:
* @key: an #EekKey
*
* Get the current symbol of @key. It is depend on the current group
* and level, and the symbol matrix of @key. They are set through
* eek_key_set_keysym_index() and eek_key_set_keysyms(), respectively.
*/
guint
eek_key_get_keysym (EekKey *key)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_val_if_fail (iface, EEK_INVALID_KEYSYM);
g_return_val_if_fail (iface->get_keysym, EEK_INVALID_KEYSYM);
return (*iface->get_keysym) (key);
g_return_val_if_fail (EEK_IS_KEY(key), EEK_INVALID_KEYSYM);
return EEK_KEY_GET_CLASS(key)->get_keysym (key);
}
/**
* eek_key_set_index:
* @key: an #EekKey
* @column: column index in the section
* @row: row index in the section
*
* Set column and row index of @key in the parent section.
*/
void
eek_key_set_index (EekKey *key,
gint column,
gint row)
eek_key_set_index (EekKey *key,
gint column,
gint row)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->set_index);
(*iface->set_index) (key, column, row);
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->set_index (key, column, row);
}
/**
* eek_key_get_index:
* @key: an #EekKey
* @column: a pointer to where column index in the section is stored
* @row: a pointer to where row index in the section is stored
*
* Get column and row index of @key in the parent section.
*/
void
eek_key_get_index (EekKey *key,
gint *column,
gint *row)
eek_key_get_index (EekKey *key,
gint *column,
gint *row)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->get_index);
return (*iface->get_index) (key, column, row);
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->get_index (key, column, row);
}
/**
* eek_key_set_outline:
* @key: an #EekKey
* @outline: a pointer to the outline shape of @key
*
* Set outline shape of @key.
*/
void
eek_key_set_outline (EekKey *key,
EekOutline *outline)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->set_outline);
(*iface->set_outline) (key, outline);
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->set_outline (key, outline);
}
/**
* eek_key_get_outline:
* @key: an #EekKey
*
* Get outline shape of @key as a pointer.
*/
EekOutline *
eek_key_get_outline (EekKey *key)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_val_if_fail (iface, NULL);
g_return_val_if_fail (iface->get_outline, NULL);
return (*iface->get_outline) (key);
g_return_val_if_fail (EEK_IS_KEY (key), NULL);
return EEK_KEY_GET_CLASS(key)->get_outline (key);
}
/**
* eek_key_set_bounds:
* @key: an #EekKey
* @bounds: bounding box of @key
*
* Set the bounding box of @key to @bounds.
*/
void
eek_key_set_bounds (EekKey *key,
EekBounds *bounds)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->set_bounds);
(*iface->set_bounds) (key, bounds);
}
/**
* eek_key_get_bounds:
* @key: an #EekKey
* @bounds: the bounding box of @key
*
* Get the bounding box of @key.
*/
void
eek_key_get_bounds (EekKey *key,
EekBounds *bounds)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->get_bounds);
return (*iface->get_bounds) (key, bounds);
}
/**
* eek_key_set_keysym_index:
* @key: an #EekKey
* @group: row index of the symbol matrix #EekKey:keysyms
* @level: column index of the symbol matrix #EekKey:keysyms
*
* Select a cell of the symbol matrix of @key.
*/
void
eek_key_set_keysym_index (EekKey *key,
gint group,
gint level)
gint group,
gint level)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->set_keysym_index);
(*iface->set_keysym_index) (key, group, level);
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->set_keysym_index (key, group, level);
}
/**
* eek_key_get_keysym_index:
* @key: an #EekKey
* @group: a pointer where row index of the symbol matrix #EekKey:keysyms
* will be stored
* @level: a pointer where column index of the symbol matrix
* #EekKey:keysyms will be stored
*
* Get the current cell position of the symbol matrix of @key.
*/
void
eek_key_get_keysym_index (EekKey *key, gint *column, gint *row)
eek_key_get_keysym_index (EekKey *key,
gint *group,
gint *level)
{
EekKeyIface *iface = EEK_KEY_GET_IFACE(key);
g_return_if_fail (iface);
g_return_if_fail (iface->get_keysym_index);
return (*iface->get_keysym_index) (key, column, row);
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->get_keysym_index (key, group, level);
}