Esempio n. 1
0
    def prepare_scene(self):
        """ Called when doing the scene setup. """

        # Settings
        self.settings = Settings("org.semplicelinux.vera.settings")
        self.openboxsettings = Settings("org.semplicelinux.vera.openbox")

        self.scene_container = Gtk.Alignment()
        self.scene_container.set_padding(10, 10, 10, 10)

        self.container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
                                 spacing=5)

        self.stack = Gtk.Stack()
        self.stack.set_homogeneous(False)
        self.stack.set_transition_type(
            Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
        self.stack_switcher = Gtk.StackSwitcher()
        self.stack_switcher.set_halign(Gtk.Align.CENTER)
        self.stack_switcher.set_stack(self.stack)

        self.container.pack_start(self.stack_switcher, False, False, 0)
        self.container.pack_start(self.stack, True, True, 0)

        # Gtk theme page
        self.stack.add_titled(GtkTheme(self.settings, self.openboxsettings),
                              "gtktheme", _("Theme"))
        self.stack.add_titled(Paranoid(self.settings), "paranoid",
                              _("Effects"))
        self.stack.add_titled(Fonts(self.settings, self.openboxsettings),
                              "font", _("Fonts"))

        self.scene_container.add(self.container)
        self.scene_container.show_all()
	def prepare_scene(self):
		"""
		Scene set-up.
		"""
		
		self.scene_container = self.objects.main
		
		self.settings = Settings("org.semplicelinux.vera")
		self.desktop_settings = Settings("org.semplicelinux.vera.desktop")
		
		# Set-up actions combobox
		renderer = Gtk.CellRendererText()
		self.objects.last_exit_action.pack_start(renderer, True)
		self.objects.last_exit_action.add_attribute(renderer, "text", 0)
		self.settings.bind_with_convert(
			"last-exit-action",
			self.objects.last_exit_action,
			"active",
			self.convert_exit_action_from_dconf,
			self.convert_exit_action_from_ui
		)
		
		# Confirmation window
		self.settings.bind(
			"hide-exit-window",
			self.objects.hide_exit_window,
			"active"
		)
		
		# Ninja shortcut
		self.settings.bind(
			"ninja-shortcut",
			self.objects.ninja_shortcut,
			"active"
		)
		
		# Ninja container
		self.objects.ninja_shortcut.bind_property(
			"active",
			self.objects.ninja_container,
			"sensitive"
		)
		
		# Desktop launcher
		self.desktop_settings.bind(
			"show-launcher",
			self.objects.enable_launcher,
			"active"
		)
Esempio n. 3
0
    def __init__(self, gtksettings):
        """
		Initializes the page.
		"""

        super().__init__(orientation=Gtk.Orientation.VERTICAL)

        # Also connect to the compton settings
        comptonsettings = Settings("org.semplicelinux.vera.compton")

        desktop_effects_frame = DesktopEffectsFrame(gtksettings,
                                                    comptonsettings)
        shadow_frame = ShadowFrame(gtksettings, comptonsettings)
        fading_frame = FadingFrame(gtksettings, comptonsettings)
        transparency_frame = TransparencyFrame(gtksettings, comptonsettings)
        advanced_frame = AdvancedFrame(gtksettings, comptonsettings)

        self.pack_start(desktop_effects_frame, False, False, 2)
        self.pack_start(shadow_frame, False, False, 2)
        self.pack_start(fading_frame, False, False, 2)
        self.pack_start(transparency_frame, False, False, 2)
        self.pack_start(advanced_frame, False, False, 2)

        # Bind compton_enable to the sensitiveness of the compton related frames
        for frame in (shadow_frame, fading_frame, transparency_frame,
                      advanced_frame):
            desktop_effects_frame.compton_enabled.bind_property(
                "active", frame, "sensitive", GObject.BindingFlags.SYNC_CREATE)

        self.show_all()
Esempio n. 4
0
    def __init__(self, cancellable):
        """
		Initializes the class.
		"""

        super().__init__()

        self.settings = Settings("org.semplicelinux.vera")

        self.timeout_id = -1

        self.countdown = self.settings.get_int("exit-window-countdown")

        # The dialog may be unexpected, so if the countdown setting is < 10,
        # default to 10 to be on the safe side
        if self.countdown > 0 and self.countdown < 10:
            self.countdown = 10

        self.cancellable = cancellable

        self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, self.cancellable)
        self.Vera = Gio.DBusProxy.new_sync(self.bus, 0, None,
                                           "org.semplicelinux.vera",
                                           "/org/semplicelinux/vera",
                                           "org.semplicelinux.vera",
                                           self.cancellable)

        self.set_title(_("Reboot"))
        self.set_modal(True)

        self.set_markup("<big>%s</big>" % _("Reboot required"))
        self.format_secondary_text(
            _("""In order to apply the changes, a reboot is required.

Please save your work and press "Reboot now" to reboot or press "Cancel" to reboot later."""
              ))

        self.add_buttons(
            _("_Cancel"), Gtk.ResponseType.CANCEL, self.REBOOT_NOW_STRING %
            self.countdown if self.countdown > 0 else _("_Reboot now"),
            Gtk.ResponseType.OK)

        self.set_default_response(Gtk.ResponseType.OK)

        self.connect("show", self.on_dialog_shown)
        self.connect("response", self.on_dialog_response)
	def __init__(self, cancellable):
		"""
		Initializes the class.
		"""
		
		super().__init__()
		
		self.settings = Settings("org.semplicelinux.vera")
		
		self.timeout_id = -1
		
		self.countdown = self.settings.get_int("exit-window-countdown")
		
		# The dialog may be unexpected, so if the countdown setting is < 10,
		# default to 10 to be on the safe side
		if self.countdown > 0 and self.countdown < 10:
			self.countdown = 10
		
		self.cancellable = cancellable

		self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, self.cancellable)
		self.Vera = Gio.DBusProxy.new_sync(
			self.bus,
			0,
			None,
			"org.semplicelinux.vera",
			"/org/semplicelinux/vera",
			"org.semplicelinux.vera",
			self.cancellable
		)
		
		self.set_title(_("Reboot"))
		self.set_modal(True)
		
		self.set_markup("<big>%s</big>" % _("Reboot required"))
		self.format_secondary_text(
			_(
"""In order to apply the changes, a reboot is required.

Please save your work and press "Reboot now" to reboot or press "Cancel" to reboot later."""
			)
		)
		
		self.add_buttons(
			_("_Cancel"),
			Gtk.ResponseType.CANCEL,
			
			self.REBOOT_NOW_STRING % self.countdown
			if self.countdown > 0 else
			_("_Reboot now"),
			Gtk.ResponseType.OK
		)
		
		self.set_default_response(Gtk.ResponseType.OK)
		
		self.connect("show", self.on_dialog_shown)
		self.connect("response", self.on_dialog_response)
Esempio n. 6
0
    def prepare_scene(self):
        """
		Scene set-up.
		"""

        self.scene_container = self.objects.main

        self.settings = Settings("org.semplicelinux.vera")
        self.desktop_settings = Settings("org.semplicelinux.vera.desktop")

        # Set-up actions combobox
        renderer = Gtk.CellRendererText()
        self.objects.last_exit_action.pack_start(renderer, True)
        self.objects.last_exit_action.add_attribute(renderer, "text", 0)
        self.settings.bind_with_convert("last-exit-action",
                                        self.objects.last_exit_action,
                                        "active",
                                        self.convert_exit_action_from_dconf,
                                        self.convert_exit_action_from_ui)

        # Confirmation window
        self.settings.bind("hide-exit-window", self.objects.hide_exit_window,
                           "active")

        # Ninja shortcut
        self.settings.bind("ninja-shortcut", self.objects.ninja_shortcut,
                           "active")

        # Ninja container
        self.objects.ninja_shortcut.bind_property("active",
                                                  self.objects.ninja_container,
                                                  "sensitive")

        # Desktop launcher
        self.desktop_settings.bind("show-launcher",
                                   self.objects.enable_launcher, "active")
Esempio n. 7
0
class Scene(quickstart.scenes.BaseScene):
    """
	Shortcuts preferences.
	"""

    events = {"toggled": ("enable_launcher", )}

    def convert_exit_action_from_dconf(self, value):
        """
		Converts the exit action from dconf.
		"""

        value = self.settings.get_enum("last-exit-action")

        if not self.settings.get_boolean("lock-last-exit-action"):
            # Not locked, this is the "Last action" item
            return 0
        else:
            return value

    def convert_exit_action_from_ui(self, value):
        """
		Converts the exit action from the UI.
		"""

        if value == 0:
            # Not locked, unset lock-last-exit-action
            self.settings.set_boolean("lock-last-exit-action", False)
            return self.settings.get_string("last-exit-action")
        else:
            self.settings.set_boolean("lock-last-exit-action", True)
            return ALLOWED_ACTIONS[value - 1]

    def on_enable_launcher_toggled(self, checkbutton):
        """
		Fired when the "Enable launcher" checkbutton has been toggled.
		"""

        self.objects.enable_launcher_notice.set_visible(
            not self.objects.enable_launcher_notice.get_visible())

    def prepare_scene(self):
        """
		Scene set-up.
		"""

        self.scene_container = self.objects.main

        self.settings = Settings("org.semplicelinux.vera")
        self.desktop_settings = Settings("org.semplicelinux.vera.desktop")

        # Set-up actions combobox
        renderer = Gtk.CellRendererText()
        self.objects.last_exit_action.pack_start(renderer, True)
        self.objects.last_exit_action.add_attribute(renderer, "text", 0)
        self.settings.bind_with_convert("last-exit-action",
                                        self.objects.last_exit_action,
                                        "active",
                                        self.convert_exit_action_from_dconf,
                                        self.convert_exit_action_from_ui)

        # Confirmation window
        self.settings.bind("hide-exit-window", self.objects.hide_exit_window,
                           "active")

        # Ninja shortcut
        self.settings.bind("ninja-shortcut", self.objects.ninja_shortcut,
                           "active")

        # Ninja container
        self.objects.ninja_shortcut.bind_property("active",
                                                  self.objects.ninja_container,
                                                  "sensitive")

        # Desktop launcher
        self.desktop_settings.bind("show-launcher",
                                   self.objects.enable_launcher, "active")
