From 5b4c1700b4798f20b61dec5193b3f08d1e60742d Mon Sep 17 00:00:00 2001 From: fujiwarat Date: Fri, 30 Dec 2011 15:46:13 +0900 Subject: [PATCH] Add XKB layouts --- Makefile.am | 7 + configure.ac | 56 + data/ibus.schemas.in | 47 + ibus-1.0.pc.in | 2 + ibus/Makefile.am | 26 + ibus/__init__.py | 2 + ibus/bus.py | 3 + ibus/interface/iibus.py | 3 + ibus/xkblayout.py.in | 360 ++++ ibus/xkbxml.py.in | 419 ++++ setup/Makefile.am | 1 + setup/enginecombobox.py | 7 +- setup/main.py | 3 + setup/setup.ui | 609 ++++++- setup/xkbsetup.py | 490 +++++ src/Makefile.am | 5 + src/ibus.h | 1 + src/ibusxkbxml.c | 441 +++++ src/ibusxkbxml.h | 172 ++ ui/gtk/panel.py | 41 + xkb/Makefile.am | 107 + xkb/Makefile.am.orig | 104 + xkb/gtkimcontextsimpleseqs.h | 4484 ++++++++++++++++++++++++++++++++++++++++++ xkb/ibus-engine-xkb-main.c | 303 +++ xkb/ibus-engine-xkb-main.h | 32 + xkb/ibus-simple-engine.c | 1007 ++++++++++ xkb/ibus-simple-engine.h | 13 + xkb/ibus-xkb-main.c | 112 ++ xkb/xkblayout.xml.in | 16 + xkb/xkblayoutconfig.xml.in | 6 + xkb/xkblib.c | 327 +++ xkb/xkblib.h | 41 + xkb/xkbxml.c | 345 ++++ xkb/xkbxml.h | 113 ++ 34 files changed, 9701 insertions(+), 4 deletions(-) create mode 100644 ibus/xkblayout.py.in create mode 100644 ibus/xkbxml.py.in create mode 100644 setup/xkbsetup.py create mode 100644 src/ibusxkbxml.c create mode 100644 src/ibusxkbxml.h create mode 100644 xkb/Makefile.am create mode 100644 xkb/Makefile.am.orig create mode 100644 xkb/gtkimcontextsimpleseqs.h create mode 100644 xkb/ibus-engine-xkb-main.c create mode 100644 xkb/ibus-engine-xkb-main.h create mode 100644 xkb/ibus-simple-engine.c create mode 100644 xkb/ibus-simple-engine.h create mode 100644 xkb/ibus-xkb-main.c create mode 100644 xkb/xkblayout.xml.in create mode 100644 xkb/xkblayoutconfig.xml.in create mode 100644 xkb/xkblib.c create mode 100644 xkb/xkblib.h create mode 100644 xkb/xkbxml.c create mode 100644 xkb/xkbxml.h diff --git a/Makefile.am b/Makefile.am index ff0fabc..056ddfc 100644 --- a/Makefile.am +++ b/Makefile.am @@ -42,6 +42,12 @@ DAEMON_DIRS = \ $(NULL) endif +if ENABLE_XKB +XKB_DIRS = \ + xkb \ + $(NULL) +endif + if ENABLE_MEMCONF MEMCONF_DIRS = \ memconf \ @@ -66,6 +72,7 @@ SUBDIRS = \ $(DAEMON_DIRS) \ $(PYTHON_DIRS) \ $(GCONF_DIRS) \ + $(XKB_DIRS) \ $(MEMCONF_DIRS) \ $(DCONF_DIRS) \ $(NULL) diff --git a/configure.ac b/configure.ac index f452666..227e28e 100644 --- a/configure.ac +++ b/configure.ac @@ -221,6 +221,60 @@ else enable_xim="no (disabled, use --enable-xim to enable)" fi +AC_ARG_ENABLE(xkb, + AS_HELP_STRING([--disable-xkb], + [Do not build xkb]), + [enable_xkb=$enableval], + [enable_xkb=yes] +) + +AM_CONDITIONAL([ENABLE_XKB], [test x"$enable_xkb" = x"yes"]) +if test x"$enable_xkb" = x"yes"; then + PKG_CHECK_MODULES(X11, [ + x11 + ]) + PKG_CHECK_MODULES(XKB, + [xkbfile],, + [XKB_LIBS="-lxkbfile"] + ) + AC_DEFINE(HAVE_XKB, 1, [define to 1 if you have xkbfile]) + HAVE_IBUS_XKB=true +else + enable_xkb="no (disabled, use --enable-xkb to enable)" + HAVE_IBUS_XKB=false +fi +AC_SUBST(HAVE_IBUS_XKB) + +# define XKB rules file +AC_ARG_WITH(xkb-rules-xml, + AS_HELP_STRING([--with-xkb-rules-xml[=$DIR/evdev.xml]], + [Set evdev.xml file path (default: /usr/share/X11/xkb/rules/evdev.xml)]), + XKB_RULES_XML_FILE=$with_xkb_rules_xml, + XKB_RULES_XML_FILE="/usr/share/X11/xkb/rules/evdev.xml" +) +AC_DEFINE_UNQUOTED(XKB_RULES_XML_FILE, "$XKB_RULES_XML_FILE", + [Define file path of evdev.xml]) +AC_SUBST(XKB_RULES_XML_FILE) + +# define XKB preload layouts +AC_ARG_WITH(xkb-preload-layouts, + AS_HELP_STRING([--with-xkb-preload-layouts[=layout,...]], + [Set preload xkb layouts (default: us,fr,de,...)]), + XKB_PRELOAD_LAYOUTS=$with_xkb_preload_layouts, + [XKB_PRELOAD_LAYOUTS=""\ +"us,us(chr),us(dvorak),ad,al,am,ara,az,ba,bd,be,bg,br,bt,by,"\ +"de,dk,ca,ch,cn(tib),cz,ee,epo,es,et,fi,fo,fr,"\ +"gb,ge,ge(dsb),ge(ru),ge(os),gh,gh(akan),gh(ewe),gh(fula),gh(ga),gh(hausa),"\ +"gn,gr,hu,hr,ie,ie(CloGaelach),il,"\ +"in,in(ben),in(guj),in(guru),in(jhelum),in(kan),in(mal),in(ori),in(tam),"\ +"in(tel),in(urd-phonetic),in(bolnagri),iq,iq(ku),ir,ir(ku),is,it,"\ +"kg,kh,kz,la,latam,lk,lk(tam_unicode),lt,lv,ma,ma(tifinagh),mal,mao,"\ +"me,mk,mm,mt,mv,ng,ng(hausa),ng,ng(igbo),ng(yoruba),nl,no,no(smi),np,"\ +"pk,pl,pl(csb),pt,ro,rs,ru,ru(cv),ru(kom),ru(sah),ru(tt),ru(xal),"\ +"se,si,sk,sy,sy(ku),th,tj,tr,ua,uz,vn"] +) +AC_SUBST(XKB_PRELOAD_LAYOUTS) + # GObject introspection GOBJECT_INTROSPECTION_CHECK([0.6.8]) @@ -478,6 +532,7 @@ bindings/Makefile bindings/vala/Makefile dconf/Makefile dconf/dconf.xml.in +xkb/Makefile ]) AC_OUTPUT @@ -493,6 +548,7 @@ Build options: Build gtk2 immodule $enable_gtk2 Build gtk3 immodule $enable_gtk3 Build XIM agent server $enable_xim + Build XKB $enable_xkb Build python modules $enable_python Build gconf modules $enable_gconf Build memconf modules $enable_memconf diff --git a/data/ibus.schemas.in b/data/ibus.schemas.in index 663358c..e0a6a37 100644 --- a/data/ibus.schemas.in +++ b/data/ibus.schemas.in @@ -191,6 +191,53 @@ + /schemas/desktop/ibus/general/system_keyboard_layout + /desktop/ibus/general/system_keyboard_layout + ibus + string + default + ibus + + Set system keyboard layout + Override default system keyboard layout. default is 'default' + + + + /schemas/desktop/ibus/general/system_keyboard_option + /desktop/ibus/general/system_keyboard_option + ibus + string + default + ibus + + Set system keyboard option + Override default system keyboard option. default is 'default' + + + + /schemas/desktop/ibus/general/use_xmodmap + /desktop/ibus/general/use_xmodmap + ibus + bool + true + + Use xmodmap + Run xmodmap if .xmodmap/.Xmodmap exists. + + + + /schemas/desktop/ibus/general/xkb_latin_layouts + /desktop/ibus/general/xkb_latin_layouts + ibus + list + string + [ara,bg,cz,dev,gr,gur,in,jp(kana),mal,mkd,ru,ua] + + Latin layout which have no ASCII + us layout is appended to the latin layouts. variant is not needed. + + + /schemas/desktop/ibus/panel/use_custom_font /desktop/ibus/panel/use_custom_font ibus diff --git a/ibus-1.0.pc.in b/ibus-1.0.pc.in index 9f593ab..51eb67a 100644 --- a/ibus-1.0.pc.in +++ b/ibus-1.0.pc.in @@ -4,6 +4,8 @@ libdir=@libdir@ includedir=@includedir@ datadir=@datadir@ pkgdatadir=@datadir@/ibus +have_ibus_xkb=@HAVE_IBUS_XKB@ +ibus_xkb=@libexecdir@/ibus-xkb Name: IBus Description: IBus Library diff --git a/ibus/Makefile.am b/ibus/Makefile.am index c71df1b..508c98f 100644 --- a/ibus/Makefile.am +++ b/ibus/Makefile.am @@ -58,12 +58,38 @@ nodist_ibus_PYTHON = \ ibusdir = @pkgpythondir@ +xkblayout_py_in_files = \ + xkblayout.py.in \ + xkbxml.py.in \ + $(NULL) +xkblayout_py_DATA = $(xkblayout_py_in_files:.py.in=.py) +xkblayout_pydir = @pkgpythondir@ + +ibus_PYTHON += $(xkblayout_py_DATA) + +if ENABLE_XKB +XKB_COMMAND=\\\"$(libexecdir)/ibus-xkb\\\" +HAVE_XKB=True +else +XKB_COMMAND="None" +HAVE_XKB=False +endif + +%.py : %.py.in + @sed -e "s|\@XKB_COMMAND\@|$(XKB_COMMAND)|g" \ + -e "s|\@XKB_RULES_XML_FILE\@|$(XKB_RULES_XML_FILE)|g" \ + -e "s|\@HAVE_XKB\@|$(HAVE_XKB)|g" \ + -e "s|\@datadir\@|$(datadir)|g" \ + $< > $@ + EXTRA_DIST = \ _config.py.in \ + $(xkblayout_py_in_files) \ $(NULL) CLEANFILES = \ *.pyc \ + $(xkblayout_py_DATA) \ $(NULL) DISTCLEANFILES = \ diff --git a/ibus/__init__.py b/ibus/__init__.py index 7c8f8be..3c25605 100644 --- a/ibus/__init__.py +++ b/ibus/__init__.py @@ -41,4 +41,6 @@ from text import * from observedpath import * from enginedesc import * from component import * +from xkblayout import * +from xkbxml import * from _config import * diff --git a/ibus/bus.py b/ibus/bus.py index a8a458d..84b4140 100644 --- a/ibus/bus.py +++ b/ibus/bus.py @@ -163,6 +163,9 @@ class Bus(object.Object): data = serializable.deserialize_object(data) return data + def get_use_sys_layout(self): + return self.__ibus.GetUseSysLayout(); + def introspect_ibus(self): return self.__ibus.Introspect() diff --git a/ibus/interface/iibus.py b/ibus/interface/iibus.py index 678d517..7de56fc 100644 --- a/ibus/interface/iibus.py +++ b/ibus/interface/iibus.py @@ -75,6 +75,9 @@ class IIBus(dbus.service.Object): @method(in_signature="v", out_signature="v") def Ping(self, data, dbusconn): pass + @method(out_signature="b") + def GetUseSysLayout(self, dbusconn): pass + @signal(signature="") def RegistryChanged(self): pass diff --git a/ibus/xkblayout.py.in b/ibus/xkblayout.py.in new file mode 100644 index 0000000..c0c95ce --- /dev/null +++ b/ibus/xkblayout.py.in @@ -0,0 +1,360 @@ +# vim:set et sts=4 sw=4: +# +# ibus - The Input Bus +# +# Copyright (c) 2011 Takao Fujiwara +# Copyright (c) 2011 Peng Huang +# Copyright (c) 2011 Red Hat, Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program; if not, write to the +# Free Software Foundation, Inc., 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +__all__ = ( + 'XKBLayout', + ) + +import os, sys, time +import glib + +XKB_COMMAND = @XKB_COMMAND@ +XKB_SESSION_TIME_OUT = 30.0 +XMODMAP_CMD = 'xmodmap' +XMODMAP_KNOWN_FILES = ['.xmodmap', '.xmodmaprc', '.Xmodmap', '.Xmodmaprc'] + +class XKBLayout(): + def __init__(self, config = None, command=XKB_COMMAND): + self.__config = config + self.__command = command + self.__use_xkb = True + self.__xkb_pid = None + self.__xmodmap_pid = None + self.__use_xmodmap = True + if self.__command == None: + self.__use_xkb = False + self.__default_layout = self.get_layout() + self.__default_model = self.get_model() + self.__default_option = self.get_option() + self.__time_lag_session_xkb_layout = True + self.__time_lag_session_xkb_option = True + self.__time_lag_session_xkb_timer = time.time() + self.__xkb_latin_layouts = [] + if config != None: + self.__xkb_latin_layouts = list(self.__config.get_value('general', + 'xkb_latin_layouts', + [])) + self.__use_xmodmap = bool(self.__config.get_value('general', + 'use_xmodmap', + True)) + + + def __get_model_from_layout(self, layout): + left_bracket = layout.find('(') + right_bracket = layout.find(')') + if left_bracket >= 0 and right_bracket > left_bracket: + return (layout[:left_bracket] + layout[right_bracket + 1:], \ + layout[left_bracket + 1:right_bracket]) + return (layout, 'default') + + def __get_option_from_layout(self, layout): + left_bracket = layout.find('[') + right_bracket = layout.find(']') + if left_bracket >= 0 and right_bracket > left_bracket: + return (layout[:left_bracket] + layout[right_bracket + 1:], \ + layout[left_bracket + 1:right_bracket]) + return (layout, 'default') + + def __get_output_from_cmdline(self, arg, string): + exec_command = '%s %s' % (self.__command, arg) + retval = None + for line in os.popen(exec_command).readlines(): + line = line.strip() + if line.startswith(string): + retval = line[len(string):] + break + return retval + + def __get_userhome(self): + if 'HOME' not in os.environ: + import pwd + userhome = pwd.getpwuid(os.getuid()).pw_dir + else: + userhome = os.environ['HOME'] + userhome = userhome.rstrip('/') + return userhome + + def __get_fullpath(self, command): + if 'PATH' in os.environ: + envpath = os.environ['PATH'] + else: + envpath = os.defpath + PATH = envpath.split(os.pathsep) + for dir in PATH: + filepath = os.path.join(dir, command) + if os.path.exists(filepath): + return filepath + return None + + def __set_layout_cb(self, pid, status): + if self.__xkb_pid != pid: + print >> sys.stderr, \ + 'ibus.xkblayout: set_layout_cb has another pid' + return + self.__xkb_pid.close() + self.__xkb_pid = None + self.set_xmodmap() + + def __set_xmodmap_cb(self, pid, status): + if self.__xmodmap_pid != pid: + print >> sys.stderr, \ + 'ibus.xkblayout: set_xmodmap_cb has another pid' + return + self.__xmodmap_pid.close() + self.__xmodmap_pid = None + + def use_xkb(self, enable): + if self.__command == None: + return + self.__use_xkb = enable + + def get_layout(self): + if not self.__use_xkb: + return None + return self.__get_output_from_cmdline('--get', 'layout: ') + + def get_model(self): + if not self.__use_xkb: + return None + return self.__get_output_from_cmdline('--get', 'model: ') + + def get_option(self): + if not self.__use_xkb: + return None + return self.__get_output_from_cmdline('--get', 'option: ') + + def get_group(self): + if not self.__use_xkb: + return 0 + return int(self.__get_output_from_cmdline('--get-group', 'group: ')) + + def set_layout(self, layout='default', model='default', option='default'): + if not self.__use_xkb: + return + if layout == None: + return + if self.__default_layout == None: + # Maybe opening display was failed in constructor. + self.reload_default_layout() + if self.__default_layout == None: + return + layout = str(layout) + # if set_default_layout() is not default, the default layout is + # pulled from the current XKB. But it's possible gnome-settings-daemon + # does not run yet. I added XKB_SESSION_TIME_OUT for the timer. + if self.__time_lag_session_xkb_layout == True: + self.__default_layout = self.get_layout() + self.__default_model = self.get_model() + if self.__time_lag_session_xkb_option == True: + self.__default_option = self.get_option() + if (self.__time_lag_session_xkb_layout == True or \ + self.__time_lag_session_xkb_option == True ) and \ + (time.time() - self.__time_lag_session_xkb_timer \ + > XKB_SESSION_TIME_OUT): + self.__time_lag_session_xkb_layout = False + self.__time_lag_session_xkb_option = False + if layout == 'default': + layout = self.__default_layout + else: + self.__time_lag_session_xkb_layout = False + if model != None: + model = str(model) + if model == 'default': + (layout, model) = self.__get_model_from_layout(layout) + if model == 'default': + model = self.__default_model + else: + self.__time_lag_session_xkb_layout = False + if option != None: + option = str(option) + if option == 'default': + (layout, engine_option) = self.__get_option_from_layout(layout) + if engine_option != None and engine_option != 'default': + option = self.__default_option + if option == None: + option = engine_option + else: + option = '%s,%s' % (option, engine_option) + self.__time_lag_session_xkb_option = False + if option == 'default': + option = self.__default_option + need_us_layout = False + for latin_layout in self.__xkb_latin_layouts: + latin_layout = str(latin_layout) + # layout 'in' and model 'eng' is English layout. + if layout == latin_layout and model != 'eng': + need_us_layout = True + break + if model != None and layout + '(' + model + ')' == latin_layout: + need_us_layout = True + break + if need_us_layout: + layout = layout + ',us' + if model != None: + model = model + ',' + if layout == self.get_layout() and \ + model == self.get_model() and \ + option == self.get_option(): + return + args = [] + args.append(self.__command) + args.append('--layout') + args.append(layout) + if model != None: + args.append('--model') + args.append(model) + if option != None: + args.append('--option') + args.append(option) + pid = glib.spawn_async(argv=args, + flags=glib.SPAWN_DO_NOT_REAP_CHILD)[0] + self.__xkb_pid = pid + glib.child_watch_add(self.__xkb_pid, self.__set_layout_cb) + + def set_default_layout(self, layout='default', model='default'): + if not self.__use_xkb: + return + if layout == None: + print >> sys.stderr, 'ibus.xkblayout: None layout' + return + if model == None: + print >> sys.stderr, 'ibus.xkblayout: None model' + return + if layout == 'default': + self.__default_layout = self.get_layout() + self.__default_model = self.get_model() + else: + if model == 'default': + (layout, model) = self.__get_model_from_layout(layout) + self.__default_layout = layout + self.__time_lag_session_xkb_layout = False + if model == 'default': + self.__default_model = None + else: + self.__default_model = model + + def set_default_option(self, option='default'): + if not self.__use_xkb: + return + if option == None: + print >> sys.stderr, 'ibus.xkblayout: None option' + return + if option == 'default': + self.__default_option = self.get_option() + else: + self.__default_option = option + self.__time_lag_session_xkb_option = False + + def get_default_layout(self): + return [self.__default_layout, self.__default_model]; + + def get_default_option(self): + return self.__default_option + + def reload_default_layout(self): + if not self.__use_xkb: + return + self.__default_layout = self.get_layout() + self.__default_model = self.get_model() + self.__default_option = self.get_option() + + def set_xmodmap(self): + if not self.__use_xmodmap: + return + if self.__xmodmap_pid != None: + return + xmodmap_cmdpath = self.__get_fullpath(XMODMAP_CMD) + if xmodmap_cmdpath == None: + xmodmap_cmdpath = XMODMAP_CMD + for xmodmap_file in XMODMAP_KNOWN_FILES: + xmodmap_filepath = os.path.join(self.__get_userhome(), xmodmap_file) + if not os.path.exists(xmodmap_filepath): + continue + pid = glib.spawn_async(argv=[xmodmap_cmdpath, xmodmap_filepath], + flags=glib.SPAWN_DO_NOT_REAP_CHILD)[0] + self.__xmodmap_pid = pid + glib.child_watch_add(self.__xmodmap_pid, self.__set_xmodmap_cb) + break + + +def test(): + import gtk + import ibus + + window = None + config = None + xkblayout = None + + def __destroy(*args): + window.hide() + gtk.main_quit() + + def __test_set_session_xkb(button): + xkblayout.set_layout('default') + print 'Reset the default keymap' + print 'Layout:', xkblayout.get_default_layout() + print 'Option:', xkblayout.get_default_option() + + def __test_set_user_xkb(button): + layout = 'us' + model = 'default' + option = 'default' + if len(sys.argv) > 1: + layout = sys.argv[1] + if len(sys.argv) > 2: + model = sys.argv[2] + if model == 'None': + model = None + if len(sys.argv) > 3: + option = sys.argv[3] + if option == 'None': + optoin = None + xkblayout.set_layout(layout, model, option) + print 'Test set_layout:', layout, model, option + + if ibus.get_address() != None: + bus = ibus.Bus() + config = bus.get_config() + else: + print 'no ibus' + xkblayout = XKBLayout(config) + print 'Layout:', xkblayout.get_default_layout() + print 'Option:', xkblayout.get_default_option() + window = gtk.Window(gtk.WINDOW_TOPLEVEL) + window.connect('destroy', __destroy) + vb = gtk.VBox() + window.add(vb) + b = gtk.Button('Test xkb') + b.connect('clicked', __test_set_user_xkb) + vb.add(b) + b = gtk.Button('Reset the default xkb') + b.connect('clicked', __test_set_session_xkb) + vb.add(b) + window.show_all() + if config != None: + ibus.main() + else: + gtk.main() + +if __name__ == '__main__': + test() diff --git a/ibus/xkbxml.py.in b/ibus/xkbxml.py.in new file mode 100644 index 0000000..9407c13 --- /dev/null +++ b/ibus/xkbxml.py.in @@ -0,0 +1,419 @@ +# vim:set et sts=4 sw=4: +# +# ibus - The Input Bus +# +# Copyright (c) 2011 Takao Fujiwara +# Copyright (c) 2011 Peng Huang +# Copyright (c) 2011 Red Hat, Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program; if not, write to the +# Free Software Foundation, Inc., 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +__all__ = ( + 'XKBConfigRegistry', + 'XKBLayoutConfig', + ) + +import os +import string +import xml.sax as sax +import enginedesc +from xml.sax.saxutils import XMLFilterBase, XMLGenerator +from xml.sax._exceptions import SAXParseException +from cStringIO import StringIO + +try: + from glib import get_user_config_dir +except ImportError: + get_user_config_dir = lambda : None + +XKB_RULES_XML_FILE = '@XKB_RULES_XML_FILE@' + +class XKBConfigRegistryHandler(XMLFilterBase): + def __init__(self, parser=None, root='root'): + XMLFilterBase.__init__(self, parser) + self.__root = root + self.__current_node = root + self.__layoutlist_array = {} + self.__layoutlist = False + self.__layout = False + self.__layout_label = None + self.__layout_desc = {} + self.__layout_lang = {} + self.__variantlist = False + self.__variant = False + self.__variant_label = None + self.__variant_desc = {} + self.__optionlist_array = {} + self.__optionlist = False + self.__option_group_desc = {} + self.__option_desc = {} + self.__option = False + self.__option_label = None + self.__group = False + self.__group_label = None + + def __characters_layoutlist(self, text): + if not self.__layout: + return + if self.__variant: + if self.__current_node == 'name': + self.__variant_label = text + if self.__layout_label != None and \ + self.__layout_label in self.__layoutlist_array: + self.__layoutlist_array[self.__layout_label].append(text) + elif self.__current_node == 'description': + label = '%s(%s)' % (self.__layout_label, self.__variant_label) + self.__variant_desc[label] = text + elif self.__current_node == 'iso639Id': + label = self.__layout_label + if label != None: + label = '%s(%s)' % (label, self.__variant_label) + else: + label = self.__variant_label + if label not in self.__layout_lang: + self.__layout_lang[label] = [] + self.__layout_lang[label].append(text) + else: + pass + else: + if self.__current_node == 'name': + self.__layout_label = text + self.__layoutlist_array[self.__layout_label] = [] + elif self.__current_node == 'description': + self.__layout_desc[self.__layout_label] = text + elif self.__current_node == 'iso639Id': + if self.__layout_label not in self.__layout_lang: + self.__layout_lang[self.__layout_label] = [] + self.__layout_lang[self.__layout_label].append(text) + else: + pass + + def __characters_optionlist(self, text): + if not self.__group: + return + if self.__option: + if self.__current_node == 'name': + self.__option_label = text + if self.__group_label != None and \ + self.__group_label in self.__optionlist_array: + self.__optionlist_array[self.__group_label].append(text) + elif self.__current_node == 'description': + self.__option_desc[self.__option_label] = text + else: + pass + else: + if self.__current_node == 'name': + self.__group_label = text + self.__optionlist_array[self.__group_label] = [] + elif self.__current_node == 'description': + self.__option_group_desc[self.__group_label] = text + else: + pass + + def startElement(self, name, attrs): + self.__current_node = name + if name == 'layoutList': + self.__layoutlist = True + elif name == 'layout': + self.__layout = True + self.__layout_label = None + elif name == 'variantList': + self.__variantlist = True + elif name == 'variant': + self.__variant = True + self.__variant_label = None + elif name == 'optionList': + self.__optionlist = True + elif name == 'option': + self.__option = True + self.__option_label = None + elif name == 'group': + self.__group = True + self.__group_label = None + + def endElement(self, name): + self.__current_node = self.__root + if name == 'layoutList': + self.__layoutlist = False + elif name == 'layout': + self.__layout = False + elif name == 'variantList': + self.__variantlist = False + elif name == 'variant': + self.__variant = False + elif name == 'optionList': + self.__optionlist = False + elif name == 'option': + self.__option = False + elif name == 'group': + self.__group = False + + def characters(self, text): + if self.__current_node == self.__root: + return + if self.__layoutlist: + self.__characters_layoutlist(text) + elif self.__optionlist: + self.__characters_optionlist(text) + + def getLayoutList(self): + return self.__layoutlist_array + + def getLayoutDesc(self): + return self.__layout_desc + + def getLayoutLang(self): + return self.__layout_lang + + def getVariantDesc(self): + return self.__variant_desc + + def getOptionList(self): + return self.__optionlist_array + + def getOptionGroupDesc(self): + return self.__option_group_desc + + def getOptionDesc(self): + return self.__option_desc + +class XKBLayoutConfigHandler(XMLFilterBase): + def __init__(self, + parser=None, + downstream=None, + preload_layouts=None, + root='root'): + XMLFilterBase.__init__(self, parser) + self.__downstream = downstream + self.__preload_layouts = preload_layouts + self.__root = root + self.__current_node = root + self.__xkblayout = False + self.__config = False + + def startDocument(self): + if self.__downstream != None: + self.__downstream.startDocument() + + def endDocument(self): + if self.__downstream != None: + self.__downstream.endDocument() + + def startElement(self, name, attrs): + self.__current_node = name + if name == 'xkblayout': + self.__xkblayout = True + if name == 'config': + self.__config = True + if self.__downstream != None: + self.__downstream.startElement(name, {}) + + def endElement(self, name): + self.__current_node = self.__root + if name == 'xkblayout': + self.__xkblayout = False + if name == 'config': + self.__config = False + if self.__downstream != None: + self.__downstream.endElement(name) + + def characters(self, text): + if self.__current_node == self.__root: + return + if not self.__xkblayout or not self.__config: + return + if self.__current_node == 'preload_layouts': + if self.__preload_layouts == None: + self.__preload_layouts = text.split(',') + self.__preload_layouts.sort() + if self.__downstream != None: + self.__downstream.characters(string.join(self.__preload_layouts, + ',')) + + def getPreloadLayouts(self): + return self.__preload_layouts + +class XKBConfigRegistry(): + def __init__(self, file_path=XKB_RULES_XML_FILE): + self.__handler = None + parser = sax.make_parser() + parser.setFeature(sax.handler.feature_namespaces, 0) + self.__handler = XKBConfigRegistryHandler(parser) + parser.setContentHandler(self.__handler) + f = file(file_path, 'r') + try: + parser.parse(f) + except SAXParseException: + print 'ERROR: invalid file format', file_path + finally: + f.close() + + def get_layout_list(self): + return self.__handler.getLayoutList() + + def get_layout_desc(self): + return self.__handler.getLayoutDesc() + + def get_layout_lang(self): + return self.__handler.getLayoutLang() + + def get_variant_desc(self): + return self.__handler.getVariantDesc() + + def get_option_list(self): + return self.__handler.getOptionList() + + def get_option_group_desc(self): + return self.__handler.getOptionGroupDesc() + + def get_option_desc(self): + return self.__handler.getOptionDesc() + + @classmethod + def have_xkb(self): + return @HAVE_XKB@ + + @classmethod + def engine_desc_new(self, + lang, + layout, + layout_desc=None, + variant=None, + variant_desc=None, + name=None): + if variant_desc != None: + longname = variant_desc + elif layout != None and variant != None: + longname = layout + ' - ' + variant + elif layout_desc != None: + longname = layout_desc + else: + longname = layout + name_prefix='xkb:layout:' + if variant != None: + if name == None: + name = name_prefix + layout + ':' + variant + desc = 'XKB ' + layout + '(' + variant + ') keyboard layout' + engine_layout = layout + '(' + variant + ')' + else: + if name == None: + name = name_prefix + layout + desc = 'XKB ' + layout + ' keyboard layout' + engine_layout = layout + + icon = 'ibus-engine' + + engine = enginedesc.EngineDesc(name, longname, desc, lang, + 'LGPL2.1', + 'Takao Fujiwara ', + icon, + engine_layout) + return engine + +class XKBLayoutConfig(): + def __init__(self, + system_config='@datadir@/ibus/xkb/xkblayoutconfig.xml'): + self.__user_config = get_user_config_dir() + if self.__user_config == None: + self.__user_config = os.environ['HOME'] + '/.config' + self.__user_config = self.__user_config + \ + '/ibus/xkb/xkblayoutconfig.xml' + self.__system_config = system_config + self.__filter_handler = None + self.__load() + + def __load(self, downstream=None, preload_layouts=None): + parser = sax.make_parser() + parser.setFeature(sax.handler.feature_namespaces, 0) + self.__filter_handler = XKBLayoutConfigHandler(parser, + downstream, + preload_layouts) + parser.setContentHandler(self.__filter_handler) + f = None + if os.path.exists(self.__user_config): + f = file(self.__user_config) + elif os.path.exists(self.__system_config): + f = file(self.__system_config) + if f == None: + return + try: + parser.parse(f) + except SAXParseException: + print 'ERROR: invalid file format', self.__user_config + finally: + f.close() + + def get_preload_layouts(self): + return self.__filter_handler.getPreloadLayouts() + + def save_preload_layouts(self, layouts): + if layouts == None: + if os.path.exists(self.__user_config): + os.unlink(self.__user_config) + return + parser = sax.make_parser() + parser.setFeature(sax.handler.feature_namespaces, 0) + result = StringIO() + downstream_handler = XMLGenerator(result, 'utf-8') + self.__load(downstream_handler, layouts) + contents = result.getvalue() + dir = os.path.dirname(self.__user_config) + if not os.path.exists(dir): + os.makedirs(dir, 0700) + f = open(self.__user_config, 'w') + f.write(contents) + f.close() + os.chmod(self.__user_config, 0600) + +def test(): + xkbconfig = XKBConfigRegistry() + layout_list = xkbconfig.get_layout_list() + layout_desc = xkbconfig.get_layout_desc() + layout_lang = xkbconfig.get_layout_lang() + variant_desc = xkbconfig.get_variant_desc() + for layout in layout_list.keys(): + if layout not in layout_lang: + print 'layout name:', layout, 'NO-LANG description:', layout_desc[layout] + continue + lang = layout_lang[layout] + print 'layout name:', layout, 'lang:', lang, 'description:', layout_desc[layout] + for variant in layout_list[layout]: + label = '%s(%s)' % (layout, variant) + if label in layout_lang: + lang = layout_lang[label] + print ' variant name:', variant, 'lang:', lang, 'description:', variant_desc[variant] + + option_list = xkbconfig.get_option_list() + option_group_desc = xkbconfig.get_option_group_desc() + option_desc = xkbconfig.get_option_desc() + for option_group in option_list.keys(): + print 'option group name:', option_group, 'description:', option_group_desc[option_group] + for option in option_list[option_group]: + print ' option name:', option, 'description:', option_desc[option] + +def test2(): + xkblayoutconfig = XKBLayoutConfig('../xkb/xkblayoutconfig.xml') + list = xkblayoutconfig.get_preload_layouts() + print list + if list == None: + list = [] + list.append('gb(test)') + list.sort() + #xkblayoutconfig.save_preload_layouts(list) + +if __name__ == '__main__': + test() + test2() diff --git a/setup/Makefile.am b/setup/Makefile.am index 9618d7f..48b1fed 100644 --- a/setup/Makefile.am +++ b/setup/Makefile.am @@ -28,6 +28,7 @@ ibussetup_PYTHON = \ enginetreeview.py \ engineabout.py \ keyboardshortcut.py \ + xkbsetup.py \ $(NULL) ibussetup_DATA = \ diff --git a/setup/enginecombobox.py b/setup/enginecombobox.py index 2fd8876..7383177 100644 --- a/setup/enginecombobox.py +++ b/setup/enginecombobox.py @@ -43,6 +43,7 @@ class EngineComboBox(gtk.ComboBox): self.connect("notify::active", self.__notify_active_cb) self.__model = None + self.__title = _("Select an input method") renderer = gtk.CellRendererPixbuf() renderer.set_property("xalign", 0) @@ -117,7 +118,7 @@ class EngineComboBox(gtk.ComboBox): renderer.set_property("weight", pango.WEIGHT_NORMAL) elif isinstance(engine, int): renderer.set_property("sensitive", True) - renderer.set_property("text", _("Select an input method")) + renderer.set_property("text", self.__title) renderer.set_property("weight", pango.WEIGHT_NORMAL) else: renderer.set_property("sensitive", True) @@ -140,5 +141,9 @@ class EngineComboBox(gtk.ComboBox): def get_active_engine(self): return self.get_property("active-engine") + def get_title(self): + return self.__title + def set_title(self, title): + self.__title = title diff --git a/setup/main.py b/setup/main.py index 6c0fb0e..97e05a4 100644 --- a/setup/main.py +++ b/setup/main.py @@ -37,6 +37,7 @@ from gtk import gdk from enginecombobox import EngineComboBox from enginetreeview import EngineTreeView from engineabout import EngineAbout +from xkbsetup import XKBSetup from i18n import DOMAINNAME, _, N_, init as i18n_init ( @@ -245,6 +246,8 @@ class Setup(object): self.__combobox.connect("notify::active-engine", self.__combobox_notify_active_engine_cb) self.__treeview.connect("notify", self.__treeview_notify_cb) + XKBSetup(self.__config, self.__builder) + def __combobox_notify_active_engine_cb(self, combobox, property): engine = self.__combobox.get_active_engine() button = self.__builder.get_object("button_engine_add") diff --git a/setup/setup.ui b/setup/setup.ui index c7ff564..57cb597 100644 --- a/setup/setup.ui +++ b/setup/setup.ui @@ -117,7 +117,6 @@ True - False The shortcut keys for switching to previous input method in the list 0 Previous input method: @@ -204,7 +203,6 @@ True - False True False @@ -216,7 +214,6 @@ ... True - False True False True @@ -841,6 +838,7 @@ You may use up/down buttons to change it.</i></small> True vertical 6 + True Use system keyboard layout @@ -856,6 +854,57 @@ You may use up/down buttons to change it.</i></small> 0 + + + True + 6 + + + True + System Keyboard Layout: + True + center + + + False + False + 0 + + + + + + True + True + False + + + False + False + 1 + + + + + False + False + 1 + + + + + Add or remove layouts in 'Select an input method' list + True + True + False + Add or remove keyboard layouts in all input method engnines + + + False + False + 2 + + @@ -1054,4 +1103,558 @@ Homepage: http://code.google.com/p/ibus + + Add or Remove Layouts + ibus-setup + + + vertical + True + 10 + 12 + + + True + 12 + 12 + + + True + 0 + none + + + True + 12 + 12 + + + True + vertical + 6 + + + True + True + 5 + 450 + 350 + automatic + automatic + out + + + True + none + + + True + vertical + + + + + + + 0 + + + + + + + + + True + <b>Keyboard Layout</b> + True + + + + + + + False + 0 + + + + + True + True + end + + + gtk-cancel + True + True + + + False + False + 0 + + + + + gtk-ok + True + True + True + + + False + False + 1 + + + + + False + False + end + 1 + + + + + + + System Keyboard Layout Setup + ibus-setup + + + vertical + True + 10 + 12 + + + True + 12 + 12 + + + True + 0 + none + + + True + 12 + 12 + + + True + vertical + 6 + + + True + + + True + vertical + 6 + + + True + + + False + 0 + + + + + 150 + True + True + automatic + automatic + in + + + True + True + 150 + + + + + False + 1 + + + + + 0 + + + + + True + vertical + 5 + start + + + gtk-add + True + False + True + True + Add the selected keyboard layout into the system keyboard layouts + True + + + False + False + 0 + + + + + gtk-remove + True + False + True + True + Remove the selected keyboard layout from the system keyboard layouts + True + + + False + False + 1 + + + + + gtk-go-up + True + False + True + True + Move up the selected keyboard layout in the system keyboard layouts list + True + + + False + False + 2 + + + + + gtk-go-down + True + False + True + True + Move down the selected keyboard layout in the system keyboard layouts list + True + + + False + False + 3 + + + + + Rese_t + True + False + True + True + Reset the system keyboard layouts list + True + + + False + False + 4 + + + + + 1 + + + + + 0 + + + + + True + 6 + + + True + gtk-info + 2 + + + False + 0 + + + + + True + 0 + True + + + 1 + + + + + 1 + + + + + + + + + True + <b>Keyboard Layout</b> + True + + + + + + + False + 0 + + + + + True + 12 + 12 + + + True + 0 + none + + + True + 12 + 12 + + + True + vertical + 6 + + + True + True + start + + + True + _Options... + True + True + + + False + False + 0 + + + + + False + False + 0 + + + + + + + + + True + <b>Keyboard Option</b> + True + + + + + + + False + 1 + + + + + True + True + end + + + gtk-cancel + True + True + + + False + False + 0 + + + + + gtk-ok + True + True + True + + + False + False + 1 + + + + + False + False + end + 1 + + + + + + + System Keyboard Option Setup + ibus-setup + + + vertical + True + 10 + 12 + + + True + 12 + 12 + + + True + 0 + none + + + True + 12 + 12 + + + True + vertical + 6 + + + Use the default keyboard option + True + True + False + Use the defualt XKB option + True + + + 0 + + + + + True + True + 5 + 450 + 350 + automatic + automatic + out + + + True + none + + + True + vertical + + + + + + + 1 + + + + + + + + + True + <b>Keyboard Option</b> + True + + + + + + + False + 0 + + + + + True + True + end + + + gtk-close + True + True + + + False + False + 0 + + + + + False + False + end + 1 + + + + + diff --git a/setup/xkbsetup.py b/setup/xkbsetup.py new file mode 100644 index 0000000..e777cea --- /dev/null +++ b/setup/xkbsetup.py @@ -0,0 +1,490 @@ +# vim:set et sts=4 sw=4: +# +# ibus - The Input Bus +# +# Copyright (c) 2011 Takao Fujiwara +# Copyright (c) 2011 Peng Huang +# Copyright (c) 2011 Red Hat, Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program; if not, write to the +# Free Software Foundation, Inc., 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +import gettext +import gobject +import gtk +import ibus + +_ = lambda a : gettext.dgettext("ibus", a) +XKB_MAX_LAYOUTS = 4 + +class XKBSetup(gobject.GObject): + def __init__(self, config, builder): + super(XKBSetup, self).__init__() + + self.__config = config + self.__builder = builder + + # system keyboard layout setting + self.__button_system_keyboard_layout = self.__builder.get_object("button_system_keyboard_layout") + text = str(self.__config.get_value("general", "system_keyboard_layout", '')) + if text == 'default' or text == '': + text = _("Default") + self.__button_system_keyboard_layout.set_label(text) + if not self.__config.get_value("general", "use_system_keyboard_layout", True): + self.__button_system_keyboard_layout.set_sensitive(False) + self.__button_system_keyboard_layout.connect("clicked", self.__button_system_keyboard_layout_cb) + + # use system keyboard layout setting + self.__config.connect("value-changed", self.__config_value_changed_cb) + + self.__xkblayoutconfig = None + self.__preload_xkb_engines = [] + self.__other_xkb_engines = [] + self.__default_xkb_engine = None + if ibus.XKBConfigRegistry.have_xkb(): + self.__xkblayoutconfig = ibus.XKBLayoutConfig() + + # config layouts dialog + self.__init_config_layouts() + + # default system keyboard dialog + self.__init_system_keyboard() + + def __config_value_changed_cb(self, bus, section, name, value): + if section == "general" and name == "use_system_keyboard_layout": + self.__button_system_keyboard_layout.set_sensitive(value) + + def __get_xkb_engines(self): + xkb_engines = [] + xkbconfig = ibus.XKBConfigRegistry() + layout_list = xkbconfig.get_layout_list() + layout_desc = xkbconfig.get_layout_desc() + layout_lang = xkbconfig.get_layout_lang() + variant_desc = xkbconfig.get_variant_desc() + for layout in layout_list.keys(): + langs = [] + if layout in layout_lang: + langs = layout_lang[layout] + for lang in langs: + engine = ibus.XKBConfigRegistry.engine_desc_new( + lang, + layout, + layout_desc[layout], + None, + None) + xkb_engines.append(engine) + for variant in layout_list[layout]: + label = "%s(%s)" % (layout, variant) + sub_langs = [] + if label in layout_lang: + sub_langs = layout_lang[label] + else: + sub_langs = langs + for lang in sub_langs: + engine = ibus.XKBConfigRegistry.engine_desc_new( + lang, + layout, + layout_desc[layout], + variant, + variant_desc[label]) + xkb_engines.append(engine) + return xkb_engines + + def __get_default_xkb_engine(self): + if self.__default_xkb_engine != None: + return self.__default_xkb_engine + self.__default_xkb_engine = ibus.XKBConfigRegistry.engine_desc_new( + "other", + "default", + _("Default"), + None, + None) + return self.__default_xkb_engine + + def __init_config_layouts(self): + if not ibus.XKBConfigRegistry.have_xkb(): + button = self.__builder.get_object("button_config_layouts") + button.hide() + return + + self.__dialog_config_layouts = self.__builder.get_object("dialog_config_layouts") + self.__button_config_layouts_cancel = self.__builder.get_object("button_config_layouts_cancel") + self.__button_config_layouts_cancel.connect("clicked", self.__button_config_layouts_cancel_cb) + self.__button_config_layouts_ok = self.__builder.get_object("button_config_layouts_ok") + self.__button_config_layouts_ok.connect("clicked", self.__button_config_layouts_ok_cb) + self.__vbox_all_keyboard_layouts = self.__builder.get_object("vbox_all_keyboard_layouts") + + xkb_engines = self.__get_xkb_engines() + if len(xkb_engines) > 0: + button = self.__builder.get_object("button_config_layouts") + button.connect("clicked", self.__button_config_layouts_cb) + button.set_sensitive(True) + + engine_dict = {} + for engine in xkb_engines: + if not engine.name.startswith("xkb:layout:"): + continue + lang = ibus.get_language_name(engine.language) + if lang not in engine_dict: + engine_dict[lang] = [] + engine_dict[lang].append(engine) + + keys = engine_dict.keys() + keys.sort() + if ibus.get_language_name("Other") in keys: + keys.remove(ibus.get_language_name("Other")) + keys += [ibus.get_language_name("Other")] + + preload_xkb_engines = self.__xkblayoutconfig.get_preload_layouts() + for lang in keys: + expander = gtk.Expander("") + self.__vbox_all_keyboard_layouts.pack_start(expander, True, True, 0) + expander.show() + label = expander.get_label_widget() + label.set_label(lang) + align = gtk.Alignment(0, 0, 1, 0) + align.set_padding(6, 0, 18, 0) + expander.add(align) + align.show() + vbox = gtk.VBox(False, 0) + align.add(vbox) + vbox.show() + + def cmp_engine(a, b): + if a.rank == b.rank: + return cmp(a.longname, b.longname) + return int(b.rank - a.rank) + engine_dict[lang].sort(cmp_engine) + + for engine in engine_dict[lang]: + sub_name = engine.name[len("xkb:layout:"):] + layout_list = sub_name.split(':') + if len(layout_list) > 1: + layout = "%s(%s)" % (layout_list[0], layout_list[1]) + else: + layout = layout_list[0] + has_preloaded = False + for preload_name in preload_xkb_engines: + preload_name = str(preload_name) + if len(preload_name) == 0: + continue + if layout == preload_name: + has_preloaded = True + break + + checkbutton = gtk.CheckButton(engine.longname) + checkbutton.set_data("layout", layout) + if has_preloaded: + checkbutton.set_active(True) + vbox.pack_start(checkbutton, False, True, 0) + checkbutton.show() + + def __init_system_keyboard_layout(self): + self.__dialog_system_keyboard_layout = self.__builder.get_object("dialog_system_keyboard_layout") + self.__button_system_keyboard_layout_cancel = self.__builder.get_object("button_system_keyboard_layout_cancel") + self.__button_system_keyboard_layout_cancel.connect("clicked", self.__button_system_keyboard_layout_cancel_cb) + self.__button_system_keyboard_layout_ok = self.__builder.get_object("button_system_keyboard_layout_ok") + self.__button_system_keyboard_layout_ok.connect("clicked", self.__button_system_keyboard_layout_ok_cb) + + # get xkb layouts + xkb_engines = self.__get_xkb_engines() + + self.__combobox_system_keyboard_layout = self.__builder.get_object("combobox_system_keyboard_layout_engines") + self.__combobox_system_keyboard_layout.set_engines(xkb_engines) + self.__combobox_system_keyboard_layout.set_title(_("Select keyboard layouts")) + self.__combobox_system_keyboard_layout.connect("notify::active-engine", self.__combobox_notify_active_system_keyboard_layout_cb) + self.__treeview_system_keyboard_layout = self.__builder.get_object("treeview_system_keyboard_layout_engines") + self.__treeview_system_keyboard_layout.connect("notify", self.__treeview_notify_system_keyboard_layout_cb) + column = self.__treeview_system_keyboard_layout.get_column(0) + column.set_title(_("Keyboard Layouts")) + button = self.__builder.get_object("button_system_keyboard_layout_engine_add") + button.connect("clicked", self.__button_system_keyboard_layout_add_cb) + button = self.__builder.get_object("button_system_keyboard_layout_engine_remove") + button.connect("clicked", self.__button_system_keyboard_layout_remove_cb) + button = self.__builder.get_object("button_system_keyboard_layout_engine_up") + button.connect("clicked", lambda *args:self.__treeview_system_keyboard_layout.move_up_engine()) + + button = self.__builder.get_object("button_system_keyboard_layout_engine_down") + button.connect("clicked", lambda *args:self.__treeview_system_keyboard_layout.move_down_engine()) + button = self.__builder.get_object("button_system_keyboard_layout_engine_reset") + button.connect("clicked", self.__button_system_keyboard_layout_reset_cb) + button_reset = button + text = str(self.__config.get_value("general", "system_keyboard_layout", '')) + if text == "default" or text == None: + engine = self.__get_default_xkb_engine() + self.__treeview_system_keyboard_layout.set_engines([engine]) + button_reset.set_sensitive(False) + else: + # The saved string 'cz,us(qwerty,)' needs to be rearranged to + # ['cz(qwerty)', 'us'] for each engine. + [l, v] = self.__get_model_from_layout(text) + variants = [] + if v != 'default' and v != None: + variants = v.split(',') + for i, layout in enumerate(l.split(',')): + if i < len(variants) and len(variants[i]) > 0: + layout = '%s(%s)' % (layout, variants[i]) + layout_engine = None + for engine in xkb_engines: + if layout == engine.layout: + layout_engine = engine + break + if layout_engine != None: + self.__treeview_system_keyboard_layout.append_engine(layout_engine) + button_reset.set_sensitive(True) + label = self.__builder.get_object("label_system_keyboard_layout_engines") + label.set_markup(_("The system keyboard layouts " + "can be set less than or equal to %d.\n" + "You may use Up/Down buttons to change the order." + "") % XKB_MAX_LAYOUTS) + + def __init_system_keyboard_option(self): + self.__dialog_system_keyboard_option = self.__builder.get_object("dialog_system_keyboard_option") + self.__button_system_keyboard_option_close = self.__builder.get_object("button_system_keyboard_option_close") + self.__button_system_keyboard_option_close.connect( + "clicked", lambda button: self.__dialog_system_keyboard_option.hide()) + + button = self.__builder.get_object("button_system_keyboard_option_setup") + button.connect("clicked", self.__button_system_keyboard_option_cb) + self.__checkbutton_use_system_keyboard_option = self.__builder.get_object("checkbutton_use_system_keyboard_option") + self.__vbox_system_keyboard_options = self.__builder.get_object("vbox_system_keyboard_options") + option_array = [] + text = str(self.__config.get_value("general", "system_keyboard_option", '')) + if text == None or text == "default": + self.__checkbutton_use_system_keyboard_option.set_active(True) + self.__vbox_system_keyboard_options.set_sensitive(False) + else: + self.__checkbutton_use_system_keyboard_option.set_active(False) + self.__vbox_system_keyboard_options.set_sensitive(True) + option_array = text.split(',') + self.__checkbutton_use_system_keyboard_option.connect( + "toggled", lambda button: self.__vbox_system_keyboard_options.set_sensitive(not button.get_active())) + + xkbconfig = ibus.XKBConfigRegistry() + option_list = xkbconfig.get_option_list() + option_group_desc = xkbconfig.get_option_group_desc() + option_desc = xkbconfig.get_option_desc() + for option_group in option_list.keys(): + expander = gtk.Expander("") + self.__vbox_system_keyboard_options.pack_start(expander, True, True, 0) + expander.show() + checked = 0 + label = expander.get_label_widget() + label.set_label(option_group_desc[option_group]) + label.set_data("option_group", option_group) + expander.set_data("checked", checked) + align = gtk.Alignment(0, 0, 1, 0) + align.set_padding(6, 0, 18, 0) + expander.add(align) + align.show() + vbox = gtk.VBox(False, 0) + align.add(vbox) + vbox.show() + for option in option_list[option_group]: + checkbutton = gtk.CheckButton(option_desc[option]) + checkbutton.set_data("option", option) + if option in option_array: + checkbutton.set_active(True) + label.set_markup("" + + option_group_desc[option_group] + + "") + checked = checked + 1 + expander.set_data("checked", checked) + checkbutton.connect("toggled", + self.__checkbutton_system_keyboard_option_toggled_cb, + expander) + vbox.pack_start(checkbutton, False, True, 0) + checkbutton.show() + + def __init_system_keyboard(self): + if not ibus.XKBConfigRegistry.have_xkb(): + hbox = self.__builder.get_object("hbox_system_keyboard_layout") + hbox.hide() + return + + self.__init_system_keyboard_layout() + self.__init_system_keyboard_option() + + def __get_model_from_layout(self, layout): + left_bracket = layout.find('(') + right_bracket = layout.find(')') + if left_bracket >= 0 and right_bracket > left_bracket: + return (layout[:left_bracket] + layout[right_bracket + 1:], \ + layout[left_bracket + 1:right_bracket]) + return (layout, 'default') + + def __combobox_notify_active_system_keyboard_layout_cb(self, combobox, property): + engine = self.__combobox_system_keyboard_layout.get_active_engine() + button = self.__builder.get_object("button_system_keyboard_layout_engine_add") + engines = self.__treeview_system_keyboard_layout.get_engines() + button.set_sensitive(engine != None and \ + engine not in engines and \ + len(engines) < XKB_MAX_LAYOUTS) + + def __treeview_notify_system_keyboard_layout_cb(self, treeview, property): + if property.name != "active-engine" and property.name != "engines": + return + + engines = self.__treeview_system_keyboard_layout.get_engines() + engine = self.__treeview_system_keyboard_layout.get_active_engine() + + button = self.__builder.get_object("button_system_keyboard_layout_engine_remove") + button.set_sensitive(engine != None) + button = self.__builder.get_object("button_system_keyboard_layout_engine_up") + button.set_sensitive(engine not in engines[:1]) + button = self.__builder.get_object("button_system_keyboard_layout_engine_down") + button.set_sensitive(engine not in engines[-1:]) + + def __button_system_keyboard_layout_add_cb(self, button): + engines = self.__treeview_system_keyboard_layout.get_engines() + engine = self.__combobox_system_keyboard_layout.get_active_engine() + if engine == None: + return + # If engines[0] is the default dummy engine: + if len(engines) > 0 and engines[0].layout == "default": + self.__treeview_system_keyboard_layout.set_engines([engine]) + else: + self.__treeview_system_keyboard_layout.append_engine(engine) + button_reset = self.__builder.get_object("button_system_keyboard_layout_engine_reset") + button_reset.set_sensitive(True) + if len(self.__treeview_system_keyboard_layout.get_engines()) >= XKB_MAX_LAYOUTS: + button.set_sensitive(False) + + def __button_system_keyboard_layout_remove_cb(self, button): + self.__treeview_system_keyboard_layout.remove_engine() + if len(self.__treeview_system_keyboard_layout.get_engines()) < XKB_MAX_LAYOUTS: + button_add = self.__builder.get_object("button_system_keyboard_layout_engine_add") + button_add.set_sensitive(True) + button_reset = self.__builder.get_object("button_system_keyboard_layout_engine_reset") + button_reset.set_sensitive(True) + + def __button_system_keyboard_layout_reset_cb(self, button): + engine = self.__get_default_xkb_engine() + self.__treeview_system_keyboard_layout.set_engines([engine]) + button.set_sensitive(False) + + def __button_config_layouts_cb(self, button): + self.__dialog_config_layouts.run() + self.__dialog_config_layouts.hide() + + def __button_config_layouts_cancel_cb(self, button): + self.__dialog_config_layouts.hide() + + def __button_config_layouts_ok_cb(self, button): + self.__dialog_config_layouts.hide() + engine_list = [] + for expander in self.__vbox_all_keyboard_layouts.get_children(): + align = expander.get_children()[0] + vbox = align.get_children()[0] + for checkbutton in vbox.get_children(): + if checkbutton.get_active(): + engine_list.append(checkbutton.get_data("layout")) + if len(engine_list) == 0: + return + engine_list.sort() + self.__xkblayoutconfig.save_preload_layouts(engine_list) + message = _("Please restart IBus to reload your configuration.") + dlg = gtk.MessageDialog(type = gtk.MESSAGE_INFO, + buttons = gtk.BUTTONS_OK, + message_format = message) + dlg.run() + dlg.destroy() + + def __button_system_keyboard_layout_cb(self, button): + self.__dialog_system_keyboard_layout.run() + self.__dialog_system_keyboard_layout.hide() + + def __button_system_keyboard_layout_cancel_cb(self, button): + self.__dialog_system_keyboard_layout.hide() + + def __button_system_keyboard_layout_ok_cb(self, button): + self.__dialog_system_keyboard_layout.hide() + layout = 'default' + variant = '' + has_variant = False + # if the string is 'cz(qwerty),us[options,...]', it would difficult + # to separate layouts by comma. So we rearrange this likes + # 'cz,us(qwerty,)[options,...]' here. + for engine in self.__treeview_system_keyboard_layout.get_engines(): + [l, v] = self.__get_model_from_layout(engine.layout) + if v == 'default' or v == None: + v = '' + if len(v) > 0: + has_variant = True + if layout == "default": + layout = l + variant = v + else: + layout = '%s,%s' % (layout, l) + variant = '%s,%s' % (variant, v) + if has_variant: + layout = '%s(%s)' % (layout, variant) + if layout == None or layout == "": + layout = "default" + org_layout = str(self.__config.get_value("general", "system_keyboard_layout", None)) + if layout != org_layout: + self.__config.set_value("general", "system_keyboard_layout", layout) + if layout == "default": + layout = _("Default") + self.__button_system_keyboard_layout.set_label(layout) + option = "default" + if not self.__checkbutton_use_system_keyboard_option.get_active(): + for expander in self.__vbox_system_keyboard_options.get_children(): + align = expander.get_children()[0] + vbox = align.get_children()[0] + for checkbutton in vbox.get_children(): + if checkbutton.get_active(): + data = checkbutton.get_data("option") + if option == "default": + option = data + else: + option = "%s,%s" % (option, data) + if option == None or option == "": + option = "default" + if option != "default" and option.find(':') < 0: + message = _("The keyboard option cannot be chosen.") + dlg = gtk.MessageDialog(type = gtk.MESSAGE_INFO, + buttons = gtk.BUTTONS_OK, + message_format = message) + dlg.run() + dlg.destroy() + return + org_option = str(self.__config.get_value("general", "system_keyboard_option", None)) + if option != org_option: + self.__config.set_value("general", "system_keyboard_option", option) + message = _("Please restart IBus to reload your configuration.") + dlg = gtk.MessageDialog(type = gtk.MESSAGE_INFO, + buttons = gtk.BUTTONS_OK, + message_format = message) + dlg.run() + dlg.destroy() + + def __button_system_keyboard_option_cb(self, button): + self.__dialog_system_keyboard_option.run() + self.__dialog_system_keyboard_option.hide() + + def __checkbutton_system_keyboard_option_toggled_cb(self, button, user_data): + expander = user_data + checked = expander.get_data("checked") + label = expander.get_label_widget() + if button.get_active(): + checked = checked + 1 + label.set_markup("" + label.get_text() + "") + else: + checked = checked - 1 + if checked <= 0: + label.set_text(label.get_text()) + expander.set_data("checked", checked) + diff --git a/src/Makefile.am b/src/Makefile.am index 6f0321c..c62f3ed 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -186,6 +186,11 @@ typelibs_DATA = $(INTROSPECTION_GIRS:.gir=.typelib) CLEANFILES += $(dist_gir_DATA) $(typelibs_DATA) endif +if ENABLE_XKB +ibus_sources += ibusxkbxml.c +ibus_headers += ibusxkbxml.h +endif + # gen enum types ibusenumtypes.h: $(ibus_headers) ibusenumtypes.h.template $(AM_V_GEN) ( top_builddir=`cd $(top_builddir) && pwd`; \ diff --git a/src/ibus.h b/src/ibus.h index addc531..467c775 100644 --- a/src/ibus.h +++ b/src/ibus.h @@ -45,6 +45,7 @@ #include #include #include +#include #include #include #include diff --git a/src/ibusxkbxml.c b/src/ibusxkbxml.c new file mode 100644 index 0000000..5386fdb --- /dev/null +++ b/src/ibusxkbxml.c @@ -0,0 +1,441 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +#include "ibus.h" +#include "ibusxkbxml.h" + +#ifndef XKB_RULES_XML_FILE +#define XKB_RULES_XML_FILE "/usr/share/X11/xkb/rules/evdev.xml" +#endif + +#define IBUS_XKB_CONFIG_REGISTRY_GET_PRIVATE(o) \ + (G_TYPE_INSTANCE_GET_PRIVATE ((o), IBUS_TYPE_XKB_CONFIG_REGISTRY, IBusXKBConfigRegistryPrivate)) + +typedef struct _IBusXKBConfigRegistryPrivate IBusXKBConfigRegistryPrivate; + +struct _IBusXKBConfigRegistryPrivate { + GHashTable *layout_list; + GHashTable *layout_lang; + GHashTable *layout_desc; + GHashTable *variant_desc; +}; + + +/* functions prototype */ +static void ibus_xkb_config_registry_destroy + (IBusXKBConfigRegistry *xkb_config); + +G_DEFINE_TYPE (IBusXKBConfigRegistry, ibus_xkb_config_registry, IBUS_TYPE_OBJECT) + +static void +parse_xkb_xml_languagelist_node (IBusXKBConfigRegistryPrivate *priv, + XMLNode *parent_node, + const gchar *layout_name) +{ + XMLNode *node = parent_node; + XMLNode *sub_node; + GList *p; + GList *lang_list = NULL; + + g_assert (node != NULL); + g_assert (layout_name != NULL); + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "iso639Id") == 0) { + lang_list = g_list_append (lang_list, + (gpointer) g_strdup (sub_node->text)); + continue; + } + } + if (lang_list == NULL) { + /* some nodes have no lang */ + return; + } + if (g_hash_table_lookup (priv->layout_lang, layout_name) != NULL) { + g_warning ("duplicated name %s exists", layout_name); + return; + } + g_hash_table_insert (priv->layout_lang, + (gpointer) g_strdup (layout_name), + (gpointer) lang_list); +} + +static const gchar * +parse_xkb_xml_configitem_node (IBusXKBConfigRegistryPrivate *priv, + XMLNode *parent_node) +{ + XMLNode *node = parent_node; + XMLNode *sub_node; + GList *p; + gchar *name = NULL; + gchar *description = NULL; + + g_assert (node != NULL); + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "name") == 0) { + name = sub_node->text; + continue; + } + if (g_strcmp0 (sub_node->name, "description") == 0) { + description = sub_node->text; + continue; + } + if (g_strcmp0 (sub_node->name, "languageList") == 0) { + if (name == NULL) { + g_warning ("layout name is NULL in node %s", node->name); + continue; + } + parse_xkb_xml_languagelist_node (priv, sub_node, name); + continue; + } + } + if (name == NULL) { + g_warning ("No name in layout node"); + return NULL; + } + if (g_hash_table_lookup (priv->layout_desc, name) != NULL) { + g_warning ("duplicated name %s exists", name); + return name; + } + g_hash_table_insert (priv->layout_desc, + (gpointer) g_strdup (name), + (gpointer) g_strdup (description)); + + return name; +} + +static const gchar * +parse_xkb_xml_variant_configitem_node (IBusXKBConfigRegistryPrivate *priv, + XMLNode *parent_node, + const gchar *layout_name) +{ + XMLNode *node = parent_node; + XMLNode *sub_node; + GList *p; + gchar *name = NULL; + gchar *description = NULL; + gchar *variant_lang_name = NULL; + + g_assert (node != NULL); + g_assert (layout_name != NULL); + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "name") == 0) { + name = sub_node->text; + continue; + } + if (g_strcmp0 (sub_node->name, "description") == 0) { + description = sub_node->text; + continue; + } + if (g_strcmp0 (sub_node->name, "languageList") == 0) { + if (name == NULL) { + g_warning ("layout name is NULL in node %s", node->name); + continue; + } + variant_lang_name = g_strdup_printf ("%s(%s)", layout_name, name); + parse_xkb_xml_languagelist_node (priv, sub_node, variant_lang_name); + g_free (variant_lang_name); + continue; + } + } + if (name == NULL) { + g_warning ("No name in layout node"); + return NULL; + } + if (g_hash_table_lookup (priv->variant_desc, name) != NULL) { + /* This is an expected case. */ + return name; + } + g_hash_table_insert (priv->variant_desc, + (gpointer) g_strdup (name), + (gpointer) g_strdup (description)); + return name; +} + +static const gchar * +parse_xkb_xml_variant_node (IBusXKBConfigRegistryPrivate *priv, + XMLNode *parent_node, + const gchar *layout_name) +{ + XMLNode *node = parent_node; + XMLNode *sub_node; + GList *p; + const gchar *variant_name = NULL; + + g_assert (node != NULL); + g_assert (layout_name != NULL); + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "configItem") == 0) { + variant_name = parse_xkb_xml_variant_configitem_node (priv, sub_node, layout_name); + continue; + } + } + return variant_name; +} + +static GList * +parse_xkb_xml_variantlist_node (IBusXKBConfigRegistryPrivate *priv, + XMLNode *parent_node, + const gchar *layout_name, + GList *variant_list) +{ + XMLNode *node = parent_node; + XMLNode *sub_node; + GList *p; + const gchar *variant_name = NULL; + + g_assert (node != NULL); + g_assert (layout_name != NULL); + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "variant") == 0) { + variant_name = parse_xkb_xml_variant_node (priv, sub_node, layout_name); + if (variant_name != NULL) { + variant_list = g_list_append (variant_list, + (gpointer) g_strdup (variant_name)); + } + continue; + } + } + return variant_list; +} + +static void +parse_xkb_xml_layout_node (IBusXKBConfigRegistryPrivate *priv, + XMLNode *parent_node) +{ + XMLNode *node = parent_node; + XMLNode *sub_node; + GList *p; + const gchar *name = NULL; + GList *variant_list = NULL; + + g_assert (node != NULL); + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "configItem") == 0) { + name = parse_xkb_xml_configitem_node (priv, sub_node); + continue; + } + if (g_strcmp0 (sub_node->name, "variantList") == 0) { + if (name == NULL) { + g_warning ("layout name is NULL in node %s", node->name); + continue; + } + variant_list = parse_xkb_xml_variantlist_node (priv, sub_node, + name, + variant_list); + continue; + } + } + if (g_hash_table_lookup (priv->layout_list, name) != NULL) { + g_warning ("duplicated name %s exists", name); + return; + } + g_hash_table_insert (priv->layout_list, + (gpointer) g_strdup (name), + (gpointer) variant_list); +} + +static void +parse_xkb_xml_top_node (IBusXKBConfigRegistryPrivate *priv, + XMLNode *parent_node) +{ + XMLNode *node = parent_node; + XMLNode *sub_node; + GList *p; + + g_assert (priv != NULL); + g_assert (node != NULL); + + if (g_strcmp0 (node->name, "xkbConfigRegistry") != 0) { + g_warning ("node has no xkbConfigRegistry name"); + return; + } + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "layoutList") == 0) { + break; + } + } + if (p == NULL) { + g_warning ("xkbConfigRegistry node has no layoutList node"); + return; + } + node = sub_node; + for (p = node->sub_nodes; p; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "layout") == 0) { + parse_xkb_xml_layout_node (priv, sub_node); + continue; + } + } +} + +static void +free_lang_list (GList *list) +{ + GList *l = list; + while (l) { + g_free (l->data); + l->data = NULL; + l = l->next; + } + g_list_free (list); +} + +static void +parse_xkb_config_registry_file (IBusXKBConfigRegistryPrivate *priv, + const gchar *file) +{ + XMLNode *node; + + g_assert (file != NULL); + + priv->layout_list = g_hash_table_new_full (g_str_hash, + (GEqualFunc) g_str_equal, + (GDestroyNotify) g_free, + (GDestroyNotify) free_lang_list); + priv->layout_desc = g_hash_table_new_full (g_str_hash, + (GEqualFunc) g_str_equal, + (GDestroyNotify) g_free, + (GDestroyNotify) g_free); + priv->layout_lang = g_hash_table_new_full (g_str_hash, + (GEqualFunc) g_str_equal, + (GDestroyNotify) g_free, + (GDestroyNotify) free_lang_list); + priv->variant_desc = g_hash_table_new_full (g_str_hash, + (GEqualFunc) g_str_equal, + (GDestroyNotify) g_free, + (GDestroyNotify) g_free); + node = ibus_xml_parse_file (file); + parse_xkb_xml_top_node (priv, node); + ibus_xml_free (node); +} + +static void +ibus_xkb_config_registry_init (IBusXKBConfigRegistry *xkb_config) +{ + IBusXKBConfigRegistryPrivate *priv; + const gchar *file = XKB_RULES_XML_FILE; + + priv = IBUS_XKB_CONFIG_REGISTRY_GET_PRIVATE (xkb_config); + parse_xkb_config_registry_file (priv, file); +} + +static void +ibus_xkb_config_registry_destroy (IBusXKBConfigRegistry *xkb_config) +{ + IBusXKBConfigRegistryPrivate *priv; + + g_return_if_fail (xkb_config != NULL); + + priv = IBUS_XKB_CONFIG_REGISTRY_GET_PRIVATE (xkb_config); + + g_hash_table_destroy (priv->layout_list); + priv->layout_list = NULL; + g_hash_table_destroy (priv->layout_lang); + priv->layout_lang= NULL; + g_hash_table_destroy (priv->layout_desc); + priv->layout_desc= NULL; + g_hash_table_destroy (priv->variant_desc); + priv->variant_desc = NULL; + + IBUS_OBJECT_CLASS(ibus_xkb_config_registry_parent_class)->destroy (IBUS_OBJECT (xkb_config)); +} + +static void +ibus_xkb_config_registry_class_init (IBusXKBConfigRegistryClass *klass) +{ + IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass); + + g_type_class_add_private (klass, sizeof (IBusXKBConfigRegistryPrivate)); + + ibus_object_class->destroy = (IBusObjectDestroyFunc) ibus_xkb_config_registry_destroy; +} + +IBusXKBConfigRegistry * +ibus_xkb_config_registry_new (void) +{ + IBusXKBConfigRegistry *xkb_config; + + xkb_config = IBUS_XKB_CONFIG_REGISTRY (g_object_new (IBUS_TYPE_XKB_CONFIG_REGISTRY, NULL)); + return xkb_config; +} + +#define TABLE_FUNC(field_name) const GHashTable * \ +ibus_xkb_config_registry_get_##field_name (IBusXKBConfigRegistry *xkb_config) \ +{ \ + IBusXKBConfigRegistryPrivate *priv; \ + \ + g_return_val_if_fail (xkb_config != NULL, NULL); \ + priv = IBUS_XKB_CONFIG_REGISTRY_GET_PRIVATE (xkb_config); \ + return priv->field_name; \ +} + +TABLE_FUNC (layout_list) +TABLE_FUNC (layout_lang) +TABLE_FUNC (layout_desc) +TABLE_FUNC (variant_desc) + +#undef TABLE_FUNC + +#define TABLE_LOOKUP_LIST_FUNC(field_name, value) GList * \ +ibus_xkb_config_registry_##field_name##_get_##value (IBusXKBConfigRegistry *xkb_config, const gchar *key) \ +{ \ + GHashTable *table; \ + GList *list = NULL; \ + \ + table = (GHashTable *) \ + ibus_xkb_config_registry_get_##field_name (xkb_config); \ + list = (GList *) g_hash_table_lookup (table, key); \ + return g_list_copy (list); \ +} + +#define TABLE_LOOKUP_STRING_FUNC(field_name, value) gchar * \ +ibus_xkb_config_registry_##field_name##_get_##value (IBusXKBConfigRegistry *xkb_config, const gchar *key) \ +{ \ + GHashTable *table; \ + const gchar *desc = NULL; \ + \ + table = (GHashTable *) \ + ibus_xkb_config_registry_get_##field_name (xkb_config); \ + desc = (const gchar *) g_hash_table_lookup (table, key); \ + return g_strdup (desc); \ +} + +TABLE_LOOKUP_LIST_FUNC (layout_list, variants) +TABLE_LOOKUP_LIST_FUNC (layout_lang, langs) +TABLE_LOOKUP_STRING_FUNC (layout_desc, desc) +TABLE_LOOKUP_STRING_FUNC (variant_desc, desc) + +#undef TABLE_LOOKUP_LIST_FUNC +#undef TABLE_LOOKUP_STRING_FUNC diff --git a/src/ibusxkbxml.h b/src/ibusxkbxml.h new file mode 100644 index 0000000..6986b5c --- /dev/null +++ b/src/ibusxkbxml.h @@ -0,0 +1,172 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifndef __IBUS_XKBXML_H_ +#define __IBUS_XKBXML_H_ + +#include "ibus.h" + +/* + * Type macros. + */ +/* define IBusXKBConfigRegistry macros */ +#define IBUS_TYPE_XKB_CONFIG_REGISTRY \ + (ibus_xkb_config_registry_get_type ()) +#define IBUS_XKB_CONFIG_REGISTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), IBUS_TYPE_XKB_CONFIG_REGISTRY, IBusXKBConfigRegistry)) +#define IBUS_XKB_CONFIG_REGISTRY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), IBUS_TYPE_XKB_CONFIG_REGISTRY, IBusXKBConfigRegistryClass)) +#define IBUS_IS_XKB_CONFIG_REGISTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), IBUS_TYPE_XKB_CONFIG_REGISTRY)) +#define IBUS_IS_XKB_CONFIG_REGISTRY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), IBUS_TYPE_XKB_CONFIG_REGISTRY)) +#define IBUS_XKB_CONFIG_REGISTRY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), IBUS_TYPE_XKB_CONFIG_REGISTRY, IBusXKBConfigRegistryClass)) + +G_BEGIN_DECLS + +typedef struct _IBusXKBConfigRegistry IBusXKBConfigRegistry; +typedef struct _IBusXKBConfigRegistryClass IBusXKBConfigRegistryClass; + +struct _IBusXKBConfigRegistry { + IBusObject parent; +}; + +struct _IBusXKBConfigRegistryClass { + IBusObjectClass parent; + /* signals */ + /*< private >*/ + /* padding */ + gpointer pdummy[8]; +}; + + +GType ibus_xkb_config_registry_get_type + (void); + +/** + * ibus_xkb_config_registry_new: + * @returns: A newly allocated IBusXKBConfigRegistry + * + * New an IBusXKBConfigRegistry. + */ +IBusXKBConfigRegistry * + ibus_xkb_config_registry_new + (void); + +/** + * ibus_xkb_config_registry_get_layout_list: (skip) + * @xkb_config: An IBusXKBConfigRegistry. + * @returns: A const GHashTable + * + * a const GHashTable + */ +const GHashTable * + ibus_xkb_config_registry_get_layout_list + (IBusXKBConfigRegistry *xkb_config); + +/** + * ibus_xkb_config_registry_get_layout_lang: (skip) + * @xkb_config: An IBusXKBConfigRegistry. + * @returns: A const GHashTable + * + * a const GHashTable + */ +const GHashTable * + ibus_xkb_config_registry_get_layout_lang + (IBusXKBConfigRegistry *xkb_config); + +/** + * ibus_xkb_config_registry_get_layout_desc: (skip) + * @xkb_config: An IBusXKBConfigRegistry. + * @returns: A const GHashTable + * + * a const GHashTable + */ +const GHashTable * + ibus_xkb_config_registry_get_layout_desc + (IBusXKBConfigRegistry *xkb_config); + +/** + * ibus_xkb_config_registry_get_variant_desc: (skip) + * @xkb_config: An IBusXKBConfigRegistry. + * @returns: A const GHashTable + * + * a const GHashTable + */ +const GHashTable * + ibus_xkb_config_registry_get_variant_desc + (IBusXKBConfigRegistry *xkb_config); + +/** + * ibus_xkb_config_registry_layout_list_get_variants: + * @xkb_config: An IBusXKBConfigRegistry. + * @layout: A layout. + * @returns: (transfer container) (element-type utf8): A GList + * + * a GList + */ +GList * + ibus_xkb_config_registry_layout_list_get_variants + (IBusXKBConfigRegistry *xkb_config, + const gchar *layout); + +/** + * ibus_xkb_config_registry_layout_lang_get_langs: + * @xkb_config: An IBusXKBConfigRegistry. + * @layout: A layout. + * @returns: (transfer container) (element-type utf8): A GList + * + * a GList + */ +GList * + ibus_xkb_config_registry_layout_lang_get_langs + (IBusXKBConfigRegistry *xkb_config, + const gchar *layout); + +/** + * ibus_xkb_config_registry_layout_desc_get_desc: + * @xkb_config: An IBusXKBConfigRegistry. + * @layout: A layout. + * @returns: A layout description + * + * a layout description + */ +gchar * + ibus_xkb_config_registry_layout_desc_get_desc + (IBusXKBConfigRegistry *xkb_config, + const gchar *layout); + +/** + * ibus_xkb_config_registry_variant_desc_get_desc: + * @xkb_config: An IBusXKBConfigRegistry. + * @variant: A variant. + * @returns: A variant description + * + * a variant description + */ +gchar * + ibus_xkb_config_registry_variant_desc_get_desc + (IBusXKBConfigRegistry *xkb_config, + const gchar *variant); +G_END_DECLS +#endif diff --git a/ui/gtk/panel.py b/ui/gtk/panel.py index f71a36d..a202d13 100644 --- a/ui/gtk/panel.py +++ b/ui/gtk/panel.py @@ -132,6 +132,22 @@ class Panel(ibus.PanelBase): self.__config_load_show_im_name() # self.__bus.request_name(ibus.panel.IBUS_SERVICE_PANEL, 0) + # init xkb + self.__xkblayout = ibus.XKBLayout(self.__config) + use_xkb = self.__config.get_value("general", "use_system_keyboard_layout", False) + if not use_xkb: + self.__xkblayout.use_xkb(use_xkb) + value = str(self.__config.get_value("general", "system_keyboard_layout", '')) + if value == '': + value = 'default' + if value != 'default': + self.__xkblayout.set_default_layout(value) + value = str(self.__config.get_value("general", "system_keyboard_option", '')) + if value == '': + value = 'default' + if value != 'default': + self.__xkblayout.set_default_option(value) + def set_cursor_location(self, x, y, w, h): self.__candidate_panel.set_cursor_location(x, y, w, h) @@ -226,14 +242,20 @@ class Panel(ibus.PanelBase): if not enabled: self.__set_im_icon(ICON_KEYBOARD) self.__set_im_name(None) + if self.__bus.get_use_sys_layout(): + self.__xkblayout.set_layout() else: engine = self.__focus_ic.get_engine() if engine: self.__set_im_icon(engine.icon) self.__set_im_name(engine.longname) + if self.__bus.get_use_sys_layout(): + self.__xkblayout.set_layout(self.__engine_get_layout_wrapper(engine)) else: self.__set_im_icon(ICON_KEYBOARD) self.__set_im_name(None) + if self.__bus.get_use_sys_layout(): + self.__xkblayout.set_layout() self.__language_bar.focus_in() def focus_out(self, ic): @@ -243,6 +265,8 @@ class Panel(ibus.PanelBase): self.__language_bar.focus_out() self.__set_im_icon(ICON_KEYBOARD) self.__set_im_name(None) + if self.__bus.get_use_sys_layout(): + self.__xkblayout.set_layout() def state_changed(self): if not self.__focus_ic: @@ -255,14 +279,20 @@ class Panel(ibus.PanelBase): self.reset() self.__set_im_icon(ICON_KEYBOARD) self.__set_im_name(None) + if self.__bus.get_use_sys_layout(): + self.__xkblayout.set_layout() else: engine = self.__focus_ic.get_engine() if engine: self.__set_im_icon(engine.icon) self.__set_im_name(engine.longname) + if self.__bus.get_use_sys_layout(): + self.__xkblayout.set_layout(self.__engine_get_layout_wrapper(engine)) else: self.__set_im_icon(ICON_KEYBOARD) self.__set_im_name(None) + if self.__bus.get_use_sys_layout(): + self.__xkblayout.set_layout() def reset(self): @@ -542,3 +572,14 @@ class Panel(ibus.PanelBase): flags=glib.SPAWN_DO_NOT_REAP_CHILD)[0] self.__setup_pid = pid glib.child_watch_add(self.__setup_pid, self.__child_watch_cb) + + def __engine_get_layout_wrapper(self, engine): + # This code is for the back compatibility. + # Should we remove the codes after all IM engines are changed + # to "default" layout? + if engine.name != None and engine.name.startswith("xkb:layout:"): + return engine.layout + elif engine.layout != None and engine.layout.startswith("default"): + return engine.layout + else: + return "default" diff --git a/xkb/Makefile.am b/xkb/Makefile.am new file mode 100644 index 0000000..b4d8ba2 --- /dev/null +++ b/xkb/Makefile.am @@ -0,0 +1,107 @@ +# vim:set noet ts=4: +# +# ibus - The Input Bus +# +# Copyright (C) 2011 Takao Fujiwara +# Copyright (c) 2011 Peng Huang +# Copyright (c) 2011 Red Hat, Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program; if not, write to the +# Free Software Foundation, Inc., 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +libibus = $(top_builddir)/src/libibus-@IBUS_API_VERSION@.la + +INCLUDES = \ + -I$(top_srcdir) \ + -I$(top_srcdir)/src \ + -DIBUS_LOCALEDIR=\"$(datadir)/locale\" \ + -DLIBEXECDIR=\""$(libexecdir)"\" \ + $(NULL) + +noinst_PROGRAMS = $(TESTS) +libexec_PROGRAMS = +EXTRA_DIST = +DISTCLEANFILES = + +if ENABLE_XKB +libexec_PROGRAMS += ibus-xkb +ibus_xkb_SOURCES = \ + ibus-xkb-main.c \ + xkblib.h \ + xkblib.c \ + $(NULL) +ibus_xkb_CFLAGS = \ + @XKB_CFLAGS@ \ + @X11_CFLAGS@ \ + @GLIB2_CFLAGS@ \ + $(NULL) +ibus_xkb_LDADD = \ + @XKB_LIBS@ \ + @X11_LIBS@ \ + @GLIB2_LIBS@ \ + $(libibus) \ + $(NULL) + +libexec_PROGRAMS += ibus-engine-xkb +ibus_engine_xkb_SOURCES = \ + ibus-engine-xkb-main.c \ + ibus-engine-xkb-main.h \ + ibus-simple-engine.c \ + ibus-simple-engine.h \ + gtkimcontextsimpleseqs.h \ + xkbxml.c \ + xkbxml.h \ + $(NULL) +ibus_engine_xkb_CFLAGS = \ + @GLIB2_CFLAGS@ \ + @GOBJECT2_CFLAGS@ \ + @GCONF_CFLAGS@ \ + $(NULL) +ibus_engine_xkb_LDADD = \ + @GLIB2_LIBS@ \ + @GOBJECT2_LIBS@ \ + @GCONF_LIBS@ \ + $(libibus) \ + $(NULL) + +xkblayoutdir = $(datadir)/ibus/component +xkblayout_in_files = xkblayout.xml.in +xkblayout_DATA = $(xkblayout_in_files:.xml.in=.xml) + +xkblayoutconfigdir = $(datadir)/ibus/xkb +xkblayoutconfig_in_files = xkblayoutconfig.xml.in +xkblayoutconfig_DATA = $(xkblayoutconfig_in_files:.xml.in=.xml) + +%.xml : %.xml.in + @sed -e "s|\@libexecdir\@|$(libexecdir)|g" \ + -e "s|\@datadir\@|$(datadir)|g" \ + -e "s|\@XKB_PRELOAD_LAYOUTS\@|$(XKB_PRELOAD_LAYOUTS)|g" \ + $< > $@ + +INCLUDES += \ + -DXKBLAYOUTCONFIG_FILE=\""$(xkblayoutconfigdir)/$(xkblayoutconfig_DATA)"\" \ + $(NULL) + +EXTRA_DIST += \ + $(xkblayout_in_files) \ + $(xkblayoutconfig_in_files) \ + $(NULL) + +DISTCLEANFILES += \ + $(xkblayout_DATA) \ + $(xkblayoutconfig_DATA) \ + $(NULL) + +endif diff --git a/xkb/Makefile.am.orig b/xkb/Makefile.am.orig new file mode 100644 index 0000000..ad9cdd9 --- /dev/null +++ b/xkb/Makefile.am.orig @@ -0,0 +1,104 @@ +# vim:set noet ts=4: +# +# ibus - The Input Bus +# +# Copyright (C) 2011 Takao Fujiwara +# Copyright (c) 2011 Peng Huang +# Copyright (c) 2011 Red Hat, Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program; if not, write to the +# Free Software Foundation, Inc., 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +libibus = $(top_builddir)/src/libibus-@IBUS_API_VERSION@.la + +INCLUDES = \ + -I$(top_srcdir) \ + -I$(top_srcdir)/src \ + -DIBUS_LOCALEDIR=\"$(datadir)/locale\" \ + -DLIBEXECDIR=\""$(libexecdir)"\" \ + $(NULL) + +noinst_PROGRAMS = $(TESTS) +libexec_PROGRAMS = +EXTRA_DIST = +DISTCLEANFILES = + +if ENABLE_XKB +libexec_PROGRAMS += ibus-xkb +ibus_xkb_SOURCES = \ + ibus-xkb-main.c \ + xkblib.h \ + xkblib.c \ + $(NULL) +ibus_xkb_CFLAGS = \ + @XKB_CFLAGS@ \ + @X11_CFLAGS@ \ + @GLIB2_CFLAGS@ \ + $(NULL) +ibus_xkb_LDADD = \ + @XKB_LIBS@ \ + @X11_LIBS@ \ + @GLIB2_LIBS@ \ + $(libibus) \ + $(NULL) + +libexec_PROGRAMS += ibus-engine-xkb +ibus_engine_xkb_SOURCES = \ + ibus-engine-xkb-main.c \ + ibus-engine-xkb-main.h \ + xkbxml.c \ + xkbxml.h \ + $(NULL) +ibus_engine_xkb_CFLAGS = \ + @GLIB2_CFLAGS@ \ + @GOBJECT2_CFLAGS@ \ + @GCONF_CFLAGS@ \ + $(NULL) +ibus_engine_xkb_LDADD = \ + @GLIB2_LIBS@ \ + @GOBJECT2_LIBS@ \ + @GCONF_LIBS@ \ + $(libibus) \ + $(NULL) + +xkblayoutdir = $(datadir)/ibus/component +xkblayout_in_files = xkblayout.xml.in +xkblayout_DATA = $(xkblayout_in_files:.xml.in=.xml) + +xkblayoutconfigdir = $(datadir)/ibus/xkb +xkblayoutconfig_in_files = xkblayoutconfig.xml.in +xkblayoutconfig_DATA = $(xkblayoutconfig_in_files:.xml.in=.xml) + +%.xml : %.xml.in + @sed -e "s|\@libexecdir\@|$(libexecdir)|g" \ + -e "s|\@datadir\@|$(datadir)|g" \ + -e "s|\@XKB_PRELOAD_LAYOUTS\@|$(XKB_PRELOAD_LAYOUTS)|g" \ + $< > $@ + +INCLUDES += \ + -DXKBLAYOUTCONFIG_FILE=\""$(xkblayoutconfigdir)/$(xkblayoutconfig_DATA)"\" \ + $(NULL) + +EXTRA_DIST += \ + $(xkblayout_in_files) \ + $(xkblayoutconfig_in_files) \ + $(NULL) + +DISTCLEANFILES += \ + $(xkblayout_DATA) \ + $(xkblayoutconfig_DATA) \ + $(NULL) + +endif diff --git a/xkb/gtkimcontextsimpleseqs.h b/xkb/gtkimcontextsimpleseqs.h new file mode 100644 index 0000000..00dc83c --- /dev/null +++ b/xkb/gtkimcontextsimpleseqs.h @@ -0,0 +1,4484 @@ +/* GTK - The GIMP Tool Kit + * Copyright (C) 2007, 2008 GNOME Foundation + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* + * File auto-generated from script found at http://bugzilla.gnome.org/show_bug.cgi?id=321896 + * using the input files + * Input : http://gitweb.freedesktop.org/?p=xorg/lib/libX11.git;a=blob_plain;f=nls/en_US.UTF-8/Compose.pre + * Input : http://www.cl.cam.ac.uk/~mgk25/ucs/keysyms.txt + * Input : http://www.unicode.org/Public/UNIDATA/UnicodeData.txt + * + * This table is optimised for space and requires special handling to access the content. + * This table is used solely by http://svn.gnome.org/viewcvs/gtk%2B/trunk/gtk/gtkimcontextsimple.c + * + * The resulting file is placed at http://svn.gnome.org/viewcvs/gtk%2B/trunk/gtk/gtkimcontextsimpleseqs.h + * This file is described in bug report http://bugzilla.gnome.org/show_bug.cgi?id=321896 + */ + +/* + * Modified by the GTK+ Team and others 2007, 2008. See the AUTHORS + * file for a list of people on the GTK+ Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + */ + +#ifndef __GTK_IM_CONTEXT_SIMPLE_SEQS_H__ +#define __GTK_IM_CONTEXT_SIMPLE_SEQS_H__ + +/* === These are the original comments of the file; we keep for historical purposes === + * + * The following table was generated from the X compose tables include with + * XFree86 4.0 using a set of Perl scripts. Contact Owen Taylor + * to obtain the relevant perl scripts. + * + * The following compose letter letter sequences confliced + * Dstroke/dstroke and ETH/eth; resolved to Dstroke (Croation, Vietnamese, Lappish), over + * ETH (Icelandic, Faroese, old English, IPA) [ D- -D d- -d ] + * Amacron/amacron and ordfeminine; resolved to ordfeminine [ _A A_ a_ _a ] + * Amacron/amacron and Atilde/atilde; resolved to atilde [ -A A- a- -a ] + * Omacron/Omacron and masculine; resolved to masculine [ _O O_ o_ _o ] + * Omacron/omacron and Otilde/atilde; resolved to otilde [ -O O- o- -o ] + * + * [ Amacron and Omacron are in Latin-4 (Baltic). ordfeminine and masculine are used for + * spanish. atilde and otilde are used at least for Portuguese ] + * + * at and Aring; resolved to Aring [ AA ] + * guillemotleft and caron; resolved to guillemotleft [ << ] + * ogonek and cedilla; resolved to cedilla [ ,, ] + * + * This probably should be resolved by first checking an additional set of compose tables + * that depend on the locale or selected input method. + */ + +static const guint16 gtk_compose_seqs_compact[] = { +IBUS_dead_stroke, 144, 232, 241, 241, 241, +IBUS_Greek_accentdieresis, 241, 245, 245, 245, 245, +IBUS_dead_grave, 245, 307, 394, 606, 606, +IBUS_dead_acute, 606, 670, 766, 1042, 1042, +IBUS_dead_circumflex, 1042, 1166, 1166, 1366, 1366, +IBUS_dead_tilde, 1366, 1450, 1513, 1653, 1653, +IBUS_dead_macron, 1653, 1699, 1699, 1771, 1771, +IBUS_dead_breve, 1771, 1821, 1821, 1845, 1845, +IBUS_dead_abovedot, 1845, 1875, 1878, 1910, 1910, +IBUS_dead_diaeresis, 1910, 1998, 2007, 2031, 2031, +IBUS_dead_abovering, 2031, 2041, 2041, 2041, 2041, +IBUS_dead_doubleacute, 2041, 2051, 2051, 2051, 2051, +IBUS_dead_caron, 2051, 2093, 2093, 2101, 2101, +IBUS_dead_cedilla, 2101, 2113, 2113, 2113, 2113, +IBUS_dead_ogonek, 2113, 2123, 2123, 2123, 2123, +IBUS_dead_iota, 2123, 2145, 2244, 2676, 3336, +IBUS_dead_voiced_sound, 3336, 3382, 3382, 3382, 3382, +IBUS_dead_semivoiced_sound, 3382, 3392, 3392, 3392, 3392, +IBUS_dead_belowdot, 3392, 3408, 3408, 3424, 3424, +IBUS_dead_hook, 3424, 3500, 3500, 3556, 3556, +IBUS_dead_horn, 3556, 3566, 3566, 3566, 3566, +IBUS_dead_psili, 3566, 3594, 3594, 3594, 3594, +IBUS_dead_dasia, 3594, 3626, 3626, 3626, 3626, +IBUS_Multi_key, 3626, 3626, 9560, 13268, 15133, +IBUS_space, 0x002F, +IBUS_2, 0x01BB, +IBUS_A, 0x023A, +IBUS_B, 0x0243, +IBUS_C, 0x023B, +IBUS_D, 0x0110, +IBUS_E, 0x0246, +IBUS_G, 0x01E4, +IBUS_H, 0x0126, +IBUS_I, 0x0197, +IBUS_J, 0x0248, +IBUS_L, 0x0141, +IBUS_O, 0x00D8, +IBUS_P, 0x2C63, +IBUS_R, 0x024C, +IBUS_T, 0x0166, +IBUS_U, 0x0244, +IBUS_Y, 0x024E, +IBUS_Z, 0x01B5, +IBUS_a, 0x2C65, +IBUS_b, 0x0180, +IBUS_c, 0x023C, +IBUS_d, 0x0111, +IBUS_e, 0x0247, +IBUS_g, 0x01E5, +IBUS_h, 0x0127, +IBUS_i, 0x0268, +IBUS_j, 0x0249, +IBUS_l, 0x0142, +IBUS_o, 0x00F8, +IBUS_p, 0x1D7D, +IBUS_r, 0x024D, +IBUS_t, 0x0167, +IBUS_u, 0x0289, +IBUS_y, 0x024F, +IBUS_z, 0x01B6, +IBUS_nobreakspace, 0x0338, +IBUS_Oacute, 0x01FE, +IBUS_oacute, 0x01FF, +0x0237, 0x025F, +0x0269, 0x1D7C, +IBUS_dead_stroke, 0x002F, +IBUS_lessthanequal, 0x2270, +IBUS_greaterthanequal, 0x2271, +IBUS_dead_acute, IBUS_O, 0x01FE, +IBUS_dead_acute, IBUS_o, 0x01FF, +IBUS_dead_abovedot, IBUS_j, 0x025F, +IBUS_Greek_iota, 0x0390, +IBUS_Greek_upsilon, 0x03B0, +IBUS_space, 0x0060, +IBUS_V, 0x01DB, +IBUS_v, 0x01DC, +IBUS_nobreakspace, 0x0300, +IBUS_Abreve, 0x1EB0, +IBUS_abreve, 0x1EB1, +IBUS_Emacron, 0x1E14, +IBUS_emacron, 0x1E15, +IBUS_Omacron, 0x1E50, +IBUS_omacron, 0x1E51, +IBUS_Cyrillic_ie, 0x0450, +IBUS_Cyrillic_i, 0x045D, +IBUS_Cyrillic_IE, 0x0400, +IBUS_Cyrillic_I, 0x040D, +IBUS_Greek_iotadieresis, 0x1FD2, +IBUS_Greek_upsilondieresis, 0x1FE2, +IBUS_Greek_ALPHA, 0x1FBA, +IBUS_Greek_EPSILON, 0x1FC8, +IBUS_Greek_ETA, 0x1FCA, +IBUS_Greek_IOTA, 0x1FDA, +IBUS_Greek_OMICRON, 0x1FF8, +IBUS_Greek_UPSILON, 0x1FEA, +IBUS_Greek_OMEGA, 0x1FFA, +IBUS_Greek_alpha, 0x1F70, +IBUS_Greek_epsilon, 0x1F72, +IBUS_Greek_eta, 0x1F74, +IBUS_Greek_iota, 0x1F76, +IBUS_Greek_omicron, 0x1F78, +IBUS_Greek_upsilon, 0x1F7A, +IBUS_Greek_omega, 0x1F7C, +IBUS_dead_grave, 0x0060, +IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD2, +IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE2, +IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0A, +IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1A, +IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2A, +IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3A, +IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4A, +IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6A, +IBUS_dead_psili, IBUS_Greek_alpha, 0x1F02, +IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F12, +IBUS_dead_psili, IBUS_Greek_eta, 0x1F22, +IBUS_dead_psili, IBUS_Greek_iota, 0x1F32, +IBUS_dead_psili, IBUS_Greek_omicron, 0x1F42, +IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F52, +IBUS_dead_psili, IBUS_Greek_omega, 0x1F62, +IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0B, +IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1B, +IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2B, +IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3B, +IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4B, +IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5B, +IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6B, +IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F03, +IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F13, +IBUS_dead_dasia, IBUS_Greek_eta, 0x1F23, +IBUS_dead_dasia, IBUS_Greek_iota, 0x1F33, +IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F43, +IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F53, +IBUS_dead_dasia, IBUS_Greek_omega, 0x1F63, +IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01DB, +IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01DC, +IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD2, +IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE2, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0B, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1B, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2B, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3B, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4B, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5B, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6B, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F03, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F13, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F23, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_iota, 0x1F33, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omicron, 0x1F43, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F53, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1F63, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0A, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1A, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F2A, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3A, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4A, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6A, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F02, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_epsilon, 0x1F12, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F22, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_iota, 0x1F32, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omicron, 0x1F42, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_upsilon, 0x1F52, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1F62, +IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EDC, +IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EEA, +IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EDD, +IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EEB, +IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EB0, +IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EB1, +IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EA6, +IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EC0, +IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED2, +IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EA7, +IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EC1, +IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED3, +IBUS_Multi_key, IBUS_underscore, IBUS_E, 0x1E14, +IBUS_Multi_key, IBUS_underscore, IBUS_O, 0x1E50, +IBUS_Multi_key, IBUS_underscore, IBUS_e, 0x1E15, +IBUS_Multi_key, IBUS_underscore, IBUS_o, 0x1E51, +IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EB0, +IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EB1, +IBUS_Multi_key, IBUS_macron, IBUS_E, 0x1E14, +IBUS_Multi_key, IBUS_macron, IBUS_O, 0x1E50, +IBUS_Multi_key, IBUS_macron, IBUS_e, 0x1E15, +IBUS_Multi_key, IBUS_macron, IBUS_o, 0x1E51, +IBUS_space, 0x0027, +IBUS_V, 0x01D7, +IBUS_v, 0x01D8, +IBUS_nobreakspace, 0x0301, +IBUS_Abreve, 0x1EAE, +IBUS_abreve, 0x1EAF, +IBUS_Emacron, 0x1E16, +IBUS_emacron, 0x1E17, +IBUS_Utilde, 0x1E78, +IBUS_omacron, 0x1E53, +IBUS_utilde, 0x1E79, +IBUS_Cyrillic_ghe, 0x0453, +IBUS_Cyrillic_ka, 0x045C, +IBUS_Cyrillic_GHE, 0x0403, +IBUS_Cyrillic_KA, 0x040C, +IBUS_Greek_iotadieresis, 0x0390, +IBUS_Greek_upsilondieresis, 0x03B0, +IBUS_Greek_ALPHA, 0x0386, +IBUS_Greek_EPSILON, 0x0388, +IBUS_Greek_ETA, 0x0389, +IBUS_Greek_IOTA, 0x038A, +IBUS_Greek_OMICRON, 0x038C, +IBUS_Greek_UPSILON, 0x038E, +IBUS_Greek_OMEGA, 0x038F, +IBUS_Greek_alpha, 0x03AC, +IBUS_Greek_epsilon, 0x03AD, +IBUS_Greek_eta, 0x03AE, +IBUS_Greek_iota, 0x03AF, +IBUS_Greek_omicron, 0x03CC, +IBUS_Greek_upsilon, 0x03CD, +IBUS_Greek_omega, 0x03CE, +IBUS_dead_acute, 0x00B4, +IBUS_dead_stroke, IBUS_O, 0x01FE, +IBUS_dead_stroke, IBUS_o, 0x01FF, +IBUS_dead_diaeresis, IBUS_space, 0x0385, +IBUS_dead_diaeresis, IBUS_Greek_iota, 0x0390, +IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x03B0, +IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0C, +IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1C, +IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2C, +IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3C, +IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4C, +IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6C, +IBUS_dead_psili, IBUS_Greek_alpha, 0x1F04, +IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F14, +IBUS_dead_psili, IBUS_Greek_eta, 0x1F24, +IBUS_dead_psili, IBUS_Greek_iota, 0x1F34, +IBUS_dead_psili, IBUS_Greek_omicron, 0x1F44, +IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F54, +IBUS_dead_psili, IBUS_Greek_omega, 0x1F64, +IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0D, +IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1D, +IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2D, +IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3D, +IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4D, +IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5D, +IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6D, +IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F05, +IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F15, +IBUS_dead_dasia, IBUS_Greek_eta, 0x1F25, +IBUS_dead_dasia, IBUS_Greek_iota, 0x1F35, +IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F45, +IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F55, +IBUS_dead_dasia, IBUS_Greek_omega, 0x1F65, +IBUS_Multi_key, IBUS_quotedbl, IBUS_I, 0x1E2E, +IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01D7, +IBUS_Multi_key, IBUS_quotedbl, IBUS_i, 0x1E2F, +IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01D8, +IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_iota, 0x0390, +IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_upsilon, 0x03B0, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0D, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1D, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2D, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3D, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4D, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5D, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6D, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F05, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F15, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F25, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_iota, 0x1F35, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omicron, 0x1F45, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F55, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1F65, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0C, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1C, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F2C, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3C, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4C, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6C, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F04, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_epsilon, 0x1F14, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F24, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_iota, 0x1F34, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omicron, 0x1F44, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_upsilon, 0x1F54, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1F64, +IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EDA, +IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EE8, +IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EDB, +IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EE9, +IBUS_Multi_key, IBUS_comma, IBUS_C, 0x1E08, +IBUS_Multi_key, IBUS_comma, IBUS_c, 0x1E09, +IBUS_Multi_key, IBUS_slash, IBUS_O, 0x01FE, +IBUS_Multi_key, IBUS_slash, IBUS_o, 0x01FF, +IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EAE, +IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EAF, +IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EA4, +IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EBE, +IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED0, +IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EA5, +IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EBF, +IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED1, +IBUS_Multi_key, IBUS_underscore, IBUS_E, 0x1E16, +IBUS_Multi_key, IBUS_underscore, IBUS_O, 0x1E52, +IBUS_Multi_key, IBUS_underscore, IBUS_e, 0x1E17, +IBUS_Multi_key, IBUS_underscore, IBUS_o, 0x1E53, +IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EAE, +IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EAF, +IBUS_Multi_key, IBUS_o, IBUS_A, 0x01FA, +IBUS_Multi_key, IBUS_o, IBUS_a, 0x01FB, +IBUS_Multi_key, IBUS_asciitilde, IBUS_O, 0x1E4C, +IBUS_Multi_key, IBUS_asciitilde, IBUS_U, 0x1E78, +IBUS_Multi_key, IBUS_asciitilde, IBUS_o, 0x1E4D, +IBUS_Multi_key, IBUS_asciitilde, IBUS_u, 0x1E79, +IBUS_Multi_key, IBUS_macron, IBUS_E, 0x1E16, +IBUS_Multi_key, IBUS_macron, IBUS_O, 0x1E52, +IBUS_Multi_key, IBUS_macron, IBUS_e, 0x1E17, +IBUS_Multi_key, IBUS_macron, IBUS_o, 0x1E53, +IBUS_Multi_key, IBUS_cedilla, IBUS_C, 0x1E08, +IBUS_Multi_key, IBUS_cedilla, IBUS_c, 0x1E09, +IBUS_Multi_key, IBUS_KP_Divide, IBUS_O, 0x01FE, +IBUS_Multi_key, IBUS_KP_Divide, IBUS_o, 0x01FF, +IBUS_space, 0x005E, +IBUS_parenleft, 0x207D, +IBUS_parenright, 0x207E, +IBUS_plus, 0x207A, +IBUS_minus, 0x207B, +IBUS_0, 0x2070, +IBUS_1, 0x00B9, +IBUS_2, 0x00B2, +IBUS_3, 0x00B3, +IBUS_4, 0x2074, +IBUS_5, 0x2075, +IBUS_6, 0x2076, +IBUS_7, 0x2077, +IBUS_8, 0x2078, +IBUS_9, 0x2079, +IBUS_equal, 0x207C, +IBUS_nobreakspace, 0x0302, +IBUS_Agrave, 0x1EA6, +IBUS_Aacute, 0x1EA4, +IBUS_Atilde, 0x1EAA, +IBUS_Egrave, 0x1EC0, +IBUS_Eacute, 0x1EBE, +IBUS_Ograve, 0x1ED2, +IBUS_Oacute, 0x1ED0, +IBUS_Otilde, 0x1ED6, +IBUS_agrave, 0x1EA7, +IBUS_aacute, 0x1EA5, +IBUS_atilde, 0x1EAB, +IBUS_egrave, 0x1EC1, +IBUS_eacute, 0x1EBF, +IBUS_ograve, 0x1ED3, +IBUS_oacute, 0x1ED1, +IBUS_otilde, 0x1ED7, +0x2212, 0x207B, +0x4E00, 0x3192, +0x4E01, 0x319C, +0x4E09, 0x3194, +0x4E0A, 0x3196, +0x4E0B, 0x3198, +0x4E19, 0x319B, +0x4E2D, 0x3197, +0x4E59, 0x319A, +0x4E8C, 0x3193, +0x4EBA, 0x319F, +0x56DB, 0x3195, +0x5730, 0x319E, +0x5929, 0x319D, +0x7532, 0x3199, +IBUS_dead_circumflex, 0x005E, +IBUS_KP_Space, 0x00B2, +IBUS_KP_Add, 0x207A, +IBUS_KP_0, 0x2070, +IBUS_KP_1, 0x00B9, +IBUS_KP_2, 0x00B2, +IBUS_KP_3, 0x00B3, +IBUS_KP_4, 0x2074, +IBUS_KP_5, 0x2075, +IBUS_KP_6, 0x2076, +IBUS_KP_7, 0x2077, +IBUS_KP_8, 0x2078, +IBUS_KP_9, 0x2079, +IBUS_KP_Equal, 0x207C, +IBUS_Multi_key, IBUS_exclam, IBUS_A, 0x1EAC, +IBUS_Multi_key, IBUS_exclam, IBUS_E, 0x1EC6, +IBUS_Multi_key, IBUS_exclam, IBUS_O, 0x1ED8, +IBUS_Multi_key, IBUS_exclam, IBUS_a, 0x1EAD, +IBUS_Multi_key, IBUS_exclam, IBUS_e, 0x1EC7, +IBUS_Multi_key, IBUS_exclam, IBUS_o, 0x1ED9, +IBUS_Multi_key, IBUS_S, IBUS_M, 0x2120, +IBUS_Multi_key, IBUS_S, IBUS_m, 0x2120, +IBUS_Multi_key, IBUS_T, IBUS_M, 0x2122, +IBUS_Multi_key, IBUS_T, IBUS_m, 0x2122, +IBUS_Multi_key, IBUS_underscore, IBUS_a, 0x00AA, +IBUS_Multi_key, IBUS_underscore, IBUS_h, 0x02B0, +IBUS_Multi_key, IBUS_underscore, IBUS_i, 0x2071, +IBUS_Multi_key, IBUS_underscore, IBUS_j, 0x02B2, +IBUS_Multi_key, IBUS_underscore, IBUS_l, 0x02E1, +IBUS_Multi_key, IBUS_underscore, IBUS_n, 0x207F, +IBUS_Multi_key, IBUS_underscore, IBUS_o, 0x00BA, +IBUS_Multi_key, IBUS_underscore, IBUS_r, 0x02B3, +IBUS_Multi_key, IBUS_underscore, IBUS_s, 0x02E2, +IBUS_Multi_key, IBUS_underscore, IBUS_w, 0x02B7, +IBUS_Multi_key, IBUS_underscore, IBUS_x, 0x02E3, +IBUS_Multi_key, IBUS_underscore, IBUS_y, 0x02B8, +IBUS_Multi_key, IBUS_underscore, 0x0263, 0x02E0, +IBUS_Multi_key, IBUS_underscore, 0x0266, 0x02B1, +IBUS_Multi_key, IBUS_underscore, 0x0279, 0x02B4, +IBUS_Multi_key, IBUS_underscore, 0x027B, 0x02B5, +IBUS_Multi_key, IBUS_underscore, 0x0281, 0x02B6, +IBUS_Multi_key, IBUS_underscore, 0x0295, 0x02E4, +IBUS_Multi_key, IBUS_s, IBUS_M, 0x2120, +IBUS_Multi_key, IBUS_s, IBUS_m, 0x2120, +IBUS_Multi_key, IBUS_t, IBUS_M, 0x2122, +IBUS_Multi_key, IBUS_t, IBUS_m, 0x2122, +IBUS_Multi_key, IBUS_underbar, IBUS_a, 0x00AA, +IBUS_Multi_key, IBUS_underbar, IBUS_h, 0x02B0, +IBUS_Multi_key, IBUS_underbar, IBUS_i, 0x2071, +IBUS_Multi_key, IBUS_underbar, IBUS_j, 0x02B2, +IBUS_Multi_key, IBUS_underbar, IBUS_l, 0x02E1, +IBUS_Multi_key, IBUS_underbar, IBUS_n, 0x207F, +IBUS_Multi_key, IBUS_underbar, IBUS_o, 0x00BA, +IBUS_Multi_key, IBUS_underbar, IBUS_r, 0x02B3, +IBUS_Multi_key, IBUS_underbar, IBUS_s, 0x02E2, +IBUS_Multi_key, IBUS_underbar, IBUS_w, 0x02B7, +IBUS_Multi_key, IBUS_underbar, IBUS_x, 0x02E3, +IBUS_Multi_key, IBUS_underbar, IBUS_y, 0x02B8, +IBUS_Multi_key, IBUS_underbar, 0x0263, 0x02E0, +IBUS_Multi_key, IBUS_underbar, 0x0266, 0x02B1, +IBUS_Multi_key, IBUS_underbar, 0x0279, 0x02B4, +IBUS_Multi_key, IBUS_underbar, 0x027B, 0x02B5, +IBUS_Multi_key, IBUS_underbar, 0x0281, 0x02B6, +IBUS_Multi_key, IBUS_underbar, 0x0295, 0x02E4, +IBUS_space, 0x007E, +IBUS_less, 0x2272, +IBUS_equal, 0x2243, +IBUS_greater, 0x2273, +IBUS_nobreakspace, 0x0303, +IBUS_Oacute, 0x1E4C, +IBUS_Odiaeresis, 0x1E4E, +IBUS_Uacute, 0x1E78, +IBUS_oacute, 0x1E4D, +IBUS_odiaeresis, 0x1E4F, +IBUS_uacute, 0x1E79, +IBUS_Abreve, 0x1EB4, +IBUS_abreve, 0x1EB5, +IBUS_Omacron, 0x022C, +IBUS_omacron, 0x022D, +IBUS_Greek_iotadieresis, 0x1FD7, +IBUS_Greek_upsilondieresis, 0x1FE7, +IBUS_Greek_alpha, 0x1FB6, +IBUS_Greek_eta, 0x1FC6, +IBUS_Greek_iota, 0x1FD6, +IBUS_Greek_upsilon, 0x1FE6, +IBUS_Greek_omega, 0x1FF6, +0x1F00, 0x1F06, +0x1F01, 0x1F07, +0x1F08, 0x1F0E, +0x1F09, 0x1F0F, +0x1F20, 0x1F26, +0x1F21, 0x1F27, +0x1F28, 0x1F2E, +0x1F29, 0x1F2F, +0x1F30, 0x1F36, +0x1F31, 0x1F37, +0x1F38, 0x1F3E, +0x1F39, 0x1F3F, +0x1F50, 0x1F56, +0x1F51, 0x1F57, +0x1F59, 0x1F5F, +0x1F60, 0x1F66, +0x1F61, 0x1F67, +0x1F68, 0x1F6E, +0x1F69, 0x1F6F, +IBUS_dead_tilde, 0x007E, +IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD7, +IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE7, +IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0E, +IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2E, +IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3E, +IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6E, +IBUS_dead_psili, IBUS_Greek_alpha, 0x1F06, +IBUS_dead_psili, IBUS_Greek_eta, 0x1F26, +IBUS_dead_psili, IBUS_Greek_iota, 0x1F36, +IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F56, +IBUS_dead_psili, IBUS_Greek_omega, 0x1F66, +IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0F, +IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2F, +IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3F, +IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5F, +IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6F, +IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F07, +IBUS_dead_dasia, IBUS_Greek_eta, 0x1F27, +IBUS_dead_dasia, IBUS_Greek_iota, 0x1F37, +IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F57, +IBUS_dead_dasia, IBUS_Greek_omega, 0x1F67, +IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD7, +IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE7, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0F, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2F, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3F, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5F, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6F, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F07, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F27, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_iota, 0x1F37, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F57, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1F67, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0E, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F2E, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3E, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6E, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F06, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F26, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_iota, 0x1F36, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_upsilon, 0x1F56, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1F66, +IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EE0, +IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EEE, +IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EE1, +IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EEF, +IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EB4, +IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EB5, +IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EAA, +IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EC4, +IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED6, +IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EAB, +IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EC5, +IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED7, +IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EB4, +IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EB5, +IBUS_space, 0x00AF, +IBUS_V, 0x01D5, +IBUS_v, 0x01D6, +IBUS_nobreakspace, 0x0304, +IBUS_Egrave, 0x1E14, +IBUS_Eacute, 0x1E16, +IBUS_Ograve, 0x1E50, +IBUS_Oacute, 0x1E52, +IBUS_egrave, 0x1E15, +IBUS_eacute, 0x1E17, +IBUS_ograve, 0x1E51, +IBUS_oacute, 0x1E53, +IBUS_Cyrillic_i, 0x04E3, +IBUS_Cyrillic_u, 0x04EF, +IBUS_Cyrillic_I, 0x04E2, +IBUS_Cyrillic_U, 0x04EE, +IBUS_Greek_ALPHA, 0x1FB9, +IBUS_Greek_IOTA, 0x1FD9, +IBUS_Greek_UPSILON, 0x1FE9, +IBUS_Greek_alpha, 0x1FB1, +IBUS_Greek_iota, 0x1FD1, +IBUS_Greek_upsilon, 0x1FE1, +IBUS_dead_macron, 0x00AF, +IBUS_Multi_key, IBUS_exclam, IBUS_L, 0x1E38, +IBUS_Multi_key, IBUS_exclam, IBUS_R, 0x1E5C, +IBUS_Multi_key, IBUS_exclam, IBUS_l, 0x1E39, +IBUS_Multi_key, IBUS_exclam, IBUS_r, 0x1E5D, +IBUS_Multi_key, IBUS_quotedbl, IBUS_A, 0x01DE, +IBUS_Multi_key, IBUS_quotedbl, IBUS_O, 0x022A, +IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01D5, +IBUS_Multi_key, IBUS_quotedbl, IBUS_a, 0x01DF, +IBUS_Multi_key, IBUS_quotedbl, IBUS_o, 0x022B, +IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01D6, +IBUS_Multi_key, IBUS_period, IBUS_A, 0x01E0, +IBUS_Multi_key, IBUS_period, IBUS_O, 0x0230, +IBUS_Multi_key, IBUS_period, IBUS_a, 0x01E1, +IBUS_Multi_key, IBUS_period, IBUS_o, 0x0231, +IBUS_Multi_key, IBUS_semicolon, IBUS_O, 0x01EC, +IBUS_Multi_key, IBUS_semicolon, IBUS_o, 0x01ED, +IBUS_Multi_key, IBUS_asciitilde, IBUS_O, 0x022C, +IBUS_Multi_key, IBUS_asciitilde, IBUS_o, 0x022D, +IBUS_space, 0x02D8, +IBUS_nobreakspace, 0x0306, +IBUS_Agrave, 0x1EB0, +IBUS_Aacute, 0x1EAE, +IBUS_Atilde, 0x1EB4, +IBUS_agrave, 0x1EB1, +IBUS_aacute, 0x1EAF, +IBUS_atilde, 0x1EB5, +IBUS_Cyrillic_a, 0x04D1, +IBUS_Cyrillic_ie, 0x04D7, +IBUS_Cyrillic_i, 0x0439, +IBUS_Cyrillic_u, 0x045E, +IBUS_Cyrillic_zhe, 0x04C2, +IBUS_Cyrillic_A, 0x04D0, +IBUS_Cyrillic_IE, 0x04D6, +IBUS_Cyrillic_I, 0x0419, +IBUS_Cyrillic_U, 0x040E, +IBUS_Cyrillic_ZHE, 0x04C1, +IBUS_Greek_ALPHA, 0x1FB8, +IBUS_Greek_IOTA, 0x1FD8, +IBUS_Greek_UPSILON, 0x1FE8, +IBUS_Greek_alpha, 0x1FB0, +IBUS_Greek_iota, 0x1FD0, +IBUS_Greek_upsilon, 0x1FE0, +IBUS_dead_breve, 0x02D8, +IBUS_Multi_key, IBUS_exclam, IBUS_A, 0x1EB6, +IBUS_Multi_key, IBUS_exclam, IBUS_a, 0x1EB7, +IBUS_Multi_key, IBUS_comma, IBUS_E, 0x1E1C, +IBUS_Multi_key, IBUS_comma, IBUS_e, 0x1E1D, +IBUS_Multi_key, IBUS_cedilla, IBUS_E, 0x1E1C, +IBUS_Multi_key, IBUS_cedilla, IBUS_e, 0x1E1D, +IBUS_space, 0x02D9, +IBUS_L, 0x013F, +IBUS_i, 0x0131, +IBUS_j, 0x0237, +IBUS_l, 0x0140, +IBUS_nobreakspace, 0x0307, +IBUS_Sacute, 0x1E64, +IBUS_Scaron, 0x1E66, +IBUS_sacute, 0x1E65, +IBUS_scaron, 0x1E67, +IBUS_Amacron, 0x01E0, +IBUS_Omacron, 0x0230, +IBUS_amacron, 0x01E1, +IBUS_omacron, 0x0231, +IBUS_dead_abovedot, 0x02D9, +IBUS_dead_stroke, IBUS_j, 0x025F, +IBUS_Multi_key, IBUS_exclam, IBUS_S, 0x1E68, +IBUS_Multi_key, IBUS_exclam, IBUS_s, 0x1E69, +IBUS_Multi_key, IBUS_apostrophe, IBUS_S, 0x1E64, +IBUS_Multi_key, IBUS_apostrophe, IBUS_s, 0x1E65, +IBUS_Multi_key, IBUS_c, IBUS_S, 0x1E66, +IBUS_Multi_key, IBUS_c, IBUS_s, 0x1E67, +IBUS_Multi_key, IBUS_acute, IBUS_S, 0x1E64, +IBUS_Multi_key, IBUS_acute, IBUS_s, 0x1E65, +IBUS_space, 0x0022, +IBUS_apostrophe, 0x0344, +IBUS_nobreakspace, 0x0308, +IBUS_acute, 0x0344, +IBUS_Iacute, 0x1E2E, +IBUS_Ugrave, 0x01DB, +IBUS_Uacute, 0x01D7, +IBUS_iacute, 0x1E2F, +IBUS_ugrave, 0x01DC, +IBUS_uacute, 0x01D8, +0x01D3, 0x01D9, +0x01D4, 0x01DA, +IBUS_Amacron, 0x01DE, +IBUS_Umacron, 0x1E7A, +IBUS_amacron, 0x01DF, +IBUS_omacron, 0x022B, +IBUS_umacron, 0x1E7B, +IBUS_Ukrainian_i, 0x0457, +IBUS_Ukrainian_I, 0x0407, +IBUS_Cyrillic_a, 0x04D3, +IBUS_Cyrillic_ie, 0x0451, +IBUS_Cyrillic_i, 0x04E5, +IBUS_Cyrillic_o, 0x04E7, +IBUS_Cyrillic_u, 0x04F1, +IBUS_Cyrillic_zhe, 0x04DD, +IBUS_Cyrillic_yeru, 0x04F9, +IBUS_Cyrillic_ze, 0x04DF, +IBUS_Cyrillic_e, 0x04ED, +IBUS_Cyrillic_che, 0x04F5, +IBUS_Cyrillic_A, 0x04D2, +IBUS_Cyrillic_IE, 0x0401, +IBUS_Cyrillic_I, 0x04E4, +IBUS_Cyrillic_O, 0x04E6, +IBUS_Cyrillic_U, 0x04F0, +IBUS_Cyrillic_ZHE, 0x04DC, +IBUS_Cyrillic_YERU, 0x04F8, +IBUS_Cyrillic_ZE, 0x04DE, +IBUS_Cyrillic_E, 0x04EC, +IBUS_Cyrillic_CHE, 0x04F4, +IBUS_Greek_IOTA, 0x03AA, +IBUS_Greek_UPSILON, 0x03AB, +IBUS_Greek_iota, 0x03CA, +IBUS_Greek_upsilon, 0x03CB, +IBUS_dead_diaeresis, 0x00A8, +IBUS_dead_acute, IBUS_space, 0x0385, +IBUS_dead_acute, IBUS_Greek_iota, 0x0390, +IBUS_dead_acute, IBUS_Greek_upsilon, 0x03B0, +IBUS_Multi_key, IBUS_underscore, IBUS_U, 0x1E7A, +IBUS_Multi_key, IBUS_underscore, IBUS_u, 0x1E7B, +IBUS_Multi_key, IBUS_asciitilde, IBUS_O, 0x1E4E, +IBUS_Multi_key, IBUS_asciitilde, IBUS_o, 0x1E4F, +IBUS_Multi_key, IBUS_macron, IBUS_U, 0x1E7A, +IBUS_Multi_key, IBUS_macron, IBUS_u, 0x1E7B, +IBUS_space, 0x00B0, +IBUS_nobreakspace, 0x030A, +IBUS_Aacute, 0x01FA, +IBUS_aacute, 0x01FB, +IBUS_dead_abovering, 0x00B0, +IBUS_space, 0x02DD, +IBUS_nobreakspace, 0x030B, +IBUS_Cyrillic_u, 0x04F3, +IBUS_Cyrillic_U, 0x04F2, +IBUS_dead_doubleacute, 0x02DD, +IBUS_space, 0x02C7, +IBUS_parenleft, 0x208D, +IBUS_parenright, 0x208E, +IBUS_plus, 0x208A, +IBUS_minus, 0x208B, +IBUS_0, 0x2080, +IBUS_1, 0x2081, +IBUS_2, 0x2082, +IBUS_3, 0x2083, +IBUS_4, 0x2084, +IBUS_5, 0x2085, +IBUS_6, 0x2086, +IBUS_7, 0x2087, +IBUS_8, 0x2088, +IBUS_9, 0x2089, +IBUS_equal, 0x208C, +IBUS_V, 0x01D9, +IBUS_v, 0x01DA, +IBUS_nobreakspace, 0x030C, +0x01F2, 0x01C5, +IBUS_dead_caron, 0x02C7, +IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01D9, +IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01DA, +IBUS_space, 0x00B8, +IBUS_nobreakspace, 0x0327, +IBUS_cent, 0x20B5, +IBUS_Cacute, 0x1E08, +IBUS_cacute, 0x1E09, +IBUS_dead_cedilla, 0x00B8, +IBUS_space, 0x02DB, +IBUS_nobreakspace, 0x0328, +IBUS_Omacron, 0x01EC, +IBUS_omacron, 0x01ED, +IBUS_dead_ogonek, 0x02DB, +IBUS_space, 0x037A, +IBUS_Greek_alphaaccent, 0x1FB4, +IBUS_Greek_etaaccent, 0x1FC4, +IBUS_Greek_omegaaccent, 0x1FF4, +IBUS_Greek_ALPHA, 0x1FBC, +IBUS_Greek_ETA, 0x1FCC, +IBUS_Greek_OMEGA, 0x1FFC, +IBUS_Greek_alpha, 0x1FB3, +IBUS_Greek_eta, 0x1FC3, +IBUS_Greek_omega, 0x1FF3, +IBUS_dead_iota, 0x037A, +IBUS_dead_grave, IBUS_Greek_alpha, 0x1FB2, +IBUS_dead_grave, IBUS_Greek_eta, 0x1FC2, +IBUS_dead_grave, IBUS_Greek_omega, 0x1FF2, +IBUS_dead_acute, IBUS_Greek_alpha, 0x1FB4, +IBUS_dead_acute, IBUS_Greek_eta, 0x1FC4, +IBUS_dead_acute, IBUS_Greek_omega, 0x1FF4, +IBUS_dead_tilde, IBUS_Greek_alpha, 0x1FB7, +IBUS_dead_tilde, IBUS_Greek_eta, 0x1FC7, +IBUS_dead_tilde, IBUS_Greek_omega, 0x1FF7, +IBUS_dead_tilde, 0x1F00, 0x1F86, +IBUS_dead_tilde, 0x1F01, 0x1F87, +IBUS_dead_tilde, 0x1F08, 0x1F8E, +IBUS_dead_tilde, 0x1F09, 0x1F8F, +IBUS_dead_tilde, 0x1F20, 0x1F96, +IBUS_dead_tilde, 0x1F21, 0x1F97, +IBUS_dead_tilde, 0x1F28, 0x1F9E, +IBUS_dead_tilde, 0x1F29, 0x1F9F, +IBUS_dead_tilde, 0x1F60, 0x1FA6, +IBUS_dead_tilde, 0x1F61, 0x1FA7, +IBUS_dead_tilde, 0x1F68, 0x1FAE, +IBUS_dead_tilde, 0x1F69, 0x1FAF, +IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F88, +IBUS_dead_psili, IBUS_Greek_ETA, 0x1F98, +IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FA8, +IBUS_dead_psili, IBUS_Greek_alpha, 0x1F80, +IBUS_dead_psili, IBUS_Greek_eta, 0x1F90, +IBUS_dead_psili, IBUS_Greek_omega, 0x1FA0, +IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F89, +IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F99, +IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FA9, +IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F81, +IBUS_dead_dasia, IBUS_Greek_eta, 0x1F91, +IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA1, +IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, +IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, +IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, +IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, +IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, +IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, +IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, +IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, +IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, +IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, +IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, +IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, +IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, +IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, +IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, +IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, +IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, +IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, +IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, +IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, +IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, +IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, +IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, +IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA7, +IBUS_Multi_key, IBUS_apostrophe, IBUS_Greek_alpha, 0x1FB4, +IBUS_Multi_key, IBUS_apostrophe, IBUS_Greek_eta, 0x1FC4, +IBUS_Multi_key, IBUS_apostrophe, IBUS_Greek_omega, 0x1FF4, +IBUS_Multi_key, IBUS_apostrophe, 0x1F00, 0x1F84, +IBUS_Multi_key, IBUS_apostrophe, 0x1F01, 0x1F85, +IBUS_Multi_key, IBUS_apostrophe, 0x1F08, 0x1F8C, +IBUS_Multi_key, IBUS_apostrophe, 0x1F09, 0x1F8D, +IBUS_Multi_key, IBUS_apostrophe, 0x1F20, 0x1F94, +IBUS_Multi_key, IBUS_apostrophe, 0x1F21, 0x1F95, +IBUS_Multi_key, IBUS_apostrophe, 0x1F28, 0x1F9C, +IBUS_Multi_key, IBUS_apostrophe, 0x1F29, 0x1F9D, +IBUS_Multi_key, IBUS_apostrophe, 0x1F60, 0x1FA4, +IBUS_Multi_key, IBUS_apostrophe, 0x1F61, 0x1FA5, +IBUS_Multi_key, IBUS_apostrophe, 0x1F68, 0x1FAC, +IBUS_Multi_key, IBUS_apostrophe, 0x1F69, 0x1FAD, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F89, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F99, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FA9, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F81, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F91, +IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA1, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F88, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F98, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FA8, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F80, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F90, +IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA0, +IBUS_Multi_key, IBUS_grave, IBUS_Greek_alpha, 0x1FB2, +IBUS_Multi_key, IBUS_grave, IBUS_Greek_eta, 0x1FC2, +IBUS_Multi_key, IBUS_grave, IBUS_Greek_omega, 0x1FF2, +IBUS_Multi_key, IBUS_grave, 0x1F00, 0x1F82, +IBUS_Multi_key, IBUS_grave, 0x1F01, 0x1F83, +IBUS_Multi_key, IBUS_grave, 0x1F08, 0x1F8A, +IBUS_Multi_key, IBUS_grave, 0x1F09, 0x1F8B, +IBUS_Multi_key, IBUS_grave, 0x1F20, 0x1F92, +IBUS_Multi_key, IBUS_grave, 0x1F21, 0x1F93, +IBUS_Multi_key, IBUS_grave, 0x1F28, 0x1F9A, +IBUS_Multi_key, IBUS_grave, 0x1F29, 0x1F9B, +IBUS_Multi_key, IBUS_grave, 0x1F60, 0x1FA2, +IBUS_Multi_key, IBUS_grave, 0x1F61, 0x1FA3, +IBUS_Multi_key, IBUS_grave, 0x1F68, 0x1FAA, +IBUS_Multi_key, IBUS_grave, 0x1F69, 0x1FAB, +IBUS_Multi_key, IBUS_asciitilde, IBUS_Greek_alpha, 0x1FB7, +IBUS_Multi_key, IBUS_asciitilde, IBUS_Greek_eta, 0x1FC7, +IBUS_Multi_key, IBUS_asciitilde, IBUS_Greek_omega, 0x1FF7, +IBUS_Multi_key, IBUS_asciitilde, 0x1F00, 0x1F86, +IBUS_Multi_key, IBUS_asciitilde, 0x1F01, 0x1F87, +IBUS_Multi_key, IBUS_asciitilde, 0x1F08, 0x1F8E, +IBUS_Multi_key, IBUS_asciitilde, 0x1F09, 0x1F8F, +IBUS_Multi_key, IBUS_asciitilde, 0x1F20, 0x1F96, +IBUS_Multi_key, IBUS_asciitilde, 0x1F21, 0x1F97, +IBUS_Multi_key, IBUS_asciitilde, 0x1F28, 0x1F9E, +IBUS_Multi_key, IBUS_asciitilde, 0x1F29, 0x1F9F, +IBUS_Multi_key, IBUS_asciitilde, 0x1F60, 0x1FA6, +IBUS_Multi_key, IBUS_asciitilde, 0x1F61, 0x1FA7, +IBUS_Multi_key, IBUS_asciitilde, 0x1F68, 0x1FAE, +IBUS_Multi_key, IBUS_asciitilde, 0x1F69, 0x1FAF, +IBUS_Multi_key, IBUS_acute, IBUS_Greek_alpha, 0x1FB4, +IBUS_Multi_key, IBUS_acute, IBUS_Greek_eta, 0x1FC4, +IBUS_Multi_key, IBUS_acute, IBUS_Greek_omega, 0x1FF4, +IBUS_Multi_key, IBUS_acute, 0x1F00, 0x1F84, +IBUS_Multi_key, IBUS_acute, 0x1F01, 0x1F85, +IBUS_Multi_key, IBUS_acute, 0x1F08, 0x1F8C, +IBUS_Multi_key, IBUS_acute, 0x1F09, 0x1F8D, +IBUS_Multi_key, IBUS_acute, 0x1F20, 0x1F94, +IBUS_Multi_key, IBUS_acute, 0x1F21, 0x1F95, +IBUS_Multi_key, IBUS_acute, 0x1F28, 0x1F9C, +IBUS_Multi_key, IBUS_acute, 0x1F29, 0x1F9D, +IBUS_Multi_key, IBUS_acute, 0x1F60, 0x1FA4, +IBUS_Multi_key, IBUS_acute, 0x1F61, 0x1FA5, +IBUS_Multi_key, IBUS_acute, 0x1F68, 0x1FAC, +IBUS_Multi_key, IBUS_acute, 0x1F69, 0x1FAD, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F92, +IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F94, +IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F96, +IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_eta, 0x1F94, +IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, +IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, +IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, +IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, +IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, +IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, +IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, +IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, +IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F92, +IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, +IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, +IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, +IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, +IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, +IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, +IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, +IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, +IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_eta, 0x1F96, +IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, +IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA7, +IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, +IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, +IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, +IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, +IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, +IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, +IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F94, +IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, +IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, +IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, +IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, +IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, +IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, +IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, +IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, +IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, +IBUS_kana_WO, 0x30FA, +IBUS_kana_U, 0x30F4, +IBUS_kana_KA, 0x30AC, +IBUS_kana_KI, 0x30AE, +IBUS_kana_KU, 0x30B0, +IBUS_kana_KE, 0x30B2, +IBUS_kana_KO, 0x30B4, +IBUS_kana_SA, 0x30B6, +IBUS_kana_SHI, 0x30B8, +IBUS_kana_SU, 0x30BA, +IBUS_kana_SE, 0x30BC, +IBUS_kana_SO, 0x30BE, +IBUS_kana_TA, 0x30C0, +IBUS_kana_CHI, 0x30C2, +IBUS_kana_TSU, 0x30C5, +IBUS_kana_TE, 0x30C7, +IBUS_kana_TO, 0x30C9, +IBUS_kana_HA, 0x30D0, +IBUS_kana_HI, 0x30D3, +IBUS_kana_FU, 0x30D6, +IBUS_kana_HE, 0x30D9, +IBUS_kana_HO, 0x30DC, +IBUS_kana_WA, 0x30F7, +IBUS_kana_HA, 0x30D1, +IBUS_kana_HI, 0x30D4, +IBUS_kana_FU, 0x30D7, +IBUS_kana_HE, 0x30DA, +IBUS_kana_HO, 0x30DD, +IBUS_space, 0x0323, +IBUS_plus, 0x2A25, +IBUS_minus, 0x2A2A, +IBUS_equal, 0x2A66, +IBUS_nobreakspace, 0x0323, +IBUS_Abreve, 0x1EB6, +IBUS_abreve, 0x1EB7, +IBUS_dead_belowdot, 0x0323, +IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EE2, +IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EF0, +IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EE3, +IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EF1, +IBUS_space, 0x0309, +IBUS_B, 0x0181, +IBUS_C, 0x0187, +IBUS_D, 0x018A, +IBUS_F, 0x0191, +IBUS_G, 0x0193, +IBUS_K, 0x0198, +IBUS_M, 0x2C6E, +IBUS_N, 0x019D, +IBUS_P, 0x01A4, +IBUS_T, 0x01AC, +IBUS_V, 0x01B2, +IBUS_W, 0x2C72, +IBUS_Z, 0x0224, +IBUS_b, 0x0253, +IBUS_c, 0x0188, +IBUS_d, 0x0257, +IBUS_f, 0x0192, +IBUS_g, 0x0260, +IBUS_h, 0x0266, +IBUS_k, 0x0199, +IBUS_m, 0x0271, +IBUS_n, 0x0272, +IBUS_p, 0x01A5, +IBUS_q, 0x02A0, +IBUS_s, 0x0282, +IBUS_t, 0x01AD, +IBUS_v, 0x028B, +IBUS_w, 0x2C73, +IBUS_z, 0x0225, +IBUS_nobreakspace, 0x0309, +IBUS_Abreve, 0x1EB2, +IBUS_abreve, 0x1EB3, +0x0256, 0x1D91, +0x025C, 0x025D, +0x025F, 0x0284, +0x0279, 0x027B, +IBUS_dead_hook, 0x0309, +IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EDE, +IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EEC, +IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EDF, +IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EED, +IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EB2, +IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EB3, +IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EA8, +IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EC2, +IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED4, +IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EA9, +IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EC3, +IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED5, +IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EB2, +IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EB3, +IBUS_space, 0x031B, +IBUS_nobreakspace, 0x031B, +IBUS_Utilde, 0x1EEE, +IBUS_utilde, 0x1EEF, +IBUS_dead_horn, 0x031B, +IBUS_Greek_ALPHA, 0x1F08, +IBUS_Greek_EPSILON, 0x1F18, +IBUS_Greek_ETA, 0x1F28, +IBUS_Greek_IOTA, 0x1F38, +IBUS_Greek_OMICRON, 0x1F48, +IBUS_Greek_OMEGA, 0x1F68, +IBUS_Greek_alpha, 0x1F00, +IBUS_Greek_epsilon, 0x1F10, +IBUS_Greek_eta, 0x1F20, +IBUS_Greek_iota, 0x1F30, +IBUS_Greek_omicron, 0x1F40, +IBUS_Greek_rho, 0x1FE4, +IBUS_Greek_upsilon, 0x1F50, +IBUS_Greek_omega, 0x1F60, +IBUS_Greek_ALPHA, 0x1F09, +IBUS_Greek_EPSILON, 0x1F19, +IBUS_Greek_ETA, 0x1F29, +IBUS_Greek_IOTA, 0x1F39, +IBUS_Greek_OMICRON, 0x1F49, +IBUS_Greek_RHO, 0x1FEC, +IBUS_Greek_UPSILON, 0x1F59, +IBUS_Greek_OMEGA, 0x1F69, +IBUS_Greek_alpha, 0x1F01, +IBUS_Greek_epsilon, 0x1F11, +IBUS_Greek_eta, 0x1F21, +IBUS_Greek_iota, 0x1F31, +IBUS_Greek_omicron, 0x1F41, +IBUS_Greek_rho, 0x1FE5, +IBUS_Greek_upsilon, 0x1F51, +IBUS_Greek_omega, 0x1F61, +IBUS_space, IBUS_space, 0x00A0, +IBUS_space, IBUS_apostrophe, 0x0027, +IBUS_space, IBUS_parenleft, 0x02D8, +IBUS_space, IBUS_comma, 0x00B8, +IBUS_space, IBUS_minus, 0x007E, +IBUS_space, IBUS_period, 0x2008, +IBUS_space, IBUS_less, 0x02C7, +IBUS_space, IBUS_greater, 0x005E, +IBUS_space, IBUS_asciicircum, 0x005E, +IBUS_space, IBUS_grave, 0x0060, +IBUS_space, IBUS_asciitilde, 0x007E, +IBUS_exclam, IBUS_exclam, 0x00A1, +IBUS_exclam, IBUS_question, 0x203D, +IBUS_exclam, IBUS_A, 0x1EA0, +IBUS_exclam, IBUS_B, 0x1E04, +IBUS_exclam, IBUS_D, 0x1E0C, +IBUS_exclam, IBUS_E, 0x1EB8, +IBUS_exclam, IBUS_H, 0x1E24, +IBUS_exclam, IBUS_I, 0x1ECA, +IBUS_exclam, IBUS_K, 0x1E32, +IBUS_exclam, IBUS_L, 0x1E36, +IBUS_exclam, IBUS_M, 0x1E42, +IBUS_exclam, IBUS_N, 0x1E46, +IBUS_exclam, IBUS_O, 0x1ECC, +IBUS_exclam, IBUS_P, 0x00B6, +IBUS_exclam, IBUS_R, 0x1E5A, +IBUS_exclam, IBUS_S, 0x1E62, +IBUS_exclam, IBUS_T, 0x1E6C, +IBUS_exclam, IBUS_U, 0x1EE4, +IBUS_exclam, IBUS_V, 0x1E7E, +IBUS_exclam, IBUS_W, 0x1E88, +IBUS_exclam, IBUS_Y, 0x1EF4, +IBUS_exclam, IBUS_Z, 0x1E92, +IBUS_exclam, IBUS_asciicircum, 0x00A6, +IBUS_exclam, IBUS_a, 0x1EA1, +IBUS_exclam, IBUS_b, 0x1E05, +IBUS_exclam, IBUS_d, 0x1E0D, +IBUS_exclam, IBUS_e, 0x1EB9, +IBUS_exclam, IBUS_h, 0x1E25, +IBUS_exclam, IBUS_i, 0x1ECB, +IBUS_exclam, IBUS_k, 0x1E33, +IBUS_exclam, IBUS_l, 0x1E37, +IBUS_exclam, IBUS_m, 0x1E43, +IBUS_exclam, IBUS_n, 0x1E47, +IBUS_exclam, IBUS_o, 0x1ECD, +IBUS_exclam, IBUS_p, 0x00B6, +IBUS_exclam, IBUS_r, 0x1E5B, +IBUS_exclam, IBUS_s, 0x1E63, +IBUS_exclam, IBUS_t, 0x1E6D, +IBUS_exclam, IBUS_u, 0x1EE5, +IBUS_exclam, IBUS_v, 0x1E7F, +IBUS_exclam, IBUS_w, 0x1E89, +IBUS_exclam, IBUS_y, 0x1EF5, +IBUS_exclam, IBUS_z, 0x1E93, +IBUS_quotedbl, IBUS_quotedbl, 0x00A8, +IBUS_quotedbl, IBUS_apostrophe, 0x0344, +IBUS_quotedbl, IBUS_comma, 0x201E, +IBUS_quotedbl, IBUS_slash, 0x301E, +IBUS_quotedbl, IBUS_less, 0x201C, +IBUS_quotedbl, IBUS_greater, 0x201D, +IBUS_quotedbl, IBUS_A, 0x00C4, +IBUS_quotedbl, IBUS_E, 0x00CB, +IBUS_quotedbl, IBUS_H, 0x1E26, +IBUS_quotedbl, IBUS_I, 0x00CF, +IBUS_quotedbl, IBUS_O, 0x00D6, +IBUS_quotedbl, IBUS_U, 0x00DC, +IBUS_quotedbl, IBUS_W, 0x1E84, +IBUS_quotedbl, IBUS_X, 0x1E8C, +IBUS_quotedbl, IBUS_Y, 0x0178, +IBUS_quotedbl, IBUS_backslash, 0x301D, +IBUS_quotedbl, IBUS_a, 0x00E4, +IBUS_quotedbl, IBUS_e, 0x00EB, +IBUS_quotedbl, IBUS_h, 0x1E27, +IBUS_quotedbl, IBUS_i, 0x00EF, +IBUS_quotedbl, IBUS_o, 0x00F6, +IBUS_quotedbl, IBUS_t, 0x1E97, +IBUS_quotedbl, IBUS_u, 0x00FC, +IBUS_quotedbl, IBUS_w, 0x1E85, +IBUS_quotedbl, IBUS_x, 0x1E8D, +IBUS_quotedbl, IBUS_y, 0x00FF, +IBUS_quotedbl, IBUS_acute, 0x0344, +IBUS_quotedbl, IBUS_Otilde, 0x1E4E, +IBUS_quotedbl, IBUS_otilde, 0x1E4F, +IBUS_quotedbl, 0x03D2, 0x03D4, +IBUS_quotedbl, IBUS_Umacron, 0x1E7A, +IBUS_quotedbl, IBUS_umacron, 0x1E7B, +IBUS_quotedbl, 0x04D8, 0x04DA, +IBUS_quotedbl, 0x04D9, 0x04DB, +IBUS_quotedbl, 0x04E8, 0x04EA, +IBUS_quotedbl, 0x04E9, 0x04EB, +IBUS_quotedbl, IBUS_Ukrainian_i, 0x0457, +IBUS_quotedbl, IBUS_Ukrainian_I, 0x0407, +IBUS_quotedbl, IBUS_Cyrillic_a, 0x04D3, +IBUS_quotedbl, IBUS_Cyrillic_ie, 0x0451, +IBUS_quotedbl, IBUS_Cyrillic_i, 0x04E5, +IBUS_quotedbl, IBUS_Cyrillic_o, 0x04E7, +IBUS_quotedbl, IBUS_Cyrillic_u, 0x04F1, +IBUS_quotedbl, IBUS_Cyrillic_zhe, 0x04DD, +IBUS_quotedbl, IBUS_Cyrillic_yeru, 0x04F9, +IBUS_quotedbl, IBUS_Cyrillic_ze, 0x04DF, +IBUS_quotedbl, IBUS_Cyrillic_e, 0x04ED, +IBUS_quotedbl, IBUS_Cyrillic_che, 0x04F5, +IBUS_quotedbl, IBUS_Cyrillic_A, 0x04D2, +IBUS_quotedbl, IBUS_Cyrillic_IE, 0x0401, +IBUS_quotedbl, IBUS_Cyrillic_I, 0x04E4, +IBUS_quotedbl, IBUS_Cyrillic_O, 0x04E6, +IBUS_quotedbl, IBUS_Cyrillic_U, 0x04F0, +IBUS_quotedbl, IBUS_Cyrillic_ZHE, 0x04DC, +IBUS_quotedbl, IBUS_Cyrillic_YERU, 0x04F8, +IBUS_quotedbl, IBUS_Cyrillic_ZE, 0x04DE, +IBUS_quotedbl, IBUS_Cyrillic_E, 0x04EC, +IBUS_quotedbl, IBUS_Cyrillic_CHE, 0x04F4, +IBUS_quotedbl, IBUS_Greek_IOTA, 0x03AA, +IBUS_quotedbl, IBUS_Greek_UPSILON, 0x03AB, +IBUS_quotedbl, IBUS_Greek_iota, 0x03CA, +IBUS_quotedbl, IBUS_Greek_upsilon, 0x03CB, +IBUS_quotedbl, IBUS_dead_acute, 0x0344, +IBUS_numbersign, IBUS_numbersign, 0x266F, +IBUS_numbersign, IBUS_b, 0x266D, +IBUS_numbersign, IBUS_f, 0x266E, +IBUS_percent, IBUS_o, 0x2030, +IBUS_apostrophe, IBUS_space, 0x0027, +IBUS_apostrophe, IBUS_apostrophe, 0x00B4, +IBUS_apostrophe, IBUS_comma, 0x201A, +IBUS_apostrophe, IBUS_less, 0x2018, +IBUS_apostrophe, IBUS_greater, 0x2019, +IBUS_apostrophe, IBUS_A, 0x00C1, +IBUS_apostrophe, IBUS_C, 0x0106, +IBUS_apostrophe, IBUS_E, 0x00C9, +IBUS_apostrophe, IBUS_G, 0x01F4, +IBUS_apostrophe, IBUS_I, 0x00CD, +IBUS_apostrophe, IBUS_K, 0x1E30, +IBUS_apostrophe, IBUS_L, 0x0139, +IBUS_apostrophe, IBUS_M, 0x1E3E, +IBUS_apostrophe, IBUS_N, 0x0143, +IBUS_apostrophe, IBUS_O, 0x00D3, +IBUS_apostrophe, IBUS_P, 0x1E54, +IBUS_apostrophe, IBUS_R, 0x0154, +IBUS_apostrophe, IBUS_S, 0x015A, +IBUS_apostrophe, IBUS_U, 0x00DA, +IBUS_apostrophe, IBUS_W, 0x1E82, +IBUS_apostrophe, IBUS_Y, 0x00DD, +IBUS_apostrophe, IBUS_Z, 0x0179, +IBUS_apostrophe, IBUS_a, 0x00E1, +IBUS_apostrophe, IBUS_c, 0x0107, +IBUS_apostrophe, IBUS_e, 0x00E9, +IBUS_apostrophe, IBUS_g, 0x01F5, +IBUS_apostrophe, IBUS_i, 0x00ED, +IBUS_apostrophe, IBUS_k, 0x1E31, +IBUS_apostrophe, IBUS_l, 0x013A, +IBUS_apostrophe, IBUS_m, 0x1E3F, +IBUS_apostrophe, IBUS_n, 0x0144, +IBUS_apostrophe, IBUS_o, 0x00F3, +IBUS_apostrophe, IBUS_p, 0x1E55, +IBUS_apostrophe, IBUS_r, 0x0155, +IBUS_apostrophe, IBUS_s, 0x015B, +IBUS_apostrophe, IBUS_u, 0x00FA, +IBUS_apostrophe, IBUS_w, 0x1E83, +IBUS_apostrophe, IBUS_y, 0x00FD, +IBUS_apostrophe, IBUS_z, 0x017A, +IBUS_apostrophe, IBUS_Acircumflex, 0x1EA4, +IBUS_apostrophe, IBUS_Aring, 0x01FA, +IBUS_apostrophe, IBUS_AE, 0x01FC, +IBUS_apostrophe, IBUS_Ccedilla, 0x1E08, +IBUS_apostrophe, IBUS_Ecircumflex, 0x1EBE, +IBUS_apostrophe, IBUS_Idiaeresis, 0x1E2E, +IBUS_apostrophe, IBUS_Ocircumflex, 0x1ED0, +IBUS_apostrophe, IBUS_Otilde, 0x1E4C, +IBUS_apostrophe, IBUS_Ooblique, 0x01FE, +IBUS_apostrophe, IBUS_Udiaeresis, 0x01D7, +IBUS_apostrophe, IBUS_acircumflex, 0x1EA5, +IBUS_apostrophe, IBUS_aring, 0x01FB, +IBUS_apostrophe, IBUS_ae, 0x01FD, +IBUS_apostrophe, IBUS_ccedilla, 0x1E09, +IBUS_apostrophe, IBUS_ecircumflex, 0x1EBF, +IBUS_apostrophe, IBUS_idiaeresis, 0x1E2F, +IBUS_apostrophe, IBUS_ocircumflex, 0x1ED1, +IBUS_apostrophe, IBUS_otilde, 0x1E4D, +IBUS_apostrophe, IBUS_oslash, 0x01FF, +IBUS_apostrophe, IBUS_udiaeresis, 0x01D8, +IBUS_apostrophe, IBUS_Abreve, 0x1EAE, +IBUS_apostrophe, IBUS_abreve, 0x1EAF, +IBUS_apostrophe, IBUS_Emacron, 0x1E16, +IBUS_apostrophe, IBUS_emacron, 0x1E17, +IBUS_apostrophe, IBUS_Omacron, 0x1E52, +IBUS_apostrophe, IBUS_Utilde, 0x1E78, +IBUS_apostrophe, IBUS_omacron, 0x1E53, +IBUS_apostrophe, IBUS_utilde, 0x1E79, +IBUS_apostrophe, IBUS_Cyrillic_ghe, 0x0453, +IBUS_apostrophe, IBUS_Cyrillic_ka, 0x045C, +IBUS_apostrophe, IBUS_Cyrillic_GHE, 0x0403, +IBUS_apostrophe, IBUS_Cyrillic_KA, 0x040C, +IBUS_apostrophe, IBUS_Greek_iotadieresis, 0x0390, +IBUS_apostrophe, IBUS_Greek_upsilondieresis, 0x03B0, +IBUS_apostrophe, IBUS_Greek_ALPHA, 0x0386, +IBUS_apostrophe, IBUS_Greek_EPSILON, 0x0388, +IBUS_apostrophe, IBUS_Greek_ETA, 0x0389, +IBUS_apostrophe, IBUS_Greek_IOTA, 0x038A, +IBUS_apostrophe, IBUS_Greek_OMICRON, 0x038C, +IBUS_apostrophe, IBUS_Greek_UPSILON, 0x038E, +IBUS_apostrophe, IBUS_Greek_OMEGA, 0x038F, +IBUS_apostrophe, IBUS_Greek_alpha, 0x03AC, +IBUS_apostrophe, IBUS_Greek_epsilon, 0x03AD, +IBUS_apostrophe, IBUS_Greek_eta, 0x03AE, +IBUS_apostrophe, IBUS_Greek_iota, 0x03AF, +IBUS_apostrophe, IBUS_Greek_omicron, 0x03CC, +IBUS_apostrophe, IBUS_Greek_upsilon, 0x03CD, +IBUS_apostrophe, IBUS_Greek_omega, 0x03CE, +IBUS_apostrophe, 0x1F00, 0x1F04, +IBUS_apostrophe, 0x1F01, 0x1F05, +IBUS_apostrophe, 0x1F08, 0x1F0C, +IBUS_apostrophe, 0x1F09, 0x1F0D, +IBUS_apostrophe, 0x1F10, 0x1F14, +IBUS_apostrophe, 0x1F11, 0x1F15, +IBUS_apostrophe, 0x1F18, 0x1F1C, +IBUS_apostrophe, 0x1F19, 0x1F1D, +IBUS_apostrophe, 0x1F20, 0x1F24, +IBUS_apostrophe, 0x1F21, 0x1F25, +IBUS_apostrophe, 0x1F28, 0x1F2C, +IBUS_apostrophe, 0x1F29, 0x1F2D, +IBUS_apostrophe, 0x1F30, 0x1F34, +IBUS_apostrophe, 0x1F31, 0x1F35, +IBUS_apostrophe, 0x1F38, 0x1F3C, +IBUS_apostrophe, 0x1F39, 0x1F3D, +IBUS_apostrophe, 0x1F40, 0x1F44, +IBUS_apostrophe, 0x1F41, 0x1F45, +IBUS_apostrophe, 0x1F48, 0x1F4C, +IBUS_apostrophe, 0x1F49, 0x1F4D, +IBUS_apostrophe, 0x1F50, 0x1F54, +IBUS_apostrophe, 0x1F51, 0x1F55, +IBUS_apostrophe, 0x1F59, 0x1F5D, +IBUS_apostrophe, 0x1F60, 0x1F64, +IBUS_apostrophe, 0x1F61, 0x1F65, +IBUS_apostrophe, 0x1F68, 0x1F6C, +IBUS_apostrophe, 0x1F69, 0x1F6D, +IBUS_parenleft, IBUS_space, 0x02D8, +IBUS_parenleft, IBUS_parenleft, 0x005B, +IBUS_parenleft, IBUS_minus, 0x007B, +IBUS_parenleft, IBUS_A, 0x0102, +IBUS_parenleft, IBUS_G, 0x011E, +IBUS_parenleft, IBUS_a, 0x0103, +IBUS_parenleft, IBUS_c, 0x00A9, +IBUS_parenleft, IBUS_g, 0x011F, +IBUS_parenleft, IBUS_r, 0x00AE, +IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F09, +IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F19, +IBUS_parenleft, IBUS_Greek_ETA, 0x1F29, +IBUS_parenleft, IBUS_Greek_IOTA, 0x1F39, +IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F49, +IBUS_parenleft, IBUS_Greek_RHO, 0x1FEC, +IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F59, +IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F69, +IBUS_parenleft, IBUS_Greek_alpha, 0x1F01, +IBUS_parenleft, IBUS_Greek_epsilon, 0x1F11, +IBUS_parenleft, IBUS_Greek_eta, 0x1F21, +IBUS_parenleft, IBUS_Greek_iota, 0x1F31, +IBUS_parenleft, IBUS_Greek_omicron, 0x1F41, +IBUS_parenleft, IBUS_Greek_rho, 0x1FE5, +IBUS_parenleft, IBUS_Greek_upsilon, 0x1F51, +IBUS_parenleft, IBUS_Greek_omega, 0x1F61, +IBUS_parenright, IBUS_parenright, 0x005D, +IBUS_parenright, IBUS_minus, 0x007D, +IBUS_parenright, IBUS_Greek_ALPHA, 0x1F08, +IBUS_parenright, IBUS_Greek_EPSILON, 0x1F18, +IBUS_parenright, IBUS_Greek_ETA, 0x1F28, +IBUS_parenright, IBUS_Greek_IOTA, 0x1F38, +IBUS_parenright, IBUS_Greek_OMICRON, 0x1F48, +IBUS_parenright, IBUS_Greek_OMEGA, 0x1F68, +IBUS_parenright, IBUS_Greek_alpha, 0x1F00, +IBUS_parenright, IBUS_Greek_epsilon, 0x1F10, +IBUS_parenright, IBUS_Greek_eta, 0x1F20, +IBUS_parenright, IBUS_Greek_iota, 0x1F30, +IBUS_parenright, IBUS_Greek_omicron, 0x1F40, +IBUS_parenright, IBUS_Greek_rho, 0x1FE4, +IBUS_parenright, IBUS_Greek_upsilon, 0x1F50, +IBUS_parenright, IBUS_Greek_omega, 0x1F60, +IBUS_asterisk, IBUS_0, 0x00B0, +IBUS_asterisk, IBUS_A, 0x00C5, +IBUS_asterisk, IBUS_U, 0x016E, +IBUS_asterisk, IBUS_a, 0x00E5, +IBUS_asterisk, IBUS_u, 0x016F, +IBUS_plus, IBUS_plus, 0x0023, +IBUS_plus, IBUS_minus, 0x00B1, +IBUS_plus, IBUS_O, 0x01A0, +IBUS_plus, IBUS_U, 0x01AF, +IBUS_plus, IBUS_o, 0x01A1, +IBUS_plus, IBUS_u, 0x01B0, +IBUS_comma, IBUS_space, 0x00B8, +IBUS_comma, IBUS_quotedbl, 0x201E, +IBUS_comma, IBUS_apostrophe, 0x201A, +IBUS_comma, IBUS_comma, 0x00B8, +IBUS_comma, IBUS_minus, 0x00AC, +IBUS_comma, IBUS_A, 0x0104, +IBUS_comma, IBUS_C, 0x00C7, +IBUS_comma, IBUS_D, 0x1E10, +IBUS_comma, IBUS_E, 0x0228, +IBUS_comma, IBUS_G, 0x0122, +IBUS_comma, IBUS_H, 0x1E28, +IBUS_comma, IBUS_I, 0x012E, +IBUS_comma, IBUS_K, 0x0136, +IBUS_comma, IBUS_L, 0x013B, +IBUS_comma, IBUS_N, 0x0145, +IBUS_comma, IBUS_R, 0x0156, +IBUS_comma, IBUS_S, 0x015E, +IBUS_comma, IBUS_T, 0x0162, +IBUS_comma, IBUS_U, 0x0172, +IBUS_comma, IBUS_a, 0x0105, +IBUS_comma, IBUS_c, 0x00E7, +IBUS_comma, IBUS_d, 0x1E11, +IBUS_comma, IBUS_e, 0x0229, +IBUS_comma, IBUS_g, 0x0123, +IBUS_comma, IBUS_h, 0x1E29, +IBUS_comma, IBUS_i, 0x012F, +IBUS_comma, IBUS_k, 0x0137, +IBUS_comma, IBUS_l, 0x013C, +IBUS_comma, IBUS_n, 0x0146, +IBUS_comma, IBUS_r, 0x0157, +IBUS_comma, IBUS_s, 0x015F, +IBUS_comma, IBUS_t, 0x0163, +IBUS_comma, IBUS_u, 0x0173, +IBUS_minus, IBUS_space, 0x007E, +IBUS_minus, IBUS_parenleft, 0x007B, +IBUS_minus, IBUS_parenright, 0x007D, +IBUS_minus, IBUS_plus, 0x00B1, +IBUS_minus, IBUS_comma, 0x00AC, +IBUS_minus, IBUS_colon, 0x00F7, +IBUS_minus, IBUS_greater, 0x2192, +IBUS_minus, IBUS_A, 0x00C3, +IBUS_minus, IBUS_D, 0x0110, +IBUS_minus, IBUS_E, 0x0112, +IBUS_minus, IBUS_I, 0x012A, +IBUS_minus, IBUS_L, 0x00A3, +IBUS_minus, IBUS_N, 0x00D1, +IBUS_minus, IBUS_O, 0x00D5, +IBUS_minus, IBUS_U, 0x016A, +IBUS_minus, IBUS_Y, 0x00A5, +IBUS_minus, IBUS_asciicircum, 0x00AF, +IBUS_minus, IBUS_a, 0x0101, +IBUS_minus, IBUS_d, 0x0111, +IBUS_minus, IBUS_e, 0x0113, +IBUS_minus, IBUS_i, 0x012B, +IBUS_minus, IBUS_l, 0x00A3, +IBUS_minus, IBUS_n, 0x00F1, +IBUS_minus, IBUS_o, 0x014D, +IBUS_minus, IBUS_u, 0x016B, +IBUS_minus, IBUS_y, 0x00A5, +IBUS_period, IBUS_minus, 0x00B7, +IBUS_period, IBUS_period, 0x2026, +IBUS_period, IBUS_less, 0x2039, +IBUS_period, IBUS_equal, 0x2022, +IBUS_period, IBUS_greater, 0x203A, +IBUS_period, IBUS_A, 0x0226, +IBUS_period, IBUS_B, 0x1E02, +IBUS_period, IBUS_C, 0x010A, +IBUS_period, IBUS_D, 0x1E0A, +IBUS_period, IBUS_E, 0x0116, +IBUS_period, IBUS_F, 0x1E1E, +IBUS_period, IBUS_G, 0x0120, +IBUS_period, IBUS_H, 0x1E22, +IBUS_period, IBUS_I, 0x0130, +IBUS_period, IBUS_M, 0x1E40, +IBUS_period, IBUS_N, 0x1E44, +IBUS_period, IBUS_O, 0x022E, +IBUS_period, IBUS_P, 0x1E56, +IBUS_period, IBUS_R, 0x1E58, +IBUS_period, IBUS_S, 0x1E60, +IBUS_period, IBUS_T, 0x1E6A, +IBUS_period, IBUS_W, 0x1E86, +IBUS_period, IBUS_X, 0x1E8A, +IBUS_period, IBUS_Y, 0x1E8E, +IBUS_period, IBUS_Z, 0x017B, +IBUS_period, IBUS_asciicircum, 0x00B7, +IBUS_period, IBUS_a, 0x0227, +IBUS_period, IBUS_b, 0x1E03, +IBUS_period, IBUS_c, 0x010B, +IBUS_period, IBUS_d, 0x1E0B, +IBUS_period, IBUS_e, 0x0117, +IBUS_period, IBUS_f, 0x1E1F, +IBUS_period, IBUS_g, 0x0121, +IBUS_period, IBUS_h, 0x1E23, +IBUS_period, IBUS_i, 0x0131, +IBUS_period, IBUS_m, 0x1E41, +IBUS_period, IBUS_n, 0x1E45, +IBUS_period, IBUS_o, 0x022F, +IBUS_period, IBUS_p, 0x1E57, +IBUS_period, IBUS_r, 0x1E59, +IBUS_period, IBUS_s, 0x1E61, +IBUS_period, IBUS_t, 0x1E6B, +IBUS_period, IBUS_w, 0x1E87, +IBUS_period, IBUS_x, 0x1E8B, +IBUS_period, IBUS_y, 0x1E8F, +IBUS_period, IBUS_z, 0x017C, +IBUS_period, 0x017F, 0x1E9B, +IBUS_period, IBUS_Sacute, 0x1E64, +IBUS_period, IBUS_Scaron, 0x1E66, +IBUS_period, IBUS_sacute, 0x1E65, +IBUS_period, IBUS_scaron, 0x1E67, +IBUS_period, 0x1E62, 0x1E68, +IBUS_period, 0x1E63, 0x1E69, +IBUS_slash, IBUS_slash, 0x005C, +IBUS_slash, IBUS_less, 0x005C, +IBUS_slash, IBUS_equal, 0x2260, +IBUS_slash, IBUS_C, 0x20A1, +IBUS_slash, IBUS_D, 0x0110, +IBUS_slash, IBUS_G, 0x01E4, +IBUS_slash, IBUS_H, 0x0126, +IBUS_slash, IBUS_I, 0x0197, +IBUS_slash, IBUS_L, 0x0141, +IBUS_slash, IBUS_O, 0x00D8, +IBUS_slash, IBUS_T, 0x0166, +IBUS_slash, IBUS_U, 0x00B5, +IBUS_slash, IBUS_Z, 0x01B5, +IBUS_slash, IBUS_asciicircum, 0x007C, +IBUS_slash, IBUS_b, 0x0180, +IBUS_slash, IBUS_c, 0x00A2, +IBUS_slash, IBUS_d, 0x0111, +IBUS_slash, IBUS_g, 0x01E5, +IBUS_slash, IBUS_h, 0x0127, +IBUS_slash, IBUS_i, 0x0268, +IBUS_slash, IBUS_l, 0x0142, +IBUS_slash, IBUS_m, 0x20A5, +IBUS_slash, IBUS_o, 0x00F8, +IBUS_slash, IBUS_t, 0x0167, +IBUS_slash, IBUS_u, 0x00B5, +IBUS_slash, IBUS_z, 0x01B6, +IBUS_slash, 0x0294, 0x02A1, +IBUS_slash, 0x04AE, 0x04B0, +IBUS_slash, 0x04AF, 0x04B1, +IBUS_slash, IBUS_Cyrillic_ghe, 0x0493, +IBUS_slash, IBUS_Cyrillic_ka, 0x049F, +IBUS_slash, IBUS_Cyrillic_GHE, 0x0492, +IBUS_slash, IBUS_Cyrillic_KA, 0x049E, +IBUS_slash, IBUS_leftarrow, 0x219A, +IBUS_slash, IBUS_rightarrow, 0x219B, +IBUS_slash, 0x2194, 0x21AE, +IBUS_0, IBUS_asterisk, 0x00B0, +IBUS_0, IBUS_C, 0x00A9, +IBUS_0, IBUS_S, 0x00A7, +IBUS_0, IBUS_X, 0x00A4, +IBUS_0, IBUS_asciicircum, 0x00B0, +IBUS_0, IBUS_c, 0x00A9, +IBUS_0, IBUS_s, 0x00A7, +IBUS_0, IBUS_x, 0x00A4, +IBUS_1, IBUS_2, 0x00BD, +IBUS_1, IBUS_3, 0x2153, +IBUS_1, IBUS_4, 0x00BC, +IBUS_1, IBUS_5, 0x2155, +IBUS_1, IBUS_6, 0x2159, +IBUS_1, IBUS_8, 0x215B, +IBUS_1, IBUS_S, 0x00B9, +IBUS_1, IBUS_asciicircum, 0x00B9, +IBUS_1, IBUS_s, 0x00B9, +IBUS_2, IBUS_3, 0x2154, +IBUS_2, IBUS_5, 0x2156, +IBUS_2, IBUS_S, 0x00B2, +IBUS_2, IBUS_asciicircum, 0x00B2, +IBUS_2, IBUS_s, 0x00B2, +IBUS_3, IBUS_4, 0x00BE, +IBUS_3, IBUS_5, 0x2157, +IBUS_3, IBUS_8, 0x215C, +IBUS_3, IBUS_S, 0x00B3, +IBUS_3, IBUS_asciicircum, 0x00B3, +IBUS_3, IBUS_s, 0x00B3, +IBUS_4, IBUS_5, 0x2158, +IBUS_5, IBUS_6, 0x215A, +IBUS_5, IBUS_8, 0x215D, +IBUS_7, IBUS_8, 0x215E, +IBUS_colon, IBUS_parenleft, 0x2639, +IBUS_colon, IBUS_parenright, 0x263A, +IBUS_colon, IBUS_minus, 0x00F7, +IBUS_semicolon, IBUS_A, 0x0104, +IBUS_semicolon, IBUS_E, 0x0118, +IBUS_semicolon, IBUS_I, 0x012E, +IBUS_semicolon, IBUS_O, 0x01EA, +IBUS_semicolon, IBUS_U, 0x0172, +IBUS_semicolon, IBUS_a, 0x0105, +IBUS_semicolon, IBUS_e, 0x0119, +IBUS_semicolon, IBUS_i, 0x012F, +IBUS_semicolon, IBUS_o, 0x01EB, +IBUS_semicolon, IBUS_u, 0x0173, +IBUS_less, IBUS_space, 0x02C7, +IBUS_less, IBUS_quotedbl, 0x201C, +IBUS_less, IBUS_apostrophe, 0x2018, +IBUS_less, IBUS_minus, 0x2190, +IBUS_less, IBUS_slash, 0x005C, +IBUS_less, IBUS_3, 0x2665, +IBUS_less, IBUS_less, 0x00AB, +IBUS_less, IBUS_equal, 0x2264, +IBUS_less, IBUS_C, 0x010C, +IBUS_less, IBUS_D, 0x010E, +IBUS_less, IBUS_E, 0x011A, +IBUS_less, IBUS_L, 0x013D, +IBUS_less, IBUS_N, 0x0147, +IBUS_less, IBUS_R, 0x0158, +IBUS_less, IBUS_S, 0x0160, +IBUS_less, IBUS_T, 0x0164, +IBUS_less, IBUS_Z, 0x017D, +IBUS_less, IBUS_c, 0x010D, +IBUS_less, IBUS_d, 0x010F, +IBUS_less, IBUS_e, 0x011B, +IBUS_less, IBUS_l, 0x013E, +IBUS_less, IBUS_n, 0x0148, +IBUS_less, IBUS_r, 0x0159, +IBUS_less, IBUS_s, 0x0161, +IBUS_less, IBUS_t, 0x0165, +IBUS_less, IBUS_z, 0x017E, +IBUS_less, 0x0338, 0x226E, +IBUS_equal, IBUS_slash, 0x2260, +IBUS_equal, IBUS_C, 0x20AC, +IBUS_equal, IBUS_E, 0x20AC, +IBUS_equal, IBUS_L, 0x20A4, +IBUS_equal, IBUS_N, 0x20A6, +IBUS_equal, IBUS_O, 0x0150, +IBUS_equal, IBUS_U, 0x0170, +IBUS_equal, IBUS_W, 0x20A9, +IBUS_equal, IBUS_Y, 0x00A5, +IBUS_equal, IBUS_c, 0x20AC, +IBUS_equal, IBUS_e, 0x20AC, +IBUS_equal, IBUS_l, 0x00A3, +IBUS_equal, IBUS_o, 0x0151, +IBUS_equal, IBUS_u, 0x0171, +IBUS_equal, IBUS_y, 0x00A5, +IBUS_equal, 0x0338, 0x2260, +IBUS_equal, IBUS_Cyrillic_u, 0x04F3, +IBUS_equal, IBUS_Cyrillic_IE, 0x20AC, +IBUS_equal, IBUS_Cyrillic_ES, 0x20AC, +IBUS_equal, IBUS_Cyrillic_U, 0x04F2, +IBUS_greater, IBUS_space, 0x005E, +IBUS_greater, IBUS_quotedbl, 0x201D, +IBUS_greater, IBUS_apostrophe, 0x2019, +IBUS_greater, IBUS_equal, 0x2265, +IBUS_greater, IBUS_greater, 0x00BB, +IBUS_greater, IBUS_A, 0x00C2, +IBUS_greater, IBUS_E, 0x00CA, +IBUS_greater, IBUS_I, 0x00CE, +IBUS_greater, IBUS_O, 0x00D4, +IBUS_greater, IBUS_U, 0x00DB, +IBUS_greater, IBUS_a, 0x00E2, +IBUS_greater, IBUS_e, 0x00EA, +IBUS_greater, IBUS_i, 0x00EE, +IBUS_greater, IBUS_o, 0x00F4, +IBUS_greater, IBUS_u, 0x00FB, +IBUS_greater, 0x0338, 0x226F, +IBUS_question, IBUS_exclam, 0x203D, +IBUS_question, IBUS_question, 0x00BF, +IBUS_question, IBUS_A, 0x1EA2, +IBUS_question, IBUS_E, 0x1EBA, +IBUS_question, IBUS_I, 0x1EC8, +IBUS_question, IBUS_O, 0x1ECE, +IBUS_question, IBUS_U, 0x1EE6, +IBUS_question, IBUS_Y, 0x1EF6, +IBUS_question, IBUS_a, 0x1EA3, +IBUS_question, IBUS_e, 0x1EBB, +IBUS_question, IBUS_i, 0x1EC9, +IBUS_question, IBUS_o, 0x1ECF, +IBUS_question, IBUS_u, 0x1EE7, +IBUS_question, IBUS_y, 0x1EF7, +IBUS_question, IBUS_Acircumflex, 0x1EA8, +IBUS_question, IBUS_Ecircumflex, 0x1EC2, +IBUS_question, IBUS_Ocircumflex, 0x1ED4, +IBUS_question, IBUS_acircumflex, 0x1EA9, +IBUS_question, IBUS_ecircumflex, 0x1EC3, +IBUS_question, IBUS_ocircumflex, 0x1ED5, +IBUS_question, IBUS_Abreve, 0x1EB2, +IBUS_question, IBUS_abreve, 0x1EB3, +IBUS_A, IBUS_quotedbl, 0x00C4, +IBUS_A, IBUS_apostrophe, 0x00C1, +IBUS_A, IBUS_parenleft, 0x0102, +IBUS_A, IBUS_asterisk, 0x00C5, +IBUS_A, IBUS_comma, 0x0104, +IBUS_A, IBUS_minus, 0x00C3, +IBUS_A, IBUS_greater, 0x00C2, +IBUS_A, IBUS_A, 0x00C5, +IBUS_A, IBUS_E, 0x00C6, +IBUS_A, IBUS_T, 0x0040, +IBUS_A, IBUS_asciicircum, 0x00C2, +IBUS_A, IBUS_underscore, 0x00AA, +IBUS_A, IBUS_grave, 0x00C0, +IBUS_A, IBUS_asciitilde, 0x00C3, +IBUS_A, IBUS_diaeresis, 0x00C4, +IBUS_A, IBUS_acute, 0x00C1, +IBUS_B, IBUS_period, 0x1E02, +IBUS_C, IBUS_apostrophe, 0x0106, +IBUS_C, IBUS_comma, 0x00C7, +IBUS_C, IBUS_period, 0x010A, +IBUS_C, IBUS_slash, 0x20A1, +IBUS_C, IBUS_0, 0x00A9, +IBUS_C, IBUS_less, 0x010C, +IBUS_C, IBUS_equal, 0x20AC, +IBUS_C, IBUS_E, 0x20A0, +IBUS_C, IBUS_O, 0x00A9, +IBUS_C, IBUS_o, 0x00A9, +IBUS_C, IBUS_r, 0x20A2, +IBUS_C, IBUS_bar, 0x00A2, +IBUS_D, IBUS_minus, 0x0110, +IBUS_D, IBUS_period, 0x1E0A, +IBUS_D, IBUS_less, 0x010E, +IBUS_D, IBUS_H, 0x00D0, +IBUS_E, IBUS_quotedbl, 0x00CB, +IBUS_E, IBUS_apostrophe, 0x00C9, +IBUS_E, IBUS_comma, 0x0118, +IBUS_E, IBUS_minus, 0x0112, +IBUS_E, IBUS_period, 0x0116, +IBUS_E, IBUS_less, 0x011A, +IBUS_E, IBUS_equal, 0x20AC, +IBUS_E, IBUS_greater, 0x00CA, +IBUS_E, IBUS_asciicircum, 0x00CA, +IBUS_E, IBUS_underscore, 0x0112, +IBUS_E, IBUS_grave, 0x00C8, +IBUS_E, IBUS_diaeresis, 0x00CB, +IBUS_E, IBUS_acute, 0x00C9, +IBUS_F, IBUS_period, 0x1E1E, +IBUS_F, IBUS_r, 0x20A3, +IBUS_G, IBUS_parenleft, 0x011E, +IBUS_G, IBUS_comma, 0x0122, +IBUS_G, IBUS_period, 0x0120, +IBUS_G, IBUS_U, 0x011E, +IBUS_G, IBUS_breve, 0x011E, +IBUS_I, IBUS_quotedbl, 0x00CF, +IBUS_I, IBUS_apostrophe, 0x00CD, +IBUS_I, IBUS_comma, 0x012E, +IBUS_I, IBUS_minus, 0x012A, +IBUS_I, IBUS_period, 0x0130, +IBUS_I, IBUS_greater, 0x00CE, +IBUS_I, IBUS_asciicircum, 0x00CE, +IBUS_I, IBUS_underscore, 0x012A, +IBUS_I, IBUS_grave, 0x00CC, +IBUS_I, IBUS_asciitilde, 0x0128, +IBUS_I, IBUS_diaeresis, 0x00CF, +IBUS_I, IBUS_acute, 0x00CD, +IBUS_K, IBUS_comma, 0x0136, +IBUS_L, IBUS_apostrophe, 0x0139, +IBUS_L, IBUS_comma, 0x013B, +IBUS_L, IBUS_minus, 0x00A3, +IBUS_L, IBUS_slash, 0x0141, +IBUS_L, IBUS_less, 0x013D, +IBUS_L, IBUS_equal, 0x00A3, +IBUS_L, IBUS_V, 0x007C, +IBUS_M, IBUS_period, 0x1E40, +IBUS_N, IBUS_apostrophe, 0x0143, +IBUS_N, IBUS_comma, 0x0145, +IBUS_N, IBUS_minus, 0x00D1, +IBUS_N, IBUS_less, 0x0147, +IBUS_N, IBUS_equal, 0x20A6, +IBUS_N, IBUS_G, 0x014A, +IBUS_N, IBUS_O, 0x2116, +IBUS_N, IBUS_o, 0x2116, +IBUS_N, IBUS_asciitilde, 0x00D1, +IBUS_O, IBUS_quotedbl, 0x00D6, +IBUS_O, IBUS_apostrophe, 0x00D3, +IBUS_O, IBUS_minus, 0x00D5, +IBUS_O, IBUS_slash, 0x00D8, +IBUS_O, IBUS_greater, 0x00D4, +IBUS_O, IBUS_C, 0x00A9, +IBUS_O, IBUS_E, 0x0152, +IBUS_O, IBUS_R, 0x00AE, +IBUS_O, IBUS_S, 0x00A7, +IBUS_O, IBUS_X, 0x00A4, +IBUS_O, IBUS_asciicircum, 0x00D4, +IBUS_O, IBUS_underscore, 0x00BA, +IBUS_O, IBUS_grave, 0x00D2, +IBUS_O, IBUS_c, 0x00A9, +IBUS_O, IBUS_r, 0x00AE, +IBUS_O, IBUS_x, 0x00A4, +IBUS_O, IBUS_asciitilde, 0x00D5, +IBUS_O, IBUS_diaeresis, 0x00D6, +IBUS_O, IBUS_acute, 0x00D3, +IBUS_P, IBUS_exclam, 0x00B6, +IBUS_P, IBUS_period, 0x1E56, +IBUS_P, IBUS_P, 0x00B6, +IBUS_P, IBUS_t, 0x20A7, +IBUS_R, IBUS_apostrophe, 0x0154, +IBUS_R, IBUS_comma, 0x0156, +IBUS_R, IBUS_less, 0x0158, +IBUS_R, IBUS_O, 0x00AE, +IBUS_R, IBUS_s, 0x20A8, +IBUS_S, IBUS_exclam, 0x00A7, +IBUS_S, IBUS_apostrophe, 0x015A, +IBUS_S, IBUS_comma, 0x015E, +IBUS_S, IBUS_period, 0x1E60, +IBUS_S, IBUS_0, 0x00A7, +IBUS_S, IBUS_1, 0x00B9, +IBUS_S, IBUS_2, 0x00B2, +IBUS_S, IBUS_3, 0x00B3, +IBUS_S, IBUS_less, 0x0160, +IBUS_S, IBUS_M, 0x2120, +IBUS_S, IBUS_O, 0x00A7, +IBUS_S, IBUS_m, 0x2120, +IBUS_S, IBUS_cedilla, 0x015E, +IBUS_T, IBUS_minus, 0x0166, +IBUS_T, IBUS_period, 0x1E6A, +IBUS_T, IBUS_slash, 0x0166, +IBUS_T, IBUS_less, 0x0164, +IBUS_T, IBUS_H, 0x00DE, +IBUS_T, IBUS_M, 0x2122, +IBUS_T, IBUS_m, 0x2122, +IBUS_U, IBUS_quotedbl, 0x00DC, +IBUS_U, IBUS_apostrophe, 0x00DA, +IBUS_U, IBUS_asterisk, 0x016E, +IBUS_U, IBUS_comma, 0x0172, +IBUS_U, IBUS_minus, 0x016A, +IBUS_U, IBUS_slash, 0x00B5, +IBUS_U, IBUS_greater, 0x00DB, +IBUS_U, IBUS_A, 0x0102, +IBUS_U, IBUS_E, 0x0114, +IBUS_U, IBUS_G, 0x011E, +IBUS_U, IBUS_I, 0x012C, +IBUS_U, IBUS_O, 0x014E, +IBUS_U, IBUS_U, 0x016C, +IBUS_U, IBUS_asciicircum, 0x00DB, +IBUS_U, IBUS_underscore, 0x016A, +IBUS_U, IBUS_grave, 0x00D9, +IBUS_U, IBUS_a, 0x0103, +IBUS_U, IBUS_e, 0x0115, +IBUS_U, IBUS_g, 0x011F, +IBUS_U, IBUS_i, 0x012D, +IBUS_U, IBUS_o, 0x014F, +IBUS_U, IBUS_u, 0x016D, +IBUS_U, IBUS_asciitilde, 0x0168, +IBUS_U, IBUS_diaeresis, 0x00DC, +IBUS_U, IBUS_acute, 0x00DA, +IBUS_U, 0x0228, 0x1E1C, +IBUS_U, 0x0229, 0x1E1D, +IBUS_U, IBUS_Cyrillic_a, 0x04D1, +IBUS_U, IBUS_Cyrillic_ie, 0x04D7, +IBUS_U, IBUS_Cyrillic_i, 0x0439, +IBUS_U, IBUS_Cyrillic_u, 0x045E, +IBUS_U, IBUS_Cyrillic_zhe, 0x04C2, +IBUS_U, IBUS_Cyrillic_A, 0x04D0, +IBUS_U, IBUS_Cyrillic_IE, 0x04D6, +IBUS_U, IBUS_Cyrillic_I, 0x0419, +IBUS_U, IBUS_Cyrillic_U, 0x040E, +IBUS_U, IBUS_Cyrillic_ZHE, 0x04C1, +IBUS_U, IBUS_Greek_ALPHA, 0x1FB8, +IBUS_U, IBUS_Greek_IOTA, 0x1FD8, +IBUS_U, IBUS_Greek_UPSILON, 0x1FE8, +IBUS_U, IBUS_Greek_alpha, 0x1FB0, +IBUS_U, IBUS_Greek_iota, 0x1FD0, +IBUS_U, IBUS_Greek_upsilon, 0x1FE0, +IBUS_U, 0x1EA0, 0x1EB6, +IBUS_U, 0x1EA1, 0x1EB7, +IBUS_V, IBUS_L, 0x007C, +IBUS_W, IBUS_equal, 0x20A9, +IBUS_W, IBUS_asciicircum, 0x0174, +IBUS_X, IBUS_0, 0x00A4, +IBUS_X, IBUS_O, 0x00A4, +IBUS_X, IBUS_o, 0x00A4, +IBUS_Y, IBUS_quotedbl, 0x0178, +IBUS_Y, IBUS_apostrophe, 0x00DD, +IBUS_Y, IBUS_minus, 0x00A5, +IBUS_Y, IBUS_equal, 0x00A5, +IBUS_Y, IBUS_asciicircum, 0x0176, +IBUS_Y, IBUS_diaeresis, 0x0178, +IBUS_Y, IBUS_acute, 0x00DD, +IBUS_Z, IBUS_apostrophe, 0x0179, +IBUS_Z, IBUS_period, 0x017B, +IBUS_Z, IBUS_less, 0x017D, +IBUS_asciicircum, IBUS_space, 0x005E, +IBUS_asciicircum, IBUS_parenleft, 0x207D, +IBUS_asciicircum, IBUS_parenright, 0x207E, +IBUS_asciicircum, IBUS_plus, 0x207A, +IBUS_asciicircum, IBUS_minus, 0x00AF, +IBUS_asciicircum, IBUS_period, 0x00B7, +IBUS_asciicircum, IBUS_slash, 0x007C, +IBUS_asciicircum, IBUS_0, 0x2070, +IBUS_asciicircum, IBUS_1, 0x00B9, +IBUS_asciicircum, IBUS_2, 0x00B2, +IBUS_asciicircum, IBUS_3, 0x00B3, +IBUS_asciicircum, IBUS_4, 0x2074, +IBUS_asciicircum, IBUS_5, 0x2075, +IBUS_asciicircum, IBUS_6, 0x2076, +IBUS_asciicircum, IBUS_7, 0x2077, +IBUS_asciicircum, IBUS_8, 0x2078, +IBUS_asciicircum, IBUS_9, 0x2079, +IBUS_asciicircum, IBUS_equal, 0x207C, +IBUS_asciicircum, IBUS_A, 0x00C2, +IBUS_asciicircum, IBUS_C, 0x0108, +IBUS_asciicircum, IBUS_E, 0x00CA, +IBUS_asciicircum, IBUS_G, 0x011C, +IBUS_asciicircum, IBUS_H, 0x0124, +IBUS_asciicircum, IBUS_I, 0x00CE, +IBUS_asciicircum, IBUS_J, 0x0134, +IBUS_asciicircum, IBUS_O, 0x00D4, +IBUS_asciicircum, IBUS_S, 0x015C, +IBUS_asciicircum, IBUS_U, 0x00DB, +IBUS_asciicircum, IBUS_W, 0x0174, +IBUS_asciicircum, IBUS_Y, 0x0176, +IBUS_asciicircum, IBUS_Z, 0x1E90, +IBUS_asciicircum, IBUS_underscore, 0x00AF, +IBUS_asciicircum, IBUS_a, 0x00E2, +IBUS_asciicircum, IBUS_c, 0x0109, +IBUS_asciicircum, IBUS_e, 0x00EA, +IBUS_asciicircum, IBUS_g, 0x011D, +IBUS_asciicircum, IBUS_h, 0x0125, +IBUS_asciicircum, IBUS_i, 0x00EE, +IBUS_asciicircum, IBUS_j, 0x0135, +IBUS_asciicircum, IBUS_o, 0x00F4, +IBUS_asciicircum, IBUS_s, 0x015D, +IBUS_asciicircum, IBUS_u, 0x00FB, +IBUS_asciicircum, IBUS_w, 0x0175, +IBUS_asciicircum, IBUS_y, 0x0177, +IBUS_asciicircum, IBUS_z, 0x1E91, +IBUS_asciicircum, 0x1EA0, 0x1EAC, +IBUS_asciicircum, 0x1EA1, 0x1EAD, +IBUS_asciicircum, 0x1EB8, 0x1EC6, +IBUS_asciicircum, 0x1EB9, 0x1EC7, +IBUS_asciicircum, 0x1ECC, 0x1ED8, +IBUS_asciicircum, 0x1ECD, 0x1ED9, +IBUS_asciicircum, 0x2212, 0x207B, +IBUS_asciicircum, 0x4E00, 0x3192, +IBUS_asciicircum, 0x4E01, 0x319C, +IBUS_asciicircum, 0x4E09, 0x3194, +IBUS_asciicircum, 0x4E0A, 0x3196, +IBUS_asciicircum, 0x4E0B, 0x3198, +IBUS_asciicircum, 0x4E19, 0x319B, +IBUS_asciicircum, 0x4E2D, 0x3197, +IBUS_asciicircum, 0x4E59, 0x319A, +IBUS_asciicircum, 0x4E8C, 0x3193, +IBUS_asciicircum, 0x4EBA, 0x319F, +IBUS_asciicircum, 0x56DB, 0x3195, +IBUS_asciicircum, 0x5730, 0x319E, +IBUS_asciicircum, 0x5929, 0x319D, +IBUS_asciicircum, 0x7532, 0x3199, +IBUS_asciicircum, IBUS_KP_Space, 0x00B2, +IBUS_asciicircum, IBUS_KP_Add, 0x207A, +IBUS_asciicircum, IBUS_KP_0, 0x2070, +IBUS_asciicircum, IBUS_KP_1, 0x00B9, +IBUS_asciicircum, IBUS_KP_2, 0x00B2, +IBUS_asciicircum, IBUS_KP_3, 0x00B3, +IBUS_asciicircum, IBUS_KP_4, 0x2074, +IBUS_asciicircum, IBUS_KP_5, 0x2075, +IBUS_asciicircum, IBUS_KP_6, 0x2076, +IBUS_asciicircum, IBUS_KP_7, 0x2077, +IBUS_asciicircum, IBUS_KP_8, 0x2078, +IBUS_asciicircum, IBUS_KP_9, 0x2079, +IBUS_asciicircum, IBUS_KP_Equal, 0x207C, +IBUS_underscore, IBUS_parenleft, 0x208D, +IBUS_underscore, IBUS_parenright, 0x208E, +IBUS_underscore, IBUS_plus, 0x208A, +IBUS_underscore, IBUS_0, 0x2080, +IBUS_underscore, IBUS_1, 0x2081, +IBUS_underscore, IBUS_2, 0x2082, +IBUS_underscore, IBUS_3, 0x2083, +IBUS_underscore, IBUS_4, 0x2084, +IBUS_underscore, IBUS_5, 0x2085, +IBUS_underscore, IBUS_6, 0x2086, +IBUS_underscore, IBUS_7, 0x2087, +IBUS_underscore, IBUS_8, 0x2088, +IBUS_underscore, IBUS_9, 0x2089, +IBUS_underscore, IBUS_equal, 0x208C, +IBUS_underscore, IBUS_A, 0x0100, +IBUS_underscore, IBUS_E, 0x0112, +IBUS_underscore, IBUS_G, 0x1E20, +IBUS_underscore, IBUS_I, 0x012A, +IBUS_underscore, IBUS_O, 0x014C, +IBUS_underscore, IBUS_U, 0x016A, +IBUS_underscore, IBUS_Y, 0x0232, +IBUS_underscore, IBUS_asciicircum, 0x00AF, +IBUS_underscore, IBUS_underscore, 0x00AF, +IBUS_underscore, IBUS_a, 0x0101, +IBUS_underscore, IBUS_e, 0x0113, +IBUS_underscore, IBUS_g, 0x1E21, +IBUS_underscore, IBUS_i, 0x012B, +IBUS_underscore, IBUS_o, 0x014D, +IBUS_underscore, IBUS_u, 0x016B, +IBUS_underscore, IBUS_y, 0x0233, +IBUS_underscore, IBUS_Adiaeresis, 0x01DE, +IBUS_underscore, IBUS_AE, 0x01E2, +IBUS_underscore, IBUS_Otilde, 0x022C, +IBUS_underscore, IBUS_Odiaeresis, 0x022A, +IBUS_underscore, IBUS_Udiaeresis, 0x01D5, +IBUS_underscore, IBUS_adiaeresis, 0x01DF, +IBUS_underscore, IBUS_ae, 0x01E3, +IBUS_underscore, IBUS_otilde, 0x022D, +IBUS_underscore, IBUS_odiaeresis, 0x022B, +IBUS_underscore, IBUS_udiaeresis, 0x01D6, +IBUS_underscore, 0x01EA, 0x01EC, +IBUS_underscore, 0x01EB, 0x01ED, +IBUS_underscore, 0x0226, 0x01E0, +IBUS_underscore, 0x0227, 0x01E1, +IBUS_underscore, 0x022E, 0x0230, +IBUS_underscore, 0x022F, 0x0231, +IBUS_underscore, IBUS_Cyrillic_i, 0x04E3, +IBUS_underscore, IBUS_Cyrillic_u, 0x04EF, +IBUS_underscore, IBUS_Cyrillic_I, 0x04E2, +IBUS_underscore, IBUS_Cyrillic_U, 0x04EE, +IBUS_underscore, IBUS_Greek_ALPHA, 0x1FB9, +IBUS_underscore, IBUS_Greek_IOTA, 0x1FD9, +IBUS_underscore, IBUS_Greek_UPSILON, 0x1FE9, +IBUS_underscore, IBUS_Greek_alpha, 0x1FB1, +IBUS_underscore, IBUS_Greek_iota, 0x1FD1, +IBUS_underscore, IBUS_Greek_upsilon, 0x1FE1, +IBUS_underscore, 0x1E36, 0x1E38, +IBUS_underscore, 0x1E37, 0x1E39, +IBUS_underscore, 0x1E5A, 0x1E5C, +IBUS_underscore, 0x1E5B, 0x1E5D, +IBUS_underscore, 0x2212, 0x208B, +IBUS_underscore, IBUS_KP_Space, 0x2082, +IBUS_underscore, IBUS_KP_Add, 0x208A, +IBUS_underscore, IBUS_KP_0, 0x2080, +IBUS_underscore, IBUS_KP_1, 0x2081, +IBUS_underscore, IBUS_KP_2, 0x2082, +IBUS_underscore, IBUS_KP_3, 0x2083, +IBUS_underscore, IBUS_KP_4, 0x2084, +IBUS_underscore, IBUS_KP_5, 0x2085, +IBUS_underscore, IBUS_KP_6, 0x2086, +IBUS_underscore, IBUS_KP_7, 0x2087, +IBUS_underscore, IBUS_KP_8, 0x2088, +IBUS_underscore, IBUS_KP_9, 0x2089, +IBUS_underscore, IBUS_KP_Equal, 0x208C, +IBUS_grave, IBUS_space, 0x0060, +IBUS_grave, IBUS_A, 0x00C0, +IBUS_grave, IBUS_E, 0x00C8, +IBUS_grave, IBUS_I, 0x00CC, +IBUS_grave, IBUS_N, 0x01F8, +IBUS_grave, IBUS_O, 0x00D2, +IBUS_grave, IBUS_U, 0x00D9, +IBUS_grave, IBUS_W, 0x1E80, +IBUS_grave, IBUS_Y, 0x1EF2, +IBUS_grave, IBUS_a, 0x00E0, +IBUS_grave, IBUS_e, 0x00E8, +IBUS_grave, IBUS_i, 0x00EC, +IBUS_grave, IBUS_n, 0x01F9, +IBUS_grave, IBUS_o, 0x00F2, +IBUS_grave, IBUS_u, 0x00F9, +IBUS_grave, IBUS_w, 0x1E81, +IBUS_grave, IBUS_y, 0x1EF3, +IBUS_grave, IBUS_Acircumflex, 0x1EA6, +IBUS_grave, IBUS_Ecircumflex, 0x1EC0, +IBUS_grave, IBUS_Ocircumflex, 0x1ED2, +IBUS_grave, IBUS_Udiaeresis, 0x01DB, +IBUS_grave, IBUS_acircumflex, 0x1EA7, +IBUS_grave, IBUS_ecircumflex, 0x1EC1, +IBUS_grave, IBUS_ocircumflex, 0x1ED3, +IBUS_grave, IBUS_udiaeresis, 0x01DC, +IBUS_grave, IBUS_Abreve, 0x1EB0, +IBUS_grave, IBUS_abreve, 0x1EB1, +IBUS_grave, IBUS_Emacron, 0x1E14, +IBUS_grave, IBUS_emacron, 0x1E15, +IBUS_grave, IBUS_Omacron, 0x1E50, +IBUS_grave, IBUS_omacron, 0x1E51, +IBUS_grave, IBUS_Cyrillic_ie, 0x0450, +IBUS_grave, IBUS_Cyrillic_i, 0x045D, +IBUS_grave, IBUS_Cyrillic_IE, 0x0400, +IBUS_grave, IBUS_Cyrillic_I, 0x040D, +IBUS_grave, IBUS_Greek_iotadieresis, 0x1FD2, +IBUS_grave, IBUS_Greek_upsilondieresis, 0x1FE2, +IBUS_grave, IBUS_Greek_ALPHA, 0x1FBA, +IBUS_grave, IBUS_Greek_EPSILON, 0x1FC8, +IBUS_grave, IBUS_Greek_ETA, 0x1FCA, +IBUS_grave, IBUS_Greek_IOTA, 0x1FDA, +IBUS_grave, IBUS_Greek_OMICRON, 0x1FF8, +IBUS_grave, IBUS_Greek_UPSILON, 0x1FEA, +IBUS_grave, IBUS_Greek_OMEGA, 0x1FFA, +IBUS_grave, IBUS_Greek_alpha, 0x1F70, +IBUS_grave, IBUS_Greek_epsilon, 0x1F72, +IBUS_grave, IBUS_Greek_eta, 0x1F74, +IBUS_grave, IBUS_Greek_iota, 0x1F76, +IBUS_grave, IBUS_Greek_omicron, 0x1F78, +IBUS_grave, IBUS_Greek_upsilon, 0x1F7A, +IBUS_grave, IBUS_Greek_omega, 0x1F7C, +IBUS_grave, 0x1F00, 0x1F02, +IBUS_grave, 0x1F01, 0x1F03, +IBUS_grave, 0x1F08, 0x1F0A, +IBUS_grave, 0x1F09, 0x1F0B, +IBUS_grave, 0x1F10, 0x1F12, +IBUS_grave, 0x1F11, 0x1F13, +IBUS_grave, 0x1F18, 0x1F1A, +IBUS_grave, 0x1F19, 0x1F1B, +IBUS_grave, 0x1F20, 0x1F22, +IBUS_grave, 0x1F21, 0x1F23, +IBUS_grave, 0x1F28, 0x1F2A, +IBUS_grave, 0x1F29, 0x1F2B, +IBUS_grave, 0x1F30, 0x1F32, +IBUS_grave, 0x1F31, 0x1F33, +IBUS_grave, 0x1F38, 0x1F3A, +IBUS_grave, 0x1F39, 0x1F3B, +IBUS_grave, 0x1F40, 0x1F42, +IBUS_grave, 0x1F41, 0x1F43, +IBUS_grave, 0x1F48, 0x1F4A, +IBUS_grave, 0x1F49, 0x1F4B, +IBUS_grave, 0x1F50, 0x1F52, +IBUS_grave, 0x1F51, 0x1F53, +IBUS_grave, 0x1F59, 0x1F5B, +IBUS_grave, 0x1F60, 0x1F62, +IBUS_grave, 0x1F61, 0x1F63, +IBUS_grave, 0x1F68, 0x1F6A, +IBUS_grave, 0x1F69, 0x1F6B, +IBUS_a, IBUS_quotedbl, 0x00E4, +IBUS_a, IBUS_apostrophe, 0x00E1, +IBUS_a, IBUS_parenleft, 0x0103, +IBUS_a, IBUS_asterisk, 0x00E5, +IBUS_a, IBUS_comma, 0x0105, +IBUS_a, IBUS_minus, 0x0101, +IBUS_a, IBUS_greater, 0x00E2, +IBUS_a, IBUS_asciicircum, 0x00E2, +IBUS_a, IBUS_underscore, 0x00AA, +IBUS_a, IBUS_grave, 0x00E0, +IBUS_a, IBUS_a, 0x00E5, +IBUS_a, IBUS_e, 0x00E6, +IBUS_a, IBUS_asciitilde, 0x00E3, +IBUS_a, IBUS_diaeresis, 0x00E4, +IBUS_a, IBUS_acute, 0x00E1, +IBUS_b, IBUS_period, 0x1E03, +IBUS_b, IBUS_A, 0x0102, +IBUS_b, IBUS_E, 0x0114, +IBUS_b, IBUS_G, 0x011E, +IBUS_b, IBUS_I, 0x012C, +IBUS_b, IBUS_O, 0x014E, +IBUS_b, IBUS_U, 0x016C, +IBUS_b, IBUS_a, 0x0103, +IBUS_b, IBUS_e, 0x0115, +IBUS_b, IBUS_g, 0x011F, +IBUS_b, IBUS_i, 0x012D, +IBUS_b, IBUS_o, 0x014F, +IBUS_b, IBUS_u, 0x016D, +IBUS_b, 0x0228, 0x1E1C, +IBUS_b, 0x0229, 0x1E1D, +IBUS_b, IBUS_Cyrillic_a, 0x04D1, +IBUS_b, IBUS_Cyrillic_ie, 0x04D7, +IBUS_b, IBUS_Cyrillic_i, 0x0439, +IBUS_b, IBUS_Cyrillic_u, 0x045E, +IBUS_b, IBUS_Cyrillic_zhe, 0x04C2, +IBUS_b, IBUS_Cyrillic_A, 0x04D0, +IBUS_b, IBUS_Cyrillic_IE, 0x04D6, +IBUS_b, IBUS_Cyrillic_I, 0x0419, +IBUS_b, IBUS_Cyrillic_U, 0x040E, +IBUS_b, IBUS_Cyrillic_ZHE, 0x04C1, +IBUS_b, IBUS_Greek_ALPHA, 0x1FB8, +IBUS_b, IBUS_Greek_IOTA, 0x1FD8, +IBUS_b, IBUS_Greek_UPSILON, 0x1FE8, +IBUS_b, IBUS_Greek_alpha, 0x1FB0, +IBUS_b, IBUS_Greek_iota, 0x1FD0, +IBUS_b, IBUS_Greek_upsilon, 0x1FE0, +IBUS_b, 0x1EA0, 0x1EB6, +IBUS_b, 0x1EA1, 0x1EB7, +IBUS_c, IBUS_apostrophe, 0x0107, +IBUS_c, IBUS_comma, 0x00E7, +IBUS_c, IBUS_period, 0x010B, +IBUS_c, IBUS_slash, 0x00A2, +IBUS_c, IBUS_0, 0x00A9, +IBUS_c, IBUS_less, 0x010D, +IBUS_c, IBUS_equal, 0x20AC, +IBUS_c, IBUS_A, 0x01CD, +IBUS_c, IBUS_C, 0x010C, +IBUS_c, IBUS_D, 0x010E, +IBUS_c, IBUS_E, 0x011A, +IBUS_c, IBUS_G, 0x01E6, +IBUS_c, IBUS_H, 0x021E, +IBUS_c, IBUS_I, 0x01CF, +IBUS_c, IBUS_K, 0x01E8, +IBUS_c, IBUS_L, 0x013D, +IBUS_c, IBUS_N, 0x0147, +IBUS_c, IBUS_O, 0x01D1, +IBUS_c, IBUS_R, 0x0158, +IBUS_c, IBUS_S, 0x0160, +IBUS_c, IBUS_T, 0x0164, +IBUS_c, IBUS_U, 0x01D3, +IBUS_c, IBUS_Z, 0x017D, +IBUS_c, IBUS_a, 0x01CE, +IBUS_c, IBUS_c, 0x010D, +IBUS_c, IBUS_d, 0x010F, +IBUS_c, IBUS_e, 0x011B, +IBUS_c, IBUS_g, 0x01E7, +IBUS_c, IBUS_h, 0x021F, +IBUS_c, IBUS_i, 0x01D0, +IBUS_c, IBUS_j, 0x01F0, +IBUS_c, IBUS_k, 0x01E9, +IBUS_c, IBUS_l, 0x013E, +IBUS_c, IBUS_n, 0x0148, +IBUS_c, IBUS_o, 0x01D2, +IBUS_c, IBUS_r, 0x0159, +IBUS_c, IBUS_s, 0x0161, +IBUS_c, IBUS_t, 0x0165, +IBUS_c, IBUS_u, 0x01D4, +IBUS_c, IBUS_z, 0x017E, +IBUS_c, IBUS_bar, 0x00A2, +IBUS_c, IBUS_Udiaeresis, 0x01D9, +IBUS_c, IBUS_udiaeresis, 0x01DA, +IBUS_c, 0x01B7, 0x01EE, +IBUS_c, 0x0292, 0x01EF, +IBUS_d, IBUS_minus, 0x20AB, +IBUS_d, IBUS_period, 0x1E0B, +IBUS_d, IBUS_less, 0x010F, +IBUS_d, IBUS_h, 0x00F0, +IBUS_e, IBUS_quotedbl, 0x00EB, +IBUS_e, IBUS_apostrophe, 0x00E9, +IBUS_e, IBUS_comma, 0x0119, +IBUS_e, IBUS_minus, 0x0113, +IBUS_e, IBUS_period, 0x0117, +IBUS_e, IBUS_less, 0x011B, +IBUS_e, IBUS_equal, 0x20AC, +IBUS_e, IBUS_greater, 0x00EA, +IBUS_e, IBUS_asciicircum, 0x00EA, +IBUS_e, IBUS_underscore, 0x0113, +IBUS_e, IBUS_grave, 0x00E8, +IBUS_e, IBUS_e, 0x0259, +IBUS_e, IBUS_diaeresis, 0x00EB, +IBUS_e, IBUS_acute, 0x00E9, +IBUS_f, IBUS_period, 0x1E1F, +IBUS_f, IBUS_S, 0x017F, +IBUS_f, IBUS_s, 0x017F, +IBUS_g, IBUS_parenleft, 0x011F, +IBUS_g, IBUS_comma, 0x0123, +IBUS_g, IBUS_period, 0x0121, +IBUS_g, IBUS_U, 0x011F, +IBUS_g, IBUS_breve, 0x011F, +IBUS_i, IBUS_quotedbl, 0x00EF, +IBUS_i, IBUS_apostrophe, 0x00ED, +IBUS_i, IBUS_comma, 0x012F, +IBUS_i, IBUS_minus, 0x012B, +IBUS_i, IBUS_period, 0x0131, +IBUS_i, IBUS_greater, 0x00EE, +IBUS_i, IBUS_asciicircum, 0x00EE, +IBUS_i, IBUS_underscore, 0x012B, +IBUS_i, IBUS_grave, 0x00EC, +IBUS_i, IBUS_asciitilde, 0x0129, +IBUS_i, IBUS_diaeresis, 0x00EF, +IBUS_i, IBUS_acute, 0x00ED, +IBUS_k, IBUS_comma, 0x0137, +IBUS_k, IBUS_k, 0x0138, +IBUS_l, IBUS_apostrophe, 0x013A, +IBUS_l, IBUS_comma, 0x013C, +IBUS_l, IBUS_minus, 0x00A3, +IBUS_l, IBUS_slash, 0x0142, +IBUS_l, IBUS_less, 0x013E, +IBUS_l, IBUS_equal, 0x00A3, +IBUS_l, IBUS_v, 0x007C, +IBUS_m, IBUS_period, 0x1E41, +IBUS_m, IBUS_slash, 0x20A5, +IBUS_m, IBUS_u, 0x00B5, +IBUS_n, IBUS_apostrophe, 0x0144, +IBUS_n, IBUS_comma, 0x0146, +IBUS_n, IBUS_minus, 0x00F1, +IBUS_n, IBUS_less, 0x0148, +IBUS_n, IBUS_g, 0x014B, +IBUS_n, IBUS_asciitilde, 0x00F1, +IBUS_o, IBUS_quotedbl, 0x00F6, +IBUS_o, IBUS_apostrophe, 0x00F3, +IBUS_o, IBUS_minus, 0x014D, +IBUS_o, IBUS_slash, 0x00F8, +IBUS_o, IBUS_greater, 0x00F4, +IBUS_o, IBUS_A, 0x00C5, +IBUS_o, IBUS_C, 0x00A9, +IBUS_o, IBUS_R, 0x00AE, +IBUS_o, IBUS_U, 0x016E, +IBUS_o, IBUS_X, 0x00A4, +IBUS_o, IBUS_asciicircum, 0x00F4, +IBUS_o, IBUS_underscore, 0x00BA, +IBUS_o, IBUS_grave, 0x00F2, +IBUS_o, IBUS_a, 0x00E5, +IBUS_o, IBUS_c, 0x00A9, +IBUS_o, IBUS_e, 0x0153, +IBUS_o, IBUS_o, 0x00B0, +IBUS_o, IBUS_r, 0x00AE, +IBUS_o, IBUS_s, 0x00A7, +IBUS_o, IBUS_u, 0x016F, +IBUS_o, IBUS_w, 0x1E98, +IBUS_o, IBUS_x, 0x00A4, +IBUS_o, IBUS_y, 0x1E99, +IBUS_o, IBUS_asciitilde, 0x00F5, +IBUS_o, IBUS_diaeresis, 0x00F6, +IBUS_o, IBUS_acute, 0x00F3, +IBUS_p, IBUS_exclam, 0x00B6, +IBUS_p, IBUS_period, 0x1E57, +IBUS_r, IBUS_apostrophe, 0x0155, +IBUS_r, IBUS_comma, 0x0157, +IBUS_r, IBUS_less, 0x0159, +IBUS_s, IBUS_exclam, 0x00A7, +IBUS_s, IBUS_apostrophe, 0x015B, +IBUS_s, IBUS_comma, 0x015F, +IBUS_s, IBUS_period, 0x1E61, +IBUS_s, IBUS_0, 0x00A7, +IBUS_s, IBUS_1, 0x00B9, +IBUS_s, IBUS_2, 0x00B2, +IBUS_s, IBUS_3, 0x00B3, +IBUS_s, IBUS_less, 0x0161, +IBUS_s, IBUS_M, 0x2120, +IBUS_s, IBUS_m, 0x2120, +IBUS_s, IBUS_o, 0x00A7, +IBUS_s, IBUS_s, 0x00DF, +IBUS_s, IBUS_cedilla, 0x015F, +IBUS_t, IBUS_minus, 0x0167, +IBUS_t, IBUS_period, 0x1E6B, +IBUS_t, IBUS_slash, 0x0167, +IBUS_t, IBUS_less, 0x0165, +IBUS_t, IBUS_M, 0x2122, +IBUS_t, IBUS_h, 0x00FE, +IBUS_t, IBUS_m, 0x2122, +IBUS_u, IBUS_quotedbl, 0x00FC, +IBUS_u, IBUS_apostrophe, 0x00FA, +IBUS_u, IBUS_asterisk, 0x016F, +IBUS_u, IBUS_comma, 0x0173, +IBUS_u, IBUS_minus, 0x016B, +IBUS_u, IBUS_slash, 0x00B5, +IBUS_u, IBUS_greater, 0x00FB, +IBUS_u, IBUS_asciicircum, 0x00FB, +IBUS_u, IBUS_underscore, 0x016B, +IBUS_u, IBUS_grave, 0x00F9, +IBUS_u, IBUS_u, 0x016D, +IBUS_u, IBUS_asciitilde, 0x0169, +IBUS_u, IBUS_diaeresis, 0x00FC, +IBUS_u, IBUS_acute, 0x00FA, +IBUS_v, IBUS_Z, 0x017D, +IBUS_v, IBUS_l, 0x007C, +IBUS_v, IBUS_z, 0x017E, +IBUS_w, IBUS_asciicircum, 0x0175, +IBUS_x, IBUS_0, 0x00A4, +IBUS_x, IBUS_O, 0x00A4, +IBUS_x, IBUS_o, 0x00A4, +IBUS_x, IBUS_x, 0x00D7, +IBUS_y, IBUS_quotedbl, 0x00FF, +IBUS_y, IBUS_apostrophe, 0x00FD, +IBUS_y, IBUS_minus, 0x00A5, +IBUS_y, IBUS_equal, 0x00A5, +IBUS_y, IBUS_asciicircum, 0x0177, +IBUS_y, IBUS_diaeresis, 0x00FF, +IBUS_y, IBUS_acute, 0x00FD, +IBUS_z, IBUS_apostrophe, 0x017A, +IBUS_z, IBUS_period, 0x017C, +IBUS_z, IBUS_less, 0x017E, +IBUS_bar, IBUS_C, 0x00A2, +IBUS_bar, IBUS_c, 0x00A2, +IBUS_asciitilde, IBUS_space, 0x007E, +IBUS_asciitilde, IBUS_A, 0x00C3, +IBUS_asciitilde, IBUS_E, 0x1EBC, +IBUS_asciitilde, IBUS_I, 0x0128, +IBUS_asciitilde, IBUS_N, 0x00D1, +IBUS_asciitilde, IBUS_O, 0x00D5, +IBUS_asciitilde, IBUS_U, 0x0168, +IBUS_asciitilde, IBUS_V, 0x1E7C, +IBUS_asciitilde, IBUS_Y, 0x1EF8, +IBUS_asciitilde, IBUS_a, 0x00E3, +IBUS_asciitilde, IBUS_e, 0x1EBD, +IBUS_asciitilde, IBUS_i, 0x0129, +IBUS_asciitilde, IBUS_n, 0x00F1, +IBUS_asciitilde, IBUS_o, 0x00F5, +IBUS_asciitilde, IBUS_u, 0x0169, +IBUS_asciitilde, IBUS_v, 0x1E7D, +IBUS_asciitilde, IBUS_y, 0x1EF9, +IBUS_asciitilde, IBUS_Acircumflex, 0x1EAA, +IBUS_asciitilde, IBUS_Ecircumflex, 0x1EC4, +IBUS_asciitilde, IBUS_Ocircumflex, 0x1ED6, +IBUS_asciitilde, IBUS_acircumflex, 0x1EAB, +IBUS_asciitilde, IBUS_ecircumflex, 0x1EC5, +IBUS_asciitilde, IBUS_ocircumflex, 0x1ED7, +IBUS_asciitilde, IBUS_Abreve, 0x1EB4, +IBUS_asciitilde, IBUS_abreve, 0x1EB5, +IBUS_asciitilde, IBUS_Greek_iotadieresis, 0x1FD7, +IBUS_asciitilde, IBUS_Greek_upsilondieresis, 0x1FE7, +IBUS_asciitilde, IBUS_Greek_alpha, 0x1FB6, +IBUS_asciitilde, IBUS_Greek_eta, 0x1FC6, +IBUS_asciitilde, IBUS_Greek_iota, 0x1FD6, +IBUS_asciitilde, IBUS_Greek_upsilon, 0x1FE6, +IBUS_asciitilde, IBUS_Greek_omega, 0x1FF6, +IBUS_asciitilde, 0x1F00, 0x1F06, +IBUS_asciitilde, 0x1F01, 0x1F07, +IBUS_asciitilde, 0x1F08, 0x1F0E, +IBUS_asciitilde, 0x1F09, 0x1F0F, +IBUS_asciitilde, 0x1F20, 0x1F26, +IBUS_asciitilde, 0x1F21, 0x1F27, +IBUS_asciitilde, 0x1F28, 0x1F2E, +IBUS_asciitilde, 0x1F29, 0x1F2F, +IBUS_asciitilde, 0x1F30, 0x1F36, +IBUS_asciitilde, 0x1F31, 0x1F37, +IBUS_asciitilde, 0x1F38, 0x1F3E, +IBUS_asciitilde, 0x1F39, 0x1F3F, +IBUS_asciitilde, 0x1F50, 0x1F56, +IBUS_asciitilde, 0x1F51, 0x1F57, +IBUS_asciitilde, 0x1F59, 0x1F5F, +IBUS_asciitilde, 0x1F60, 0x1F66, +IBUS_asciitilde, 0x1F61, 0x1F67, +IBUS_asciitilde, 0x1F68, 0x1F6E, +IBUS_asciitilde, 0x1F69, 0x1F6F, +IBUS_diaeresis, IBUS_apostrophe, 0x0385, +IBUS_diaeresis, IBUS_A, 0x00C4, +IBUS_diaeresis, IBUS_E, 0x00CB, +IBUS_diaeresis, IBUS_I, 0x00CF, +IBUS_diaeresis, IBUS_O, 0x00D6, +IBUS_diaeresis, IBUS_U, 0x00DC, +IBUS_diaeresis, IBUS_Y, 0x0178, +IBUS_diaeresis, IBUS_grave, 0x1FED, +IBUS_diaeresis, IBUS_a, 0x00E4, +IBUS_diaeresis, IBUS_e, 0x00EB, +IBUS_diaeresis, IBUS_i, 0x00EF, +IBUS_diaeresis, IBUS_o, 0x00F6, +IBUS_diaeresis, IBUS_u, 0x00FC, +IBUS_diaeresis, IBUS_y, 0x00FF, +IBUS_diaeresis, IBUS_asciitilde, 0x1FC1, +IBUS_diaeresis, IBUS_acute, 0x0385, +IBUS_diaeresis, IBUS_dead_grave, 0x1FED, +IBUS_diaeresis, IBUS_dead_acute, 0x0385, +IBUS_diaeresis, IBUS_dead_tilde, 0x1FC1, +IBUS_macron, IBUS_A, 0x0100, +IBUS_macron, IBUS_E, 0x0112, +IBUS_macron, IBUS_G, 0x1E20, +IBUS_macron, IBUS_I, 0x012A, +IBUS_macron, IBUS_O, 0x014C, +IBUS_macron, IBUS_U, 0x016A, +IBUS_macron, IBUS_Y, 0x0232, +IBUS_macron, IBUS_a, 0x0101, +IBUS_macron, IBUS_e, 0x0113, +IBUS_macron, IBUS_g, 0x1E21, +IBUS_macron, IBUS_i, 0x012B, +IBUS_macron, IBUS_o, 0x014D, +IBUS_macron, IBUS_u, 0x016B, +IBUS_macron, IBUS_y, 0x0233, +IBUS_macron, IBUS_Adiaeresis, 0x01DE, +IBUS_macron, IBUS_AE, 0x01E2, +IBUS_macron, IBUS_Otilde, 0x022C, +IBUS_macron, IBUS_Odiaeresis, 0x022A, +IBUS_macron, IBUS_Udiaeresis, 0x01D5, +IBUS_macron, IBUS_adiaeresis, 0x01DF, +IBUS_macron, IBUS_ae, 0x01E3, +IBUS_macron, IBUS_otilde, 0x022D, +IBUS_macron, IBUS_odiaeresis, 0x022B, +IBUS_macron, IBUS_udiaeresis, 0x01D6, +IBUS_macron, 0x01EA, 0x01EC, +IBUS_macron, 0x01EB, 0x01ED, +IBUS_macron, 0x0226, 0x01E0, +IBUS_macron, 0x0227, 0x01E1, +IBUS_macron, 0x022E, 0x0230, +IBUS_macron, 0x022F, 0x0231, +IBUS_macron, IBUS_Cyrillic_i, 0x04E3, +IBUS_macron, IBUS_Cyrillic_u, 0x04EF, +IBUS_macron, IBUS_Cyrillic_I, 0x04E2, +IBUS_macron, IBUS_Cyrillic_U, 0x04EE, +IBUS_macron, IBUS_Greek_ALPHA, 0x1FB9, +IBUS_macron, IBUS_Greek_IOTA, 0x1FD9, +IBUS_macron, IBUS_Greek_UPSILON, 0x1FE9, +IBUS_macron, IBUS_Greek_alpha, 0x1FB1, +IBUS_macron, IBUS_Greek_iota, 0x1FD1, +IBUS_macron, IBUS_Greek_upsilon, 0x1FE1, +IBUS_macron, 0x1E36, 0x1E38, +IBUS_macron, 0x1E37, 0x1E39, +IBUS_macron, 0x1E5A, 0x1E5C, +IBUS_macron, 0x1E5B, 0x1E5D, +IBUS_acute, IBUS_A, 0x00C1, +IBUS_acute, IBUS_C, 0x0106, +IBUS_acute, IBUS_E, 0x00C9, +IBUS_acute, IBUS_G, 0x01F4, +IBUS_acute, IBUS_I, 0x00CD, +IBUS_acute, IBUS_K, 0x1E30, +IBUS_acute, IBUS_L, 0x0139, +IBUS_acute, IBUS_M, 0x1E3E, +IBUS_acute, IBUS_N, 0x0143, +IBUS_acute, IBUS_O, 0x00D3, +IBUS_acute, IBUS_P, 0x1E54, +IBUS_acute, IBUS_R, 0x0154, +IBUS_acute, IBUS_S, 0x015A, +IBUS_acute, IBUS_U, 0x00DA, +IBUS_acute, IBUS_W, 0x1E82, +IBUS_acute, IBUS_Y, 0x00DD, +IBUS_acute, IBUS_Z, 0x0179, +IBUS_acute, IBUS_a, 0x00E1, +IBUS_acute, IBUS_c, 0x0107, +IBUS_acute, IBUS_e, 0x00E9, +IBUS_acute, IBUS_g, 0x01F5, +IBUS_acute, IBUS_i, 0x00ED, +IBUS_acute, IBUS_k, 0x1E31, +IBUS_acute, IBUS_l, 0x013A, +IBUS_acute, IBUS_m, 0x1E3F, +IBUS_acute, IBUS_n, 0x0144, +IBUS_acute, IBUS_o, 0x00F3, +IBUS_acute, IBUS_p, 0x1E55, +IBUS_acute, IBUS_r, 0x0155, +IBUS_acute, IBUS_s, 0x015B, +IBUS_acute, IBUS_u, 0x00FA, +IBUS_acute, IBUS_w, 0x1E83, +IBUS_acute, IBUS_y, 0x00FD, +IBUS_acute, IBUS_z, 0x017A, +IBUS_acute, IBUS_Acircumflex, 0x1EA4, +IBUS_acute, IBUS_Aring, 0x01FA, +IBUS_acute, IBUS_AE, 0x01FC, +IBUS_acute, IBUS_Ccedilla, 0x1E08, +IBUS_acute, IBUS_Ecircumflex, 0x1EBE, +IBUS_acute, IBUS_Idiaeresis, 0x1E2E, +IBUS_acute, IBUS_Ocircumflex, 0x1ED0, +IBUS_acute, IBUS_Otilde, 0x1E4C, +IBUS_acute, IBUS_Ooblique, 0x01FE, +IBUS_acute, IBUS_Udiaeresis, 0x01D7, +IBUS_acute, IBUS_acircumflex, 0x1EA5, +IBUS_acute, IBUS_aring, 0x01FB, +IBUS_acute, IBUS_ae, 0x01FD, +IBUS_acute, IBUS_ccedilla, 0x1E09, +IBUS_acute, IBUS_ecircumflex, 0x1EBF, +IBUS_acute, IBUS_idiaeresis, 0x1E2F, +IBUS_acute, IBUS_ocircumflex, 0x1ED1, +IBUS_acute, IBUS_otilde, 0x1E4D, +IBUS_acute, IBUS_oslash, 0x01FF, +IBUS_acute, IBUS_udiaeresis, 0x01D8, +IBUS_acute, IBUS_Abreve, 0x1EAE, +IBUS_acute, IBUS_abreve, 0x1EAF, +IBUS_acute, IBUS_Emacron, 0x1E16, +IBUS_acute, IBUS_emacron, 0x1E17, +IBUS_acute, IBUS_Omacron, 0x1E52, +IBUS_acute, IBUS_Utilde, 0x1E78, +IBUS_acute, IBUS_omacron, 0x1E53, +IBUS_acute, IBUS_utilde, 0x1E79, +IBUS_acute, IBUS_Cyrillic_ghe, 0x0453, +IBUS_acute, IBUS_Cyrillic_ka, 0x045C, +IBUS_acute, IBUS_Cyrillic_GHE, 0x0403, +IBUS_acute, IBUS_Cyrillic_KA, 0x040C, +IBUS_acute, IBUS_Greek_iotadieresis, 0x0390, +IBUS_acute, IBUS_Greek_upsilondieresis, 0x03B0, +IBUS_acute, IBUS_Greek_ALPHA, 0x0386, +IBUS_acute, IBUS_Greek_EPSILON, 0x0388, +IBUS_acute, IBUS_Greek_ETA, 0x0389, +IBUS_acute, IBUS_Greek_IOTA, 0x038A, +IBUS_acute, IBUS_Greek_OMICRON, 0x038C, +IBUS_acute, IBUS_Greek_UPSILON, 0x038E, +IBUS_acute, IBUS_Greek_OMEGA, 0x038F, +IBUS_acute, IBUS_Greek_alpha, 0x03AC, +IBUS_acute, IBUS_Greek_epsilon, 0x03AD, +IBUS_acute, IBUS_Greek_eta, 0x03AE, +IBUS_acute, IBUS_Greek_iota, 0x03AF, +IBUS_acute, IBUS_Greek_omicron, 0x03CC, +IBUS_acute, IBUS_Greek_upsilon, 0x03CD, +IBUS_acute, IBUS_Greek_omega, 0x03CE, +IBUS_acute, 0x1F00, 0x1F04, +IBUS_acute, 0x1F01, 0x1F05, +IBUS_acute, 0x1F08, 0x1F0C, +IBUS_acute, 0x1F09, 0x1F0D, +IBUS_acute, 0x1F10, 0x1F14, +IBUS_acute, 0x1F11, 0x1F15, +IBUS_acute, 0x1F18, 0x1F1C, +IBUS_acute, 0x1F19, 0x1F1D, +IBUS_acute, 0x1F20, 0x1F24, +IBUS_acute, 0x1F21, 0x1F25, +IBUS_acute, 0x1F28, 0x1F2C, +IBUS_acute, 0x1F29, 0x1F2D, +IBUS_acute, 0x1F30, 0x1F34, +IBUS_acute, 0x1F31, 0x1F35, +IBUS_acute, 0x1F38, 0x1F3C, +IBUS_acute, 0x1F39, 0x1F3D, +IBUS_acute, 0x1F40, 0x1F44, +IBUS_acute, 0x1F41, 0x1F45, +IBUS_acute, 0x1F48, 0x1F4C, +IBUS_acute, 0x1F49, 0x1F4D, +IBUS_acute, 0x1F50, 0x1F54, +IBUS_acute, 0x1F51, 0x1F55, +IBUS_acute, 0x1F59, 0x1F5D, +IBUS_acute, 0x1F60, 0x1F64, +IBUS_acute, 0x1F61, 0x1F65, +IBUS_acute, 0x1F68, 0x1F6C, +IBUS_acute, 0x1F69, 0x1F6D, +IBUS_cedilla, IBUS_C, 0x00C7, +IBUS_cedilla, IBUS_D, 0x1E10, +IBUS_cedilla, IBUS_E, 0x0228, +IBUS_cedilla, IBUS_G, 0x0122, +IBUS_cedilla, IBUS_H, 0x1E28, +IBUS_cedilla, IBUS_K, 0x0136, +IBUS_cedilla, IBUS_L, 0x013B, +IBUS_cedilla, IBUS_N, 0x0145, +IBUS_cedilla, IBUS_R, 0x0156, +IBUS_cedilla, IBUS_S, 0x015E, +IBUS_cedilla, IBUS_T, 0x0162, +IBUS_cedilla, IBUS_c, 0x00E7, +IBUS_cedilla, IBUS_d, 0x1E11, +IBUS_cedilla, IBUS_e, 0x0229, +IBUS_cedilla, IBUS_g, 0x0123, +IBUS_cedilla, IBUS_h, 0x1E29, +IBUS_cedilla, IBUS_k, 0x0137, +IBUS_cedilla, IBUS_l, 0x013C, +IBUS_cedilla, IBUS_n, 0x0146, +IBUS_cedilla, IBUS_r, 0x0157, +IBUS_cedilla, IBUS_s, 0x015F, +IBUS_cedilla, IBUS_t, 0x0163, +IBUS_breve, IBUS_G, 0x011E, +IBUS_breve, IBUS_g, 0x011F, +0x05B4, IBUS_hebrew_yod, 0xFB1D, +0x05B7, 0x05F2, 0xFB1F, +0x05B7, IBUS_hebrew_aleph, 0xFB2E, +0x05B8, IBUS_hebrew_aleph, 0xFB2F, +0x05B9, IBUS_hebrew_waw, 0xFB4B, +0x05BC, IBUS_hebrew_aleph, 0xFB30, +0x05BC, IBUS_hebrew_beth, 0xFB31, +0x05BC, IBUS_hebrew_gimmel, 0xFB32, +0x05BC, IBUS_hebrew_daleth, 0xFB33, +0x05BC, IBUS_hebrew_he, 0xFB34, +0x05BC, IBUS_hebrew_waw, 0xFB35, +0x05BC, IBUS_hebrew_zayin, 0xFB36, +0x05BC, IBUS_hebrew_teth, 0xFB38, +0x05BC, IBUS_hebrew_yod, 0xFB39, +0x05BC, IBUS_hebrew_finalkaph, 0xFB3A, +0x05BC, IBUS_hebrew_kaph, 0xFB3B, +0x05BC, IBUS_hebrew_lamed, 0xFB3C, +0x05BC, IBUS_hebrew_mem, 0xFB3E, +0x05BC, IBUS_hebrew_nun, 0xFB40, +0x05BC, IBUS_hebrew_samekh, 0xFB41, +0x05BC, IBUS_hebrew_finalpe, 0xFB43, +0x05BC, IBUS_hebrew_pe, 0xFB44, +0x05BC, IBUS_hebrew_zadi, 0xFB46, +0x05BC, IBUS_hebrew_qoph, 0xFB47, +0x05BC, IBUS_hebrew_resh, 0xFB48, +0x05BC, IBUS_hebrew_shin, 0xFB49, +0x05BC, IBUS_hebrew_taw, 0xFB4A, +0x05BF, IBUS_hebrew_beth, 0xFB4C, +0x05BF, IBUS_hebrew_kaph, 0xFB4D, +0x05BF, IBUS_hebrew_pe, 0xFB4E, +0x05C1, IBUS_hebrew_shin, 0xFB2A, +0x05C1, 0xFB49, 0xFB2C, +0x05C2, IBUS_hebrew_shin, 0xFB2B, +0x05C2, 0xFB49, 0xFB2D, +0x0653, IBUS_Arabic_alef, 0x0622, +0x0654, IBUS_Arabic_alef, 0x0623, +0x0654, IBUS_Arabic_waw, 0x0624, +0x0654, IBUS_Arabic_yeh, 0x0626, +0x0654, 0x06C1, 0x06C2, +0x0654, 0x06D2, 0x06D3, +0x0654, 0x06D5, 0x06C0, +0x0655, IBUS_Arabic_alef, 0x0625, +IBUS_Cyrillic_pe, IBUS_Cyrillic_a, 0x00A7, +IBUS_Cyrillic_IE, IBUS_equal, 0x20AC, +IBUS_Cyrillic_EN, IBUS_Cyrillic_o, 0x2116, +IBUS_Cyrillic_EN, IBUS_Cyrillic_O, 0x2116, +IBUS_Cyrillic_ES, IBUS_equal, 0x20AC, +IBUS_Greek_ALPHA, IBUS_apostrophe, 0x0386, +IBUS_Greek_EPSILON, IBUS_apostrophe, 0x0388, +IBUS_Greek_ETA, IBUS_apostrophe, 0x0389, +IBUS_Greek_IOTA, IBUS_quotedbl, 0x03AA, +IBUS_Greek_IOTA, IBUS_apostrophe, 0x038A, +IBUS_Greek_OMICRON, IBUS_apostrophe, 0x038C, +IBUS_Greek_UPSILON, IBUS_quotedbl, 0x03AB, +IBUS_Greek_UPSILON, IBUS_apostrophe, 0x038E, +IBUS_Greek_OMEGA, IBUS_apostrophe, 0x038F, +IBUS_Greek_alpha, IBUS_apostrophe, 0x03AC, +IBUS_Greek_epsilon, IBUS_apostrophe, 0x03AD, +IBUS_Greek_eta, IBUS_apostrophe, 0x03AE, +IBUS_Greek_iota, IBUS_quotedbl, 0x03CA, +IBUS_Greek_iota, IBUS_apostrophe, 0x03AF, +IBUS_Greek_iota, IBUS_Greek_alphaaccent, 0x1FB4, +IBUS_Greek_iota, IBUS_Greek_etaaccent, 0x1FC4, +IBUS_Greek_iota, IBUS_Greek_omegaaccent, 0x1FF4, +IBUS_Greek_iota, IBUS_Greek_ALPHA, 0x1FBC, +IBUS_Greek_iota, IBUS_Greek_ETA, 0x1FCC, +IBUS_Greek_iota, IBUS_Greek_OMEGA, 0x1FFC, +IBUS_Greek_iota, IBUS_Greek_alpha, 0x1FB3, +IBUS_Greek_iota, IBUS_Greek_eta, 0x1FC3, +IBUS_Greek_iota, IBUS_Greek_omega, 0x1FF3, +IBUS_Greek_iota, 0x1F00, 0x1F80, +IBUS_Greek_iota, 0x1F01, 0x1F81, +IBUS_Greek_iota, 0x1F02, 0x1F82, +IBUS_Greek_iota, 0x1F03, 0x1F83, +IBUS_Greek_iota, 0x1F04, 0x1F84, +IBUS_Greek_iota, 0x1F05, 0x1F85, +IBUS_Greek_iota, 0x1F06, 0x1F86, +IBUS_Greek_iota, 0x1F07, 0x1F87, +IBUS_Greek_iota, 0x1F08, 0x1F88, +IBUS_Greek_iota, 0x1F09, 0x1F89, +IBUS_Greek_iota, 0x1F0A, 0x1F8A, +IBUS_Greek_iota, 0x1F0B, 0x1F8B, +IBUS_Greek_iota, 0x1F0C, 0x1F8C, +IBUS_Greek_iota, 0x1F0D, 0x1F8D, +IBUS_Greek_iota, 0x1F0E, 0x1F8E, +IBUS_Greek_iota, 0x1F0F, 0x1F8F, +IBUS_Greek_iota, 0x1F20, 0x1F90, +IBUS_Greek_iota, 0x1F21, 0x1F91, +IBUS_Greek_iota, 0x1F22, 0x1F92, +IBUS_Greek_iota, 0x1F23, 0x1F93, +IBUS_Greek_iota, 0x1F24, 0x1F94, +IBUS_Greek_iota, 0x1F25, 0x1F95, +IBUS_Greek_iota, 0x1F26, 0x1F96, +IBUS_Greek_iota, 0x1F27, 0x1F97, +IBUS_Greek_iota, 0x1F28, 0x1F98, +IBUS_Greek_iota, 0x1F29, 0x1F99, +IBUS_Greek_iota, 0x1F2A, 0x1F9A, +IBUS_Greek_iota, 0x1F2B, 0x1F9B, +IBUS_Greek_iota, 0x1F2C, 0x1F9C, +IBUS_Greek_iota, 0x1F2D, 0x1F9D, +IBUS_Greek_iota, 0x1F2E, 0x1F9E, +IBUS_Greek_iota, 0x1F2F, 0x1F9F, +IBUS_Greek_iota, 0x1F60, 0x1FA0, +IBUS_Greek_iota, 0x1F61, 0x1FA1, +IBUS_Greek_iota, 0x1F62, 0x1FA2, +IBUS_Greek_iota, 0x1F63, 0x1FA3, +IBUS_Greek_iota, 0x1F64, 0x1FA4, +IBUS_Greek_iota, 0x1F65, 0x1FA5, +IBUS_Greek_iota, 0x1F66, 0x1FA6, +IBUS_Greek_iota, 0x1F67, 0x1FA7, +IBUS_Greek_iota, 0x1F68, 0x1FA8, +IBUS_Greek_iota, 0x1F69, 0x1FA9, +IBUS_Greek_iota, 0x1F6A, 0x1FAA, +IBUS_Greek_iota, 0x1F6B, 0x1FAB, +IBUS_Greek_iota, 0x1F6C, 0x1FAC, +IBUS_Greek_iota, 0x1F6D, 0x1FAD, +IBUS_Greek_iota, 0x1F6E, 0x1FAE, +IBUS_Greek_iota, 0x1F6F, 0x1FAF, +IBUS_Greek_iota, 0x1F70, 0x1FB2, +IBUS_Greek_iota, 0x1F74, 0x1FC2, +IBUS_Greek_iota, 0x1F7C, 0x1FF2, +IBUS_Greek_iota, 0x1FB6, 0x1FB7, +IBUS_Greek_iota, 0x1FC6, 0x1FC7, +IBUS_Greek_iota, 0x1FF6, 0x1FF7, +IBUS_Greek_omicron, IBUS_apostrophe, 0x03CC, +IBUS_Greek_upsilon, IBUS_quotedbl, 0x03CB, +IBUS_Greek_upsilon, IBUS_apostrophe, 0x03CD, +IBUS_Greek_omega, IBUS_apostrophe, 0x03CE, +IBUS_lessthanequal, 0x0338, 0x2270, +IBUS_greaterthanequal, 0x0338, 0x2271, +IBUS_approximate, 0x0338, 0x2247, +IBUS_identical, 0x0338, 0x2262, +IBUS_includedin, 0x0338, 0x2284, +IBUS_includes, 0x0338, 0x2285, +0x093C, 0x0915, 0x0958, +0x093C, 0x0916, 0x0959, +0x093C, 0x0917, 0x095A, +0x093C, 0x091C, 0x095B, +0x093C, 0x0921, 0x095C, +0x093C, 0x0922, 0x095D, +0x093C, 0x0928, 0x0929, +0x093C, 0x092B, 0x095E, +0x093C, 0x092F, 0x095F, +0x093C, 0x0930, 0x0931, +0x093C, 0x0933, 0x0934, +0x09BC, 0x09A1, 0x09DC, +0x09BC, 0x09A2, 0x09DD, +0x09BC, 0x09AF, 0x09DF, +0x09C7, 0x09BE, 0x09CB, +0x09C7, 0x09D7, 0x09CC, +0x0A3C, 0x0A16, 0x0A59, +0x0A3C, 0x0A17, 0x0A5A, +0x0A3C, 0x0A1C, 0x0A5B, +0x0A3C, 0x0A2B, 0x0A5E, +0x0A3C, 0x0A32, 0x0A33, +0x0A3C, 0x0A38, 0x0A36, +0x0B3C, 0x0B21, 0x0B5C, +0x0B3C, 0x0B22, 0x0B5D, +0x0B47, 0x0B3E, 0x0B4B, +0x0B47, 0x0B56, 0x0B48, +0x0B47, 0x0B57, 0x0B4C, +IBUS_leftcaret, 0x0338, 0x226E, +IBUS_rightcaret, 0x0338, 0x226F, +IBUS_underbar, IBUS_parenleft, 0x208D, +IBUS_underbar, IBUS_parenright, 0x208E, +IBUS_underbar, IBUS_plus, 0x208A, +IBUS_underbar, IBUS_0, 0x2080, +IBUS_underbar, IBUS_1, 0x2081, +IBUS_underbar, IBUS_2, 0x2082, +IBUS_underbar, IBUS_3, 0x2083, +IBUS_underbar, IBUS_4, 0x2084, +IBUS_underbar, IBUS_5, 0x2085, +IBUS_underbar, IBUS_6, 0x2086, +IBUS_underbar, IBUS_7, 0x2087, +IBUS_underbar, IBUS_8, 0x2088, +IBUS_underbar, IBUS_9, 0x2089, +IBUS_underbar, IBUS_equal, 0x208C, +0x0BC6, 0x0BBE, 0x0BCA, +0x0BC6, 0x0BD7, 0x0BCC, +IBUS_underbar, 0x2212, 0x208B, +IBUS_underbar, IBUS_KP_Space, 0x2082, +IBUS_underbar, IBUS_KP_Add, 0x208A, +IBUS_underbar, IBUS_KP_0, 0x2080, +IBUS_underbar, IBUS_KP_1, 0x2081, +IBUS_underbar, IBUS_KP_2, 0x2082, +IBUS_underbar, IBUS_KP_3, 0x2083, +IBUS_underbar, IBUS_KP_4, 0x2084, +IBUS_underbar, IBUS_KP_5, 0x2085, +IBUS_underbar, IBUS_KP_6, 0x2086, +IBUS_underbar, IBUS_KP_7, 0x2087, +IBUS_underbar, IBUS_KP_8, 0x2088, +IBUS_underbar, IBUS_KP_9, 0x2089, +IBUS_underbar, IBUS_KP_Equal, 0x208C, +0x0BC7, 0x0BBE, 0x0BCB, +0x0BD7, 0x0B92, 0x0B94, +IBUS_rightshoe, 0x0338, 0x2285, +IBUS_leftshoe, 0x0338, 0x2284, +IBUS_righttack, 0x0338, 0x22AC, +0x0C46, 0x0C56, 0x0C48, +0x0CBF, 0x0CD5, 0x0CC0, +0x0CC6, 0x0CC2, 0x0CCA, +0x0CC6, 0x0CD5, 0x0CC7, +0x0CC6, 0x0CD6, 0x0CC8, +0x0CCA, 0x0CD5, 0x0CCB, +0x0D46, 0x0D3E, 0x0D4A, +0x0D46, 0x0D57, 0x0D4C, +0x0D47, 0x0D3E, 0x0D4B, +0x0DD9, 0x0DCA, 0x0DDA, +0x0DD9, 0x0DCF, 0x0DDC, +0x0DD9, 0x0DDF, 0x0DDE, +0x0DDC, 0x0DCA, 0x0DDD, +0x0F71, 0x0F72, 0x0F73, +0x0F71, 0x0F74, 0x0F75, +0x0F71, 0x0F80, 0x0F81, +0x0F90, 0x0FB5, 0x0FB9, +0x0F92, 0x0FB7, 0x0F93, +0x0F9C, 0x0FB7, 0x0F9D, +0x0FA1, 0x0FB7, 0x0FA2, +0x0FA6, 0x0FB7, 0x0FA7, +0x0FAB, 0x0FB7, 0x0FAC, +0x0FB2, 0x0F80, 0x0F76, +0x0FB3, 0x0F80, 0x0F78, +0x0FB5, 0x0F40, 0x0F69, +0x0FB7, 0x0F42, 0x0F43, +0x0FB7, 0x0F4C, 0x0F4D, +0x0FB7, 0x0F51, 0x0F52, +0x0FB7, 0x0F56, 0x0F57, +0x0FB7, 0x0F5B, 0x0F5C, +0x102E, 0x1025, 0x1026, +0x1100, 0x1100, 0x1101, +0x1102, 0x1100, 0x1113, +0x1102, 0x1102, 0x1114, +0x1102, 0x1103, 0x1115, +0x1102, 0x1107, 0x1116, +0x1103, 0x1100, 0x1117, +0x1103, 0x1103, 0x1104, +0x1105, 0x1102, 0x1118, +0x1105, 0x1105, 0x1119, +0x1105, 0x110B, 0x111B, +0x1105, 0x1112, 0x111A, +0x1106, 0x1107, 0x111C, +0x1106, 0x110B, 0x111D, +0x1107, 0x1100, 0x111E, +0x1107, 0x1102, 0x111F, +0x1107, 0x1103, 0x1120, +0x1107, 0x1107, 0x1108, +0x1107, 0x1109, 0x1121, +0x1107, 0x110A, 0x1125, +0x1107, 0x110B, 0x112B, +0x1107, 0x110C, 0x1127, +0x1107, 0x110E, 0x1128, +0x1107, 0x1110, 0x1129, +0x1107, 0x1111, 0x112A, +0x1107, 0x112B, 0x112C, +0x1107, 0x112D, 0x1122, +0x1107, 0x112F, 0x1123, +0x1107, 0x1132, 0x1124, +0x1107, 0x1136, 0x1126, +0x1108, 0x110B, 0x112C, +0x1109, 0x1100, 0x112D, +0x1109, 0x1102, 0x112E, +0x1109, 0x1103, 0x112F, +0x1109, 0x1105, 0x1130, +0x1109, 0x1106, 0x1131, +0x1109, 0x1107, 0x1132, +0x1109, 0x1109, 0x110A, +0x1109, 0x110A, 0x1134, +0x1109, 0x110B, 0x1135, +0x1109, 0x110C, 0x1136, +0x1109, 0x110E, 0x1137, +0x1109, 0x110F, 0x1138, +0x1109, 0x1110, 0x1139, +0x1109, 0x1111, 0x113A, +0x1109, 0x1112, 0x113B, +0x1109, 0x111E, 0x1133, +0x110A, 0x1109, 0x1134, +0x110B, 0x1100, 0x1141, +0x110B, 0x1103, 0x1142, +0x110B, 0x1106, 0x1143, +0x110B, 0x1107, 0x1144, +0x110B, 0x1109, 0x1145, +0x110B, 0x110B, 0x1147, +0x110B, 0x110C, 0x1148, +0x110B, 0x110E, 0x1149, +0x110B, 0x1110, 0x114A, +0x110B, 0x1111, 0x114B, +0x110B, 0x1140, 0x1146, +0x110C, 0x110B, 0x114D, +0x110C, 0x110C, 0x110D, +0x110E, 0x110F, 0x1152, +0x110E, 0x1112, 0x1153, +0x1111, 0x1107, 0x1156, +0x1111, 0x110B, 0x1157, +0x1112, 0x1112, 0x1158, +0x1121, 0x1100, 0x1122, +0x1121, 0x1103, 0x1123, +0x1121, 0x1107, 0x1124, +0x1121, 0x1109, 0x1125, +0x1121, 0x110C, 0x1126, +0x1132, 0x1100, 0x1133, +0x113C, 0x113C, 0x113D, +0x113E, 0x113E, 0x113F, +0x114E, 0x114E, 0x114F, +0x1150, 0x1150, 0x1151, +0x1161, 0x1169, 0x1176, +0x1161, 0x116E, 0x1177, +0x1161, 0x1175, 0x1162, +0x1163, 0x1169, 0x1178, +0x1163, 0x116D, 0x1179, +0x1163, 0x1175, 0x1164, +0x1165, 0x1169, 0x117A, +0x1165, 0x116E, 0x117B, +0x1165, 0x1173, 0x117C, +0x1165, 0x1175, 0x1166, +0x1167, 0x1169, 0x117D, +0x1167, 0x116E, 0x117E, +0x1167, 0x1175, 0x1168, +0x1169, 0x1161, 0x116A, +0x1169, 0x1162, 0x116B, +0x1169, 0x1165, 0x117F, +0x1169, 0x1166, 0x1180, +0x1169, 0x1168, 0x1181, +0x1169, 0x1169, 0x1182, +0x1169, 0x116E, 0x1183, +0x1169, 0x1175, 0x116C, +0x116A, 0x1175, 0x116B, +0x116D, 0x1163, 0x1184, +0x116D, 0x1164, 0x1185, +0x116D, 0x1167, 0x1186, +0x116D, 0x1169, 0x1187, +0x116D, 0x1175, 0x1188, +0x116E, 0x1161, 0x1189, +0x116E, 0x1162, 0x118A, +0x116E, 0x1165, 0x116F, +0x116E, 0x1166, 0x1170, +0x116E, 0x1168, 0x118C, +0x116E, 0x116E, 0x118D, +0x116E, 0x1175, 0x1171, +0x116E, 0x117C, 0x118B, +0x116F, 0x1173, 0x118B, +0x116F, 0x1175, 0x1170, +0x1172, 0x1161, 0x118E, +0x1172, 0x1165, 0x118F, +0x1172, 0x1166, 0x1190, +0x1172, 0x1167, 0x1191, +0x1172, 0x1168, 0x1192, +0x1172, 0x116E, 0x1193, +0x1172, 0x1175, 0x1194, +0x1173, 0x116E, 0x1195, +0x1173, 0x1173, 0x1196, +0x1173, 0x1175, 0x1174, +0x1174, 0x116E, 0x1197, +0x1175, 0x1161, 0x1198, +0x1175, 0x1163, 0x1199, +0x1175, 0x1169, 0x119A, +0x1175, 0x116E, 0x119B, +0x1175, 0x1173, 0x119C, +0x1175, 0x119E, 0x119D, +0x119E, 0x1165, 0x119F, +0x119E, 0x116E, 0x11A0, +0x119E, 0x1175, 0x11A1, +0x119E, 0x119E, 0x11A2, +0x11A8, 0x11A8, 0x11A9, +0x11A8, 0x11AF, 0x11C3, +0x11A8, 0x11BA, 0x11AA, +0x11A8, 0x11E7, 0x11C4, +0x11AA, 0x11A8, 0x11C4, +0x11AB, 0x11A8, 0x11C5, +0x11AB, 0x11AE, 0x11C6, +0x11AB, 0x11BA, 0x11C7, +0x11AB, 0x11BD, 0x11AC, +0x11AB, 0x11C0, 0x11C9, +0x11AB, 0x11C2, 0x11AD, +0x11AB, 0x11EB, 0x11C8, +0x11AE, 0x11A8, 0x11CA, +0x11AE, 0x11AF, 0x11CB, +0x11AF, 0x11A8, 0x11B0, +0x11AF, 0x11AA, 0x11CC, +0x11AF, 0x11AB, 0x11CD, +0x11AF, 0x11AE, 0x11CE, +0x11AF, 0x11AF, 0x11D0, +0x11AF, 0x11B7, 0x11B1, +0x11AF, 0x11B8, 0x11B2, +0x11AF, 0x11B9, 0x11D3, +0x11AF, 0x11BA, 0x11B3, +0x11AF, 0x11BB, 0x11D6, +0x11AF, 0x11BF, 0x11D8, +0x11AF, 0x11C0, 0x11B4, +0x11AF, 0x11C1, 0x11B5, +0x11AF, 0x11C2, 0x11B6, +0x11AF, 0x11DA, 0x11D1, +0x11AF, 0x11DD, 0x11D2, +0x11AF, 0x11E5, 0x11D4, +0x11AF, 0x11E6, 0x11D5, +0x11AF, 0x11EB, 0x11D7, +0x11AF, 0x11F9, 0x11D9, +0x11B0, 0x11BA, 0x11CC, +0x11B1, 0x11A8, 0x11D1, +0x11B1, 0x11BA, 0x11D2, +0x11B2, 0x11BA, 0x11D3, +0x11B2, 0x11BC, 0x11D5, +0x11B2, 0x11C2, 0x11D4, +0x11B3, 0x11BA, 0x11D6, +0x11B7, 0x11A8, 0x11DA, +0x11B7, 0x11AF, 0x11DB, +0x11B7, 0x11B8, 0x11DC, +0x11B7, 0x11BA, 0x11DD, +0x11B7, 0x11BB, 0x11DE, +0x11B7, 0x11BC, 0x11E2, +0x11B7, 0x11BE, 0x11E0, +0x11B7, 0x11C2, 0x11E1, +0x11B7, 0x11EB, 0x11DF, +0x11B8, 0x11AF, 0x11E3, +0x11B8, 0x11BA, 0x11B9, +0x11B8, 0x11BC, 0x11E6, +0x11B8, 0x11C1, 0x11E4, +0x11B8, 0x11C2, 0x11E5, +0x11BA, 0x11A8, 0x11E7, +0x11BA, 0x11AE, 0x11E8, +0x11BA, 0x11AF, 0x11E9, +0x11BA, 0x11B8, 0x11EA, +0x11BA, 0x11BA, 0x11BB, +0x11BC, 0x11A8, 0x11EC, +0x11BC, 0x11A9, 0x11ED, +0x11BC, 0x11BC, 0x11EE, +0x11BC, 0x11BF, 0x11EF, +0x11C1, 0x11B8, 0x11F3, +0x11C1, 0x11BC, 0x11F4, +0x11C2, 0x11AB, 0x11F5, +0x11C2, 0x11AF, 0x11F6, +0x11C2, 0x11B7, 0x11F7, +0x11C2, 0x11B8, 0x11F8, +0x11CE, 0x11C2, 0x11CF, +0x11DD, 0x11BA, 0x11DE, +0x11EC, 0x11A8, 0x11ED, +0x11F0, 0x11BA, 0x11F1, +0x11F0, 0x11EB, 0x11F2, +0x1FBF, IBUS_apostrophe, 0x1FCE, +0x1FBF, IBUS_grave, 0x1FCD, +0x1FBF, IBUS_asciitilde, 0x1FCF, +0x1FBF, IBUS_acute, 0x1FCE, +0x1FBF, IBUS_dead_grave, 0x1FCD, +0x1FBF, IBUS_dead_acute, 0x1FCE, +0x1FBF, IBUS_dead_tilde, 0x1FCF, +0x1FFE, IBUS_apostrophe, 0x1FDE, +0x1FFE, IBUS_grave, 0x1FDD, +0x1FFE, IBUS_asciitilde, 0x1FDF, +0x1FFE, IBUS_acute, 0x1FDE, +0x1FFE, IBUS_dead_grave, 0x1FDD, +0x1FFE, IBUS_dead_acute, 0x1FDE, +0x1FFE, IBUS_dead_tilde, 0x1FDF, +0x2203, 0x0338, 0x2204, +0x2208, 0x0338, 0x2209, +0x220B, 0x0338, 0x220C, +0x2223, 0x0338, 0x2224, +0x2225, 0x0338, 0x2226, +0x223C, 0x0338, 0x2241, +0x2243, 0x0338, 0x2244, +0x2248, 0x0338, 0x2249, +0x224D, 0x0338, 0x226D, +0x2272, 0x0338, 0x2274, +0x2273, 0x0338, 0x2275, +0x2276, 0x0338, 0x2278, +0x2277, 0x0338, 0x2279, +0x227A, 0x0338, 0x2280, +0x227B, 0x0338, 0x2281, +0x227C, 0x0338, 0x22E0, +0x227D, 0x0338, 0x22E1, +0x2286, 0x0338, 0x2288, +0x2287, 0x0338, 0x2289, +0x2291, 0x0338, 0x22E2, +0x2292, 0x0338, 0x22E3, +0x22A8, 0x0338, 0x22AD, +0x22A9, 0x0338, 0x22AE, +0x22AB, 0x0338, 0x22AF, +0x22B2, 0x0338, 0x22EA, +0x22B3, 0x0338, 0x22EB, +0x22B4, 0x0338, 0x22EC, +0x22B5, 0x0338, 0x22ED, +0x2ADD, 0x0338, 0x2ADC, +IBUS_KP_Divide, IBUS_D, 0x0110, +IBUS_KP_Divide, IBUS_G, 0x01E4, +IBUS_KP_Divide, IBUS_H, 0x0126, +IBUS_KP_Divide, IBUS_I, 0x0197, +IBUS_KP_Divide, IBUS_L, 0x0141, +IBUS_KP_Divide, IBUS_O, 0x00D8, +IBUS_KP_Divide, IBUS_T, 0x0166, +IBUS_KP_Divide, IBUS_Z, 0x01B5, +IBUS_KP_Divide, IBUS_b, 0x0180, +IBUS_KP_Divide, IBUS_d, 0x0111, +IBUS_KP_Divide, IBUS_g, 0x01E5, +IBUS_KP_Divide, IBUS_h, 0x0127, +IBUS_KP_Divide, IBUS_i, 0x0268, +IBUS_KP_Divide, IBUS_l, 0x0142, +IBUS_KP_Divide, IBUS_o, 0x00F8, +IBUS_KP_Divide, IBUS_t, 0x0167, +IBUS_KP_Divide, IBUS_z, 0x01B6, +IBUS_KP_Divide, 0x0294, 0x02A1, +IBUS_KP_Divide, 0x04AE, 0x04B0, +IBUS_KP_Divide, 0x04AF, 0x04B1, +IBUS_KP_Divide, IBUS_Cyrillic_ghe, 0x0493, +IBUS_KP_Divide, IBUS_Cyrillic_ka, 0x049F, +IBUS_KP_Divide, IBUS_Cyrillic_GHE, 0x0492, +IBUS_KP_Divide, IBUS_Cyrillic_KA, 0x049E, +IBUS_KP_Divide, IBUS_leftarrow, 0x219A, +IBUS_KP_Divide, IBUS_rightarrow, 0x219B, +IBUS_KP_Divide, 0x2194, 0x21AE, +IBUS_KP_Equal, 0x0338, 0x2260, +IBUS_exclam, IBUS_plus, IBUS_O, 0x1EE2, +IBUS_exclam, IBUS_plus, IBUS_U, 0x1EF0, +IBUS_exclam, IBUS_plus, IBUS_o, 0x1EE3, +IBUS_exclam, IBUS_plus, IBUS_u, 0x1EF1, +IBUS_exclam, IBUS_dead_horn, IBUS_O, 0x1EE2, +IBUS_exclam, IBUS_dead_horn, IBUS_U, 0x1EF0, +IBUS_exclam, IBUS_dead_horn, IBUS_o, 0x1EE3, +IBUS_exclam, IBUS_dead_horn, IBUS_u, 0x1EF1, +IBUS_quotedbl, IBUS_apostrophe, IBUS_space, 0x0385, +IBUS_quotedbl, IBUS_apostrophe, IBUS_Greek_iota, 0x0390, +IBUS_quotedbl, IBUS_apostrophe, IBUS_Greek_upsilon, 0x03B0, +IBUS_quotedbl, IBUS_underscore, IBUS_U, 0x1E7A, +IBUS_quotedbl, IBUS_underscore, IBUS_u, 0x1E7B, +IBUS_quotedbl, IBUS_asciitilde, IBUS_O, 0x1E4E, +IBUS_quotedbl, IBUS_asciitilde, IBUS_o, 0x1E4F, +IBUS_quotedbl, IBUS_macron, IBUS_U, 0x1E7A, +IBUS_quotedbl, IBUS_macron, IBUS_u, 0x1E7B, +IBUS_quotedbl, IBUS_dead_tilde, IBUS_O, 0x1E4E, +IBUS_quotedbl, IBUS_dead_tilde, IBUS_o, 0x1E4F, +IBUS_quotedbl, IBUS_dead_macron, IBUS_U, 0x1E7A, +IBUS_quotedbl, IBUS_dead_macron, IBUS_u, 0x1E7B, +IBUS_apostrophe, IBUS_quotedbl, IBUS_space, 0x0385, +IBUS_apostrophe, IBUS_quotedbl, IBUS_I, 0x1E2E, +IBUS_apostrophe, IBUS_quotedbl, IBUS_U, 0x01D7, +IBUS_apostrophe, IBUS_quotedbl, IBUS_i, 0x1E2F, +IBUS_apostrophe, IBUS_quotedbl, IBUS_u, 0x01D8, +IBUS_apostrophe, IBUS_quotedbl, IBUS_Greek_iota, 0x0390, +IBUS_apostrophe, IBUS_quotedbl, IBUS_Greek_upsilon, 0x03B0, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0D, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1D, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2D, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3D, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4D, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5D, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6D, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_alpha, 0x1F05, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F15, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_eta, 0x1F25, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_iota, 0x1F35, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omicron, 0x1F45, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F55, +IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omega, 0x1F65, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0C, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1C, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ETA, 0x1F2C, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3C, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4C, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6C, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_alpha, 0x1F04, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_epsilon, 0x1F14, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_eta, 0x1F24, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_iota, 0x1F34, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omicron, 0x1F44, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_upsilon, 0x1F54, +IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omega, 0x1F64, +IBUS_apostrophe, IBUS_plus, IBUS_O, 0x1EDA, +IBUS_apostrophe, IBUS_plus, IBUS_U, 0x1EE8, +IBUS_apostrophe, IBUS_plus, IBUS_o, 0x1EDB, +IBUS_apostrophe, IBUS_plus, IBUS_u, 0x1EE9, +IBUS_apostrophe, IBUS_slash, IBUS_O, 0x01FE, +IBUS_apostrophe, IBUS_slash, IBUS_o, 0x01FF, +IBUS_apostrophe, IBUS_asciicircum, IBUS_A, 0x1EA4, +IBUS_apostrophe, IBUS_asciicircum, IBUS_E, 0x1EBE, +IBUS_apostrophe, IBUS_asciicircum, IBUS_O, 0x1ED0, +IBUS_apostrophe, IBUS_asciicircum, IBUS_a, 0x1EA5, +IBUS_apostrophe, IBUS_asciicircum, IBUS_e, 0x1EBF, +IBUS_apostrophe, IBUS_asciicircum, IBUS_o, 0x1ED1, +IBUS_apostrophe, IBUS_underscore, IBUS_E, 0x1E16, +IBUS_apostrophe, IBUS_underscore, IBUS_O, 0x1E52, +IBUS_apostrophe, IBUS_underscore, IBUS_e, 0x1E17, +IBUS_apostrophe, IBUS_underscore, IBUS_o, 0x1E53, +IBUS_apostrophe, IBUS_b, IBUS_A, 0x1EAE, +IBUS_apostrophe, IBUS_b, IBUS_a, 0x1EAF, +IBUS_apostrophe, IBUS_asciitilde, IBUS_O, 0x1E4C, +IBUS_apostrophe, IBUS_asciitilde, IBUS_U, 0x1E78, +IBUS_apostrophe, IBUS_asciitilde, IBUS_o, 0x1E4D, +IBUS_apostrophe, IBUS_asciitilde, IBUS_u, 0x1E79, +IBUS_apostrophe, IBUS_macron, IBUS_E, 0x1E16, +IBUS_apostrophe, IBUS_macron, IBUS_O, 0x1E52, +IBUS_apostrophe, IBUS_macron, IBUS_e, 0x1E17, +IBUS_apostrophe, IBUS_macron, IBUS_o, 0x1E53, +IBUS_apostrophe, IBUS_cedilla, IBUS_C, 0x1E08, +IBUS_apostrophe, IBUS_cedilla, IBUS_c, 0x1E09, +IBUS_apostrophe, IBUS_dead_circumflex, IBUS_A, 0x1EA4, +IBUS_apostrophe, IBUS_dead_circumflex, IBUS_E, 0x1EBE, +IBUS_apostrophe, IBUS_dead_circumflex, IBUS_O, 0x1ED0, +IBUS_apostrophe, IBUS_dead_circumflex, IBUS_a, 0x1EA5, +IBUS_apostrophe, IBUS_dead_circumflex, IBUS_e, 0x1EBF, +IBUS_apostrophe, IBUS_dead_circumflex, IBUS_o, 0x1ED1, +IBUS_apostrophe, IBUS_dead_tilde, IBUS_O, 0x1E4C, +IBUS_apostrophe, IBUS_dead_tilde, IBUS_U, 0x1E78, +IBUS_apostrophe, IBUS_dead_tilde, IBUS_o, 0x1E4D, +IBUS_apostrophe, IBUS_dead_tilde, IBUS_u, 0x1E79, +IBUS_apostrophe, IBUS_dead_macron, IBUS_E, 0x1E16, +IBUS_apostrophe, IBUS_dead_macron, IBUS_O, 0x1E52, +IBUS_apostrophe, IBUS_dead_macron, IBUS_e, 0x1E17, +IBUS_apostrophe, IBUS_dead_macron, IBUS_o, 0x1E53, +IBUS_apostrophe, IBUS_dead_breve, IBUS_A, 0x1EAE, +IBUS_apostrophe, IBUS_dead_breve, IBUS_a, 0x1EAF, +IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_I, 0x1E2E, +IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_U, 0x01D7, +IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_i, 0x1E2F, +IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_u, 0x01D8, +IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x0390, +IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x03B0, +IBUS_apostrophe, IBUS_dead_abovering, IBUS_A, 0x01FA, +IBUS_apostrophe, IBUS_dead_abovering, IBUS_a, 0x01FB, +IBUS_apostrophe, IBUS_dead_cedilla, IBUS_C, 0x1E08, +IBUS_apostrophe, IBUS_dead_cedilla, IBUS_c, 0x1E09, +IBUS_apostrophe, IBUS_dead_horn, IBUS_O, 0x1EDA, +IBUS_apostrophe, IBUS_dead_horn, IBUS_U, 0x1EE8, +IBUS_apostrophe, IBUS_dead_horn, IBUS_o, 0x1EDB, +IBUS_apostrophe, IBUS_dead_horn, IBUS_u, 0x1EE9, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0C, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1C, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2C, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3C, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4C, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6C, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F04, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F14, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_eta, 0x1F24, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_iota, 0x1F34, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omicron, 0x1F44, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F54, +IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omega, 0x1F64, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0D, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1D, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2D, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3D, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4D, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5D, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6D, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F05, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F15, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F25, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F35, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F45, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F55, +IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F65, +IBUS_apostrophe, IBUS_KP_Divide, IBUS_O, 0x01FE, +IBUS_apostrophe, IBUS_KP_Divide, IBUS_o, 0x01FF, +IBUS_parenleft, IBUS_0, IBUS_parenright, 0x24EA, +IBUS_parenleft, IBUS_1, IBUS_parenright, 0x2460, +IBUS_parenleft, IBUS_2, IBUS_parenright, 0x2461, +IBUS_parenleft, IBUS_3, IBUS_parenright, 0x2462, +IBUS_parenleft, IBUS_4, IBUS_parenright, 0x2463, +IBUS_parenleft, IBUS_5, IBUS_parenright, 0x2464, +IBUS_parenleft, IBUS_6, IBUS_parenright, 0x2465, +IBUS_parenleft, IBUS_7, IBUS_parenright, 0x2466, +IBUS_parenleft, IBUS_8, IBUS_parenright, 0x2467, +IBUS_parenleft, IBUS_9, IBUS_parenright, 0x2468, +IBUS_parenleft, IBUS_A, IBUS_parenright, 0x24B6, +IBUS_parenleft, IBUS_B, IBUS_parenright, 0x24B7, +IBUS_parenleft, IBUS_C, IBUS_parenright, 0x24B8, +IBUS_parenleft, IBUS_D, IBUS_parenright, 0x24B9, +IBUS_parenleft, IBUS_E, IBUS_parenright, 0x24BA, +IBUS_parenleft, IBUS_F, IBUS_parenright, 0x24BB, +IBUS_parenleft, IBUS_G, IBUS_parenright, 0x24BC, +IBUS_parenleft, IBUS_H, IBUS_parenright, 0x24BD, +IBUS_parenleft, IBUS_I, IBUS_parenright, 0x24BE, +IBUS_parenleft, IBUS_J, IBUS_parenright, 0x24BF, +IBUS_parenleft, IBUS_K, IBUS_parenright, 0x24C0, +IBUS_parenleft, IBUS_L, IBUS_parenright, 0x24C1, +IBUS_parenleft, IBUS_M, IBUS_parenright, 0x24C2, +IBUS_parenleft, IBUS_N, IBUS_parenright, 0x24C3, +IBUS_parenleft, IBUS_O, IBUS_parenright, 0x24C4, +IBUS_parenleft, IBUS_P, IBUS_parenright, 0x24C5, +IBUS_parenleft, IBUS_Q, IBUS_parenright, 0x24C6, +IBUS_parenleft, IBUS_R, IBUS_parenright, 0x24C7, +IBUS_parenleft, IBUS_S, IBUS_parenright, 0x24C8, +IBUS_parenleft, IBUS_T, IBUS_parenright, 0x24C9, +IBUS_parenleft, IBUS_U, IBUS_parenright, 0x24CA, +IBUS_parenleft, IBUS_V, IBUS_parenright, 0x24CB, +IBUS_parenleft, IBUS_W, IBUS_parenright, 0x24CC, +IBUS_parenleft, IBUS_X, IBUS_parenright, 0x24CD, +IBUS_parenleft, IBUS_Y, IBUS_parenright, 0x24CE, +IBUS_parenleft, IBUS_Z, IBUS_parenright, 0x24CF, +IBUS_parenleft, IBUS_a, IBUS_parenright, 0x24D0, +IBUS_parenleft, IBUS_b, IBUS_parenright, 0x24D1, +IBUS_parenleft, IBUS_c, IBUS_parenright, 0x24D2, +IBUS_parenleft, IBUS_d, IBUS_parenright, 0x24D3, +IBUS_parenleft, IBUS_e, IBUS_parenright, 0x24D4, +IBUS_parenleft, IBUS_f, IBUS_parenright, 0x24D5, +IBUS_parenleft, IBUS_g, IBUS_parenright, 0x24D6, +IBUS_parenleft, IBUS_h, IBUS_parenright, 0x24D7, +IBUS_parenleft, IBUS_i, IBUS_parenright, 0x24D8, +IBUS_parenleft, IBUS_j, IBUS_parenright, 0x24D9, +IBUS_parenleft, IBUS_k, IBUS_parenright, 0x24DA, +IBUS_parenleft, IBUS_l, IBUS_parenright, 0x24DB, +IBUS_parenleft, IBUS_m, IBUS_parenright, 0x24DC, +IBUS_parenleft, IBUS_n, IBUS_parenright, 0x24DD, +IBUS_parenleft, IBUS_o, IBUS_parenright, 0x24DE, +IBUS_parenleft, IBUS_p, IBUS_parenright, 0x24DF, +IBUS_parenleft, IBUS_q, IBUS_parenright, 0x24E0, +IBUS_parenleft, IBUS_r, IBUS_parenright, 0x24E1, +IBUS_parenleft, IBUS_s, IBUS_parenright, 0x24E2, +IBUS_parenleft, IBUS_t, IBUS_parenright, 0x24E3, +IBUS_parenleft, IBUS_u, IBUS_parenright, 0x24E4, +IBUS_parenleft, IBUS_v, IBUS_parenright, 0x24E5, +IBUS_parenleft, IBUS_w, IBUS_parenright, 0x24E6, +IBUS_parenleft, IBUS_x, IBUS_parenright, 0x24E7, +IBUS_parenleft, IBUS_y, IBUS_parenright, 0x24E8, +IBUS_parenleft, IBUS_z, IBUS_parenright, 0x24E9, +IBUS_parenleft, IBUS_kana_WO, IBUS_parenright, 0x32FE, +IBUS_parenleft, IBUS_kana_A, IBUS_parenright, 0x32D0, +IBUS_parenleft, IBUS_kana_I, IBUS_parenright, 0x32D1, +IBUS_parenleft, IBUS_kana_U, IBUS_parenright, 0x32D2, +IBUS_parenleft, IBUS_kana_E, IBUS_parenright, 0x32D3, +IBUS_parenleft, IBUS_kana_O, IBUS_parenright, 0x32D4, +IBUS_parenleft, IBUS_kana_KA, IBUS_parenright, 0x32D5, +IBUS_parenleft, IBUS_kana_KI, IBUS_parenright, 0x32D6, +IBUS_parenleft, IBUS_kana_KU, IBUS_parenright, 0x32D7, +IBUS_parenleft, IBUS_kana_KE, IBUS_parenright, 0x32D8, +IBUS_parenleft, IBUS_kana_KO, IBUS_parenright, 0x32D9, +IBUS_parenleft, IBUS_kana_SA, IBUS_parenright, 0x32DA, +IBUS_parenleft, IBUS_kana_SHI, IBUS_parenright, 0x32DB, +IBUS_parenleft, IBUS_kana_SU, IBUS_parenright, 0x32DC, +IBUS_parenleft, IBUS_kana_SE, IBUS_parenright, 0x32DD, +IBUS_parenleft, IBUS_kana_SO, IBUS_parenright, 0x32DE, +IBUS_parenleft, IBUS_kana_TA, IBUS_parenright, 0x32DF, +IBUS_parenleft, IBUS_kana_CHI, IBUS_parenright, 0x32E0, +IBUS_parenleft, IBUS_kana_TSU, IBUS_parenright, 0x32E1, +IBUS_parenleft, IBUS_kana_TE, IBUS_parenright, 0x32E2, +IBUS_parenleft, IBUS_kana_TO, IBUS_parenright, 0x32E3, +IBUS_parenleft, IBUS_kana_NA, IBUS_parenright, 0x32E4, +IBUS_parenleft, IBUS_kana_NI, IBUS_parenright, 0x32E5, +IBUS_parenleft, IBUS_kana_NU, IBUS_parenright, 0x32E6, +IBUS_parenleft, IBUS_kana_NE, IBUS_parenright, 0x32E7, +IBUS_parenleft, IBUS_kana_NO, IBUS_parenright, 0x32E8, +IBUS_parenleft, IBUS_kana_HA, IBUS_parenright, 0x32E9, +IBUS_parenleft, IBUS_kana_HI, IBUS_parenright, 0x32EA, +IBUS_parenleft, IBUS_kana_FU, IBUS_parenright, 0x32EB, +IBUS_parenleft, IBUS_kana_HE, IBUS_parenright, 0x32EC, +IBUS_parenleft, IBUS_kana_HO, IBUS_parenright, 0x32ED, +IBUS_parenleft, IBUS_kana_MA, IBUS_parenright, 0x32EE, +IBUS_parenleft, IBUS_kana_MI, IBUS_parenright, 0x32EF, +IBUS_parenleft, IBUS_kana_MU, IBUS_parenright, 0x32F0, +IBUS_parenleft, IBUS_kana_ME, IBUS_parenright, 0x32F1, +IBUS_parenleft, IBUS_kana_MO, IBUS_parenright, 0x32F2, +IBUS_parenleft, IBUS_kana_YA, IBUS_parenright, 0x32F3, +IBUS_parenleft, IBUS_kana_YU, IBUS_parenright, 0x32F4, +IBUS_parenleft, IBUS_kana_YO, IBUS_parenright, 0x32F5, +IBUS_parenleft, IBUS_kana_RA, IBUS_parenright, 0x32F6, +IBUS_parenleft, IBUS_kana_RI, IBUS_parenright, 0x32F7, +IBUS_parenleft, IBUS_kana_RU, IBUS_parenright, 0x32F8, +IBUS_parenleft, IBUS_kana_RE, IBUS_parenright, 0x32F9, +IBUS_parenleft, IBUS_kana_RO, IBUS_parenright, 0x32FA, +IBUS_parenleft, IBUS_kana_WA, IBUS_parenright, 0x32FB, +IBUS_parenleft, 0x1100, IBUS_parenright, 0x3260, +IBUS_parenleft, 0x1102, IBUS_parenright, 0x3261, +IBUS_parenleft, 0x1103, IBUS_parenright, 0x3262, +IBUS_parenleft, 0x1105, IBUS_parenright, 0x3263, +IBUS_parenleft, 0x1106, IBUS_parenright, 0x3264, +IBUS_parenleft, 0x1107, IBUS_parenright, 0x3265, +IBUS_parenleft, 0x1109, IBUS_parenright, 0x3266, +IBUS_parenleft, 0x110B, IBUS_parenright, 0x3267, +IBUS_parenleft, 0x110C, IBUS_parenright, 0x3268, +IBUS_parenleft, 0x110E, IBUS_parenright, 0x3269, +IBUS_parenleft, 0x110F, IBUS_parenright, 0x326A, +IBUS_parenleft, 0x1110, IBUS_parenright, 0x326B, +IBUS_parenleft, 0x1111, IBUS_parenright, 0x326C, +IBUS_parenleft, 0x1112, IBUS_parenright, 0x326D, +IBUS_parenleft, 0x30F0, IBUS_parenright, 0x32FC, +IBUS_parenleft, 0x30F1, IBUS_parenright, 0x32FD, +IBUS_parenleft, 0x4E00, IBUS_parenright, 0x3280, +IBUS_parenleft, 0x4E03, IBUS_parenright, 0x3286, +IBUS_parenleft, 0x4E09, IBUS_parenright, 0x3282, +IBUS_parenleft, 0x4E0A, IBUS_parenright, 0x32A4, +IBUS_parenleft, 0x4E0B, IBUS_parenright, 0x32A6, +IBUS_parenleft, 0x4E2D, IBUS_parenright, 0x32A5, +IBUS_parenleft, 0x4E5D, IBUS_parenright, 0x3288, +IBUS_parenleft, 0x4E8C, IBUS_parenright, 0x3281, +IBUS_parenleft, 0x4E94, IBUS_parenright, 0x3284, +IBUS_parenleft, 0x4F01, IBUS_parenright, 0x32AD, +IBUS_parenleft, 0x4F11, IBUS_parenright, 0x32A1, +IBUS_parenleft, 0x512A, IBUS_parenright, 0x329D, +IBUS_parenleft, 0x516B, IBUS_parenright, 0x3287, +IBUS_parenleft, 0x516D, IBUS_parenright, 0x3285, +IBUS_parenleft, 0x5199, IBUS_parenright, 0x32A2, +IBUS_parenleft, 0x52B4, IBUS_parenright, 0x3298, +IBUS_parenleft, 0x533B, IBUS_parenright, 0x32A9, +IBUS_parenleft, 0x5341, IBUS_parenright, 0x3289, +IBUS_parenleft, 0x5354, IBUS_parenright, 0x32AF, +IBUS_parenleft, 0x5370, IBUS_parenright, 0x329E, +IBUS_parenleft, 0x53F3, IBUS_parenright, 0x32A8, +IBUS_parenleft, 0x540D, IBUS_parenright, 0x3294, +IBUS_parenleft, 0x56DB, IBUS_parenright, 0x3283, +IBUS_parenleft, 0x571F, IBUS_parenright, 0x328F, +IBUS_parenleft, 0x591C, IBUS_parenright, 0x32B0, +IBUS_parenleft, 0x5973, IBUS_parenright, 0x329B, +IBUS_parenleft, 0x5B66, IBUS_parenright, 0x32AB, +IBUS_parenleft, 0x5B97, IBUS_parenright, 0x32AA, +IBUS_parenleft, 0x5DE6, IBUS_parenright, 0x32A7, +IBUS_parenleft, 0x65E5, IBUS_parenright, 0x3290, +IBUS_parenleft, 0x6708, IBUS_parenright, 0x328A, +IBUS_parenleft, 0x6709, IBUS_parenright, 0x3292, +IBUS_parenleft, 0x6728, IBUS_parenright, 0x328D, +IBUS_parenleft, 0x682A, IBUS_parenright, 0x3291, +IBUS_parenleft, 0x6B63, IBUS_parenright, 0x32A3, +IBUS_parenleft, 0x6C34, IBUS_parenright, 0x328C, +IBUS_parenleft, 0x6CE8, IBUS_parenright, 0x329F, +IBUS_parenleft, 0x706B, IBUS_parenright, 0x328B, +IBUS_parenleft, 0x7279, IBUS_parenright, 0x3295, +IBUS_parenleft, 0x7537, IBUS_parenright, 0x329A, +IBUS_parenleft, 0x76E3, IBUS_parenright, 0x32AC, +IBUS_parenleft, 0x793E, IBUS_parenright, 0x3293, +IBUS_parenleft, 0x795D, IBUS_parenright, 0x3297, +IBUS_parenleft, 0x79D8, IBUS_parenright, 0x3299, +IBUS_parenleft, 0x8CA1, IBUS_parenright, 0x3296, +IBUS_parenleft, 0x8CC7, IBUS_parenright, 0x32AE, +IBUS_parenleft, 0x9069, IBUS_parenright, 0x329C, +IBUS_parenleft, 0x91D1, IBUS_parenright, 0x328E, +IBUS_parenleft, 0x9805, IBUS_parenright, 0x32A0, +IBUS_parenleft, IBUS_KP_Space, IBUS_parenright, 0x2461, +IBUS_parenleft, IBUS_KP_0, IBUS_parenright, 0x24EA, +IBUS_parenleft, IBUS_KP_1, IBUS_parenright, 0x2460, +IBUS_parenleft, IBUS_KP_2, IBUS_parenright, 0x2461, +IBUS_parenleft, IBUS_KP_3, IBUS_parenright, 0x2462, +IBUS_parenleft, IBUS_KP_4, IBUS_parenright, 0x2463, +IBUS_parenleft, IBUS_KP_5, IBUS_parenright, 0x2464, +IBUS_parenleft, IBUS_KP_6, IBUS_parenright, 0x2465, +IBUS_parenleft, IBUS_KP_7, IBUS_parenright, 0x2466, +IBUS_parenleft, IBUS_KP_8, IBUS_parenright, 0x2467, +IBUS_parenleft, IBUS_KP_9, IBUS_parenright, 0x2468, +IBUS_minus, IBUS_minus, IBUS_space, 0x00AD, +IBUS_minus, IBUS_minus, IBUS_minus, 0x2014, +IBUS_minus, IBUS_minus, IBUS_period, 0x2013, +IBUS_period, IBUS_exclam, IBUS_S, 0x1E68, +IBUS_period, IBUS_exclam, IBUS_s, 0x1E69, +IBUS_period, IBUS_apostrophe, IBUS_S, 0x1E64, +IBUS_period, IBUS_apostrophe, IBUS_s, 0x1E65, +IBUS_period, IBUS_acute, IBUS_S, 0x1E64, +IBUS_period, IBUS_acute, IBUS_s, 0x1E65, +IBUS_period, IBUS_dead_acute, IBUS_S, 0x1E64, +IBUS_period, IBUS_dead_acute, IBUS_s, 0x1E65, +IBUS_period, IBUS_dead_caron, IBUS_S, 0x1E66, +IBUS_period, IBUS_dead_caron, IBUS_s, 0x1E67, +IBUS_period, IBUS_dead_belowdot, IBUS_S, 0x1E68, +IBUS_period, IBUS_dead_belowdot, IBUS_s, 0x1E69, +IBUS_question, IBUS_plus, IBUS_O, 0x1EDE, +IBUS_question, IBUS_plus, IBUS_U, 0x1EEC, +IBUS_question, IBUS_plus, IBUS_o, 0x1EDF, +IBUS_question, IBUS_plus, IBUS_u, 0x1EED, +IBUS_question, IBUS_asciicircum, IBUS_A, 0x1EA8, +IBUS_question, IBUS_asciicircum, IBUS_E, 0x1EC2, +IBUS_question, IBUS_asciicircum, IBUS_O, 0x1ED4, +IBUS_question, IBUS_asciicircum, IBUS_a, 0x1EA9, +IBUS_question, IBUS_asciicircum, IBUS_e, 0x1EC3, +IBUS_question, IBUS_asciicircum, IBUS_o, 0x1ED5, +IBUS_question, IBUS_b, IBUS_A, 0x1EB2, +IBUS_question, IBUS_b, IBUS_a, 0x1EB3, +IBUS_question, IBUS_dead_circumflex, IBUS_A, 0x1EA8, +IBUS_question, IBUS_dead_circumflex, IBUS_E, 0x1EC2, +IBUS_question, IBUS_dead_circumflex, IBUS_O, 0x1ED4, +IBUS_question, IBUS_dead_circumflex, IBUS_a, 0x1EA9, +IBUS_question, IBUS_dead_circumflex, IBUS_e, 0x1EC3, +IBUS_question, IBUS_dead_circumflex, IBUS_o, 0x1ED5, +IBUS_question, IBUS_dead_breve, IBUS_A, 0x1EB2, +IBUS_question, IBUS_dead_breve, IBUS_a, 0x1EB3, +IBUS_question, IBUS_dead_horn, IBUS_O, 0x1EDE, +IBUS_question, IBUS_dead_horn, IBUS_U, 0x1EEC, +IBUS_question, IBUS_dead_horn, IBUS_o, 0x1EDF, +IBUS_question, IBUS_dead_horn, IBUS_u, 0x1EED, +IBUS_U, IBUS_exclam, IBUS_A, 0x1EB6, +IBUS_U, IBUS_exclam, IBUS_a, 0x1EB7, +IBUS_U, IBUS_comma, IBUS_E, 0x1E1C, +IBUS_U, IBUS_comma, IBUS_e, 0x1E1D, +IBUS_U, IBUS_cedilla, IBUS_E, 0x1E1C, +IBUS_U, IBUS_cedilla, IBUS_e, 0x1E1D, +IBUS_U, IBUS_dead_cedilla, IBUS_E, 0x1E1C, +IBUS_U, IBUS_dead_cedilla, IBUS_e, 0x1E1D, +IBUS_U, IBUS_dead_belowdot, IBUS_A, 0x1EB6, +IBUS_U, IBUS_dead_belowdot, IBUS_a, 0x1EB7, +IBUS_asciicircum, IBUS_exclam, IBUS_A, 0x1EAC, +IBUS_asciicircum, IBUS_exclam, IBUS_E, 0x1EC6, +IBUS_asciicircum, IBUS_exclam, IBUS_O, 0x1ED8, +IBUS_asciicircum, IBUS_exclam, IBUS_a, 0x1EAD, +IBUS_asciicircum, IBUS_exclam, IBUS_e, 0x1EC7, +IBUS_asciicircum, IBUS_exclam, IBUS_o, 0x1ED9, +IBUS_asciicircum, IBUS_underscore, IBUS_a, 0x00AA, +IBUS_asciicircum, IBUS_underscore, IBUS_h, 0x02B0, +IBUS_asciicircum, IBUS_underscore, IBUS_i, 0x2071, +IBUS_asciicircum, IBUS_underscore, IBUS_j, 0x02B2, +IBUS_asciicircum, IBUS_underscore, IBUS_l, 0x02E1, +IBUS_asciicircum, IBUS_underscore, IBUS_n, 0x207F, +IBUS_asciicircum, IBUS_underscore, IBUS_o, 0x00BA, +IBUS_asciicircum, IBUS_underscore, IBUS_r, 0x02B3, +IBUS_asciicircum, IBUS_underscore, IBUS_s, 0x02E2, +IBUS_asciicircum, IBUS_underscore, IBUS_w, 0x02B7, +IBUS_asciicircum, IBUS_underscore, IBUS_x, 0x02E3, +IBUS_asciicircum, IBUS_underscore, IBUS_y, 0x02B8, +IBUS_asciicircum, IBUS_underscore, 0x0263, 0x02E0, +IBUS_asciicircum, IBUS_underscore, 0x0266, 0x02B1, +IBUS_asciicircum, IBUS_underscore, 0x0279, 0x02B4, +IBUS_asciicircum, IBUS_underscore, 0x027B, 0x02B5, +IBUS_asciicircum, IBUS_underscore, 0x0281, 0x02B6, +IBUS_asciicircum, IBUS_underscore, 0x0295, 0x02E4, +IBUS_asciicircum, IBUS_underbar, IBUS_a, 0x00AA, +IBUS_asciicircum, IBUS_underbar, IBUS_h, 0x02B0, +IBUS_asciicircum, IBUS_underbar, IBUS_i, 0x2071, +IBUS_asciicircum, IBUS_underbar, IBUS_j, 0x02B2, +IBUS_asciicircum, IBUS_underbar, IBUS_l, 0x02E1, +IBUS_asciicircum, IBUS_underbar, IBUS_n, 0x207F, +IBUS_asciicircum, IBUS_underbar, IBUS_o, 0x00BA, +IBUS_asciicircum, IBUS_underbar, IBUS_r, 0x02B3, +IBUS_asciicircum, IBUS_underbar, IBUS_s, 0x02E2, +IBUS_asciicircum, IBUS_underbar, IBUS_w, 0x02B7, +IBUS_asciicircum, IBUS_underbar, IBUS_x, 0x02E3, +IBUS_asciicircum, IBUS_underbar, IBUS_y, 0x02B8, +IBUS_asciicircum, IBUS_underbar, 0x0263, 0x02E0, +IBUS_asciicircum, IBUS_underbar, 0x0266, 0x02B1, +IBUS_asciicircum, IBUS_underbar, 0x0279, 0x02B4, +IBUS_asciicircum, IBUS_underbar, 0x027B, 0x02B5, +IBUS_asciicircum, IBUS_underbar, 0x0281, 0x02B6, +IBUS_asciicircum, IBUS_underbar, 0x0295, 0x02E4, +IBUS_asciicircum, IBUS_dead_belowdot, IBUS_A, 0x1EAC, +IBUS_asciicircum, IBUS_dead_belowdot, IBUS_E, 0x1EC6, +IBUS_asciicircum, IBUS_dead_belowdot, IBUS_O, 0x1ED8, +IBUS_asciicircum, IBUS_dead_belowdot, IBUS_a, 0x1EAD, +IBUS_asciicircum, IBUS_dead_belowdot, IBUS_e, 0x1EC7, +IBUS_asciicircum, IBUS_dead_belowdot, IBUS_o, 0x1ED9, +IBUS_underscore, IBUS_exclam, IBUS_L, 0x1E38, +IBUS_underscore, IBUS_exclam, IBUS_R, 0x1E5C, +IBUS_underscore, IBUS_exclam, IBUS_l, 0x1E39, +IBUS_underscore, IBUS_exclam, IBUS_r, 0x1E5D, +IBUS_underscore, IBUS_quotedbl, IBUS_A, 0x01DE, +IBUS_underscore, IBUS_quotedbl, IBUS_O, 0x022A, +IBUS_underscore, IBUS_quotedbl, IBUS_U, 0x01D5, +IBUS_underscore, IBUS_quotedbl, IBUS_a, 0x01DF, +IBUS_underscore, IBUS_quotedbl, IBUS_o, 0x022B, +IBUS_underscore, IBUS_quotedbl, IBUS_u, 0x01D6, +IBUS_underscore, IBUS_period, IBUS_A, 0x01E0, +IBUS_underscore, IBUS_period, IBUS_O, 0x0230, +IBUS_underscore, IBUS_period, IBUS_a, 0x01E1, +IBUS_underscore, IBUS_period, IBUS_o, 0x0231, +IBUS_underscore, IBUS_semicolon, IBUS_O, 0x01EC, +IBUS_underscore, IBUS_semicolon, IBUS_o, 0x01ED, +IBUS_underscore, IBUS_asciitilde, IBUS_O, 0x022C, +IBUS_underscore, IBUS_asciitilde, IBUS_o, 0x022D, +IBUS_underscore, IBUS_dead_tilde, IBUS_O, 0x022C, +IBUS_underscore, IBUS_dead_tilde, IBUS_o, 0x022D, +IBUS_underscore, IBUS_dead_abovedot, IBUS_A, 0x01E0, +IBUS_underscore, IBUS_dead_abovedot, IBUS_O, 0x0230, +IBUS_underscore, IBUS_dead_abovedot, IBUS_a, 0x01E1, +IBUS_underscore, IBUS_dead_abovedot, IBUS_o, 0x0231, +IBUS_underscore, IBUS_dead_diaeresis, IBUS_A, 0x01DE, +IBUS_underscore, IBUS_dead_diaeresis, IBUS_O, 0x022A, +IBUS_underscore, IBUS_dead_diaeresis, IBUS_U, 0x01D5, +IBUS_underscore, IBUS_dead_diaeresis, IBUS_a, 0x01DF, +IBUS_underscore, IBUS_dead_diaeresis, IBUS_o, 0x022B, +IBUS_underscore, IBUS_dead_diaeresis, IBUS_u, 0x01D6, +IBUS_underscore, IBUS_dead_ogonek, IBUS_O, 0x01EC, +IBUS_underscore, IBUS_dead_ogonek, IBUS_o, 0x01ED, +IBUS_underscore, IBUS_dead_belowdot, IBUS_L, 0x1E38, +IBUS_underscore, IBUS_dead_belowdot, IBUS_R, 0x1E5C, +IBUS_underscore, IBUS_dead_belowdot, IBUS_l, 0x1E39, +IBUS_underscore, IBUS_dead_belowdot, IBUS_r, 0x1E5D, +IBUS_grave, IBUS_quotedbl, IBUS_U, 0x01DB, +IBUS_grave, IBUS_quotedbl, IBUS_u, 0x01DC, +IBUS_grave, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD2, +IBUS_grave, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE2, +IBUS_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0B, +IBUS_grave, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1B, +IBUS_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2B, +IBUS_grave, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3B, +IBUS_grave, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4B, +IBUS_grave, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5B, +IBUS_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6B, +IBUS_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F03, +IBUS_grave, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F13, +IBUS_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F23, +IBUS_grave, IBUS_parenleft, IBUS_Greek_iota, 0x1F33, +IBUS_grave, IBUS_parenleft, IBUS_Greek_omicron, 0x1F43, +IBUS_grave, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F53, +IBUS_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1F63, +IBUS_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0A, +IBUS_grave, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1A, +IBUS_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F2A, +IBUS_grave, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3A, +IBUS_grave, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4A, +IBUS_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6A, +IBUS_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F02, +IBUS_grave, IBUS_parenright, IBUS_Greek_epsilon, 0x1F12, +IBUS_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F22, +IBUS_grave, IBUS_parenright, IBUS_Greek_iota, 0x1F32, +IBUS_grave, IBUS_parenright, IBUS_Greek_omicron, 0x1F42, +IBUS_grave, IBUS_parenright, IBUS_Greek_upsilon, 0x1F52, +IBUS_grave, IBUS_parenright, IBUS_Greek_omega, 0x1F62, +IBUS_grave, IBUS_plus, IBUS_O, 0x1EDC, +IBUS_grave, IBUS_plus, IBUS_U, 0x1EEA, +IBUS_grave, IBUS_plus, IBUS_o, 0x1EDD, +IBUS_grave, IBUS_plus, IBUS_u, 0x1EEB, +IBUS_grave, IBUS_asciicircum, IBUS_A, 0x1EA6, +IBUS_grave, IBUS_asciicircum, IBUS_E, 0x1EC0, +IBUS_grave, IBUS_asciicircum, IBUS_O, 0x1ED2, +IBUS_grave, IBUS_asciicircum, IBUS_a, 0x1EA7, +IBUS_grave, IBUS_asciicircum, IBUS_e, 0x1EC1, +IBUS_grave, IBUS_asciicircum, IBUS_o, 0x1ED3, +IBUS_grave, IBUS_underscore, IBUS_E, 0x1E14, +IBUS_grave, IBUS_underscore, IBUS_O, 0x1E50, +IBUS_grave, IBUS_underscore, IBUS_e, 0x1E15, +IBUS_grave, IBUS_underscore, IBUS_o, 0x1E51, +IBUS_grave, IBUS_b, IBUS_A, 0x1EB0, +IBUS_grave, IBUS_b, IBUS_a, 0x1EB1, +IBUS_grave, IBUS_macron, IBUS_E, 0x1E14, +IBUS_grave, IBUS_macron, IBUS_O, 0x1E50, +IBUS_grave, IBUS_macron, IBUS_e, 0x1E15, +IBUS_grave, IBUS_macron, IBUS_o, 0x1E51, +IBUS_grave, IBUS_dead_circumflex, IBUS_A, 0x1EA6, +IBUS_grave, IBUS_dead_circumflex, IBUS_E, 0x1EC0, +IBUS_grave, IBUS_dead_circumflex, IBUS_O, 0x1ED2, +IBUS_grave, IBUS_dead_circumflex, IBUS_a, 0x1EA7, +IBUS_grave, IBUS_dead_circumflex, IBUS_e, 0x1EC1, +IBUS_grave, IBUS_dead_circumflex, IBUS_o, 0x1ED3, +IBUS_grave, IBUS_dead_macron, IBUS_E, 0x1E14, +IBUS_grave, IBUS_dead_macron, IBUS_O, 0x1E50, +IBUS_grave, IBUS_dead_macron, IBUS_e, 0x1E15, +IBUS_grave, IBUS_dead_macron, IBUS_o, 0x1E51, +IBUS_grave, IBUS_dead_breve, IBUS_A, 0x1EB0, +IBUS_grave, IBUS_dead_breve, IBUS_a, 0x1EB1, +IBUS_grave, IBUS_dead_diaeresis, IBUS_U, 0x01DB, +IBUS_grave, IBUS_dead_diaeresis, IBUS_u, 0x01DC, +IBUS_grave, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD2, +IBUS_grave, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE2, +IBUS_grave, IBUS_dead_horn, IBUS_O, 0x1EDC, +IBUS_grave, IBUS_dead_horn, IBUS_U, 0x1EEA, +IBUS_grave, IBUS_dead_horn, IBUS_o, 0x1EDD, +IBUS_grave, IBUS_dead_horn, IBUS_u, 0x1EEB, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0A, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1A, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2A, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3A, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4A, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6A, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F02, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F12, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F22, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_iota, 0x1F32, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_omicron, 0x1F42, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F52, +IBUS_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1F62, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0B, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1B, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2B, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3B, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4B, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5B, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6B, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F03, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F13, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F23, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F33, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F43, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F53, +IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F63, +IBUS_b, IBUS_exclam, IBUS_A, 0x1EB6, +IBUS_b, IBUS_exclam, IBUS_a, 0x1EB7, +IBUS_b, IBUS_comma, IBUS_E, 0x1E1C, +IBUS_b, IBUS_comma, IBUS_e, 0x1E1D, +IBUS_b, IBUS_cedilla, IBUS_E, 0x1E1C, +IBUS_b, IBUS_cedilla, IBUS_e, 0x1E1D, +IBUS_b, IBUS_dead_cedilla, IBUS_E, 0x1E1C, +IBUS_b, IBUS_dead_cedilla, IBUS_e, 0x1E1D, +IBUS_b, IBUS_dead_belowdot, IBUS_A, 0x1EB6, +IBUS_b, IBUS_dead_belowdot, IBUS_a, 0x1EB7, +IBUS_c, IBUS_quotedbl, IBUS_U, 0x01D9, +IBUS_c, IBUS_quotedbl, IBUS_u, 0x01DA, +IBUS_c, IBUS_dead_diaeresis, IBUS_U, 0x01D9, +IBUS_c, IBUS_dead_diaeresis, IBUS_u, 0x01DA, +IBUS_o, IBUS_apostrophe, IBUS_A, 0x01FA, +IBUS_o, IBUS_apostrophe, IBUS_a, 0x01FB, +IBUS_asciitilde, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD7, +IBUS_asciitilde, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE7, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0F, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2F, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3F, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5F, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6F, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F07, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F27, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_iota, 0x1F37, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F57, +IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_omega, 0x1F67, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0E, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F2E, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3E, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6E, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F06, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_eta, 0x1F26, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_iota, 0x1F36, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_upsilon, 0x1F56, +IBUS_asciitilde, IBUS_parenright, IBUS_Greek_omega, 0x1F66, +IBUS_asciitilde, IBUS_plus, IBUS_O, 0x1EE0, +IBUS_asciitilde, IBUS_plus, IBUS_U, 0x1EEE, +IBUS_asciitilde, IBUS_plus, IBUS_o, 0x1EE1, +IBUS_asciitilde, IBUS_plus, IBUS_u, 0x1EEF, +IBUS_asciitilde, IBUS_asciicircum, IBUS_A, 0x1EAA, +IBUS_asciitilde, IBUS_asciicircum, IBUS_E, 0x1EC4, +IBUS_asciitilde, IBUS_asciicircum, IBUS_O, 0x1ED6, +IBUS_asciitilde, IBUS_asciicircum, IBUS_a, 0x1EAB, +IBUS_asciitilde, IBUS_asciicircum, IBUS_e, 0x1EC5, +IBUS_asciitilde, IBUS_asciicircum, IBUS_o, 0x1ED7, +IBUS_asciitilde, IBUS_b, IBUS_A, 0x1EB4, +IBUS_asciitilde, IBUS_b, IBUS_a, 0x1EB5, +IBUS_asciitilde, IBUS_dead_circumflex, IBUS_A, 0x1EAA, +IBUS_asciitilde, IBUS_dead_circumflex, IBUS_E, 0x1EC4, +IBUS_asciitilde, IBUS_dead_circumflex, IBUS_O, 0x1ED6, +IBUS_asciitilde, IBUS_dead_circumflex, IBUS_a, 0x1EAB, +IBUS_asciitilde, IBUS_dead_circumflex, IBUS_e, 0x1EC5, +IBUS_asciitilde, IBUS_dead_circumflex, IBUS_o, 0x1ED7, +IBUS_asciitilde, IBUS_dead_breve, IBUS_A, 0x1EB4, +IBUS_asciitilde, IBUS_dead_breve, IBUS_a, 0x1EB5, +IBUS_asciitilde, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD7, +IBUS_asciitilde, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE7, +IBUS_asciitilde, IBUS_dead_horn, IBUS_O, 0x1EE0, +IBUS_asciitilde, IBUS_dead_horn, IBUS_U, 0x1EEE, +IBUS_asciitilde, IBUS_dead_horn, IBUS_o, 0x1EE1, +IBUS_asciitilde, IBUS_dead_horn, IBUS_u, 0x1EEF, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0E, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2E, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3E, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6E, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F06, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F26, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_iota, 0x1F36, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F56, +IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1F66, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0F, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2F, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3F, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5F, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6F, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F07, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F27, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F37, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F57, +IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F67, +IBUS_macron, IBUS_exclam, IBUS_L, 0x1E38, +IBUS_macron, IBUS_exclam, IBUS_R, 0x1E5C, +IBUS_macron, IBUS_exclam, IBUS_l, 0x1E39, +IBUS_macron, IBUS_exclam, IBUS_r, 0x1E5D, +IBUS_macron, IBUS_quotedbl, IBUS_A, 0x01DE, +IBUS_macron, IBUS_quotedbl, IBUS_O, 0x022A, +IBUS_macron, IBUS_quotedbl, IBUS_U, 0x01D5, +IBUS_macron, IBUS_quotedbl, IBUS_a, 0x01DF, +IBUS_macron, IBUS_quotedbl, IBUS_o, 0x022B, +IBUS_macron, IBUS_quotedbl, IBUS_u, 0x01D6, +IBUS_macron, IBUS_period, IBUS_A, 0x01E0, +IBUS_macron, IBUS_period, IBUS_O, 0x0230, +IBUS_macron, IBUS_period, IBUS_a, 0x01E1, +IBUS_macron, IBUS_period, IBUS_o, 0x0231, +IBUS_macron, IBUS_semicolon, IBUS_O, 0x01EC, +IBUS_macron, IBUS_semicolon, IBUS_o, 0x01ED, +IBUS_macron, IBUS_asciitilde, IBUS_O, 0x022C, +IBUS_macron, IBUS_asciitilde, IBUS_o, 0x022D, +IBUS_macron, IBUS_dead_tilde, IBUS_O, 0x022C, +IBUS_macron, IBUS_dead_tilde, IBUS_o, 0x022D, +IBUS_macron, IBUS_dead_abovedot, IBUS_A, 0x01E0, +IBUS_macron, IBUS_dead_abovedot, IBUS_O, 0x0230, +IBUS_macron, IBUS_dead_abovedot, IBUS_a, 0x01E1, +IBUS_macron, IBUS_dead_abovedot, IBUS_o, 0x0231, +IBUS_macron, IBUS_dead_diaeresis, IBUS_A, 0x01DE, +IBUS_macron, IBUS_dead_diaeresis, IBUS_O, 0x022A, +IBUS_macron, IBUS_dead_diaeresis, IBUS_U, 0x01D5, +IBUS_macron, IBUS_dead_diaeresis, IBUS_a, 0x01DF, +IBUS_macron, IBUS_dead_diaeresis, IBUS_o, 0x022B, +IBUS_macron, IBUS_dead_diaeresis, IBUS_u, 0x01D6, +IBUS_macron, IBUS_dead_ogonek, IBUS_O, 0x01EC, +IBUS_macron, IBUS_dead_ogonek, IBUS_o, 0x01ED, +IBUS_macron, IBUS_dead_belowdot, IBUS_L, 0x1E38, +IBUS_macron, IBUS_dead_belowdot, IBUS_R, 0x1E5C, +IBUS_macron, IBUS_dead_belowdot, IBUS_l, 0x1E39, +IBUS_macron, IBUS_dead_belowdot, IBUS_r, 0x1E5D, +IBUS_acute, IBUS_quotedbl, IBUS_I, 0x1E2E, +IBUS_acute, IBUS_quotedbl, IBUS_U, 0x01D7, +IBUS_acute, IBUS_quotedbl, IBUS_i, 0x1E2F, +IBUS_acute, IBUS_quotedbl, IBUS_u, 0x01D8, +IBUS_acute, IBUS_quotedbl, IBUS_Greek_iota, 0x0390, +IBUS_acute, IBUS_quotedbl, IBUS_Greek_upsilon, 0x03B0, +IBUS_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0D, +IBUS_acute, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1D, +IBUS_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2D, +IBUS_acute, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3D, +IBUS_acute, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4D, +IBUS_acute, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5D, +IBUS_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6D, +IBUS_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F05, +IBUS_acute, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F15, +IBUS_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F25, +IBUS_acute, IBUS_parenleft, IBUS_Greek_iota, 0x1F35, +IBUS_acute, IBUS_parenleft, IBUS_Greek_omicron, 0x1F45, +IBUS_acute, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F55, +IBUS_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1F65, +IBUS_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0C, +IBUS_acute, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1C, +IBUS_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F2C, +IBUS_acute, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3C, +IBUS_acute, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4C, +IBUS_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6C, +IBUS_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F04, +IBUS_acute, IBUS_parenright, IBUS_Greek_epsilon, 0x1F14, +IBUS_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F24, +IBUS_acute, IBUS_parenright, IBUS_Greek_iota, 0x1F34, +IBUS_acute, IBUS_parenright, IBUS_Greek_omicron, 0x1F44, +IBUS_acute, IBUS_parenright, IBUS_Greek_upsilon, 0x1F54, +IBUS_acute, IBUS_parenright, IBUS_Greek_omega, 0x1F64, +IBUS_acute, IBUS_plus, IBUS_O, 0x1EDA, +IBUS_acute, IBUS_plus, IBUS_U, 0x1EE8, +IBUS_acute, IBUS_plus, IBUS_o, 0x1EDB, +IBUS_acute, IBUS_plus, IBUS_u, 0x1EE9, +IBUS_acute, IBUS_comma, IBUS_C, 0x1E08, +IBUS_acute, IBUS_comma, IBUS_c, 0x1E09, +IBUS_acute, IBUS_slash, IBUS_O, 0x01FE, +IBUS_acute, IBUS_slash, IBUS_o, 0x01FF, +IBUS_acute, IBUS_asciicircum, IBUS_A, 0x1EA4, +IBUS_acute, IBUS_asciicircum, IBUS_E, 0x1EBE, +IBUS_acute, IBUS_asciicircum, IBUS_O, 0x1ED0, +IBUS_acute, IBUS_asciicircum, IBUS_a, 0x1EA5, +IBUS_acute, IBUS_asciicircum, IBUS_e, 0x1EBF, +IBUS_acute, IBUS_asciicircum, IBUS_o, 0x1ED1, +IBUS_acute, IBUS_underscore, IBUS_E, 0x1E16, +IBUS_acute, IBUS_underscore, IBUS_O, 0x1E52, +IBUS_acute, IBUS_underscore, IBUS_e, 0x1E17, +IBUS_acute, IBUS_underscore, IBUS_o, 0x1E53, +IBUS_acute, IBUS_b, IBUS_A, 0x1EAE, +IBUS_acute, IBUS_b, IBUS_a, 0x1EAF, +IBUS_acute, IBUS_asciitilde, IBUS_O, 0x1E4C, +IBUS_acute, IBUS_asciitilde, IBUS_U, 0x1E78, +IBUS_acute, IBUS_asciitilde, IBUS_o, 0x1E4D, +IBUS_acute, IBUS_asciitilde, IBUS_u, 0x1E79, +IBUS_acute, IBUS_macron, IBUS_E, 0x1E16, +IBUS_acute, IBUS_macron, IBUS_O, 0x1E52, +IBUS_acute, IBUS_macron, IBUS_e, 0x1E17, +IBUS_acute, IBUS_macron, IBUS_o, 0x1E53, +IBUS_acute, IBUS_cedilla, IBUS_C, 0x1E08, +IBUS_acute, IBUS_cedilla, IBUS_c, 0x1E09, +IBUS_acute, IBUS_dead_circumflex, IBUS_A, 0x1EA4, +IBUS_acute, IBUS_dead_circumflex, IBUS_E, 0x1EBE, +IBUS_acute, IBUS_dead_circumflex, IBUS_O, 0x1ED0, +IBUS_acute, IBUS_dead_circumflex, IBUS_a, 0x1EA5, +IBUS_acute, IBUS_dead_circumflex, IBUS_e, 0x1EBF, +IBUS_acute, IBUS_dead_circumflex, IBUS_o, 0x1ED1, +IBUS_acute, IBUS_dead_tilde, IBUS_O, 0x1E4C, +IBUS_acute, IBUS_dead_tilde, IBUS_U, 0x1E78, +IBUS_acute, IBUS_dead_tilde, IBUS_o, 0x1E4D, +IBUS_acute, IBUS_dead_tilde, IBUS_u, 0x1E79, +IBUS_acute, IBUS_dead_macron, IBUS_E, 0x1E16, +IBUS_acute, IBUS_dead_macron, IBUS_O, 0x1E52, +IBUS_acute, IBUS_dead_macron, IBUS_e, 0x1E17, +IBUS_acute, IBUS_dead_macron, IBUS_o, 0x1E53, +IBUS_acute, IBUS_dead_breve, IBUS_A, 0x1EAE, +IBUS_acute, IBUS_dead_breve, IBUS_a, 0x1EAF, +IBUS_acute, IBUS_dead_diaeresis, IBUS_I, 0x1E2E, +IBUS_acute, IBUS_dead_diaeresis, IBUS_U, 0x01D7, +IBUS_acute, IBUS_dead_diaeresis, IBUS_i, 0x1E2F, +IBUS_acute, IBUS_dead_diaeresis, IBUS_u, 0x01D8, +IBUS_acute, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x0390, +IBUS_acute, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x03B0, +IBUS_acute, IBUS_dead_abovering, IBUS_A, 0x01FA, +IBUS_acute, IBUS_dead_abovering, IBUS_a, 0x01FB, +IBUS_acute, IBUS_dead_cedilla, IBUS_C, 0x1E08, +IBUS_acute, IBUS_dead_cedilla, IBUS_c, 0x1E09, +IBUS_acute, IBUS_dead_horn, IBUS_O, 0x1EDA, +IBUS_acute, IBUS_dead_horn, IBUS_U, 0x1EE8, +IBUS_acute, IBUS_dead_horn, IBUS_o, 0x1EDB, +IBUS_acute, IBUS_dead_horn, IBUS_u, 0x1EE9, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0C, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1C, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2C, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3C, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4C, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6C, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F04, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F14, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F24, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_iota, 0x1F34, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_omicron, 0x1F44, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F54, +IBUS_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1F64, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0D, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1D, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2D, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3D, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4D, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5D, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6D, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F05, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F15, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F25, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F35, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F45, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F55, +IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F65, +IBUS_acute, IBUS_KP_Divide, IBUS_O, 0x01FE, +IBUS_acute, IBUS_KP_Divide, IBUS_o, 0x01FF, +0x05C1, 0x05BC, IBUS_hebrew_shin, 0xFB2C, +0x05C2, 0x05BC, IBUS_hebrew_shin, 0xFB2D, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_Greek_alpha, 0x1FB4, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_Greek_eta, 0x1FC4, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_Greek_omega, 0x1FF4, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F00, 0x1F84, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F01, 0x1F85, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F08, 0x1F8C, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F09, 0x1F8D, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F20, 0x1F94, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F21, 0x1F95, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F28, 0x1F9C, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F29, 0x1F9D, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F60, 0x1FA4, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F61, 0x1FA5, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F68, 0x1FAC, +IBUS_Greek_iota, IBUS_apostrophe, 0x1F69, 0x1FAD, +IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F89, +IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_ETA, 0x1F99, +IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FA9, +IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_alpha, 0x1F81, +IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_eta, 0x1F91, +IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_omega, 0x1FA1, +IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F88, +IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_ETA, 0x1F98, +IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FA8, +IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_alpha, 0x1F80, +IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_eta, 0x1F90, +IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_omega, 0x1FA0, +IBUS_Greek_iota, IBUS_grave, IBUS_Greek_alpha, 0x1FB2, +IBUS_Greek_iota, IBUS_grave, IBUS_Greek_eta, 0x1FC2, +IBUS_Greek_iota, IBUS_grave, IBUS_Greek_omega, 0x1FF2, +IBUS_Greek_iota, IBUS_grave, 0x1F00, 0x1F82, +IBUS_Greek_iota, IBUS_grave, 0x1F01, 0x1F83, +IBUS_Greek_iota, IBUS_grave, 0x1F08, 0x1F8A, +IBUS_Greek_iota, IBUS_grave, 0x1F09, 0x1F8B, +IBUS_Greek_iota, IBUS_grave, 0x1F20, 0x1F92, +IBUS_Greek_iota, IBUS_grave, 0x1F21, 0x1F93, +IBUS_Greek_iota, IBUS_grave, 0x1F28, 0x1F9A, +IBUS_Greek_iota, IBUS_grave, 0x1F29, 0x1F9B, +IBUS_Greek_iota, IBUS_grave, 0x1F60, 0x1FA2, +IBUS_Greek_iota, IBUS_grave, 0x1F61, 0x1FA3, +IBUS_Greek_iota, IBUS_grave, 0x1F68, 0x1FAA, +IBUS_Greek_iota, IBUS_grave, 0x1F69, 0x1FAB, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_Greek_alpha, 0x1FB7, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_Greek_eta, 0x1FC7, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_Greek_omega, 0x1FF7, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F00, 0x1F86, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F01, 0x1F87, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F08, 0x1F8E, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F09, 0x1F8F, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F20, 0x1F96, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F21, 0x1F97, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F28, 0x1F9E, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F29, 0x1F9F, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F60, 0x1FA6, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F61, 0x1FA7, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F68, 0x1FAE, +IBUS_Greek_iota, IBUS_asciitilde, 0x1F69, 0x1FAF, +IBUS_Greek_iota, IBUS_acute, IBUS_Greek_alpha, 0x1FB4, +IBUS_Greek_iota, IBUS_acute, IBUS_Greek_eta, 0x1FC4, +IBUS_Greek_iota, IBUS_acute, IBUS_Greek_omega, 0x1FF4, +IBUS_Greek_iota, IBUS_acute, 0x1F00, 0x1F84, +IBUS_Greek_iota, IBUS_acute, 0x1F01, 0x1F85, +IBUS_Greek_iota, IBUS_acute, 0x1F08, 0x1F8C, +IBUS_Greek_iota, IBUS_acute, 0x1F09, 0x1F8D, +IBUS_Greek_iota, IBUS_acute, 0x1F20, 0x1F94, +IBUS_Greek_iota, IBUS_acute, 0x1F21, 0x1F95, +IBUS_Greek_iota, IBUS_acute, 0x1F28, 0x1F9C, +IBUS_Greek_iota, IBUS_acute, 0x1F29, 0x1F9D, +IBUS_Greek_iota, IBUS_acute, 0x1F60, 0x1FA4, +IBUS_Greek_iota, IBUS_acute, 0x1F61, 0x1FA5, +IBUS_Greek_iota, IBUS_acute, 0x1F68, 0x1FAC, +IBUS_Greek_iota, IBUS_acute, 0x1F69, 0x1FAD, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_Greek_alpha, 0x1FB2, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_Greek_eta, 0x1FC2, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_Greek_omega, 0x1FF2, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F00, 0x1F82, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F01, 0x1F83, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F08, 0x1F8A, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F09, 0x1F8B, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F20, 0x1F92, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F21, 0x1F93, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F28, 0x1F9A, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F29, 0x1F9B, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F60, 0x1FA2, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F61, 0x1FA3, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F68, 0x1FAA, +IBUS_Greek_iota, IBUS_dead_grave, 0x1F69, 0x1FAB, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_Greek_alpha, 0x1FB4, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_Greek_eta, 0x1FC4, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_Greek_omega, 0x1FF4, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F00, 0x1F84, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F01, 0x1F85, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F08, 0x1F8C, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F09, 0x1F8D, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F20, 0x1F94, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F21, 0x1F95, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F28, 0x1F9C, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F29, 0x1F9D, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F60, 0x1FA4, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F61, 0x1FA5, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F68, 0x1FAC, +IBUS_Greek_iota, IBUS_dead_acute, 0x1F69, 0x1FAD, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_Greek_alpha, 0x1FB7, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_Greek_eta, 0x1FC7, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_Greek_omega, 0x1FF7, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F00, 0x1F86, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F01, 0x1F87, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F08, 0x1F8E, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F09, 0x1F8F, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F20, 0x1F96, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F21, 0x1F97, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F28, 0x1F9E, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F29, 0x1F9F, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F60, 0x1FA6, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F61, 0x1FA7, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F68, 0x1FAE, +IBUS_Greek_iota, IBUS_dead_tilde, 0x1F69, 0x1FAF, +IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F88, +IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F98, +IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FA8, +IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F80, +IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_eta, 0x1F90, +IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA0, +IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F89, +IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F99, +IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FA9, +IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F81, +IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F91, +IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA1, +IBUS_parenleft, IBUS_1, IBUS_0, IBUS_parenright, 0x2469, +IBUS_parenleft, IBUS_1, IBUS_1, IBUS_parenright, 0x246A, +IBUS_parenleft, IBUS_1, IBUS_2, IBUS_parenright, 0x246B, +IBUS_parenleft, IBUS_1, IBUS_3, IBUS_parenright, 0x246C, +IBUS_parenleft, IBUS_1, IBUS_4, IBUS_parenright, 0x246D, +IBUS_parenleft, IBUS_1, IBUS_5, IBUS_parenright, 0x246E, +IBUS_parenleft, IBUS_1, IBUS_6, IBUS_parenright, 0x246F, +IBUS_parenleft, IBUS_1, IBUS_7, IBUS_parenright, 0x2470, +IBUS_parenleft, IBUS_1, IBUS_8, IBUS_parenright, 0x2471, +IBUS_parenleft, IBUS_1, IBUS_9, IBUS_parenright, 0x2472, +IBUS_parenleft, IBUS_1, IBUS_KP_Space, IBUS_parenright, 0x246B, +IBUS_parenleft, IBUS_1, IBUS_KP_0, IBUS_parenright, 0x2469, +IBUS_parenleft, IBUS_1, IBUS_KP_1, IBUS_parenright, 0x246A, +IBUS_parenleft, IBUS_1, IBUS_KP_2, IBUS_parenright, 0x246B, +IBUS_parenleft, IBUS_1, IBUS_KP_3, IBUS_parenright, 0x246C, +IBUS_parenleft, IBUS_1, IBUS_KP_4, IBUS_parenright, 0x246D, +IBUS_parenleft, IBUS_1, IBUS_KP_5, IBUS_parenright, 0x246E, +IBUS_parenleft, IBUS_1, IBUS_KP_6, IBUS_parenright, 0x246F, +IBUS_parenleft, IBUS_1, IBUS_KP_7, IBUS_parenright, 0x2470, +IBUS_parenleft, IBUS_1, IBUS_KP_8, IBUS_parenright, 0x2471, +IBUS_parenleft, IBUS_1, IBUS_KP_9, IBUS_parenright, 0x2472, +IBUS_parenleft, IBUS_2, IBUS_0, IBUS_parenright, 0x2473, +IBUS_parenleft, IBUS_2, IBUS_1, IBUS_parenright, 0x3251, +IBUS_parenleft, IBUS_2, IBUS_2, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_2, IBUS_3, IBUS_parenright, 0x3253, +IBUS_parenleft, IBUS_2, IBUS_4, IBUS_parenright, 0x3254, +IBUS_parenleft, IBUS_2, IBUS_5, IBUS_parenright, 0x3255, +IBUS_parenleft, IBUS_2, IBUS_6, IBUS_parenright, 0x3256, +IBUS_parenleft, IBUS_2, IBUS_7, IBUS_parenright, 0x3257, +IBUS_parenleft, IBUS_2, IBUS_8, IBUS_parenright, 0x3258, +IBUS_parenleft, IBUS_2, IBUS_9, IBUS_parenright, 0x3259, +IBUS_parenleft, IBUS_2, IBUS_KP_Space, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_2, IBUS_KP_0, IBUS_parenright, 0x2473, +IBUS_parenleft, IBUS_2, IBUS_KP_1, IBUS_parenright, 0x3251, +IBUS_parenleft, IBUS_2, IBUS_KP_2, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_2, IBUS_KP_3, IBUS_parenright, 0x3253, +IBUS_parenleft, IBUS_2, IBUS_KP_4, IBUS_parenright, 0x3254, +IBUS_parenleft, IBUS_2, IBUS_KP_5, IBUS_parenright, 0x3255, +IBUS_parenleft, IBUS_2, IBUS_KP_6, IBUS_parenright, 0x3256, +IBUS_parenleft, IBUS_2, IBUS_KP_7, IBUS_parenright, 0x3257, +IBUS_parenleft, IBUS_2, IBUS_KP_8, IBUS_parenright, 0x3258, +IBUS_parenleft, IBUS_2, IBUS_KP_9, IBUS_parenright, 0x3259, +IBUS_parenleft, IBUS_3, IBUS_0, IBUS_parenright, 0x325A, +IBUS_parenleft, IBUS_3, IBUS_1, IBUS_parenright, 0x325B, +IBUS_parenleft, IBUS_3, IBUS_2, IBUS_parenright, 0x325C, +IBUS_parenleft, IBUS_3, IBUS_3, IBUS_parenright, 0x325D, +IBUS_parenleft, IBUS_3, IBUS_4, IBUS_parenright, 0x325E, +IBUS_parenleft, IBUS_3, IBUS_5, IBUS_parenright, 0x325F, +IBUS_parenleft, IBUS_3, IBUS_6, IBUS_parenright, 0x32B1, +IBUS_parenleft, IBUS_3, IBUS_7, IBUS_parenright, 0x32B2, +IBUS_parenleft, IBUS_3, IBUS_8, IBUS_parenright, 0x32B3, +IBUS_parenleft, IBUS_3, IBUS_9, IBUS_parenright, 0x32B4, +IBUS_parenleft, IBUS_3, IBUS_KP_Space, IBUS_parenright, 0x325C, +IBUS_parenleft, IBUS_3, IBUS_KP_0, IBUS_parenright, 0x325A, +IBUS_parenleft, IBUS_3, IBUS_KP_1, IBUS_parenright, 0x325B, +IBUS_parenleft, IBUS_3, IBUS_KP_2, IBUS_parenright, 0x325C, +IBUS_parenleft, IBUS_3, IBUS_KP_3, IBUS_parenright, 0x325D, +IBUS_parenleft, IBUS_3, IBUS_KP_4, IBUS_parenright, 0x325E, +IBUS_parenleft, IBUS_3, IBUS_KP_5, IBUS_parenright, 0x325F, +IBUS_parenleft, IBUS_3, IBUS_KP_6, IBUS_parenright, 0x32B1, +IBUS_parenleft, IBUS_3, IBUS_KP_7, IBUS_parenright, 0x32B2, +IBUS_parenleft, IBUS_3, IBUS_KP_8, IBUS_parenright, 0x32B3, +IBUS_parenleft, IBUS_3, IBUS_KP_9, IBUS_parenright, 0x32B4, +IBUS_parenleft, IBUS_4, IBUS_0, IBUS_parenright, 0x32B5, +IBUS_parenleft, IBUS_4, IBUS_1, IBUS_parenright, 0x32B6, +IBUS_parenleft, IBUS_4, IBUS_2, IBUS_parenright, 0x32B7, +IBUS_parenleft, IBUS_4, IBUS_3, IBUS_parenright, 0x32B8, +IBUS_parenleft, IBUS_4, IBUS_4, IBUS_parenright, 0x32B9, +IBUS_parenleft, IBUS_4, IBUS_5, IBUS_parenright, 0x32BA, +IBUS_parenleft, IBUS_4, IBUS_6, IBUS_parenright, 0x32BB, +IBUS_parenleft, IBUS_4, IBUS_7, IBUS_parenright, 0x32BC, +IBUS_parenleft, IBUS_4, IBUS_8, IBUS_parenright, 0x32BD, +IBUS_parenleft, IBUS_4, IBUS_9, IBUS_parenright, 0x32BE, +IBUS_parenleft, IBUS_4, IBUS_KP_Space, IBUS_parenright, 0x32B7, +IBUS_parenleft, IBUS_4, IBUS_KP_0, IBUS_parenright, 0x32B5, +IBUS_parenleft, IBUS_4, IBUS_KP_1, IBUS_parenright, 0x32B6, +IBUS_parenleft, IBUS_4, IBUS_KP_2, IBUS_parenright, 0x32B7, +IBUS_parenleft, IBUS_4, IBUS_KP_3, IBUS_parenright, 0x32B8, +IBUS_parenleft, IBUS_4, IBUS_KP_4, IBUS_parenright, 0x32B9, +IBUS_parenleft, IBUS_4, IBUS_KP_5, IBUS_parenright, 0x32BA, +IBUS_parenleft, IBUS_4, IBUS_KP_6, IBUS_parenright, 0x32BB, +IBUS_parenleft, IBUS_4, IBUS_KP_7, IBUS_parenright, 0x32BC, +IBUS_parenleft, IBUS_4, IBUS_KP_8, IBUS_parenright, 0x32BD, +IBUS_parenleft, IBUS_4, IBUS_KP_9, IBUS_parenright, 0x32BE, +IBUS_parenleft, IBUS_5, IBUS_KP_0, IBUS_parenright, 0x32BF, +IBUS_parenleft, 0x1100, 0x1161, IBUS_parenright, 0x326E, +IBUS_parenleft, 0x1102, 0x1161, IBUS_parenright, 0x326F, +IBUS_parenleft, 0x1103, 0x1161, IBUS_parenright, 0x3270, +IBUS_parenleft, 0x1105, 0x1161, IBUS_parenright, 0x3271, +IBUS_parenleft, 0x1106, 0x1161, IBUS_parenright, 0x3272, +IBUS_parenleft, 0x1107, 0x1161, IBUS_parenright, 0x3273, +IBUS_parenleft, 0x1109, 0x1161, IBUS_parenright, 0x3274, +IBUS_parenleft, 0x110B, 0x1161, IBUS_parenright, 0x3275, +IBUS_parenleft, 0x110C, 0x1161, IBUS_parenright, 0x3276, +IBUS_parenleft, 0x110E, 0x1161, IBUS_parenright, 0x3277, +IBUS_parenleft, 0x110F, 0x1161, IBUS_parenright, 0x3278, +IBUS_parenleft, 0x1110, 0x1161, IBUS_parenright, 0x3279, +IBUS_parenleft, 0x1111, 0x1161, IBUS_parenright, 0x327A, +IBUS_parenleft, 0x1112, 0x1161, IBUS_parenright, 0x327B, +IBUS_parenleft, IBUS_KP_Space, IBUS_0, IBUS_parenright, 0x2473, +IBUS_parenleft, IBUS_KP_Space, IBUS_1, IBUS_parenright, 0x3251, +IBUS_parenleft, IBUS_KP_Space, IBUS_2, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_KP_Space, IBUS_3, IBUS_parenright, 0x3253, +IBUS_parenleft, IBUS_KP_Space, IBUS_4, IBUS_parenright, 0x3254, +IBUS_parenleft, IBUS_KP_Space, IBUS_5, IBUS_parenright, 0x3255, +IBUS_parenleft, IBUS_KP_Space, IBUS_6, IBUS_parenright, 0x3256, +IBUS_parenleft, IBUS_KP_Space, IBUS_7, IBUS_parenright, 0x3257, +IBUS_parenleft, IBUS_KP_Space, IBUS_8, IBUS_parenright, 0x3258, +IBUS_parenleft, IBUS_KP_Space, IBUS_9, IBUS_parenright, 0x3259, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_Space, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_0, IBUS_parenright, 0x2473, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_1, IBUS_parenright, 0x3251, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_2, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_3, IBUS_parenright, 0x3253, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_4, IBUS_parenright, 0x3254, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_5, IBUS_parenright, 0x3255, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_6, IBUS_parenright, 0x3256, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_7, IBUS_parenright, 0x3257, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_8, IBUS_parenright, 0x3258, +IBUS_parenleft, IBUS_KP_Space, IBUS_KP_9, IBUS_parenright, 0x3259, +IBUS_parenleft, IBUS_KP_1, IBUS_0, IBUS_parenright, 0x2469, +IBUS_parenleft, IBUS_KP_1, IBUS_1, IBUS_parenright, 0x246A, +IBUS_parenleft, IBUS_KP_1, IBUS_2, IBUS_parenright, 0x246B, +IBUS_parenleft, IBUS_KP_1, IBUS_3, IBUS_parenright, 0x246C, +IBUS_parenleft, IBUS_KP_1, IBUS_4, IBUS_parenright, 0x246D, +IBUS_parenleft, IBUS_KP_1, IBUS_5, IBUS_parenright, 0x246E, +IBUS_parenleft, IBUS_KP_1, IBUS_6, IBUS_parenright, 0x246F, +IBUS_parenleft, IBUS_KP_1, IBUS_7, IBUS_parenright, 0x2470, +IBUS_parenleft, IBUS_KP_1, IBUS_8, IBUS_parenright, 0x2471, +IBUS_parenleft, IBUS_KP_1, IBUS_9, IBUS_parenright, 0x2472, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_Space, IBUS_parenright, 0x246B, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_0, IBUS_parenright, 0x2469, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_1, IBUS_parenright, 0x246A, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_2, IBUS_parenright, 0x246B, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_3, IBUS_parenright, 0x246C, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_4, IBUS_parenright, 0x246D, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_5, IBUS_parenright, 0x246E, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_6, IBUS_parenright, 0x246F, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_7, IBUS_parenright, 0x2470, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_8, IBUS_parenright, 0x2471, +IBUS_parenleft, IBUS_KP_1, IBUS_KP_9, IBUS_parenright, 0x2472, +IBUS_parenleft, IBUS_KP_2, IBUS_0, IBUS_parenright, 0x2473, +IBUS_parenleft, IBUS_KP_2, IBUS_1, IBUS_parenright, 0x3251, +IBUS_parenleft, IBUS_KP_2, IBUS_2, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_KP_2, IBUS_3, IBUS_parenright, 0x3253, +IBUS_parenleft, IBUS_KP_2, IBUS_4, IBUS_parenright, 0x3254, +IBUS_parenleft, IBUS_KP_2, IBUS_5, IBUS_parenright, 0x3255, +IBUS_parenleft, IBUS_KP_2, IBUS_6, IBUS_parenright, 0x3256, +IBUS_parenleft, IBUS_KP_2, IBUS_7, IBUS_parenright, 0x3257, +IBUS_parenleft, IBUS_KP_2, IBUS_8, IBUS_parenright, 0x3258, +IBUS_parenleft, IBUS_KP_2, IBUS_9, IBUS_parenright, 0x3259, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_Space, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_0, IBUS_parenright, 0x2473, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_1, IBUS_parenright, 0x3251, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_2, IBUS_parenright, 0x3252, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_3, IBUS_parenright, 0x3253, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_4, IBUS_parenright, 0x3254, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_5, IBUS_parenright, 0x3255, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_6, IBUS_parenright, 0x3256, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_7, IBUS_parenright, 0x3257, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_8, IBUS_parenright, 0x3258, +IBUS_parenleft, IBUS_KP_2, IBUS_KP_9, IBUS_parenright, 0x3259, +IBUS_parenleft, IBUS_KP_3, IBUS_0, IBUS_parenright, 0x325A, +IBUS_parenleft, IBUS_KP_3, IBUS_1, IBUS_parenright, 0x325B, +IBUS_parenleft, IBUS_KP_3, IBUS_2, IBUS_parenright, 0x325C, +IBUS_parenleft, IBUS_KP_3, IBUS_3, IBUS_parenright, 0x325D, +IBUS_parenleft, IBUS_KP_3, IBUS_4, IBUS_parenright, 0x325E, +IBUS_parenleft, IBUS_KP_3, IBUS_5, IBUS_parenright, 0x325F, +IBUS_parenleft, IBUS_KP_3, IBUS_6, IBUS_parenright, 0x32B1, +IBUS_parenleft, IBUS_KP_3, IBUS_7, IBUS_parenright, 0x32B2, +IBUS_parenleft, IBUS_KP_3, IBUS_8, IBUS_parenright, 0x32B3, +IBUS_parenleft, IBUS_KP_3, IBUS_9, IBUS_parenright, 0x32B4, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_Space, IBUS_parenright, 0x325C, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_0, IBUS_parenright, 0x325A, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_1, IBUS_parenright, 0x325B, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_2, IBUS_parenright, 0x325C, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_3, IBUS_parenright, 0x325D, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_4, IBUS_parenright, 0x325E, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_5, IBUS_parenright, 0x325F, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_6, IBUS_parenright, 0x32B1, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_7, IBUS_parenright, 0x32B2, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_8, IBUS_parenright, 0x32B3, +IBUS_parenleft, IBUS_KP_3, IBUS_KP_9, IBUS_parenright, 0x32B4, +IBUS_parenleft, IBUS_KP_4, IBUS_0, IBUS_parenright, 0x32B5, +IBUS_parenleft, IBUS_KP_4, IBUS_1, IBUS_parenright, 0x32B6, +IBUS_parenleft, IBUS_KP_4, IBUS_2, IBUS_parenright, 0x32B7, +IBUS_parenleft, IBUS_KP_4, IBUS_3, IBUS_parenright, 0x32B8, +IBUS_parenleft, IBUS_KP_4, IBUS_4, IBUS_parenright, 0x32B9, +IBUS_parenleft, IBUS_KP_4, IBUS_5, IBUS_parenright, 0x32BA, +IBUS_parenleft, IBUS_KP_4, IBUS_6, IBUS_parenright, 0x32BB, +IBUS_parenleft, IBUS_KP_4, IBUS_7, IBUS_parenright, 0x32BC, +IBUS_parenleft, IBUS_KP_4, IBUS_8, IBUS_parenright, 0x32BD, +IBUS_parenleft, IBUS_KP_4, IBUS_9, IBUS_parenright, 0x32BE, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_Space, IBUS_parenright, 0x32B7, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_0, IBUS_parenright, 0x32B5, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_1, IBUS_parenright, 0x32B6, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_2, IBUS_parenright, 0x32B7, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_3, IBUS_parenright, 0x32B8, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_4, IBUS_parenright, 0x32B9, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_5, IBUS_parenright, 0x32BA, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_6, IBUS_parenright, 0x32BB, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_7, IBUS_parenright, 0x32BC, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_8, IBUS_parenright, 0x32BD, +IBUS_parenleft, IBUS_KP_4, IBUS_KP_9, IBUS_parenright, 0x32BE, +IBUS_parenleft, IBUS_KP_5, IBUS_KP_0, IBUS_parenright, 0x32BF, +IBUS_C, IBUS_C, IBUS_C, IBUS_P, 0x262D, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_eta, 0x1F94, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, +IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, +IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, +IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, +IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, +IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, +IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, +IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, +IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F92, +IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, +IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_eta, 0x1F96, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, +IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA7, +IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, +IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, +IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, +IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, +IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, +IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, +IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F94, +IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, +IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F92, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, +IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F94, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, +IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_eta, 0x1F96, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, +IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, +}; + +#endif /* __GTK_IM_CONTEXT_SIMPLE_SEQS_H__ */ + diff --git a/xkb/ibus-engine-xkb-main.c b/xkb/ibus-engine-xkb-main.c new file mode 100644 index 0000000..5866b40 --- /dev/null +++ b/xkb/ibus-engine-xkb-main.c @@ -0,0 +1,303 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include + +#ifdef ENABLE_NLS +#include +#endif + +#include "xkbxml.h" +#include "ibusxkbxml.h" +#include "ibus-simple-engine.h" + + +static IBusBus *bus = NULL; +static IBusFactory *factory = NULL; +static gboolean ibus = FALSE; +static gboolean xml = FALSE; + +static const GOptionEntry entries[] = +{ + { "ibus", 'i', 0, G_OPTION_ARG_NONE, &ibus, "component is executed by ibus", NULL }, + { "xml", 'x', 0, G_OPTION_ARG_NONE, &xml, "print component xml", NULL }, + { NULL }, +}; + +static void +ibus_disconnected_cb (IBusBus *bus, + gpointer user_data) +{ + g_debug ("bus disconnected"); + ibus_quit (); +} + +IBusEngine * +_factory_create_engine_cb (IBusFactory *factory, + const gchar *engine_name, + gpointer data) +{ + IBusEngine *engine = NULL; + gchar *object_path = NULL; + static int id = 0; + + g_return_val_if_fail (engine_name != NULL, NULL); + + if (g_strcmp0 (engine_name, "xkb:layout:us") == 0) { + return NULL; + } + + object_path = g_strdup_printf ("/org/freedesktop/IBus/XKBEngine/%d", + ++id); + engine = ibus_engine_new_type (IBUS_TYPE_SIMPLE_ENGINE, + engine_name, + object_path, + ibus_service_get_connection (IBUS_SERVICE (factory))); + g_free (object_path); + return engine; +} + +static void +start_component (int argc, char **argv) +{ + IBusComponent *component; + + ibus_init (); + + bus = ibus_bus_new (); + g_signal_connect (bus, "disconnected", G_CALLBACK (ibus_disconnected_cb), NULL); + + component = ibus_component_new ("org.freedesktop.IBus.XKB", + "XKB Component", + VERSION, + "LGPL2.1", + "Takao Fujiwara ", + "http://code.google.com/p/ibus/", + "", + GETTEXT_PACKAGE); + ibus_component_add_engine (component, + ibus_xkb_engine_desc_new ("eng", + "us", + "USA", + NULL, + NULL, + NULL)); + + factory = ibus_factory_new (ibus_bus_get_connection (bus)); + + ibus_factory_add_engine (factory, "xkb:layout:us", IBUS_TYPE_SIMPLE_ENGINE); + + g_signal_connect (G_OBJECT (factory), "create-engine", + G_CALLBACK (_factory_create_engine_cb), + NULL); + if (ibus) { + ibus_bus_request_name (bus, "org.freedesktop.IBus.XKB", 0); + } + else { + ibus_bus_register_component (bus, component); + } + + g_object_unref (component); + + ibus_main (); +} + +static gboolean +is_included_engine_in_preload (const GList * preload_xkb_engines, + const gchar *layout, + const gchar *variant) +{ + const GList *list = preload_xkb_engines; + gchar *key = NULL; + gboolean retval = FALSE; + + g_return_val_if_fail (layout != NULL, FALSE); + + if (variant == NULL) { + key = g_strdup (layout); + } else { + key = g_strdup_printf ("%s(%s)", layout, variant); + } + while (list) { + if (list->data == NULL) { + continue; + } + if (g_strcmp0 ((const gchar *) list->data, + (const gchar *) key) == 0) { + retval = TRUE; + break; + } + list = list->next; + } + g_free (key); + return retval; +} + +static void +print_component () +{ + IBusXKBLayoutConfig *layout_config; + IBusXKBConfigRegistry *config_registry; + GHashTable *layout_list; + GHashTable *layout_lang; + GHashTable *layout_desc; + GHashTable *variant_desc; + IBusComponent *component; + IBusEngineDesc *engine; + const GList *preload_xkb_engines = NULL; + GList *keys; + GList *variants; + GList *langs; + gboolean is_preload; + gchar *layout_name; + const gchar *desc; + gchar *output; + GString *str; + +#ifdef XKBLAYOUTCONFIG_FILE + layout_config = ibus_xkb_layout_config_new (XKBLAYOUTCONFIG_FILE); + preload_xkb_engines = ibus_xkb_layout_config_get_preload_layouts (layout_config); +#endif + + config_registry = ibus_xkb_config_registry_new (); + layout_list = (GHashTable *) ibus_xkb_config_registry_get_layout_list (config_registry); + layout_lang = (GHashTable *) ibus_xkb_config_registry_get_layout_lang (config_registry); + layout_desc = (GHashTable *) ibus_xkb_config_registry_get_layout_desc (config_registry); + variant_desc = (GHashTable *) ibus_xkb_config_registry_get_variant_desc (config_registry); + component = ibus_xkb_component_new (); + for (keys = g_hash_table_get_keys (layout_list); keys; keys = keys->next) { + if (keys->data == NULL) { + continue; + } + desc = (const gchar *) g_hash_table_lookup (layout_desc, keys->data); + langs = (GList *) g_hash_table_lookup (layout_lang, keys->data); + for (;langs; langs = langs->next) { + if (langs->data == NULL) { + continue; + } + is_preload = FALSE; + if (!preload_xkb_engines) { + is_preload = TRUE; + } else { + is_preload = is_included_engine_in_preload (preload_xkb_engines, + (const gchar *) keys->data, + NULL); + } + if (is_preload) { + engine = ibus_xkb_engine_desc_new ((const gchar *) langs->data, + (const gchar *) keys->data, + desc, + NULL, + NULL, + NULL); + ibus_component_add_engine (component, engine); + } + } + variants = (GList *) g_hash_table_lookup (layout_list, keys->data); + for (;variants; variants = variants->next) { + if (variants->data == NULL) { + continue; + } + layout_name = g_strdup_printf ("%s(%s)", (gchar *) keys->data, + (gchar *) variants->data); + langs = (GList *) g_hash_table_lookup (layout_lang, layout_name); + if (langs == NULL) { + g_free (layout_name); + layout_name = g_strdup ((gchar *) keys->data); + langs = (GList *) g_hash_table_lookup (layout_lang, layout_name); + } + g_free (layout_name); + for (;langs; langs = langs->next) { + if (langs->data == NULL) { + continue; + } + is_preload = FALSE; + if (!preload_xkb_engines) { + is_preload = TRUE; + } else { + is_preload = is_included_engine_in_preload (preload_xkb_engines, + (const gchar *) keys->data, + (const gchar *) variants->data); + } + if (is_preload) { + engine = ibus_xkb_engine_desc_new ((const gchar *) langs->data, + (const gchar *) keys->data, + desc, + (const gchar *) variants->data, + (const gchar *) g_hash_table_lookup (variant_desc, variants->data), + NULL); + ibus_component_add_engine (component, engine); + } + } + } + } + g_object_unref (G_OBJECT (config_registry)); +#ifdef XKBLAYOUTCONFIG_FILE + g_object_unref (G_OBJECT (layout_config)); +#endif + + str = g_string_new (NULL); + ibus_component_output_engines (component , str, 0); + g_object_unref (G_OBJECT (component)); + + output = g_string_free (str, FALSE); + g_print ("%s\n", output); + g_free (output); +} + +int +main (int argc, char **argv) +{ + GError *error = NULL; + GOptionContext *context; + +#ifdef ENABLE_NLS + setlocale (LC_ALL, ""); + bindtextdomain (GETTEXT_PACKAGE, IBUS_LOCALEDIR); + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +#endif + + g_type_init (); + + context = g_option_context_new ("- ibus xkb engine component"); + + g_option_context_add_main_entries (context, entries, "ibus-xbl"); + + if (!g_option_context_parse (context, &argc, &argv, &error)) { + g_print ("Option parsing failed: %s\n", error->message); + exit (-1); + } + + if (xml) { + print_component (); + return 0; + } + start_component (argc, argv); + + return 0; +} diff --git a/xkb/ibus-engine-xkb-main.h b/xkb/ibus-engine-xkb-main.h new file mode 100644 index 0000000..255e952 --- /dev/null +++ b/xkb/ibus-engine-xkb-main.h @@ -0,0 +1,32 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifndef __IBUS_ENGINE_XKB_MAIN_H_ +#define __IBUS_ENGINE_XKB_MAIN_H_ + +G_BEGIN_DECLS + +typedef struct _IBusXKBEngine IBusXKBEngine; +typedef struct _IBusXKBEngineClass IBusXKBEngineClass; + +G_END_DECLS +#endif diff --git a/xkb/ibus-simple-engine.c b/xkb/ibus-simple-engine.c new file mode 100644 index 0000000..4b5bd83 --- /dev/null +++ b/xkb/ibus-simple-engine.c @@ -0,0 +1,1007 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#include "ibus-simple-engine.h" +#include +#include +#include + +#ifdef ENABLE_NLS +#include +#endif + +#define MAX_COMPOSE_LEN 7 + +typedef enum { + IBUS_COMPOSE_TABLE_NONE = 0, + IBUS_COMPOSE_TABLE_CEDILLA, +} IBusComposeAddOnTableType; + +typedef struct _IBusSimpleEngine IBusSimpleEngine; +typedef struct _IBusSimpleEngineClass IBusSimpleEngineClass; + +struct _IBusSimpleEngine { + IBusEngine parent; + + IBusPropList *prop_list; + + guint compose_buffer[MAX_COMPOSE_LEN + 1]; + gunichar tentative_match; + gint tentative_match_len; + + guint in_hex_sequence : 1; + guint modifiers_dropped : 1; +}; + +struct _IBusSimpleEngineClass { + IBusEngineClass parent; + IBusComposeAddOnTableType compose_addon_table_type; +}; + +typedef struct _GtkComposeTableCompact GtkComposeTableCompact; +struct _GtkComposeTableCompact +{ + const guint16 *data; + gint max_seq_len; + gint n_index_size; + gint n_index_stride; +}; + +/* This file contains the table of the compose sequences, + * static const guint16 gtk_compose_seqs_compact[] = {} + * IT is generated from the compose-parse.py script. + */ +#include "gtkimcontextsimpleseqs.h" + +/* From the values below, the value 23 means the number of different first keysyms + * that exist in the Compose file (from Xorg). When running compose-parse.py without + * parameters, you get the count that you can put here. Needed when updating the + * gtkimcontextsimpleseqs.h header file (contains the compose sequences). + */ +static const GtkComposeTableCompact gtk_compose_table_compact = { + gtk_compose_seqs_compact, + 5, + 24, + 6 +}; + +static const guint16 gtk_compose_ignore[] = { + IBUS_Shift_L, + IBUS_Shift_R, + IBUS_Control_L, + IBUS_Control_R, + IBUS_Caps_Lock, + IBUS_Shift_Lock, + IBUS_Meta_L, + IBUS_Meta_R, + IBUS_Alt_L, + IBUS_Alt_R, + IBUS_Super_L, + IBUS_Super_R, + IBUS_Hyper_L, + IBUS_Hyper_R, + IBUS_Mode_switch, + IBUS_ISO_Level3_Shift +}; + +/* Copied from gtk+2.0-2.20.1/modules/input/imcedilla.c to fix crosbug.com/11421. + * Overwrite the original Gtk+'s compose table in gtk+-2.x.y/gtk/gtkimcontextsimple.c. */ + +/* The difference between this and the default input method is the handling + * of C+acute - this method produces C WITH CEDILLA rather than C WITH ACUTE. + * For languages that use CCedilla and not acute, this is the preferred mapping, + * and is particularly important for pt_BR, where the us-intl keyboard is + * used extensively. + */ +static guint16 cedilla_compose_seqs[] = { + IBUS_dead_acute, IBUS_C, 0, 0, 0, 0x00C7, /* LATIN_CAPITAL_LETTER_C_WITH_CEDILLA */ + IBUS_dead_acute, IBUS_c, 0, 0, 0, 0x00E7, /* LATIN_SMALL_LETTER_C_WITH_CEDILLA */ + IBUS_Multi_key, IBUS_apostrophe, IBUS_C, 0, 0, 0x00C7, /* LATIN_CAPITAL_LETTER_C_WITH_CEDILLA */ + IBUS_Multi_key, IBUS_apostrophe, IBUS_c, 0, 0, 0x00E7, /* LATIN_SMALL_LETTER_C_WITH_CEDILLA */ + IBUS_Multi_key, IBUS_C, IBUS_apostrophe, 0, 0, 0x00C7, /* LATIN_CAPITAL_LETTER_C_WITH_CEDILLA */ + IBUS_Multi_key, IBUS_c, IBUS_apostrophe, 0, 0, 0x00E7, /* LATIN_SMALL_LETTER_C_WITH_CEDILLA */ +}; + +/* functions prototype */ +static void ibus_simple_engine_class_init (IBusSimpleEngineClass *klass); +static void ibus_simple_engine_init (IBusSimpleEngine *simple); +static void ibus_simple_engine_destroy (IBusSimpleEngine *simple); +static void ibus_simple_engine_reset (IBusEngine *engine); +static void ibus_simple_engine_enable (IBusEngine *engine); +static void ibus_simple_engine_disable (IBusEngine *engine); +static void ibus_simple_engine_focus_in (IBusEngine *engine); +static void ibus_simple_engine_focus_out (IBusEngine *engine); +static void ibus_simple_engine_reset (IBusEngine *engine); +static void ibus_simple_engine_property_activate + (IBusEngine *engine, + const gchar *prop_name, + guint prop_state); +static gboolean ibus_simple_engine_process_key_event + (IBusEngine *engine, + guint keyval, + guint keycode, + guint modifiers); +static void ibus_simple_engine_commit_char (IBusSimpleEngine *simple, + gunichar ch); +static void ibus_simple_engine_update_preedit_text + (IBusSimpleEngine *simple); + +G_DEFINE_TYPE (IBusSimpleEngine, ibus_simple_engine, IBUS_TYPE_ENGINE) + +static void +ibus_simple_engine_class_init (IBusSimpleEngineClass *klass) +{ + IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass); + IBusEngineClass *engine_class = IBUS_ENGINE_CLASS (klass); + gchar *lang = NULL; + + ibus_object_class->destroy = (IBusObjectDestroyFunc) ibus_simple_engine_destroy; + + engine_class->reset = ibus_simple_engine_reset; + engine_class->enable = ibus_simple_engine_enable; + engine_class->disable = ibus_simple_engine_disable; + engine_class->focus_in = ibus_simple_engine_focus_in; + engine_class->focus_out = ibus_simple_engine_focus_out; + engine_class->property_activate + = ibus_simple_engine_property_activate; + engine_class->process_key_event + = ibus_simple_engine_process_key_event; + + klass->compose_addon_table_type = IBUS_COMPOSE_TABLE_NONE; + +#ifdef ENABLE_NLS + lang = g_strdup (setlocale (LC_CTYPE, NULL)); +#endif + if (lang == NULL) { + lang = g_strdup (g_getenv ("LANG")); + } + if (lang && g_ascii_strncasecmp (lang, "pt_BR", strlen ("pt_BR")) == 0) { + klass->compose_addon_table_type = IBUS_COMPOSE_TABLE_CEDILLA; + } + g_free (lang); +} + +static void +ibus_simple_engine_init (IBusSimpleEngine *simple) +{ +#ifdef ENABLE_SETUP_GUI + IBusText *label; + IBusText *tooltip; + IBusProperty *prop; + + simple->prop_list = ibus_prop_list_new (); + + g_object_ref_sink (simple->prop_list); + label = ibus_text_new_from_string (_("Setup")); + tooltip = ibus_text_new_from_string (_("Configure XKB engine")); + prop = ibus_property_new ("setup", + PROP_TYPE_NORMAL, + label, + "gtk-preferences", + tooltip, + TRUE, TRUE, + PROP_STATE_UNCHECKED, + NULL); + g_object_ref_sink (prop); + ibus_prop_list_append (simple->prop_list, prop); +#endif +} + +static void +ibus_simple_engine_destroy (IBusSimpleEngine *simple) +{ +#ifdef ENABLE_SETUP_GUI + if (simple->prop_list) { + g_object_unref (simple->prop_list); + simple->prop_list = NULL; + } +#endif + + ((IBusObjectClass *) ibus_simple_engine_parent_class)->destroy ((IBusObject *)simple); +} + +static void +ibus_simple_engine_reset (IBusEngine *engine) +{ + IBusSimpleEngine *simple = (IBusSimpleEngine *)engine; + simple->compose_buffer[0] = 0; + + if (simple->tentative_match || simple->in_hex_sequence) { + simple->in_hex_sequence = FALSE; + simple->tentative_match = 0; + simple->tentative_match_len = 0; + ibus_engine_hide_preedit_text ((IBusEngine *)simple); + } +} + +static void +ibus_simple_engine_enable (IBusEngine *engine) +{ + IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->enable (engine); +} + +static void +ibus_simple_engine_disable (IBusEngine *engine) +{ + IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->disable (engine); +} + +static void +ibus_simple_engine_focus_in (IBusEngine *engine) +{ +#ifdef ENABLE_SETUP_GUI + IBusSimpleEngine *simple = (IBusSimpleEngine *) engine; + + ibus_engine_register_properties (engine, simple->prop_list); +#endif + IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->focus_in (engine); +} + +static void +ibus_simple_engine_focus_out (IBusEngine *engine) +{ + IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->focus_out (engine); +} + +static void +ibus_simple_engine_property_activate (IBusEngine *engine, + const gchar *prop_name, + guint prop_state) +{ + if (g_strcmp0 (prop_name, "setup") == 0) { + gchar *argv[2] = { NULL, NULL}; + gchar *path; + const gchar *libexecdir = g_getenv ("LIBEXECDIR"); + GError *error = NULL; + + if (libexecdir == NULL) { + libexecdir = LIBEXECDIR; + } + path = g_build_filename (libexecdir, "ibus-setup-xkb", NULL); + argv[0] = path; + if (!g_spawn_async (NULL, argv, NULL, 0, NULL, NULL, NULL, &error)) { + if (error) { + g_warning ("exec failure: %s", error->message); + g_error_free (error); + } + } + g_free (path); + return; + } + IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->property_activate (engine, prop_name, prop_state); +} + +static void +ibus_simple_engine_commit_char (IBusSimpleEngine *simple, + gunichar ch) +{ + g_return_if_fail (g_unichar_validate (ch)); + + if (simple->tentative_match || simple->in_hex_sequence) { + simple->in_hex_sequence = FALSE; + simple->tentative_match = 0; + simple->tentative_match_len = 0; + ibus_simple_engine_update_preedit_text (simple); + } + + ibus_engine_commit_text ((IBusEngine *)simple, + ibus_text_new_from_unichar (ch)); +} + +static void +ibus_simple_engine_update_preedit_text (IBusSimpleEngine *simple) +{ + gunichar outbuf[MAX_COMPOSE_LEN + 2]; + int len = 0; + + if (simple->in_hex_sequence) { + int hexchars = 0; + + outbuf[0] = L'u'; + len = 1; + + while (simple->compose_buffer[hexchars] != 0) { + outbuf[len] = ibus_keyval_to_unicode (simple->compose_buffer[hexchars]); + ++len; + ++hexchars; + } + g_assert (len <= MAX_COMPOSE_LEN + 1); + } + else if (simple->tentative_match) + outbuf[len++] = simple->tentative_match; + + outbuf[len] = L'\0'; + if (len == 0) { + ibus_engine_hide_preedit_text ((IBusEngine *)simple); + } + else { + IBusText *text = ibus_text_new_from_ucs4 (outbuf); + ibus_text_append_attribute (text, + IBUS_ATTR_TYPE_UNDERLINE, IBUS_ATTR_UNDERLINE_SINGLE, 0, len); + g_debug ("UpdatePreedit text=%s", text->text); + ibus_engine_update_preedit_text ((IBusEngine *)simple, text, len, TRUE); + } +} + + +/* In addition to the table-driven sequences, we allow Unicode hex + * codes to be entered. The method chosen here is similar to the + * one recommended in ISO 14755, but not exactly the same, since we + * don't want to steal 16 valuable key combinations. + * + * A hex Unicode sequence must be started with Ctrl-Shift-U, followed + * by a sequence of hex digits entered with Ctrl-Shift still held. + * Releasing one of the modifiers or pressing space while the modifiers + * are still held commits the character. It is possible to erase + * digits using backspace. + * + * As an extension to the above, we also allow to start the sequence + * with Ctrl-Shift-U, then release the modifiers before typing any + * digits, and enter the digits without modifiers. + */ +#define HEX_MOD_MASK (IBUS_CONTROL_MASK | IBUS_SHIFT_MASK) + +static gboolean +check_hex (IBusSimpleEngine *simple, + gint n_compose) +{ + gint i; + GString *str; + gulong n; + gchar *nptr = NULL; + gchar buf[7]; + + simple->tentative_match = 0; + simple->tentative_match_len = 0; + + str = g_string_new (NULL); + + i = 0; + while (i < n_compose) { + gunichar ch; + + ch = ibus_keyval_to_unicode (simple->compose_buffer[i]); + + if (ch == 0) + return FALSE; + + if (!g_unichar_isxdigit (ch)) + return FALSE; + + buf[g_unichar_to_utf8 (ch, buf)] = '\0'; + + g_string_append (str, buf); + + ++i; + } + + n = strtoul (str->str, &nptr, 16); + + /* if strtoul fails it probably means non-latin digits were used; + * we should in principle handle that, but we probably don't. + */ + if (nptr - str->str < str->len) { + g_string_free (str, TRUE); + return FALSE; + } else + g_string_free (str, TRUE); + + if (g_unichar_validate (n)) { + simple->tentative_match = n; + simple->tentative_match_len = n_compose; + } + + return TRUE; +} + +static int +compare_seq_index (const void *key, const void *value) +{ + const guint *keysyms = key; + const guint16 *seq = value; + + if (keysyms[0] < seq[0]) + return -1; + else if (keysyms[0] > seq[0]) + return 1; + return 0; +} + +static int +compare_seq (const void *key, const void *value) +{ + int i = 0; + const guint *keysyms = key; + const guint16 *seq = value; + + while (keysyms[i]) { + if (keysyms[i] < seq[i]) + return -1; + else if (keysyms[i] > seq[i]) + return 1; + + i++; + } + + return 0; +} + + +static gboolean +check_addon_table (IBusSimpleEngine *simple, + gint n_compose) +{ + IBusComposeAddOnTableType table_type; + const guint16 *data = NULL; + gint max_seq_len = 0; + gint n_seqs = 0; + gint row_stride = 0; + guint16 *seq; + + g_assert (IBUS_IS_SIMPLE_ENGINE (simple)); + + table_type = IBUS_SIMPLE_ENGINE_GET_CLASS (simple)->compose_addon_table_type; + + if (table_type == IBUS_COMPOSE_TABLE_CEDILLA) { + data = cedilla_compose_seqs; + max_seq_len = 4; + n_seqs = G_N_ELEMENTS (cedilla_compose_seqs) / (4 + 2); + } + else { + return FALSE; + } + + /* Will never match, if the sequence in the compose buffer is longer + * than the sequences in the table. Further, compare_seq (key, val) + * will overrun val if key is longer than val. */ + if (n_compose > max_seq_len) { + return FALSE; + } + + row_stride = max_seq_len + 2; + seq = bsearch (simple->compose_buffer, + data, n_seqs, + sizeof (guint16) * row_stride, + compare_seq); + + if (seq) { + guint16 *prev_seq; + + /* Back up to the first sequence that matches to make sure + * we find the exact match if their is one. + */ + while (seq > data) { + prev_seq = seq - row_stride; + if (compare_seq (simple->compose_buffer, prev_seq) != 0) { + break; + } + seq = prev_seq; + } + + /* complete sequence */ + if (n_compose == max_seq_len || seq[n_compose] == 0) { + guint16 *next_seq; + gunichar value = + 0x10000 * seq[max_seq_len] + seq[max_seq_len + 1]; + + /* We found a tentative match. See if there are any longer + * sequences containing this subsequence + */ + next_seq = seq + row_stride; + if (next_seq < data + row_stride * n_seqs) { + if (compare_seq (simple->compose_buffer, next_seq) == 0) { + simple->tentative_match = value; + simple->tentative_match_len = n_compose; + + ibus_simple_engine_update_preedit_text (simple); + + return TRUE; + } + } + + ibus_simple_engine_commit_char (simple, value); + g_debug ("U+%04X\n", value); + simple->compose_buffer[0] = 0; + } + return TRUE; + } + return FALSE; +} + +static gboolean +check_compact_table (IBusSimpleEngine *simple, + const GtkComposeTableCompact *table, + gint n_compose) +{ + gint row_stride; + guint16 *seq_index; + guint16 *seq; + gint i; + + /* Will never match, if the sequence in the compose buffer is longer + * than the sequences in the table. Further, compare_seq (key, val) + * will overrun val if key is longer than val. */ + if (n_compose > table->max_seq_len) + return FALSE; + + g_debug ("check_compact_table(n_compose=%d) [%04x, %04x, %04x, %04x]", + n_compose, + simple->compose_buffer[0], + simple->compose_buffer[1], + simple->compose_buffer[2], + simple->compose_buffer[3]); + + seq_index = bsearch (simple->compose_buffer, + table->data, + table->n_index_size, + sizeof (guint16) * table->n_index_stride, + compare_seq_index); + + if (seq_index == NULL) { + g_debug ("compact: no\n"); + return FALSE; + } + + if (n_compose == 1) { + g_debug ("compact: yes\n"); + return TRUE; + } + + g_debug ("compact: %04x ", *seq_index); + seq = NULL; + + for (i = n_compose - 1; i < table->max_seq_len; i++) { + row_stride = i + 1; + + if (seq_index[i + 1] - seq_index[i] > 0) { + seq = bsearch (simple->compose_buffer + 1, + table->data + seq_index[i], + (seq_index[i + 1] - seq_index[i]) / row_stride, + sizeof (guint16) * row_stride, + compare_seq); + g_debug ("seq = %p", seq); + + if (seq) { + if (i == n_compose - 1) + break; + else { + ibus_simple_engine_update_preedit_text (simple); + g_debug ("yes\n"); + return TRUE; + } + } + } + } + + if (!seq) { + g_debug ("no\n"); + return FALSE; + } + else { + gunichar value; + + value = seq[row_stride - 1]; + ibus_simple_engine_commit_char (simple, value); + simple->compose_buffer[0] = 0; + + g_debug ("U+%04X\n", value); + return TRUE; + } +} + +/* Checks if a keysym is a dead key. Dead key keysym values are defined in + * ../gdk/gdkkeysyms.h and the first is GDK_KEY_dead_grave. As X.Org is updated, + * more dead keys are added and we need to update the upper limit. + * Currently, the upper limit is GDK_KEY_dead_dasia+1. The +1 has to do with + * a temporary issue in the X.Org header files. + * In future versions it will be just the keysym (no +1). + */ +#define IS_DEAD_KEY(k) \ + ((k) >= IBUS_dead_grave && (k) <= (IBUS_dead_dasia+1)) + +/* This function receives a sequence of Unicode characters and tries to + * normalize it (NFC). We check for the case the the resulting string + * has length 1 (single character). + * NFC normalisation normally rearranges diacritic marks, unless these + * belong to the same Canonical Combining Class. + * If they belong to the same canonical combining class, we produce all + * permutations of the diacritic marks, then attempt to normalize. + */ +static gboolean +check_normalize_nfc (gunichar* combination_buffer, gint n_compose) +{ + gunichar combination_buffer_temp[MAX_COMPOSE_LEN]; + gchar *combination_utf8_temp = NULL; + gchar *nfc_temp = NULL; + gint n_combinations; + gunichar temp_swap; + gint i; + + n_combinations = 1; + + for (i = 1; i < n_compose; i++ ) + n_combinations *= i; + + /* Xorg reuses dead_tilde for the perispomeni diacritic mark. + * We check if base character belongs to Greek Unicode block, + * and if so, we replace tilde with perispomeni. */ + if (combination_buffer[0] >= 0x390 && combination_buffer[0] <= 0x3FF) { + for (i = 1; i < n_compose; i++ ) + if (combination_buffer[i] == 0x303) + combination_buffer[i] = 0x342; + } + + memcpy (combination_buffer_temp, combination_buffer, MAX_COMPOSE_LEN * sizeof (gunichar) ); + + for (i = 0; i < n_combinations; i++ ) { + g_unicode_canonical_ordering (combination_buffer_temp, n_compose); + combination_utf8_temp = g_ucs4_to_utf8 (combination_buffer_temp, -1, NULL, NULL, NULL); + nfc_temp = g_utf8_normalize (combination_utf8_temp, -1, G_NORMALIZE_NFC); + + if (g_utf8_strlen (nfc_temp, -1) == 1) { + memcpy (combination_buffer, combination_buffer_temp, MAX_COMPOSE_LEN * sizeof (gunichar) ); + + g_free (combination_utf8_temp); + g_free (nfc_temp); + + return TRUE; + } + + g_free (combination_utf8_temp); + g_free (nfc_temp); + + if (n_compose > 2) { + temp_swap = combination_buffer_temp[i % (n_compose - 1) + 1]; + combination_buffer_temp[i % (n_compose - 1) + 1] = combination_buffer_temp[(i+1) % (n_compose - 1) + 1]; + combination_buffer_temp[(i+1) % (n_compose - 1) + 1] = temp_swap; + } + else + break; + } + + return FALSE; +} + +static gboolean +check_algorithmically (IBusSimpleEngine *simple, + gint n_compose) + +{ + gint i; + gunichar combination_buffer[MAX_COMPOSE_LEN]; + gchar *combination_utf8, *nfc; + + if (n_compose >= MAX_COMPOSE_LEN) + return FALSE; + + for (i = 0; i < n_compose && IS_DEAD_KEY (simple->compose_buffer[i]); i++) + ; + if (i == n_compose) + return TRUE; + + if (i > 0 && i == n_compose - 1) { + combination_buffer[0] = ibus_keyval_to_unicode (simple->compose_buffer[i]); + combination_buffer[n_compose] = 0; + i--; + while (i >= 0) { + switch (simple->compose_buffer[i]) { +#define CASE(keysym, unicode) \ + case IBUS_dead_##keysym: combination_buffer[i+1] = unicode; break + CASE (grave, 0x0300); + CASE (acute, 0x0301); + CASE (circumflex, 0x0302); + CASE (tilde, 0x0303); /* Also used with perispomeni, 0x342. */ + CASE (macron, 0x0304); + CASE (breve, 0x0306); + CASE (abovedot, 0x0307); + CASE (diaeresis, 0x0308); + CASE (hook, 0x0309); + CASE (abovering, 0x030A); + CASE (doubleacute, 0x030B); + CASE (caron, 0x030C); + CASE (abovecomma, 0x0313); /* Equivalent to psili */ + CASE (abovereversedcomma, 0x0314); /* Equivalent to dasia */ + CASE (horn, 0x031B); /* Legacy use for psili, 0x313 (or 0x343). */ + CASE (belowdot, 0x0323); + CASE (cedilla, 0x0327); + CASE (ogonek, 0x0328); /* Legacy use for dasia, 0x314.*/ + CASE (iota, 0x0345); + CASE (voiced_sound, 0x3099); /* Per Markus Kuhn keysyms.txt file. */ + CASE (semivoiced_sound, 0x309A); /* Per Markus Kuhn keysyms.txt file. */ + + /* The following cases are to be removed once xkeyboard-config, + * xorg are fully updated. + */ + /* Workaround for typo in 1.4.x xserver-xorg */ + case 0xfe66: combination_buffer[i+1] = 0x314; break; + /* CASE (dasia, 0x314); */ + /* CASE (perispomeni, 0x342); */ + /* CASE (psili, 0x343); */ +#undef CASE + default: + combination_buffer[i+1] = ibus_keyval_to_unicode (simple->compose_buffer[i]); + } + i--; + } + + /* If the buffer normalizes to a single character, + * then modify the order of combination_buffer accordingly, if necessary, + * and return TRUE. + */ + if (check_normalize_nfc (combination_buffer, n_compose)) { + gunichar value; + combination_utf8 = g_ucs4_to_utf8 (combination_buffer, -1, NULL, NULL, NULL); + nfc = g_utf8_normalize (combination_utf8, -1, G_NORMALIZE_NFC); + + value = g_utf8_get_char (nfc); + ibus_simple_engine_commit_char (simple, value); + simple->compose_buffer[0] = 0; + + g_free (combination_utf8); + g_free (nfc); + + return TRUE; + } + } + + return FALSE; +} + +static gboolean +no_sequence_matches (IBusSimpleEngine *simple, + gint n_compose, + guint keyval, + guint keycode, + guint modifiers) +{ + gunichar ch; + + /* No compose sequences found, check first if we have a partial + * match pending. + */ + if (simple->tentative_match) { + gint len = simple->tentative_match_len; + int i; + + ibus_simple_engine_commit_char (simple, + simple->tentative_match); + simple->compose_buffer[0] = 0; + + for (i=0; i < n_compose - len - 1; i++) { + ibus_simple_engine_process_key_event ( + (IBusEngine *)simple, + simple->compose_buffer[len + i], + 0, 0); + } + + return ibus_simple_engine_process_key_event ( + (IBusEngine *)simple, keyval, keycode, modifiers); + } + else { + simple->compose_buffer[0] = 0; + if (n_compose > 1) { + /* Invalid sequence */ + // FIXME beep_window (event->window); + return TRUE; + } + + ch = ibus_keyval_to_unicode (keyval); + /* IBUS_CHANGE: RH#769133 + * Since we use ibus xkb engines as the disable state, + * do not commit the characters locally without in_hex_sequence. */ + if (ch != 0 && !g_unichar_iscntrl (ch) && + simple->in_hex_sequence) { + ibus_simple_engine_commit_char (simple, ch); + return TRUE; + } + else + return FALSE; + } +} + +gboolean +ibus_simple_engine_process_key_event (IBusEngine *engine, + guint keyval, + guint keycode, + guint modifiers) +{ + IBusSimpleEngine *simple = (IBusSimpleEngine *)engine; + gint n_compose = 0; + gboolean have_hex_mods; + gboolean is_hex_start; + gboolean is_hex_end; + gboolean is_backspace; + gboolean is_escape; + guint hex_keyval; + gint i; + + while (simple->compose_buffer[n_compose] != 0) + n_compose++; + + if (n_compose >= MAX_COMPOSE_LEN) + return TRUE; + + if (modifiers & IBUS_RELEASE_MASK) { + if (simple->in_hex_sequence && + (keyval == IBUS_Control_L || keyval == IBUS_Control_R || + keyval == IBUS_Shift_L || keyval == IBUS_Shift_R)) { + if (simple->tentative_match && + g_unichar_validate (simple->tentative_match)) { + ibus_simple_engine_commit_char (simple, + simple->tentative_match); + } + else if (n_compose == 0) { + simple->modifiers_dropped = TRUE; + } + else { + /* invalid hex sequence */ + /* FIXME beep_window (event->window); */ + simple->tentative_match = 0; + simple->in_hex_sequence = FALSE; + simple->compose_buffer[0] = 0; + + ibus_simple_engine_update_preedit_text (simple); + } + + return TRUE; + } + else + return FALSE; + } + + /* Ignore modifier key presses */ + for (i = 0; i < G_N_ELEMENTS (gtk_compose_ignore); i++) + if (keyval == gtk_compose_ignore[i]) + return FALSE; + + if (simple->in_hex_sequence && simple->modifiers_dropped) + have_hex_mods = TRUE; + else + have_hex_mods = (modifiers & (HEX_MOD_MASK)) == HEX_MOD_MASK; + + is_hex_start = keyval == IBUS_U; + is_hex_end = (keyval == IBUS_space || + keyval == IBUS_KP_Space || + keyval == IBUS_Return || + keyval == IBUS_ISO_Enter || + keyval == IBUS_KP_Enter); + is_backspace = keyval == IBUS_BackSpace; + is_escape = keyval == IBUS_Escape; + hex_keyval = keyval; + + /* If we are already in a non-hex sequence, or + * this keystroke is not hex modifiers + hex digit, don't filter + * key events with accelerator modifiers held down. We only treat + * Control and Alt as accel modifiers here, since Super, Hyper and + * Meta are often co-located with Mode_Switch, Multi_Key or + * ISO_Level3_Switch. + */ + if (!have_hex_mods || + (n_compose > 0 && !simple->in_hex_sequence) || + (n_compose == 0 && !simple->in_hex_sequence && !is_hex_start) || + (simple->in_hex_sequence && !hex_keyval && + !is_hex_start && !is_hex_end && !is_escape && !is_backspace)) { + if (modifiers & (IBUS_MOD1_MASK | IBUS_CONTROL_MASK) || + (simple->in_hex_sequence && simple->modifiers_dropped && + (keyval == IBUS_Return || + keyval == IBUS_ISO_Enter || + keyval == IBUS_KP_Enter))) { + return FALSE; + } + } + + /* Handle backspace */ + if (simple->in_hex_sequence && have_hex_mods && is_backspace) { + if (n_compose > 0) { + n_compose--; + simple->compose_buffer[n_compose] = 0; + check_hex (simple, n_compose); + } + else { + simple->in_hex_sequence = FALSE; + } + + ibus_simple_engine_update_preedit_text (simple); + + return TRUE; + } + + /* Check for hex sequence restart */ + if (simple->in_hex_sequence && have_hex_mods && is_hex_start) { + if (simple->tentative_match && + g_unichar_validate (simple->tentative_match)) { + ibus_simple_engine_commit_char (simple, simple->tentative_match); + } + else { + /* invalid hex sequence */ + if (n_compose > 0) { + // FIXME beep_window (event->window); + simple->tentative_match = 0; + simple->in_hex_sequence = FALSE; + simple->compose_buffer[0] = 0; + } + } + } + + /* Check for hex sequence start */ + if (!simple->in_hex_sequence && have_hex_mods && is_hex_start) { + simple->compose_buffer[0] = 0; + simple->in_hex_sequence = TRUE; + simple->modifiers_dropped = FALSE; + simple->tentative_match = 0; + + g_debug ("Start HEX MODE"); + + ibus_simple_engine_update_preedit_text (simple); + + return TRUE; + } + + /* Then, check for compose sequences */ + if (simple->in_hex_sequence) { + if (hex_keyval) + simple->compose_buffer[n_compose++] = hex_keyval; + else if (is_escape) { + // FIXME + ibus_simple_engine_reset (engine); + + return TRUE; + } + else if (!is_hex_end) { + // FIXME + /* non-hex character in hex sequence */ + // beep_window (event->window); + return TRUE; + } + } + else + simple->compose_buffer[n_compose++] = keyval; + + simple->compose_buffer[n_compose] = 0; + + if (simple->in_hex_sequence) { + /* If the modifiers are still held down, consider the sequence again */ + if (have_hex_mods) { + /* space or return ends the sequence, and we eat the key */ + if (n_compose > 0 && is_hex_end) { + if (simple->tentative_match && + g_unichar_validate (simple->tentative_match)) { + ibus_simple_engine_commit_char (simple, + simple->tentative_match); + simple->compose_buffer[0] = 0; + } + else { + // FIXME + /* invalid hex sequence */ + // beep_window (event->window); + simple->tentative_match = 0; + simple->in_hex_sequence = FALSE; + simple->compose_buffer[0] = 0; + } + } + else if (!check_hex (simple, n_compose)) + // FIXME + // beep_window (event->window); + ; + ibus_simple_engine_update_preedit_text (simple); + + return TRUE; + } + } + else { + // TODO CONT + if (check_addon_table (simple, n_compose)) { + return TRUE; + } + if (check_compact_table (simple, >k_compose_table_compact, n_compose)) + return TRUE; + + if (check_algorithmically (simple, n_compose)) + return TRUE; + } + + /* The current compose_buffer doesn't match anything */ + return no_sequence_matches (simple, n_compose, keyval, keycode, modifiers); +} diff --git a/xkb/ibus-simple-engine.h b/xkb/ibus-simple-engine.h new file mode 100644 index 0000000..dbc725a --- /dev/null +++ b/xkb/ibus-simple-engine.h @@ -0,0 +1,13 @@ +#ifndef __IBUS_SIMPLE_ENGINE_H__ +#define __IBUS_SIMPLE_ENGINE_H__ + +#include + +#define IBUS_TYPE_SIMPLE_ENGINE (ibus_simple_engine_get_type ()) +#define IBUS_IS_SIMPLE_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), IBUS_TYPE_SIMPLE_ENGINE)) +#define IBUS_SIMPLE_ENGINE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), IBUS_TYPE_SIMPLE_ENGINE, IBusSimpleEngineClass)) + +GType ibus_simple_engine_get_type (void); + +#endif // __IBUS_SIMPLE_ENGINE_H__ diff --git a/xkb/ibus-xkb-main.c b/xkb/ibus-xkb-main.c new file mode 100644 index 0000000..ef57553 --- /dev/null +++ b/xkb/ibus-xkb-main.c @@ -0,0 +1,112 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include + +#ifdef ENABLE_NLS +#include +#endif + +#include "xkblib.h" + +static gboolean get_layout = FALSE; +static gboolean get_group = FALSE; +static gchar *layout = NULL; +static gchar *model = NULL; +static gchar *option = NULL; +static int group = 0; + +static const GOptionEntry entries[] = +{ + { "get", 'g', 0, G_OPTION_ARG_NONE, &get_layout, N_("Get current xkb layout"), NULL }, + /* Translators: the "layout" should not be translated due to a variable. */ + { "layout", 'l', 0, G_OPTION_ARG_STRING, &layout, N_("Set xkb layout"), "layout" }, + { "model", 'm', 0, G_OPTION_ARG_STRING, &model, N_("Set xkb model"), "model" }, + { "option", 'o', 0, G_OPTION_ARG_STRING, &option, N_("Set xkb option"), "option" }, + { "get-group", 'G', 0, G_OPTION_ARG_NONE, &get_group, N_("Get current xkb state"), NULL }, + { NULL }, +}; + +int +main (int argc, char *argv[]) +{ + GOptionContext *context; + GError *error = NULL; + Display *xdisplay; + +#ifdef ENABLE_NLS + setlocale (LC_ALL, ""); + + bindtextdomain (GETTEXT_PACKAGE, IBUS_LOCALEDIR); + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +#endif + + context = g_option_context_new ("- ibus daemon"); + + g_option_context_set_translation_domain (context, GETTEXT_PACKAGE); + g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); + + if (!g_option_context_parse (context, &argc, &argv, &error)) { + g_printerr ("Option parsing failed: %s\n", error->message); + return -1; + } + + xdisplay = XOpenDisplay (NULL); + if (xdisplay == NULL) { + g_warning ("Could not open display"); + return -1; + } + ibus_xkb_init (xdisplay); + + if (layout) { + ibus_xkb_set_layout (layout, model, option); + } + if (get_layout) { + layout = ibus_xkb_get_current_layout (); + model = ibus_xkb_get_current_model (); + option = ibus_xkb_get_current_option (); + g_printf ("layout: %s\n" + "model: %s\n" + "option: %s\n", + layout ? layout : "", + model ? model : "", + option ? option : ""); + g_free (layout); + g_free (model); + g_free (option); + } + if (get_group) { + group = ibus_xkb_get_current_group (); + g_printf ("group: %d\n", group); + } + + ibus_xkb_finit (); + + return 0; +} diff --git a/xkb/xkblayout.xml.in b/xkb/xkblayout.xml.in new file mode 100644 index 0000000..0b5a4dc --- /dev/null +++ b/xkb/xkblayout.xml.in @@ -0,0 +1,16 @@ + + + org.freedesktop.IBus.XKB + XKB Component + @libexecdir@/ibus-engine-xkb --ibus + 0.0.0 + Takao Fujiwara <takao.fujiwara1@gmail.com> + LGPL2.1 + http://code.google.com/p/ibus/ + ibus + + @datadir@/ibus/xkb/xkblayoutconfig.xml + ~/.config/ibus/xkb/xkblayoutconfig.xml + + + diff --git a/xkb/xkblayoutconfig.xml.in b/xkb/xkblayoutconfig.xml.in new file mode 100644 index 0000000..b1212d1 --- /dev/null +++ b/xkb/xkblayoutconfig.xml.in @@ -0,0 +1,6 @@ + + + + @XKB_PRELOAD_LAYOUTS@ + + diff --git a/xkb/xkblib.c b/xkb/xkblib.c new file mode 100644 index 0000000..293cdaf --- /dev/null +++ b/xkb/xkblib.c @@ -0,0 +1,327 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include /* for XKBrules.h */ +#include +#include +#include + +#include "xkblib.h" + +#ifndef XKB_RULES_XML_FILE +#define XKB_RULES_XML_FILE "/usr/share/X11/xkb/rules/evdev.xml" +#endif + +static gchar **default_layouts; +static gchar **default_models; +static gchar **default_options; +static int default_layout_group; + +static Display * +get_xdisplay (Display *xdisplay) +{ + static Display *saved_xdisplay = NULL; + if (xdisplay != NULL) { + saved_xdisplay = xdisplay; + } + return saved_xdisplay; +} + +static void +init_xkb_default_layouts (Display *xdisplay) +{ + XkbStateRec state; + Atom xkb_rules_name, type; + int format; + unsigned long l, nitems, bytes_after; + unsigned char *prop = NULL; + + xkb_rules_name = XInternAtom (xdisplay, "_XKB_RULES_NAMES", TRUE); + if (xkb_rules_name == None) { + g_warning ("Could not get XKB rules atom"); + return; + } + if (XGetWindowProperty (xdisplay, + XDefaultRootWindow (xdisplay), + xkb_rules_name, + 0, 1024, FALSE, XA_STRING, + &type, &format, &nitems, &bytes_after, &prop) != Success) { + g_warning ("Could not get X property"); + return; + } + if (nitems < 3) { + g_warning ("Could not get group layout from X property"); + return; + } + for (l = 0; l < 2; l++) { + prop += strlen ((const char *) prop) + 1; + } + if (prop == NULL || *prop == '\0') { + g_warning ("No layouts form X property"); + return; + } + default_layouts = g_strsplit ((gchar *) prop, ",", -1); + prop += strlen ((const char *) prop) + 1; + default_models = g_strsplit ((gchar *) prop, ",", -1); + prop += strlen ((const char *) prop) + 1; + default_options = g_strsplit ((gchar *) prop, ",", -1); + + if (XkbGetState (xdisplay, XkbUseCoreKbd, &state) != Success) { + g_warning ("Could not get state"); + return; + } + default_layout_group = state.group; +} + +static Bool +set_xkb_rules (Display *xdisplay, + const char *rules_file, const char *model, + const char *all_layouts, const char *all_variants, + const char *all_options) +{ + gchar *rules_path; + XkbRF_RulesPtr rules; + XkbRF_VarDefsRec rdefs; + XkbComponentNamesRec rnames; + XkbDescPtr xkb; + + rules_path = g_strdup ("./rules/evdev"); + rules = XkbRF_Load (rules_path, "C", TRUE, TRUE); + if (rules == NULL) { + g_return_val_if_fail (XKB_RULES_XML_FILE != NULL, FALSE); + + g_free (rules_path); + if (g_str_has_suffix (XKB_RULES_XML_FILE, ".xml")) { + rules_path = g_strndup (XKB_RULES_XML_FILE, + strlen (XKB_RULES_XML_FILE) - 4); + } else { + rules_path = g_strdup (XKB_RULES_XML_FILE); + } + rules = XkbRF_Load (rules_path, "C", TRUE, TRUE); + } + g_return_val_if_fail (rules != NULL, FALSE); + + memset (&rdefs, 0, sizeof (XkbRF_VarDefsRec)); + memset (&rnames, 0, sizeof (XkbComponentNamesRec)); + rdefs.model = model ? g_strdup (model) : NULL; + rdefs.layout = all_layouts ? g_strdup (all_layouts) : NULL; + rdefs.variant = all_variants ? g_strdup (all_variants) : NULL; + rdefs.options = all_options ? g_strdup (all_options) : NULL; + XkbRF_GetComponents (rules, &rdefs, &rnames); + xkb = XkbGetKeyboardByName (xdisplay, XkbUseCoreKbd, &rnames, + XkbGBN_AllComponentsMask, + XkbGBN_AllComponentsMask & + (~XkbGBN_GeometryMask), True); + if (!xkb) { + g_warning ("Cannot load new keyboard description."); + return FALSE; + } + XkbRF_SetNamesProp (xdisplay, rules_path, &rdefs); + g_free (rules_path); + g_free (rdefs.model); + g_free (rdefs.layout); + g_free (rdefs.variant); + g_free (rdefs.options); + + return TRUE; +} + +static Bool +update_xkb_properties (Display *xdisplay, + const char *rules_file, const char *model, + const char *all_layouts, const char *all_variants, + const char *all_options) +{ + int len; + char *pval; + char *next; + Atom rules_atom; + Window root_window; + + len = (rules_file ? strlen (rules_file) : 0); + len += (model ? strlen (model) : 0); + len += (all_layouts ? strlen (all_layouts) : 0); + len += (all_variants ? strlen (all_variants) : 0); + len += (all_options ? strlen (all_options) : 0); + + if (len < 1) { + return TRUE; + } + len += 5; /* trailing NULs */ + + rules_atom = XInternAtom (xdisplay, _XKB_RF_NAMES_PROP_ATOM, False); + root_window = XDefaultRootWindow (xdisplay); + pval = next = g_new0 (char, len + 1); + if (!pval) { + return TRUE; + } + + if (rules_file) { + strcpy (next, rules_file); + next += strlen (rules_file); + } + *next++ = '\0'; + if (model) { + strcpy (next, model); + next += strlen (model); + } + *next++ = '\0'; + if (all_layouts) { + strcpy (next, all_layouts); + next += strlen (all_layouts); + } + *next++ = '\0'; + if (all_variants) { + strcpy (next, all_variants); + next += strlen (all_variants); + } + *next++ = '\0'; + if (all_options) { + strcpy (next, all_options); + next += strlen (all_options); + } + *next++ = '\0'; + if ((next - pval) != len) { + g_free (pval); + return TRUE; + } + + XChangeProperty (xdisplay, root_window, + rules_atom, XA_STRING, 8, PropModeReplace, + (unsigned char *) pval, len); + XSync(xdisplay, False); + + return TRUE; +} + +void +ibus_xkb_init (Display *xdisplay) +{ + get_xdisplay (xdisplay); + init_xkb_default_layouts (xdisplay); +} + +void +ibus_xkb_finit (void) +{ + g_strfreev (default_layouts); + default_layouts = NULL; + g_strfreev (default_models); + default_models = NULL; + g_strfreev (default_options); + default_options = NULL; +} + +gchar * +ibus_xkb_get_current_layout (void) +{ + if (default_layouts == NULL) { + g_warning ("Your system seems not to support XKB."); + return NULL; + } + + return g_strjoinv (",", (gchar **) default_layouts); +} + +gchar * +ibus_xkb_get_current_model (void) +{ + if (default_models == NULL) { + return NULL; + } + + return g_strjoinv (",", (gchar **) default_models); +} + +gchar * +ibus_xkb_get_current_option (void) +{ + if (default_options == NULL) { + return NULL; + } + + return g_strjoinv (",", (gchar **) default_options); +} + +gboolean +ibus_xkb_set_layout (const char *layouts, + const char *variants, + const char *options) +{ + Display *xdisplay; + gboolean retval; + gchar *layouts_line; + + if (default_layouts == NULL) { + g_warning ("Your system seems not to support XKB."); + return FALSE; + } + + if (layouts == NULL || g_strcmp0 (layouts, "default") == 0) { + layouts_line = g_strjoinv (",", (gchar **) default_layouts); + } else { + layouts_line = g_strdup (layouts); + } + + xdisplay = get_xdisplay (NULL); + retval = set_xkb_rules (xdisplay, + "evdev", "evdev", + layouts_line, variants, options); + update_xkb_properties (xdisplay, + "evdev", "evdev", + layouts_line, variants, options); + g_free (layouts_line); + + return retval; +} + +int +ibus_xkb_get_current_group (void) +{ + Display *xdisplay = get_xdisplay (NULL); + XkbStateRec state; + + if (default_layouts == NULL) { + g_warning ("Your system seems not to support XKB."); + return 0; + } + + if (xdisplay == NULL) { + g_warning ("ibus-xkb is not initialized."); + return 0; + } + + if (XkbGetState (xdisplay, XkbUseCoreKbd, &state) != Success) { + g_warning ("Could not get state"); + return 0; + } + + return state.group; +} diff --git a/xkb/xkblib.h b/xkb/xkblib.h new file mode 100644 index 0000000..15e5d18 --- /dev/null +++ b/xkb/xkblib.h @@ -0,0 +1,41 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifndef __XKBLIB_H_ +#define __XKBLIB_H_ + +#include + +G_BEGIN_DECLS + +void ibus_xkb_init (Display *xdisplay); +void ibus_xkb_finit (void); +gchar *ibus_xkb_get_current_layout (void); +gchar *ibus_xkb_get_current_model (void); +gchar *ibus_xkb_get_current_option (void); +gboolean ibus_xkb_set_layout (const char *layouts, + const char *variants, + const char *options); +int ibus_xkb_get_current_group (void); + +G_END_DECLS +#endif diff --git a/xkb/xkbxml.c b/xkb/xkbxml.c new file mode 100644 index 0000000..d59a929 --- /dev/null +++ b/xkb/xkbxml.c @@ -0,0 +1,345 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +#include "xkbxml.h" +#include "ibus.h" + +#define IBUS_XKB_LAYOUT_CONFIG_GET_PRIVATE(o) \ + (G_TYPE_INSTANCE_GET_PRIVATE ((o), IBUS_TYPE_XKB_LAYOUT_CONFIG, IBusXKBLayoutConfigPrivate)) + +typedef struct _IBusXKBLayoutConfigPrivate IBusXKBLayoutConfigPrivate; + +enum { + PROP_0, + PROP_SYSTEM_CONFIG_FILE, +}; + +struct _IBusXKBLayoutConfigPrivate { + gchar *system_config_file; + GList *preload_layouts; +}; + +/* functions prototype */ +static void ibus_xkb_layout_config_destroy + (IBusXKBLayoutConfig *xkb_layout_config); + +G_DEFINE_TYPE (IBusXKBLayoutConfig, ibus_xkb_layout_config, IBUS_TYPE_OBJECT) + +static void +free_lang_list (GList *list) +{ + GList *l = list; + while (l) { + g_free (l->data); + l->data = NULL; + l = l->next; + } + g_list_free (list); +} + +static GList * +parse_xkblayoutconfig_file (gchar *path) +{ + XMLNode *node = NULL; + XMLNode *sub_node; + XMLNode *sub_sub_node; + GList *p; + GList *retval = NULL; + gchar **array; + int i; + + node = ibus_xml_parse_file (path); + if (node == NULL) { + return NULL; + } + if (g_strcmp0 (node->name, "xkblayout") != 0) { + ibus_xml_free (node); + return NULL; + } + for (p = node->sub_nodes; p != NULL; p = p->next) { + sub_node = (XMLNode *) p->data; + if (g_strcmp0 (sub_node->name, "config") == 0) { + GList *pp; + for (pp = sub_node->sub_nodes; pp != NULL; pp = pp->next) { + sub_sub_node = (XMLNode *) pp->data; + if (g_strcmp0 (sub_sub_node->name, "preload_layouts") == 0) { + if (sub_sub_node->text != NULL) { + array = g_strsplit ((gchar *) sub_sub_node->text, + ",", -1); + for (i = 0; array[i]; i++) { + retval = g_list_append (retval, g_strdup (array[i])); + } + g_strfreev (array); + break; + } + } + } + } + if (retval != NULL) { + break; + } + } + + ibus_xml_free (node); + return retval; +} + +static void +parse_xkb_layout_config (IBusXKBLayoutConfigPrivate *priv) +{ + gchar *basename; + gchar *user_config; + GList *list = NULL; + + g_return_if_fail (priv->system_config_file != NULL); + + basename = g_path_get_basename (priv->system_config_file); + user_config = g_build_filename (g_get_user_config_dir (), + "ibus", "xkb", + basename, NULL); + g_free (basename); + list = parse_xkblayoutconfig_file (user_config); + g_free (user_config); + if (list) { + priv->preload_layouts = list; + return; + } + list = parse_xkblayoutconfig_file (priv->system_config_file); + priv->preload_layouts = list; +} + +static void +ibus_xkb_layout_config_init (IBusXKBLayoutConfig *xkb_layout_config) +{ + IBusXKBLayoutConfigPrivate *priv; + + priv = IBUS_XKB_LAYOUT_CONFIG_GET_PRIVATE (xkb_layout_config); + priv->system_config_file = NULL; + priv->preload_layouts = NULL; +} + +static GObject * +ibus_xkb_layout_config_constructor (GType type, + guint n_construct_params, + GObjectConstructParam *construct_params) +{ + GObject *obj; + IBusXKBLayoutConfig *xkb_layout_config; + IBusXKBLayoutConfigPrivate *priv; + + obj = G_OBJECT_CLASS (ibus_xkb_layout_config_parent_class)->constructor (type, n_construct_params, construct_params); + xkb_layout_config = IBUS_XKB_LAYOUT_CONFIG (obj); + priv = IBUS_XKB_LAYOUT_CONFIG_GET_PRIVATE (xkb_layout_config); + parse_xkb_layout_config (priv); + + return obj; +} + +static void +ibus_xkb_layout_config_destroy (IBusXKBLayoutConfig *xkb_layout_config) +{ + IBusXKBLayoutConfigPrivate *priv; + + g_return_if_fail (xkb_layout_config != NULL); + + priv = IBUS_XKB_LAYOUT_CONFIG_GET_PRIVATE (xkb_layout_config); + + g_free (priv->system_config_file); + priv->system_config_file = NULL; + free_lang_list (priv->preload_layouts); + priv->preload_layouts = NULL; +} + +static void +ibus_xkb_layout_config_set_property (IBusXKBLayoutConfig *xkb_layout_config, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + IBusXKBLayoutConfigPrivate *priv; + + g_return_if_fail (xkb_layout_config != NULL); + priv = IBUS_XKB_LAYOUT_CONFIG_GET_PRIVATE (xkb_layout_config); + + switch (prop_id) { + case PROP_SYSTEM_CONFIG_FILE: + g_assert (priv->system_config_file == NULL); + priv->system_config_file = g_strdup (g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (xkb_layout_config, prop_id, pspec); + } +} + +static void +ibus_xkb_layout_config_get_property (IBusXKBLayoutConfig *xkb_layout_config, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + IBusXKBLayoutConfigPrivate *priv; + + g_return_if_fail (xkb_layout_config != NULL); + priv = IBUS_XKB_LAYOUT_CONFIG_GET_PRIVATE (xkb_layout_config); + + switch (prop_id) { + case PROP_SYSTEM_CONFIG_FILE: + g_value_set_string (value, priv->system_config_file); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (xkb_layout_config, prop_id, pspec); + + } +} + +static void +ibus_xkb_layout_config_class_init (IBusXKBLayoutConfigClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass); + + g_type_class_add_private (klass, sizeof (IBusXKBLayoutConfigPrivate)); + + gobject_class->constructor = ibus_xkb_layout_config_constructor; + gobject_class->set_property = (GObjectSetPropertyFunc) ibus_xkb_layout_config_set_property; + gobject_class->get_property = (GObjectGetPropertyFunc) ibus_xkb_layout_config_get_property; + ibus_object_class->destroy = (IBusObjectDestroyFunc) ibus_xkb_layout_config_destroy; + + /** + * IBusProxy:interface: + * + * The interface of the proxy object. + */ + g_object_class_install_property (gobject_class, + PROP_SYSTEM_CONFIG_FILE, + g_param_spec_string ("system_config_file", + "system_config_file", + "The system file of xkblayoutconfig", + NULL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); +} + +IBusComponent * +ibus_xkb_component_new (void) +{ + IBusComponent *component; + + component = ibus_component_new ("org.freedesktop.IBus.XKB", + "XKB Component", + VERSION, + "LGPL2.1", + "Takao Fujiwara ", + "http://code.google.com/p/ibus/", + LIBEXECDIR "/ibus-engine-xkb --ibus", + GETTEXT_PACKAGE); + + return component; +} + +IBusEngineDesc * +ibus_xkb_engine_desc_new (const gchar *lang, + const gchar *layout, + const gchar *layout_desc, + const gchar *variant, + const gchar *variant_desc, + const gchar *alt_name) +{ + IBusEngineDesc *engine; + gchar *name = NULL; + gchar *longname = NULL; + gchar *desc = NULL; + gchar *engine_layout = NULL; + const gchar *name_prefix = "xkb:layout:"; + + g_return_val_if_fail (lang != NULL && layout != NULL, NULL); + + if (variant_desc) { + longname = g_strdup (variant_desc); + } else if (layout && variant) { + longname = g_strdup_printf ("%s - %s", layout, variant); + } else if (layout_desc) { + longname = g_strdup (layout_desc); + } else { + longname = g_strdup (layout); + } + if (variant) { + if (alt_name) { + name = g_strdup (alt_name); + } else { + name = g_strdup_printf ("%s%s:%s", name_prefix, layout, variant); + } + desc = g_strdup_printf ("XKB %s(%s) keyboard layout", layout, variant); + engine_layout = g_strdup_printf ("%s(%s)", layout, variant); + } else { + if (alt_name) { + name = g_strdup (alt_name); + } else { + name = g_strdup_printf ("%s%s", name_prefix, layout); + } + desc = g_strdup_printf ("XKB %s keyboard layout", layout); + engine_layout = g_strdup (layout); + } + + engine = ibus_engine_desc_new (name, + longname, + desc, + lang, + "LGPL2.1", + "Takao Fujiwara ", + "ibus-engine", + engine_layout); + + g_free (name); + g_free (longname); + g_free (desc); + g_free (engine_layout); + + return engine; +} + +IBusXKBLayoutConfig * +ibus_xkb_layout_config_new (const gchar *system_config_file) +{ + IBusXKBLayoutConfig *xkb_layout_config; + + xkb_layout_config = IBUS_XKB_LAYOUT_CONFIG (g_object_new (IBUS_TYPE_XKB_LAYOUT_CONFIG, + "system_config_file", + system_config_file, + NULL)); + return xkb_layout_config; +} + +const GList * +ibus_xkb_layout_config_get_preload_layouts (IBusXKBLayoutConfig *xkb_layout_config) +{ + IBusXKBLayoutConfigPrivate *priv; + + g_return_val_if_fail (xkb_layout_config != NULL, NULL); + priv = IBUS_XKB_LAYOUT_CONFIG_GET_PRIVATE (xkb_layout_config); + return (const GList *) priv->preload_layouts; +} diff --git a/xkb/xkbxml.h b/xkb/xkbxml.h new file mode 100644 index 0000000..6c00f1d --- /dev/null +++ b/xkb/xkbxml.h @@ -0,0 +1,113 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus + * Copyright (C) 2011 Takao Fujiwara + * Copyright (C) 2011 Peng Huang + * Copyright (C) 2011 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ +#ifndef __XKBXML_H_ +#define __XKBXML_H_ + +#include "ibus.h" + +/* + * Type macros. + */ +/* define IBusXKBLayoutConfig macros */ +#define IBUS_TYPE_XKB_LAYOUT_CONFIG \ + (ibus_xkb_layout_config_get_type ()) +#define IBUS_XKB_LAYOUT_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), IBUS_TYPE_XKB_LAYOUT_CONFIG, IBusXKBLayoutConfig)) +#define IBUS_XKB_LAYOUT_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), IBUS_TYPE_XKB_LAYOUT_CONFIG, IBusXKBLayoutConfigClass)) +#define IBUS_IS_XKB_LAYOUT_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), IBUS_TYPE_XKB_LAYOUT_CONFIG)) +#define IBUS_IS_XKB_LAYOUT_CONFIG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), IBUS_TYPE_XKB_LAYOUT_CONFIG)) +#define IBUS_XKB_LAYOUT_CONFIG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), IBUS_TYPE_XKB_LAYOUT_CONFIG, IBusXKBLayoutConfigClass)) + +G_BEGIN_DECLS + +typedef struct _IBusXKBLayoutConfig IBusXKBLayoutConfig; +typedef struct _IBusXKBLayoutConfigClass IBusXKBLayoutConfigClass; + +struct _IBusXKBLayoutConfig { + IBusObject parent; +}; + +struct _IBusXKBLayoutConfigClass { + IBusObjectClass parent; + /* signals */ + /*< private >*/ + /* padding */ + gpointer pdummy[8]; +}; + + +/** + * ibus_xkb_component_new: + * @returns: A newly allocated IBusComponent. + * + * New an IBusComponent. + */ +IBusComponent *ibus_xkb_component_new (void); + +/** + * ibus_xkb_engine_desc_new: + * @lang: Language (e.g. zh, jp) supported by this input method engine. + * @layout: Keyboard layout + * @layout_desc: Keyboard layout description for engine description + * @variant: Keyboard variant + * @variant_desc: Keyboard variant description for engine description + * @name_prefix: Name prefix for engine description, If NULL, + * the default is "xkb:layout:". + * @returns: A newly allocated IBusEngineDesc. + * + * New a IBusEngineDesc. + */ +IBusEngineDesc *ibus_xkb_engine_desc_new (const gchar *lang, + const gchar *layout, + const gchar *layout_desc, + const gchar *variant, + const gchar *variant_desc, + const gchar *name_prefix); + +GType ibus_xkb_layout_config_get_type (void); + +/** + * ibus_xkb_layout_config_new: + * @returns: A newly allocated IBusXKBLayoutConfig + * + * New an IBusXKBLayoutConfig + */ +IBusXKBLayoutConfig * + ibus_xkb_layout_config_new (const gchar *system_config_file); + +/** + * ibus_xkb_layout_config_get_preload_layouts: + * @xkb_layout_config: An IBusXKBLayoutConfig. + * @returns: A const GList + * + * a const GList + */ +const GList * ibus_xkb_layout_config_get_preload_layouts + (IBusXKBLayoutConfig *xkb_layout_config); + +G_END_DECLS +#endif -- 1.7.7.4