From a70f67b0ef101cd21da0322612648880d97219cd Mon Sep 17 00:00:00 2001 From: pnfisher Date: Tue, 14 Sep 1999 06:15:03 +0000 Subject: Make keyboard select work -- default to US. --- iw/keyboard.py | 48 ++++++++++++++++-------- xkb.c | 113 +++++++++++++++++++++++++++++++++++++++------------------ xkb.py | 12 ++++++ 3 files changed, 122 insertions(+), 51 deletions(-) diff --git a/iw/keyboard.py b/iw/keyboard.py index 5ba54a699..872afa75f 100644 --- a/iw/keyboard.py +++ b/iw/keyboard.py @@ -9,8 +9,6 @@ class KeyboardWindow (InstallWindow): InstallWindow.__init__ (self, ics) ics.setTitle (_("Keyboard Configuration")) -## ics.setHTML ("Select your keyboard." -## "") ics.readHTML ("kybd") ics.setNextEnabled (TRUE) self.kb = xkb.XKB () @@ -20,9 +18,14 @@ class KeyboardWindow (InstallWindow): # self.todo.keyboard.set (self.keyboardList.get_selection ()[0].children ()[0].get ()) return None + def select_row (self, clist, row, col, event): + self.kb.setRule (self.modelList.get_row_data (self.modelList.selection[0]), + self.layoutList.get_row_data (self.layoutList.selection[0]), + self.variantList.get_row_data (self.variantList.selection[0]), + "complete") + def getScreen (self): -# print self.todo.keyboard.available () - box = GtkVBox (FALSE) + box = GtkVBox (FALSE, 5) im = self.ics.readPixmap ("gnome-keyboard.png") if im: im.render () @@ -34,43 +37,56 @@ class KeyboardWindow (InstallWindow): box.pack_start (GtkLabel (_("Model")), FALSE) sw = GtkScrolledWindow () - sw.set_border_width (5) +# sw.set_border_width (5) sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC) self.modelList = GtkCList () self.modelList.set_selection_mode (SELECTION_BROWSE) - for model in self.rules[0].values (): - self.modelList.append ((model,)) + for (key, model) in self.rules[0].items (): + loc = self.modelList.append ((model,)) + self.modelList.set_row_data (loc, key) + if key == "pc104": + self.modelList.select_row (loc, 0) + self.modelList.sort () + self.modelList.connect ("select_row", self.select_row) self.modelList.columns_autosize () sw.add (self.modelList) box.pack_start (sw, TRUE) box.pack_start (GtkLabel (_("Layout")), FALSE) sw = GtkScrolledWindow () - sw.set_border_width (5) +# sw.set_border_width (5) sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC) self.layoutList = GtkCList () self.layoutList.set_selection_mode (SELECTION_BROWSE) - layouts = self.rules[1].values () - layouts.sort () - for layout in layouts: - self.layoutList.append ((layout,)) + for (key, layout) in self.rules[1].items (): + loc = self.layoutList.append ((layout,)) + self.layoutList.set_row_data (loc, key) + if key == "en_US": + self.layoutList.select_row (loc, 0) + self.layoutList.sort () + self.layoutList.connect ("select_row", self.select_row) self.layoutList.columns_autosize () sw.add (self.layoutList) box.pack_start (sw, TRUE) box.pack_start (GtkLabel (_("Variant")), FALSE) sw = GtkScrolledWindow () - sw.set_border_width (5) +# sw.set_border_width (5) sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC) self.variantList = GtkCList () self.variantList.set_selection_mode (SELECTION_BROWSE) self.variantList.append (("None",)) - for variant in self.rules[2].values (): - self.variantList.append ((variant,)) + for (key, variant) in self.rules[2].items (): + loc = self.variantList.append ((variant,)) + self.variantList.set_row_data (loc, key) + self.variantList.sort () + self.variantList.connect ("select_row", self.select_row) self.variantList.columns_autosize () sw.add (self.variantList) box.pack_start (sw, FALSE) -# print self.kb.getOptions () + entry = GtkEntry () + box.pack_start (entry, FALSE) + box.set_border_width (5) return box diff --git a/xkb.c b/xkb.c index 9c2b1a2c9..3ecc8b5f7 100644 --- a/xkb.c +++ b/xkb.c @@ -4,6 +4,7 @@ #include #include #include +#include #include #define max(a,b) ((a) > (b) ? (a) : (b)) @@ -13,98 +14,138 @@ #define XKB_XFREE86_RULES "/usr/X11R6/lib/X11/xkb/rules/xfree86" #define XKB_SUN_RULES "/usr/X11R6/lib/X11/xkb/rules/sun" +static XkbRF_RulesPtr rules; + PyObject *list_rules (); +PyObject *set_rule (PyObject *, PyObject *); +char * get_rulesbase (); static PyMethodDef _xkbMethods[] = { { "list_rules", list_rules, 1 }, + { "set_rule", set_rule, 1}, { NULL, NULL } }; +char * +get_rulesbase () +{ + char *rulesbase = XKB_XFREE86_RULES; +#ifdef __sparc__ + int fd; + + fd = open("/dev/kbd", O_RDONLY); + if (fd >= 0) { + rulesbase = XKB_SUN_RULES; + } +#endif + + return rulesbase; +} + void init_xkb () { + char *lang; PyObject *m; m = Py_InitModule ("_xkb", _xkbMethods); + lang = getenv ("LC_ALL"); + rules = XkbRF_Load (get_rulesbase (), (lang) ? lang : "C", True, True); + if (!rules) + Py_FatalError ("unable to load XKB rules database"); + if (PyErr_Occurred ()) Py_FatalError ("can't initialize module _xkb"); } +PyObject * +set_rule (PyObject *self, PyObject *args) +{ + XkbRF_VarDefsRec defs; + XkbComponentNamesRec rnames; + + if (!PyArg_ParseTuple (args, "ssss", &defs.model, &defs.layout, &defs.variant, &defs.options)) + return NULL; + + if (!strcmp (defs.model, "")) + defs.model = NULL; + if (!strcmp (defs.layout, "")) + defs.layout = NULL; + if (!strcmp (defs.variant, "")) + defs.variant = NULL; + if (!strcmp (defs.options, "")) + defs.options = NULL; + + XkbRF_GetComponents (rules, &defs, &rnames); + + XkbGetKeyboardByName (GDK_DISPLAY (), XkbUseCoreKbd, &rnames, + XkbGBN_AllComponentsMask, + XkbGBN_AllComponentsMask, True); + + XkbRF_SetNamesProp (GDK_DISPLAY (), get_rulesbase (), &defs); + + return Py_BuildValue ("i", 1); +} + PyObject * list_rules () { - PyObject *models, *layouts, *variants, *options, *rules; - XkbRF_RulesPtr list; - Bool result; + PyObject *models, *layouts, *variants, *options, *py_rules; int num_comp; int i; - char *rulesbase = XKB_XFREE86_RULES; -#ifdef __sparc__ - int fd; - - fd = open("/dev/kbd", O_RDONLY); - if (fd >= 0) { - rulesbase = XKB_SUN_RULES; - } -#endif - - list = XkbRF_Create (0,0); - result = XkbRF_LoadDescriptionsByName (rulesbase, NULL, list); models = PyDict_New (); - num_comp = min (list->models.num_desc, MAX_COMPONENTS); + num_comp = min (rules->models.num_desc, MAX_COMPONENTS); for (i = 0; i < num_comp; i++) { PyObject *desc, *name; - name = PyString_FromString (list->models.desc[i].name); - desc = PyString_FromString (list->models.desc[i].desc); + name = PyString_FromString (rules->models.desc[i].name); + desc = PyString_FromString (rules->models.desc[i].desc); PyDict_SetItem (models, name, desc); } layouts = PyDict_New (); - num_comp = min (list->layouts.num_desc, MAX_COMPONENTS); + num_comp = min (rules->layouts.num_desc, MAX_COMPONENTS); for (i = 0; i < num_comp; i++) { PyObject *desc, *name; - name = PyString_FromString (list->layouts.desc[i].name); - desc = PyString_FromString (list->layouts.desc[i].desc); + name = PyString_FromString (rules->layouts.desc[i].name); + desc = PyString_FromString (rules->layouts.desc[i].desc); PyDict_SetItem (layouts, name, desc); } variants = PyDict_New (); - num_comp = min (list->variants.num_desc, MAX_COMPONENTS); + num_comp = min (rules->variants.num_desc, MAX_COMPONENTS); for (i = 0; i < num_comp; i++) { PyObject *desc, *name; - name = PyString_FromString (list->variants.desc[i].name); - desc = PyString_FromString (list->variants.desc[i].desc); + name = PyString_FromString (rules->variants.desc[i].name); + desc = PyString_FromString (rules->variants.desc[i].desc); PyDict_SetItem (variants, name, desc); } options = PyDict_New (); - num_comp = min (list->options.num_desc, MAX_COMPONENTS); + num_comp = min (rules->options.num_desc, MAX_COMPONENTS); for (i = 0; i < num_comp; i++) { PyObject *desc, *name; - name = PyString_FromString (list->options.desc[i].name); - desc = PyString_FromString (list->options.desc[i].desc); + name = PyString_FromString (rules->options.desc[i].name); + desc = PyString_FromString (rules->options.desc[i].desc); PyDict_SetItem (options, name, desc); } - XkbRF_Free (list,True); + py_rules = PyTuple_New (4); - rules = PyTuple_New (4); + PyTuple_SET_ITEM (py_rules, 0, models); + PyTuple_SET_ITEM (py_rules, 1, layouts); + PyTuple_SET_ITEM (py_rules, 2, variants); + PyTuple_SET_ITEM (py_rules, 3, options); - PyTuple_SET_ITEM (rules, 0, models); - PyTuple_SET_ITEM (rules, 1, layouts); - PyTuple_SET_ITEM (rules, 2, variants); - PyTuple_SET_ITEM (rules, 3, options); - - return rules; + return py_rules; } int main (int argc, char **argv) @@ -143,4 +184,6 @@ int main (int argc, char **argv) /* xkb->names = NULL; */ /* XkbGetNames (dpy, XkbGeometryNameMask, xkb); */ /* printf ("%s\n", XkbAtomText (dpy, xkb->names->geometry, 3)); */ + + return 0; } diff --git a/xkb.py b/xkb.py index b70c09517..902e13a5d 100644 --- a/xkb.py +++ b/xkb.py @@ -24,4 +24,16 @@ class XKB: for x in keys: groups = tree.merge (groups, string.split (x, ":")) return (groups, self.rules[3]) + + def setRule (self, model, layout, variant, options): + if model == None: model = "" + if layout == None: layout = "" + if variant == None: variant = "" + if options == None: options = "" + + return _xkb.set_rule (model, layout, variant, options) + + + + -- cgit