class Scene(quickstart.scenes.BaseScene):
    """ Desktop preferences. """

    events = {
        "item-activated": ("wallpapers", ),
        "response": ("add_background_window", "about_background_dialog"),
        "update_preview": ("add_background_window", ),
        "toggled": ("select_entire_directories", ),
        "clicked": ("add_background", "remove_background", "about_button"),
    }

    wallpapers = {}

    infos = configparser.ConfigParser()

    properties = Properties()

    def new_rgba_from_string(self, string):
        """
		Given a string, return a parsed Gdk.RGBA.
		"""

        rgba = Gdk.RGBA()
        rgba.parse(string)

        return rgba

    def get_selection(self):
        """
		Returns the TreeIter of the current selection.
		"""

        item = self.objects.wallpapers.get_selected_items()[0]

        return self.objects.wallpaper_list.get_iter(item)

    def set_selection(self, path):
        """
		Sets the selected wallpaper given its path (not TreePath, the path
		of the wallpaper).
		"""

        if path in self.wallpapers:
            self.objects.wallpapers.select_path(
                self.objects.wallpaper_list.get_path(self.wallpapers[path]))

            # Show/Hide the About button
            if os.path.basename(
                    self.objects.wallpaper_list.get_value(
                        self.get_selection(), 0)) in self.infos:
                GObject.idle_add(self.objects.about_button.show)
            else:
                GObject.idle_add(self.objects.about_button.hide)
        else:
            # The wallpaper is not in our list, so we need to add it now...
            if os.path.exists(path):
                self.add_wallpaper_to_list(path)
                return self.set_selection(path)  # Restart

    def on_select_entire_directories_toggled(self, checkbutton):
        """
		Fired when the user presses the "Select entire directories"
		CheckButton in the FileChooser.
		"""

        self.objects.add_background_window.set_action(
            Gtk.FileChooserAction.OPEN if not checkbutton.get_active() else Gtk
            .FileChooserAction.SELECT_FOLDER)

    def on_add_background_window_update_preview(self, window):
        """
		Fired when the preview of the window should be updated.
		"""

        filename = window.get_preview_filename()
        if not os.path.isfile(filename):
            window.set_preview_widget_active(False)
            return
        else:
            window.set_preview_widget_active(True)

        try:
            pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
                window.get_preview_filename(), 150, 200, True)
            self.objects.preview.set_from_pixbuf(pixbuf)
        except:
            window.set_preview_widget_active(False)

    def on_add_background_window_response(self, window, response_id):
        """
		Fired when the user presses an action button in the FileChooser
		shown when adding a new wallpaper/directory.
		"""

        if response_id == Gtk.ResponseType.ACCEPT:
            # Add background
            _queue_repopulation = False
            for wall in window.get_filenames():
                if window.get_action() == Gtk.FileChooserAction.OPEN:
                    # Single files, no directories, so append to "include"

                    if wall in self.wallpapers:
                        # Already there!
                        continue

                    include = self.settings.get_strv("background-include")
                    exclude = self.settings.get_strv("background-exclude")

                    if wall in exclude:
                        # Already excluded, so we can simply remove it
                        # from the list
                        exclude.remove(wall)
                    elif wall not in include:
                        # Not excluded, append to the include list
                        include.append(wall)

                    self.add_wallpaper_to_list(wall)

                    self.settings.set_strv("background-include", include)
                    self.settings.set_strv("background-exclude", exclude)
                else:
                    # Entire directories, append them to the search path

                    background_search_paths = self.settings.get_strv(
                        "background-search-paths")

                    if wall in background_search_paths:
                        # Already there!
                        continue

                    background_search_paths.append(wall)

                    self.settings.set_strv("background-search-paths",
                                           background_search_paths)

                    # Queue
                    _queue_repopulation = True

            if _queue_repopulation:
                # Repopulate
                self.populate_wallpapers()

        window.hide()

    def on_about_background_dialog_response(self, window, response_id):
        """
		Fired when the user closes the about background dialog.
		"""

        window.hide()

    def on_about_button_clicked(self, button):
        """
		Fired when the about button has been clicked.
		"""

        # Populate
        itr = self.get_selection()
        wall = os.path.basename(self.objects.wallpaper_list.get_value(itr, 0))

        self.objects.name.set_label(self.infos[wall]["Name"] if "Name" in
                                    self.infos[wall] else "")
        self.objects.description.set_label(
            self.infos[wall]["Description"] if "Description" in
            self.infos[wall] else "")
        self.objects.author.set_label(self.infos[wall]["Author"] if "Author" in
                                      self.infos[wall] else "")
        self.objects.license.set_label(self.infos[wall]["License"] if "License"
                                       in self.infos[wall] else "")

        if "LicenseLink" in self.infos[wall]:
            self.objects.license.set_sensitive(True)
            self.objects.license.set_uri(self.infos[wall]["LicenseLink"])
        else:
            self.objects.license.set_sensitive(False)
            self.objects.license.set_uri("")

        if "Link" in self.infos[wall]:
            self.objects.name.set_sensitive(True)
            self.objects.name.set_uri(self.infos[wall]["Link"])
        else:
            self.objects.name.set_sensitive(False)
            self.objects.name.set_uri("")

        self.objects.about_background_dialog.run()

    def on_add_background_clicked(self, button):
        """
		Fired when the add background button has been clicked.
		"""

        self.objects.add_background_window.run()

    def on_remove_background_clicked(self, button):
        """
		Fired when the remove background button has been clicked.
		"""

        itr = self.get_selection()
        wall = self.objects.wallpaper_list.get_value(itr, 0)

        # If wallpaper is in background-include, remove from there.
        # Otherwise, add an exclusion rule
        include = self.settings.get_strv("background-include")
        if wall in include:
            include.remove(wall)
            self.settings.set_strv("background-include", include)
        else:
            exclude = self.settings.get_strv("background-exclude")
            exclude.append(wall)
            self.settings.set_strv("background-exclude", exclude)

        new = self.objects.wallpaper_list.iter_next(itr)
        if not new:
            # Unable to set next (probably this was the last iter), so
            # use the previous
            new = self.objects.wallpaper_list.iter_previous(itr)

            # If new == None (again), probably this was the only one wallpaper.
            # We can't do anything, so we'll leave an inconsistent state

        if new:
            path = self.objects.wallpaper_list.get_path(new)
            self.objects.wallpapers.select_path(path)
            self.objects.wallpapers.emit("item_activated", path)

        self.objects.wallpaper_list.remove(itr)
        del self.wallpapers[wall]

    def on_wallpapers_item_activated(self, widget, path):
        """
		Fired when the user changes the wallpaper.
		"""

        itr = self.objects.wallpaper_list.get_iter(path)
        wall = self.objects.wallpaper_list.get_value(itr, 0)
        # Show/Hide the About button
        if os.path.basename(wall) in self.infos:
            GObject.idle_add(self.objects.about_button.show)
        else:
            GObject.idle_add(self.objects.about_button.hide)

        current_wallpapers = self.properties.current_wallpapers
        if self.properties.current_selected_monitor == 0:
            # "All monitors", change only the first item in the array
            current_wallpapers[0] = wall
        else:
            # Single monitor, change the relevant item
            current_wallpapers[self.properties.current_selected_monitor -
                               1] = wall

        self.properties.set_property("current-wallpapers", current_wallpapers)

    def add_wallpaper_to_list(self, path, set=False):
        """
		Appends the given wallpaper to the list.
		"""

        if Gio.File.new_for_path(path).query_info(
                Gio.FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
                Gio.FileQueryInfoFlags.NONE).get_content_type(
                ) in SUPPORTED_MIMETYPES:
            try:
                itr = self.objects.wallpaper_list.append(
                    (path,
                     GdkPixbuf.Pixbuf.new_from_file_at_scale(
                         path, 150, 200, True)))

                self.wallpapers[path] = itr

                if set:
                    self.set_selection(path)
            except:
                pass

    def load_wallpaperpack(self, path):
        """
		Loads the given wallpaperpack.
		"""

        try:
            self.infos.read(path)
        except:
            # FIXME: Implement true logging
            print("Unable to load wallpaperpack %s" % path)

    @quickstart.threads.thread
    def populate_wallpapers(self):
        """
		Populates the wallpaper_list.
		"""

        # Clear things up
        self.wallpapers = {}
        self.objects.wallpaper_list.clear()

        excluded = self.settings.get_strv("background-exclude")
        include = self.settings.get_strv("background-include")

        default = self.settings.get_strv("image-path")[0]

        for directory in self.settings.get_strv("background-search-paths"):
            for root, dirs, files in os.walk(directory):
                for wall in files:
                    path = os.path.join(root, wall)
                    if not os.path.exists(path) or path in excluded: continue

                    # .wallpaperpack file?
                    if wall.endswith(".wallpaperpack"):
                        # Load it
                        self.load_wallpaperpack(path)

                    GObject.idle_add(self.add_wallpaper_to_list, path,
                                     (path == default))

        # Add to the Included wallpapers
        for wallpaper in include:
            if not os.path.exists(wallpaper):
                continue

            GObject.idle_add(self.add_wallpaper_to_list, wallpaper,
                             (path == default))

        #GObject.idle_add(self.set_selection, self.settings.get_strv("image-path")[0])
        GObject.idle_add(self.objects.wallpapers.set_sensitive, True)

    def on_current_selected_monitor_changed(self, properties, param):
        """
		Fired when the current-selected-monitor property in Properties has been changed.
		"""

        if self.properties.current_selected_monitor == 0:
            # All monitors, use the first wallpaper everywhere
            self.properties.set_property(
                "current-wallpapers",
                [(self.properties.current_wallpapers[x] if x == 0 else "")
                 for x in range(0, self.monitor_number)])
            self.set_selection(self.properties.current_wallpapers[0])
        else:
            # Single monitor, simply re-set selection
            self.set_selection(self.properties.current_wallpapers[
                self.properties.current_selected_monitor -
                1] if self.properties.current_wallpapers[
                    self.properties.current_selected_monitor -
                    1] != "" else self.properties.current_wallpapers[0])

    def prepare_scene(self):
        """ Called when doing the scene setup. """

        self.scene_container = self.objects.main

        self.objects.wallpapers.set_pixbuf_column(1)

        self.settings = Settings("org.semplicelinux.vera.desktop")
        self.openbox_settings = Settings("org.semplicelinux.vera.openbox")

        # Build monitor list
        self.monitor_number = Gdk.Screen.get_default().get_n_monitors()

        # Build monitor chooser
        self.monitor_model = Gtk.ListStore(str)
        self.objects.monitor_chooser.set_model(self.monitor_model)
        renderer = Gtk.CellRendererText()
        self.objects.monitor_chooser.pack_start(renderer, True)
        self.objects.monitor_chooser.add_attribute(renderer, "text", 0)

        # Current wallpaper
        self.settings.bind_with_convert(
            "image-path", self.properties, "current-wallpapers",
            lambda x: [(x[y] if y < len(x) else "")
                       for y in range(0, self.monitor_number)], lambda x: x)

        # Populate monitor model
        self.monitor_model.insert_with_valuesv(
            -1, [0], [_("All monitors")])  # "All monitors"
        for monitor in range(1, self.monitor_number + 1):
            self.monitor_model.insert_with_valuesv(
                -1, [0], [_("Monitor %d") % (monitor)])
        self.objects.monitor_chooser.set_active(0)
        self.objects.monitor_chooser.bind_property(
            "active", self.properties, "current-selected-monitor",
            GObject.BindingFlags.SYNC_CREATE)
        self.properties.connect("notify::current-selected-monitor",
                                self.on_current_selected_monitor_changed)

        if self.properties.current_wallpapers.count(
                "") == self.monitor_number - 1:
            # Probably we are in an "All monitors" situation
            # We do not use set_active() to avoid trigger an useless write action
            # to dconf.
            self.set_selection(self.properties.current_wallpapers[0])
        else:
            # Single monitor, default to Monitor 1
            self.objects.monitor_chooser.set_active(1)

        # Show it if we should
        if self.monitor_number > 1: self.objects.monitor_chooser.show()

        # Background color
        self.settings.bind_with_convert("background-color",
                                        self.objects.background_color, "rgba",
                                        lambda x: self.new_rgba_from_string(x),
                                        lambda x: x.to_string())

        # Background mode
        renderer = Gtk.CellRendererText()
        self.objects.background_mode.pack_start(renderer, True)
        self.objects.background_mode.add_attribute(renderer, "text", 1)
        self.settings.bind("background-mode", self.objects.background_mode,
                           "active_id")

        # Background random enabled?
        self.settings.bind("background-random-enabled",
                           self.objects.background_random_enabled, "active")

        # Background random timeout
        self.settings.bind("background-random-timeout",
                           self.objects.background_random_timeout, "value")

        # Ensure the random timeout spinbutton is insensitive if
        # the checkbutton is not active
        self.objects.background_random_enabled.bind_property(
            "active", self.objects.background_random_timeout_spin, "sensitive",
            GObject.BindingFlags.SYNC_CREATE)

        # Virtual desktops
        self.openbox_settings.bind("desktops-number",
                                   self.objects.virtual_desktops_spin, "value")

        # Prepare the "Add background" dialog...
        self.objects.add_background_window.add_buttons(_("_Cancel"),
                                                       Gtk.ResponseType.CANCEL,
                                                       _("_Open"),
                                                       Gtk.ResponseType.ACCEPT)
        self.objects.all_files.set_name(_("All Files"))
        self.objects.image_filter.set_name(_("Images"))
        self.objects.add_background_window.add_filter(
            self.objects.image_filter)
        self.objects.add_background_window.add_filter(self.objects.all_files)

        # Prepare the "About background" dialog...
        self.objects.about_background_dialog.add_buttons(
            _("_Close"), Gtk.ResponseType.CLOSE)

        self.objects.main.show_all()

        # Ensure the user doesn't change wallpaper while we are builing the list
        GObject.idle_add(self.objects.wallpapers.set_sensitive, False)

        self.populate_wallpapers()
    def prepare_scene(self):
        """ Called when doing the scene setup. """

        self.scene_container = self.objects.main

        self.objects.wallpapers.set_pixbuf_column(1)

        self.settings = Settings("org.semplicelinux.vera.desktop")
        self.openbox_settings = Settings("org.semplicelinux.vera.openbox")

        # Build monitor list
        self.monitor_number = Gdk.Screen.get_default().get_n_monitors()

        # Build monitor chooser
        self.monitor_model = Gtk.ListStore(str)
        self.objects.monitor_chooser.set_model(self.monitor_model)
        renderer = Gtk.CellRendererText()
        self.objects.monitor_chooser.pack_start(renderer, True)
        self.objects.monitor_chooser.add_attribute(renderer, "text", 0)

        # Current wallpaper
        self.settings.bind_with_convert(
            "image-path", self.properties, "current-wallpapers",
            lambda x: [(x[y] if y < len(x) else "")
                       for y in range(0, self.monitor_number)], lambda x: x)

        # Populate monitor model
        self.monitor_model.insert_with_valuesv(
            -1, [0], [_("All monitors")])  # "All monitors"
        for monitor in range(1, self.monitor_number + 1):
            self.monitor_model.insert_with_valuesv(
                -1, [0], [_("Monitor %d") % (monitor)])
        self.objects.monitor_chooser.set_active(0)
        self.objects.monitor_chooser.bind_property(
            "active", self.properties, "current-selected-monitor",
            GObject.BindingFlags.SYNC_CREATE)
        self.properties.connect("notify::current-selected-monitor",
                                self.on_current_selected_monitor_changed)

        if self.properties.current_wallpapers.count(
                "") == self.monitor_number - 1:
            # Probably we are in an "All monitors" situation
            # We do not use set_active() to avoid trigger an useless write action
            # to dconf.
            self.set_selection(self.properties.current_wallpapers[0])
        else:
            # Single monitor, default to Monitor 1
            self.objects.monitor_chooser.set_active(1)

        # Show it if we should
        if self.monitor_number > 1: self.objects.monitor_chooser.show()

        # Background color
        self.settings.bind_with_convert("background-color",
                                        self.objects.background_color, "rgba",
                                        lambda x: self.new_rgba_from_string(x),
                                        lambda x: x.to_string())

        # Background mode
        renderer = Gtk.CellRendererText()
        self.objects.background_mode.pack_start(renderer, True)
        self.objects.background_mode.add_attribute(renderer, "text", 1)
        self.settings.bind("background-mode", self.objects.background_mode,
                           "active_id")

        # Background random enabled?
        self.settings.bind("background-random-enabled",
                           self.objects.background_random_enabled, "active")

        # Background random timeout
        self.settings.bind("background-random-timeout",
                           self.objects.background_random_timeout, "value")

        # Ensure the random timeout spinbutton is insensitive if
        # the checkbutton is not active
        self.objects.background_random_enabled.bind_property(
            "active", self.objects.background_random_timeout_spin, "sensitive",
            GObject.BindingFlags.SYNC_CREATE)

        # Virtual desktops
        self.openbox_settings.bind("desktops-number",
                                   self.objects.virtual_desktops_spin, "value")

        # Prepare the "Add background" dialog...
        self.objects.add_background_window.add_buttons(_("_Cancel"),
                                                       Gtk.ResponseType.CANCEL,
                                                       _("_Open"),
                                                       Gtk.ResponseType.ACCEPT)
        self.objects.all_files.set_name(_("All Files"))
        self.objects.image_filter.set_name(_("Images"))
        self.objects.add_background_window.add_filter(
            self.objects.image_filter)
        self.objects.add_background_window.add_filter(self.objects.all_files)

        # Prepare the "About background" dialog...
        self.objects.about_background_dialog.add_buttons(
            _("_Close"), Gtk.ResponseType.CLOSE)

        self.objects.main.show_all()

        # Ensure the user doesn't change wallpaper while we are builing the list
        GObject.idle_add(self.objects.wallpapers.set_sensitive, False)

        self.populate_wallpapers()
