Example #1
0
	def init_keybinder(self, config):
		"""Initialise keybinder and bind some keys (toggle, copy, paste)"""
		Keybinder.init()
		Keybinder.set_use_cooked_accelerators(False)
		self.bind_all_key(config['key_toggle_visibility'],
							config['key_copy_to_clipboard'],
							config['key_paste_from_clipboard'])
Example #2
0
def _enable(eventname, exaile, eventdata):
    global initialized
    if not initialized:
        Keybinder.init()
        initialized = True
    for k in KEYS:
        Keybinder.bind(k, on_media_key, exaile)
Example #3
0
    def setup(self, _):
        self.hold()  # Keep the app running even without a window
        self.window = window = UlauncherWindow.get_instance()
        window.set_application(self)
        window.set_keep_above(True)
        window.position_window()
        window.init_theme()

        # this will trigger to show frequent apps if necessary
        window.show_results([])

        if self.settings.get_property('show-indicator-icon'):
            self.appindicator = AppIndicator(self)
            self.appindicator.switch(True)

        if IS_X11:
            # bind hotkey
            Keybinder.init()
            accel_name = self.settings.get_property('hotkey-show-app')
            # bind in the main thread
            GLib.idle_add(self.bind_hotkey, accel_name)

        ExtensionServer.get_instance().start()
        time.sleep(0.01)
        ExtensionRunner.get_instance().run_all()
Example #4
0
    def finish_initializing(self, builder):
        """
        Set up the main window
        """
        super(UlauncherWindow, self).finish_initializing(builder)

        self.results_nav = None
        self.builder = builder
        self.window = self.get_widget('ulauncher_window')
        self.input = self.get_widget('input')
        self.prefs_btn = self.get_widget('prefs_btn')
        self.result_box = builder.get_object("result_box")

        self.input.connect('changed', self.on_input_changed)
        self.prefs_btn.connect('clicked', self.on_mnu_preferences_activate)

        self.set_keep_above(True)

        self.AboutDialog = AboutUlauncherDialog
        self.PreferencesDialog = PreferencesUlauncherDialog

        self.position_window()
        self.init_styles()

        # bind hotkey
        Keybinder.init()
        accel_name = Settings.get_instance().get_property('hotkey-show-app')
        # bind in the main thread
        GLib.idle_add(self.bind_show_app_hotkey, accel_name)

        start_app_watcher()
Example #5
0
    def __init__(self, config_files):
        super(Klemmbrett, self).__init__()
        self._clipboard = _gtk.Clipboard.get(_gdk.SELECTION_CLIPBOARD)
        self._primary = _gtk.Clipboard.get(_gdk.SELECTION_PRIMARY)

        self.config = _config.Config()
        self.config.read(config_files)

        _keybinder.init()

        # configure klemmbrett
        self._plugins = dict()
        self._load_plugins()

        self._sync = _util.humanbool(
            self.config.get('klemmbrett', 'sync', True))

        self.selection = None

        self._clipboard.connect('owner-change', self._clipboard_owner_changed)
        self._primary.connect('owner-change', self._clipboard_owner_changed)

        try:
            _notify.init("Klemmbrett")
        except _dbus.exceptions.DBusException:
            _log.error(
                "Could not register with notification interface, notifications will not work properly",
                exc_info=True)
Example #6
0
 def __init__(self):
     # =>public window props
     Gtk.Window.__init__(self,
                         title="Kimia-Dict (V " + glob.VERSION + ")"
                         # type_hint=Gdk.WindowTypeHint.TOOLBAR
                         )
     self.set_default_size(800, 500)
     self.set_icon_from_file("./assets/img/logo.png")
     self.set_position(Gtk.WindowPosition.CENTER)
     #=>connect to destory main window
     # self.connect("destroy", self.on_destroy)
     self.connect("delete_event", self.on_delete)
     #=>connect to key events of main window
     self.connect("key-press-event", self.on_key_press_event)
     # =>set toolbar
     MainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
     MainToolbar = menu.ToolBar()
     MainBox.pack_start(MainToolbar, False, False, 0)
     # =>set search box
     MainSearch = search.SearchBox()
     MainBox.pack_start(MainSearch, False, False, 10)
     # =>set content
     sw = Gtk.ScrolledWindow()
     mcontent = search.content
     sw.add_with_viewport(mcontent)
     MainBox.pack_start(sw, True, True, 0)
     # =>add MainBox to main window
     self.add(MainBox)
     # =>init keybinder
     Keybinder.init()
     # =>handle global shortuct by 'shortcut_callback'
     Keybinder.bind(glob.KEYDISPLAY, self.show_shortcut_callback,
                    "keystring %s (user data)" % glob.KEYDISPLAY)
     # =>show all widgets and window
     self.show_all()
Example #7
0
    def __init__(self, silent = False):
        super(KazamSuperIndicator, self).__init__()
        self.blink_icon = BLINK_STOP_ICON
        self.blink_state = False
        self.blink_mode = BLINK_SLOW
        self.recording = False
        self.silent = silent
        logger.debug("Indicatior silent: {0}".format(self.silent))

        self.menu = Gtk.Menu()

        self.menuitem_settings = Gtk.MenuItem(_("Settings"))
        self.menuitem_settings.set_sensitive(True)
        self.menuitem_settings.connect("activate", self.on_menuitem_settings_activate)

        self.menuitem_separator1 = Gtk.SeparatorMenuItem()

        self.menuitem_start = Gtk.MenuItem(_("Start recording"))
        self.menuitem_start.set_sensitive(True)
        self.menuitem_start.connect("activate", self.on_menuitem_start_activate)

        self.menuitem_pause = Gtk.CheckMenuItem(_("Pause recording"))
        self.menuitem_pause.set_sensitive(False)
        self.menuitem_pause.connect("toggled", self.on_menuitem_pause_activate)

        self.menuitem_finish = Gtk.MenuItem(_("Finish recording"))
        self.menuitem_finish.set_sensitive(False)
        self.menuitem_finish.connect("activate", self.on_menuitem_finish_activate)

        self.menuitem_separator2 = Gtk.SeparatorMenuItem()

        self.menuitem_quit = Gtk.MenuItem(_("Quit"))
        self.menuitem_quit.connect("activate", self.on_menuitem_quit_activate)

        self.menu.append(self.menuitem_settings)
        self.menu.append(self.menuitem_separator1)
        self.menu.append(self.menuitem_start)
        self.menu.append(self.menuitem_pause)
        self.menu.append(self.menuitem_finish)
        self.menu.append(self.menuitem_separator2)
        self.menu.append(self.menuitem_quit)

        self.menu.show_all()

        #
        # Setup keybindings - Hardcore way
        #
        try:
            from gi.repository import Keybinder
            logger.debug("Trying to bind hotkeys.")
            Keybinder.init()
            Keybinder.bind("<Super><Ctrl>R", self.cb_hotkeys, "start-request")
            Keybinder.bind("<Super><Ctrl>F", self.cb_hotkeys, "stop-request")
            Keybinder.bind("<Super><Ctrl>P", self.cb_hotkeys, "pause-request")
            Keybinder.bind("<Super><Ctrl>W", self.cb_hotkeys, "show-request")
            Keybinder.bind("<Super><Ctrl>Q", self.cb_hotkeys, "quit-request")
            self.recording = False
        except ImportError:
            logger.info("Unable to import Keybinder, hotkeys not available.")
