def __init__(self, exec_by_ibus):
self.__id = 0
engine_name = "BoGo Engine"
self.__component = \
IBus.Component.new("org.freedesktop.IBus.BoGoPython",
"BoGo Engine for IBus",
"0.2",
"GPLv3",
"Long T. Dam <*****@*****.**>",
"https://github.com/BoGoEngine/ibus-bogo-python",
"/usr/bin/exec",
"ibus-bogo")
engine = IBus.EngineDesc(name="bogo-python",
longname=engine_name,
description="BoGo Engine for IBus",
language="vi",
license="GPLv3",
author="Long T. Dam <*****@*****.**>",
icon=current_path + "/data/ibus-bogo.svg",
layout="us")
self.__component.add_engine(engine)
self.__mainloop = GObject.MainLoop()
self.__bus = IBus.Bus()
self.__bus.connect("disconnected", self.__bus_disconnected_cb)
self.__config = Config()
self.__factory = IBus.Factory.new(self.__bus.get_connection())
self.__factory.add_engine("bogo-python",
GObject.type_from_name("EngineBoGo"))
if exec_by_ibus:
self.__bus.request_name("org.freedesktop.IBus.BoGoPython", 0)
else:
self.__bus.register_component(self.__component)
self.__bus.set_global_engine_async("bogo-python", -1, None, None,
None)
def __init__(self, exec_by_ibus):
self.__mainloop = GObject.MainLoop()
self.__bus = IBus.Bus()
self.__bus.connect("disconnected", self.__bus_destroy_cb)
self.__factory = factory.EngineFactory(self.__bus)
self.destroied = False
if exec_by_ibus:
self.__bus.request_name("org.freedesktop.IBus.Sdim", 0)
else:
self.__component = IBus.Component("org.freedesktop.IBus.Sdim",
"Sdim Component", "0.1.0", "GPL",
"Yuwei Yu <*****@*****.**>")
name = 'SDIM'
longname = name
description = 'Shadow Dance Input Method'
language = 'zh'
license = 'LGPL'
author = 'Bao Haojun <*****@*****.**>'
icon = icon_dir + "/sdim.png"
if icon:
icon = os.path.join(icon_dir, icon)
if not os.access(icon, os.F_OK):
icon = ''
layout = 'us'
self.__component.add_engine(name, longname, description, language,
license, author, icon, layout)
self.__bus.register_component(self.__component)
def __init_charset_prop_menu(self):
charset_prop_list = IBus.PropList()
for charset in Config.charsets:
charset_prop_list.append(
IBus.Property(
key=charset,
prop_type=IBus.PropType.RADIO,
label=IBus.Text.new_from_string(
Config.charsets[charset][0]),
tooltip=IBus.Text.new_from_string(
Config.charsets[charset][1]),
sensitive=True,
visible=True,
state=IBus.PropState.CHECKED if Config.charsets[charset][2]
== self.output_charset else IBus.PropState.UNCHECKED,
sub_props=None))
self.__charset_prop_menu = IBus.Property(
key="charset",
prop_type=IBus.PropType.MENU,
label=IBus.Text.new_from_string(
Config.charsets['charset.' + self.output_charset][0]),
icon=None,
tooltip=IBus.Text.new_from_string("Choose charset"),
sensitive=True,
visible=True,
state=IBus.PropState.UNCHECKED,
sub_props=charset_prop_list)
return self.__charset_prop_menu
def test_component(self):
# construction with keyword args
component = IBus.Component(name='foo', description='foo desc')
self.assertEqual(component.props.name, 'foo')
# construction with non-keyword args
component = IBus.Component('bar', 'bar desc')
self.assertEqual(component.props.name, 'bar')
def __model_append_langs(self, model, langs, visible):
keys = list(langs.keys())
keys.sort(key=functools.cmp_to_key(locale.strcoll))
loc = locale.getlocale()[0]
# None on C locale
if loc == None:
loc = 'en_US'
current_lang = IBus.get_language_name(loc)
# move current language to the first place
if current_lang in keys:
keys.remove(current_lang)
keys.insert(0, current_lang)
#add "Others" to the end of the combo box
if IBus.get_language_name("Other") in keys:
keys.remove(IBus.get_language_name("Other"))
keys += [IBus.get_language_name("Other")]
for l in keys:
iter1 = model.append(None)
model.set(iter1, 0, l)
def cmp_engine(a, b):
if a.get_rank() == b.get_rank():
return locale.strcoll(a.get_longname(), b.get_longname())
return int(b.get_rank() - a.get_rank())
langs[l].sort(key=functools.cmp_to_key(cmp_engine))
for e in langs[l]:
iter2 = model.append(iter1)
model.set(iter2, 0, e)
def do_other_key(self, keyval):
"""Handle all otherwise unhandled key presses."""
c = IBus.keyval_to_unicode(keyval)
if not c or c == '\n' or c == '\r':
return False
if not self.lookuptable.get_number_of_candidates() and \
self.current_input:
# FIXME: This is really ugly
if len(self.current_input) == 1 and \
not self.cangjie.is_input_key(self.current_input):
self.get_candidates(by_shortcode=True)
else:
try:
self.get_candidates()
except cangjie.errors.CangjieNoCharsError:
self.play_error_bell()
return True
if self.lookuptable.get_number_of_candidates():
self.do_select_candidate(1)
return self.do_fullwidth_char(IBus.keyval_to_unicode(keyval))
def do_number(self, keyval):
"""Handle numeric input."""
if self.lookuptable.get_number_of_candidates():
return self.do_select_candidate(int(
IBus.keyval_to_unicode(keyval)))
return self.do_fullwidth_char(IBus.keyval_to_unicode(keyval))
def __init__(self, exec_by_ibus):
engine_name = "bogo"
long_engine_name = "BoGo"
author = "BoGo Development Team <*****@*****.**>"
description = "ibus-bogo for IBus"
version = "0.4"
license = "GPLv3"
self.component = \
IBus.Component.new("org.freedesktop.IBus.BoGo",
description,
version,
license,
author,
"https://github.com/BoGoEngine/ibus-bogo",
"/usr/bin/exec",
"ibus-bogo")
engine = IBus.EngineDesc(
name=engine_name,
longname=long_engine_name,
description=description,
language="vi",
license=license,
author=author,
icon=current_path + "/data/ibus-bogo-dev.svg",
# icon = "ibus-bogo",
layout="default")
self.component.add_engine(engine)
self.mainloop = GObject.MainLoop()
self.bus = IBus.Bus()
self.bus.connect("disconnected", self.bus_disconnected_cb)
self.engine_count = 0
self.factory = IBus.Factory.new(self.bus.get_connection())
self.factory.connect("create-engine", self.create_engine)
CONFIG_DIR = os.path.expanduser("~/.config/ibus-bogo/")
self.config = Config()
self.abbr_expander = AbbreviationExpander(config=self.config)
self.abbr_expander.watch_file(CONFIG_DIR + "/abbr_rules.json")
if exec_by_ibus:
self.bus.request_name("org.freedesktop.IBus.BoGo", 0)
else:
self.bus.register_component(self.component)
self.bus.set_global_engine_async("bogo", -1, None, None, None)
custom_broker = enchant.Broker()
custom_broker.set_param('enchant.myspell.dictionary.path', DICT_PATH)
spellchecker = enchant.DictWithPWL('vi_VN_telex',
pwl=PWL_PATH,
broker=custom_broker)
# FIXME: Catch enchant.errors.DictNotFoundError exception here.
english_spellchecker = enchant.Dict('en_US')
self.auto_corrector = AutoCorrector(self.config, spellchecker,
english_spellchecker)
def __gconf_get_lang_list_from_locale(self):
common_list = ['en', 'Other']
loc = None
try:
loc = locale.setlocale(locale.LC_ALL)
except:
pass
if loc == None:
return common_list
current_lang = IBus.get_language_name(loc)
if current_lang == None:
return common_list
group_list = self.__settings_xkblayoutconfig.get_strv('group-list')
if len(group_list) == 0:
return [loc] + common_list
lang_list = None
for group in group_list:
group = group.replace('_', '-')
langs = self.__settings_xkblayoutconfig.get_strv(group)
for lang in langs:
if current_lang == IBus.get_language_name(lang):
lang_list = langs
break
if lang_list != None:
break
if lang_list == None:
return [loc] + common_list
return lang_list + common_list
def fetch_item(self, section, key, readonly=False):
if self._config == None:
return
s = '/'.join(
[s for s in '/'.join([self._prefix, section]).split('/') if s])
try:
v = None
# gobject-introspection has a bug.
# https://bugzilla.gnome.org/show_bug.cgi?id=670509
# GLib.log_set_handler("IBUS", GLib.LogLevelFlags.LEVEL_MASK,
# self.__log_handler, False)
if self.__no_key_warning:
IBus.set_log_handler(False)
variant = self._config.get_value(s, key)
if self.__no_key_warning:
IBus.unset_log_handler()
v = self.variant_to_value(variant)
except:
v = None
if readonly:
return v != None
if v != None:
self.modified.setdefault(section, {})[key] = v if v != [''] else []
return True
def __init__(self):
IBus.init()
self.__id = 0
self.__rerun = False
self.__test_index = 0
self.__conversion_index = 0
self.__commit_done = False
def _init_props(self):
self._prop_list = IBus.PropList()
self._input_mode_prop = IBus.Property(
key='InputMode',
prop_type=IBus.PropType.NORMAL,
symbol=IBus.Text.new_from_string(self._mode),
label=IBus.Text.new_from_string(_("Input mode (%s)") % self._mode),
icon=None,
tooltip=None,
sensitive=False,
visible=True,
state=IBus.PropState.UNCHECKED,
sub_props=None)
self._prop_list.append(self._input_mode_prop)
prop = IBus.Property(key='Setup',
prop_type=IBus.PropType.NORMAL,
label=IBus.Text.new_from_string(_("Setup")),
icon=None,
tooltip=None,
sensitive=True,
visible=True,
state=IBus.PropState.UNCHECKED,
sub_props=None)
self._prop_list.append(prop)
prop = IBus.Property(key='About',
prop_type=IBus.PropType.NORMAL,
label=IBus.Text.new_from_string(
_("About Hiragana IME...")),
icon=None,
tooltip=None,
sensitive=True,
visible=True,
state=IBus.PropState.UNCHECKED,
sub_props=None)
self._prop_list.append(prop)
def __model_append_langs(self, model, langs, visible):
keys = langs.keys()
keys.sort(locale.strcoll)
loc = locale.getlocale()[0]
# None on C locale
if loc == None:
loc = 'en_US'
current_lang = IBus.get_language_name(loc)
# move current language to the first place
if current_lang in keys:
keys.remove(current_lang)
keys.insert(0, current_lang)
#add "Others" to the end of the combo box
if IBus.get_language_name("Other") in keys:
keys.remove(IBus.get_language_name("Other"))
keys += [IBus.get_language_name("Other")]
for l in keys:
iter1 = model.append(None)
model.set(iter1, 0, l)
def cmp_engine(a, b):
if a.get_rank() == b.get_rank():
return locale.strcoll(a.get_longname(), b.get_longname())
return int(b.get_rank() - a.get_rank())
langs[l].sort(cmp_engine)
for e in langs[l]:
iter2 = model.append(iter1)
model.set(iter2, 0, e)
def __gconf_get_lang_list_from_locale(self):
common_list = ['en', 'Other']
if self.__config == None:
return None
loc = None
try:
loc = locale.setlocale (locale.LC_ALL)
except:
pass
if loc == None:
return common_list
current_lang = IBus.get_language_name(loc)
if current_lang == None:
return common_list
group_list = self.__config.get_value("general/xkblayoutconfig",
"group_list")
if group_list == None:
return [loc] + common_list
group_list = list(group_list)
lang_list = None
for group in group_list:
group = str(group)
langs = list(self.__config.get_value("general/xkblayoutconfig",
group))
for lang in langs:
lang = str(lang)
if current_lang == IBus.get_language_name(lang):
lang_list = langs
break
if lang_list != None:
break
if lang_list == None:
return [loc] + common_list
return lang_list + common_list
def __init_method_prop_menu(self):
method_prop_list = IBus.PropList()
for method in Config.methods:
method_prop_list.append(
IBus.Property(
key=method,
prop_type=IBus.PropType.RADIO,
label=IBus.Text.new_from_string(Config.methods[method][0]),
icon=None,
tooltip=IBus.Text.new_from_string(
Config.methods[method][1]),
sensitive=True,
visible=True,
state=IBus.PropState.CHECKED if method == self.input_method
else IBus.PropState.UNCHECKED,
sub_props=None))
self.__method_prop_menu = IBus.Property(
key="method",
prop_type=IBus.PropType.MENU,
label=IBus.Text.new_from_string(
Config.methods['im.' + self.input_method][0]),
icon=None,
tooltip=IBus.Text.new_from_string("Choose typing method"),
sensitive=True,
visible=True,
state=IBus.PropState.UNCHECKED,
sub_props=method_prop_list)
return self.__method_prop_menu
def init_properties(self):
self.prop_list = IBus.PropList()
for (key, label) in (("halfwidth-chars", _("Half-Width Characters")),
):
stored_value = self.settings.get_boolean(key)
state = IBus.PropState.CHECKED if stored_value else IBus.PropState.UNCHECKED
try:
# Try the new constructor from IBus >= 1.5
prop = IBus.Property(key=key,
prop_type=IBus.PropType.TOGGLE,
label=label,
icon='',
sensitive=True,
visible=True,
state=state,
sub_props=None)
except TypeError:
# IBus 1.4.x didn't have the GI overrides for the nice
# constructor, so let's do it the old, non-pythonic way.
# IBus.Property.new(key, type, label, icon, tooltip,
# sensitive, visible, state, sub_props)
prop = IBus.Property.new(key, IBus.PropType.TOGGLE,
IBus.Text.new_from_string(label),
'', IBus.Text.new_from_string(''),
True, True, state, None)
self.prop_list.append(prop)
def __init__(self, keyval, keycode, state):
self.val = keyval
self.code = keycode
self.state = state
self.name = IBus.keyval_name(self.val)
self.unicode = IBus.keyval_to_unicode(self.val)
self.shift = self.state & IBus.ModifierType.SHIFT_MASK != 0
self.lock = self.state & IBus.ModifierType.LOCK_MASK != 0
self.control = self.state & IBus.ModifierType.CONTROL_MASK != 0
self.super = self.state & IBus.ModifierType.SUPER_MASK != 0
self.hyper = self.state & IBus.ModifierType.HYPER_MASK != 0
self.meta = self.state & IBus.ModifierType.META_MASK != 0
# mod1: Usually Alt_L (0x40), Alt_R (0x6c), Meta_L (0xcd)
self.mod1 = self.state & IBus.ModifierType.MOD1_MASK != 0
# mod2: Usually Num_Lock (0x4d)
self.mod2 = self.state & IBus.ModifierType.MOD2_MASK != 0
self.mod3 = self.state & IBus.ModifierType.MOD3_MASK != 0
# mod4: Usually Super_L (0xce), Hyper_L (0xcf)
self.mod4 = self.state & IBus.ModifierType.MOD4_MASK != 0
# mod5: ISO_Level3_Shift (0x5c), Mode_switch (0xcb)
self.mod5 = self.state & IBus.ModifierType.MOD5_MASK != 0
self.button1 = self.state & IBus.ModifierType.BUTTON1_MASK != 0
self.button2 = self.state & IBus.ModifierType.BUTTON2_MASK != 0
self.button3 = self.state & IBus.ModifierType.BUTTON3_MASK != 0
self.button4 = self.state & IBus.ModifierType.BUTTON4_MASK != 0
self.button5 = self.state & IBus.ModifierType.BUTTON5_MASK != 0
self.release = self.state & IBus.ModifierType.RELEASE_MASK != 0
# MODIFIER_MASK: Modifier mask for the all the masks above
self.modifier = self.state & IBus.ModifierType.MODIFIER_MASK != 0
def __init__(self, exec_by_ibus):
command_line = config.LIBEXECDIR + '/ibus-engine-anthy --ibus'
self.__component = IBus.Component(
name='org.freedesktop.IBus.Anthy',
description='Anthy Component',
version='0.1.0',
license='GPL',
author='Peng Huang <*****@*****.**>',
homepage='https://github.com/ibus/ibus/wiki',
command_line=command_line,
textdomain='ibus-anthy')
engine = IBus.EngineDesc(name='anthy',
longname='Anthy',
description='Anthy Input Method',
language='ja',
license='GPL',
author='Peng Huang <*****@*****.**>',
icon='ibus-anthy',
layout=config.LAYOUT,
symbol=config.SYMBOL_CHAR,
rank=99)
self.__component.add_engine(engine)
self.__mainloop = GLib.MainLoop()
self.__bus = IBus.Bus()
self.__bus.connect('disconnected', self.__bus_disconnected_cb)
self.__factory = factory.EngineFactory(self.__bus)
if exec_by_ibus:
self.__bus.request_name('org.freedesktop.IBus.Anthy', 0)
else:
self.__bus.register_component(self.__component)
def do_other_key(self, keyval):
"""Handle all otherwise unhandled key presses."""
c = IBus.keyval_to_unicode(keyval)
if not c or c == '\n' or c == '\r':
return False
if not self.lookuptable.get_number_of_candidates() and \
self.current_input:
# FIXME: This is really ugly
if len(self.current_input) == 1 and \
not self.cangjie.is_input_key(self.current_input):
self.get_candidates(by_shortcode=True)
else:
try:
self.get_candidates()
except cangjie.errors.CangjieNoCharsError:
self.play_error_bell()
return True
if self.lookuptable.get_number_of_candidates():
self.do_select_candidate(1)
return self.do_fullwidth_char(IBus.keyval_to_unicode(keyval))
def __init__(self, exec_by_ibus):
self._mainloop = GLib.MainLoop()
self._bus = IBus.Bus()
self._bus.connect("disconnected", self._bus_disconnected_cb)
self._factory = IBus.Factory(self._bus)
self._factory.add_engine("hiragana",
GObject.type_from_name("EngineHiragana"))
if exec_by_ibus:
self._bus.request_name("org.freedesktop.IBus.Hiragana", 0)
else:
self._component = IBus.Component(
name="org.freedesktop.IBus.Hiragana",
description="Hiragana IME",
version=package.get_version(),
license="Apache",
author="Esrille Inc. <*****@*****.**>",
homepage="https://github.com/esrille/" + package.get_name(),
textdomain=package.get_name())
engine = IBus.EngineDesc(name="hiragana",
longname="Hiragana IME",
description="Hiragana IME",
language="ja",
license="Apache",
author="Esrille Inc. <*****@*****.**>",
icon=package.get_name(),
layout="default")
self._component.add_engine(engine)
self._bus.register_component(self._component)
self._bus.set_global_engine_async("hiragana", -1, None, None, None)
def __init_charset_prop_menu(self):
charset_prop_list = IBus.PropList()
for charset in self.__charset_list:
charset_prop_list.append(
IBus.Property(key=charset,
prop_type=IBus.PropType.RADIO,
label=IBus.Text.new_from_string(charset),
icon='',
tooltip=IBus.Text.new_from_string(charset),
sensitive=True,
visible=True,
state=IBus.PropState.CHECKED if charset == "UTF8"
else IBus.PropState.UNCHECKED,
sub_props=None))
charset_prop_menu = IBus.Property(
key="charset",
prop_type=IBus.PropType.MENU,
label=IBus.Text.new_from_string("Charset"),
icon="gtk-preferences",
tooltip=IBus.Text.new_from_string("Choose charset"),
sensitive=True,
visible=True,
state=IBus.PropState.UNCHECKED,
sub_props=charset_prop_list)
return charset_prop_menu
def __init__(self):
"""initialize the newly created engine
"""
self.properties = IBus.PropList()
# self.properties.append(IBus.Property(
# key='source',
# type=IBus.PropType.NORMAL,
# label='Microphone',
# tooltip='ALSA device such as hw:0,0 or hw:1,0 (see arecord -l for ids)',
# visible=True,
# ))
self.properties.append(
IBus.Property(
key='listening',
type=IBus.PropType.TOGGLE,
label='DeepSpeech',
tooltip='Toggle whether the engine is currently listening',
visible=True,
))
# self.lookup_table = IBus.LookupTable.new(
# 5, 0, True, True, # size # index, # cursor visible # round
# )
# self.lookup_table_content = []
# self.interpreter_rules, self.rule_set = interpreter.load_rules(
# interpreter.good_commands,
# )
# self.lookup_table.ref_sink()
super(ListenerEngine, self).__init__()
def __init__(self, keyval, keycode, state):
self.val = keyval
self.code = keycode
self.state = state
self.name = IBus.keyval_name(self.val)
self.unicode = IBus.keyval_to_unicode(self.val)
self.shift = self.state & IBus.ModifierType.SHIFT_MASK != 0
self.lock = self.state & IBus.ModifierType.LOCK_MASK != 0
self.control = self.state & IBus.ModifierType.CONTROL_MASK != 0
self.mod1 = self.state & IBus.ModifierType.MOD1_MASK != 0
self.mod2 = self.state & IBus.ModifierType.MOD2_MASK != 0
self.mod3 = self.state & IBus.ModifierType.MOD3_MASK != 0
self.mod4 = self.state & IBus.ModifierType.MOD4_MASK != 0
self.mod5 = self.state & IBus.ModifierType.MOD5_MASK != 0
self.button1 = self.state & IBus.ModifierType.BUTTON1_MASK != 0
self.button2 = self.state & IBus.ModifierType.BUTTON2_MASK != 0
self.button3 = self.state & IBus.ModifierType.BUTTON3_MASK != 0
self.button4 = self.state & IBus.ModifierType.BUTTON4_MASK != 0
self.button5 = self.state & IBus.ModifierType.BUTTON5_MASK != 0
self.super = self.state & IBus.ModifierType.SUPER_MASK != 0
self.hyper = self.state & IBus.ModifierType.HYPER_MASK != 0
self.meta = self.state & IBus.ModifierType.META_MASK != 0
self.release = self.state & IBus.ModifierType.RELEASE_MASK != 0
# MODIFIER_MASK: Modifier mask for the all the masks above
self.modifier = self.state & IBus.ModifierType.MODIFIER_MASK != 0
def __init__(self):
self.__init_curses()
self.__bus = IBus.Bus()
self.__ic_path = self.__bus.create_input_context("DemoTerm")
#self.__ic = IBus.InputContext(self.__bus, self.__ic_path, True)
self.__ic = IBus.InputContext()
self.__ic.set_capabilities(7)
self.__ic.connect("commit-text", self.__commit_text_cb)
self.__ic.connect("update-preedit-text", self.__update_preedit_text_cb)
self.__ic.connect("show-preedit-text", self.__show_preedit_text_cb)
self.__ic.connect("hide-preedit-text", self.__hide_preedit_text_cb)
self.__ic.connect("update-auxiliary-text", self.__update_aux_text_cb)
self.__ic.connect("show-auxiliary-text", self.__show_aux_text_cb)
self.__ic.connect("hide-auxiliary-text", self.__hide_aux_text_cb)
self.__ic.connect("update-lookup-table", self.__update_lookup_table_cb)
self.__ic.connect("show-lookup-table", self.__show_lookup_table_cb)
self.__ic.connect("hide-lookup-table", self.__hide_lookup_table_cb)
GLib.io_add_watch(0, GLib.IO_IN, self.__stdin_cb)
# GLib.timeout_add(500, self.__timeout_cb)
# self.__master_fd, self.__slave_fd = os.openpty()
# self.__run_shell()
self.__is_invalidate = False
self.__preedit = None
self.__preedit_visible = False
self.__aux_string = None
self.__aux_string_visible = False
self.__lookup_table = None
self.__lookup_table_visible = False
def register_ibus_engine(self) -> bool:
self.__bus = IBus.Bus()
if not self.__bus.is_connected():
self.fail('ibus-daemon is not running')
return False
self.__bus.get_connection().signal_subscribe(
'org.freedesktop.DBus', 'org.freedesktop.DBus', 'NameOwnerChanged',
'/org/freedesktop/DBus', None, 0, self.__bus_signal_cb, self.__bus)
self.__factory = IBus.Factory(object_path=IBus.PATH_FACTORY,
connection=self.__bus.get_connection())
self.__factory.connect('create-engine', self.__create_engine_cb)
self.__component = IBus.Component(
name='org.freedesktop.IBus.TypingBooster.Test',
description='Test Typing Booster Component',
version='1.0',
license='GPL',
author=('Mike FABIAN <*****@*****.**>, ' +
'Anish Patil <*****@*****.**>'),
homepage='http://mike-fabian.github.io/ibus-typing-booster',
command_line='',
textdomain='ibus-typing-booster')
desc = IBus.EngineDesc(
name='testTyping-booster',
longname='Test Typing Booster',
description='Test a completion input method to speedup typing.',
language='t',
license='GPL',
author=('Mike FABIAN <*****@*****.**>, ' +
'Anish Patil <*****@*****.**>'),
icon='',
symbol='T')
self.__component.add_engine(desc)
self.__bus.register_component(self.__component)
self.__bus.request_name('org.freedesktop.IBus.TypingBooster.Test', 0)
return True
def test_property(self):
# construction with keyword args
prop = IBus.Property(key='foo')
self.assertEqual(prop.props.key, 'foo')
# construction with non-keyword args
prop = IBus.Property('bar')
self.assertEqual(prop.props.key, 'bar')
def test_engine_desc(self):
# construction with keyword args
desc = IBus.EngineDesc(name='foo')
self.assertEqual(desc.props.name, 'foo')
# construction with non-keyword args
desc = IBus.EngineDesc('bar')
self.assertEqual(desc.props.name, 'bar')
def __init__(self, engine, delay, layout):
self.__engine = engine
self.__delay = delay # Delay for non-shift keys in milliseconds (mainly for Nicola layout)
self.MODIFIERS = (keysyms.Shift_L, keysyms.Shift_R, keysyms.Control_L,
keysyms.Control_R, keysyms.Alt_L, keysyms.Alt_R)
# Set to the default values
self.__OnOffByCaps = True # or False
self.__SandS = False # True if SandS is used
self.__Henkan = keysyms.space # or keysyms.Henkan
self.__Muhenkan = keysyms.VoidSymbol # or keysyms.Muhenkan
self.__Eisuu = keysyms.VoidSymbol # or keysyms.Eisu_toggle
self.__Kana = keysyms.Control_R # or keysyms.Hiragana_Katakana, keysyms.Control_R
self.__Space = keysyms.Shift_R # Extra space key in Kana mode
self.__Prefix = False # True if Shift is to be prefixed
self.__HasYen = False
self.__DualBits = bits.Dual_ShiftL_Bit
if "Keyboard" in layout:
keyboard = layout["Keyboard"]
if keyboard == "109":
self.__Henkan = keysyms.VoidSymbol
self.__Muhenkan = keysyms.VoidSymbol
self.__Kana = keysyms.Hiragana_Katakana
self.__Eisuu = keysyms.Eisu_toggle
self.__Space = keysyms.VoidSymbol
if "OnOffByCaps" in layout:
self.__OnOffByCaps = layout["OnOffByCaps"]
if "HasYen" in layout:
self.__HasYen = layout["HasYen"]
if "SandS" in layout:
self.__SandS = layout["SandS"]
if self.__SandS:
self.__DualBits |= bits.Dual_Space_Bit
elif "Prefix" in layout:
self.__Prefix = layout["Prefix"]
if self.__Prefix:
self.__DualBits |= bits.Dual_Space_Bit
if "Space" in layout:
self.__Space = IBus.keyval_from_name(layout["Space"])
if "Henkan" in layout:
self.__Henkan = IBus.keyval_from_name(layout["Henkan"])
if "Muhenkan" in layout:
self.__Muhenkan = IBus.keyval_from_name(layout["Muhenkan"])
# Check dual role modifiers
for k in (self.__Henkan, self.__Muhenkan, self.__Kana, self.__Space):
if k in self.MODIFIERS:
self.__DualBits |= bits.Dual_ShiftL_Bit << self.MODIFIERS.index(
k)
# Current event
self.__keyval = keysyms.VoidSymbol
self.__keycode = 0
self.reset()
def __has_engine_in_lang_list(self, engine, lang_list):
retval = False
for lang in lang_list:
if IBus.get_language_name(lang) == \
IBus.get_language_name(engine.props.language):
retval = True
break
return retval
def __sort_engines(self, model, a, b, data):
engine_a = model[a][0]
engine_b = model[b][0]
language_a = IBus.get_language_name(engine_a.get_language())
language_b = IBus.get_language_name(engine_b.get_language())
label_a = "%s - %s" % (language_a, engine_a.get_longname())
label_b = "%s - %s" % (language_b, engine_b.get_longname())
return cmp(label_a, label_b)
def __has_engine_in_lang_list(self, engine, lang_list):
retval = False
for lang in lang_list:
if IBus.get_language_name(lang) == \
IBus.get_language_name(engine.props.language):
retval = True
break
return retval
def __sort_engines(self, model, a, b, data):
engine_a = model[a][0]
engine_b = model[b][0]
language_a = IBus.get_language_name(engine_a.get_language())
language_b = IBus.get_language_name(engine_b.get_language())
label_a = "%s - %s" % (language_a, engine_a.get_longname())
label_b = "%s - %s" % (language_b, engine_b.get_longname())
return cmp(label_a, label_b)
def __init__(self):
super(EngineEnchant, self).__init__()
self.__is_invalidate = False
self.__preedit_string = ""
self.__lookup_table = IBus.LookupTable.new(10, 0, True, True)
self.__prop_list = IBus.PropList()
self.__prop_list.append(IBus.Property(key="test", icon="ibus-local"))
print("Create EngineEnchant OK")
def __sort_engines(self, model, a, b, data):
engine_a = model[a][0]
engine_b = model[b][0]
language_a = IBus.get_language_name(engine_a.get_language())
language_b = IBus.get_language_name(engine_b.get_language())
label_a = "%s - %s" % (language_a, engine_a.get_longname())
label_b = "%s - %s" % (language_b, engine_b.get_longname())
# http://docs.python.org/3.0/whatsnew/3.0.html#ordering-comparisons
return (label_a > label_b) - (label_a < label_b)
def test_lookup_table(self):
# construction with keyword args
table = IBus.LookupTable(page_size=6)
self.assertEqual(table.page_size, 6)
# construction with non-keyword args
table = IBus.LookupTable()
self.assertEqual(table.page_size, 5)
table = IBus.LookupTable(7)
self.assertEqual(table.page_size, 7)
def __sort_engines(self, model, a, b, data):
engine_a = model[a][0]
engine_b = model[b][0]
language_a = IBus.get_language_name(engine_a.get_language())
language_b = IBus.get_language_name(engine_b.get_language())
label_a = "%s - %s" % (language_a, engine_a.get_longname())
label_b = "%s - %s" % (language_b, engine_b.get_longname())
# http://docs.python.org/3.0/whatsnew/3.0.html#ordering-comparisons
return (label_a > label_b) - (label_a < label_b)
def __init__(self, engine, delay, layout):
self._engine = engine
self._delay = delay # Delay for non-shift keys in milliseconds (mainly for Nicola layout)
# Set to the default values
self._OnOffByCaps = True # or False
self._SandS = False # True if SandS is used
self._Henkan = keysyms.VoidSymbol # or keysyms.Henkan, keysyms.space
self._Muhenkan = keysyms.VoidSymbol # or keysyms.Muhenkan
self._Eisuu = keysyms.VoidSymbol # or keysyms.Eisu_toggle
self._Kana = keysyms.VoidSymbol # or keysyms.Hiragana_Katakana, keysyms.Control_R
self._Space = keysyms.VoidSymbol # Extra space key
self._Shrink = keysyms.VoidSymbol
self._Prefix = False # True if Shift is to be prefixed
self._HasYen = False
self._DualBits = DUAL_SHIFT_L_BIT
if layout.get("Keyboard") == "109":
self._Kana = keysyms.Hiragana_Katakana
self._Eisuu = keysyms.Eisu_toggle
self._OnOffByCaps = layout.get("OnOffByCaps", self._OnOffByCaps)
self._HasYen = layout.get("HasYen", self._HasYen)
self._SandS = layout.get("SandS", False)
if self._SandS:
self._DualBits |= DUAL_SPACE_BIT
else:
self._Prefix = layout.get("Prefix", False)
if self._Prefix:
self._DualBits |= DUAL_SPACE_BIT
if "Space" in layout:
self._Space = IBus.keyval_from_name(layout["Space"])
if "Henkan" in layout:
self._Henkan = IBus.keyval_from_name(layout["Henkan"])
if "Muhenkan" in layout:
self._Muhenkan = IBus.keyval_from_name(layout["Muhenkan"])
if "Katakana" in layout:
self._Kana = IBus.keyval_from_name(layout["Katakana"])
if "Shrink" in layout:
self._Shrink = IBus.keyval_from_name(layout["Shrink"])
# Check dual role modifiers
self._capture_alt_r = False
for k in (self._Henkan, self._Muhenkan, self._Kana, self._Space,
self._Shrink):
if k in MODIFIERS:
self._DualBits |= DUAL_SHIFT_L_BIT << MODIFIERS.index(k)
if k == keysyms.Alt_R:
self._capture_alt_r = True
# Current event
self._keyval = keysyms.VoidSymbol
self._keycode = 0
self.reset()
def get_value_direct(self, section, key, default=None):
s = section
section = '/'.join(
[s for s in '/'.join([self._prefix, section]).split('/') if s])
try:
if self.__no_key_warning:
IBus.set_log_handler(False)
variant = self._config.get_value(section, key)
if self.__no_key_warning:
IBus.unset_log_handler()
return self.variant_to_value(variant)
except:
return default
def set_engines(self, engines):
self.__model = Gtk.TreeStore(object)
iter1 = self.__model.append(None)
self.__model.set(iter1, 0, 0)
lang_list = self.__gconf_get_lang_list_from_locale()
lang = {}
sub_lang = {}
for e in engines:
l = IBus.get_language_name(e.props.language)
if lang_list == None or \
self.__has_engine_in_lang_list(e, lang_list):
if l not in lang:
lang[l] = []
lang[l].append(e)
else:
if l not in sub_lang:
sub_lang[l] = []
sub_lang[l].append(e)
self.__model_append_langs(self.__model, lang, True)
iter1 = self.__model.append(None)
self.__model.set(iter1, 0, -1)
self.__all_model = Gtk.TreeStore(object)
iter1 = self.__all_model.append(None)
self.__all_model.set(iter1, 0, 0)
self.__model_append_langs(self.__all_model, lang, False)
iter1 = self.__all_model.append(None)
self.__all_model.set(iter1, 0, -1)
self.__model_append_langs(self.__all_model, sub_lang, False)
self.__toggle_sub_lang()
def __fill_text_view(self):
text_buffer = self.__text_view.get_buffer()
self.__create_tags(text_buffer)
iter = text_buffer.get_iter_at_offset(0)
text_buffer.insert_with_tags_by_name(iter, "\n ",
"left_margin_16")
text_buffer.insert_pixbuf(iter,
self.__load_icon(self.__engine_desc.get_icon()))
text_buffer.insert_with_tags_by_name(iter,
"\n%s\n" % self.__engine_desc.get_longname(),
"heading", "left_margin_16")
text_buffer.insert_with_tags_by_name(iter,
_("Language: %s\n") % IBus.get_language_name(self.__engine_desc.get_language()),
"small", "bold", "left_margin_16")
text_buffer.insert_with_tags_by_name(iter,
_("Keyboard layout: %s\n") % self.__engine_desc.get_layout(),
"small", "bold", "left_margin_16")
text_buffer.insert_with_tags_by_name(iter,
_("Author: %s\n") % self.__engine_desc.get_author(),
"small", "bold", "left_margin_16")
text_buffer.insert_with_tags_by_name(iter,
_("Description:\n"), "small", "bold", "left_margin_16")
text_buffer.insert_with_tags_by_name(iter,
self.__engine_desc.get_description(),
"wrap_text", "left_margin_32")
def __s_to_key_raw(self, s):
keyval = IBus.keyval_from_name(s.split('+')[-1])
s = s.lower()
state = ('shift+' in s and IBus.ModifierType.SHIFT_MASK or 0) | (
'ctrl+' in s and IBus.ModifierType.CONTROL_MASK or 0) | (
'alt+' in s and IBus.ModifierType.MOD1_MASK or 0)
return (keyval, state)
def set_keys_and_shortcuts_to_ui(self,widget,data=None):
for item in self.key_dict.keys():
widget = self.guibuilder.get_object(item)
hardware_keycode = int(self.config.get('cfg',item))
map = Gdk.Keymap.get_default()
var1, var2, var3 = map.get_entries_for_keycode(hardware_keycode+8)
text = IBus.keyval_to_unicode(var3[0])
widget.set_text(text)
def set_engines(self, engines):
self.__model = Gtk.TreeStore(object)
iter1 = self.__model.append(None)
self.__model.set(iter1, 0, 0)
langs = {}
for e in engines:
l = IBus.get_language_name(e.get_language())
if l == None:
l = ""
if l not in langs:
langs[l] = []
langs[l].append(e)
keys = langs.keys()
keys.sort(locale.strcoll)
loc = locale.getlocale()[0]
# None on C locale
if loc == None:
loc = "en_US"
current_lang = IBus.get_language_name(loc)
# move current language to the first place
if current_lang in keys:
keys.remove(current_lang)
keys.insert(0, current_lang)
# add "Others" to the end of the combo box
if IBus.get_language_name("Other") in keys:
keys.remove(IBus.get_language_name("Other"))
keys += [IBus.get_language_name("Other")]
for l in keys:
iter1 = self.__model.append(None)
self.__model.set(iter1, 0, l)
def cmp_engine(a, b):
if a.get_rank() == b.get_rank():
return locale.strcoll(a.get_longname(), b.get_longname())
return int(b.get_rank() - a.get_rank())
langs[l].sort(cmp_engine)
for e in langs[l]:
iter2 = self.__model.append(iter1)
self.__model.set(iter2, 0, e)
self.set_model(self.__model)
self.set_active(0)
def __load_lang_list(self):
dictdir = os.path.dirname(__file__) + '/../dicts'
for filename in os.listdir(dictdir):
suffix = '.dict'
if not filename.endswith(suffix):
continue
lang_id = filename[0:len(filename) - len(suffix)]
prefix = 'emoji-'
if not lang_id.startswith(prefix):
continue
lang_id = lang_id[len(prefix):]
lang = LanguageString(lang_id, IBus.get_language_name(lang_id))
self.__lang_list.append(lang)
if len(self.__lang_list) == 0:
print("Not found dicts in %s" % dictdir, file=sys.stderr)
lang = LanguageString('en', IBus.get_language_name('en'))
self.__lang_list.append(lang)
return
def cmp_lang(a, b):
label_a = a.trans + a.id
label_b = b.trans + b.id
return (label_a > label_b) - (label_a < label_b)
self.__lang_list.sort(key = functools.cmp_to_key(cmp_lang))
loc = locale.getlocale()[0]
# None on C locale
if loc == None or loc == 'C':
loc = 'en_US'
index = 0
for lang in self.__lang_list:
# move current language to the first place
if lang.trans == IBus.get_language_name(loc):
self.__lang_list.remove(lang)
self.__lang_list.insert(index, lang)
index += 1
for lang in self.__lang_list:
# move English to the second place
if lang.trans == IBus.get_language_name('en'):
self.__lang_list.remove(lang)
self.__lang_list.insert(index, lang)
index += 1
def __name_cell_data_cb(self, celllayout, renderer, model, it, data):
engine = self.__model.get_value(it, 0)
renderer.set_property("sensitive", True)
language = IBus.get_language_name(engine.get_language())
renderer.set_property("text", "%s - %s" % (language, engine.get_longname()))
if self.__model.get_path(it).get_indices()[0] == 0:
# default engine
renderer.set_property("weight", Pango.Weight.BOLD)
else:
renderer.set_property("weight", Pango.Weight.NORMAL)
def __name_cell_data_cb(self, celllayout, renderer, model, it, data):
engine = self.__model.get_value(it, 0)
# When append_engine() is called, self.__model.append(None)
# is called internally and engine == None could happen in
# a slow system.
if engine == None:
return
renderer.set_property("sensitive", True)
language = IBus.get_language_name(engine.get_language())
renderer.set_property("text",
"%s - %s" % (language, engine.get_longname()))
renderer.set_property("weight", Pango.Weight.NORMAL)
def do_process_key_event(self, keyval, keycode, state):
"""Handle `process-key-event` events.
This event is fired when the user presses a key.
"""
# Ignore key release events
if (state & IBus.ModifierType.RELEASE_MASK):
return False
# Work around integer overflow bug on 32 bits systems:
# https://bugzilla.gnome.org/show_bug.cgi?id=693121
# The bug is fixed in pygobject 3.7.91, but many distributions will
# ship the previous version for some time. (e.g Fedora 18)
if (state & 1073741824):
return False
if state & (IBus.ModifierType.CONTROL_MASK |
IBus.ModifierType.MOD1_MASK):
# Ignore Alt+<key> and Ctrl+<key>
return False
if keyval == IBus.Escape:
return self.do_cancel_input()
if keyval == IBus.space:
return self.do_space()
if keyval == IBus.Page_Down:
return self.do_page_down()
if keyval == IBus.Page_Up:
return self.do_page_up()
if keyval == IBus.BackSpace:
return self.do_backspace()
if is_inputnumber(keyval):
return self.do_number(keyval)
c = IBus.keyval_to_unicode(keyval)
if c and c == "*":
return self.do_star()
if c and self.cangjie.is_input_key(c):
return self.do_inputchar(c)
return self.do_other_key(keyval)
def set_engines(self, engines):
self.__engines_for_lang = {}
self.__untrans_for_lang = {}
for e in engines:
l = IBus.get_language_name(e.get_language())
if l == None:
l = ''
if l not in self.__engines_for_lang:
self.__engines_for_lang[l] = []
self.__engines_for_lang[l].append(e)
# Retrieve Untranslated language names.
backup_locale = locale.setlocale(locale.LC_ALL, None)
try:
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
untrans = IBus.get_language_name(e.get_language())
if untrans == None:
untrans = ''
self.__untrans_for_lang[l] = untrans
except locale.Error:
pass
locale.setlocale(locale.LC_ALL, backup_locale)
keys = list(self.__engines_for_lang.keys())
keys.sort(key=functools.cmp_to_key(locale.strcoll))
loc = locale.getlocale()[0]
# None on C locale
if loc == None:
loc = 'en_US'
current_lang = IBus.get_language_name(loc)
# move current language to the first place
if current_lang in keys:
keys.remove(current_lang)
keys.insert(0, current_lang)
# move English to the second place
en_lang = IBus.get_language_name('en_US')
if en_lang != current_lang and en_lang in keys:
keys.remove(en_lang)
keys.insert(1, en_lang)
#add 'Others' to the end of the combo box
if IBus.get_language_name('Other') in keys:
keys.remove(IBus.get_language_name('Other'))
keys += [IBus.get_language_name('Other')]
self.__langs = keys
self.__show_lang_rows()
def _update_aux (self):
'''Update Aux String in UI'''
_aux = self._aux_str
if _aux:
attrs = IBus.AttrList()
attrs.append(IBus.attr_foreground_new(0x9515b5, 0, len(_aux)))
text = IBus.Text.new_from_string(_aux)
i = 0
while attrs.get(i) != None:
attr = attrs.get(i)
text.append_attribute(attr.get_attr_type(),
attr.get_value(),
attr.get_start_index(),
attr.get_end_index())
i += 1
super(tabengine, self).update_auxiliary_text(text, True)
else:
self.hide_auxiliary_text()
def __init__(self):
self._bus = IBus.Bus()
self._dbusconn = dbus.connection.Connection(IBus.get_address())
# XXX: the new IBus bindings do not export create_input_context for
# introspection. This is troublesome - so, to workaround this problem
# we're directly fetching a new input context manually
ibus_obj = self._dbusconn.get_object(IBus.SERVICE_IBUS, IBus.PATH_IBUS)
self._test = dbus.Interface(ibus_obj, dbus_interface="org.freedesktop.IBus")
path = self._test.CreateInputContext("IBusQuery")
self._context = IBus.InputContext.new(path, self._bus.get_connection(), None)
self._glibloop = GLib.MainLoop()
self._context.connect("commit-text", self.__commit_text_cb)
self._context.connect("update-preedit-text", self.__update_preedit_cb)
self._context.connect("disabled", self.__disabled_cb)
self._context.set_capabilities (9)
def _update_preedit (self):
'''Update Preedit String in UI'''
_str = self._preedit_str
if _str == '':
super(tabengine, self).update_preedit_text(IBus.Text.new_from_string(''), 0, False)
else:
# because ibus now can only insert preedit into txt, so...
attrs = IBus.AttrList()
attrs.append(IBus.attr_underline_new(IBus.AttrUnderline.SINGLE, 0, len(_str)))
text = IBus.Text.new_from_string(_str)
i = 0
while attrs.get(i) != None:
attr = attrs.get(i)
text.append_attribute(attr.get_attr_type(),
attr.get_value(),
attr.get_start_index(),
attr.get_end_index())
i += 1
super(tabengine, self).update_preedit_text(text, len(_str), True)
def set_engines(self, engines):
#model
self.__model = Gtk.TreeStore(object)
iter1 = self.__model.append(None)
self.__model.set(iter1, 0, 0)
lang_list = self.__gconf_get_lang_list_from_locale()
lang = {}
sub_lang = {}
for e in engines:
l = IBus.get_language_name(e.props.language)
if lang_list == None or \
self.__has_engine_in_lang_list(e, lang_list):
if l not in lang:
lang[l] = []
lang[l].append(e)
else:
if l not in sub_lang:
sub_lang[l] = []
sub_lang[l].append(e)
self.__model_append_langs(self.__model, lang, True)
iter1 = self.__model.append(None)
#self.__model.set(iter1, 0, -1)
#all model
self.__all_model = Gtk.TreeStore(object)
#it will add a column
#iter1 = self.__all_model.append(None)
#self.__all_model.set(iter1, 0, 0)
self.__model_append_langs(self.__all_model, lang, False)
#remove it ,it will add a column
#iter1 = self.__all_model.append(None)
#self.__all_model.set(iter1, 0, -1)
#ok, it will add other region input method
self.__model_append_langs(self.__all_model, sub_lang, False)
self.__toggle_sub_lang()
def do_process_key_event(self, keyval, keycode, state):
"""Handle `process-key-event` events.
This event is fired when the user presses a key."""
# Ignore key release events
if (state & IBus.ModifierType.RELEASE_MASK):
return False
if state & (IBus.ModifierType.CONTROL_MASK |
IBus.ModifierType.MOD1_MASK):
# Ignore Alt+<key> and Ctrl+<key>
return False
if keyval == IBus.Escape:
return self.do_cancel_input()
if keyval == IBus.space:
return self.do_space()
if keyval == IBus.Page_Down:
return self.do_page_down()
if keyval == IBus.Page_Up:
return self.do_page_up()
if keyval == IBus.BackSpace:
return self.do_backspace()
if is_inputnumber(keyval):
return self.do_number(keyval)
c = IBus.keyval_to_unicode(keyval)
# TODO: should wildcard support be optional?
if c and self.cangjie.isCangJieInputKey(c) or c == "*":
return self.do_inputchar(c)
return self.do_other_key(keyval)
def __set_untrans_with_locale(en_locale):
locale.setlocale(locale.LC_ALL, en_locale)
untrans = IBus.get_language_name(e.get_language())
if untrans == None:
untrans = ''
self.__untrans_for_lang[l] = untrans
def run(self):
IBus.init()
self.__mainloop.run()
def do_number(self, keyval):
"""Handle numeric input."""
if self.lookuptable.get_number_of_candidates():
return self.do_select_candidate(int(IBus.keyval_to_unicode(keyval)))
return self.do_fullwidth_char(IBus.keyval_to_unicode(keyval))
def launch_engine(exec_by_ibus):
IBus.init()
IMApp(exec_by_ibus).run()
def set_default_settings():
global ENGINE
global TABSQLITEDB
ENGINE.set_input_mode(mode=1)
chinese_mode = 4
language_filter = TABSQLITEDB.ime_properties.get('language_filter')
if language_filter in ('cm0', 'cm1', 'cm2', 'cm3', 'cm4'):
chinese_mode = int(language_filter[-1])
ENGINE.set_chinese_mode(mode=chinese_mode)
letter_width_mode = False
def_full_width_letter = TABSQLITEDB.ime_properties.get(
'def_full_width_letter')
if def_full_width_letter:
letter_width_mode = (def_full_width_letter.lower() == u'true')
ENGINE.set_letter_width(mode=False, input_mode=0)
ENGINE.set_letter_width(mode=letter_width_mode, input_mode=1)
punctuation_width_mode = False
def_full_width_punct = TABSQLITEDB.ime_properties.get(
'def_full_width_punct')
if def_full_width_punct:
punctuation_width_mode = (def_full_width_punct.lower() == u'true')
ENGINE.set_punctuation_width(mode=False, input_mode=0)
ENGINE.set_punctuation_width(mode=punctuation_width_mode, input_mode=1)
always_show_lookup_mode = True
always_show_lookup = TABSQLITEDB.ime_properties.get(
'always_show_lookup')
if always_show_lookup:
always_show_lookup_mode = (always_show_lookup.lower() == u'true')
ENGINE.set_always_show_lookup(always_show_lookup_mode)
orientation = TABSQLITEDB.get_orientation()
ENGINE.set_lookup_table_orientation(orientation)
page_size = 6
select_keys_csv = TABSQLITEDB.ime_properties.get('select_keys')
# select_keys_csv is something like: "1,2,3,4,5,6,7,8,9,0"
if select_keys_csv:
page_size = len(select_keys_csv.split(","))
ENGINE.set_page_size(page_size)
onechar = False
ENGINE.set_onechar_mode(onechar)
auto_select_mode = False
auto_select = TABSQLITEDB.ime_properties.get('auto_select')
if auto_select:
auto_select_mode = (auto_select.lower() == u'true')
ENGINE.set_autoselect_mode(auto_select_mode)
auto_commit_mode = False
auto_commit = TABSQLITEDB.ime_properties.get('auto_commit')
if auto_commit:
auto_commit_mode = (auto_commit.lower() == u'true')
ENGINE.set_autocommit_mode(auto_commit_mode)
space_key_behavior_mode = False
# if space is a page down key, set the option
# “spacekeybehavior” to “True”:
page_down_keys_csv = TABSQLITEDB.ime_properties.get(
'page_down_keys')
if page_down_keys_csv:
page_down_keys = [
IBus.keyval_from_name(x)
for x in page_down_keys_csv.split(',')]
if IBus.KEY_space in page_down_keys:
space_key_behavior_mode = True
# if space is a commit key, set the option
# “spacekeybehavior” to “False” (overrides if space is
# also a page down key):
commit_keys_csv = TABSQLITEDB.ime_properties.get('commit_keys')
if commit_keys_csv:
commit_keys = [
IBus.keyval_from_name(x)
for x in commit_keys_csv.split(',')]
if IBus.KEY_space in commit_keys:
space_key_behavior_mode = False
ENGINE.set_space_key_behavior_mode(space_key_behavior_mode)
auto_wildcard_mode = True
auto_wildcard = TABSQLITEDB.ime_properties.get('auto_wildcard')
if auto_wildcard:
auto_wildcard_mode = (auto_wildcard.lower() == u'true')
ENGINE.set_autowildcard_mode(auto_wildcard_mode)
single_wildcard_char = TABSQLITEDB.ime_properties.get(
'single_wildcard_char')
if not single_wildcard_char:
single_wildcard_char = u''
if len(single_wildcard_char) > 1:
single_wildcard_char = single_wildcard_char[0]
ENGINE.set_single_wildcard_char(single_wildcard_char)
multi_wildcard_char = TABSQLITEDB.ime_properties.get(
'multi_wildcard_char')
if not multi_wildcard_char:
multi_wildcard_char = u''
if len(multi_wildcard_char) > 1:
multi_wildcard_char = multi_wildcard_char[0]
ENGINE.set_multi_wildcard_char(multi_wildcard_char)
def get_default_options_from_database(self):
'''
If there are default options in the database,
they override the defaults from Gsettings.
'''
self.tabsqlitedb = tabsqlitedb.TabSqliteDb(
filename=os.path.join(
DB_DIR,
re.sub(r'^table:', '', self.__engine_name)+'.db'),
user_db=None,
create_database=False)
self.__is_chinese = False
self.__is_cjk = False
languages = self.tabsqlitedb.ime_properties.get('languages')
if languages:
languages = languages.split(',')
for language in languages:
if language.strip().startswith('zh'):
self.__is_chinese = True
for lang in ['zh', 'ja', 'ko']:
if language.strip().startswith(lang):
self.__is_cjk = True
self.__user_can_define_phrase = False
user_can_define_phrase = self.tabsqlitedb.ime_properties.get(
'user_can-define_phrase')
if user_can_define_phrase:
self.__user_can_define_phrase = (
user_can_define_phrase.lower() == u'true')
self.__rules = self.tabsqlitedb.ime_properties.get('rules')
language_filter = self.tabsqlitedb.ime_properties.get(
'language_filter')
if language_filter in ('cm0', 'cm1', 'cm2', 'cm3', 'cm4'):
OPTION_DEFAULTS['chinesemode'] = int(language_filter[-1])
def_full_width_punct = self.tabsqlitedb.ime_properties.get(
'def_full_width_punct')
if (def_full_width_punct
and type(def_full_width_punct) == type(u'')
and def_full_width_punct.lower() in [u'true', u'false']):
OPTION_DEFAULTS['tabdeffullwidthpunct'] = (
def_full_width_punct.lower() == u'true')
OPTION_DEFAULTS['endeffullwidthpunct'] = (
def_full_width_punct.lower() == u'true')
def_full_width_letter = self.tabsqlitedb.ime_properties.get(
'def_full_width_letter')
if (def_full_width_letter
and type(def_full_width_letter) == type(u'')
and def_full_width_letter.lower() in [u'true', u'false']):
OPTION_DEFAULTS['tabdeffullwidthletter'] = (
def_full_width_letter.lower() == u'true')
OPTION_DEFAULTS['endeffullwidthletter'] = (
def_full_width_letter.lower() == u'true')
always_show_lookup = self.tabsqlitedb.ime_properties.get(
'always_show_lookup')
if (always_show_lookup
and type(always_show_lookup) == type(u'')
and always_show_lookup.lower() in [u'true', u'false']):
OPTION_DEFAULTS['alwaysshowlookup'] = (
always_show_lookup.lower() == u'true')
select_keys_csv = self.tabsqlitedb.ime_properties.get('select_keys')
if select_keys_csv:
# select_keys_csv is something like: "1,2,3,4,5,6,7,8,9,0"
OPTION_DEFAULTS['lookuptablepagesize'] = len(
select_keys_csv.split(","))
auto_select = self.tabsqlitedb.ime_properties.get('auto_select')
if (auto_select
and type(auto_select) == type(u'')
and auto_select.lower() in [u'true', u'false']):
OPTION_DEFAULTS['autoselect'] = auto_select.lower() == u'true'
auto_commit = self.tabsqlitedb.ime_properties.get('auto_commit')
if (auto_commit
and type(auto_commit) == type(u'')
and auto_commit.lower() in [u'true', u'false']):
OPTION_DEFAULTS['autocommit'] = auto_commit.lower() == u'true'
orientation = self.tabsqlitedb.get_orientation()
OPTION_DEFAULTS['lookuptableorientation'] = orientation
# if space is a page down key, set the option
# “spacekeybehavior” to “True”:
page_down_keys_csv = self.tabsqlitedb.ime_properties.get(
'page_down_keys')
if page_down_keys_csv:
self._page_down_keys = [
IBus.keyval_from_name(x)
for x in page_down_keys_csv.split(',')]
if IBus.KEY_space in self._page_down_keys:
OPTION_DEFAULTS['spacekeybehavior'] = True
# if space is a commit key, set the option
# “spacekeybehavior” to “False” (overrides if space is
# also a page down key):
commit_keys_csv = self.tabsqlitedb.ime_properties.get('commit_keys')
if commit_keys_csv:
self._commit_keys = [
IBus.keyval_from_name(x)
for x in commit_keys_csv.split(',')]
if IBus.KEY_space in self._commit_keys:
OPTION_DEFAULTS['spacekeybehavior'] = False
auto_wildcard = self.tabsqlitedb.ime_properties.get('auto_wildcard')
if (auto_wildcard
and type(auto_wildcard) == type(u'')
and auto_wildcard.lower() in [u'true', u'false']):
OPTION_DEFAULTS['autowildcard'] = auto_wildcard.lower() == u'true'
single_wildcard_char = self.tabsqlitedb.ime_properties.get(
'single_wildcard_char')
if (single_wildcard_char
and type(single_wildcard_char) == type(u'')):
if len(single_wildcard_char) > 1:
single_wildcard_char = single_wildcard_char[0]
OPTION_DEFAULTS['singlewildcardchar'] = single_wildcard_char
multi_wildcard_char = self.tabsqlitedb.ime_properties.get(
'multi_wildcard_char')
if (multi_wildcard_char
and type(multi_wildcard_char) == type(u'')):
if len(multi_wildcard_char) > 1:
multi_wildcard_char = multi_wildcard_char[0]
OPTION_DEFAULTS['multiwildcardchar'] = multi_wildcard_char
