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

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

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

184
eek/eek-key.c
View File

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

92
eek/eek-key.h
View File

@ -48,8 +48,8 @@ struct _EekKey
* EekKeyClass: * EekKeyClass:
* @set_keycode: virtual function for setting keycode of the key * @set_keycode: virtual function for setting keycode of the key
* @get_keycode: virtual function for getting 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 * @set_symbol_matrix: virtual function for setting symbol matrix of the key
* @get_keysyms: virtual function for getting 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 * @set_index: virtual function for setting position of the key in the
* section * section
* @get_index: virtual function for getting position of the key in the * @get_index: virtual function for getting position of the key in the
@ -66,70 +66,60 @@ struct _EekKeyClass
EekElementClass parent_class; EekElementClass parent_class;
/*< public >*/ /*< public >*/
void (* set_keycode) (EekKey *self, void (* set_keycode) (EekKey *self,
guint keycode); guint keycode);
guint (* get_keycode) (EekKey *self); guint (* get_keycode) (EekKey *self);
void (* set_keysyms) (EekKey *self, void (* set_symbol_matrix) (EekKey *self,
guint *keysyms, EekSymbolMatrix *matrix);
gint num_groups, EekSymbolMatrix *(* get_symbol_matrix) (EekKey *self);
gint num_levels);
void (* get_keysyms) (EekKey *self,
guint **keysyms,
gint *num_groups,
gint *num_levels);
void (* set_index) (EekKey *self, void (* set_index) (EekKey *self,
gint column, gint column,
gint row); gint row);
void (* get_index) (EekKey *self, void (* get_index) (EekKey *self,
gint *column, gint *column,
gint *row); gint *row);
void (* set_outline) (EekKey *self, void (* set_outline) (EekKey *self,
EekOutline *outline); EekOutline *outline);
EekOutline *(* get_outline) (EekKey *self); EekOutline *(* get_outline) (EekKey *self);
gboolean (* is_pressed) (EekKey *self); gboolean (* is_pressed) (EekKey *self);
/* signals */ /* signals */
void (* pressed) (EekKey *key); void (* pressed) (EekKey *key);
void (* released) (EekKey *key); void (* released) (EekKey *key);
/*< private >*/ /*< private >*/
/* padding */ /* padding */
gpointer pdummy[23]; gpointer pdummy[23];
}; };
GType eek_key_get_type (void) G_GNUC_CONST; GType eek_key_get_type (void) G_GNUC_CONST;
void eek_key_set_keycode (EekKey *key, void eek_key_set_keycode (EekKey *key,
guint keycode); guint keycode);
guint eek_key_get_keycode (EekKey *key); guint eek_key_get_keycode (EekKey *key);
void eek_key_set_keysyms (EekKey *key, void eek_key_set_symbol_matrix (EekKey *key,
guint *keysyms, EekSymbolMatrix *matrix);
gint num_groups, EekSymbolMatrix *eek_key_get_symbol_matrix (EekKey *key);
gint num_levels); EekSymbol *eek_key_get_symbol (EekKey *key);
void eek_key_get_keysyms (EekKey *key, EekSymbol *eek_key_get_symbol_at_index (EekKey *key,
guint **keysyms, gint group,
gint *num_groups, gint level);
gint *num_levels);
guint eek_key_get_keysym (EekKey *key);
guint eek_key_get_keysym_at_index (EekKey *key,
gint group,
gint level);
void eek_key_set_index (EekKey *key, void eek_key_set_index (EekKey *key,
gint column, gint column,
gint row); gint row);
void eek_key_get_index (EekKey *key, void eek_key_get_index (EekKey *key,
gint *column, gint *column,
gint *row); gint *row);
void eek_key_set_outline (EekKey *key, void eek_key_set_outline (EekKey *key,
EekOutline *outline); EekOutline *outline);
EekOutline *eek_key_get_outline (EekKey *key); EekOutline *eek_key_get_outline (EekKey *key);
gboolean eek_key_is_pressed (EekKey *key); gboolean eek_key_is_pressed (EekKey *key);
G_END_DECLS G_END_DECLS
#endif /* EEK_KEY_H */ #endif /* EEK_KEY_H */