Esempio n. 10
0
class Scene(quickstart.scenes.BaseScene):
	""" Desktop preferences. """
	
	events = {
		"item-activated": ("wallpapers",),
		"response": ("add_background_window", "about_background_dialog"),
		"update_preview" : ("add_background_window",),
		"toggled": ("select_entire_directories",),
		"clicked": (
			"add_background",
			"remove_background",
			"about_button"
		),
	}

	wallpapers = {}
	
	infos = configparser.ConfigParser()
	
	properties = Properties()
		
	def new_rgba_from_string(self, string):
		"""
		Given a string, return a parsed Gdk.RGBA.
		"""

		rgba = Gdk.RGBA()
		rgba.parse(string)
		
		return rgba

	def get_selection(self):
		"""
		Returns the TreeIter of the current selection.
		"""
		
		item = self.objects.wallpapers.get_selected_items()[0]
		
		return self.objects.wallpaper_list.get_iter(item)

	def set_selection(self, path):
		"""
		Sets the selected wallpaper given its path (not TreePath, the path
		of the wallpaper).
		"""
		
		if path in self.wallpapers:
			self.objects.wallpapers.select_path(self.objects.wallpaper_list.get_path(self.wallpapers[path]))

			# Show/Hide the About button
			if os.path.basename(self.objects.wallpaper_list.get_value(self.get_selection(), 0)) in self.infos:
				GObject.idle_add(self.objects.about_button.show)
			else:
				GObject.idle_add(self.objects.about_button.hide)
		else:
			# The wallpaper is not in our list, so we need to add it now...
			if os.path.exists(path):
				self.add_wallpaper_to_list(path)
				return self.set_selection(path) # Restart
	
	def on_select_entire_directories_toggled(self, checkbutton):
		"""
		Fired when the user presses the "Select entire directories"
		CheckButton in the FileChooser.
		"""
		
		self.objects.add_background_window.set_action(
			Gtk.FileChooserAction.OPEN if not checkbutton.get_active() else Gtk.FileChooserAction.SELECT_FOLDER
		)
	
	def on_add_background_window_update_preview(self, window):
		"""
		Fired when the preview of the window should be updated.
		"""
		
		filename = window.get_preview_filename()
		if not os.path.isfile(filename):
			window.set_preview_widget_active(False)
			return
		else:
			window.set_preview_widget_active(True)
		
		try:
			pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
				window.get_preview_filename(),
				150,
				200,
				True
			)
			self.objects.preview.set_from_pixbuf(pixbuf)
		except:
			window.set_preview_widget_active(False)
	
	def on_add_background_window_response(self, window, response_id):
		"""
		Fired when the user presses an action button in the FileChooser
		shown when adding a new wallpaper/directory.
		"""
		
		if response_id == Gtk.ResponseType.ACCEPT:
			# Add background
			_queue_repopulation = False
			for wall in window.get_filenames():
				if window.get_action() == Gtk.FileChooserAction.OPEN:
					# Single files, no directories, so append to "include"
					
					if wall in self.wallpapers:
						# Already there!
						continue
					
					include = self.settings.get_strv("background-include")
					exclude = self.settings.get_strv("background-exclude")
					
					if wall in exclude:
						# Already excluded, so we can simply remove it
						# from the list
						exclude.remove(wall)
					elif wall not in include:
						# Not excluded, append to the include list
						include.append(wall)
					
					self.add_wallpaper_to_list(wall)

					self.settings.set_strv("background-include", include)
					self.settings.set_strv("background-exclude", exclude)
				else:
					# Entire directories, append them to the search path
					
					background_search_paths = self.settings.get_strv("background-search-paths")
					
					if wall in background_search_paths:
						# Already there!
						continue
					
					background_search_paths.append(wall)
					
					self.settings.set_strv("background-search-paths", background_search_paths)
					
					# Queue
					_queue_repopulation = True
			
			if _queue_repopulation:
				# Repopulate
				self.populate_wallpapers()
		
		window.hide()
	
	def on_about_background_dialog_response(self, window, response_id):
		"""
		Fired when the user closes the about background dialog.
		"""
		
		window.hide()
	
	def on_about_button_clicked(self, button):
		"""
		Fired when the about button has been clicked.
		"""
		
		# Populate
		itr = self.get_selection()
		wall = os.path.basename(self.objects.wallpaper_list.get_value(itr, 0))
		
		self.objects.name.set_label(
			self.infos[wall]["Name"] if "Name" in self.infos[wall] else ""
		)
		self.objects.description.set_label(
			self.infos[wall]["Description"] if "Description" in self.infos[wall] else ""
		)
		self.objects.author.set_label(
			self.infos[wall]["Author"] if "Author" in self.infos[wall] else ""
		)
		self.objects.license.set_label(
			self.infos[wall]["License"] if "License" in self.infos[wall] else ""
		)
		
		if "LicenseLink" in self.infos[wall]:
			self.objects.license.set_sensitive(True)
			self.objects.license.set_uri(self.infos[wall]["LicenseLink"])
		else:
			self.objects.license.set_sensitive(False)
			self.objects.license.set_uri("")
		
		if "Link" in self.infos[wall]:
			self.objects.name.set_sensitive(True)
			self.objects.name.set_uri(self.infos[wall]["Link"])
		else:
			self.objects.name.set_sensitive(False)
			self.objects.name.set_uri("")
		
		self.objects.about_background_dialog.run()
	
	def on_add_background_clicked(self, button):
		"""
		Fired when the add background button has been clicked.
		"""
		
		self.objects.add_background_window.run()

	def on_remove_background_clicked(self, button):
		"""
		Fired when the remove background button has been clicked.
		"""
		
		itr = self.get_selection()
		wall = self.objects.wallpaper_list.get_value(itr, 0)
		
		# If wallpaper is in background-include, remove from there.
		# Otherwise, add an exclusion rule
		include = self.settings.get_strv("background-include")
		if wall in include:
			include.remove(wall)
			self.settings.set_strv("background-include", include)
		else:
			exclude = self.settings.get_strv("background-exclude")
			exclude.append(wall)
			self.settings.set_strv("background-exclude", exclude)
		
		new = self.objects.wallpaper_list.iter_next(itr)
		if not new:
			# Unable to set next (probably this was the last iter), so
			# use the previous
			new =  self.objects.wallpaper_list.iter_previous(itr)
			
			# If new == None (again), probably this was the only one wallpaper.
			# We can't do anything, so we'll leave an inconsistent state
		
		if new:
			path = self.objects.wallpaper_list.get_path(new)
			self.objects.wallpapers.select_path(path)
			self.objects.wallpapers.emit("item_activated", path)
		
		self.objects.wallpaper_list.remove(itr)
		del self.wallpapers[wall]
	
	def on_wallpapers_item_activated(self, widget, path):
		"""
		Fired when the user changes the wallpaper.
		"""
				
		itr = self.objects.wallpaper_list.get_iter(path)
		wall = self.objects.wallpaper_list.get_value(itr, 0)
		# Show/Hide the About button
		if os.path.basename(wall) in self.infos:
			GObject.idle_add(self.objects.about_button.show)
		else:
			GObject.idle_add(self.objects.about_button.hide)
		
		current_wallpapers = self.properties.current_wallpapers
		if self.properties.current_selected_monitor == 0:
			# "All monitors", change only the first item in the array
			current_wallpapers[0] = wall
		else:
			# Single monitor, change the relevant item
			current_wallpapers[self.properties.current_selected_monitor-1] = wall
		
		self.properties.set_property("current-wallpapers", current_wallpapers)

	def add_wallpaper_to_list(self, path, set=False):
		"""
		Appends the given wallpaper to the list.
		"""
		
		if Gio.File.new_for_path(path).query_info(
			Gio.FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
			Gio.FileQueryInfoFlags.NONE
		).get_content_type() in SUPPORTED_MIMETYPES:
			try:
				itr = self.objects.wallpaper_list.append(
					(
						path,
						GdkPixbuf.Pixbuf.new_from_file_at_scale(
							path,
							150,
							200,
							True
						)
					)
				)
				
				self.wallpapers[path] = itr
				
				if set:
					self.set_selection(path)
			except:
				pass
	
	def load_wallpaperpack(self, path):
		"""
		Loads the given wallpaperpack.
		"""
		
		try:
			self.infos.read(path)
		except:
			# FIXME: Implement true logging
			print("Unable to load wallpaperpack %s" % path)
	
	@quickstart.threads.thread
	def populate_wallpapers(self):
		"""
		Populates the wallpaper_list.
		"""
		
		# Clear things up
		self.wallpapers = {}
		self.objects.wallpaper_list.clear()
		
		excluded = self.settings.get_strv("background-exclude")
		include = self.settings.get_strv("background-include")
		
		default = self.settings.get_strv("image-path")[0]
		
		for directory in self.settings.get_strv("background-search-paths"):
			for root, dirs, files in os.walk(directory):
				for wall in files:
					path = os.path.join(root, wall)
					if not os.path.exists(path) or path in excluded: continue
					
					# .wallpaperpack file?
					if wall.endswith(".wallpaperpack"):
						# Load it
						self.load_wallpaperpack(path)
					
					GObject.idle_add(self.add_wallpaper_to_list, path, (path == default))
		
		# Add to the Included wallpapers
		for wallpaper in include:
			if not os.path.exists(wallpaper):
				continue

			GObject.idle_add(self.add_wallpaper_to_list, wallpaper, (path == default))
		
		#GObject.idle_add(self.set_selection, self.settings.get_strv("image-path")[0])
		GObject.idle_add(self.objects.wallpapers.set_sensitive, True)
	
	def on_current_selected_monitor_changed(self, properties, param):
		"""
		Fired when the current-selected-monitor property in Properties has been changed.
		"""
		
		if self.properties.current_selected_monitor == 0:
			# All monitors, use the first wallpaper everywhere
			self.properties.set_property(
				"current-wallpapers",
				[(self.properties.current_wallpapers[x] if x == 0 else "") for x in range(0, self.monitor_number)]
			)
			self.set_selection(self.properties.current_wallpapers[0])
		else:
			# Single monitor, simply re-set selection
			self.set_selection(
				self.properties.current_wallpapers[self.properties.current_selected_monitor-1] if self.properties.current_wallpapers[
					self.properties.current_selected_monitor-1] != "" else self.properties.current_wallpapers[0]
			)
			
	def prepare_scene(self):
		""" Called when doing the scene setup. """
		
		self.scene_container = self.objects.main
		
		self.objects.wallpapers.set_pixbuf_column(1)
		
		self.settings = Settings("org.semplicelinux.vera.desktop")
		self.openbox_settings = Settings("org.semplicelinux.vera.openbox")
		
		# Build monitor list
		self.monitor_number = Gdk.Screen.get_default().get_n_monitors()
		
		# Build monitor chooser
		self.monitor_model = Gtk.ListStore(str)
		self.objects.monitor_chooser.set_model(self.monitor_model)
		renderer = Gtk.CellRendererText()
		self.objects.monitor_chooser.pack_start(renderer, True)
		self.objects.monitor_chooser.add_attribute(renderer, "text", 0)

		# Current wallpaper		
		self.settings.bind_with_convert(
			"image-path",
			self.properties,
			"current-wallpapers",
			lambda x: [(x[y] if y < len(x) else "") for y in range(0, self.monitor_number)],
			lambda x: x
		)

		# Populate monitor model
		self.monitor_model.insert_with_valuesv(-1, [0], [_("All monitors")]) # "All monitors"
		for monitor in range(1, self.monitor_number+1):
			self.monitor_model.insert_with_valuesv(-1, [0], [_("Monitor %d") % (monitor)])
		self.objects.monitor_chooser.set_active(0)
		self.objects.monitor_chooser.bind_property(
			"active",
			self.properties,
			"current-selected-monitor",
			GObject.BindingFlags.SYNC_CREATE
		)
		self.properties.connect("notify::current-selected-monitor", self.on_current_selected_monitor_changed)
		
		if self.properties.current_wallpapers.count("") == self.monitor_number-1:
			# Probably we are in an "All monitors" situation
			# We do not use set_active() to avoid trigger an useless write action
			# to dconf.
			self.set_selection(self.properties.current_wallpapers[0])
		else:
			# Single monitor, default to Monitor 1
			self.objects.monitor_chooser.set_active(1)
		
		# Show it if we should
		if self.monitor_number > 1: self.objects.monitor_chooser.show()
		
		# Background color
		self.settings.bind_with_convert(
			"background-color",
			self.objects.background_color,
			"rgba",
			lambda x: self.new_rgba_from_string(x),
			lambda x: x.to_string()
		)
		
		# Background mode
		renderer = Gtk.CellRendererText()
		self.objects.background_mode.pack_start(renderer, True)
		self.objects.background_mode.add_attribute(renderer, "text", 1)
		self.settings.bind(
			"background-mode",
			self.objects.background_mode,
			"active_id"
		)
		
		# Background random enabled?
		self.settings.bind(
			"background-random-enabled",
			self.objects.background_random_enabled,
			"active"
		)
		
		# Background random timeout
		self.settings.bind(
			"background-random-timeout",
			self.objects.background_random_timeout,
			"value"
		)
		
		# Ensure the random timeout spinbutton is insensitive if
		# the checkbutton is not active
		self.objects.background_random_enabled.bind_property(
			"active",
			self.objects.background_random_timeout_spin,
			"sensitive",
			GObject.BindingFlags.SYNC_CREATE
		)
		
		# Virtual desktops
		self.openbox_settings.bind(
			"desktops-number",
			self.objects.virtual_desktops_spin,
			"value"
		)
		
		# Prepare the "Add background" dialog...
		self.objects.add_background_window.add_buttons(
			_("_Cancel"),
			Gtk.ResponseType.CANCEL,
			_("_Open"),
			Gtk.ResponseType.ACCEPT
		)
		self.objects.all_files.set_name(_("All Files"))
		self.objects.image_filter.set_name(_("Images"))
		self.objects.add_background_window.add_filter(self.objects.image_filter)
		self.objects.add_background_window.add_filter(self.objects.all_files)
		
		# Prepare the "About background" dialog...
		self.objects.about_background_dialog.add_buttons(
			_("_Close"),
			Gtk.ResponseType.CLOSE
		)
		
		self.objects.main.show_all()
				
		# Ensure the user doesn't change wallpaper while we are builing the list
		GObject.idle_add(self.objects.wallpapers.set_sensitive, False)
		
		self.populate_wallpapers()