Example #8
0
    def _init_keys(self):
        Keybinder.init()

        def bind_toggle_key(self, key):
            self.bind_toggle_key(key)
            return False  # to not be called again.

        GLib.idle_add(bind_toggle_key, self, catapult.conf.toggle_key)
Example #9
0
def run_keybinder(callback):
    Keybinder.init()
    Keybinder.bind('<Ctrl><Alt>space', callback)

    try:
        GLib.MainLoop().run()
    except KeyboardInterrupt:
        GLib.MainLoop().quit()
Example #10
0
 def on_exaile_loaded(self):
     if not self.__exaile:
         return  # Plugin has been disabled in the meantime
     Keybinder.init()
     for k in KEYS:
         if not Keybinder.bind(k, on_media_key, self.__exaile):
             LOGGER.warning("Failed to set key binding using Keybinder.")
             self.__exaile.plugins.disable_plugin(__name__)
             return
Example #11
0
 def bind_key(cls):
     Keybinder.init()
     shortcut = MetaData.get_snapshoot_shortcut()
     if Keybinder.bind(shortcut, cls.callback, ""):
         if cls.old_key_shortcut is not None:
             Keybinder.unbind(cls.old_key_shortcut)
         cls.old_key_shortcut = shortcut
     else:
         logging.error("Bind shortcut key failed ")
Example #12
0
    def __init__(self, superkey='<Super>'):
        self.montab = MonTab()
        self.super = superkey

        nmons = self.montab.screen.get_n_monitors()
        self.monkeys = [chr(ord('1') + n) for n in range(nmons)]

        Keybinder.init()
        Keybinder.set_use_cooked_accelerators(False)
Example #13
0
    def __init__(self, superkey='<Super>'):
        self.montab = MonTab()
        self.super = superkey

        nmons = self.montab.screen.get_n_monitors()
        self.monkeys = [chr(ord('1') + n) for n in range(nmons)]

        Keybinder.init()
        Keybinder.set_use_cooked_accelerators(False)
Example #14
0
 def bind_key(cls):
     Keybinder.init()
     shortcut = MetaData.get_snapshoot_shortcut()
     if Keybinder.bind(shortcut,cls.callback,""):
         if cls.old_key_shortcut is not None:
             Keybinder.unbind(cls.old_key_shortcut)
         cls.old_key_shortcut = shortcut
     else:
         logging.error("Bind shortcut key failed ")
Example #15
0
 def __init__(self):
 
     self.recorder = Recorder()
         
     keybinder.init()
     keybinder.bind('<Control>Escape', self.callback, None)
     
     self.overlay = Overlay()
     self.overlay.connect('trigger', lambda *args: self.start_recording(*self.overlay.get_selection()))
     self.overlay.show_all()
Example #16
0
    def __init__(self, silent=False):
        super(KazamSuperIndicator, self).__init__()
        self.blink_icon = BLINK_STOP_ICON
        self.blink_state = False
        self.blink_mode = BLINK_SLOW
        self.recording = False
        self.silent = silent
        logger.debug("Indicatior silent: {0}".format(self.silent))

        self.menu = Gtk.Menu()

        self.menuitem_start = Gtk.MenuItem(_("Start recording"))
        self.menuitem_start.set_sensitive(True)
        self.menuitem_start.connect("activate", self.on_menuitem_start_activate)

        self.menuitem_pause = Gtk.CheckMenuItem(_("Pause recording"))
        self.menuitem_pause.set_sensitive(False)
        self.menuitem_pause.connect("toggled", self.on_menuitem_pause_activate)

        self.menuitem_finish = Gtk.MenuItem(_("Finish recording"))
        self.menuitem_finish.set_sensitive(False)
        self.menuitem_finish.connect("activate", self.on_menuitem_finish_activate)

        self.menuitem_separator = Gtk.SeparatorMenuItem()

        self.menuitem_quit = Gtk.MenuItem(_("Quit"))
        self.menuitem_quit.connect("activate", self.on_menuitem_quit_activate)

        self.menu.append(self.menuitem_start)
        self.menu.append(self.menuitem_pause)
        self.menu.append(self.menuitem_finish)
        self.menu.append(self.menuitem_separator)
        self.menu.append(self.menuitem_quit)

        self.menu.show_all()

        #
        # Setup keybindings - Hardcore way
        #
        try:
            from gi.repository import Keybinder

            logger.debug("Trying to bind hotkeys.")
            Keybinder.init()
            # 2015-10-10, Joshua Chen
            # configure the shortcut keys
            Keybinder.bind("<Ctrl><Shift>F1", self.cb_hotkeys, "start-request")
            Keybinder.bind("<Ctrl><Shift>F12", self.cb_hotkeys, "stop-request")
            Keybinder.bind("<Ctrl><Shift>F8", self.cb_hotkeys, "pause-request")
            # Keybinder.bind("<Ctrl>W", self.cb_hotkeys, "show-request")
            Keybinder.bind("<Ctrl><Shift>F11", self.cb_hotkeys, "quit-request")
            self.recording = False
        except ImportError:
            logger.info("Unable to import Keybinder, hotkeys not available.")
