Major code overhaul, and a lot more method coverage

3 files changed, 981 insertions, 122 deletions

diff --git a/xklavier/xklavier.defs b/xklavier/xklavier.defs
index 2883ed4..40eeeeb 100644
--- a/xklavier/xklavier.defs
+++ b/xklavier/xklavier.defs
@@ -1,5 +1,26 @@
 ;; -*- scheme -*-
 ; object definitions ...
+(define-object ConfigItem
+  (in-module "Xkl")
+  (parent "GObject")
+  (c-name "XklConfigItem")
+  (gtype-id "XKL_TYPE_CONFIG_ITEM")
+)
+
+(define-object ConfigRec
+  (in-module "Xkl")
+  (parent "GObject")
+  (c-name "XklConfigRec")
+  (gtype-id "XKL_TYPE_CONFIG_REC")
+)
+
+(define-object ConfigRegistry
+  (in-module "Xkl")
+  (parent "GObject")
+  (c-name "XklConfigRegistry")
+  (gtype-id "XKL_TYPE_CONFIG_REGISTRY")
+)
+
 (define-object Engine
   (in-module "Xkl")
   (parent "GObject")
@@ -7,57 +28,209 @@
   (gtype-id "XKL_TYPE_ENGINE")
 )
 
-;; methods
+;; Enumerations and flags ...
 