class Scene(quickstart.scenes.BaseScene):
	"""
	Shortcuts preferences.
	"""
	
	events = {
		"toggled" : ("enable_launcher",)
	}
	
	def convert_exit_action_from_dconf(self, value):
		"""
		Converts the exit action from dconf.
		"""
		
		value = self.settings.get_enum("last-exit-action")
		
		if not self.settings.get_boolean("lock-last-exit-action"):
			# Not locked, this is the "Last action" item
			return 0
		else:
			return value
	
	def convert_exit_action_from_ui(self, value):
		"""
		Converts the exit action from the UI.
		"""
				
		if value == 0:
			# Not locked, unset lock-last-exit-action
			self.settings.set_boolean("lock-last-exit-action", False)
			return self.settings.get_string("last-exit-action")
		else:
			self.settings.set_boolean("lock-last-exit-action", True)
			return ALLOWED_ACTIONS[value-1]
	
	def on_enable_launcher_toggled(self, checkbutton):
		"""
		Fired when the "Enable launcher" checkbutton has been toggled.
		"""
		
		self.objects.enable_launcher_notice.set_visible(
			not self.objects.enable_launcher_notice.get_visible()
		)
	
	def prepare_scene(self):
		"""
		Scene set-up.
		"""
		
		self.scene_container = self.objects.main
		
		self.settings = Settings("org.semplicelinux.vera")
		self.desktop_settings = Settings("org.semplicelinux.vera.desktop")
		
		# Set-up actions combobox
		renderer = Gtk.CellRendererText()
		self.objects.last_exit_action.pack_start(renderer, True)
		self.objects.last_exit_action.add_attribute(renderer, "text", 0)
		self.settings.bind_with_convert(
			"last-exit-action",
			self.objects.last_exit_action,
			"active",
			self.convert_exit_action_from_dconf,
			self.convert_exit_action_from_ui
		)
		
		# Confirmation window
		self.settings.bind(
			"hide-exit-window",
			self.objects.hide_exit_window,
			"active"
		)
		
		# Ninja shortcut
		self.settings.bind(
			"ninja-shortcut",
			self.objects.ninja_shortcut,
			"active"
		)
		
		# Ninja container
		self.objects.ninja_shortcut.bind_property(
			"active",
			self.objects.ninja_container,
			"sensitive"
		)
		
		# Desktop launcher
		self.desktop_settings.bind(
			"show-launcher",
			self.objects.enable_launcher,
			"active"
		)
    def __init__(self, settings):
        """
		Initializes the frame.
		"""

        super().__init__(name=_("Widgets"))

        # Settings
        self.settings = settings
        self.desktopsettings = Settings("org.semplicelinux.vera.desktop")

        # Container
        self.main_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        # Combobox
        self.combobox_container = Gtk.Box(
            orientation=Gtk.Orientation.HORIZONTAL)
        self.combobox = Gtk.ComboBoxText()
        self.combobox_label = Gtk.Label(_("Theme"))
        self.combobox_label.set_alignment(0, 0.50)

        self.combobox_container.pack_start(self.combobox_label, True, True, 0)
        self.combobox_container.pack_start(self.combobox, False, False, 0)

        # Populate it and bind
        self.populate_themes()

        # Images in buttons
        self.button_images = Gtk.CheckButton(_("Show images in buttons"))
        self.settings.bind("button-images", self.button_images, "active")

        # Images in menus
        self.menu_images = Gtk.CheckButton(_("Show images in menus"))
        self.settings.bind("menu-images", self.menu_images, "active")

        # Vera color
        self.vera_color_enabled = Gtk.CheckButton(
            _("Use custom color for selected items (when supported)"))
        self.desktopsettings.bind("vera-color-enabled",
                                  self.vera_color_enabled, "active")

        # Vera color selection
        self.vera_color_selection = Gtk.Box(
            orientation=Gtk.Orientation.VERTICAL)
        self.vera_color_selection.set_margin_start(20)
        self.vera_color_enabled.bind_property("active",
                                              self.vera_color_selection,
                                              "sensitive",
                                              GObject.BindingFlags.SYNC_CREATE)
        self.vera_color_from_wallpaper = Gtk.RadioButton.new_with_label_from_widget(
            None, _("Pick color from the current wallpaper"))
        self.vera_color_manual_container = Gtk.Box(
            orientation=Gtk.Orientation.HORIZONTAL)
        self.vera_color_manual_color = Gtk.ColorButton()
        self.desktopsettings.bind_with_convert(
            "vera-color", self.vera_color_manual_color, "rgba",
            lambda x: self.new_rgba_from_string(x), lambda x: x.to_string())
        self.vera_color_manual_color.set_sensitive(True)
        self.vera_color_manual = Gtk.RadioButton.new_with_label_from_widget(
            self.vera_color_from_wallpaper, _("Use this color"))
        self.vera_color_manual.bind_property("active",
                                             self.vera_color_manual_color,
                                             "sensitive",
                                             GObject.BindingFlags.SYNC_CREATE)
        self.desktopsettings.bind("vera-color-lock", self.vera_color_manual,
                                  "active")
        self.vera_color_manual_container.pack_start(self.vera_color_manual,
                                                    True, True, 0)
        self.vera_color_manual_container.pack_start(
            self.vera_color_manual_color, False, False, 0)

        self.vera_color_selection.pack_start(self.vera_color_from_wallpaper,
                                             False, False, 0)
        self.vera_color_selection.pack_start(self.vera_color_manual_container,
                                             False, False, 2)

        self.main_container.pack_start(self.combobox_container, False, False,
                                       0)
        self.main_container.pack_start(self.button_images, False, False, 2)
        self.main_container.pack_start(self.menu_images, False, False, 2)
        self.main_container.pack_start(self.vera_color_enabled, False, False,
                                       2)
        self.main_container.pack_start(self.vera_color_selection, False, False,
                                       2)

        self.get_alignment().add(self.main_container)
