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

Use GObject instead of guint to represent keysyms.

Browse Source
This commit is contained in:
Daiki Ueno
2011-01-28 16:19:18 +09:00
parent 4ff254df97
commit e6df7d90fe
25 changed files with 3251 additions and 2915 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
eek/Makefile.am
View File

@ -33,8 +33,9 @@ libeek_public_headers = \
$(srcdir)/eek-keyboard.h \
$(srcdir)/eek-section.h \
$(srcdir)/eek-key.h \
$(srcdir)/eek-types.h \
$(srcdir)/eek-symbol.h \
$(srcdir)/eek-keysym.h \
$(srcdir)/eek-types.h \
$(srcdir)/eek-xml.h \
$(srcdir)/eek.h
@ -43,7 +44,7 @@ libeek_private_headers = \
$(srcdir)/eek-xml-layout.h \
$(srcdir)/eek-special-keysym-entries.h \
$(srcdir)/eek-unicode-keysym-entries.h \
$(srcdir)/eek-keyname-keysym-entries.h \
$(srcdir)/eek-xkeysym-keysym-entries.h \
$(srcdir)/eek-marshallers.h
libeek_sources = \
@ -53,8 +54,9 @@ libeek_sources = \
$(srcdir)/eek-keyboard.c \
$(srcdir)/eek-section.c \
$(srcdir)/eek-key.c \
$(srcdir)/eek-types.c \
$(srcdir)/eek-symbol.c \
$(srcdir)/eek-keysym.c \
$(srcdir)/eek-types.c \
$(srcdir)/eek-xml.c \
$(srcdir)/eek-xml-layout.c \
$(srcdir)/eek-renderer.c \
@ -63,7 +65,7 @@ libeek_sources = \
libeek_keysym_sources = \
$(srcdir)/eek-special-keysym-entries.h \
$(srcdir)/eek-unicode-keysym-entries.h \
$(srcdir)/eek-keyname-keysym-entries.h
$(srcdir)/eek-xkeysym-keysym-entries.h
libeek_enumtypes_sources = \
$(srcdir)/eek-enumtypes.c \
@ -156,8 +158,8 @@ eek-special-keysym-entries.h: special-keysym-entries.txt
$(PYTHON) ./gen-keysym-entries.py special_keysym_entries < $< > $@
eek-unicode-keysym-entries.h: unicode-keysym-entries.txt
$(PYTHON) ./gen-keysym-entries.py unicode_keysym_entries < $< > $@
eek-keyname-keysym-entries.h: keyname-keysym-entries.txt
$(PYTHON) ./gen-keysym-entries.py keyname_keysym_entries < $< > $@
eek-xkeysym-keysym-entries.h: xkeysym-keysym-entries.txt
$(PYTHON) ./gen-keysym-entries.py xkeysym_keysym_entries < $< > $@
# gen marshal
eek-marshallers.h: eek-marshallers.list
@ -190,7 +192,7 @@ EXTRA_DIST = \
gen-keysym-entries.py \
special-keysym-entries.txt \
unicode-keysym-entries.txt \
keyname-keysym-entries.txt \
xkeysym-keysym-entries.txt \
eek-marshallers.list
-include $(INTROSPECTION_MAKEFILE)

10
eek/eek-gtk-keyboard.c
View File

