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