Example #17
0
    def __init__(self):
        self.indicator = appindicator.Indicator.new(APPINDICATOR_ID, self.get_current_state_icon(), appindicator.IndicatorCategory.SYSTEM_SERVICES)
        self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
        self.indicator.set_menu(self.build_menu())
        self.update_mic_state()
        Notify.init(APPINDICATOR_ID)

        Keybinder.init()
        Keybinder.set_use_cooked_accelerators(False)
        Keybinder.bind(keystr, self.callback_toggle_mic, "keystring %s (user data)" % keystr)
        print ("Press '" + keystr + "' to toggle microphone mute")
Example #18
0
    def __init__(self, data):
        """Create a new UIObject instance, including loading its uiFile and
           all UI-related objects.

           Instance attributes:

           data     -- An instance of a pykickstart Handler object.  The Hub
                       never directly uses this instance.  Instead, it passes
                       it down into Spokes when they are created and applied.
                       The Hub simply stores this instance so it doesn't need
                       to be passed by the user.
           skipTo   -- If this attribute is set to something other than None,
                       it must be the name of a class (as a string).  Then,
                       the interface will skip to the first instance of that
                       class in the action list instead of going on to
                       whatever the next action is normally.

                       Note that actions may only skip ahead, never backwards.
                       Also, standalone spokes may not skip to an individual
                       spoke off a hub.  They can only skip to the hub
                       itself.
        """
        common.UIObject.__init__(self, data)

        if self.__class__ is GUIObject:
            raise TypeError("GUIObject is an abstract class")

        self.skipTo = None
        self.applyOnSkip = False

        self.builder = Gtk.Builder()
        self.builder.set_translation_domain(self.translationDomain)
        self._window = None

        if self.builderObjects:
            self.builder.add_objects_from_file(self._findUIFile(),
                                               self.builderObjects)
        else:
            self.builder.add_from_file(self._findUIFile())

        self.builder.connect_signals(self)

        # Keybinder from GI needs to be initialized before use
        Keybinder.init()
        Keybinder.bind("<Shift>Print", self._handlePrntScreen, [])

        self._automaticEntry = False
        self._autostepRunning = False
        self._autostepDone = False
        self._autostepDoneCallback = None

        # this indicates if the screen is the last spoke to be processed for a hub
        self.lastAutostepSpoke = False
Example #19
0
 def __init__(self):
     self.indicator = AppIndicator3.Indicator.new(
         'tasker', 'tasker',
         AppIndicator3.IndicatorCategory.APPLICATION_STATUS)
     Keybinder.init()
     self.load_preferences()
     self.indicator.set_menu(self.build_menu())
     self.indicator.set_label('', '')
     self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
     self.set_icon(True)
     self.load_todos()
     Gtk.main()
Example #20
0
    def __init__(self):
        self.app = "xkb-indicator"
        self.indicator = appindicator.Indicator.new(
            self.app,
            "ibus-keyboard",
            category=appindicator.IndicatorCategory.OTHER)
        self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
        self.indicator.set_menu(self.build_menu())
        self.indicator.set_label(label(), self.app)

        Keybinder.bind("<Alt>space", self.toggle)
        Keybinder.init()
Example #21
0
    def __init__(self, data):
        """Create a new UIObject instance, including loading its uiFile and
           all UI-related objects.

           Instance attributes:

           data     -- An instance of a pykickstart Handler object.  The Hub
                       never directly uses this instance.  Instead, it passes
                       it down into Spokes when they are created and applied.
                       The Hub simply stores this instance so it doesn't need
                       to be passed by the user.
           skipTo   -- If this attribute is set to something other than None,
                       it must be the name of a class (as a string).  Then,
                       the interface will skip to the first instance of that
                       class in the action list instead of going on to
                       whatever the next action is normally.

                       Note that actions may only skip ahead, never backwards.
                       Also, standalone spokes may not skip to an individual
                       spoke off a hub.  They can only skip to the hub
                       itself.
        """
        common.UIObject.__init__(self, data)

        if self.__class__ is GUIObject:
            raise TypeError("GUIObject is an abstract class")

        self.skipTo = None
        self.applyOnSkip = False

        self.builder = Gtk.Builder()
        self.builder.set_translation_domain(self.translationDomain)
        self._window = None

        if self.builderObjects:
            self.builder.add_objects_from_file(self._findUIFile(), self.builderObjects)
        else:
            self.builder.add_from_file(self._findUIFile())

        self.builder.connect_signals(self)

        # Keybinder from GI needs to be initialized before use
        Keybinder.init()
        Keybinder.bind("<Shift>Print", self._handlePrntScreen, [])

        self._automaticEntry = False
        self._autostepRunning = False
        self._autostepDone = False
        self._autostepDoneCallback = None

        # this indicates if the screen is the last spoke to be processed for a hub
        self.lastAutostepSpoke = False
Example #22
0
def plugin_main(app, fullpath):
    import gi
    gi.require_version('Notify', '0.7')
    gi.require_version('Keybinder', '3.0')

    from gi.repository import Keybinder, Notify

    global notification
    notification = Notify.Notification()

    Keybinder.init()
    Keybinder.bind("<Ctrl><Alt>v", lambda *a: grab_notify(app))
    Keybinder.bind("<Ctrl><Alt>m", lambda *a: notifier(app))
    Notify.init("anubad")
    notification.set_icon_from_pixbuf(app.pixbuf_logo)
Example #23
0
    def __init__(self, player):
        self.player = player
        self.logger = logging.getLogger('KeyboardClient')

        try:
            import gi
            gi.require_version('Keybinder', '3.0')
            from gi.repository import Keybinder
            Keybinder.init()
            Keybinder.bind('XF86AudioPlay', self._on_XF86AudioPlay)
            Keybinder.bind('XF86AudioNext', self._on_XF86AudioNext)
            Keybinder.bind('XF86AudioPrev', self._on_XF86AudioPrev)
        except ValueError:
            self.logger.warning(
                'Keybinder is needed on Linux for MediaKey binding')
Example #24
0
    def __init__(self):
        self.bound_keys = []
        self.workarea = Workarea()
        self.callable_actions = dict
        self.__define_callable_actions()

        notify2.init("Azulejo")
        Keybinder.init()

        Keybinder.bind("<Super>y", WindowTools.print_window_info, None)
        Keybinder.bind("<Super>c", self.switch_config_files, None)

        self.bind_keys(configuration.get_config_data_first_time())

        Gtk.main()