Esempio n. 13
0
	def prepare_scene(self):
		""" Called when doing the scene setup. """
		
		self.scene_container = self.objects.main
		
		self.objects.wallpapers.set_pixbuf_column(1)
		
		self.settings = Settings("org.semplicelinux.vera.desktop")
		self.openbox_settings = Settings("org.semplicelinux.vera.openbox")
		
		# Build monitor list
		self.monitor_number = Gdk.Screen.get_default().get_n_monitors()
		
		# Build monitor chooser
		self.monitor_model = Gtk.ListStore(str)
		self.objects.monitor_chooser.set_model(self.monitor_model)
		renderer = Gtk.CellRendererText()
		self.objects.monitor_chooser.pack_start(renderer, True)
		self.objects.monitor_chooser.add_attribute(renderer, "text", 0)

		# Current wallpaper		
		self.settings.bind_with_convert(
			"image-path",
			self.properties,
			"current-wallpapers",
			lambda x: [(x[y] if y < len(x) else "") for y in range(0, self.monitor_number)],
			lambda x: x
		)

		# Populate monitor model
		self.monitor_model.insert_with_valuesv(-1, [0], [_("All monitors")]) # "All monitors"
		for monitor in range(1, self.monitor_number+1):
			self.monitor_model.insert_with_valuesv(-1, [0], [_("Monitor %d") % (monitor)])
		self.objects.monitor_chooser.set_active(0)
		self.objects.monitor_chooser.bind_property(
			"active",
			self.properties,
			"current-selected-monitor",
			GObject.BindingFlags.SYNC_CREATE
		)
		self.properties.connect("notify::current-selected-monitor", self.on_current_selected_monitor_changed)
		
		if self.properties.current_wallpapers.count("") == self.monitor_number-1:
			# Probably we are in an "All monitors" situation
			# We do not use set_active() to avoid trigger an useless write action
			# to dconf.
			self.set_selection(self.properties.current_wallpapers[0])
		else:
			# Single monitor, default to Monitor 1
			self.objects.monitor_chooser.set_active(1)
		
		# Show it if we should
		if self.monitor_number > 1: self.objects.monitor_chooser.show()
		
		# Background color
		self.settings.bind_with_convert(
			"background-color",
			self.objects.background_color,
			"rgba",
			lambda x: self.new_rgba_from_string(x),
			lambda x: x.to_string()
		)
		
		# Background mode
		renderer = Gtk.CellRendererText()
		self.objects.background_mode.pack_start(renderer, True)
		self.objects.background_mode.add_attribute(renderer, "text", 1)
		self.settings.bind(
			"background-mode",
			self.objects.background_mode,
			"active_id"
		)
		
		# Background random enabled?
		self.settings.bind(
			"background-random-enabled",
			self.objects.background_random_enabled,
			"active"
		)
		
		# Background random timeout
		self.settings.bind(
			"background-random-timeout",
			self.objects.background_random_timeout,
			"value"
		)
		
		# Ensure the random timeout spinbutton is insensitive if
		# the checkbutton is not active
		self.objects.background_random_enabled.bind_property(
			"active",
			self.objects.background_random_timeout_spin,
			"sensitive",
			GObject.BindingFlags.SYNC_CREATE
		)
		
		# Virtual desktops
		self.openbox_settings.bind(
			"desktops-number",
			self.objects.virtual_desktops_spin,
			"value"
		)
		
		# Prepare the "Add background" dialog...
		self.objects.add_background_window.add_buttons(
			_("_Cancel"),
			Gtk.ResponseType.CANCEL,
			_("_Open"),
			Gtk.ResponseType.ACCEPT
		)
		self.objects.all_files.set_name(_("All Files"))
		self.objects.image_filter.set_name(_("Images"))
		self.objects.add_background_window.add_filter(self.objects.image_filter)
		self.objects.add_background_window.add_filter(self.objects.all_files)
		
		# Prepare the "About background" dialog...
		self.objects.about_background_dialog.add_buttons(
			_("_Close"),
			Gtk.ResponseType.CLOSE
		)
		
		self.objects.main.show_all()
				
		# Ensure the user doesn't change wallpaper while we are builing the list
		GObject.idle_add(self.objects.wallpapers.set_sensitive, False)
		
		self.populate_wallpapers()
