# vim:fileencoding=utf-8:sw=4:et # # ibus-table-setup - Setup UI for ibus-table # # Copyright (c) 2008-2010 Peng Huang <shawn.p.huang@gmail.com> # Copyright (c) 2010 BYVoid <byvoid1@gmail.com> # Copyright (c) 2012 Ma Xiaojun <damage3025@gmail.com> # Copyright (c) 2012 mozbugbox <mozbugbox@yahoo.com.au> # Copyright (c) 2014-2018 Mike FABIAN <mfabian@redhat.com> # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. ''' The setup tool for ibus-table. ''' import gettext import locale import os import sys import signal import optparse from time import strftime import re from gi import require_version require_version('Gio', '2.0') from gi.repository import Gio require_version('GLib', '2.0') from gi.repository import GLib # set_prgname before importing other modules to show the name in warning # messages when import modules are failed. E.g. Gtk. GLib.set_application_name('IBus Table Preferences') # This makes gnome-shell load the .desktop file when running under Wayland: GLib.set_prgname('ibus-setup-table') require_version('Gtk', '3.0') from gi.repository import Gtk require_version('IBus', '1.0') from gi.repository import IBus import version sys.path = [sys.path[0]+'/../engine'] + sys.path import tabsqlitedb import ibus_table_location import it_util _ = lambda a: gettext.dgettext("ibus-table", a) # The contents this OPTION_DEFAULTS dict are first overwritten # with the defaults from the Gsettings schema file and then again with # the defaults from the tables. OPTION_DEFAULTS = { "inputmode": 1, "chinesemode": 4, "tabdeffullwidthletter": False, "tabdeffullwidthpunct": False, "endeffullwidthletter": False, "endeffullwidthpunct": False, "alwaysshowlookup": True, "lookuptableorientation": 1, # 0 = horizontal, 1 = vertical, 2 = system "lookuptablepagesize": 6, "onechar": False, "autoselect": False, "autocommit": False, "spacekeybehavior": False, "autowildcard": True, "singlewildcardchar": u'', "multiwildcardchar": u'', } SCALE_WIDGETS = { "lookuptablepagesize", } ENTRY_WIDGETS = { "singlewildcardchar", "multiwildcardchar", } DB_DIR = os.path.join(ibus_table_location.data(), 'tables') ICON_DIR = os.path.join(ibus_table_location.data(), 'icons') LOGFILE = os.path.join(ibus_table_location.cache_home(), 'setup-debug.log') _OPTION_PARSER = optparse.OptionParser() _OPTION_PARSER.set_usage('%prog [options]') _OPTION_PARSER.add_option( '-n', '--engine-name', action='store', type='string', dest='engine_name', default='', help=('Set the name of the engine, for example "table:cangjie3". ' + 'Default: "%default"')) _OPTION_PARSER.add_option( '-q', '--no-debug', action='store_false', dest='debug', default=True, help=('redirect stdout and stderr to ' + LOGFILE + ', default: %default')) (_OPTIONS, _ARGS) = _OPTION_PARSER.parse_args() if _OPTIONS.debug: sys.stdout = open(LOGFILE, mode='a', buffering=1) sys.stderr = open(LOGFILE, mode='a', buffering=1) print('--- %s ---' %strftime('%Y-%m-%d: %H:%M:%S')) class PreferencesDialog: ''' The setup dialog of ibus-table. ''' def __init__(self): locale.setlocale(locale.LC_ALL, "") localedir = os.getenv("IBUS_LOCALEDIR") gettext.bindtextdomain("ibus-table", localedir) gettext.bind_textdomain_codeset("ibus-table", "UTF-8") self.__bus = IBus.Bus() self.__engine_name = None if _OPTIONS.engine_name: # If the engine name is specified on the command line, use that: self.__engine_name = _OPTIONS.engine_name else: # If the engine name is not specified on the command line, # try to get it from the environment. This is necessary # in gnome-shell on Fedora 18,19,20,... because the setup tool is # called without command line options there but the # environment variable IBUS_ENGINE_NAME is set: if 'IBUS_ENGINE_NAME' in os.environ: self.__engine_name = os.environ['IBUS_ENGINE_NAME'] else: self.__run_message_dialog( _("IBUS_ENGINE_NAME environment variable is not set."), Gtk.MessageType.WARNING) if self.__engine_name is None: self.__run_message_dialog( _("Cannot determine the engine name. Please use the --engine-name option."), Gtk.MessageType.ERROR) sys.exit(1) short_engine_name = re.sub( r'^table:', '', self.__engine_name).replace(" ", "_") self.__gsettings = Gio.Settings( schema='org.freedesktop.ibus.engine.table', path='/org/freedesktop/ibus/engine/table/%s/' %short_engine_name) self.__gsettings.connect('changed', self.on_gsettings_value_changed) def check_table_available(self): """Check if the current engine_name is available. Return bool""" names = self.__bus.list_engines() names = [x.get_name() for x in names] ret = True if self.__engine_name not in names: ret = False self.__run_message_dialog( _('IBus Table engine %s is not available') %self.__engine_name, Gtk.MessageType.ERROR) return ret def get_default_options_from_gsettings(self): ''' Get the default options from the Gsettings schema file. ''' for key in OPTION_DEFAULTS: OPTION_DEFAULTS[key] = it_util.variant_to_value( self.__gsettings.get_value(key)) 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 def __restore_defaults(self): ''' Restore defaults as specified in the database for this engine. ''' for key in OPTION_DEFAULTS: value = OPTION_DEFAULTS[key] self.__set_value(key, value) def _build_combobox_renderer(self, key): """setup cell renderer for combobox""" __combobox = self.__builder.get_object("combobox%s" % key) __cell = Gtk.CellRendererText() __combobox.pack_start(__cell, True) __combobox.add_attribute(__cell, 'text', 0) def load_builder(self): """Load builder and __dialog attribute""" self.__builder = Gtk.Builder() self.__builder.set_translation_domain("ibus-table") self.__builder.add_from_file("ibus-table-preferences.ui") self.__dialog = self.__builder.get_object("dialog") for key in list(OPTION_DEFAULTS.keys()): if key not in SCALE_WIDGETS and key not in ENTRY_WIDGETS: self._build_combobox_renderer(key) def do_init(self): ''' Initialize the setup dialog. ''' self.__init_general() self.__init_about() def __init_general(self): """Initialize the general notebook page""" self.__dialog.set_title(_("IBus Table %s Preferences") %re.sub(r'^table:', '', self.__engine_name)) # https://tronche.com/gui/x/icccm/sec-4.html#WM_CLASS # gnome-shell seems to use the first argument of set_wmclass() # to find the .desktop file. If the .desktop file can be # found, the name shown by gnome-shell in the top bar comes # from that .desktop file and the icon to show is also read # from that .desktop file. If the .desktop file cannot be # found, the second argument of set_wmclass() is shown by # gnome-shell in the top bar. self.__dialog.set_wmclass('ibus-setup-table', 'IBus Table Setup') self.__user_values = {} for key in OPTION_DEFAULTS: if self.__gsettings.get_user_value(key) != None: self.__user_values[key] = it_util.variant_to_value( self.__gsettings.get_user_value(key)) sys.stderr.write( 'self.__user_values[%s]=%s\n' %(key, self.__user_values[key])) if key in SCALE_WIDGETS: self._init_hscale(key) elif key in ENTRY_WIDGETS: self._init_entry(key) else: self._init_combobox(key) self._init_button('restoredefaults') return def __init_about(self): ''' Initialize the About notebook page ''' self.__name_version = self.__builder.get_object("NameVersion") self.__name_version.set_markup( "<big><b>IBus Table %s</b></big>" %version.get_version()) img_fname = os.path.join(ICON_DIR, "ibus-table.svg") if os.path.exists(img_fname): img = self.__builder.get_object("image_about") img.set_from_file(img_fname) # setup table info our_engine = None for engine in self.__bus.list_engines(): if engine.get_name() == self.__engine_name: our_engine = engine break if our_engine: longname = our_engine.get_longname() if not longname: longname = our_engine.get_name() label = self.__builder.get_object("TableNameVersion") label.set_markup("<b>%s</b>" %longname) icon_path = our_engine.get_icon() if icon_path and os.path.exists(icon_path): from gi.repository import GdkPixbuf pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( icon_path, -1, 32) image = self.__builder.get_object("TableNameImage") image.set_from_pixbuf(pixbuf) def _init_combobox(self, key): """Set combobox from the Gsettings""" __combobox = self.__builder.get_object("combobox%s" % key) val = 0 if key in self.__user_values: init_val = self.__user_values[key] else: init_val = OPTION_DEFAULTS[key] if isinstance(init_val, bool): val = 1 if init_val else 0 elif isinstance(init_val, int): val = init_val elif isinstance(init_val, str): model = __combobox.get_model() for i, row in enumerate(model): if row[0] == init_val: val = i break __combobox.set_active(val) __combobox.connect("changed", self.__changed_cb, key) if ((key in ['chinesemode'] and not self.__is_chinese) or (key in ['tabdeffullwidthletter', 'tabdeffullwidthpunct', 'endeffullwidthletter', 'endeffullwidthpunct'] and not self.__is_cjk) or (key in ['onechar'] and not self.__is_cjk) or (key in ['autocommit'] and (not self.__user_can_define_phrase or not self.__rules))): __combobox.set_button_sensitivity(Gtk.SensitivityType.OFF) def _init_entry(self, key): """Set entry widget from the Gsettings engine""" __entry = self.__builder.get_object("entry%s" % key) if key in self.__user_values: val = self.__user_values[key] else: val = OPTION_DEFAULTS[key] __entry.set_text(val) __entry.connect("notify::text", self.__entry_changed_cb, key) def _init_hscale(self, key): """Set scale widget from Gsettings""" __hscale = self.__builder.get_object("hscale%s" % key) if key in self.__user_values: val = self.__user_values[key] else: val = OPTION_DEFAULTS[key] __hscale.set_value(val) __hscale.connect("value-changed", self.__value_changed_cb, key) def _init_button(self, key): """Initialize the button to restore the default settings""" __button = self.__builder.get_object("button%s" %key) __button.connect("clicked", self.__button_clicked_cb, key) def __button_clicked_cb(self, widget, key): """Button clicked handler""" if key == 'restoredefaults': self.__restore_defaults() def __changed_cb(self, widget, key): """Combobox changed handler""" val = widget.get_active() vtype = type(OPTION_DEFAULTS[key]) if vtype == bool: val = False if val == 0 else True self.__set_value(key, val) def __value_changed_cb(self, widget, key): """scale widget value changed handler""" val = widget.get_value() vtype = type(OPTION_DEFAULTS[key]) if vtype == int: val = int(val) self.__set_value(key, val) def __entry_changed_cb(self, widget, property_spec, key): """entry widget text changed handler""" val = widget.get_text() vtype = type(OPTION_DEFAULTS[key]) if vtype != type(u''): val = val.decode('UTF-8') self.__set_value(key, val) def on_gsettings_value_changed(self, _settings, key): """ Called when a value in the settings has been changed. """ value = it_util.variant_to_value(self.__gsettings.get_value(key)) sys.stderr.write('Settings changed: key=%s value=%s\n' %(key, value)) if key in SCALE_WIDGETS: __hscale = self.__builder.get_object("hscale%s" % key) __hscale.set_value(value) elif key in ENTRY_WIDGETS: __entry = self.__builder.get_object("entry%s" % key) __entry.set_text(value) else: __combobox = self.__builder.get_object("combobox%s" % key) if isinstance(value, bool): value = 1 if value else 0 elif isinstance(value, str): model = __combobox.get_model() for i, row in enumerate(model): if row[0] == value: value = i break __combobox.set_active(value) self.__user_values[key] = value def __toggled_cb(self, widget, key): """toggle button toggled signal handler""" self.__set_value(key, widget.get_active()) def __set_value(self, key, val): """Set the _gsettings value""" var = None if isinstance(val, bool): var = GLib.Variant.new_boolean(val) elif isinstance(val, int): var = GLib.Variant.new_int32(val) elif isinstance(val, str): var = GLib.Variant.new_string(val) else: sys.stderr.write("val(%s) is not in support type." %repr(val)) return self.__user_values[key] = val self.__gsettings.set_value(key, var) def __run_message_dialog(self, message, message_type=Gtk.MessageType.INFO): ''' Pop up a message dialog. ''' dlg = Gtk.MessageDialog(parent=None, flags=Gtk.DialogFlags.MODAL, message_type=message_type, buttons=Gtk.ButtonsType.OK, message_format=message) dlg.run() dlg.destroy() def run(self): ''' Run the setup dialog. ''' ret = self.check_table_available() if not ret: return 0 self.load_builder() self.get_default_options_from_gsettings() self.get_default_options_from_database() self.do_init() return self.__dialog.run() def main(): ''' Main function to run the setup dialog. ''' PreferencesDialog().run() if __name__ == "__main__": # Workaround for # https://bugzilla.gnome.org/show_bug.cgi?id=622084 # Bug 622084 - Ctrl+C does not exit gtk app signal.signal(signal.SIGINT, signal.SIG_DFL) main()

Simpan