Example #25
0
    def finish_initializing(self, builder):
        """Called while initializing this instance in __new__

        finish_initializing should be called after parsing the UI definition
        and creating a UlauncherWindow object with it in order to finish
        initializing the start of the new UlauncherWindow instance.
        """
        # Get a reference to the builder and set up the signals.
        self.builder = builder
        self.ui = builder.get_ui(self, True)
        self.PreferencesDialog = None  # class
        self.preferences_dialog = None  # instance

        self.results_nav = None
        self.window = self.ui['ulauncher_window']
        self.window_body = self.ui['body']
        self.input = self.ui['input']
        self.prefs_btn = self.ui['prefs_btn']
        self.result_box = self.ui["result_box"]

        self.input.connect('changed', self.on_input_changed)
        self.prefs_btn.connect('clicked', self.on_mnu_preferences_activate)

        self.set_keep_above(True)

        self.PreferencesDialog = PreferencesUlauncherDialog
        self.settings = Settings.get_instance()

        self.fix_window_width()
        self.position_window()
        self.init_theme()

        # this will trigger to show frequent apps if necessary
        self.show_results([])

        if not is_wayland_compatibility_on():
            # bind hotkey
            Keybinder.init()
            accel_name = self.settings.get_property('hotkey-show-app')
            # bind in the main thread
            GLib.idle_add(self.bind_show_app_hotkey, accel_name)

        start_app_watcher()
        ExtensionServer.get_instance().start()
        time.sleep(0.01)
        ExtensionRunner.get_instance().run_all()
        if not get_options().no_extensions:
            ExtensionDownloader.get_instance().download_missing()
Example #26
0
    def start_daemon(self):
        Keybinder.init()
        self.set_accelerator()

        css.load_css()
        emojis.init()

        self.activated = True

        # The first time the app launches, open the picker and show the
        # guide
        if not user_data.load_shown_welcome():
            self.create_picker_window(True)
            user_data.update_shown_welcome()

        # Run the main gtk event loop - this prevents the app from quitting
        Gtk.main()
Example #27
0
    def finish_initializing(self, builder):
        """Called while initializing this instance in __new__

        finish_initializing should be called after parsing the UI definition
        and creating a UlauncherWindow object with it in order to finish
        initializing the start of the new UlauncherWindow instance.
        """
        # Get a reference to the builder and set up the signals.
        self.builder = builder
        self.ui = builder.get_ui(self, True)
        self.PreferencesDialog = None  # class
        self.preferences_dialog = None  # instance

        self.results_nav = None
        self.window = self.ui['ulauncher_window']
        self.input = self.ui['input']
        self.prefs_btn = self.ui['prefs_btn']
        self.result_box = self.ui["result_box"]

        self.input.connect('changed', self.on_input_changed)
        self.prefs_btn.connect('clicked', self.on_mnu_preferences_activate)

        self.set_keep_above(True)

        self.PreferencesDialog = PreferencesUlauncherDialog
        self.settings = Settings.get_instance()

        self.fix_window_width()
        self.position_window()
        self.init_theme()

        # this will trigger to show frequent apps if necessary
        self.show_results([])

        if not is_wayland_compatibility_on():
            # bind hotkey
            Keybinder.init()
            accel_name = self.settings.get_property('hotkey-show-app')
            # bind in the main thread
            GLib.idle_add(self.bind_show_app_hotkey, accel_name)

        start_app_watcher()
        ExtensionServer.get_instance().start()
        time.sleep(0.01)
        ExtensionRunner.get_instance().run_all()
        ExtensionDownloader.get_instance().download_missing()
Example #28
0
 def __init__(self, hook):
     self.hook = hook
     self.indicator = AppIndicator3.Indicator.new(
         "tasker",
         "tasker",
         AppIndicator3.IndicatorCategory.APPLICATION_STATUS,
     )
     Keybinder.init()
     self.tracking = False
     self.load_preferences()
     self.indicator.set_menu(self.build_menu())
     self.indicator.set_label("", "")
     self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
     self.set_icon()
     self.load_todos()
     self.hook.after_init_indicator()
     Gtk.main()
Example #29
0
	def __init__(self):
		Gtk.Window.__init__(self, type=Gtk.WindowType.TOPLEVEL)
		Keybinder.init()

		# Deactivating WM keybindings
		keybindings = Gio.Settings.new('org.gnome.desktop.wm.keybindings')
		wm_hotkey = lambda t: keybindings.get_value(t)[0]
		if wm_hotkey('switch-input-source') or wm_hotkey('switch-input-source-backward'):
			self.show_message("Unity-Kbd-Switcher is going to deactivate the following WM keybindings\n"
				+ "You can set them later in settings if you'll decide to discontinue using.\n"
				+ "\n"
				+ "switch-input-source: " + wm_hotkey('switch-input-source') + "\n"
				+ "switch-input-source-backward: " + wm_hotkey('switch-input-source-backward') + "\n")
			keybindings.set_value('switch-input-source', GLib.Variant('as', ['']))
			keybindings.set_value('switch-input-source-backward', GLib.Variant('as', ['']))

		# Initializing GSettings
		self.source_settings = Gio.Settings.new('org.gnome.desktop.input-sources')
		self.source_settings.connect("changed::current", self.on_current_changed)
		self.source_settings.connect("changed::sources", self.on_sources_changed)

		# Loading config
		rc = "%s/.kbdrc" % os.getenv("HOME")
		if not os.path.isfile(rc):
			self.generate_default_rc(rc)
		keymap = {}
		execfile(rc)
		self.keymap = keymap

		self.current_layout = None
		self.on_sources_changed(None, None)
		self.on_current_changed(None, None)

		# Binding global hotkeys
		for key in self.keymap.keys():
			print "Binding %s" % key
			if not Keybinder.bind(key, self.on_global_key_activated, None):
				self.show_message("Could not bind '%s'" % key)
		
		# Usual Gtk Stuff
		self.connect("destroy", Gtk.main_quit)
		self.connect("delete_event", Gtk.main_quit)
		signal.signal(signal.SIGINT, signal.SIG_DFL)
		internals.app = self
		Gtk.main()