-(define-function xkl_engine_get_instance
-  (c-name "xkl_engine_get_instance")
-  (is-constructor-of "XklEngine")
-  (return-type "XklEngine*")
+(define-enum EngineStateChange
+  (in-module "Xkl")
+  (c-name "XklEngineStateChange")
+  (gtype-id "XKL_TYPE_ENGINE_STATE_CHANGE")
+  (values
+    '("group-changed" "GROUP_CHANGED")
+    '("indicators-changed" "INDICATORS_CHANGED")
+  )
 )
 
-(define-method get_backend_name
-  (of-object "XklEngine")
-  (c-name "xkl_engine_get_backend_name")
-  (return-type "const-gchar*")
+(define-enum EngineFeatures
+  (in-module "Xkl")
+  (c-name "XklEngineFeatures")
+  (gtype-id "XKL_TYPE_ENGINE_FEATURES")
+  (values
+    '("can-toggle-indicators" "XKLF_CAN_TOGGLE_INDICATORS")
+    '("can-output-config-as-ascii" "XKLF_CAN_OUTPUT_CONFIG_AS_ASCII")
+    '("can-output-config-as-binary" "XKLF_CAN_OUTPUT_CONFIG_AS_BINARY")
+    '("multiple-layouts-supported" "XKLF_MULTIPLE_LAYOUTS_SUPPORTED")
+    '("requires-manual-layout-management" "XKLF_REQUIRES_MANUAL_LAYOUT_MANAGEMENT")
+    '("device-discovery" "XKLF_DEVICE_DISCOVERY")
+  )
 )
 
-(define-method start_listen
-  (of-object "XklEngine")
-  (c-name "xkl_engine_start_listen")
-  (return-type "gint")
+(define-enum EngineListenModes
+  (in-module "Xkl")
+  (c-name "XklEngineListenModes")
+  (gtype-id "XKL_TYPE_ENGINE_LISTEN_MODES")
+  (values
+    '("manage-window-states" "XKLL_MANAGE_WINDOW_STATES")
+    '("track-keyboard-state" "XKLL_TRACK_KEYBOARD_STATE")
+    '("manage-layouts" "XKLL_MANAGE_LAYOUTS")
+  )
+)
+
+
+;; From xklavier.h
+
+(define-function void
+  (c-name "void")
+  (return-type "typedef")
   (parameters
-    '("guint" "flags")
+    '("*" "XklLogAppender")
   )
 )
 
-(define-method stop_listen
-  (of-object "XklEngine")
-  (c-name "xkl_engine_stop_listen")
-  (return-type "gint")
+(define-function xkl_default_log_appender
+  (c-name "xkl_default_log_appender")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "file")
+    '("const-gchar*" "function")
+    '("gint" "level")
+    '("const-gchar*" "format")
+    '("va_list" "args")
+  )
 )
 
-(define-method pause_listen
-  (of-object "XklEngine")
-  (c-name "xkl_engine_pause_listen")
-  (return-type "gint")
+(define-function xkl_set_log_appender
+  (c-name "xkl_set_log_appender")
+  (return-type "none")
+  (parameters
+    '("XklLogAppender" "fun")
+  )
 )
 
-(define-method resume_listen
+(define-function xkl_set_debug_level
+  (c-name "xkl_set_debug_level")
+  (return-type "none")
+  (parameters
+    '("gint" "level")
+  )
+)
+
+
+
+;; From xkl_config_item.h
+
+(define-function xkl_config_item_get_type
+  (c-name "xkl_config_item_get_type")
+  (return-type "GType")
+)
+
+(define-function xkl_config_item_new
+  (c-name "xkl_config_item_new")
+  (is-constructor-of "XklConfigItem")
+  (return-type "XklConfigItem*")
+)
+
+
+
+;; From xkl_config_rec.h
+
+(define-function xkl_config_rec_get_type
+  (c-name "xkl_config_rec_get_type")
+  (return-type "GType")
+)
+
+(define-function xkl_config_rec_new
+  (c-name "xkl_config_rec_new")
+  (is-constructor-of "XklConfigRec")
+  (return-type "XklConfigRec*")
+)
+
+(define-method activate
+  (of-object "XklConfigRec")
+  (c-name "xkl_config_rec_activate")
+  (return-type "gboolean")
+  (parameters
+    '("XklEngine*" "engine")
+  )
+)
+
+(define-method get_from_server
+  (of-object "XklConfigRec")
+  (c-name "xkl_config_rec_get_from_server")
+  (return-type "gboolean")
+  (parameters
+    '("XklEngine*" "engine")
+  )
+)
+
+(define-method get_from_backup
+  (of-object "XklConfigRec")
+  (c-name "xkl_config_rec_get_from_backup")
+  (return-type "gboolean")
+  (parameters
+    '("XklEngine*" "engine")
+  )
+)
+
+(define-function xkl_config_rec_write_to_file
+  (c-name "xkl_config_rec_write_to_file")
+  (return-type "gboolean")
+  (parameters
+    '("XklEngine*" "engine")
+    '("const-gchar*" "file_name")
+    '("const-XklConfigRec*" "data")
+    '("gboolean" "binary")
+  )
+)
+
+(define-method get_from_root_window_property
+  (of-object "XklConfigRec")
+  (c-name "xkl_config_rec_get_from_root_window_property")
+  (return-type "gboolean")
+  (parameters
+    '("Atom" "rules_atom_name")
+    '("gchar**" "rules_file_out")
+    '("XklEngine*" "engine")
+  )
+)
+
+(define-method set_to_root_window_property
+  (of-object "XklConfigRec")
+  (c-name "xkl_config_rec_set_to_root_window_property")
+  (return-type "gboolean")
+  (parameters
+    '("Atom" "rules_atom_name")
+    '("gchar*" "rules_file")
+    '("XklEngine*" "engine")
+  )
+)
+
+(define-method backup_names_prop
   (of-object "XklEngine")
-  (c-name "xkl_engine_resume_listen")
-  (return-type "gint")
+  (c-name "xkl_engine_backup_names_prop")
+  (return-type "gboolean")
 )
 
-; object definitions ...
+(define-function xkl_restore_names_prop
+  (c-name "xkl_restore_names_prop")
+  (return-type "gboolean")
+  (parameters
+    '("XklEngine*" "engine")
+  )
+)
 
-(define-object ConfigRegistry
-  (in-module "Xkl")
-  (parent "GObject")
-  (c-name "XklConfigRegistry")
-  (gtype-id "XKL_TYPE_CONFIG_REGISTRY")
+(define-method reset
+  (of-object "XklConfigRec")
+  (c-name "xkl_config_rec_reset")
+  (return-type "none")
 )
 
-;; methods
+(define-method equals
+  (of-object "XklConfigRec")
+  (c-name "xkl_config_rec_equals")
+  (return-type "gboolean")
+  (parameters
+    '("XklConfigRec*" "data2")
+  )
+)
+
+
+
+;; From xkl_config_registry.h
+
+(define-function xkl_config_registry_get_type
+  (c-name "xkl_config_registry_get_type")
+  (return-type "GType")
+)
 
 (define-function xkl_config_registry_get_instance
   (c-name "xkl_config_registry_get_instance")
@@ -72,6 +245,25 @@
   (of-object "XklConfigRegistry")
   (c-name "xkl_config_registry_load")
   (return-type "gboolean")
+  (parameters
+    '("gboolean" "if_extras_needed")
+  )
+)
+
+(define-function void
+  (c-name "void")
+  (return-type "typedef")
+  (parameters
+    '("*" "ConfigItemProcessFunc")
+  )
+)
+
+(define-function void
+  (c-name "void")
+  (return-type "typedef")
+  (parameters
+    '("*" "TwoConfigItemsProcessFunc")
+  )
 )
 
 (define-method foreach_model
@@ -126,6 +318,53 @@
   )
 )
 
+(define-method find_model
+  (of-object "XklConfigRegistry")
+  (c-name "xkl_config_registry_find_model")
+  (return-type "gboolean")
+  (parameters
+    '("XklConfigItem*" "item")
+  )
+)
+
+(define-method find_layout
+  (of-object "XklConfigRegistry")
+  (c-name "xkl_config_registry_find_layout")
+  (return-type "gboolean")
+  (parameters
+    '("XklConfigItem*" "item")
+  )
+)
+
+(define-method find_variant
+  (of-object "XklConfigRegistry")
+  (c-name "xkl_config_registry_find_variant")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "layout_name")
+    '("XklConfigItem*" "item")
+  )
+)
+
+(define-method find_option_group
+  (of-object "XklConfigRegistry")
+  (c-name "xkl_config_registry_find_option_group")
+  (return-type "gboolean")
+  (parameters
+    '("XklConfigItem*" "item")
+  )
+)
+
+(define-method find_option
+  (of-object "XklConfigRegistry")
+  (c-name "xkl_config_registry_find_option")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "option_group_name")
+    '("XklConfigItem*" "item")
+  )
+)
+
 (define-method foreach_country
   (of-object "XklConfigRegistry")
   (c-name "xkl_config_registry_foreach_country")
@@ -146,3 +385,335 @@
     '("gpointer" "data")
   )
 )