class RebootDialog(Gtk.MessageDialog):
	"""
	A RebootDialog() is a dialog that displays a "Reboot now" request
	to the user.
	"""
	
	REBOOT_NOW_STRING = _("_Reboot now (in %ds)")
	
	def on_dialog_response(self, dialog, response):
		"""
		Fired when the dialog generated a response.
		"""
		
		# Reset the countdown
		self.countdown = self.settings.get_int("exit-window-countdown")
		
		# Stop the timeout
		if self.timeout_id > -1:
			GObject.source_remove(self.timeout_id)
		
		if response == Gtk.ResponseType.OK:
			self.Vera.Reboot()
		
		self.hide()
	
	def process_countdown(self):
		"""
		Processes the countdown.
		"""
				
		self.countdown -= 1
		
		if self.countdown == 0:
			# Assume we're OK
			self.emit("response", Gtk.ResponseType.OK)
			
			return False
		else:
			self.get_widget_for_response(Gtk.ResponseType.OK).set_label(self.REBOOT_NOW_STRING % self.countdown)
			
			return True
	
	def on_dialog_shown(self, dialog):
		"""
		Fired when the dialog has been shown.
		"""
		
		# Start the timeout
		if self.countdown > 0:
			self.timeout_id = GObject.timeout_add_seconds(1, self.process_countdown)
	
	def __init__(self, cancellable):
		"""
		Initializes the class.
		"""
		
		super().__init__()
		
		self.settings = Settings("org.semplicelinux.vera")
		
		self.timeout_id = -1
		
		self.countdown = self.settings.get_int("exit-window-countdown")
		
		# The dialog may be unexpected, so if the countdown setting is < 10,
		# default to 10 to be on the safe side
		if self.countdown > 0 and self.countdown < 10:
			self.countdown = 10
		
		self.cancellable = cancellable

		self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, self.cancellable)
		self.Vera = Gio.DBusProxy.new_sync(
			self.bus,
			0,
			None,
			"org.semplicelinux.vera",
			"/org/semplicelinux/vera",
			"org.semplicelinux.vera",
			self.cancellable
		)
		
		self.set_title(_("Reboot"))
		self.set_modal(True)
		
		self.set_markup("<big>%s</big>" % _("Reboot required"))
		self.format_secondary_text(
			_(
"""In order to apply the changes, a reboot is required.

Please save your work and press "Reboot now" to reboot or press "Cancel" to reboot later."""
			)
		)
		
		self.add_buttons(
			_("_Cancel"),
			Gtk.ResponseType.CANCEL,
			
			self.REBOOT_NOW_STRING % self.countdown
			if self.countdown > 0 else
			_("_Reboot now"),
			Gtk.ResponseType.OK
		)
		
		self.set_default_response(Gtk.ResponseType.OK)
		
		self.connect("show", self.on_dialog_shown)
		self.connect("response", self.on_dialog_response)