Example #30
0
    def finish_initializing(self, ui):
        # pylint: disable=attribute-defined-outside-init
        self.ui = ui
        self.preferences = None  # instance

        self.results_nav = None
        self.window_body = self.ui['body']
        self.input = self.ui['input']
        self.prefs_btn = self.ui['prefs_btn']
        self.result_box = self.ui["result_box"]
        self.scroll_container = self.ui["result_box_scroll_container"]

        self.input.connect('changed', self.on_input_changed)
        self.prefs_btn.connect('clicked', self.on_mnu_preferences_activate)

        self.set_keep_above(True)

        self.settings = Settings.get_instance()

        self.fix_window_width()
        self.position_window()
        self.init_theme()

        # this will trigger to show frequent apps if necessary
        self.show_results([])

        self.connect('button-press-event', self.mouse_down_event)
        self.connect('button-release-event', self.mouse_up_event)
        self.connect('motion_notify_event', self.mouse_move_event)

        if self.settings.get_property('show-indicator-icon'):
            AppIndicator.get_instance(self).show()

        if IS_X11:
            # bind hotkey
            Keybinder.init()
            accel_name = self.settings.get_property('hotkey-show-app')
            # bind in the main thread
            GLib.idle_add(self.bind_hotkey, accel_name)

        ExtensionServer.get_instance().start()
        time.sleep(0.01)
        ExtensionRunner.get_instance().run_all()
        if not get_options().no_extensions:
            ExtensionDownloader.get_instance().download_missing()
Example #31
0
    def bind_keybinder(self):
        try:
            import gi
            gi.require_version('Keybinder', '3.0')
            # Gdk needed for Keybinder
            from gi.repository import Keybinder, Gdk
            Keybinder.init()
        except:
            return False

        Keybinder.bind('XF86AudioPlay', self.window.playpause, None)
        Keybinder.bind('XF86AudioStop', self.window.user_pause, None)
        Keybinder.bind('XF86AudioNext', self.window.next_song, None)
        Keybinder.bind('XF86AudioPrev', self.window.bring_to_top, None)

        logging.info("Bound media keys with keybinder")
        self.method = 'keybinder'
        return True
Example #32
0
 def bind_keybinder(self):
     try:
         import gi
         gi.require_version('Keybinder', '3.0')
         # Gdk needed for Keybinder
         from gi.repository import Keybinder
         Keybinder.init()
     except (ValueError, ImportError):
         return False
     
     Keybinder.bind('XF86AudioPlay', self.window.playpause, None)
     Keybinder.bind('XF86AudioStop', self.window.user_pause, None)
     Keybinder.bind('XF86AudioNext', self.window.next_song, None)
     Keybinder.bind('XF86AudioPrev', self.window.bring_to_top, None)
     
     logging.info("Bound media keys with keybinder")
     self.method = 'keybinder'
     return True
Example #33
0
    def __init__(self):
        assert self.__class__.instance is None, 'Can be created only once!'
        self.hotkeys = {}
        self.config = None

        self.play_pause = EventHook()
        self.next = EventHook()
        self.prev = EventHook()

        if IS_INIT:
            Keybinder.init()
            self.initialize()

            threading.Thread(target=Gtk.main).start()
        else:
            NotificationArea.notify(
                'Could not import Keybinder and Gtk. Error was: "{}"\n'
                'Global shortcuts will not work.'.format(ERROR))
Example #34
0
    def __init__(self):
        self._x_hotkeys = {}
        self._hotkeys = self._parse_hotkeys()
        self.config = None

        self.play_pause = EventHook()
        self.next = EventHook()
        self.prev = EventHook()

        if IS_INIT:
            Keybinder.init()
            self.initialize()
            threading.Thread(target=Gtk.main).start()
        else:
            logger.debug("Not loading the global shortcuts.")
            notification_area.notify(
                ERROR_MESSAGE +
                ", this means the global shortcuts will not work.\n" +
                "You can check the log for more details.")
Example #35
0
    def __init__(self):
        GObject.GObject.__init__(self)

        self.bound = False
        self.prevbinding = None

        keybinder.init()

        # Set and retreive global keybinding from GSettings
        glipper.GSETTINGS.connect(
            "changed::" + glipper.GSETTINGS_KEY_COMBINATION,
            lambda x, y, z=None: self.on_config_key_combination())
        self.key_combination = glipper.GSETTINGS.get_string(
            glipper.GSETTINGS_KEY_COMBINATION)
        if self.key_combination == None:
            # This is for uninstalled cases, the real default is in the schema
            self.key_combination = "<Ctrl><Alt>C"

        self.bind()
Example #36
0
 def on_startup(self, app):
     '''
     This method handles the startup signal.
     As per GNOME guidelines this is where most of
     the work to create the window should be done.
     '''
     self.create_directories()
     
     self.settings = Gio.Settings(schema=self.schema_id + '.preferences')
     self.win_settings = Gio.Settings(schema=self.schema_id + '.window')
     self.width = self.win_settings['width']
     self.height = self.win_settings['height']
     self.general_settings = self.settings.get_child('general')
     self.set_autostart(self.general_settings['autostart'])
     self.closehide = self.general_settings['closehide']
     self.about_dialog = None
     self.preferences_dialog = None
     logging.basicConfig(filename=self.log_file, level=logging.DEBUG,
                         format='%(asctime)s %(levelname)s: %(message)s')
     
     self.window = Gtk.ApplicationWindow(application=app)
     self.window.connect('size-allocate', self.on_size_allocate)
     self.window.connect('delete-event', self.on_window_delete)
     self.window.set_title(self.title)
     self.window.set_default_size(self.width, self.height)
     self.window.set_position(Gtk.WindowPosition.MOUSE)
     self.window.set_titlebar(HeaderBar(self))
     # We need to set the icon here as a backup, the gnome system monitor
     # for instance, and for whatever reason, doesn't choose the right icon
     # sometimes, particularly after hiding the window, and showing again.
     self.window.set_icon_name(self.icon)
     self.main_view = MainView(self)
     self.window.add(self.main_view)
     
     self.add_actions()
     builder = Gtk.Builder.new_from_file(self.gui_ui)
     app_menu = builder.get_object('app_menu')
     self.set_app_menu(app_menu)
     
     Keybinder.init()
     shortcuts = self.settings.get_child('shortcuts')
     Keybinder.bind(shortcuts['app-show'], self.on_show)
Example #37
0
def init_keybinder(player):
    try:
        import gi
        gi.require_version("Keybinder", "3.0")
        from gi.repository import Keybinder
    except (ValueError, ImportError):
        return False

    Keybinder.init()

    signals = {
        "XF86AudioPrev": "prev",
        "XF86AudioNext": "next",
        "XF86AudioStop": "stop",
        "XF86AudioPlay": "play"
    }
    for sig, action in signals.items():
        Keybinder.bind(sig, make_keybinder_cb(player, action), None)

    return True