72
eek/eek-keyboard.c
View File

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

11
eek/eek-keyboard.h
View File

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

357
eek/eek-keysym.c
View File

@ -20,27 +20,57 @@
/** /**
* SECTION:eek-keysym * 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> #include <stdlib.h>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include "config.h" #include "config.h"
#endif /* HAVE_CONFIG_H */ #endif /* HAVE_CONFIG_H */
#include "eek-keysym.h" #include "eek-keysym.h"
struct _EekKeysymEntry { /* modifier keys */
guint keysym; #define EEK_KEYSYM_Shift_L 0xffe1
const gchar *label; #define EEK_KEYSYM_Shift_R 0xffe2
EekKeysymCategory category; #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-special-keysym-entries.h"
#include "eek-unicode-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 * static gchar *
unichar_to_utf8 (gunichar uc) unichar_to_utf8 (gunichar uc)
@ -58,202 +88,179 @@ unichar_to_utf8 (gunichar uc)
} }
static int 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; const EekKeysymEntry *entry0 = key0, *entry1 = key1;
return (gint)entry0->keysym - (gint)entry1->keysym; return (gint)entry0->xkeysym - (gint)entry1->xkeysym;
} }
static gboolean static EekKeysymEntry *
find_keysym (guint keysym, find_keysym_entry_by_xkeysym (guint xkeysym,
gchar **label, const EekKeysymEntry *entries,
EekKeysymCategory *category) 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. */ /* First, search special keysyms. */
bsearch_key.keysym = keysym; entry = find_keysym_entry_by_xkeysym (priv->xkeysym,
bsearch_val = bsearch (&bsearch_key, special_keysym_entries,
special_keysym_entries, G_N_ELEMENTS(special_keysym_entries));
G_N_ELEMENTS(special_keysym_entries), if (entry)
sizeof (EekKeysymEntry), return g_strdup (entry->name);
keysym_entry_compare_keysym);
if (bsearch_val) {
if (label)
*label = g_strdup (bsearch_val->label);
if (category)
*category = bsearch_val->category;
return TRUE;
}
/* Check for Latin-1 characters (1:1 mapping) */ /* Check for Latin-1 characters (1:1 mapping) */
if ((keysym >= 0x0020 && keysym <= 0x007e) || if ((priv->xkeysym >= 0x0020 && priv->xkeysym <= 0x007e) ||
(keysym >= 0x00a0 && keysym <= 0x00ff)) { (priv->xkeysym >= 0x00a0 && priv->xkeysym <= 0x00ff))
if (label) return unichar_to_utf8 (priv->xkeysym);
*label = unichar_to_utf8 (keysym);
if (category)
*category = EEK_KEYSYM_CATEGORY_LETTER;
return TRUE;
}
/* Also check for directly encoded 24-bit UCS characters: /* Also check for directly encoded 24-bit UCS characters:
*/ */
if ((keysym & 0xff000000) == 0x01000000) { if ((priv->xkeysym & 0xff000000) == 0x01000000)
if (label) return unichar_to_utf8 (priv->xkeysym & 0x00ffffff);
*label = unichar_to_utf8 (keysym & 0x00ffffff);
if (category)
*category = EEK_KEYSYM_CATEGORY_LETTER;
return TRUE;
}
/* Search known unicode keysyms. */ /* Search known unicode keysyms. */
bsearch_key.keysym = keysym; entry = find_keysym_entry_by_xkeysym (priv->xkeysym,
bsearch_val = bsearch (&bsearch_key, unicode_keysym_entries,
unicode_keysym_entries, G_N_ELEMENTS(unicode_keysym_entries));
G_N_ELEMENTS(unicode_keysym_entries), if (entry)
sizeof (EekKeysymEntry), return g_strdup (entry->name);
keysym_entry_compare_keysym);
if (bsearch_val) {
if (label)
*label = g_strdup (bsearch_val->label);
if (category)
*category = bsearch_val->category;
return TRUE;
}
/* Finally, search keynames. */ return g_strdup (eek_symbol_get_name (self));
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;
} }
/** EekSymbolCategory
* eek_keysym_to_string: eek_keysym_real_get_category (EekSymbol *self)
* @keysym: keysym ID
*
* Return a string representation of @keysym.
*/
gchar *
eek_keysym_to_string (guint keysym)
{ {
gchar *label; EekKeysymPrivate *priv = EEK_KEYSYM_GET_PRIVATE(self);
return priv->category;
if (find_keysym (keysym, &label, NULL))
return label;
return g_strdup ("");
} }
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 EekModifierType
eek_keysym_to_modifier (guint keysym) eek_keysym_real_get_modifier_mask (EekSymbol *self)
{ {
switch (keysym) { EekKeysymPrivate *priv = EEK_KEYSYM_GET_PRIVATE(self);
case EEK_KEY_Shift_L:
case EEK_KEY_Shift_R: switch (priv->xkeysym) {
case EEK_KEY_Caps_Lock: case EEK_KEYSYM_Shift_L:
case EEK_KEY_Shift_Lock: case EEK_KEYSYM_Shift_R:
case EEK_KEYSYM_Caps_Lock:
case EEK_KEYSYM_Shift_Lock:
return EEK_SHIFT_MASK; return EEK_SHIFT_MASK;
case EEK_KEY_ISO_Level3_Shift: case EEK_KEYSYM_ISO_Level3_Shift:
return EEK_MOD5_MASK; return EEK_MOD5_MASK;
case EEK_KEY_Control_L: case EEK_KEYSYM_Control_L:
case EEK_KEY_Control_R: case EEK_KEYSYM_Control_R:
return EEK_CONTROL_MASK; return EEK_CONTROL_MASK;
case EEK_KEY_Alt_L: case EEK_KEYSYM_Alt_L:
case EEK_KEY_Alt_R: case EEK_KEYSYM_Alt_R:
return EEK_MOD1_MASK; return EEK_MOD1_MASK;
case EEK_KEY_Meta_L: case EEK_KEYSYM_Meta_L:
case EEK_KEY_Meta_R: case EEK_KEYSYM_Meta_R:
return EEK_META_MASK; return EEK_META_MASK;
case EEK_KEY_Super_L: case EEK_KEYSYM_Super_L:
case EEK_KEY_Super_R: case EEK_KEYSYM_Super_R:
return EEK_SUPER_MASK; return EEK_SUPER_MASK;
case EEK_KEY_Hyper_L: case EEK_KEYSYM_Hyper_L:
case EEK_KEY_Hyper_R: case EEK_KEYSYM_Hyper_R:
return EEK_HYPER_MASK; return EEK_HYPER_MASK;
} }
return 0; 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 #ifndef EEK_KEYSYM_H
#define EEK_KEYSYM_H 1 #define EEK_KEYSYM_H 1
#include <glib-object.h> #include "eek-symbol.h"
G_BEGIN_DECLS
/** /**
* EEK_INVALID_KEYSYM: * EEK_INVALID_KEYSYM:
@ -29,93 +31,34 @@
*/ */
#define EEK_INVALID_KEYSYM ((guint)(-1)) #define EEK_INVALID_KEYSYM ((guint)(-1))
/** #define EEK_TYPE_KEYSYM (eek_keysym_get_type())
* EEK_INVALID_KEYCODE: #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))
* Pseudo keycode used for error reporting. #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_INVALID_KEYCODE ((guint)(-1)) #define EEK_KEYSYM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EEK_TYPE_KEYSYM, EekKeysymClass))
/** typedef struct _EekKeysymClass EekKeysymClass;
* EekKeysymCategory: typedef struct _EekKeysymPrivate EekKeysymPrivate;
* @EEK_KEYSYM_CATEGORY_LETTER: the symbol represents an alphabet letter
* @EEK_KEYSYM_CATEGORY_FUNCTION: the symbol represents a function struct _EekKeysym {
* @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,
/*< private >*/ /*< private >*/
EEK_KEYSYM_CATEGORY_LAST = EEK_KEYSYM_CATEGORY_UNKNOWN EekSymbol parent;
} EekKeysymCategory;
gchar *eek_keysym_to_string (guint keysym); EekKeysymPrivate *priv;
};
gchar *eek_xkeysym_to_string (guint xkeysym); struct _EekKeysymClass {
guint eek_xkeysym_from_string (gchar *string); /*< 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 EekKeysym *eek_keysym_new_from_name (const gchar *name);
{
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. G_END_DECLS
* 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)
#endif /* EEK_KEYSYM_H */ #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 static void
eek_layout_class_init (EekLayoutClass *klass) eek_layout_class_init (EekLayoutClass *klass)
{ {
klass->create_keyboard = NULL;
} }
void void

46
eek/eek-renderer.c
View File

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

57
eek/eek-types.h
View File

@ -24,7 +24,7 @@
G_BEGIN_DECLS 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_POINT (eek_point_get_type ())
#define EEK_TYPE_BOUNDS (eek_bounds_get_type ()) #define EEK_TYPE_BOUNDS (eek_bounds_get_type ())
#define EEK_TYPE_OUTLINE (eek_outline_get_type ()) #define EEK_TYPE_OUTLINE (eek_outline_get_type ())
@ -61,35 +61,78 @@ typedef enum {
EEK_MODIFIER_BEHAVIOR_LOCK, EEK_MODIFIER_BEHAVIOR_LOCK,
EEK_MODIFIER_BEHAVIOR_LATCH EEK_MODIFIER_BEHAVIOR_LATCH
} EekModifierBehavior; } 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 _EekElement EekElement;
typedef struct _EekContainer EekContainer; typedef struct _EekContainer EekContainer;
typedef struct _EekKey EekKey; typedef struct _EekKey EekKey;
typedef struct _EekSection EekSection; typedef struct _EekSection EekSection;
typedef struct _EekKeyboard EekKeyboard; 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 _EekPoint EekPoint;
typedef struct _EekBounds EekBounds; typedef struct _EekBounds EekBounds;
typedef struct _EekOutline EekOutline; typedef struct _EekOutline EekOutline;
typedef struct _EekColor EekColor; typedef struct _EekColor EekColor;
/** /**
* EekKeysymMatrix: * EekSymbolMatrix:
* @data: array of keysyms * @data: array of symbols
* @num_groups: the number of groups (rows) * @num_groups: the number of groups (rows)
* @num_levels: the number of levels (columns) * @num_levels: the number of levels (columns)
* *
* Symbol matrix of a key. * Symbol matrix of a key.
*/ */
struct _EekKeysymMatrix struct _EekSymbolMatrix
{ {
guint *data; EekSymbol **data;
gint num_groups; gint num_groups;
gint num_levels; 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: * EekPoint:

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

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

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

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

38
eek/eek-xml.c
View File

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

1
eek/eek.h
View File

@ -24,6 +24,7 @@
#include "eek-section.h" #include "eek-section.h"
#include "eek-key.h" #include "eek-key.h"
#include "eek-layout.h" #include "eek-layout.h"
#include "eek-symbol.h"
#include "eek-keysym.h" #include "eek-keysym.h"
#include "eek-xml.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 0x20 "" EEK_SYMBOL_CATEGORY_LETTER
0x8A3 "horiz\nconn" EEK_KEYSYM_CATEGORY_LETTER 0x8A3 "horiz\nconn" EEK_SYMBOL_CATEGORY_LETTER
0xFE50 "ˋ" EEK_KEYSYM_CATEGORY_LETTER 0xFE50 "ˋ" EEK_SYMBOL_CATEGORY_LETTER
0xFE51 "ˊ" EEK_KEYSYM_CATEGORY_LETTER 0xFE51 "ˊ" EEK_SYMBOL_CATEGORY_LETTER
0xFE52 "ˆ" EEK_KEYSYM_CATEGORY_LETTER 0xFE52 "ˆ" EEK_SYMBOL_CATEGORY_LETTER
0xFE53 "~" EEK_KEYSYM_CATEGORY_LETTER 0xFE53 "~" EEK_SYMBOL_CATEGORY_LETTER
0xFE54 "ˉ" EEK_KEYSYM_CATEGORY_LETTER 0xFE54 "ˉ" EEK_SYMBOL_CATEGORY_LETTER
0xFE55 "˘" EEK_KEYSYM_CATEGORY_LETTER 0xFE55 "˘" EEK_SYMBOL_CATEGORY_LETTER
0xFE56 "˙" EEK_KEYSYM_CATEGORY_LETTER 0xFE56 "˙" EEK_SYMBOL_CATEGORY_LETTER
0xFE57 "¨" EEK_KEYSYM_CATEGORY_LETTER 0xFE57 "¨" EEK_SYMBOL_CATEGORY_LETTER
0xFE58 "˚" EEK_KEYSYM_CATEGORY_LETTER 0xFE58 "˚" EEK_SYMBOL_CATEGORY_LETTER
0xFE59 "˝" EEK_KEYSYM_CATEGORY_LETTER 0xFE59 "˝" EEK_SYMBOL_CATEGORY_LETTER
0xFE5A "ˇ" EEK_KEYSYM_CATEGORY_LETTER 0xFE5A "ˇ" EEK_SYMBOL_CATEGORY_LETTER
0xFE5B "¸" EEK_KEYSYM_CATEGORY_LETTER 0xFE5B "¸" EEK_SYMBOL_CATEGORY_LETTER
0xFE5C "˛" EEK_KEYSYM_CATEGORY_LETTER 0xFE5C "˛" EEK_SYMBOL_CATEGORY_LETTER
0xFF14 "Scroll\nLock" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF14 "Scroll\nLock" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF20 "Compose" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF20 "Compose" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF55 "Page\nUp" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF55 "Page\nUp" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF56 "Page\nDown" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF56 "Page\nDown" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF7E "AltGr" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF7E "AltGr" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF7F "Num\nLock" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF7F "Num\nLock" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF8D "Enter" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF8D "Enter" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF95 "Home" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF95 "Home" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF96 "Left" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF96 "Left" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF97 "Up" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF97 "Up" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF98 "Right" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF98 "Right" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF99 "Down" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF99 "Down" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9C "End" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF9C "End" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9D "Begin" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF9D "Begin" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9E "Ins" EEK_KEYSYM_CATEGORY_FUNCTION 0xFF9E "Ins" EEK_SYMBOL_CATEGORY_FUNCTION
0xFF9F "Del" EEK_KEYSYM_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; Eekboard *eekboard = user_data;
EekKey *key; EekKey *key;
guint keysym; EekSymbol *symbol;
guint ignored_keysyms[] = {XK_Shift_L, guint ignored_keysyms[] = {XK_Shift_L,
XK_Shift_R, XK_Shift_R,
XK_ISO_Level3_Shift, 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 /* XXX: Ignore modifier keys since there is no way to receive
SPI_KEY_RELEASED event for them. */ SPI_KEY_RELEASED event for them. */
keysym = eek_key_get_keysym (key); symbol = eek_key_get_symbol (key);
for (i = 0; i < G_N_ELEMENTS(ignored_keysyms) && for (i = 0; i < G_N_ELEMENTS(ignored_keysyms); i++)
keysym != ignored_keysyms[i]; i++) if (EEK_IS_KEYSYM(symbol) &&
; eek_keysym_get_xkeysym (EEK_KEYSYM(symbol)) == ignored_keysyms[i])
break;
if (i != G_N_ELEMENTS(ignored_keysyms)) if (i != G_N_ELEMENTS(ignored_keysyms))
return FALSE; return FALSE;
@ -431,16 +432,17 @@ on_key_pressed (EekKeyboard *keyboard,
gpointer user_data) gpointer user_data)
{ {
Eekboard *eekboard = 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", EEKBOARD_NOTE("%s %X",
eek_keysym_to_string (keysym), eek_symbol_get_name (symbol),
eek_keyboard_get_modifiers (keyboard)); 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, fakekey_press_keysym (eekboard->fakekey,
keysym, eek_keysym_get_xkeysym (EEK_KEYSYM(symbol)),
eek_keyboard_get_modifiers (keyboard)); 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); eek_keyboard_output (keyboard, output, 0);
g_object_unref (keyboard); g_object_unref (keyboard);
#if 1 #if 0
fwrite (output->str, sizeof(gchar), output->len, stdout); fwrite (output->str, sizeof(gchar), output->len, stdout);
#endif #endif

466
tests/test-keyboard.xml
View File

File diff suppressed because it is too large Load Diff