+
+(define-method foreach_language
+  (of-object "XklConfigRegistry")
+  (c-name "xkl_config_registry_foreach_language")
+  (return-type "none")
+  (parameters
+    '("ConfigItemProcessFunc" "func")
+    '("gpointer" "data")
+  )
+)
+
+(define-method foreach_language_variant
+  (of-object "XklConfigRegistry")
+  (c-name "xkl_config_registry_foreach_language_variant")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "language_code")
+    '("TwoConfigItemsProcessFunc" "func")
+    '("gpointer" "data")
+  )
+)
+
+
+
+;; From xkl_engine.h
+
+(define-function xkl_engine_get_type
+  (c-name "xkl_engine_get_type")
+  (return-type "GType")
+)
+
+(define-function xkl_engine_get_instance
+  (c-name "xkl_engine_get_instance")
+  (return-type "XklEngine*")
+  (is-constructor-of "XklEngine")
+)
+
+(define-method get_backend_name
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_backend_name")
+  (return-type "gchar*")
+)
+
+(define-method get_features
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_features")
+  (return-type "guint")
+)
+
+(define-method get_max_num_groups
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_max_num_groups")
+  (return-type "guint")
+)
+
+(define-method start_listen
+  (of-object "XklEngine")
+  (c-name "xkl_engine_start_listen")
+  (return-type "gint")
+  (parameters
+    '("guint" "flags")
+  )
+)
+
+(define-method stop_listen
+  (of-object "XklEngine")
+  (c-name "xkl_engine_stop_listen")
+  (return-type "gint")
+)
+
+(define-method pause_listen
+  (of-object "XklEngine")
+  (c-name "xkl_engine_pause_listen")
+  (return-type "gint")
+)
+
+(define-method resume_listen
+  (of-object "XklEngine")
+  (c-name "xkl_engine_resume_listen")
+  (return-type "gint")
+)
+
+(define-method grab_key
+  (of-object "XklEngine")
+  (c-name "xkl_engine_grab_key")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "keycode")
+    '("guint" "modifiers")
+  )
+)
+
+(define-method ungrab_key
+  (of-object "XklEngine")
+  (c-name "xkl_engine_ungrab_key")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "keycode")
+    '("guint" "modifiers")
+  )
+)
+
+(define-method filter_events
+  (of-object "XklEngine")
+  (c-name "xkl_engine_filter_events")
+  (return-type "gint")
+  (parameters
+    '("XEvent*" "evt")
+  )
+)
+
+(define-method allow_one_switch_to_secondary_group
+  (of-object "XklEngine")
+  (c-name "xkl_engine_allow_one_switch_to_secondary_group")
+  (return-type "none")
+)
+
+(define-method get_current_window
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_current_window")
+  (return-type "Window")
+)
+
+(define-method get_current_state
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_current_state")
+  (return-type "XklState*")
+)
+
+(define-method get_window_title
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_window_title")
+  (return-type "gchar*")
+  (parameters
+    '("Window" "win")
+  )
+)
+
+(define-method get_state
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_state")
+  (return-type "gboolean")
+  (parameters
+    '("Window" "win")
+    '("XklState*" "state_out")
+  )
+)
+
+(define-method delete_state
+  (of-object "XklEngine")
+  (c-name "xkl_engine_delete_state")
+  (return-type "none")
+  (parameters
+    '("Window" "win")
+  )
+)
+
+(define-method save_state
+  (of-object "XklEngine")
+  (c-name "xkl_engine_save_state")
+  (return-type "none")
+  (parameters
+    '("Window" "win")
+    '("XklState*" "state")
+  )
+)
+
+(define-method set_window_transparent
+  (of-object "XklEngine")
+  (c-name "xkl_engine_set_window_transparent")
+  (return-type "none")
+  (parameters
+    '("Window" "win")
+    '("gboolean" "transparent")
+  )
+)
+
+(define-method is_window_transparent
+  (of-object "XklEngine")
+  (c-name "xkl_engine_is_window_transparent")
+  (return-type "gboolean")
+  (parameters
+    '("Window" "win")
+  )
+)
+
+(define-method is_window_from_same_toplevel_window
+  (of-object "XklEngine")
+  (c-name "xkl_engine_is_window_from_same_toplevel_window")
+  (return-type "gboolean")
+  (parameters
+    '("Window" "win1")
+    '("Window" "win2")
+  )
+)
+
+(define-method get_num_groups
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_num_groups")
+  (return-type "guint")
+)
+
+(define-method get_groups_names
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_groups_names")
+  (return-type "const-gchar**")
+)
+
+(define-method get_indicators_names
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_indicators_names")
+  (return-type "const-gchar**")
+)
+
+(define-method get_next_group
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_next_group")
+  (return-type "gint")
+)
+
+(define-method get_prev_group
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_prev_group")
+  (return-type "gint")
+)
+
+(define-method get_current_window_group
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_current_window_group")
+  (return-type "gint")
+)
+
+(define-method lock_group
+  (of-object "XklEngine")
+  (c-name "xkl_engine_lock_group")
+  (return-type "none")
+  (parameters
+    '("gint" "group")
+  )
+)
+
+(define-method set_group_per_toplevel_window
+  (of-object "XklEngine")
+  (c-name "xkl_engine_set_group_per_toplevel_window")
+  (return-type "none")
+  (parameters
+    '("gboolean" "is_global")
+  )
+)
+
+(define-method is_group_per_toplevel_window
+  (of-object "XklEngine")
+  (c-name "xkl_engine_is_group_per_toplevel_window")
+  (return-type "gboolean")
+)
+
+(define-method set_indicators_handling
+  (of-object "XklEngine")
+  (c-name "xkl_engine_set_indicators_handling")
+  (return-type "none")
+  (parameters
+    '("gboolean" "whether_handle")
+  )
+)
+
+(define-method get_indicators_handling
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_indicators_handling")
+  (return-type "gboolean")
+)
+
+(define-method set_secondary_groups_mask
+  (of-object "XklEngine")
+  (c-name "xkl_engine_set_secondary_groups_mask")
+  (return-type "none")
+  (parameters
+    '("guint" "mask")
+  )
+)
+
+(define-method get_secondary_groups_mask
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_secondary_groups_mask")
+  (return-type "guint")
+)
+
+(define-method set_default_group
+  (of-object "XklEngine")
+  (c-name "xkl_engine_set_default_group")
+  (return-type "none")
+  (parameters
+    '("gint" "group")
+  )
+)
+
+(define-method get_default_group
+  (of-object "XklEngine")
+  (c-name "xkl_engine_get_default_group")
+  (return-type "gint")
+)
+
+
+
+;; From xkl_engine_marshal.h
+
+(define-function xkl_engine_INT__LONG_LONG
+  (c-name "xkl_engine_INT__LONG_LONG")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function xkl_engine_VOID__FLAGS_INT_BOOLEAN
+  (c-name "xkl_engine_VOID__FLAGS_INT_BOOLEAN")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+
diff --git a/xklavier/xklavier.override b/xklavier/xklavier.override
index e83b27b..3c80c7b 100644
--- a/xklavier/xklavier.override
+++ b/xklavier/xklavier.override
@@ -2,6 +2,7 @@
 headers
 #include <Python.h>               
 #include <pygobject.h>
+#include <gdk/gdkx.h>
 #include <libxklavier/xklavier.h>
 #include <libxklavier/xkl_config_item.h>
 
@@ -9,84 +10,6 @@ typedef struct {
     PyObject *func, *data;
 } PyGtkCustomNotify;
 
-/* ----------- XklConfigItem ----------- */
-
-static PyObject *
-_wrap_xkl_config_item_get_name(PyGObject *self)
-{
-    XklConfigItem * item;
-
-    item = XKL_CONFIG_ITEM(self->obj);
-    
-    return Py_BuildValue("s", item->name);
-
-}
-
-static PyObject *
-_wrap_xkl_config_item_get_description(PyGObject *self)
-{
-    XklConfigItem * item;
-
-    item = XKL_CONFIG_ITEM(self->obj);
-    
-    return Py_BuildValue("s", item->description);
-
-}
-
-
-static const PyMethodDef _PyXklConfigItem_methods[] = {
-    { "get_name", (PyCFunction)_wrap_xkl_config_item_get_name, METH_NOARGS,
-      NULL },
-    { "get_description", (PyCFunction)_wrap_xkl_config_item_get_description, METH_NOARGS,
-      NULL },
-    { NULL, NULL, 0, NULL }
-};
-
-PyTypeObject G_GNUC_INTERNAL PyXklConfigItem_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,                                 /* ob_size */
-    "Xkl.ConfigItem",                   /* tp_name */
-    sizeof(PyGObject),          /* tp_basicsize */
-    0,                                 /* tp_itemsize */
-    /* methods */
-    (destructor)0,        /* tp_dealloc */
-    (printfunc)0,                      /* tp_print */
-    (getattrfunc)0,       /* tp_getattr */
-    (setattrfunc)0,       /* tp_setattr */
-    (cmpfunc)0,           /* tp_compare */
-    (reprfunc)0,             /* tp_repr */
-    (PyNumberMethods*)0,     /* tp_as_number */
-    (PySequenceMethods*)0, /* tp_as_sequence */
-    (PyMappingMethods*)0,   /* tp_as_mapping */
-    (hashfunc)0,             /* tp_hash */
-    (ternaryfunc)0,          /* tp_call */
-    (reprfunc)0,              /* tp_str */
-    (getattrofunc)0,     /* tp_getattro */
-    (setattrofunc)0,     /* tp_setattro */
-    (PyBufferProcs*)0,  /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
-    NULL,                        /* Documentation string */
-    (traverseproc)0,     /* tp_traverse */
-    (inquiry)0,             /* tp_clear */
-    (richcmpfunc)0,   /* tp_richcompare */
-    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
-    (getiterfunc)0,          /* tp_iter */
-    (iternextfunc)0,     /* tp_iternext */
-    (struct PyMethodDef*)_PyXklConfigItem_methods, /* tp_methods */
-    (struct PyMemberDef*)0,              /* tp_members */
-    (struct PyGetSetDef*)0,  /* tp_getset */
-    NULL,                              /* tp_base */
-    NULL,                              /* tp_dict */
-    (descrgetfunc)0,    /* tp_descr_get */
-    (descrsetfunc)0,    /* tp_descr_set */
-    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
-    (initproc)0,             /* tp_init */
-    (allocfunc)0,           /* tp_alloc */
-    (newfunc)0,               /* tp_new */
-    (freefunc)0,             /* tp_free */
-    (inquiry)0              /* tp_is_gc */
-};
-
 static void
 pyxkl_config_process_one_item(XklConfigRegistry * config, 
                     const XklConfigItem * item, gpointer data)