Example #38
0
 def add_global_shortcut(self):
     '''
     This method adds a global shortcut,
     the shortcut used to show the application.
     '''
     shortcuts = self.settings.get_child('shortcuts')
     if platform.system() == 'Windows':
         self.modifiers = {
             Gdk.ModifierType.SHIFT_MASK: ['VK_SHIFT'],
             Gdk.ModifierType.CONTROL_MASK: ['VK_CONTROL'],
             Gdk.ModifierType.MOD1_MASK: ['VK_MENU'],
             Gdk.ModifierType.SUPER_MASK: ['VK_LWIN', 'VK_RWIN']
         }
         hook_manager = pyHook.HookManager()
         hook_manager.KeyDown = self.on_keyboard_event
         self.set_hotkey(shortcuts['app-show'])
         hook_manager.HookKeyboard()
     else:
         Keybinder.init()
         Keybinder.bind(shortcuts['app-show'], self.on_show)
Example #39
0
def main():
    # Catch SIGINT signal
    signal.signal(signal.SIGINT, signal.SIG_DFL)

    # Load the configuration with defaults
    config = Config()

    # Create the window and set attributes
    win = NimblestWindow(config)
    win.connect("delete-event", Gtk.main_quit)
    win.set_position(Gtk.WindowPosition.CENTER)
    win.set_keep_above(True)
    win.set_skip_taskbar_hint(True)
    win.set_decorated(False)

    # Set the hotkey
    Keybinder.init()
    if not Keybinder.bind(config.hotkey, win.hotkey, None):
        print("Could not bind the hotkey:", config.hotkey)
        exit()
    Gtk.main()
Example #40
0
 def add_global_shortcut(self):
     '''
     This method adds a global shortcut,
     the shortcut used to show the application.
     '''
     shortcuts = self.settings.get_child('shortcuts')
     if platform.system() == 'Windows':
         self.modifiers = {Gdk.ModifierType.SHIFT_MASK:
                               ['VK_SHIFT'],
                           Gdk.ModifierType.CONTROL_MASK:
                               ['VK_CONTROL'],
                           Gdk.ModifierType.MOD1_MASK:
                               ['VK_MENU'],
                           Gdk.ModifierType.SUPER_MASK:
                               ['VK_LWIN', 'VK_RWIN']}
         hook_manager = pyHook.HookManager()
         hook_manager.KeyDown = self.on_keyboard_event
         self.set_hotkey(shortcuts['app-show'])
         hook_manager.HookKeyboard()
     else:
         Keybinder.init()
         Keybinder.bind(shortcuts['app-show'], self.on_show)
Example #41
0
    def __init__(self):
        self.builder = Gtk.Builder()
        self.builder.add_from_file(UI_FILE)
        self.builder.connect_signals(self)

        Keybinder.init()
        Keybinder.bind("<Ctrl>T", self.on_shortcut_pressed, True)
        Keybinder.bind("<Ctrl>W", self.on_shortcut_pressed, True)
        Keybinder.bind("<Ctrl>Q", self.on_shortcut_pressed, True)
        Keybinder.bind("<Ctrl>L", self.on_shortcut_pressed, True)

        self.btn_back = self.builder.get_object('bar-btn-back')
        self.btn_forward = self.builder.get_object('bar-btn-forward')
        self.urlbar = self.builder.get_object('bar-urlbar')

        self.settings = self.builder.get_object('bar-settings')

        self.tabcontainer = self.builder.get_object('tabcontainer')

        self.browser = self.builder.get_object('browser')
        self.browser.show_all()

        self.tab_append()
Example #42
0
    def __init__(self):
        self.display = display.Display()

        Keybinder.init()
        Keybinder.bind("<Ctrl>9", self.on_snippets_activated)

        menu = Gtk.Menu()

        item = Gtk.MenuItem()
        item.set_label("Editor")
        item.connect("activate", self.on_editor_activated)
        item.show()
        menu.append(item)

        item = Gtk.MenuItem()
        item.set_label("Exit")
        item.connect("activate", Gtk.main_quit)
        item.show()
        menu.append(item)

        self.status_icon = AppIndicator3.Indicator.new(
            "linux-snippets",
            "onboard-mono",
            AppIndicator3.IndicatorCategory.APPLICATION_STATUS
        )
        self.status_icon.set_icon_theme_path(os.getcwd()+"/res/")
        self.status_icon.set_icon("icon")

        self.status_icon.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
        self.status_icon.set_menu(menu)

        self.editor = e_w.EditorWindow()
        self.editor.connect("delete-event", self.on_window_deleted)

        self.snippets = sn_w.SnippetsWindow(self.on_snippets_completed)
        self.snippets.connect("delete-event", self.on_window_deleted)
