path: root/setup/main.py

# vim:set et sts=4 sw=4:
# -*- coding: utf-8 -*-
#
# ibus - The Input Bus
#
# Copyright (c) 2007-2016 Peng Huang <shawn.p.huang@gmail.com>
# Copyright (c) 2010-2020 Takao Fujiwara <takao.fujiwara1@gmail.com>
# Copyright (c) 2007-2020 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.1 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
# USA

# for python2
from __future__ import print_function

import os
import signal
import sys
import time
import glob

from gi import require_version as gi_require_version
gi_require_version('GLib', '2.0')
gi_require_version('GdkX11', '3.0')
gi_require_version('Gio', '2.0')
gi_require_version('Gtk', '3.0')
gi_require_version('IBus', '1.0')

from gi.repository import GLib
# set_prgname before importing other modules to show the name in warning
# messages when import modules are failed.
GLib.set_prgname('ibus-setup')

from gi.repository import GdkX11
from gi.repository import Gio
from gi.repository import Gtk
from gi.repository import IBus
from os import path

import i18n
import keyboardshortcut
import locale
from emojilang import EmojiLangButton
from enginecombobox import EngineComboBox
from enginedialog import EngineDialog
from enginetreeview import EngineTreeView
from engineabout import EngineAbout
from i18n import DOMAINNAME, _, N_

(
    COLUMN_NAME,
    COLUMN_ENABLE,
    COLUMN_PRELOAD,
    COLUMN_VISIBLE,
    COLUMN_ICON,
    COLUMN_DATA,
) = list(range(6))

(
    DATA_NAME,
    DATA_LOCAL_NAME,
    DATA_LANG,
    DATA_ICON,
    DATA_AUTHOR,
    DATA_CREDITS,
    DATA_EXEC,
    DATA_STARTED,
    DATA_PRELOAD
) = list(range(9))