@@ -157,24 +80,44 @@ init
 modulename Xkl
 %%
 import gobject.GObject as PyGObject_Type
+import gtk.gdk.Display as PyGdkDisplay_Type
 %%
 ignore-glob
-  *_get_type                            
+  *_get_type
+%%
+ignore
+  xkl_engine_filter_events
+  xkl_engine_get_current_window
+  xkl_engine_get_window_title
+  xkl_engine_get_state
+  xkl_engine_delete_state
+  xkl_engine_save_state
+  xkl_engine_set_window_transparent
+  xkl_engine_is_window_transparent
+  xkl_engine_is_window_from_same_toplevel_window
+%%
+new-constructor XKL_TYPE_ENGINE
 %%
 override xkl_engine_get_instance kwargs
 static int
 _wrap_xkl_engine_get_instance(PyGObject *self, PyObject *args, PyObject *kwargs)
 {
-    static char* kwlist[] = { NULL };
+    static char* kwlist[] = { "display", NULL };
 
+    PyGObject *py_display;
     Display *display;
 
+	if (!PyArg_ParseTuple(args, "O!", &PyGdkDisplay_Type, &py_display))
+		return -1;
+
+    /*FIXME: This does not work
     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-                                     ":xklavier.Engine.__init__",
-                                     kwlist ))
-        return -1;
+                                     "O!:xklavier.Engine.__init__",
+                                     kwlist, &PyGdkDisplay_Type, py_display))
+        return -1;*/
     
-    display = XOpenDisplay(0);
+    display = gdk_x11_display_get_xdisplay(GDK_DISPLAY_OBJECT(py_display->obj));
+
     pygobject_construct(self, "display", display, NULL);
 
     if (!self->obj) {
@@ -183,7 +126,44 @@ _wrap_xkl_engine_get_instance(PyGObject *self, PyObject *args, PyObject *kwargs)
     }
 
     return 0;
-    
+}
+%%
+override xkl_engine_get_groups_names kwargs
+static int
+_wrap_xkl_engine_get_groups_names(PyGObject *self)
+{
+    gchar **groups_names;
+    PyObject *groups_names_list;
+    gint i;
+
+    groups_names = xkl_engine_get_groups_names(XKL_ENGINE(self->obj));
+
+    groups_names_list = PyList_New(0);
+
+    for (i = 0; i < g_strv_length(groups_names); i++)
+        PyList_Append(groups_names_list,
+            Py_BuildValue("s", groups_names[i]));
+
+    return groups_names_list;
+}
+%%
+override xkl_engine_get_indicators_names kwargs
+static int
+_wrap_xkl_engine_get_indicators_names(PyGObject *self)
+{
+    gchar **indicators_names;
+    PyObject *indicators_names_list;
+    gint i;
+
+    indicators_names = xkl_engine_get_indicators_names(XKL_ENGINE(self->obj));
+
+    indicators_names_list = PyList_New(0);
+
+    for (i = 0; i < g_strv_length(indicators_names); i++)
+        PyList_Append(indicators_names_list,
+            Py_BuildValue("s", indicators_names[i]));
+
+    return indicators_names_list;
 }
 %%
 override xkl_config_registry_foreach_model kwargs