Example #43
0
    def run(self):
        # self.win = Gtk.Window()
        self.win = Gtk.Window(type=Gtk.WindowType.POPUP)
        self.win.set_border_width(1)

        width = 400
        relative_top = 0.25

        self.win.set_size_request(width, -1)

        self.win.move(
            (Gdk.Screen.get_default().width() / 2) - width / 2,
            Gdk.Screen.get_default().height() * relative_top,
        )

        self.win.connect("delete-event", Gtk.main_quit)
        self.win.connect("show", self.handle_show)

        self.win.set_type_hint(Gdk.WindowTypeHint.UTILITY)

        self.win.set_resizable(False)

        self.win.set_decorated(False)

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        vbox.set_homogeneous(False)
        self.win.add(vbox)

        self.entry = Gtk.Entry()

        self.entry.override_font(
            Pango.FontDescription.from_string(self.config["entry_font"]))

        self.entry.connect("key-press-event", self.handle_key_press)
        self.entry.connect("changed", self.handle_input)

        vbox.pack_start(self.entry, False, True, 0)

        self.store = Gtk.ListStore(GdkPixbuf.Pixbuf, str, object)

        self.tree = Gtk.TreeView(self.store)

        self.tree.override_font(Pango.FontDescription.from_string(self.config["name_font"]))
        self.tree.set_headers_visible(False)

        self.tree.get_selection().set_mode(Gtk.SelectionMode.BROWSE)

        self.content_renderer = Gtk.CellRendererText()
        content_column = Gtk.TreeViewColumn("Name", self.content_renderer, markup=1)

        self.icon_renderer = Gtk.CellRendererPixbuf()
        icon_column = Gtk.TreeViewColumn("Icon", self.icon_renderer, pixbuf=0)

        self.tree.append_column(icon_column)
        self.tree.append_column(content_column)

        self.tree.set_search_column(-1)

        def handle_selection_changed(selection):
            tree_iter = selection.get_selected()[1]

            if not tree_iter:
                return

            self.tree.scroll_to_cell(self.store.get_path(tree_iter))

        self.tree.get_selection().connect("changed", handle_selection_changed)

        self.scrolled = Gtk.ScrolledWindow()
        self.scrolled.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.AUTOMATIC)


        self.scrolled.add(self.tree)

        vbox.pack_start(self.scrolled, False, False, 0)

        signal.signal(signal.SIGINT, signal.SIG_DFL)

        accel_group = Gtk.AccelGroup()

        def connect_accel(accel, func):
            accel_group.connect(accel[0], accel[1], 0, func)

        def connection_multiple_accels(accels, func):
            for accel in accels:
                connect_accel(accel, func)

        hide_accel = Gtk.accelerator_parse("Escape")
        connect_accel(hide_accel, self.hide)

        quit_accel = Gtk.accelerator_parse("<Ctrl>q")
        connect_accel(quit_accel, Gtk.main_quit)

        launch_accel = Gtk.accelerator_parse("Return")
        connect_accel(launch_accel, self.launch_choice)

        Keybinder.init()
        Keybinder.bind(self.config["show_binding"], self.show, None)

        self.win.add_accel_group(accel_group)
        self.win.show_all()
        self.scrolled.hide()

        # Gdk.keyboard_grab(self.win.get_window(), False, Gdk.CURRENT_TIME)

        Gtk.main()
Example #44
0
example-gi-py3.py

Looked at a pull request that was built for py2.x, but
overwrote the original py instead of making a separate example.
I wouldn't have accepted that pull request either.

The keybinder.init() part wasn't in the original example.

[email protected]