@ -33,7 +33,7 @@
#include "eek-keyboard.h"
#include "eek-section.h"
#include "eek-key.h"
#include "eek-keysym.h"
#include "eek-symbol.h"
enum {
PROP_0,
@ -66,7 +66,7 @@ static void on_key_pressed (EekKeyboard *keyboard,
static void on_key_released (EekKeyboard *keyboard,
EekKey *key,
gpointer user_data);
static void on_keysym_index_changed (EekKeyboard *keyboard,
static void on_symbol_index_changed (EekKeyboard *keyboard,
gint group,
gint level,
gpointer user_data);
@ -210,8 +210,8 @@ eek_gtk_keyboard_set_keyboard (EekGtkKeyboard *self,
G_CALLBACK(on_key_pressed), self);
g_signal_connect (priv->keyboard, "key-released",
G_CALLBACK(on_key_released), self);
g_signal_connect (priv->keyboard, "keysym-index-changed",
G_CALLBACK(on_keysym_index_changed), self);
g_signal_connect (priv->keyboard, "symbol-index-changed",
G_CALLBACK(on_symbol_index_changed), self);
}
static void
@ -399,7 +399,7 @@ on_key_released (EekKeyboard *keyboard,
}
static void
on_keysym_index_changed (EekKeyboard *keyboard,
on_symbol_index_changed (EekKeyboard *keyboard,
gint group,
gint level,
gpointer user_data)

184
eek/eek-key.c
View File

@ -37,12 +37,12 @@
#include "eek-key.h"
#include "eek-section.h"
#include "eek-keyboard.h"
#include "eek-keysym.h"
#include "eek-symbol.h"
enum {
PROP_0,
PROP_KEYCODE,
PROP_KEYSYMS,
PROP_SYMBOL_MATRIX,
PROP_COLUMN,
PROP_ROW,
PROP_OUTLINE,
@ -66,7 +66,7 @@ G_DEFINE_TYPE (EekKey, eek_key, EEK_TYPE_ELEMENT);
struct _EekKeyPrivate
{
guint keycode;
EekKeysymMatrix keysyms;
EekSymbolMatrix *symbol_matrix;
gint column;
gint row;
EekOutline *outline;
@ -88,53 +88,19 @@ eek_key_real_get_keycode (EekKey *self)
}
static void
eek_key_real_set_keysyms (EekKey *self,
guint *keysyms,
gint num_groups,
gint num_levels)
eek_key_real_set_symbol_matrix (EekKey *self,
EekSymbolMatrix *matrix)
{
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;
#if DEBUG
{
const gchar *name;
gint i;
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
eek_symbol_matrix_free (priv->symbol_matrix);
priv->symbol_matrix = eek_symbol_matrix_copy (matrix);
}
static void
eek_key_real_get_keysyms (EekKey *self,
guint **keysyms,
gint *num_groups,
gint *num_levels)
static EekSymbolMatrix *
eek_key_real_get_symbol_matrix (EekKey *self)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(self);
gint num_keysyms = priv->keysyms.num_groups * priv->keysyms.num_levels;
if (num_groups)
*num_groups = priv->keysyms.num_groups;
if (num_levels)
*num_levels = priv->keysyms.num_levels;
if (keysyms && num_keysyms > 0) {
memcpy (*keysyms, priv->keysyms.data, num_keysyms * sizeof(guint));
}
return priv->symbol_matrix;
}
static void
@ -210,9 +176,7 @@ 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);
eek_symbol_matrix_free (priv->symbol_matrix);
G_OBJECT_CLASS (eek_key_parent_class)->finalize (object);
}
@ -222,19 +186,16 @@ eek_key_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
EekKeysymMatrix *matrix;
EekSymbolMatrix *matrix;
gint column, row;
switch (prop_id) {
case PROP_KEYCODE:
eek_key_set_keycode (EEK_KEY(object), g_value_get_uint (value));
break;
case PROP_KEYSYMS:
case PROP_SYMBOL_MATRIX:
matrix = g_value_get_boxed (value);
eek_key_set_keysyms (EEK_KEY(object),
matrix->data,
matrix->num_groups,
matrix->num_levels);
eek_key_set_symbol_matrix (EEK_KEY(object), matrix);
break;
case PROP_COLUMN:
eek_key_get_index (EEK_KEY(object), &column, &row);
@ -261,7 +222,6 @@ eek_key_get_property (GObject *object,
GValue *value,
GParamSpec *pspec)
{
EekKeysymMatrix matrix;
gint column, row;
g_return_if_fail (EEK_IS_KEY(object));
@ -269,10 +229,9 @@ eek_key_get_property (GObject *object,
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);
case PROP_SYMBOL_MATRIX:
g_value_set_boxed (value,
eek_key_get_symbol_matrix (EEK_KEY(object)));
break;
case PROP_COLUMN:
eek_key_get_index (EEK_KEY(object), &column, &row);
@ -304,8 +263,8 @@ eek_key_class_init (EekKeyClass *klass)
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->set_symbol_matrix = eek_key_real_set_symbol_matrix;
klass->get_symbol_matrix = eek_key_real_get_symbol_matrix;
klass->set_index = eek_key_real_set_index;
klass->get_index = eek_key_real_get_index;
klass->set_outline = eek_key_real_set_outline;
@ -333,16 +292,16 @@ eek_key_class_init (EekKeyClass *klass)
g_object_class_install_property (gobject_class, PROP_KEYCODE, pspec);
/**
* EekKey:keysyms:
* EekKey:symbol-matrix:
*
* The symbol matrix of #EekKey.
*/
pspec = g_param_spec_boxed ("keysyms",
"Keysyms",
pspec = g_param_spec_boxed ("symbol-matrix",
"Symbol matrix",
"Symbol matrix of the key",
EEK_TYPE_KEYSYM_MATRIX,
EEK_TYPE_SYMBOL_MATRIX,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_KEYSYMS, pspec);
g_object_class_install_property (gobject_class, PROP_SYMBOL_MATRIX, pspec);
/**
* EekKey:column:
@ -375,7 +334,7 @@ eek_key_class_init (EekKeyClass *klass)
*/
/* 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). */
keyboard (unlike symbol matrix and bounds). */
pspec = g_param_spec_pointer ("outline",
"Outline",
"Pointer to outline shape of the key",
@ -424,7 +383,7 @@ eek_key_init (EekKey *self)
priv = self->priv = EEK_KEY_GET_PRIVATE(self);
priv->keycode = 0;
memset (&priv->keysyms, 0, sizeof priv->keysyms);
priv->symbol_matrix = eek_symbol_matrix_new (0, 0);
priv->column = priv->row = 0;
priv->outline = NULL;
}
@ -459,45 +418,32 @@ eek_key_get_keycode (EekKey *key)
}
/**
* eek_key_set_keysyms:
* eek_key_set_symbol_matrix:
* @key: an #EekKey
* @keysyms: symbol matrix of @key
* @num_groups: number of groups (rows) of @keysyms
* @num_levels: number of levels (columns) of @keysyms
* @matrix: an #EekSymbolMatrix
*
* Set the symbol matrix of @key to @keysyms. The length of @keysyms
* is @num_groups * @num_levels.
* Set the symbol matrix @matrix to @key.
*/
void
eek_key_set_keysyms (EekKey *key,
guint *keysyms,
gint num_groups,
gint num_levels)
eek_key_set_symbol_matrix (EekKey *key,
EekSymbolMatrix *matrix)
{
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->set_keysyms (key, keysyms, num_groups, num_levels);
EEK_KEY_GET_CLASS(key)->set_symbol_matrix (key, matrix);
}
/**
* eek_key_get_keysyms:
* eek_key_get_symbol_matrix:
* @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. If either @keysyms, @num_groups, or
* @num_levels are NULL, this function does not try to get the value.
* Get the symbol matrix of @key.
* Returns: #EekSymbolMatrix or %NULL
*/
void
eek_key_get_keysyms (EekKey *key,
guint **keysyms,
gint *num_groups,
gint *num_levels)
EekSymbolMatrix *
eek_key_get_symbol_matrix (EekKey *key)
{
g_return_if_fail (EEK_IS_KEY(key));
EEK_KEY_GET_CLASS(key)->get_keysyms (key, keysyms, num_groups, num_levels);
g_return_val_if_fail (EEK_IS_KEY(key), NULL);
return EEK_KEY_GET_CLASS(key)->get_symbol_matrix (key);
}
static EekKeyboard *
@ -515,54 +461,60 @@ get_keyboard (EekKey *key)
}
/**
* eek_key_get_keysym:
* eek_key_get_symbol:
* @key: an #EekKey
*
* Get the current symbol of @key.
* Returns: a symbol or %EEK_INVALID_KEYSYM on failure
* Returns: an #EekSymbol or %NULL on failure
*/
guint
eek_key_get_keysym (EekKey *key)
EekSymbol *
eek_key_get_symbol (EekKey *key)
{
gint group, level;
EekKeyboard *keyboard;
g_return_val_if_fail (EEK_IS_KEY (key), EEK_INVALID_KEYSYM);
g_return_val_if_fail (EEK_IS_KEY (key), NULL);
keyboard = get_keyboard (key);
g_return_val_if_fail (keyboard, EEK_INVALID_KEYSYM);
g_return_val_if_fail (keyboard, NULL);
eek_keyboard_get_keysym_index (keyboard, &group, &level);
eek_keyboard_get_symbol_index (keyboard, &group, &level);
return eek_key_get_keysym_at_index (key, group, level);
return eek_key_get_symbol_at_index (key, group, level);
}
/**
* eek_key_get_keysym_at_index:
* eek_key_get_symbol_at_index:
* @key: an #EekKey
* @group: group index of the keysym matrix
* @level: level index of the keysym matrix
* @group: group index of the symbol matrix
* @level: level index of the symbol matrix
*
* Get the symbol at (@group, @level) in the keysym matrix of @key.
* Returns: a symbol or %EEK_INVALID_KEYSYM on failure
* Get the symbol at (@group, @level) in the symbol matrix of @key.
* Returns: an #EekSymbol or %NULL on failure
*/
guint
eek_key_get_keysym_at_index (EekKey *key,
EekSymbol *
eek_key_get_symbol_at_index (EekKey *key,
gint group,
gint level)
{
EekKeyPrivate *priv = EEK_KEY_GET_PRIVATE(key);
gint num_keysyms = priv->keysyms.num_groups * priv->keysyms.num_levels;
gint num_symbols;
if (num_keysyms == 0)
return EEK_INVALID_KEYSYM;
if (!priv->symbol_matrix)
return NULL;
if (group >= priv->keysyms.num_groups)
return EEK_INVALID_KEYSYM;
if (level >= priv->keysyms.num_levels)
return EEK_INVALID_KEYSYM;
num_symbols = priv->symbol_matrix->num_groups *
priv->symbol_matrix->num_levels;
if (num_symbols == 0)
return NULL;
return priv->keysyms.data[group * priv->keysyms.num_levels + level];
if (group >= priv->symbol_matrix->num_groups)
return NULL;
if (level >= priv->symbol_matrix->num_levels)
return NULL;
return priv->symbol_matrix->data[group * priv->symbol_matrix->num_levels +
level];
}
/**

30
eek/eek-key.h
View File

@ -48,8 +48,8 @@ struct _EekKey
* EekKeyClass:
* @set_keycode: virtual function for setting keycode of the key
* @get_keycode: virtual function for getting keycode of the key
* @set_keysyms: virtual function for setting symbol matrix of the key
* @get_keysyms: virtual function for getting symbol matrix of the key
* @set_symbol_matrix: virtual function for setting symbol matrix of the key
* @get_symbol_matrix: virtual function for getting symbol matrix of the key
* @set_index: virtual function for setting position of the key in the
* section
* @get_index: virtual function for getting position of the key in the
@ -69,14 +69,9 @@ struct _EekKeyClass
void (* set_keycode) (EekKey *self,
guint keycode);
guint (* get_keycode) (EekKey *self);
void (* set_keysyms) (EekKey *self,
guint *keysyms,
gint num_groups,
gint num_levels);
void (* get_keysyms) (EekKey *self,
guint **keysyms,
gint *num_groups,
gint *num_levels);
void (* set_symbol_matrix) (EekKey *self,
EekSymbolMatrix *matrix);
EekSymbolMatrix *(* get_symbol_matrix) (EekKey *self);
void (* set_index) (EekKey *self,
gint column,
@ -105,16 +100,11 @@ GType eek_key_get_type (void) G_GNUC_CONST;
void eek_key_set_keycode (EekKey *key,
guint keycode);
guint eek_key_get_keycode (EekKey *key);
void eek_key_set_keysyms (EekKey *key,
guint *keysyms,
gint num_groups,
gint num_levels);
void eek_key_get_keysyms (EekKey *key,
guint **keysyms,
gint *num_groups,
gint *num_levels);
guint eek_key_get_keysym (EekKey *key);
guint eek_key_get_keysym_at_index (EekKey *key,
void eek_key_set_symbol_matrix (EekKey *key,
EekSymbolMatrix *matrix);
EekSymbolMatrix *eek_key_get_symbol_matrix (EekKey *key);
EekSymbol *eek_key_get_symbol (EekKey *key);
EekSymbol *eek_key_get_symbol_at_index (EekKey *key,
gint group,
gint level);

68
eek/eek-keyboard.c
View File

@ -34,7 +34,7 @@
#include "eek-keyboard.h"
#include "eek-section.h"
#include "eek-key.h"
#include "eek-keysym.h"
#include "eek-symbol.h"
#include "eek-marshallers.h"
enum {
@ -49,7 +49,7 @@ enum {
enum {
KEY_PRESSED,
KEY_RELEASED,
KEYSYM_INDEX_CHANGED,
SYMBOL_INDEX_CHANGED,
LAST_SIGNAL
};
@ -71,7 +71,7 @@ struct _EekKeyboardPrivate
};
static void
eek_keyboard_real_set_keysym_index (EekKeyboard *self,
eek_keyboard_real_set_symbol_index (EekKeyboard *self,
gint group,
gint level)
{
@ -81,12 +81,12 @@ eek_keyboard_real_set_keysym_index (EekKeyboard *self,
priv->group = group;
priv->level = level;
g_signal_emit_by_name (self, "keysym-index-changed", group, level);
g_signal_emit_by_name (self, "symbol-index-changed", group, level);
}
}
void
eek_keyboard_real_get_keysym_index (EekKeyboard *self,
eek_keyboard_real_get_symbol_index (EekKeyboard *self,
gint *group,
gint *level)
{
@ -182,6 +182,7 @@ eek_keyboard_set_property (GObject *object,
break;
case PROP_LAYOUT:
priv->layout = g_value_get_object (value);
if (priv->layout)
g_object_ref (priv->layout);
break;
case PROP_MODIFIER_BEHAVIOR:
@ -229,11 +230,11 @@ eek_keyboard_get_property (GObject *object,
}
static void
eek_keyboard_real_keysym_index_changed (EekKeyboard *self,
eek_keyboard_real_symbol_index_changed (EekKeyboard *self,
gint group,
gint level)
{
/* g_debug ("keysym-index-changed"); */
/* g_debug ("symbol-index-changed"); */
}
static void
@ -254,15 +255,17 @@ eek_keyboard_real_key_pressed (EekKeyboard *self,
EekKey *key)
{
EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(self);
guint keysym;
EekSymbol *symbol;
EekModifierType modifier;
if (priv->modifier_behavior == EEK_MODIFIER_BEHAVIOR_LATCH)
priv->modifiers = 0;
keysym = eek_key_get_keysym_at_index (key, priv->group, priv->level);
modifier = eek_keysym_to_modifier (keysym);
symbol = eek_key_get_symbol_at_index (key, priv->group, priv->level);
if (!symbol)
return;
modifier = eek_symbol_get_modifier_mask (symbol);
if (modifier != 0) {
if (priv->modifier_behavior == EEK_MODIFIER_BEHAVIOR_NONE ||
priv->modifier_behavior == EEK_MODIFIER_BEHAVIOR_LATCH)
@ -278,11 +281,14 @@ eek_keyboard_real_key_released (EekKeyboard *self,
EekKey *key)
{
EekKeyboardPrivate *priv = EEK_KEYBOARD_GET_PRIVATE(self);
guint keysym;
EekSymbol *symbol;
EekModifierType modifier;
keysym = eek_key_get_keysym_at_index (key, priv->group, priv->level);
modifier = eek_keysym_to_modifier (keysym);
symbol = eek_key_get_symbol_at_index (key, priv->group, priv->level);
if (!symbol)
return;
modifier = eek_symbol_get_modifier_mask (symbol);
if (modifier != 0) {
if (priv->modifier_behavior == EEK_MODIFIER_BEHAVIOR_NONE)
priv->modifiers &= ~modifier;
@ -312,15 +318,15 @@ eek_keyboard_class_init (EekKeyboardClass *klass)
g_type_class_add_private (gobject_class,
sizeof (EekKeyboardPrivate));
klass->set_keysym_index = eek_keyboard_real_set_keysym_index;
klass->get_keysym_index = eek_keyboard_real_get_keysym_index;
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->keysym_index_changed = eek_keyboard_real_keysym_index_changed;
klass->symbol_index_changed = eek_keyboard_real_symbol_index_changed;
gobject_class->get_property = eek_keyboard_get_property;
gobject_class->set_property = eek_keyboard_set_property;
@ -423,19 +429,19 @@ eek_keyboard_class_init (EekKeyboardClass *klass)
EEK_TYPE_KEY);
/**
* EekKeyboard::keysym-index-changed:
* 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 ::keysym-index-changed signal is emitted each time the
* The ::symbol-index-changed signal is emitted each time the
* global configuration of group/level index changes.
*/
signals[KEYSYM_INDEX_CHANGED] =
g_signal_new ("keysym-index-changed",
signals[SYMBOL_INDEX_CHANGED] =
g_signal_new ("symbol-index-changed",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(EekKeyboardClass, keysym_index_changed),
G_STRUCT_OFFSET(EekKeyboardClass, symbol_index_changed),
NULL,
NULL,
_eek_marshal_VOID__INT_INT,
@ -458,7 +464,7 @@ eek_keyboard_init (EekKeyboard *self)
}
/**
* eek_keyboard_set_keysym_index:
* eek_keyboard_set_symbol_index:
* @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
@ -466,16 +472,16 @@ eek_keyboard_init (EekKeyboard *self)
* Select a cell of the symbol matrix of each key on @keyboard.
*/
void
eek_keyboard_set_keysym_index (EekKeyboard *keyboard,
eek_keyboard_set_symbol_index (EekKeyboard *keyboard,
gint group,
gint level)
{
g_return_if_fail (EEK_IS_KEYBOARD(keyboard));
EEK_KEYBOARD_GET_CLASS(keyboard)->set_keysym_index (keyboard, group, level);
EEK_KEYBOARD_GET_CLASS(keyboard)->set_symbol_index (keyboard, group, level);
}
/**
* eek_keyboard_get_keysym_index:
* eek_keyboard_get_symbol_index:
* @keyboard: an #EekKeyboard
* @group: a pointer where row index of the symbol matrix of keys on
* @keyboard will be stored
@ -485,12 +491,12 @@ eek_keyboard_set_keysym_index (EekKeyboard *keyboard,
* Get the current cell position of the symbol matrix of each key on @keyboard.
*/
void
eek_keyboard_get_keysym_index (EekKeyboard *keyboard,
eek_keyboard_get_symbol_index (EekKeyboard *keyboard,
gint *group,
gint *level)
{
g_return_if_fail (EEK_IS_KEYBOARD(keyboard));
EEK_KEYBOARD_GET_CLASS(keyboard)->get_keysym_index (keyboard, group, level);
EEK_KEYBOARD_GET_CLASS(keyboard)->get_symbol_index (keyboard, group, level);
}
/**
@ -505,7 +511,7 @@ eek_keyboard_set_group (EekKeyboard *keyboard,
gint group)
{
gint level = eek_keyboard_get_level (keyboard);
eek_keyboard_set_keysym_index (keyboard, group, level);
eek_keyboard_set_symbol_index (keyboard, group, level);
}
/**
@ -520,7 +526,7 @@ eek_keyboard_set_level (EekKeyboard *keyboard,
gint level)
{
gint group = eek_keyboard_get_group (keyboard);
eek_keyboard_set_keysym_index (keyboard, group, level);
eek_keyboard_set_symbol_index (keyboard, group, level);
}
/**
@ -533,7 +539,7 @@ gint
eek_keyboard_get_group (EekKeyboard *keyboard)
{
gint group;
eek_keyboard_get_keysym_index (keyboard, &group, NULL);
eek_keyboard_get_symbol_index (keyboard, &group, NULL);
return group;
}
@ -547,7 +553,7 @@ gint
eek_keyboard_get_level (EekKeyboard *keyboard)
{
gint level;
eek_keyboard_get_keysym_index (keyboard, NULL, &level);
eek_keyboard_get_symbol_index (keyboard, NULL, &level);
return level;
}

11
eek/eek-keyboard.h
View File

@ -24,7 +24,6 @@
#include "eek-container.h"
#include "eek-types.h"
#include "eek-layout.h"
#include "eek-keysym.h"
G_BEGIN_DECLS
@ -65,10 +64,10 @@ struct _EekKeyboardClass
EekContainerClass parent_class;
/*< public >*/
void (* set_keysym_index) (EekKeyboard *self,
void (* set_symbol_index) (EekKeyboard *self,
gint group,
gint level);
void (* get_keysym_index) (EekKeyboard *self,
void (* get_symbol_index) (EekKeyboard *self,
gint *group,
gint *level);
@ -82,7 +81,7 @@ struct _EekKeyboardClass
EekKey *key);
void (* key_released) (EekKeyboard *self,
EekKey *key);
void (* keysym_index_changed) (EekKeyboard *self,
void (* symbol_index_changed) (EekKeyboard *self,
gint group,
gint level);
@ -103,11 +102,11 @@ void eek_keyboard_get_size
(EekKeyboard *keyboard,
gdouble *width,
gdouble *height);
void eek_keyboard_set_keysym_index
void eek_keyboard_set_symbol_index
(EekKeyboard *keyboard,
gint group,
gint level);
void eek_keyboard_get_keysym_index
void eek_keyboard_get_symbol_index
(EekKeyboard *keyboard,
gint *group,
gint *level);

355
eek/eek-keysym.c
View File

@ -20,27 +20,57 @@
/**
* SECTION:eek-keysym
* @short_description: Keysym conversion utilities
* @short_description: an #EekSymbol represents an X keysym
*/
#include <glib.h>
#include <string.h>
#include <stdlib.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#include "eek-keysym.h"
struct _EekKeysymEntry {
guint keysym;
const gchar *label;
EekKeysymCategory category;
/* modifier keys */
#define EEK_KEYSYM_Shift_L 0xffe1
#define EEK_KEYSYM_Shift_R 0xffe2
#define EEK_KEYSYM_ISO_Level3_Shift 0xfe03
#define EEK_KEYSYM_Caps_Lock 0xffe5
#define EEK_KEYSYM_Shift_Lock 0xffe6
#define EEK_KEYSYM_Control_L 0xffe3
#define EEK_KEYSYM_Control_R 0xffe4
#define EEK_KEYSYM_Alt_L 0xffe9
#define EEK_KEYSYM_Alt_R 0xffea
#define EEK_KEYSYM_Meta_L 0xffe7
#define EEK_KEYSYM_Meta_R 0xffe8
#define EEK_KEYSYM_Super_L 0xffeb
#define EEK_KEYSYM_Super_R 0xffec
#define EEK_KEYSYM_Hyper_L 0xffed
#define EEK_KEYSYM_Hyper_R 0xffee
struct _EekKeysymPrivate {
guint xkeysym;
const gchar *name;
EekSymbolCategory category;
};
typedef struct _EekKeysymEntry EekKeysymEntry;
typedef EekKeysymPrivate EekKeysymEntry;
#include "eek-special-keysym-entries.h"
#include "eek-unicode-keysym-entries.h"
#include "eek-keyname-keysym-entries.h"
#include "eek-xkeysym-keysym-entries.h"
static const EekKeysymEntry invalid_keysym_entry = {
EEK_INVALID_KEYSYM,
"\0",
EEK_SYMBOL_CATEGORY_UNKNOWN,
};
G_DEFINE_TYPE (EekKeysym, eek_keysym, EEK_TYPE_SYMBOL);
#define EEK_KEYSYM_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), EEK_TYPE_KEYSYM, EekKeysymPrivate))
static gchar *
unichar_to_utf8 (gunichar uc)
@ -58,202 +88,179 @@ unichar_to_utf8 (gunichar uc)
}
static int
keysym_entry_compare_keysym (const void *key0, const void *key1)
keysym_entry_compare_by_xkeysym (const void *key0, const void *key1)
{
const EekKeysymEntry *entry0 = key0, *entry1 = key1;
return (gint)entry0->keysym - (gint)entry1->keysym;
return (gint)entry0->xkeysym - (gint)entry1->xkeysym;
}
static gboolean
find_keysym (guint keysym,
gchar **label,
EekKeysymCategory *category)
static EekKeysymEntry *
find_keysym_entry_by_xkeysym (guint xkeysym,
const EekKeysymEntry *entries,
gint num_entries)
{
EekKeysymEntry bsearch_key, *bsearch_val;
EekKeysymEntry key;
key.xkeysym = xkeysym;
return bsearch (&key, entries, num_entries, sizeof (EekKeysymEntry),
keysym_entry_compare_by_xkeysym);
}
static G_CONST_RETURN gchar *
eek_keysym_real_get_name (EekSymbol *self)
{
EekKeysymPrivate *priv = EEK_KEYSYM_GET_PRIVATE(self);
return priv->name;
}
static gchar *
eek_keysym_real_get_label (EekSymbol *self)
{
EekKeysymPrivate *priv = EEK_KEYSYM_GET_PRIVATE(self);
EekKeysymEntry *entry;
/* First, search special keysyms. */
bsearch_key.keysym = keysym;
bsearch_val = bsearch (&bsearch_key,
entry = find_keysym_entry_by_xkeysym (priv->xkeysym,
special_keysym_entries,
G_N_ELEMENTS(special_keysym_entries),
sizeof (EekKeysymEntry),
keysym_entry_compare_keysym);
if (bsearch_val) {
if (label)
*label = g_strdup (bsearch_val->label);
if (category)
*category = bsearch_val->category;
return TRUE;
}
G_N_ELEMENTS(special_keysym_entries));
if (entry)
return g_strdup (entry->name);
/* Check for Latin-1 characters (1:1 mapping) */
if ((keysym >= 0x0020 && keysym <= 0x007e) ||
(keysym >= 0x00a0 && keysym <= 0x00ff)) {
if (label)
*label = unichar_to_utf8 (keysym);
if (category)
*category = EEK_KEYSYM_CATEGORY_LETTER;
return TRUE;
}
if ((priv->xkeysym >= 0x0020 && priv->xkeysym <= 0x007e) ||
(priv->xkeysym >= 0x00a0 && priv->xkeysym <= 0x00ff))
return unichar_to_utf8 (priv->xkeysym);
/* Also check for directly encoded 24-bit UCS characters:
*/
if ((keysym & 0xff000000) == 0x01000000) {
if (label)
*label = unichar_to_utf8 (keysym & 0x00ffffff);
if (category)
*category = EEK_KEYSYM_CATEGORY_LETTER;
return TRUE;
}
if ((priv->xkeysym & 0xff000000) == 0x01000000)
return unichar_to_utf8 (priv->xkeysym & 0x00ffffff);
/* Search known unicode keysyms. */
bsearch_key.keysym = keysym;
bsearch_val = bsearch (&bsearch_key,
entry = find_keysym_entry_by_xkeysym (priv->xkeysym,
unicode_keysym_entries,
G_N_ELEMENTS(unicode_keysym_entries),
sizeof (EekKeysymEntry),
keysym_entry_compare_keysym);
if (bsearch_val) {
if (label)
*label = g_strdup (bsearch_val->label);
if (category)
*category = bsearch_val->category;
return TRUE;
G_N_ELEMENTS(unicode_keysym_entries));
if (entry)
return g_strdup (entry->name);
return g_strdup (eek_symbol_get_name (self));
}
/* Finally, search keynames. */
bsearch_key.keysym = keysym;
bsearch_val = bsearch (&bsearch_key,
keyname_keysym_entries,
G_N_ELEMENTS(keyname_keysym_entries),
sizeof (EekKeysymEntry),
keysym_entry_compare_keysym);
if (bsearch_val) {
if (label)
*label = g_strdup (bsearch_val->label);
if (category)
*category = bsearch_val->category;
return TRUE;
}
return FALSE;
}
/**
* eek_keysym_to_string:
* @keysym: keysym ID
*
* Return a string representation of @keysym.
*/
gchar *
eek_keysym_to_string (guint keysym)
EekSymbolCategory
eek_keysym_real_get_category (EekSymbol *self)
{
gchar *label;
if (find_keysym (keysym, &label, NULL))
return label;
return g_strdup ("");
EekKeysymPrivate *priv = EEK_KEYSYM_GET_PRIVATE(self);
return priv->category;
}
gchar *
eek_xkeysym_to_string (guint xkeysym)
{
EekKeysymEntry bsearch_key, *bsearch_val;
bsearch_key.keysym = xkeysym;
bsearch_val = bsearch (&bsearch_key,
keyname_keysym_entries,
G_N_ELEMENTS(keyname_keysym_entries),
sizeof (EekKeysymEntry),
keysym_entry_compare_keysym);
if (bsearch_val)
return g_strdup (bsearch_val->label);
return NULL;
}
static GHashTable *xkeysym_hash = NULL;
static void
xkeysym_free (gpointer xkeysym)
{
g_slice_free (guint, xkeysym);
}
guint
eek_xkeysym_from_string (gchar *string)
{
guint *xkeysym;
if (!xkeysym_hash) {
gint i;
xkeysym_hash = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
xkeysym_free);
for (i = 0; i < G_N_ELEMENTS(keyname_keysym_entries); i++) {
xkeysym = g_slice_new (guint);
*xkeysym = keyname_keysym_entries[i].keysym;
g_hash_table_insert (xkeysym_hash,
g_strdup (keyname_keysym_entries[i].label),
xkeysym);
}
}
xkeysym = g_hash_table_lookup (xkeysym_hash, string);
if (xkeysym)
return *xkeysym;
return EEK_INVALID_KEYSYM;
}
/**
* eek_keysym_get_category:
* @keysym: keysym ID
*
* Return a string representation of @keysym.
*/
EekKeysymCategory
eek_keysym_get_category (guint keysym)
{
EekKeysymCategory category;
if (find_keysym (keysym, NULL, &category))
return category;
return EEK_KEYSYM_CATEGORY_UNKNOWN;
}
/**
* eek_keysym_to_modifier:
* @keysym: keysym ID
*
* Return a modifier mask which @keysym affects.
*/
EekModifierType
eek_keysym_to_modifier (guint keysym)
eek_keysym_real_get_modifier_mask (EekSymbol *self)
{
switch (keysym) {
case EEK_KEY_Shift_L:
case EEK_KEY_Shift_R:
case EEK_KEY_Caps_Lock:
case EEK_KEY_Shift_Lock:
EekKeysymPrivate *priv = EEK_KEYSYM_GET_PRIVATE(self);
switch (priv->xkeysym) {
case EEK_KEYSYM_Shift_L:
case EEK_KEYSYM_Shift_R:
case EEK_KEYSYM_Caps_Lock:
case EEK_KEYSYM_Shift_Lock:
return EEK_SHIFT_MASK;
case EEK_KEY_ISO_Level3_Shift:
case EEK_KEYSYM_ISO_Level3_Shift:
return EEK_MOD5_MASK;
case EEK_KEY_Control_L:
case EEK_KEY_Control_R:
case EEK_KEYSYM_Control_L:
case EEK_KEYSYM_Control_R:
return EEK_CONTROL_MASK;
case EEK_KEY_Alt_L:
case EEK_KEY_Alt_R:
case EEK_KEYSYM_Alt_L:
case EEK_KEYSYM_Alt_R:
return EEK_MOD1_MASK;
case EEK_KEY_Meta_L:
case EEK_KEY_Meta_R:
case EEK_KEYSYM_Meta_L:
case EEK_KEYSYM_Meta_R:
return EEK_META_MASK;
case EEK_KEY_Super_L:
case EEK_KEY_Super_R:
case EEK_KEYSYM_Super_L:
case EEK_KEYSYM_Super_R:
return EEK_SUPER_MASK;
case EEK_KEY_Hyper_L:
case EEK_KEY_Hyper_R:
case EEK_KEYSYM_Hyper_L:
case EEK_KEYSYM_Hyper_R:
return EEK_HYPER_MASK;
}
return 0;
}
static void
eek_keysym_class_init (EekKeysymClass *klass)
{
EekSymbolClass *symbol_class = EEK_SYMBOL_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (gobject_class, sizeof (EekKeysymPrivate));
symbol_class->get_name = eek_keysym_real_get_name;
symbol_class->get_label = eek_keysym_real_get_label;
symbol_class->get_category = eek_keysym_real_get_category;
symbol_class->get_modifier_mask = eek_keysym_real_get_modifier_mask;
}
static void
eek_keysym_init (EekKeysym *self)
{
EekKeysymPrivate *priv;
priv = self->priv = EEK_KEYSYM_GET_PRIVATE(self);
memcpy (priv, &invalid_keysym_entry, sizeof (EekKeysymEntry));
}
EekKeysym *
eek_keysym_new (guint xkeysym)
{
EekKeysym *keysym;
EekKeysymPrivate *priv;
EekKeysymEntry *entry;
keysym = g_object_new (EEK_TYPE_KEYSYM, NULL);
priv = EEK_KEYSYM_GET_PRIVATE(keysym);
entry = find_keysym_entry_by_xkeysym (xkeysym,
xkeysym_keysym_entries,
G_N_ELEMENTS(xkeysym_keysym_entries));
if (entry)
memcpy (priv, entry, sizeof (EekKeysymEntry));
else {
// g_warning ("can't find keysym entry %u", xkeysym);
memcpy (priv, &invalid_keysym_entry, sizeof (EekKeysymEntry));
priv->xkeysym = xkeysym;
}
return keysym;
}
EekKeysym *
eek_keysym_new_from_name (const gchar *name)
{
EekKeysym *keysym;
EekKeysymPrivate *priv;
gint i;
for (i = 0;
i < G_N_ELEMENTS(xkeysym_keysym_entries) &&
g_strcmp0 (xkeysym_keysym_entries[i].name, name) != 0; i++)
;
keysym = g_object_new (EEK_TYPE_KEYSYM, NULL);
priv = EEK_KEYSYM_GET_PRIVATE(keysym);
if (i < G_N_ELEMENTS(xkeysym_keysym_entries))
memcpy (priv, &xkeysym_keysym_entries[i], sizeof (EekKeysymEntry));
else {
// g_warning ("can't find keysym entry for %s", name);
memcpy (priv, &invalid_keysym_entry, sizeof (EekKeysymEntry));
}
return keysym;
}
guint
eek_keysym_get_xkeysym (EekKeysym *keysym)
{
EekKeysymPrivate *priv;
g_assert (EEK_IS_KEYSYM(keysym));
priv = EEK_KEYSYM_GET_PRIVATE(keysym);
return priv->xkeysym;
}

107
eek/eek-keysym.h
View File

@ -20,7 +20,9 @@
#ifndef EEK_KEYSYM_H
#define EEK_KEYSYM_H 1
#include <glib-object.h>
#include "eek-symbol.h"
G_BEGIN_DECLS
/**
* EEK_INVALID_KEYSYM:
@ -29,93 +31,34 @@
*/
#define EEK_INVALID_KEYSYM ((guint)(-1))
/**
* EEK_INVALID_KEYCODE:
*
* Pseudo keycode used for error reporting.
*/
#define EEK_INVALID_KEYCODE ((guint)(-1))
#define EEK_TYPE_KEYSYM (eek_keysym_get_type())
#define EEK_KEYSYM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EEK_TYPE_KEYSYM, EekKeysym))
#define EEK_KEYSYM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EEK_TYPE_KEYSYM, EekKeysymClass))
#define EEK_IS_KEYSYM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EEK_TYPE_KEYSYM))
#define EEK_IS_KEYSYM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EEK_TYPE_KEYSYM))
#define EEK_KEYSYM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EEK_TYPE_KEYSYM, EekKeysymClass))
/**
* EekKeysymCategory:
* @EEK_KEYSYM_CATEGORY_LETTER: the symbol represents an alphabet letter
* @EEK_KEYSYM_CATEGORY_FUNCTION: the symbol represents a function
* @EEK_KEYSYM_CATEGORY_KEYNAME: the symbol does not have meaning but
* have a name
* @EEK_KEYSYM_CATEGORY_UNKNOWN: used for error reporting
*
* Category of the key symbols.
*/
typedef enum {
EEK_KEYSYM_CATEGORY_LETTER,
EEK_KEYSYM_CATEGORY_FUNCTION,
EEK_KEYSYM_CATEGORY_KEYNAME,
EEK_KEYSYM_CATEGORY_UNKNOWN,
typedef struct _EekKeysymClass EekKeysymClass;
typedef struct _EekKeysymPrivate EekKeysymPrivate;
struct _EekKeysym {
/*< private >*/
EEK_KEYSYM_CATEGORY_LAST = EEK_KEYSYM_CATEGORY_UNKNOWN
} EekKeysymCategory;
EekSymbol parent;
gchar *eek_keysym_to_string (guint keysym);
EekKeysymPrivate *priv;
};
gchar *eek_xkeysym_to_string (guint xkeysym);
guint eek_xkeysym_from_string (gchar *string);
struct _EekKeysymClass {
/*< private >*/
EekSymbolClass parent_class;
};
EekKeysymCategory eek_keysym_get_category (guint keysym);
GType eek_keysym_get_type (void) G_GNUC_CONST;
EekKeysym *eek_keysym_new (guint xkeysym);
guint eek_keysym_get_xkeysym (EekKeysym *keysym);
typedef enum
{
EEK_SHIFT_MASK = 1 << 0,
EEK_LOCK_MASK = 1 << 1,
EEK_CONTROL_MASK = 1 << 2,
EEK_MOD1_MASK = 1 << 3,
EEK_MOD2_MASK = 1 << 4,
EEK_MOD3_MASK = 1 << 5,
EEK_MOD4_MASK = 1 << 6,
EEK_MOD5_MASK = 1 << 7,
EEK_BUTTON1_MASK = 1 << 8,
EEK_BUTTON2_MASK = 1 << 9,
EEK_BUTTON3_MASK = 1 << 10,
EEK_BUTTON4_MASK = 1 << 11,
EEK_BUTTON5_MASK = 1 << 12,
EekKeysym *eek_keysym_new_from_name (const gchar *name);
/* The next few modifiers are used by XKB, so we skip to the end.
* Bits 15 - 25 are currently unused. Bit 29 is used internally.
*/
EEK_SUPER_MASK = 1 << 26,
EEK_HYPER_MASK = 1 << 27,
EEK_META_MASK = 1 << 28,
EEK_RELEASE_MASK = 1 << 30,
EEK_MODIFIER_MASK = 0x5c001fff
} EekModifierType;
#define EEK_KEY_Shift_L 0xffe1
#define EEK_KEY_Shift_R 0xffe2
#define EEK_KEY_ISO_Level3_Shift 0xfe03
#define EEK_KEY_Caps_Lock 0xffe5
#define EEK_KEY_Shift_Lock 0xffe6
#define EEK_KEY_Control_L 0xffe3
#define EEK_KEY_Control_R 0xffe4
#define EEK_KEY_Alt_L 0xffe9
#define EEK_KEY_Alt_R 0xffea
#define EEK_KEY_Meta_L 0xffe7
#define EEK_KEY_Meta_R 0xffe8
#define EEK_KEY_Super_L 0xffeb
#define EEK_KEY_Super_R 0xffec
#define EEK_KEY_Hyper_L 0xffed
#define EEK_KEY_Hyper_R 0xffee
EekModifierType eek_keysym_to_modifier (guint keysym);
/**
* eek_keysym_is_modifier:
* @keysym: keysym ID
*
* Check if @keysym is a modifier key.
* Returns: %TRUE if @keysym is a modifier.
*/
#define eek_keysym_is_modifier(keysym) (eek_keysym_to_modifier ((keysym)) != 0)
G_END_DECLS
#endif /* EEK_KEYSYM_H */

1
eek/eek-layout.c
View File

@ -38,6 +38,7 @@ G_DEFINE_TYPE (EekLayout, eek_layout, G_TYPE_OBJECT);
static void
eek_layout_class_init (EekLayoutClass *klass)
{
klass->create_keyboard = NULL;
}
void

46
eek/eek-renderer.c
View File

@ -58,10 +58,10 @@ struct _EekRendererPrivate
struct {
gint category;
gdouble scale;
} keysym_category_scale_factors[EEK_KEYSYM_CATEGORY_LAST] = {
{ EEK_KEYSYM_CATEGORY_LETTER, 1.0 },
{ EEK_KEYSYM_CATEGORY_FUNCTION, 0.5 },
{ EEK_KEYSYM_CATEGORY_KEYNAME, 0.5 }
} symbol_category_scale_factors[EEK_SYMBOL_CATEGORY_LAST] = {
{ EEK_SYMBOL_CATEGORY_LETTER, 1.0 },
{ EEK_SYMBOL_CATEGORY_FUNCTION, 0.5 },
{ EEK_SYMBOL_CATEGORY_KEYNAME, 0.5 }
};
/* eek-keyboard-drawing.c */
@ -78,7 +78,7 @@ static void invalidate (EekRenderer *renderer);
static void render_key (EekRenderer *self,
cairo_t *cr,
EekKey *key);
static void on_keysym_index_changed (EekKeyboard *keyboard,
static void on_symbol_index_changed (EekKeyboard *keyboard,
gint group,
gint level,
gpointer user_data);
@ -269,16 +269,16 @@ calculate_font_size_key_callback (EekElement *element, gpointer user_data)
PangoRectangle extents = { 0, };
PangoLayout *layout;
gdouble size;
guint keysym;
EekSymbol *symbol;
EekBounds bounds;
gchar *label;
keysym = eek_key_get_keysym (EEK_KEY(element));
if (keysym == EEK_INVALID_KEYSYM ||
eek_keysym_get_category (keysym) != EEK_KEYSYM_CATEGORY_LETTER)
symbol = eek_key_get_symbol (EEK_KEY(element));
if (!symbol ||
eek_symbol_get_category (symbol) != EEK_SYMBOL_CATEGORY_LETTER)
return;
label = eek_keysym_to_string (keysym);
label = eek_symbol_get_label (symbol);
if (!label)
return;
@ -434,23 +434,23 @@ eek_renderer_real_render_key_label (EekRenderer *self,
EekKey *key)
{
EekRendererPrivate *priv = EEK_RENDERER_GET_PRIVATE(self);
guint keysym;
EekKeysymCategory category;
EekSymbol *symbol;
EekSymbolCategory category;
gchar *label;
EekBounds bounds;
PangoFontDescription *font;
gdouble size, scale;
gint i;
keysym = eek_key_get_keysym (key);
if (keysym == EEK_INVALID_KEYSYM)
symbol = eek_key_get_symbol (key);
if (!symbol)
return;
category = eek_keysym_get_category (keysym);
if (category == EEK_KEYSYM_CATEGORY_UNKNOWN)
category = eek_symbol_get_category (symbol);
if (category == EEK_SYMBOL_CATEGORY_UNKNOWN)
return;
label = eek_keysym_to_string (keysym);
label = eek_symbol_get_label (symbol);
if (!label)
return;
@ -470,9 +470,9 @@ eek_renderer_real_render_key_label (EekRenderer *self,
font = pango_font_description_copy (priv->font);
size = pango_font_description_get_size (font);
for (i = 0; i < G_N_ELEMENTS(keysym_category_scale_factors); i++)
if (keysym_category_scale_factors[i].category == category) {
size *= keysym_category_scale_factors[i].scale;
for (i = 0; i < G_N_ELEMENTS(symbol_category_scale_factors); i++)
if (symbol_category_scale_factors[i].category == category) {
size *= symbol_category_scale_factors[i].scale;
break;
}
pango_font_description_set_size (font, size * priv->scale * scale);
@ -536,8 +536,8 @@ eek_renderer_set_property (GObject *object,
priv->keyboard = g_value_get_object (value);
g_object_ref (priv->keyboard);
g_signal_connect (priv->keyboard, "keysym-index-changed",
G_CALLBACK(on_keysym_index_changed),
g_signal_connect (priv->keyboard, "symbol-index-changed",
G_CALLBACK(on_symbol_index_changed),
object);
break;
case PROP_PCONTEXT:
@ -655,7 +655,7 @@ invalidate (EekRenderer *renderer)
}
static void
on_keysym_index_changed (EekKeyboard *keyboard,
on_symbol_index_changed (EekKeyboard *keyboard,
gint group,
gint level,
gpointer user_data)

266
eek/eek-symbol.c Normal file
View File

@ -0,0 +1,266 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#include "eek-symbol.h"
enum {
PROP_0,
PROP_NAME,
PROP_LABEL,
PROP_CATEGORY,
PROP_MODIFIER_MASK,
PROP_LAST
};
struct _EekSymbolPrivate {
gchar *name;
gchar *label;
EekSymbolCategory category;
EekModifierType modifier_mask;
};
G_DEFINE_TYPE (EekSymbol, eek_symbol, G_TYPE_OBJECT);
#define EEK_SYMBOL_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), EEK_TYPE_SYMBOL, EekSymbolPrivate))
static void
eek_symbol_real_set_name (EekSymbol *self,
const gchar *name)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
g_free (priv->name);
priv->name = g_strdup (name);
}
G_CONST_RETURN gchar *
eek_symbol_real_get_name (EekSymbol *self)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
return priv->name;
}
static void
eek_symbol_real_set_label (EekSymbol *self,
const gchar *label)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
g_free (priv->label);
priv->label = g_strdup (label);
}
gchar *
eek_symbol_real_get_label (EekSymbol *self)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
return priv->label;
}
static void
eek_symbol_real_set_category (EekSymbol *self,
EekSymbolCategory category)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
priv->category = category;
}
EekSymbolCategory
eek_symbol_real_get_category (EekSymbol *self)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
return priv->category;
}
static void
eek_symbol_real_set_modifier_mask (EekSymbol *self,
EekModifierType mask)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
priv->modifier_mask = mask;
}
EekModifierType
eek_symbol_real_get_modifier_mask (EekSymbol *self)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(self);
return priv->modifier_mask;
}
static void
eek_symbol_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
switch (prop_id) {
case PROP_NAME:
eek_symbol_set_name (EEK_SYMBOL(object), g_value_get_string (value));
break;
case PROP_LABEL:
eek_symbol_set_label (EEK_SYMBOL(object), g_value_get_string (value));
break;
case PROP_CATEGORY:
eek_symbol_set_category (EEK_SYMBOL(object), g_value_get_int (value));
break;
case PROP_MODIFIER_MASK:
eek_symbol_set_modifier_mask (EEK_SYMBOL(object),
g_value_get_int (value));
break;
default:
g_object_set_property (object,
g_param_spec_get_name (pspec),
value);
break;
}
}
static void
eek_symbol_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
switch (prop_id) {
case PROP_NAME:
g_value_set_string (value, eek_symbol_get_name (EEK_SYMBOL(object)));
break;
case PROP_LABEL:
g_value_set_string (value, eek_symbol_get_label (EEK_SYMBOL(object)));
break;
case PROP_CATEGORY:
g_value_set_int (value, eek_symbol_get_category (EEK_SYMBOL(object)));
break;
case PROP_MODIFIER_MASK:
g_value_set_int (value,
eek_symbol_get_modifier_mask (EEK_SYMBOL(object)));
break;
default:
g_object_get_property (object,
g_param_spec_get_name (pspec),
value);
break;
}
}
static void
eek_symbol_finalize (GObject *object)
{
EekSymbolPrivate *priv = EEK_SYMBOL_GET_PRIVATE(object);
if (priv->name)
g_free (priv->name);
}
static void
eek_symbol_class_init (EekSymbolClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GParamSpec *pspec;
g_type_class_add_private (gobject_class, sizeof (EekSymbolPrivate));
klass->set_name = eek_symbol_real_set_name;
klass->get_name = eek_symbol_real_get_name;
klass->set_label = eek_symbol_real_set_label;
klass->get_label = eek_symbol_real_get_label;
klass->set_category = eek_symbol_real_set_category;
klass->get_category = eek_symbol_real_get_category;
klass->set_modifier_mask = eek_symbol_real_set_modifier_mask;
klass->get_modifier_mask = eek_symbol_real_get_modifier_mask;
gobject_class->set_property = eek_symbol_set_property;
gobject_class->get_property = eek_symbol_get_property;
gobject_class->finalize = eek_symbol_finalize;
pspec = g_param_spec_string ("name",
"Name",
"Canonical name of the keysym",
NULL,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_NAME, pspec);
pspec = g_param_spec_string ("label",
"Label",
"Text used to display the keysym",
NULL,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_LABEL, pspec);
}
static void
eek_symbol_init (EekSymbol *self)
{
EekSymbolPrivate *priv;
priv = self->priv = EEK_SYMBOL_GET_PRIVATE(self);
priv->name = NULL;
priv->label = NULL;
priv->category = EEK_SYMBOL_CATEGORY_UNKNOWN;
priv->modifier_mask = 0;
}
EekSymbol *
eek_symbol_new (const gchar *name)
{
return g_object_new (EEK_TYPE_SYMBOL, "name", name);
}
void
eek_symbol_set_name (EekSymbol *symbol,
const gchar *name)
{
g_return_if_fail (EEK_IS_SYMBOL(symbol));
EEK_SYMBOL_GET_CLASS(symbol)->set_name (symbol, name);
}
G_CONST_RETURN gchar *
eek_symbol_get_name (EekSymbol *symbol)
{
g_return_val_if_fail (EEK_IS_SYMBOL(symbol), NULL);
return EEK_SYMBOL_GET_CLASS(symbol)->get_name (symbol);
}
void
eek_symbol_set_label (EekSymbol *symbol,
const gchar *label)
{
g_return_if_fail (EEK_IS_SYMBOL(symbol));
return EEK_SYMBOL_GET_CLASS(symbol)->set_label (symbol, label);
}
gchar *
eek_symbol_get_label (EekSymbol *symbol)
{
g_return_val_if_fail (EEK_IS_SYMBOL(symbol), NULL);
return EEK_SYMBOL_GET_CLASS(symbol)->get_label (symbol);
}
void
eek_symbol_set_category (EekSymbol *symbol,
EekSymbolCategory category)
{
g_return_if_fail (EEK_IS_SYMBOL(symbol));
return EEK_SYMBOL_GET_CLASS(symbol)->set_category (symbol, category);
}
EekSymbolCategory
eek_symbol_get_category (EekSymbol *symbol)
{
g_return_val_if_fail (EEK_IS_SYMBOL(symbol), EEK_SYMBOL_CATEGORY_UNKNOWN);
return EEK_SYMBOL_GET_CLASS(symbol)->get_category (symbol);
}
void
eek_symbol_set_modifier_mask (EekSymbol *symbol,
EekModifierType mask)
{
g_return_if_fail (EEK_IS_SYMBOL(symbol));
return EEK_SYMBOL_GET_CLASS(symbol)->set_modifier_mask (symbol, mask);
}
EekModifierType
eek_symbol_get_modifier_mask (EekSymbol *symbol)
{
g_return_val_if_fail (EEK_IS_SYMBOL(symbol), 0);
return EEK_SYMBOL_GET_CLASS(symbol)->get_modifier_mask (symbol);
}

101
eek/eek-symbol.h Normal file
View File

@ -0,0 +1,101 @@
#ifndef EEK_SYMBOL_H
#define EEK_SYMBOL_H 1
#include <glib-object.h>
#include "eek-types.h"
G_BEGIN_DECLS
/**
* EekSymbolCategory:
* @EEK_SYMBOL_CATEGORY_LETTER: the symbol represents an alphabet letter
* @EEK_SYMBOL_CATEGORY_FUNCTION: the symbol represents a function
* @EEK_SYMBOL_CATEGORY_KEYNAME: the symbol does not have meaning but
* have a name
* @EEK_SYMBOL_CATEGORY_UNKNOWN: used for error reporting
*
* Category of the key symbols.
*/
typedef enum {
EEK_SYMBOL_CATEGORY_LETTER,
EEK_SYMBOL_CATEGORY_FUNCTION,
EEK_SYMBOL_CATEGORY_KEYNAME,
EEK_SYMBOL_CATEGORY_USER0,
EEK_SYMBOL_CATEGORY_USER1,
EEK_SYMBOL_CATEGORY_USER2,
EEK_SYMBOL_CATEGORY_USER3,
EEK_SYMBOL_CATEGORY_USER4,
EEK_SYMBOL_CATEGORY_UNKNOWN,
/*< private >*/
EEK_SYMBOL_CATEGORY_LAST = EEK_SYMBOL_CATEGORY_UNKNOWN
} EekSymbolCategory;
#define EEK_TYPE_SYMBOL (eek_symbol_get_type())
#define EEK_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EEK_TYPE_SYMBOL, EekSymbol))
#define EEK_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EEK_TYPE_SYMBOL, EekSymbolClass))
#define EEK_IS_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EEK_TYPE_SYMBOL))
#define EEK_IS_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EEK_TYPE_SYMBOL))
#define EEK_SYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EEK_TYPE_SYMBOL, EekSymbolClass))
typedef struct _EekSymbolClass EekSymbolClass;
typedef struct _EekSymbolPrivate EekSymbolPrivate;
struct _EekSymbol {
/*< private >*/
GObject parent;
EekSymbolPrivate *priv;
};
struct _EekSymbolClass {
/*< private >*/
GObjectClass parent_class;
/*< public >*/
void (* set_name) (EekSymbol *self,
const gchar *name);
G_CONST_RETURN gchar *(* get_name) (EekSymbol *self);
void (* set_label) (EekSymbol *self,
const gchar *label);
gchar *(* get_label) (EekSymbol *self);
void (* set_category) (EekSymbol *self,
EekSymbolCategory category);
EekSymbolCategory (* get_category) (EekSymbol *self);
void (* set_modifier_mask) (EekSymbol *self,
EekModifierType mask);
EekModifierType (* get_modifier_mask) (EekSymbol *self);
/*< private >*/
/* padding */
gpointer pdummy[24];
};
GType eek_symbol_get_type (void) G_GNUC_CONST;
EekSymbol *eek_symbol_new (const gchar *name);
void eek_symbol_set_name (EekSymbol *symbol,
const gchar *name);
G_CONST_RETURN gchar *eek_symbol_get_name (EekSymbol *symbol);
void eek_symbol_set_label (EekSymbol *symbol,
const gchar *label);
gchar *eek_symbol_get_label (EekSymbol *symbol);
void eek_symbol_set_category (EekSymbol *symbol,
EekSymbolCategory category);
EekSymbolCategory eek_symbol_get_category (EekSymbol *symbol);
EekModifierType eek_symbol_get_modifier_mask (EekSymbol *keysym);
void eek_symbol_set_modifier_mask (EekSymbol *keysym,
EekModifierType mask);
/**
* eek_symbol_is_modifier:
* @symbol: an #EekSymbol
*
* Check if @symbol is a modifier.
* Returns: %TRUE if @symbol is a modifier.
*/
#define eek_symbol_is_modifier(symbol) \
(eek_symbol_get_modifier_mask ((symbol)) != 0)
G_END_DECLS
#endif /* EEK_SYMBOL_H */

48
eek/eek-types.c
View File

@ -30,29 +30,55 @@
#include "eek-types.h"
#include <math.h>
/* EekKeysymMatrix */
static EekKeysymMatrix *
eek_keysym_matrix_copy (const EekKeysymMatrix *matrix)
/* EekSymbolMatrix */
EekSymbolMatrix *
eek_symbol_matrix_new (gint num_groups, gint num_levels)
{
return g_slice_dup (EekKeysymMatrix, matrix);
EekSymbolMatrix *matrix = g_slice_new (EekSymbolMatrix);
matrix->num_groups = num_groups;
matrix->num_levels = num_levels;
matrix->data = g_slice_alloc0 (sizeof (EekSymbol *) *
num_groups * num_levels);
return matrix;
}
static void
eek_keysym_matrix_free (EekKeysymMatrix *matrix)
EekSymbolMatrix *
eek_symbol_matrix_copy (const EekSymbolMatrix *matrix)
{
g_slice_free (EekKeysymMatrix, matrix);
EekSymbolMatrix *retval;
gint i, num_symbols = matrix->num_groups * matrix->num_levels;
retval = g_slice_dup (EekSymbolMatrix, matrix);
retval->data = g_slice_copy (sizeof (EekSymbol *) * num_symbols,
matrix->data);
for (i = 0; i < num_symbols; i++)
if (retval->data[i])
g_object_ref (retval->data[i]);
return retval;
}
void
eek_symbol_matrix_free (EekSymbolMatrix *matrix)
{
gint i, num_symbols = matrix->num_groups * matrix->num_levels;
for (i = 0; i < num_symbols; i++)
if (matrix->data[i])
g_object_unref (matrix->data[i]);
g_slice_free1 (sizeof (EekSymbol *) * num_symbols, matrix->data);
g_slice_free (EekSymbolMatrix, matrix);
}
GType
eek_keysym_matrix_get_type (void)
eek_symbol_matrix_get_type (void)
{
static GType our_type = 0;
if (our_type == 0)
our_type =
g_boxed_type_register_static ("EekKeysymMatrix",
(GBoxedCopyFunc)eek_keysym_matrix_copy,
(GBoxedFreeFunc)eek_keysym_matrix_free);
g_boxed_type_register_static ("EekSymbolMatrix",
(GBoxedCopyFunc)eek_symbol_matrix_copy,
(GBoxedFreeFunc)eek_symbol_matrix_free);
return our_type;
}

57
eek/eek-types.h
View File

@ -24,7 +24,7 @@
G_BEGIN_DECLS
#define EEK_TYPE_KEYSYM_MATRIX (eek_keysym_matrix_get_type ())
#define EEK_TYPE_SYMBOL_MATRIX (eek_symbol_matrix_get_type ())
#define EEK_TYPE_POINT (eek_point_get_type ())
#define EEK_TYPE_BOUNDS (eek_bounds_get_type ())
#define EEK_TYPE_OUTLINE (eek_outline_get_type ())
@ -62,34 +62,77 @@ typedef enum {
EEK_MODIFIER_BEHAVIOR_LATCH
} EekModifierBehavior;
typedef enum
{
EEK_SHIFT_MASK = 1 << 0,
EEK_LOCK_MASK = 1 << 1,
EEK_CONTROL_MASK = 1 << 2,
EEK_MOD1_MASK = 1 << 3,
EEK_MOD2_MASK = 1 << 4,
EEK_MOD3_MASK = 1 << 5,
EEK_MOD4_MASK = 1 << 6,
EEK_MOD5_MASK = 1 << 7,
EEK_BUTTON1_MASK = 1 << 8,
EEK_BUTTON2_MASK = 1 << 9,
EEK_BUTTON3_MASK = 1 << 10,
EEK_BUTTON4_MASK = 1 << 11,
EEK_BUTTON5_MASK = 1 << 12,
/* The next few modifiers are used by XKB, so we skip to the end.
* Bits 15 - 25 are currently unused. Bit 29 is used internally.
*/
EEK_SUPER_MASK = 1 << 26,
EEK_HYPER_MASK = 1 << 27,
EEK_META_MASK = 1 << 28,
EEK_RELEASE_MASK = 1 << 30,
EEK_MODIFIER_MASK = 0x5c001fff
} EekModifierType;
/**
* EEK_INVALID_KEYCODE:
*
* Pseudo keycode used for error reporting.
*/
#define EEK_INVALID_KEYCODE ((guint)(-1))
typedef struct _EekElement EekElement;
typedef struct _EekContainer EekContainer;
typedef struct _EekKey EekKey;
typedef struct _EekSection EekSection;
typedef struct _EekKeyboard EekKeyboard;
typedef struct _EekSymbol EekSymbol;
typedef struct _EekKeysym EekKeysym;
typedef struct _EekKeysymMatrix EekKeysymMatrix;
typedef struct _EekSymbolMatrix EekSymbolMatrix;
typedef struct _EekPoint EekPoint;
typedef struct _EekBounds EekBounds;
typedef struct _EekOutline EekOutline;
typedef struct _EekColor EekColor;
/**
* EekKeysymMatrix:
* @data: array of keysyms
* EekSymbolMatrix:
* @data: array of symbols
* @num_groups: the number of groups (rows)
* @num_levels: the number of levels (columns)
*
* Symbol matrix of a key.
*/
struct _EekKeysymMatrix
struct _EekSymbolMatrix
{
guint *data;
EekSymbol **data;
gint num_groups;
gint num_levels;
};
GType eek_keysym_matrix_get_type (void) G_GNUC_CONST;
GType eek_symbol_matrix_get_type
(void) G_GNUC_CONST;
EekSymbolMatrix * eek_symbol_matrix_new (gint num_groups,
gint num_levels);
EekSymbolMatrix *eek_symbol_matrix_copy (const EekSymbolMatrix *matrix);
void eek_symbol_matrix_free (EekSymbolMatrix *matrix);
/**
* EekPoint:

16
eek/eek-xkb-layout.c
View File

@ -123,11 +123,11 @@ create_key (EekXkbLayout *layout,
EekXkbLayoutPrivate *priv = layout->priv;
EekKey *key;
EekBounds bounds;
guint *keysyms = NULL;
EekSymbolMatrix *matrix = NULL;
gchar name[XkbKeyNameLength + 1];
EekOutline *outline;
KeyCode keycode;
gint num_groups, num_levels, num_keysyms;
gint num_groups, num_levels, num_symbols;
xkbgeometry = priv->xkb->geom;
xkbshape = &xkbgeometry->shapes[xkbkey->shape_ndx];
@ -193,12 +193,13 @@ create_key (EekXkbLayout *layout,
num_groups = XkbKeyNumGroups (priv->xkb, keycode);
num_levels = XkbKeyGroupsWidth (priv->xkb, keycode);
num_keysyms = num_groups * num_levels;
keysyms = g_slice_alloc0 (num_keysyms * sizeof(guint));
num_symbols = num_groups * num_levels;
matrix = eek_symbol_matrix_new (num_groups, num_levels);
for (i = 0; i < num_groups; i++)
for (j = 0; j < num_levels; j++) {
keysym = XkbKeySymEntry (priv->xkb, keycode, j, i);
keysyms[i * num_levels + j] = keysym;
matrix->data[i * num_levels + j] =
EEK_SYMBOL(eek_keysym_new (keysym));
}
}
@ -206,9 +207,8 @@ create_key (EekXkbLayout *layout,
eek_element_set_name (EEK_ELEMENT(key), name);
eek_element_set_bounds (EEK_ELEMENT(key), &bounds);
eek_key_set_keycode (key, keycode);
eek_key_set_keysyms (key, keysyms, num_groups, num_levels);
if (keysyms)
g_slice_free1 (num_keysyms * sizeof(guint), keysyms);
eek_key_set_symbol_matrix (key, matrix);
eek_symbol_matrix_free (matrix);
eek_key_set_outline (key, outline);
}

39
eek/eek-xml-layout.c
View File

@ -32,6 +32,7 @@
#include "eek-keyboard.h"
#include "eek-section.h"
#include "eek-key.h"
#include "eek-keysym.h"
enum {
PROP_0,
@ -64,7 +65,7 @@ struct _ParseCallbackData {
EekOrientation orientation;
GSList *points;
guint keycode;
GSList *keysyms;
GSList *symbols;
gint groups, levels;
EekOutline outline;
gchar *oref;
@ -89,7 +90,10 @@ static const gchar *valid_path_list[] = {
"symbols/key/section/keyboard",
"groups/symbols/key/section/keyboard",
"levels/symbols/key/section/keyboard",
"xkeysym/symbols/key/section/keyboard",
"keysym/symbols/key/section/keyboard",
"custom/symbols/key/section/keyboard",
"text/symbols/key/section/keyboard",
"icon/symbols/key/section/keyboard",
"invalid/symbols/key/section/keyboard",
"index/key/section/keyboard",
"point/outline/keyboard"
@ -207,7 +211,7 @@ start_element_callback (GMarkupParseContext *pcontext,
if (g_strcmp0 (element_name, "symbols") == 0) {
data->groups = groups;
data->levels = levels;
data->keysyms = NULL;
data->symbols = NULL;
goto out;
}
@ -253,23 +257,22 @@ end_element_callback (GMarkupParseContext *pcontext,
}
if (g_strcmp0 (element_name, "symbols") == 0) {
gint num_keysyms = data->groups * data->levels;
guint *keysyms = g_slice_alloc0 (sizeof(guint) * num_keysyms);
gint num_symbols = data->groups * data->levels;
EekSymbolMatrix *matrix = eek_symbol_matrix_new (data->groups,
data->levels);
head = data->keysyms = g_slist_reverse (data->keysyms);
for (i = 0; i < num_keysyms; i++) {
head = data->symbols = g_slist_reverse (data->symbols);
for (i = 0; i < num_symbols; i++) {
if (head && head->data) {
keysyms[i] = eek_xkeysym_from_string (head->data);
g_free (head->data);
matrix->data[i] = head->data;
head = g_slist_next (head);
} else
keysyms[i] = EEK_INVALID_KEYSYM;
matrix->data[i] = NULL;
}
eek_key_set_keysyms (data->key, keysyms, data->groups, data->levels);
g_slice_free1 (sizeof(guint) * num_keysyms, keysyms);
g_slist_free (data->keysyms);
data->keysyms = NULL;
eek_key_set_symbol_matrix (data->key, matrix);
g_slist_free (data->symbols);
data->symbols = NULL;
goto out;
}
@ -376,13 +379,15 @@ end_element_callback (GMarkupParseContext *pcontext,
goto out;
}
if (g_strcmp0 (element_name, "xkeysym") == 0) {
data->keysyms = g_slist_prepend (data->keysyms, g_strdup (text));
if (g_strcmp0 (element_name, "keysym") == 0) {
data->symbols =
g_slist_prepend (data->symbols,
eek_keysym_new_from_name (g_strdup (text)));
goto out;
}
if (g_strcmp0 (element_name, "invalid") == 0) {
data->keysyms = g_slist_prepend (data->keysyms, NULL);
data->symbols = g_slist_prepend (data->symbols, NULL);
goto out;
}

36
eek/eek-xml.c
View File

@ -27,6 +27,7 @@
#include "eek-section.h"
#include "eek-key.h"
#include "eek-xml.h"
#include "eek-keysym.h"
#define g_string_append_indent(string, indent) \
{ \
@ -74,8 +75,8 @@ output_key_callback (EekElement *element, gpointer user_data)
OutputCallbackData *data = user_data;
EekBounds bounds;
EekOutline *outline;
gint i, num_groups, num_levels, num_keysyms;
guint *keysyms;
gint i, num_symbols;
EekSymbolMatrix *matrix;
gint column, row;
eek_key_get_index (EEK_KEY(element), &column, &row);
@ -108,36 +109,27 @@ output_key_callback (EekElement *element, gpointer user_data)
i);
}
eek_key_get_keysyms (EEK_KEY(element), NULL, &num_groups, &num_levels);
num_keysyms = num_groups * num_levels;
if (num_keysyms > 0) {
keysyms = g_slice_alloc (num_keysyms * sizeof(guint));
eek_key_get_keysyms (EEK_KEY(element), &keysyms, NULL, NULL);
matrix = eek_key_get_symbol_matrix (EEK_KEY(element));
num_symbols = matrix->num_groups * matrix->num_levels;
if (num_symbols > 0) {
g_string_append_indent (data->output, data->indent + 1);
g_string_markup_printf (data->output,
"<symbols groups=\"%d\" levels=\"%d\">\n",
num_groups, num_levels);
matrix->num_groups, matrix->num_levels);
for (i = 0; i < num_groups * num_levels; i++) {
for (i = 0; i < num_symbols; i++) {
g_string_append_indent (data->output, data->indent + 2);
if (keysyms[i] != EEK_INVALID_KEYSYM) {
gchar *name = eek_xkeysym_to_string (keysyms[i]);
if (name) {
if (EEK_IS_KEYSYM(matrix->data[i]))
g_string_markup_printf (data->output,
"<xkeysym>%s</xkeysym>\n",
name);
g_free (name);
} else
"<keysym>%s</keysym>\n",
eek_symbol_get_name (matrix->data[i]));
else
g_string_markup_printf (data->output,
"<invalid/>\n");
} else
g_string_markup_printf (data->output,
"<invalid/>\n");
"<symbol>%s</symbol>\n",
eek_symbol_get_name (matrix->data[i]));
}
g_string_append_indent (data->output, data->indent + 1);
g_string_markup_printf (data->output, "</symbols>\n");
g_slice_free1 (num_keysyms * sizeof(guint), keysyms);
}
g_string_append_indent (data->output, data->indent);

1
eek/eek.h
View File

@ -24,6 +24,7 @@
#include "eek-section.h"
#include "eek-key.h"
#include "eek-layout.h"
#include "eek-symbol.h"
#include "eek-keysym.h"
#include "eek-xml.h"

1306
eek/keyname-keysym-entries.txt
View File

File diff suppressed because it is too large Load Diff

62
eek/special-keysym-entries.txt
View File

@ -1,31 +1,31 @@
0x20 "" EEK_KEYSYM_CATEGORY_LETTER
0x8A3 "horiz\nconn" EEK_KEYSYM_CATEGORY_LETTER
0xFE50 "ˋ" EEK_KEYSYM_CATEGORY_LETTER
0xFE51 "ˊ" EEK_KEYSYM_CATEGORY_LETTER
0xFE52 "ˆ" EEK_KEYSYM_CATEGORY_LETTER
0xFE53 "~" EEK_KEYSYM_CATEGORY_LETTER
0xFE54 "ˉ" EEK_KEYSYM_CATEGORY_LETTER
0xFE55 "˘" EEK_KEYSYM_CATEGORY_LETTER
0xFE56 "˙" EEK_KEYSYM_CATEGORY_LETTER
0xFE57 "¨" EEK_KEYSYM_CATEGORY_LETTER
0xFE58 "˚" EEK_KEYSYM_CATEGORY_LETTER
0xFE59 "˝" EEK_KEYSYM_CATEGORY_LETTER
0xFE5A "ˇ" EEK_KEYSYM_CATEGORY_LETTER
0xFE5B "¸" EEK_KEYSYM_CATEGORY_LETTER
0xFE5C "˛" EEK_KEYSYM_CATEGORY_LETTER
0xFF14 "Scroll\nLock" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF20 "Compose" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF55 "Page\nUp" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF56 "Page\nDown" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF7E "AltGr" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF7F "Num\nLock" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF8D "Enter" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF95 "Home" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF96 "Left" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF97 "Up" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF98 "Right" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF99 "Down" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF9C "End" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF9D "Begin" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF9E "Ins" EEK_KEYSYM_CATEGORY_FUNCTION
0xFF9F "Del" EEK_KEYSYM_CATEGORY_FUNCTION
0x20 "" EEK_SYMBOL_CATEGORY_LETTER
0x8A3 "horiz\nconn" EEK_SYMBOL_CATEGORY_LETTER
0xFE50 "ˋ" EEK_SYMBOL_CATEGORY_LETTER
0xFE51 "ˊ" EEK_SYMBOL_CATEGORY_LETTER
0xFE52 "ˆ" EEK_SYMBOL_CATEGORY_LETTER
0xFE53 "~" EEK_SYMBOL_CATEGORY_LETTER
0xFE54 "ˉ" EEK_SYMBOL_CATEGORY_LETTER
0xFE55 "˘" EEK_SYMBOL_CATEGORY_LETTER
0xFE56 "˙" EEK_SYMBOL_CATEGORY_LETTER
0xFE57 "¨" EEK_SYMBOL_CATEGORY_LETTER
0xFE58 "˚" EEK_SYMBOL_CATEGORY_LETTER
0xFE59 "˝" EEK_SYMBOL_CATEGORY_LETTER
0xFE5A "ˇ" EEK_SYMBOL_CATEGORY_LETTER
0xFE5B "¸" EEK_SYMBOL_CATEGORY_LETTER
0xFE5C "˛" EEK_SYMBOL_CATEGORY_LETTER
0xFF14 "Scroll\nLock" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF20 "Compose" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF55 "Page\nUp" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF56 "Page\nDown" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF7E "AltGr" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF7F "Num\nLock" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF8D "Enter" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF95 "Home" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF96 "Left" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF97 "Up" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF98 "Right" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF99 "Down" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9C "End" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9D "Begin" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9E "Ins" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9F "Del" EEK_SYMBOL_CATEGORY_FUNCTION

1540
eek/unicode-keysym-entries.txt
View File

File diff suppressed because it is too large Load Diff

1306
eek/xkeysym-keysym-entries.txt Normal file
View File

File diff suppressed because it is too large Load Diff

22
src/eekboard.c
View File

@ -382,7 +382,7 @@ a11y_keystroke_listener (const AccessibleKeystroke *stroke,
{
Eekboard *eekboard = user_data;
EekKey *key;
guint keysym;
EekSymbol *symbol;
guint ignored_keysyms[] = {XK_Shift_L,
XK_Shift_R,
XK_ISO_Level3_Shift,
@ -399,10 +399,11 @@ a11y_keystroke_listener (const AccessibleKeystroke *stroke,
/* XXX: Ignore modifier keys since there is no way to receive
SPI_KEY_RELEASED event for them. */
keysym = eek_key_get_keysym (key);
for (i = 0; i < G_N_ELEMENTS(ignored_keysyms) &&
keysym != ignored_keysyms[i]; i++)
;
symbol = eek_key_get_symbol (key);
for (i = 0; i < G_N_ELEMENTS(ignored_keysyms); i++)
if (EEK_IS_KEYSYM(symbol) &&
eek_keysym_get_xkeysym (EEK_KEYSYM(symbol)) == ignored_keysyms[i])
break;
if (i != G_N_ELEMENTS(ignored_keysyms))
return FALSE;
@ -431,16 +432,17 @@ on_key_pressed (EekKeyboard *keyboard,
gpointer user_data)
{
Eekboard *eekboard = user_data;
guint keysym;
EekSymbol *symbol;
keysym = eek_key_get_keysym (key);
symbol = eek_key_get_symbol (key);
EEKBOARD_NOTE("%s %X",
eek_keysym_to_string (keysym),
eek_symbol_get_name (symbol),
eek_keyboard_get_modifiers (keyboard));
if (!eek_keysym_is_modifier (keysym))
if (!eek_symbol_is_modifier (symbol) &&
EEK_IS_KEYSYM(symbol))
fakekey_press_keysym (eekboard->fakekey,
keysym,
eek_keysym_get_xkeysym (EEK_KEYSYM(symbol)),
eek_keyboard_get_modifiers (keyboard));
}

2
tests/eek-xml-test.c
View File

@ -41,7 +41,7 @@ test_output_parse (void)
eek_keyboard_output (keyboard, output, 0);
g_object_unref (keyboard);
#if 1
#if 0
fwrite (output->str, sizeof(gchar), output->len, stdout);
#endif

466
tests/test-keyboard.xml
View File

File diff suppressed because it is too large Load Diff