# 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-2018 Takao Fujiwara <takao.fujiwara1@gmail.com>

# Copyright (c) 2007-2016 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

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)

        # 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)

    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)

        # auto start ibus

        self.__checkbutton_auto_start = self.__builder.get_object(

                "checkbutton_auto_start")

        self.__checkbutton_auto_start.set_active(self.__is_auto_start())

        self.__checkbutton_auto_start.connect("toggled",

                self.__checkbutton_auto_start_toggled_cb)

        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")

        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 __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 __is_auto_start(self):

        link_file = path.join(GLib.get_user_config_dir(),

                              "autostart/ibus.desktop")

        ibus_desktop = path.join(os.getenv("IBUS_PREFIX"),

                                 "share/applications/ibus.desktop")

        if not path.exists(link_file):

            return False

        if not path.islink(link_file):

            return False

        if path.realpath(link_file) != ibus_desktop:

            return False

        return True

    def __checkbutton_auto_start_toggled_cb(self, button):

        auto_start_dir = path.join(GLib.get_user_config_dir(), "autostart")

        if not path.isdir(auto_start_dir):

            os.makedirs(auto_start_dir)

        link_file = path.join(GLib.get_user_config_dir(),

                              "autostart/ibus.desktop")

        ibus_desktop = path.join(os.getenv("IBUS_PREFIX"),

                                 "share/applications/ibus.desktop")

        # unlink file

        try:

            os.unlink(link_file)

        except:

            pass

        if self.__checkbutton_auto_start.get_active():

            os.symlink(ibus_desktop, link_file)

    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()