class Setup(object):
    def __flush_gtk_events(self):
        while Gtk.events_pending():
            Gtk.main_iteration()

    def __init__(self):
        super(Setup, self).__init__()

        self.__settings_general = Gio.Settings(
                schema = "org.freedesktop.ibus.general");
        self.__settings_hotkey = Gio.Settings(
                schema = "org.freedesktop.ibus.general.hotkey");
        self.__settings_panel = Gio.Settings(
                schema = "org.freedesktop.ibus.panel");
        self.__settings_emoji = Gio.Settings(
                schema = "org.freedesktop.ibus.panel.emoji");

        # IBus.Bus() calls ibus_bus_new().
        # Gtk.Builder().add_from_file() also calls ibus_bus_new_async()
        # via ibus_im_context_new().
        # Then if IBus.Bus() is called after Gtk.Builder().add_from_file(),
        # the connection delay would be happened without an async
        # finish function.
        self.__bus = None
        self.__init_bus()

        # Gtk.ListBox has been available since gtk 3.10
        self.__has_list_box = hasattr(Gtk, 'ListBox')

        gtk_builder_file = path.join(path.dirname(__file__), "./setup.ui")
        self.__builder = Gtk.Builder()
        self.__builder.set_translation_domain(DOMAINNAME)
        self.__builder.add_from_file(gtk_builder_file);
        self.__init_ui()

    def __init_hotkeys(self):
        name = 'triggers'
        label = 'switch_engine'
        comment = \
            _("Use shortcut with shift to switch to the previous input method") 
        self.__init_hotkey(name, label, comment)
        name = 'emoji'
        label = 'emoji_dialog'
        self.__init_hotkey(name, label)
        name = 'unicode'
        label = 'unicode_dialog'
        self.__init_hotkey(name, label)

    def __init_hotkey(self, name, label, comment=None):
        if name == 'emoji':
            shortcuts = self.__settings_emoji.get_strv('hotkey')
        elif name == 'unicode':
            shortcuts = self.__settings_emoji.get_strv('unicode-hotkey')
        else:
            shortcuts = self.__settings_hotkey.get_strv(name)
        button = self.__builder.get_object("button_%s" % label)
        entry = self.__builder.get_object("entry_%s" % label)
        entry.set_text("; ".join(shortcuts))
        tooltip = "\n".join(shortcuts)
        if comment != None:
            tooltip += "\n" + comment
        entry.set_tooltip_text(tooltip)
        if name == 'emoji':
            button.connect("clicked", self.__shortcut_button_clicked_cb,
                    'hotkey', 'panel/' + name, label, entry)
        elif name == 'unicode':
            button.connect("clicked", self.__shortcut_button_clicked_cb,
                    'unicode-hotkey', 'panel/emoji', label, entry)
        else:
            button.connect("clicked", self.__shortcut_button_clicked_cb,
                    name, "general/hotkey", label, entry)

    def __init_panel(self):
        # lookup table orientation
        self.__combobox_lookup_table_orientation = self.__builder.get_object(
                "combobox_lookup_table_orientation")
        self.__settings_panel.bind('lookup-table-orientation',
                                   self.__combobox_lookup_table_orientation,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)

        # auto hide
        self.__combobox_panel_show = self.__builder.get_object(
                "combobox_panel_show")
        self.__settings_panel.bind('show',
                                   self.__combobox_panel_show,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)

        # panel position
        self.__combobox_panel_position = self.__builder.get_object(
                "combobox_panel_position")
        self.__combobox_panel_position.set_active(3)
        #self.__settings_panel.bind('position',
        #                           self.__combobox_panel_position,
        #                           'active',
        #                           Gio.SettingsBindFlags.DEFAULT)

        # custom font
        self.__checkbutton_custom_font = self.__builder.get_object(
                "checkbutton_custom_font")
        self.__settings_panel.bind('use-custom-font',
                                   self.__checkbutton_custom_font,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)

        self.__fontbutton_custom_font = self.__builder.get_object(
                "fontbutton_custom_font")
        self.__settings_panel.bind('custom-font',
                                    self.__fontbutton_custom_font,
                                   'font-name',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__settings_panel.bind('use-custom-font',
                                    self.__fontbutton_custom_font,
                                   'sensitive',
                                   Gio.SettingsBindFlags.GET)

        # custom theme
        self.__model_custom_theme = self.__builder.get_object(
                "model_custom_theme")
        self.__combobox_custom_theme = self.__builder.get_object(
                "combobox_custom_theme")
        self.__checkbutton_custom_theme = self.__builder.get_object(
                "checkbutton_custom_theme")

        def update_combobox_custom_theme(settings, key):
            theme_name_list = self.__init_available_gtk_themes()
            self.__model_custom_theme.clear()
            for name in theme_name_list:
                self.__model_custom_theme.append([name])
            current_theme = self.__settings_panel.get_string(key)
            try:
                current_theme_number = theme_name_list.index(current_theme)
            except ValueError:
                self.__settings_panel.reset(key)
                current_theme = self.__settings_panel.get_string(key)
                current_theme_number = theme_name_list.index(current_theme)
            self.__combobox_custom_theme.set_active(current_theme_number)

        update_combobox_custom_theme(None, 'custom-theme')
        self.__settings_panel.bind('use-custom-theme',
                                   self.__checkbutton_custom_theme,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__settings_panel.connect('changed::custom-theme',
                                   update_combobox_custom_theme)
        self.__settings_panel.bind('use-custom-theme',
                                   self.__combobox_custom_theme,
                                   'sensitive',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__combobox_custom_theme.connect("changed",
                                   self.__on_combobox_custom_theme_changed)


        # custom icon
        self.__model_custom_icon = self.__builder.get_object(
                "model_custom_icon")
        self.__combobox_custom_icon = self.__builder.get_object(
                "combobox_custom_icon")
        self.__checkbutton_custom_icon = self.__builder.get_object(
                "checkbutton_custom_icon")

        def update_combobox_custom_icon(settings, key):
            icon_name_list = self.__init_available_gtk_icons()
            self.__model_custom_icon.clear()
            for name in icon_name_list:
                self.__model_custom_icon.append([name])
            current_icon = self.__settings_panel.get_string(key)
            try:
                current_icon_number = icon_name_list.index(current_icon)
            except ValueError:
                self.__settings_panel.reset(key)
                current_icon = self.__settings_panel.get_string(key)
                current_icon_number = icon_name_list.index(current_icon)
            self.__combobox_custom_icon.set_active(current_icon_number)

        update_combobox_custom_icon(None, 'custom-icon')
        self.__settings_panel.bind('use-custom-icon',
                                   self.__checkbutton_custom_icon,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__settings_panel.connect('changed::custom-icon',
                                   update_combobox_custom_icon)
        self.__settings_panel.bind('use-custom-icon',
                                   self.__combobox_custom_icon,
                                   'sensitive',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__combobox_custom_icon.connect("changed",
                                   self.__on_combobox_custom_icon_changed)

        # show icon on system tray
        self.__checkbutton_show_icon_on_systray = self.__builder.get_object(
                "checkbutton_show_icon_on_systray")
        self.__settings_panel.bind('show-icon-on-systray',
                                   self.__checkbutton_show_icon_on_systray,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)

        # show ime name
        self.__checkbutton_show_im_name = self.__builder.get_object(
                "checkbutton_show_im_name")
        self.__settings_panel.bind('show-im-name',
                                   self.__checkbutton_show_im_name,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)

        self.__checkbutton_glyph_from_engine_lang = self.__builder.get_object(
                "checkbutton_use_glyph_from_engine_lang")
        self.__settings_panel.bind('use-glyph-from-engine-lang',
                                   self.__checkbutton_glyph_from_engine_lang,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)

    def __init_general(self):
        # embed preedit text
        self.__checkbutton_embed_preedit_text = self.__builder.get_object(
                "checkbutton_embed_preedit_text")
        self.__settings_general.bind('embed-preedit-text',
                                    self.__checkbutton_embed_preedit_text,
                                    'active',
                                    Gio.SettingsBindFlags.DEFAULT)

        # use system keyboard layout setting
        self.__checkbutton_use_sys_layout = self.__builder.get_object(
                "checkbutton_use_sys_layout")
        self.__settings_general.bind('use-system-keyboard-layout',
                                    self.__checkbutton_use_sys_layout,
                                    'active',
                                    Gio.SettingsBindFlags.DEFAULT)

        # use global ime setting
        self.__checkbutton_use_global_engine = self.__builder.get_object(
                "checkbutton_use_global_engine")
        self.__settings_general.bind('use-global-engine',
                                    self.__checkbutton_use_global_engine,
                                    'active',
                                    Gio.SettingsBindFlags.DEFAULT)

        # init engine page
        self.__engines = self.__bus.list_engines()
        self.__combobox = self.__builder.get_object("combobox_engines")
        if self.__has_list_box:
            self.__combobox.set_no_show_all(True)
            self.__combobox.hide()
        else:
            self.__combobox.set_engines(self.__engines)

        tmp_dict = {}
        for e in self.__engines:
            tmp_dict[e.get_name()] = e
        engine_names = self.__settings_general.get_strv('preload-engines')
        engines = [tmp_dict[name] for name in engine_names if name in tmp_dict]

        self.__treeview = self.__builder.get_object("treeview_engines")
        self.__treeview.set_engines(engines)

        button = self.__builder.get_object("button_engine_add")
        if self.__has_list_box:
            button.set_sensitive(True)
            button.connect("clicked", self.__button_engine_add_cb)
        else:
            button.connect("clicked", self.__button_engine_add_cb_deprecate)
        button = self.__builder.get_object("button_engine_remove")
        button.connect("clicked", lambda *args:self.__treeview.remove_engine())
        button = self.__builder.get_object("button_engine_up")
        button.connect("clicked", lambda *args:self.__treeview.move_up_engine())

        button = self.__builder.get_object("button_engine_down")
        button.connect("clicked",
                lambda *args:self.__treeview.move_down_engine())

        button = self.__builder.get_object("button_engine_about")
        button.connect("clicked", self.__button_engine_about_cb)

        self.__engine_setup_exec_list = {}
        button = self.__builder.get_object("button_engine_preferences")
        button.connect("clicked", self.__button_engine_preferences_cb)

        self.__combobox.connect("notify::active-engine",
                self.__combobox_notify_active_engine_cb)
        self.__treeview.connect("notify::active-engine", self.__treeview_notify_cb)
        self.__treeview.connect("notify::engines", self.__treeview_notify_cb)

    def __init_emoji(self):
        self.__fontbutton_emoji_font = self.__builder.get_object(
                'fontbutton_emoji_font')
        self.__fontbutton_emoji_font.set_preview_text('🙂🍎🚃💓📧⚽🐳');
        self.__settings_emoji.bind('font',
                                    self.__fontbutton_emoji_font,
                                   'font-name',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__button_emoji_lang = self.__builder.get_object(
                'button_emoji_lang')
        self.__settings_emoji.bind('lang',
                                    self.__button_emoji_lang,
                                   'lang',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__checkbutton_emoji_partial_match = self.__builder.get_object(
                'checkbutton_emoji_partial_match')
        checkbutton_label = self.__checkbutton_emoji_partial_match.get_child()
        if type(checkbutton_label) == Gtk.Label:
            checkbutton_label.set_property('wrap', True)
            checkbutton_label.set_property('max-width-chars', 74)
        self.__spinbutton_emoji_partial_match = self.__builder.get_object(
                'spinbutton_emoji_partial_match')
        self.__settings_emoji.bind('has-partial-match',
                                   self.__checkbutton_emoji_partial_match,
                                   'active',
                                   Gio.SettingsBindFlags.DEFAULT)
        self.__settings_emoji.bind('has-partial-match',
                                   self.__spinbutton_emoji_partial_match,
                                   'sensitive',
                                   Gio.SettingsBindFlags.GET)

        def adjustment_value_changed_cb(obj):
            key = 'partial-match-length'
            value = int(adjustment.get_value())
            if value == self.__settings_emoji.get_int(key):
                return
            self.__settings_emoji.set_int(key, value)
        def settings_emoji_partial_match_length_cb(settings, key):
            value = self.__settings_emoji.get_int(key)
            old_value = int(self.__spinbutton_emoji_partial_match.get_value())
            if value == old_value:
                return
            self.__spinbutton_emoji_partial_match.set_value(value)
        settings_emoji_partial_match_length_cb(None, 'partial-match-length')
        adjustment = self.__spinbutton_emoji_partial_match.get_adjustment()
        adjustment.connect('value-changed', adjustment_value_changed_cb)
        self.__settings_emoji.connect('changed::partial-match-length',
                                      settings_emoji_partial_match_length_cb)

        self.__hbox_emoji_partial_match = self.__builder.get_object(
                'hbox_emoji_partial_match')
        self.__settings_emoji.bind('has-partial-match',
                                   self.__hbox_emoji_partial_match,
                                   'sensitive',
                                   Gio.SettingsBindFlags.GET)
        self.__radiobutton_emoji_prefix_match = self.__builder.get_object(
                'radiobutton_emoji_prefix_match')
        self.__radiobutton_emoji_suffix_match = self.__builder.get_object(
                'radiobutton_emoji_suffix_match')
        self.__radiobutton_emoji_contain_match = self.__builder.get_object(
                'radiobutton_emoji_contain_match')

        def radiobuton_emoji_partial_match_cb(obj):
            key = 'partial-match-condition'
            condition = 0
            if not obj.get_active():
                return
            if obj == self.__radiobutton_emoji_prefix_match:
                condition = 0
            elif obj == self.__radiobutton_emoji_suffix_match:
                condition = 1
            elif obj == self.__radiobutton_emoji_contain_match:
                condition = 2
            else:
                print('Wrong emoji partial match object')
                return
            self.__settings_emoji.set_int(key, condition)
        def settings_emoji_partial_match_condition_cb(settings, key):
            value = self.__settings_emoji.get_int(key)
            obj = None
            if value == 0:
                obj = self.__radiobutton_emoji_prefix_match
            elif value == 1:
                obj = self.__radiobutton_emoji_suffix_match
            elif value == 2:
                obj = self.__radiobutton_emoji_contain_match
            else:
                print('Wrong emoji partial match condition')
                return
            if obj.get_active():
                return
            obj.set_active(True)

        settings_emoji_partial_match_condition_cb(None,
                                                  'partial-match-condition')
        self.__radiobutton_emoji_prefix_match.connect(
                'toggled',
                radiobuton_emoji_partial_match_cb)
        self.__radiobutton_emoji_suffix_match.connect(
                'toggled',
                radiobuton_emoji_partial_match_cb)
        self.__radiobutton_emoji_contain_match.connect(
                'toggled',
                radiobuton_emoji_partial_match_cb)
        self.__settings_emoji.connect('changed::partial-match-condition',
                                      settings_emoji_partial_match_condition_cb)

    def __init_ui(self):
        # add icon search path
        self.__window = self.__builder.get_object("window_preferences")
        self.__window.connect("delete-event", Gtk.main_quit)
        self.__window.connect("notify::window", self.__gdk_window_set_cb)

        self.__button_close = self.__builder.get_object("button_close")
        self.__button_close.connect("clicked", Gtk.main_quit)

        self.__init_hotkeys()
        self.__init_panel()
        self.__init_general()
        self.__init_emoji()

    def __gdk_window_set_cb(self, object, pspec):
        window = object.get_window()
        if type(window) != GdkX11.X11Window:
            return
        s = '%u' % GdkX11.X11Window.get_xid(window)
        GLib.setenv('IBUS_SETUP_XID', s, True)

    def __combobox_notify_active_engine_cb(self, combobox, property):
        engine = self.__combobox.get_active_engine()
        button = self.__builder.get_object("button_engine_add")
        button.set_sensitive(
                engine != None and engine not in self.__treeview.get_engines())

    def __get_engine_setup_exec_args(self, engine):
        args = []
        if engine == None:
           return args
        setup = str(engine.get_setup())
        if len(setup) != 0:
            args = setup.split()
            args.insert(1, path.basename(args[0]))
            return args
        name = str(engine.get_name())
        libexecdir = os.environ['IBUS_LIBEXECDIR']
        setup_path = (libexecdir + '/' + 'ibus-setup-' if libexecdir != None \
            else 'ibus-setup-') + name.split(':')[0]
        if path.exists(setup_path):
            args.append(setup_path)
            args.append(path.basename(setup_path))
        return args

    def __treeview_notify_cb(self, treeview, prop):
        if prop.name not in ("active-engine", "engines"):
            return

        engines = self.__treeview.get_sorted_engines()
        engine = self.__treeview.get_active_engine()

        self.__builder.get_object("button_engine_remove").set_sensitive(engine != None)
        self.__builder.get_object("button_engine_about").set_sensitive(engine != None)
        self.__builder.get_object("button_engine_up").set_sensitive(engine not in engines[:1])
        self.__builder.get_object("button_engine_down").set_sensitive(engine not in engines[-1:])

        obj = self.__builder.get_object("button_engine_preferences")
        if len(self.__get_engine_setup_exec_args(engine)) != 0:
            obj.set_sensitive(True)
        else:
            obj.set_sensitive(False)

        if prop.name == "engines":
            engines = self.__treeview.get_engines()
            engine_names = [e.get_name() for e in engines]
            self.__settings_general.set_strv('preload-engines', engine_names)

    def __button_engine_add_cb(self, button):
        dialog = EngineDialog(transient_for = self.__window)
        dialog.set_engines(self.__engines)
        id = dialog.run()

        if id != Gtk.ResponseType.APPLY:
            dialog.destroy()
            return

        engine = dialog.get_selected_engine()
        dialog.destroy()

        self.__treeview.append_engine(engine)

    def __button_engine_add_cb_deprecate(self, button):
        engine = self.__combobox.get_active_engine()
        self.__treeview.append_engine(engine)

    def __button_engine_about_cb(self, button):
        engine = self.__treeview.get_active_engine()
        if engine:
            about = EngineAbout(engine = engine, transient_for = self.__window)
            about.run()
            about.destroy()

    def __button_engine_preferences_cb(self, button):
        engine = self.__treeview.get_active_engine()
        args = self.__get_engine_setup_exec_args(engine)
        if len(args) == 0:
            return
        name = engine.get_name()
        if name in list(self.__engine_setup_exec_list.keys()):
            try:
                wpid, sts = os.waitpid(self.__engine_setup_exec_list[name],
                                       os.WNOHANG)
                # the setup is still running.
                if wpid == 0:
                    return
            except OSError:
                pass
            del self.__engine_setup_exec_list[name]
        self.__engine_setup_exec_list[name] = os.spawnl(os.P_NOWAIT, *args)

    def __init_bus(self):
        self.__bus = IBus.Bus()
        if self.__bus.is_connected():
            return

        message = _("The IBus daemon is not running. Do you wish to start it?")
        dlg = Gtk.MessageDialog(message_type = Gtk.MessageType.QUESTION,
                                buttons = Gtk.ButtonsType.YES_NO,
                                text = message)
        id = dlg.run()
        dlg.destroy()
        self.__flush_gtk_events()
        if id != Gtk.ResponseType.YES:
            sys.exit(0)

        main_loop = GLib.MainLoop()

        timeout = 5
        GLib.timeout_add_seconds(timeout, lambda *args: main_loop.quit())
        self.__bus.connect("connected", lambda *args: main_loop.quit())

        os.spawnlp(os.P_NOWAIT, "ibus-daemon", "ibus-daemon", "--xim", "--daemonize")

        main_loop.run()

        if self.__bus.is_connected():
            message = _("IBus has been started! "
                "If you cannot use IBus, add the following lines to your $HOME/.bashrc; then relog into your desktop.\n"
                "  export GTK_IM_MODULE=ibus\n"
                "  export XMODIFIERS=@im=ibus\n"
                "  export QT_IM_MODULE=ibus"
                )
            dlg = Gtk.MessageDialog(message_type = Gtk.MessageType.INFO,
                                    buttons = Gtk.ButtonsType.OK,
                                    text = message)
            id = dlg.run()
            dlg.destroy()
            self.__flush_gtk_events()
        else:
            # Translators: %d == 5 currently
            message = _("IBus daemon could not be started in %d seconds.")
            dlg = Gtk.MessageDialog(message_type = Gtk.MessageType.INFO,
                                    buttons = Gtk.ButtonsType.OK,
                                    text = message % timeout)
            id = dlg.run()
            dlg.destroy()
            self.__flush_gtk_events()
            sys.exit(0)

    def __shortcut_button_clicked_cb(self, button, name, section, _name, entry):
        buttons = (_("_Cancel"), Gtk.ResponseType.CANCEL,
                   _("_OK"), Gtk.ResponseType.OK)
        title1 = _("Select keyboard shortcut for %s")
        # Translators: Title of the window
        title2 = _("switching input methods")
        title = title1 % title2
        dialog = keyboardshortcut.KeyboardShortcutSelectionDialog(
                title = title, transient_for = self.__window)
        dialog.add_buttons(*buttons)
        text = entry.get_text()
        if text:
            shortcuts = text.split("; ")
        else:
            shortcuts = None
        dialog.set_shortcuts(shortcuts)
        id = dialog.run()
        shortcuts = dialog.get_shortcuts()
        dialog.destroy()
        if id != Gtk.ResponseType.OK:
            return
        if section == 'panel/emoji':
            self.__settings_emoji.set_strv(name, shortcuts)
        else:
            self.__settings_hotkey.set_strv(name, shortcuts)
        text = "; ".join(shortcuts)
        entry.set_text(text)
        tooltip = "\n".join(shortcuts)
        tooltip += "\n" + \
            _("Use shortcut with shift to switch to the previous input method") 
        entry.set_tooltip_text(tooltip)

    def __init_available_gtk_themes(self):
        path_list = []
        path_list.append(os.path.join(GLib.get_home_dir(), ".themes"))
        path_list.append(os.path.join(GLib.get_user_data_dir(), "themes"))
        path_list.extend(list(map(lambda x: os.path.join(
            x, "themes"), GLib.get_system_data_dirs())))
        theme_name_list = []
        gtk_theme_path = []
        for path in path_list:
            gtk_theme_path.extend(glob.glob(path + "/*/gtk-*/gtk.css"))
        for path in gtk_theme_path:
            theme_name_list.append(os.path.basename(
                os.path.dirname(os.path.dirname(path))))

        theme_name_list.extend([
            'Adwaita', 'HighContrast', 'HighContrastInverse'
        ])
        theme_name_list = list(set(theme_name_list))
        theme_name_list.sort()

        return theme_name_list

    def __on_combobox_custom_theme_changed(self, combobox):
        tree_iter = self.__combobox_custom_theme.get_active_iter()
        if tree_iter is not None:
            model = self.__combobox_custom_theme.get_model()
            theme_name = model[tree_iter][0]
            self.__settings_panel.set_string('custom-theme', theme_name)

    def __init_available_gtk_icons(self):
        path_list = []
        path_list.append(os.path.join(GLib.get_home_dir(), ".icons"))
        path_list.append(os.path.join(GLib.get_user_data_dir(), "icons"))
        path_list.extend(list(map(lambda x: os.path.join(
            x, "icons"), GLib.get_system_data_dirs())))
        icon_name_list = []
        gtk_icon_path = []
        for path in path_list:
            gtk_icon_path.extend(glob.glob(path + "/*/index.theme"))
        for path in gtk_icon_path:
            dir = os.path.dirname(path)
            if not os.path.exists(os.path.join(dir, "cursors")):
                icon_name_list.append(os.path.basename(dir))

        icon_name_list.extend(["Adwaita"])
        icon_name_list = list(set(icon_name_list))
        icon_name_list.sort()

        return icon_name_list

    def __on_combobox_custom_icon_changed(self, combobox):
        tree_iter = self.__combobox_custom_icon.get_active_iter()
        if tree_iter is not None:
            model = self.__combobox_custom_icon.get_model()
            icon_name = model[tree_iter][0]
            self.__settings_panel.set_string('custom-icon', icon_name)

    def __item_started_column_toggled_cb(self, cell, path_str, model):

        # get toggled iter
        iter = model.get_iter_from_string(path_str)
        data = model.get_value(iter, COLUMN_DATA)

        # do something with the value
        if data[DATA_STARTED] == False:
            try:
                self.__bus.register_start_engine(data[DATA_LANG], data[DATA_NAME])
            except Exception as e:
                dlg = Gtk.MessageDialog(message_type = Gtk.MessageType.ERROR,
                        transient_for = self.__window,
                        buttons = Gtk.ButtonsType.CLOSE,
                        text = str(e))
                dlg.run()
                dlg.destroy()
                self.__flush_gtk_events()
                return
        else:
            try:
                self.__bus.register_stop_engine(data[DATA_LANG], data[DATA_NAME])
            except Exception as e:
                dlg = Gtk.MessageDialog(message_type = Gtk.MessageType.ERROR,
                        transient_for = self.__window,
                        buttons = Gtk.ButtonsType.CLOSE,
                        text = str(e))
                dlg.run()
                dlg.destroy()
                self.__flush_gtk_events()
                return
        data[DATA_STARTED] = not data[DATA_STARTED]

        # set new value
        model.set(iter, COLUMN_ENABLE, data[DATA_STARTED])

    def __item_preload_column_toggled_cb(self, cell, path_str, model):

        # get toggled iter
        iter = model.get_iter_from_string(path_str)
        data = model.get_value(iter, COLUMN_DATA)

        data[DATA_PRELOAD] = not data[DATA_PRELOAD]
        engine = "%s:%s" % (data[DATA_LANG], data[DATA_NAME])

        if data[DATA_PRELOAD]:
            if engine not in self.__preload_engines:
                self.__preload_engines.add(engine)
                self.__settings_general.set_strv('preload-engines',
                                                 list(self.__preload_engines))
        else:
            if engine in self.__preload_engines:
                self.__preload_engines.remove(engine)
                self.__settings_general.set_strv('preload-engines',
                                                 list(self.__preload_engines))

        # set new value
        model.set(iter, COLUMN_PRELOAD, data[DATA_PRELOAD])

    def __sigusr1_cb(self, *args):
        self.__window.present()

    def run(self):
        self.__window.show_all()
        signal.signal(signal.SIGUSR1, self.__sigusr1_cb)
        Gtk.main()

if __name__ == "__main__":
    try:
        locale.setlocale(locale.LC_ALL, '')
    except locale.Error:
        print("Using the fallback 'C' locale", file=sys.stderr)
        locale.setlocale(locale.LC_ALL, 'C')

    i18n.init_textdomain(DOMAINNAME)
    i18n.init_textdomain('xkeyboard-config')
    setup = Setup()
    setup.run()