@@ -327,14 +307,14 @@ override xkl_config_registry_foreach_country_variant kwargs
 static PyObject *
 _wrap_xkl_config_registry_foreach_country_variant(PyGObject *self, PyObject *args, PyObject *kwargs)
 {
-    static char *kwlist[] = { "country_name", "func", "data", NULL };
-    gchar *country_name;
+    static char *kwlist[] = { "country_code", "func", "data", NULL };
+    gchar *country_code;
     PyObject *py_func, *py_data = NULL;
     PyGtkCustomNotify cunote;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                      "sO|O:xklavier.ConfigRegistry.foreach_country_variant",
-                     kwlist, &country_name, &py_func, &py_data))
+                     kwlist, &country_code, &py_func, &py_data))
     return NULL;
 
     if (!PyCallable_Check(py_func)) {
@@ -347,7 +327,7 @@ _wrap_xkl_config_registry_foreach_country_variant(PyGObject *self, PyObject *arg
     Py_INCREF(cunote.func);
     Py_XINCREF(cunote.data);
 
-    xkl_config_registry_foreach_country_variant(XKL_CONFIG_REGISTRY(self->obj), country_name, 
+    xkl_config_registry_foreach_country_variant(XKL_CONFIG_REGISTRY(self->obj), country_code, 
               pyxkl_config_process_two_item,
               (gpointer)&cunote);
 
@@ -426,3 +406,307 @@ _wrap_xkl_config_registry_foreach_option(PyGObject *self, PyObject *args, PyObje
     Py_INCREF(Py_None);
     return Py_None;
 }
+%%
+override xkl_config_registry_foreach_language kwargs
+static PyObject *
+_wrap_xkl_config_registry_foreach_language(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "func", "data", NULL };
+    PyObject *py_func, *py_data = NULL;
+    PyGtkCustomNotify cunote;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                     "O|O:xklavier.ConfigRegistry.foreach_language",
+                     kwlist, &py_func, &py_data))
+    return NULL;
+
+    if (!PyCallable_Check(py_func)) {
+        PyErr_SetString(PyExc_TypeError, "func must be callable");
+        return NULL;
+    }
+
+    cunote.func = py_func;
+    cunote.data = py_data;
+    Py_INCREF(cunote.func);
+    Py_XINCREF(cunote.data);
+
+    xkl_config_registry_foreach_language(XKL_CONFIG_REGISTRY(self->obj),
+              pyxkl_config_process_one_item,
+              (gpointer)&cunote);
+
+    Py_DECREF(cunote.func);
+    Py_XDECREF(cunote.data);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override xkl_config_registry_foreach_language_variant kwargs
+static PyObject *
+_wrap_xkl_config_registry_foreach_language_variant(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "language_code", "func", "data", NULL };
+    gchar *language_code;
+    PyObject *py_func, *py_data = NULL;
+    PyGtkCustomNotify cunote;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                     "sO|O:xklavier.ConfigRegistry.foreach_country_variant",
+                     kwlist, &language_code, &py_func, &py_data))
+    return NULL;
+
+    if (!PyCallable_Check(py_func)) {
+        PyErr_SetString(PyExc_TypeError, "func must be callable");
+        return NULL;
+    }
+
+    cunote.func = py_func;
+    cunote.data = py_data;
+    Py_INCREF(cunote.func);
+    Py_XINCREF(cunote.data);
+
+    xkl_config_registry_foreach_language_variant(XKL_CONFIG_REGISTRY(self->obj), language_code, 
+              pyxkl_config_process_two_item,
+              (gpointer)&cunote);
+
+    Py_DECREF(cunote.func);
+    Py_XDECREF(cunote.data);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+define XklConfigItem.get_name
+static PyObject *
+_wrap_xkl_config_item_get_name(PyGObject *self)
+{
+    XklConfigItem * item;
+
+    item = XKL_CONFIG_ITEM(self->obj);
+    
+    return Py_BuildValue("s", item->name);
+
+}
+%%
+define XklConfigItem.get_description
+static PyObject *
+_wrap_xkl_config_item_get_description(PyGObject *self)
+{
+    XklConfigItem * item;
+
+    item = XKL_CONFIG_ITEM(self->obj);
+    
+    return Py_BuildValue("s", item->description);
+
+}
+%%
+define XklConfigRec.get_layouts
+static PyObject *
+_wrap_xkl_config_rec_get_layouts(PyGObject *self)
+{
+    XklConfigRec * rec;
+
+    rec = XKL_CONFIG_REC(self->obj);
+
+	PyObject *layout_list;
+	gint i;
+
+	layout_list = PyList_New(0);
+	for (i = 0; i < g_strv_length(rec->layouts); i++)
+		PyList_Append(layout_list,
+			      Py_BuildValue("s", rec->layouts[i]));
+
+	return layout_list;
+}
+%%
+define XklConfigRec.get_variants
+static PyObject *
+_wrap_xkl_config_rec_get_variants(PyGObject *self)
+{
+    XklConfigRec * rec;
+
+    rec = XKL_CONFIG_REC(self->obj);
+
+	PyObject *variants_list;
+	gint i;
+
+	variants_list = PyList_New(0);
+	for (i = 0; i < g_strv_length(rec->variants); i++)
+		PyList_Append(variants_list,
+			      Py_BuildValue("s", rec->variants[i]));
+
+	return variants_list;
+}
+%%
+define XklConfigRec.get_options
+static PyObject *
+_wrap_xkl_config_rec_get_options(PyGObject *self)
+{
+    XklConfigRec * rec;
+
+    rec = XKL_CONFIG_REC(self->obj);
+
+	PyObject *options_list;
+	gint i;
+
+	options_list = PyList_New(0);
+	for (i = 0; i < g_strv_length(rec->options); i++)
+		PyList_Append(options_list,
+			      Py_BuildValue("s", rec->options[i]));
+
+	return options_list;
+}
+%%
+define XklConfigRec.get_model
+static PyObject *
+_wrap_xkl_config_rec_get_model(PyGObject *self)
+{
+    XklConfigRec * rec;
+
+    rec = XKL_CONFIG_REC(self->obj);
+
+    return Py_BuildValue("s", rec->model);
+}
+%%
+define XklConfigRec.set_layouts kwargs
+static PyObject *
+_wrap_xkl_config_rec_set_layouts(PyGObject *self, PyObject *args, 
+                                    PyObject *kwargs)
+{
+    static char *kwlist[] = { "layouts", NULL };
+    PyObject *py_layouts, *strObj;
+    int len, i;
+    gchar **layout_arg;
+    XklConfigRec *rec;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:XklConfigRec.set_layouts",
+                                     kwlist, &PyList_Type, &py_layouts))
+        return NULL;
+
+    rec = XKL_CONFIG_REC(self->obj);
+	len = PyList_Size(py_layouts);
+
+	if (!len)
+        return Py_None;
+
+    layout_arg = g_try_malloc((len + 1) * sizeof(char *));
+    if (!layout_arg)
+        return PyErr_NoMemory();
+
+	for (i = 0; i < len; i++) {
+		strObj = PyList_GetItem(py_layouts, i);
+        layout_arg[i] = PyString_AsString(strObj);
+	}
+
+    layout_arg[len] = NULL;
+
+	if (rec->layouts != NULL)
+		g_strfreev(rec->layouts);
+	rec->layouts = g_strdupv(layout_arg);
+
+    return Py_None;
+
+}
+%%
+define XklConfigRec.set_variants kwargs
+static PyObject *
+_wrap_xkl_config_rec_set_variants(PyGObject *self, PyObject *args, 
+                                    PyObject *kwargs)
+{
+    static char *kwlist[] = { "variants", NULL };
+    PyObject *py_variants, *strObj;
+    int len, i;
+    gchar **variant_arg;
+    XklConfigRec *rec;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:XklConfigRec.set_variants",
+                                     kwlist, &PyList_Type, &py_variants))
+        return NULL;
+
+    rec = XKL_CONFIG_REC(self->obj);
+	len = PyList_Size(py_variants);
+
+	if (!len)
+        return Py_None;
+
+    variant_arg = g_try_malloc((len + 1) * sizeof(char *));
+    if (!variant_arg)
+        return PyErr_NoMemory();
+
+	for (i = 0; i < len; i++) {
+		strObj = PyList_GetItem(py_variants, i);
+        variant_arg[i] = PyString_AsString(strObj);
+	}
+
+    variant_arg[len] = NULL;
+
+	if (rec->variants != NULL)
+		g_strfreev(rec->variants);
+	rec->variants = g_strdupv(variant_arg);
+
+    return Py_None;
+
+}
+%%
+define XklConfigRec.set_options kwargs
+static PyObject *
+_wrap_xkl_config_rec_set_options(PyGObject *self, PyObject *args, 
+                                    PyObject *kwargs)
+{
+    static char *kwlist[] = { "options", NULL };
+    PyObject *py_options, *strObj;
+    int len, i;
+    gchar **option_arg;
+    XklConfigRec *rec;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:XklConfigRec.set_options",
+                                     kwlist, &PyList_Type, &py_options))
+        return NULL;
+
+    rec = XKL_CONFIG_REC(self->obj);
+	len = PyList_Size(py_options);
+
+	if (!len)
+        return Py_None;
+
+    option_arg = g_try_malloc((len + 1) * sizeof(char *));
+    if (!option_arg)
+        return PyErr_NoMemory();
+
+	for (i = 0; i < len; i++) {
+		strObj = PyList_GetItem(py_options, i);
+        option_arg[i] = PyString_AsString(strObj);
+	}
+
+    option_arg[len] = NULL;
+
+	if (rec->options != NULL)
+		g_strfreev(rec->options);
+	rec->options = g_strdupv(option_arg);
+
+    return Py_None;
+
+}
+%%
+define XklConfigRec.set_model kwargs
+static PyObject *
+_wrap_xkl_config_rec_set_model(PyGObject *self, PyObject *args, 
+                                    PyObject *kwargs)
+{
+    static char *kwlist[] = { "model", NULL };
+    PyObject *py_model;
+    XklConfigRec *rec;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:XklConfigRec.set_model",
+                                     kwlist, &py_model))
+        return NULL;
+
+    rec = XKL_CONFIG_REC(self->obj);
+
+	if (rec->model != NULL)
+		g_free(rec->model);
+	rec->model = g_strdup(PyString_AsString(py_model));
+
+    return Py_None;
+
+}
diff --git a/xklavier/xklaviermodule.c b/xklavier/xklaviermodule.c
index f9bac11..e54ae07 100644
--- a/xklavier/xklaviermodule.c
+++ b/xklavier/xklaviermodule.c
@@ -1,6 +1,8 @@
 #include <pygobject.h>
  
-void xklavier_register_classes (PyObject *d); 
+void xklavier_register_classes (PyObject *d);
+void xklavier_add_constants(PyObject *module, const gchar *strip_prefix);
+
 extern PyMethodDef xklavier_functions[];
  
 DL_EXPORT(void)
@@ -14,6 +16,8 @@ initxklavier(void)
     d = PyModule_GetDict (m);
  
     xklavier_register_classes (d);
+    xklavier_add_constants(m, "");
+
  
     if (PyErr_Occurred ()) {
         Py_FatalError ("can't initialise module xklavier");