from veracc.widgets.ApplicationSelectionDialog import ApplicationSelectionDialog

# Search path for the applications.
#
# /usr/share/vera/autostart is taken out volountairly because it contains
# core applications that the user doesn't want to disable.
# You can still disable those by manually modifying the vera settings via
# e.g. dconf-editor.
SEARCH_PATH = (
	"/etc/xdg/autostart",
	os.path.expanduser("~/.config/autostart")
)

# dconf settings
SETTINGS = Settings("org.semplicelinux.vera")

# Blacklist
BLACKLIST = SETTINGS.get_strv("autostart-ignore")

class ApplicationRow(Gtk.ListBoxRow):
	
	"""
	An ApplicationRow is a modified Gtk.ListBoxRow that shows informations
	about an application to autostart.
	It permits to enable or disable the application via a Switch.
	
	--------------------------------------------------------------------
	|  ICON   Program name                                       ##ON  |
	--------------------------------------------------------------------
	"""
Esempio n. 16
0
	def __init__(self, settings):
		"""
		Initializes the frame.
		"""
		
		super().__init__(name=_("Widgets"))
		
		# Settings
		self.settings = settings
		self.desktopsettings = Settings("org.semplicelinux.vera.desktop")
		
		# Container
		self.main_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
		
		# Combobox
		self.combobox_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
		self.combobox = Gtk.ComboBoxText()
		self.combobox_label = Gtk.Label(_("Theme"))
		self.combobox_label.set_alignment(0, 0.50)
		
		self.combobox_container.pack_start(self.combobox_label, True, True, 0)
		self.combobox_container.pack_start(self.combobox, False, False, 0)
		
		# Populate it and bind
		self.populate_themes()
		
		# Images in buttons
		self.button_images = Gtk.CheckButton(_("Show images in buttons"))
		self.settings.bind(
			"button-images",
			self.button_images,
			"active"
		)
		
		# Images in menus
		self.menu_images = Gtk.CheckButton(_("Show images in menus"))
		self.settings.bind(
			"menu-images",
			self.menu_images,
			"active"
		)
		
		# Vera color
		self.vera_color_enabled = Gtk.CheckButton(_("Use custom color for selected items (when supported)"))
		self.desktopsettings.bind(
			"vera-color-enabled",
			self.vera_color_enabled,
			"active"
		)
		
		# Vera color selection
		self.vera_color_selection = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
		self.vera_color_selection.set_margin_start(20)
		self.vera_color_enabled.bind_property(
			"active",
			self.vera_color_selection,
			"sensitive",
			GObject.BindingFlags.SYNC_CREATE
		)
		self.vera_color_from_wallpaper = Gtk.RadioButton.new_with_label_from_widget(None, _("Pick color from the current wallpaper"))
		self.vera_color_manual_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
		self.vera_color_manual_color = Gtk.ColorButton()
		self.desktopsettings.bind_with_convert(
			"vera-color",
			self.vera_color_manual_color,
			"rgba",
			lambda x: self.new_rgba_from_string(x),
			lambda x: x.to_string()
		)
		self.vera_color_manual_color.set_sensitive(True)
		self.vera_color_manual = Gtk.RadioButton.new_with_label_from_widget(self.vera_color_from_wallpaper, _("Use this color"))
		self.vera_color_manual.bind_property(
			"active",
			self.vera_color_manual_color,
			"sensitive",
			GObject.BindingFlags.SYNC_CREATE
		)
		self.desktopsettings.bind(
			"vera-color-lock",
			self.vera_color_manual,
			"active"
		)
		self.vera_color_manual_container.pack_start(self.vera_color_manual, True, True, 0)
		self.vera_color_manual_container.pack_start(self.vera_color_manual_color, False, False, 0)
		
		self.vera_color_selection.pack_start(self.vera_color_from_wallpaper, False, False, 0)
		self.vera_color_selection.pack_start(self.vera_color_manual_container, False, False, 2)
		
		self.main_container.pack_start(self.combobox_container, False, False, 0)
		self.main_container.pack_start(self.button_images, False, False, 2)
		self.main_container.pack_start(self.menu_images, False, False, 2)
		self.main_container.pack_start(self.vera_color_enabled, False, False, 2)
		self.main_container.pack_start(self.vera_color_selection, False, False, 2)
		
		self.get_alignment().add(self.main_container)
Esempio n. 17
0
class GtkThemeFrame(CommonFrame):
	"""
	This is the Frame with controls to change the GTK+ theme.
	"""

	SEARCH_PATH = ("/usr/share/themes", os.path.expanduser("~/.themes"))

	@property
	def available_themes(self):
		""" Returns the available themes, searching in SEARCH_PATH. """
		
		themes = []
		
		for directory in self.SEARCH_PATH:
			if not os.path.exists(directory):
				continue
			
			for theme in os.listdir(directory):
				
				path = os.path.join(directory, theme)
				
				if theme not in themes and (
					os.path.isdir(path) and os.path.exists(os.path.join(path, "gtk-3.0"))
				):
					themes.append(theme)
		
		themes.sort()
		return themes

	@quickstart.threads.on_idle
	def populate_themes(self):
		""" Populates the theme list. """
		
		self.themes = {}
		
		count = -1
		for theme in self.available_themes:
			count += 1
			
			self.combobox.append_text(theme)
			
			# Add to self.themes
			self.themes[theme] = count
		
		# Bind
		self.settings.bind_with_convert(
			"theme-name",
			self.combobox,
			"active",
			lambda x: self.themes[x] if x in self.themes else -1,
			lambda x: self.combobox.get_active_text()
		)
	
	def new_rgba_from_string(self, string):
		"""
		Given a string, return a parsed Gdk.RGBA.
		"""
		
		rgba = Gdk.RGBA()
		rgba.parse(string)
		
		return rgba
	
	def __init__(self, settings):
		"""
		Initializes the frame.
		"""
		
		super().__init__(name=_("Widgets"))
		
		# Settings
		self.settings = settings
		self.desktopsettings = Settings("org.semplicelinux.vera.desktop")
		
		# Container
		self.main_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
		
		# Combobox
		self.combobox_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
		self.combobox = Gtk.ComboBoxText()
		self.combobox_label = Gtk.Label(_("Theme"))
		self.combobox_label.set_alignment(0, 0.50)
		
		self.combobox_container.pack_start(self.combobox_label, True, True, 0)
		self.combobox_container.pack_start(self.combobox, False, False, 0)
		
		# Populate it and bind
		self.populate_themes()
		
		# Images in buttons
		self.button_images = Gtk.CheckButton(_("Show images in buttons"))
		self.settings.bind(
			"button-images",
			self.button_images,
			"active"
		)
		
		# Images in menus
		self.menu_images = Gtk.CheckButton(_("Show images in menus"))
		self.settings.bind(
			"menu-images",
			self.menu_images,
			"active"
		)
		
		# Vera color
		self.vera_color_enabled = Gtk.CheckButton(_("Use custom color for selected items (when supported)"))
		self.desktopsettings.bind(
			"vera-color-enabled",
			self.vera_color_enabled,
			"active"
		)
		
		# Vera color selection
		self.vera_color_selection = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
		self.vera_color_selection.set_margin_start(20)
		self.vera_color_enabled.bind_property(
			"active",
			self.vera_color_selection,
			"sensitive",
			GObject.BindingFlags.SYNC_CREATE
		)
		self.vera_color_from_wallpaper = Gtk.RadioButton.new_with_label_from_widget(None, _("Pick color from the current wallpaper"))
		self.vera_color_manual_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
		self.vera_color_manual_color = Gtk.ColorButton()
		self.desktopsettings.bind_with_convert(
			"vera-color",
			self.vera_color_manual_color,
			"rgba",
			lambda x: self.new_rgba_from_string(x),
			lambda x: x.to_string()
		)
		self.vera_color_manual_color.set_sensitive(True)
		self.vera_color_manual = Gtk.RadioButton.new_with_label_from_widget(self.vera_color_from_wallpaper, _("Use this color"))
		self.vera_color_manual.bind_property(
			"active",
			self.vera_color_manual_color,
			"sensitive",
			GObject.BindingFlags.SYNC_CREATE
		)
		self.desktopsettings.bind(
			"vera-color-lock",
			self.vera_color_manual,
			"active"
		)
		self.vera_color_manual_container.pack_start(self.vera_color_manual, True, True, 0)
		self.vera_color_manual_container.pack_start(self.vera_color_manual_color, False, False, 0)
		
		self.vera_color_selection.pack_start(self.vera_color_from_wallpaper, False, False, 0)
		self.vera_color_selection.pack_start(self.vera_color_manual_container, False, False, 2)
		
		self.main_container.pack_start(self.combobox_container, False, False, 0)
		self.main_container.pack_start(self.button_images, False, False, 2)
		self.main_container.pack_start(self.menu_images, False, False, 2)
		self.main_container.pack_start(self.vera_color_enabled, False, False, 2)
		self.main_container.pack_start(self.vera_color_selection, False, False, 2)
		
		self.get_alignment().add(self.main_container)