public domain
"""

import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Keybinder', '3.0')

from gi.repository import Gtk
from gi.repository import Keybinder

def callback(keystr, user_data):
    print ("Handling", user_data)
    print ("Event time:", Keybinder.get_current_event_time())
    Gtk.main_quit()

if __name__ == '__main__':
    keystr = "<Ctrl><Alt>M"
    Keybinder.init()
    Keybinder.bind(keystr, callback, "keystring %s (user data)" % keystr)
    print ("Press", keystr, "to handle keybinding and quit")
    Gtk.main()
Example #45
0
 def run(self):
     keybinder.init()
     me = lib.singleton.SingleInstance()
     self.handleKeys()
     self.startIndicator()
     gtk.main()
 def bind_key(self):
     key_bind_hide = "Menu"
     Keybinder.init()
     Keybinder.bind(key_bind_hide, self.hide_app, "key_bind_hide: %s" % key_bind_hide)
Example #47
0
 def __init__(self):
     Keybinder.init()
Example #48
0
def run(queue):
    keystr = "<Ctrl><Alt>z"
    Keybinder.init()
    assert Keybinder.bind(keystr, _on_shortcut, queue)
    debug('keybinder active')
    Gtk.main()
Example #49
0
 def init_key_binding(self):
     Keybinder.init()
     Keybinder.bind(show_keystr, self.show)
     Keybinder.bind(hide_keystr, self.hide)
     Keybinder.bind(take_photo_keystr, write_photo)
Example #50
0
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GLib
import threading

from gi.repository import GObject
import datetime
from gecoc import gecolib

from gi.repository import Notify
Notify.init('GECO')
import keyring

try:
    from gi.repository import Keybinder as keybinder
    keybinder.init()
except:
    keybinder = None


__version__ = '1.0'
IMG = 'glade'
SECONDS = 600
CONFFILE = 'geco.conf'


def remove_text(button):
    alignment = button.get_children()[0]
    hbox = alignment.get_children()[0]
    image, label = hbox.get_children()
    image.show()
Example #51
0
    def __init__(self):

        def load_schema():
            return Gio.SettingsSchemaSource.new_from_directory(
                SCHEMA_DIR, Gio.SettingsSchemaSource.get_default(), False
            )

        try:
            schema_source = load_schema()
        except GLib.Error:  # pylint: disable=catching-non-exception
            log.exception("Unable to load the GLib schema, try to compile it")
            try_to_compile_glib_schemas()
            schema_source = load_schema()
        self.settings = Settings(schema_source)

        super(Guake, self).__init__(gladefile('guake.glade'))

        select_gtk_theme(self.settings)
        patch_gtk_theme(self.get_widget("window-root").get_style_context(), self.settings)
        self.add_callbacks(self)

        log.info('Guake Terminal %s', guake_version())
        log.info('VTE %s', vte_version())
        log.info('Gtk %s', gtk_version())

        self.hidden = True
        self.forceHide = False

        # trayicon! Using SVG handles better different OS trays
        # img = pixmapfile('guake-tray.svg')
        # trayicon!
        img = pixmapfile('guake-tray.png')
        try:
            import appindicator
        except ImportError:
            self.tray_icon = Gtk.StatusIcon()
            self.tray_icon.set_from_file(img)
            self.tray_icon.set_tooltip_text(_("Guake Terminal"))
            self.tray_icon.connect('popup-menu', self.show_menu)
            self.tray_icon.connect('activate', self.show_hide)
        else:
            # TODO PORT test this on a system with app indicator
            self.tray_icon = appindicator.Indicator(
                _("guake-indicator"), _("guake-tray"), appindicator.CATEGORY_OTHER
            )
            self.tray_icon.set_icon(img)
            self.tray_icon.set_status(appindicator.STATUS_ACTIVE)
            menu = self.get_widget('tray-menu')
            show = Gtk.MenuItem(_('Show'))
            show.set_sensitive(True)
            show.connect('activate', self.show_hide)
            show.show()
            menu.prepend(show)
            self.tray_icon.set_menu(menu)

        # important widgets
        self.window = self.get_widget('window-root')
        self.window.set_keep_above(True)
        self.mainframe = self.get_widget('mainframe')
        self.mainframe.remove(self.get_widget('notebook-teminals'))

        # Workspace tracking
        self.notebook_manager = NotebookManager(
            self.window, self.mainframe,
            self.settings.general.get_boolean('workspace-specific-tab-sets'), self.terminal_spawned,
            self.page_deleted
        )
        self.notebook_manager.connect('notebook-created', self.notebook_created)
        self.notebook_manager.set_workspace(0)
        self.set_tab_position()

        # check and set ARGB for real transparency
        color = self.window.get_style_context().get_background_color(Gtk.StateFlags.NORMAL)
        self.window.set_app_paintable(True)

        def draw_callback(widget, cr):
            if widget.transparency:
                cr.set_source_rgba(color.red, color.green, color.blue, 1)
            else:
                cr.set_source_rgb(0, 0, 0)
            cr.set_operator(cairo.OPERATOR_SOURCE)
            cr.paint()
            cr.set_operator(cairo.OPERATOR_OVER)

        screen = self.window.get_screen()
        visual = screen.get_rgba_visual()

        if visual and screen.is_composited():
            self.window.set_visual(visual)
            self.window.transparency = True
        else:
            log.warn('System doesn\'t support transparency')
            self.window.transparency = False
            self.window.set_visual(screen.get_system_visual())

        self.window.connect('draw', draw_callback)

        # Debounce accel_search_terminal
        self.prev_accel_search_terminal_time = 0.0

        # holds the timestamp of the losefocus event
        self.losefocus_time = 0

        # holds the timestamp of the previous show/hide action
        self.prev_showhide_time = 0

        # Controls the transparency state needed for function accel_toggle_transparency
        self.transparency_toggled = False

        # store the default window title to reset it when update is not wanted
        self.default_window_title = self.window.get_title()

        self.abbreviate = False

        self.window.connect('focus-out-event', self.on_window_losefocus)

        # Handling the delete-event of the main window to avoid
        # problems when closing it.
        def destroy(*args):
            self.hide()
            return True

        def window_event(*args):
            return self.window_event(*args)

        self.window.connect('delete-event', destroy)
        self.window.connect('window-state-event', window_event)

        # this line is important to resize the main window and make it
        # smaller.
        # TODO PORT do we still need this?
        # self.window.set_geometry_hints(min_width=1, min_height=1)

        # special trick to avoid the "lost guake on Ubuntu 'Show Desktop'" problem.
        # DOCK makes the window foundable after having being "lost" after "Show
        # Desktop"
        self.window.set_type_hint(Gdk.WindowTypeHint.DOCK)
        # Restore back to normal behavior
        self.window.set_type_hint(Gdk.WindowTypeHint.NORMAL)

        # loading and setting up configuration stuff
        GSettingHandler(self)
        Keybinder.init()
        self.hotkeys = Keybinder
        Keybindings(self)
        self.load_config()

        if self.settings.general.get_boolean('start-fullscreen'):
            self.fullscreen()

        refresh_user_start(self.settings)

        # Restore tabs when startup
        if self.settings.general.get_boolean('restore-tabs-startup'):
            self.restore_tabs(suppress_notify=True)

        # Pop-up that shows that guake is working properly (if not
        # unset in the preferences windows)
        if self.settings.general.get_boolean('use-popup'):
            key = self.settings.keybindingsGlobal.get_string('show-hide')
            keyval, mask = Gtk.accelerator_parse(key)
            label = Gtk.accelerator_get_label(keyval, mask)
            filename = pixmapfile('guake-notification.png')
            notifier.showMessage(
                _("Guake Terminal"),
                _("Guake is now running,\n"
                  "press <b>{!s}</b> to use it.").format(xml_escape(label)), filename
            )

        log.info("Guake initialized")
    def __init__(self, fullscreen):
        """Create a new anaconda main window.

          :param bool fullscreen: if True, fullscreen the window, if false maximize
        """
        Gtk.Window.__init__(self)

        # Hide the titlebar when maximized if the window manager allows it.
        # This makes anaconda look full-screenish but without covering parts
        # needed to interact with the window manager, like the GNOME top bar.
        self.set_hide_titlebar_when_maximized(True)

        # The Anaconda and Initial Setup windows might sometimes get decorated with
        # a titlebar which contains the __init__.py header text by default.
        # As all Anaconda and Initial Setup usually have a very distinct title text
        # inside the window, the titlebar text is redundant and should be disabled.
        self.set_title(_(WINDOW_TITLE_TEXT))

        # Set the icon used in the taskbar of window managers that have a taskbar
        # The "anaconda" icon is part of fedora-logos
        self.set_icon_name("anaconda")

        # Treat an attempt to close the window the same as hitting quit
        self.connect("delete-event", self._on_delete_event)

        # Create a black, 50% opacity pixel that will be scaled to fit the lightbox overlay
        # The confusing list of unnamed parameters is:
        # bytes, colorspace (there is no other colorspace), has-alpha,
        # bits-per-sample (has to be 8), width, height,
        # rowstride (bytes between row starts, but we only have one row)
        self._transparent_base = GdkPixbuf.Pixbuf.new_from_bytes(GLib.Bytes.new([0, 0, 0, 127]),
                GdkPixbuf.Colorspace.RGB, True, 8, 1, 1, 1)

        # Contain everything in an overlay so the window can be overlayed with the transparency
        # for the lightbox effect
        self._overlay = Gtk.Overlay()
        self._overlay_img = None
        self._overlay.connect("get-child-position", self._on_overlay_get_child_position)

        self._overlay_depth = 0

        # Create a stack and a list of what's been added to the stack
        # Double the stack transition duration since the default 200ms is too
        # quick to get the point across
        self._stack = Gtk.Stack(transition_duration=400)
        self._stack_contents = set()

        # Create an accel group for the F12 accelerators added after window transitions
        self._accel_group = Gtk.AccelGroup()
        self.add_accel_group(self._accel_group)

        # Make the window big
        if fullscreen:
            self.fullscreen()
        else:
            self.maximize()

        self._overlay.add(self._stack)
        self.add(self._overlay)
        self.show_all()

        self._current_action = None

        # Help button mnemonics handling
        self._mnemonic_signal = None
        # we have a sensible initial value, just in case
        self._saved_help_button_label = _("Help!")

        # Apply the initial language attributes
        self._language = None
        self.reapply_language()

        # Keybinder from GI needs to be initialized before use
        Keybinder.init()
        Keybinder.bind("<Shift>Print", self._handle_print_screen, [])

        self._screenshot_index = 0