class GtkThemeFrame(CommonFrame):
    """
	This is the Frame with controls to change the GTK+ theme.
	"""

    SEARCH_PATH = ("/usr/share/themes", os.path.expanduser("~/.themes"))

    @property
    def available_themes(self):
        """ Returns the available themes, searching in SEARCH_PATH. """

        themes = []

        for directory in self.SEARCH_PATH:
            if not os.path.exists(directory):
                continue

            for theme in os.listdir(directory):

                path = os.path.join(directory, theme)

                if theme not in themes and (
                        os.path.isdir(path)
                        and os.path.exists(os.path.join(path, "gtk-3.0"))):
                    themes.append(theme)

        themes.sort()
        return themes

    @quickstart.threads.on_idle
    def populate_themes(self):
        """ Populates the theme list. """

        self.themes = {}

        count = -1
        for theme in self.available_themes:
            count += 1

            self.combobox.append_text(theme)

            # Add to self.themes
            self.themes[theme] = count

        # Bind
        self.settings.bind_with_convert(
            "theme-name", self.combobox, "active", lambda x: self.themes[x]
            if x in self.themes else -1,
            lambda x: self.combobox.get_active_text())

    def new_rgba_from_string(self, string):
        """
		Given a string, return a parsed Gdk.RGBA.
		"""

        rgba = Gdk.RGBA()
        rgba.parse(string)

        return rgba

    def __init__(self, settings):
        """
		Initializes the frame.
		"""

        super().__init__(name=_("Widgets"))

        # Settings
        self.settings = settings
        self.desktopsettings = Settings("org.semplicelinux.vera.desktop")

        # Container
        self.main_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        # Combobox
        self.combobox_container = Gtk.Box(
            orientation=Gtk.Orientation.HORIZONTAL)
        self.combobox = Gtk.ComboBoxText()
        self.combobox_label = Gtk.Label(_("Theme"))
        self.combobox_label.set_alignment(0, 0.50)

        self.combobox_container.pack_start(self.combobox_label, True, True, 0)
        self.combobox_container.pack_start(self.combobox, False, False, 0)

        # Populate it and bind
        self.populate_themes()

        # Images in buttons
        self.button_images = Gtk.CheckButton(_("Show images in buttons"))
        self.settings.bind("button-images", self.button_images, "active")

        # Images in menus
        self.menu_images = Gtk.CheckButton(_("Show images in menus"))
        self.settings.bind("menu-images", self.menu_images, "active")

        # Vera color
        self.vera_color_enabled = Gtk.CheckButton(
            _("Use custom color for selected items (when supported)"))
        self.desktopsettings.bind("vera-color-enabled",
                                  self.vera_color_enabled, "active")

        # Vera color selection
        self.vera_color_selection = Gtk.Box(
            orientation=Gtk.Orientation.VERTICAL)
        self.vera_color_selection.set_margin_start(20)
        self.vera_color_enabled.bind_property("active",
                                              self.vera_color_selection,
                                              "sensitive",
                                              GObject.BindingFlags.SYNC_CREATE)
        self.vera_color_from_wallpaper = Gtk.RadioButton.new_with_label_from_widget(
            None, _("Pick color from the current wallpaper"))
        self.vera_color_manual_container = Gtk.Box(
            orientation=Gtk.Orientation.HORIZONTAL)
        self.vera_color_manual_color = Gtk.ColorButton()
        self.desktopsettings.bind_with_convert(
            "vera-color", self.vera_color_manual_color, "rgba",
            lambda x: self.new_rgba_from_string(x), lambda x: x.to_string())
        self.vera_color_manual_color.set_sensitive(True)
        self.vera_color_manual = Gtk.RadioButton.new_with_label_from_widget(
            self.vera_color_from_wallpaper, _("Use this color"))
        self.vera_color_manual.bind_property("active",
                                             self.vera_color_manual_color,
                                             "sensitive",
                                             GObject.BindingFlags.SYNC_CREATE)
        self.desktopsettings.bind("vera-color-lock", self.vera_color_manual,
                                  "active")
        self.vera_color_manual_container.pack_start(self.vera_color_manual,
                                                    True, True, 0)
        self.vera_color_manual_container.pack_start(
            self.vera_color_manual_color, False, False, 0)

        self.vera_color_selection.pack_start(self.vera_color_from_wallpaper,
                                             False, False, 0)
        self.vera_color_selection.pack_start(self.vera_color_manual_container,
                                             False, False, 2)

        self.main_container.pack_start(self.combobox_container, False, False,
                                       0)
        self.main_container.pack_start(self.button_images, False, False, 2)
        self.main_container.pack_start(self.menu_images, False, False, 2)
        self.main_container.pack_start(self.vera_color_enabled, False, False,
                                       2)
        self.main_container.pack_start(self.vera_color_selection, False, False,
                                       2)

        self.get_alignment().add(self.main_container)
from xdg.DesktopEntry import DesktopEntry

from veracc.utils import Settings

from veracc.widgets.ApplicationSelectionDialog import ApplicationSelectionDialog

# Search path for the applications.
#
# /usr/share/vera/autostart is taken out volountairly because it contains
# core applications that the user doesn't want to disable.
# You can still disable those by manually modifying the vera settings via
# e.g. dconf-editor.
SEARCH_PATH = ("/etc/xdg/autostart", os.path.expanduser("~/.config/autostart"))

# dconf settings
SETTINGS = Settings("org.semplicelinux.vera")

# Blacklist
BLACKLIST = SETTINGS.get_strv("autostart-ignore")


class ApplicationRow(Gtk.ListBoxRow):
    """
	An ApplicationRow is a modified Gtk.ListBoxRow that shows informations
	about an application to autostart.
	It permits to enable or disable the application via a Switch.
	
	--------------------------------------------------------------------
	|  ICON   Program name                                       ##ON  |
	--------------------------------------------------------------------
	"""
Esempio n. 20
0
class RebootDialog(Gtk.MessageDialog):
    """
	A RebootDialog() is a dialog that displays a "Reboot now" request
	to the user.
	"""

    REBOOT_NOW_STRING = _("_Reboot now (in %ds)")

    def on_dialog_response(self, dialog, response):
        """
		Fired when the dialog generated a response.
		"""

        # Reset the countdown
        self.countdown = self.settings.get_int("exit-window-countdown")

        # Stop the timeout
        if self.timeout_id > -1:
            GObject.source_remove(self.timeout_id)

        if response == Gtk.ResponseType.OK:
            self.Vera.Reboot()

        self.hide()

    def process_countdown(self):
        """
		Processes the countdown.
		"""

        self.countdown -= 1

        if self.countdown == 0:
            # Assume we're OK
            self.emit("response", Gtk.ResponseType.OK)

            return False
        else:
            self.get_widget_for_response(Gtk.ResponseType.OK).set_label(
                self.REBOOT_NOW_STRING % self.countdown)

            return True

    def on_dialog_shown(self, dialog):
        """
		Fired when the dialog has been shown.
		"""

        # Start the timeout
        if self.countdown > 0:
            self.timeout_id = GObject.timeout_add_seconds(
                1, self.process_countdown)

    def __init__(self, cancellable):
        """
		Initializes the class.
		"""

        super().__init__()

        self.settings = Settings("org.semplicelinux.vera")

        self.timeout_id = -1

        self.countdown = self.settings.get_int("exit-window-countdown")

        # The dialog may be unexpected, so if the countdown setting is < 10,
        # default to 10 to be on the safe side
        if self.countdown > 0 and self.countdown < 10:
            self.countdown = 10

        self.cancellable = cancellable

        self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, self.cancellable)
        self.Vera = Gio.DBusProxy.new_sync(self.bus, 0, None,
                                           "org.semplicelinux.vera",
                                           "/org/semplicelinux/vera",
                                           "org.semplicelinux.vera",
                                           self.cancellable)

        self.set_title(_("Reboot"))
        self.set_modal(True)

        self.set_markup("<big>%s</big>" % _("Reboot required"))
        self.format_secondary_text(
            _("""In order to apply the changes, a reboot is required.

Please save your work and press "Reboot now" to reboot or press "Cancel" to reboot later."""
              ))

        self.add_buttons(
            _("_Cancel"), Gtk.ResponseType.CANCEL, self.REBOOT_NOW_STRING %
            self.countdown if self.countdown > 0 else _("_Reboot now"),
            Gtk.ResponseType.OK)

        self.set_default_response(Gtk.ResponseType.OK)

        self.connect("show", self.on_dialog_shown)
        self.connect("response", self.on_dialog_response)