def pulse_progress(self):
self.progressbar.pulse()
if self.mode == "normal":
self.window.set_title(_("USB Image Writer"))
else:
self.window.set_title(_("USB Stick Formatter"))
XApp.set_window_progress_pulse(self.window, True)
def pct(self, so_far, total=None):
percentage = str(int(self.percentage * 100)) + "%"
if self.num_files_left > 1:
message = _("Uploading %(number)d files to %(service)s") % {
'number': self.num_files_left,
'service': "\"" + service['name'] + "\""
}
title = _(
"%(percentage)s of %(number)d files - Uploading to %(service)s"
) % {
'percentage': percentage,
'number': self.num_files_left,
'service': "\"" + service['name'] + "\""
}
else:
message = _("Uploading 1 file to %(service)s") % {
'service': "\"" + service['name'] + "\""
}
title = _(
"%(percentage)s of 1 file - Uploading to %(service)s") % {
'percentage': percentage,
'service': "\"" + service['name'] + "\""
}
self.percentage = float(self.size_so_far) / float(self.total_size)
Gdk.threads_enter()
try:
XApp.set_window_progress(self.window, int(self.percentage * 100))
self.progressbar.set_fraction(self.percentage)
self.progressbar.set_text(str(int(self.percentage * 100)) + "%")
self.builder.get_object("upload_label").set_text(message)
self.window.set_title(title)
finally:
Gdk.threads_leave()
pass
def __init__(self):
user_id = os.getuid()
username = pwd.getpwuid(user_id).pw_name
home_dir = pwd.getpwuid(user_id).pw_dir
self.builder = Gtk.Builder()
self.builder.add_from_file("/usr/share/cinnamon/cinnamon-screensaver-lock-dialog/cinnamon-screensaver-lock-dialog.ui")
self.window = self.builder.get_object("main_dialog")
self.button_cancel = self.builder.get_object("button_cancel")
self.button_ok = self.builder.get_object("button_ok")
self.entry = self.builder.get_object("entry_away_message")
self.image = self.builder.get_object("image_face")
self.window.set_title(_("Screen Locker"))
XApp.set_window_icon_name(self.window, "cs-screensaver")
self.builder.get_object("label_description").set_markup("<i>%s</i>" % _("Please type an away message for the lock screen"))
if os.path.exists("%s/.face" % home_dir):
self.image.set_from_file("%s/.face" % home_dir)
else:
self.image.set_from_icon_name("cs-screensaver", Gtk.IconSize.DIALOG)
self.window.connect("destroy", Gtk.main_quit)
self.button_cancel.connect("clicked", Gtk.main_quit)
self.button_ok.connect('clicked', self.lock_screen)
self.entry.connect('activate', self.lock_screen)
self.builder.get_object("dialog-action_area1").set_focus_chain((self.button_ok, self.button_cancel))
self.window.show()
def set_progress(self, size):
self.progressbar.set_fraction(size)
str_progress = "%3.0f%%" % (float(size) * 100)
int_progress = int(float(size) * 100)
self.progressbar.set_text(str_progress)
self.window.set_title("%s - %s" % (str_progress, _("USB Image Writer")))
XApp.set_window_progress_pulse(self.window, False)
XApp.set_window_progress(self.window, int_progress)
def set_progress(self, size):
self.progressbar.set_fraction(size)
str_progress = "%3.0f%%" % (float(size)*100)
int_progress = int(float(size)*100)
self.progressbar.set_text(str_progress)
self.window.set_title("%s - %s" % (str_progress, _("USB Image Writer")))
XApp.set_window_progress_pulse(self.window, False)
XApp.set_window_progress(self.window, int_progress)
def set_progress(self, path):
fraction = float(self.archived_files) / float(self.num_files)
int_fraction = int(fraction * 100)
self.progressbar.set_fraction(fraction)
self.progressbar.set_text(str(int_fraction) + "%")
self.builder.get_object("label_current_file").set_label(_("Backing up:"))
self.builder.get_object("label_current_file_value").set_label(path)
XApp.set_window_progress(self.main_window, int_fraction)
def set_progress(self, path):
fraction = float(self.archived_files) / float(self.num_files)
int_fraction = int(fraction * 100)
self.progressbar.set_fraction(fraction)
self.progressbar.set_text(str(int_fraction) + "%")
self.builder.get_object("label_current_file").set_label(_("Backing up:"))
self.builder.get_object("label_current_file_value").set_label(path)
XApp.set_window_progress(self.main_window, int_fraction)
def set_restore_progress(self, path):
fraction = float(self.restored_files) / float(self.num_files)
int_fraction = int(fraction * 100)
self.restore_progressbar.set_fraction(fraction)
self.restore_progressbar.set_text(str(int_fraction) + "%")
self.builder.get_object("label_current_file1").set_label(_("Restoring:"))
self.builder.get_object("label_current_file_value1").set_label(path)
XApp.set_window_progress(self.main_window, int_fraction)
def set_restore_progress(self, path):
fraction = float(self.restored_files) / float(self.num_files)
int_fraction = int(fraction * 100)
self.restore_progressbar.set_fraction(fraction)
self.restore_progressbar.set_text(str(int_fraction) + "%")
self.builder.get_object("label_current_file1").set_label(_("Restoring:"))
self.builder.get_object("label_current_file_value1").set_label(path)
XApp.set_window_progress(self.main_window, int_fraction)
def on_driver_changes_error(self, transaction, error_code, error_details):
self.on_driver_changes_revert()
self.set_driver_action_status()
self.update_label_and_icons_from_status()
self.button_driver_revert.set_visible(True)
self.button_driver_apply.set_visible(True)
self.button_driver_cancel.set_visible(False)
self.scrolled_window_drivers.set_sensitive(True)
self.on_error(transaction.error)
XApp.set_window_progress(self.window_main, 0)
def on_driver_changes_error(self, transaction, error_code, error_details):
self.on_driver_changes_revert()
self.set_driver_action_status()
self.update_label_and_icons_from_status()
self.button_driver_revert.set_visible(True)
self.button_driver_apply.set_visible(True)
self.button_driver_cancel.set_visible(False)
self.scrolled_window_drivers.set_sensitive(True)
self.on_error(transaction.error)
XApp.set_window_progress(self.window_main, 0)
def updateBar(self, object, value, size, written):
Gdk.threads_enter()
# print("---UPDATEBAR----", value, size, written)
self.bar.set_fraction(value)
int_progress = int(float(value)*100)
XApp.set_window_progress_pulse(self.window, False)
XApp.set_window_progress(self.window, int_progress)
self.size = size
self.written = written
Gdk.threads_leave()
def window_client_progress_cb(self, pkginfo, progress, estimating):
if estimating:
self.start_progress_pulse()
else:
self.stop_progress_pulse()
self.progress.set_fraction(progress / 100.0)
XApp.set_window_progress(self, progress)
self.tick()
self.update_labels()
def window_client_progress_cb(self, pkginfo, progress, estimating):
if estimating:
self.start_progress_pulse()
else:
self.stop_progress_pulse()
self.progress.set_fraction(progress / 100.0)
XApp.set_window_progress(self, progress)
self.tick()
self.update_labels()
def on_driver_changes_finish(self, transaction, exit_state):
self.needs_restart = True
self.progress_bar.set_visible(False)
self.clear_changes()
self.apt_cache = apt.Cache()
self.set_driver_action_status()
self.update_label_and_icons_from_status()
self.button_driver_revert.set_visible(True)
self.button_driver_apply.set_visible(True)
self.button_driver_cancel.set_visible(False)
self.scrolled_window_drivers.set_sensitive(True)
XApp.set_window_progress(self.window_main, 0)
def on_driver_changes_progress(self, transaction, progress):
#print(progress)
self.button_driver_revert.set_visible(False)
self.button_driver_apply.set_visible(False)
self.button_driver_restart.set_visible(False)
self.button_driver_cancel.set_visible(True)
self.progress_bar.set_visible(True)
self.progress_bar.set_visible(True)
self.label_driver_action.set_label(_("Applying changes..."))
self.progress_bar.set_fraction(progress / 100.0)
XApp.set_window_progress(self.window_main, progress)
def on_driver_changes_progress(self, transaction, progress):
#print(progress)
self.button_driver_revert.set_visible(False)
self.button_driver_apply.set_visible(False)
self.button_driver_restart.set_visible(False)
self.button_driver_cancel.set_visible(True)
self.progress_bar.set_visible(True)
self.progress_bar.set_visible(True)
self.label_driver_action.set_label(_("Applying changes..."))
self.progress_bar.set_fraction(progress / 100.0)
XApp.set_window_progress(self.window_main, progress)
def on_driver_changes_finish(self, transaction, exit_state):
self.needs_restart = True
self.progress_bar.set_visible(False)
self.clear_changes()
self.apt_cache = apt.Cache()
self.set_driver_action_status()
self.update_label_and_icons_from_status()
self.button_driver_revert.set_visible(True)
self.button_driver_apply.set_visible(True)
self.button_driver_cancel.set_visible(False)
self.scrolled_window_drivers.set_sensitive(True)
XApp.set_window_progress(self.window_main, 0)
def _get_dialog(self, dialog_type, summary, msg="",
buttons=Gtk.ButtonsType.CLOSE):
" internal helper for dialog construction "
d = Gtk.MessageDialog(parent=self.dia,
flags=Gtk.DialogFlags.MODAL,
type=dialog_type,
buttons=buttons)
d.set_title("")
d.set_markup("<big><b>%s</b></big>\n\n%s" % (summary, msg))
XApp.set_window_icon_name(d, "package-x-generic")
d.set_keep_above(True)
d.realize()
d.get_window().set_functions(Gdk.WMFunction.MOVE)
return d
def on_driver_changes_progress(self, progress, ptype, data=None):
#print(progress)
self.button_driver_revert.set_visible(False)
self.button_driver_apply.set_visible(False)
self.button_driver_restart.set_visible(False)
self.button_driver_cancel.set_visible(True)
self.progress_bar.set_visible(True)
self.progress_bar.set_visible(True)
self.label_driver_action.set_label(_("Applying changes..."))
if ptype == packagekit.ProgressType.PERCENTAGE:
prog_value = progress.get_property('percentage')
self.progress_bar.set_fraction(prog_value / 100.0)
XApp.set_window_progress(self.window_main, prog_value)
def _get_dialog(self, dialog_type, summary, msg="",
buttons=Gtk.ButtonsType.CLOSE):
" internal helper for dialog construction "
d = Gtk.MessageDialog(parent=self.dia,
flags=Gtk.DialogFlags.MODAL,
type=dialog_type,
buttons=buttons)
d.set_title("")
d.set_markup("<big><b>%s</b></big>\n\n%s" % (summary, msg))
XApp.set_window_icon_name(d, "package-x-generic")
d.set_keep_above(True)
d.realize()
d.get_window().set_functions(Gdk.WMFunction.MOVE)
return d
def __init__(self):
# Determine path to system locale-config
self.locale_path=''
if os.path.exists('/etc/default/locale'):
self.locale_path='/etc/default/locale'
else:
self.locale_path='/etc/locale.conf'
# Prepare the APT cache
self.cache = apt.Cache()
self.cache_updated = False
# load our glade ui file in
self.builder = Gtk.Builder()
self.builder.set_translation_domain("mintlocale")
self.builder.add_from_file('/usr/share/linuxmint/mintlocale/im.ui')
self.window = self.builder.get_object("main_window")
self.window.set_title(_("Input Method"))
XApp.set_window_icon_name(self.window, "mintlocale-im")
self.window.connect("destroy", Gtk.main_quit)
self.im_combo = self.builder.get_object("im_combo")
model = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING)
cell = Gtk.CellRendererText()
self.im_combo.pack_start(cell, True)
self.im_combo.add_attribute(cell, 'text', IM_NAME)
self.im_combo.set_model(model)
self.ImConfig = ImConfig()
self.im_languages = []
self.im_languages.append(IMLanguage("zh-hans", "fcitx:ibus", self.builder.get_object("button_szh"), self))
self.im_languages.append(IMLanguage("zh-hant", "fcitx:ibus", self.builder.get_object("button_tzh"), self))
self.im_languages.append(IMLanguage("ja", "fcitx:ibus", self.builder.get_object("button_ja"), self))
self.im_languages.append(IMLanguage("th", "fcitx:ibus", self.builder.get_object("button_th"), self))
self.im_languages.append(IMLanguage("vi", "fcitx:ibus", self.builder.get_object("button_vi"), self))
self.im_languages.append(IMLanguage("ko", "fcitx:ibus", self.builder.get_object("button_ko"), self))
self.im_languages.append(IMLanguage("te", "ibus", self.builder.get_object("button_te"), self))
self.im_loaded = False # don't react to im changes until we're fully loaded (we're loading that combo asynchronously)
self.im_combo.connect("changed", self.on_combobox_input_method_changed)
self.lock_ui()
self.check_input_methods()
self.window.show_all()
def window_client_finished_cb(self, pkginfo, error_message):
self.finished = True
XApp.set_window_progress(self, 0)
self.stop_progress_pulse()
self.progress.set_fraction(1.0)
self.update_labels()
if error_message:
self.set_urgency_hint(True)
self.button.set_label(Gtk.STOCK_CLOSE)
else:
self.destroy()
self.final_finished_cb(self.task.pkginfo, error_message)
def set_widgets_after_restore(self):
if len(self.errors) > 0:
self.builder.get_object("label_finished_status1").set_markup(_("The following errors occurred:"))
self.builder.get_object("image_finished1").set_from_icon_name("dialog-error-symbolic", Gtk.IconSize.DIALOG)
self.builder.get_object("treeview_restore_errors").set_model(self.errors)
self.builder.get_object("win_errors1").show_all()
else:
if not self.operating:
self.builder.get_object("label_finished_status1").set_markup(_("The restoration was aborted."))
self.builder.get_object("image_finished1").set_from_icon_name("dialog-warning-symbolic", Gtk.IconSize.DIALOG)
else:
self.builder.get_object("image_finished1").set_from_icon_name("mintbackup-success-symbolic", Gtk.IconSize.DIALOG)
self.builder.get_object("label_finished_status1").set_markup(_("Your files were successfully restored."))
self.notebook.next_page()
self.operating = False
XApp.set_window_progress(self.main_window, 0)
def __init__(self,
label,
default_icon=None,
icon_categories=[],
default_category=None,
expand_width=False,
size_group=None,
dep_key=None,
tooltip=""):
super(IconChooser, self).__init__(dep_key=dep_key)
self.label = SettingsLabel(label)
self.content_widget = XApp.IconChooserButton()
self.content_widget.set_icon_size(Gtk.IconSize.BUTTON)
dialog = self.content_widget.get_dialog()
if default_icon:
dialog.set_default_icon(default_icon)
for category in icon_categories:
dialog.add_custom_category(category['name'], category['icons'])
if default_category is not None:
self.content_widget.set_default_category(default_category)
self.pack_start(self.label, False, False, 0)
self.pack_end(self.content_widget, expand_width, expand_width, 0)
self.set_tooltip_text(tooltip)
if size_group:
self.add_to_size_group(size_group)
def __init__(self, app):
if XApp or AyatanaIndicator:
show_menu_item = create_menu_item("Show Ulauncher",
lambda *_: app.do_activate())
menu = Gtk.Menu()
menu.append(show_menu_item)
menu.append(
create_menu_item("Preferences",
lambda *_: app.show_preferences()))
menu.append(
create_menu_item("About",
lambda *_: app.show_preferences("about")))
menu.append(Gtk.SeparatorMenuItem())
menu.append(create_menu_item("Exit", lambda *_: app.quit()))
menu.show_all()
if XApp:
self.indicator = XApp.StatusIcon()
self.indicator.set_icon_name("ulauncher-indicator")
# Show menu on right click and show launcher on left click
self.indicator.set_secondary_menu(menu)
self.indicator.connect("activate", lambda *_: app.do_activate())
elif AyatanaIndicator:
self.indicator = AyatanaIndicator.Indicator.new(
"ulauncher", "ulauncher-indicator",
AyatanaIndicator.IndicatorCategory.APPLICATION_STATUS)
# libappindicator can't/won't distinguish between left and right clicks
# Show menu on left or right click and show launcher on middle click
self.indicator.set_menu(menu)
self.indicator.set_secondary_activate_target(show_menu_item)
def set_widgets_after_restore(self):
if len(self.errors) > 0:
self.builder.get_object("label_finished_status1").set_markup(_("The following errors occurred:"))
self.builder.get_object("image_finished1").set_from_icon_name("dialog-error-symbolic", Gtk.IconSize.DIALOG)
self.builder.get_object("treeview_restore_errors").set_model(self.errors)
self.builder.get_object("win_errors1").show_all()
else:
if not self.operating:
self.builder.get_object("label_finished_status1").set_markup(_("The restoration was aborted."))
self.builder.get_object("image_finished1").set_from_icon_name("dialog-warning-symbolic", Gtk.IconSize.DIALOG)
else:
self.builder.get_object("image_finished1").set_from_icon_name("mintbackup-success-symbolic", Gtk.IconSize.DIALOG)
self.builder.get_object("label_finished_status1").set_markup(_("Your files were successfully restored."))
self.notebook.next_page()
self.operating = False
XApp.set_window_progress(self.main_window, 0)
def __init__(self, application_id, flags):
Gtk.Application.__init__(self, application_id=application_id, flags=flags)
self.connect("activate", self.activate)
self.settings = Gio.Settings(schema_id="com.linuxmint.report")
# Status icon
self.menu = Gtk.Menu()
menuItem = Gtk.MenuItem.new_with_label(_("Show System Reports"))
menuItem.connect('activate', self.on_menu_show)
self.menu.append(menuItem)
self.menu.append(Gtk.SeparatorMenuItem())
menuItem = Gtk.MenuItem.new_with_label(_("Quit"))
menuItem.connect('activate', self.on_menu_quit)
self.menu.append(menuItem)
self.menu.show_all()
try:
self.status_icon = XApp.StatusIcon()
self.status_icon.set_name("mintreport")
self.status_icon.connect("activate", self.on_statusicon_activated)
self.status_icon.set_secondary_menu(self.menu)
except Exception as e:
print("Couldn't instantiate XApp.StatusIcon: %s" % e)
self.status_icon = GtkStatusIcon()
self.status_icon.connect("activate", self.on_gtk_statusicon_activated)
self.status_icon.connect("popup-menu", self.on_gtk_statusicon_popup)
self.status_icon.set_visible(False)
def do_startup(self):
Gtk.Application.do_startup(self)
debug = False
if len(sys.argv) > 1 and sys.argv[1] == "debug":
debug = True
self.rfkill = rfkillMagic.Interface(self.update_icon_callback, debug)
self.settings = Gio.Settings(schema="org.blueberry")
self.settings.connect("changed::tray-enabled",
self.on_settings_changed_cb)
# If we have no adapter, or disabled tray, end early
if (not self.rfkill.have_adapter) or (
not self.settings.get_boolean("tray-enabled")):
self.rfkill.terminate()
sys.exit(0)
self.client = GnomeBluetooth.Client()
self.model = self.client.get_model()
self.model.connect('row-changed', self.update_icon_callback)
self.model.connect('row-deleted', self.update_icon_callback)
self.model.connect('row-inserted', self.update_icon_callback)
self.icon = XApp.StatusIcon()
self.icon.set_name("blueberry")
self.icon.set_tooltip_text(_("Bluetooth"))
self.icon.connect("activate", self.on_statusicon_activated)
self.icon.connect("button-release-event", self.on_statusicon_released)
self.update_icon_callback(None, None, None)
def window_client_finished_cb(self, pkginfo, error_message):
self.finished = True
XApp.set_window_progress(self, 0)
self.stop_progress_pulse()
self.progress.set_fraction(1.0)
self.update_labels()
if error_message:
self.set_urgency_hint(True)
self.button.set_label(Gtk.STOCK_CLOSE)
else:
self.destroy()
self.final_finished_cb(self.task.pkginfo, error_message)
def create_status_icon(self):
self.menu = Gtk.Menu()
item = Gtk.MenuItem(label=_("New Note"))
item.connect('activate', self.new_note)
self.menu.append(item)
item = Gtk.MenuItem(label=_("Manage Notes"))
item.connect('activate', self.open_manager)
self.menu.append(item)
self.menu.append(Gtk.SeparatorMenuItem())
self.group_menu = Gtk.Menu()
item = Gtk.MenuItem(label=_("Change Group"), submenu=self.group_menu)
self.menu.append(item)
self.update_groups_menu()
self.menu.append(Gtk.SeparatorMenuItem())
item = Gtk.MenuItem(label=_("Back Up Notes"))
item.connect('activate', self.file_handler.save_backup)
self.menu.append(item)
item = Gtk.MenuItem(label=_("Back Up To File"))
item.connect('activate', self.file_handler.backup_to_file)
self.menu.append(item)
item = Gtk.MenuItem(label=_("Restore Backup"))
item.connect('activate', self.file_handler.restore_backup)
self.menu.append(item)
self.menu.append(Gtk.SeparatorMenuItem())
item = Gtk.MenuItem(label=_("Settings"))
item.connect('activate', self.open_settings_window)
self.menu.append(item)
item = Gtk.MenuItem(label=_("Keyboard Shortcuts"))
item.connect('activate', self.open_keyboard_shortcuts)
self.menu.append(item)
self.menu.append(Gtk.SeparatorMenuItem())
item = Gtk.MenuItem(label=_("Exit"))
item.connect('activate', self.quit_app)
self.menu.append(item)
self.menu.show_all()
self.status_icon = XApp.StatusIcon()
self.status_icon.set_name('sticky')
self.status_icon.set_icon_name('sticky-symbolic')
self.status_icon.set_tooltip_text('Sticky Notes')
self.status_icon.set_visible(True)
self.status_icon.set_secondary_menu(self.menu)
self.status_icon.connect('activate', self.activate_notes)
def create_status_icon(self):
self.status_icon = XApp.StatusIcon()
self.status_icon.set_name('sticky')
self.status_icon.set_icon_name('sticky-symbolic')
self.status_icon.set_tooltip_text(_('Notes'))
self.status_icon.set_visible(True)
self.status_icon.connect('button-press-event',
self.on_tray_button_pressed)
self.status_icon.connect('button-release-event',
self.on_tray_button_released)
def pct(self, so_far, total=None):
percentage = str(int(self.percentage * 100)) + "%"
if self.num_files_left > 1:
message = _("Uploading %(number)d files to %(service)s") % {'number': self.num_files_left, 'service': "\"" + service['name'] + "\""}
title = _("%(percentage)s of %(number)d files - Uploading to %(service)s") % {'percentage': percentage, 'number': self.num_files_left, 'service': "\"" + service['name'] + "\""}
else:
message = _("Uploading 1 file to %(service)s") % {'service': "\"" + service['name'] + "\""}
title = _("%(percentage)s of 1 file - Uploading to %(service)s") % {'percentage': percentage, 'service': "\"" + service['name'] + "\""}
self.percentage = float(self.size_so_far) / float(self.total_size)
Gdk.threads_enter()
try:
XApp.set_window_progress(self.window, int(self.percentage * 100))
self.progressbar.set_fraction(self.percentage)
self.progressbar.set_text(str(int(self.percentage * 100)) + "%")
self.builder.get_object("upload_label").set_text(message)
self.window.set_title(title)
finally:
Gdk.threads_leave()
pass
def do_activate(self):
Gtk.Application.do_activate(self)
self.file_handler = FileHandler()
self.settings = Gio.Settings(schema_id=SCHEMA)
self.note_group = self.settings.get_string('default-group')
group_names = self.file_handler.get_note_group_names()
if self.note_group not in group_names:
if len(group_names) > 0:
self.note_group = group_names[0]
else:
self.file_handler.update_note_list([], self.note_group)
provider = Gtk.CssProvider()
provider.load_from_path(STYLE_SHEET_PATH)
Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),
provider, 600)
self.menu = Gtk.Menu()
item = Gtk.MenuItem(label=_("New Note"))
item.connect('activate', self.new_note)
self.menu.append(item)
item = Gtk.MenuItem(label=_("Manage Notes"))
item.connect('activate', self.open_manager)
self.menu.append(item)
item = Gtk.MenuItem(label=_("Settings"))
item.connect('activate', self.open_settings_window)
self.menu.append(item)
self.menu.append(Gtk.SeparatorMenuItem())
item = Gtk.MenuItem(label=_("Exit"))
item.connect('activate', self.quit_app)
self.menu.append(item)
self.menu.show_all()
self.status_icon = XApp.StatusIcon()
self.status_icon.set_name('sticky')
self.status_icon.set_icon_name('sticky-symbolic')
self.status_icon.set_tooltip_text('Sticky Notes')
self.status_icon.set_visible(True)
self.status_icon.set_secondary_menu(self.menu)
self.status_icon.connect('activate', self.activate_notes)
self.load_notes()
self.hold()
def on_driver_changes_finish(self, source, result, installs_pending):
results = None
errors = False
try:
results = self.pk_task.generic_finish(result)
except Exception as e:
self.on_driver_changes_revert()
self.on_error(str(e))
errors = True
if not installs_pending:
self.needs_restart = (not errors)
self.progress_bar.set_visible(False)
self.clear_changes()
self.apt_cache = apt.Cache()
self.set_driver_action_status()
self.update_label_and_icons_from_status()
self.button_driver_revert.set_visible(True)
self.button_driver_apply.set_visible(True)
self.button_driver_cancel.set_visible(False)
self.scrolled_window_drivers.set_sensitive(True)
XApp.set_window_progress(self.window_main, 0)
def __init__(self):
user_id = os.getuid()
username = pwd.getpwuid(user_id).pw_name
real_name = pwd.getpwuid(user_id).pw_gecos
home_dir = pwd.getpwuid(user_id).pw_dir
real_name = real_name.replace(",", "")
if real_name == "":
real_name = username
self.builder = Gtk.Builder()
self.builder.add_from_file("/usr/share/cinnamon/cinnamon-screensaver-lock-dialog/cinnamon-screensaver-lock-dialog.ui")
self.window = self.builder.get_object("main_dialog")
self.button_cancel = self.builder.get_object("button_cancel")
self.button_ok = self.builder.get_object("button_ok")
self.entry = self.builder.get_object("entry_away_message")
self.image = self.builder.get_object("image_face")
self.window.set_title(_("Screen Locker"))
XApp.set_window_icon_name(self.window, "cs-screensaver")
self.builder.get_object("label_description").set_markup("<i>%s</i>" % _("Please type an away message for the lock screen"))
self.builder.get_object("label_away_message").set_markup("<b>%s: </b>" % real_name)
if os.path.exists("%s/.face" % home_dir):
self.image.set_from_file("%s/.face" % home_dir)
else:
self.image.set_from_icon_name("cs-screensaver", Gtk.IconSize.DIALOG)
self.window.connect("destroy", Gtk.main_quit)
self.button_cancel.connect("clicked", Gtk.main_quit)
self.button_ok.connect('clicked', self.lock_screen)
self.entry.connect('activate', self.lock_screen)
self.builder.get_object("dialog-action_area1").set_focus_chain((self.button_ok, self.button_cancel))
self.window.show()
def __init__(self):
self.drop_zones = {}
self.services = None
self.build_services_menu()
# Refresh list of services in the menu every 2 seconds
GLib.timeout_add_seconds(2, self.reload_services)
self.status_icon = XApp.StatusIcon()
self.status_icon.set_name("mintupload")
self.status_icon.set_icon_name(SYSTRAY_ICON)
self.status_icon.set_tooltip_text(_("Upload services"))
self.status_icon.set_primary_menu(self.menu)
self.status_icon.set_secondary_menu(self.menu)
def askInstallPackage(self, package, summary, description, homepage):
# populate the dialog
dia = self.dia
dia_xml = self.dia_xml
header = _("Install additional software?")
body = _("Do you want to install package '%s'?") % package
dia.set_title(package)
header_label = dia_xml.get_object('header_label')
header_label.set_markup("<b><big>%s</big></b>" % header)
body_label = dia_xml.get_object('body_label')
body_label.set_label(body)
description_text_view = dia_xml.get_object('description_text_view')
tbuf = Gtk.TextBuffer()
desc = "%s\n\n%s" % (summary, Helpers.format_description(description))
tbuf.set_text(desc)
description_text_view.set_buffer(tbuf)
XApp.set_window_icon_name(dia, "package-x-generic")
# check if another package manager is already running
# FIXME: just checking for the existance of the file is
# not sufficient, it need to be tested if it can
# be locked via apt_pkg.get_lock()
# - but that needs to run as root
# - a dbus helper might be the best answer here
#args = (update_button_status, dia_xml.get_object("yes_button"),
# dia_xml.get_object("infolabel"))
#args[0](*args[1:])
#timer_id = GObject.timeout_add(750, *args )
# show the dialog
res = dia.run()
#GObject.source_remove(timer_id)
if res != Gtk.ResponseType.YES:
dia.hide()
return False
return True
def askInstallPackage(self, package, summary, description, homepage):
# populate the dialog
dia = self.dia
dia_xml = self.dia_xml
header = _("Install additional software?")
body = _("Do you want to install package '%s'?") % package
dia.set_title(package)
header_label = dia_xml.get_object('header_label')
header_label.set_markup("<b><big>%s</big></b>" % header)
body_label = dia_xml.get_object('body_label')
body_label.set_label(body)
description_text_view = dia_xml.get_object('description_text_view')
tbuf = Gtk.TextBuffer()
desc = "%s\n\n%s" % (summary, Helpers.format_description(description))
tbuf.set_text(desc)
description_text_view.set_buffer(tbuf)
XApp.set_window_icon_name(dia, "package-x-generic")
# check if another package manager is already running
# FIXME: just checking for the existance of the file is
# not sufficient, it need to be tested if it can
# be locked via apt_pkg.get_lock()
# - but that needs to run as root
# - a dbus helper might be the best answer here
#args = (update_button_status, dia_xml.get_object("yes_button"),
# dia_xml.get_object("infolabel"))
#args[0](*args[1:])
#timer_id = GObject.timeout_add(750, *args )
# show the dialog
res = dia.run()
#GObject.source_remove(timer_id)
if res != Gtk.ResponseType.YES:
dia.hide()
return False
return True
def __init__(self, label, expand_width=False, size_group=None, dep_key=None, tooltip=""):
super(IconChooser, self).__init__(dep_key=dep_key)
self.label = SettingsLabel(label)
self.content_widget = XApp.IconChooserButton()
self.content_widget.set_icon_size(Gtk.IconSize.BUTTON)
self.pack_start(self.label, False, False, 0)
self.pack_end(self.content_widget, expand_width, expand_width, 0)
self.set_tooltip_text(tooltip)
if size_group:
self.add_to_size_group(size_group)
def on_scroll(self, widget, event):
has, direction = event.get_scroll_direction()
x_dir = XApp.ScrollDirection.UP
delta = 0
if direction != Gdk.ScrollDirection.SMOOTH:
x_dir = XApp.ScrollDirection(int(direction))
if direction == Gdk.ScrollDirection.UP:
delta = -1
elif direction == Gdk.ScrollDirection.DOWN:
delta = 1
elif direction == Gdk.ScrollDirection.LEFT:
delta = -1
elif direction == Gdk.ScrollDirection.RIGHT:
delta = 1
self.proxy.call_scroll_sync(delta, x_dir, event.time, None)
def do_activate(self):
"""
Called when the plugin is activated
"""
self.shell = self.object
self.wind = self.shell.get_property("window")
self.player = self.shell.props.shell_player
self.db = self.shell.props.db
self.playing = False
self.wind.connect("delete-event", self.hide_on_delete)
self.icon = XApp.StatusIcon()
self.icon.set_icon_name("folder-music-symbolic")
self.icon.connect("scroll-event", self.on_scroll)
self.icon.connect("activate", self.toggle_player_visibility)
self.player.connect("playing-changed", self.on_playing_changed)
self.set_tooltip_text("Rhythmbox")
self.create_popup_menu()
def dowork(self):
# Wait for translated texts to be loaded
while not sabnzbd.WEBUI_READY:
sleep(0.2)
logging.debug("language file not loaded, waiting")
self.sabpaused = False
if HAVE_XAPP:
self.statusicon = XApp.StatusIcon()
else:
self.statusicon = Gtk.StatusIcon()
self.statusicon.set_name("SABnzbd")
self.statusicon.set_visible(True)
self.icon = self.sabicons["default"]
self.refresh_icon()
self.tooltip = "SABnzbd %s" % sabnzbd.__version__
self.refresh_tooltip()
if HAVE_XAPP:
self.statusicon.connect("activate", self.right_click_event)
else:
self.statusicon.connect("popup-menu", self.right_click_event)
GLib.timeout_add(self.updatefreq, self.run)
Gtk.main()
def __init__(self, task, parent=None):
Gtk.Dialog.__init__(self, parent=parent)
self.task = task
self.finished = False
# Progress goes directly to this window
task.client_progress_cb = self.window_client_progress_cb
# finished callbacks route thru the installer
# but we want to see them in this window also.
self.final_finished_cb = task.client_finished_cb
task.client_finished_cb = self.window_client_finished_cb
self.pulse_timer = 0
self.active_task_state = task.progress_state
self.real_progress_text = None
self.num_dots = 0
# Setup the dialog
self.set_border_width(6)
self.set_resizable(False)
self.get_content_area().set_spacing(6)
# Setup the cancel button
self.button = Gtk.Button.new_from_stock(Gtk.STOCK_CANCEL)
self.button.set_use_stock(True)
self.get_action_area().pack_start(self.button, False, False, 0)
self.button.connect("clicked", self.on_button_clicked)
self.button.show()
# labels and progressbar
hbox = Gtk.HBox()
hbox.set_spacing(12)
hbox.set_border_width(6)
vbox = Gtk.VBox()
vbox.set_spacing(12)
self.phase_label = Gtk.Label()
vbox.pack_start(self.phase_label, False, False, 0)
self.phase_label.set_halign(Gtk.Align.START)
vbox_progress = Gtk.VBox()
vbox_progress.set_spacing(6)
self.progress = Gtk.ProgressBar()
vbox_progress.pack_start(self.progress, False, True, 0)
self.progress_label = Gtk.Label()
vbox_progress.pack_start(self.progress_label, False, False, 0)
self.progress_label.set_halign(Gtk.Align.START)
self.progress_label.set_line_wrap(True)
self.progress_label.set_max_width_chars(60)
vbox.pack_start(vbox_progress, False, True, 0)
hbox.pack_start(vbox, True, True, 0)
self.get_content_area().pack_start(hbox, True, True, 0)
self.set_title(_("Flatpak Progress"))
XApp.set_window_icon_name(self, "system-software-installer")
hbox.show_all()
self.realize()
self.progress.set_size_request(350, -1)
functions = Gdk.WMFunction.MOVE | Gdk.WMFunction.RESIZE
try:
self.get_window().set_functions(functions)
except TypeError:
# workaround for older and broken GTK typelibs
self.get_window().set_functions(Gdk.WMFunction(functions))
self.update_labels()
# catch ESC and behave as if cancel was clicked
self.connect("delete-event", self._on_dialog_delete_event)
def pulse_progress(self):
self.progressbar.pulse()
self.window.set_title(_("USB Image Writer"))
XApp.set_window_progress_pulse(self.window, True)
def __init__(self):
# Determine path to system locale-config
self.locale_path=''
if os.path.exists('/etc/default/locale'):
self.locale_path='/etc/default/locale'
else:
self.locale_path='/etc/locale.conf'
# Prepare the APT cache
if IS_DEBIAN:
self.cache = apt.Cache()
self.cache_updated = False
# load our glade ui file in
self.builder = Gtk.Builder()
self.builder.set_translation_domain("mintlocale")
self.builder.add_from_file('/usr/share/linuxmint/mintlocale/mintlocale.ui')
self.window = self.builder.get_object("main_window")
self.window.set_title(_("Language Settings"))
self.window.connect("destroy", Gtk.main_quit)
XApp.set_window_icon_name(self.window, "preferences-desktop-locale")
self.toolbar = Gtk.Toolbar()
self.toolbar.get_style_context().add_class("primary-toolbar")
self.builder.get_object("box1").pack_start(self.toolbar, False, False, 0)
size_group = Gtk.SizeGroup.new(Gtk.SizeGroupMode.HORIZONTAL)
self.locale_button = PictureChooserButton(num_cols=2, button_picture_size=BUTTON_FLAG_SIZE, has_button_label=True)
size_group.add_widget(self.locale_button)
self.region_button = PictureChooserButton(num_cols=2, button_picture_size=BUTTON_FLAG_SIZE, has_button_label=True)
size_group.add_widget(self.region_button)
self.locale_system_wide_button = Gtk.Button()
self.locale_system_wide_button.set_label(_("Apply System-Wide"))
self.locale_system_wide_button.connect("clicked", self.button_system_language_clicked)
size_group.add_widget(self.locale_system_wide_button)
self.locale_install_button = Gtk.Button()
self.locale_install_button.set_label(_("Install / Remove Languages..."))
self.locale_install_button.connect("clicked", self.button_install_remove_clicked)
size_group.add_widget(self.locale_install_button)
self.system_label = Gtk.Label()
self.install_label = Gtk.Label()
page = SettingsPage()
self.builder.get_object("box1").pack_start(page, True, True, 0)
language_settings = page.add_section()
label = Gtk.Label.new()
label.set_markup("<b>%s</b>\n<small>%s</small>" % (_("Language"), _("Language, interface, date and time...")))
row = SettingsRow(label, self.locale_button)
language_settings.add_row(row)
label = Gtk.Label.new()
label.set_markup("<b>%s</b>\n<small>%s</small>" % (_("Region"), _("Numbers, currency, addresses, measurement...")))
row = SettingsRow(label, self.region_button)
language_settings.add_row(row)
self.system_row = SettingsRow(self.system_label, self.locale_system_wide_button)
self.system_row.set_no_show_all(True)
language_settings.add_row(self.system_row)
self.install_row = SettingsRow(self.install_label, self.locale_install_button)
self.install_row.set_no_show_all(True)
if IS_DEBIAN:
language_settings.add_row(self.install_row)
self.pam_environment_path = os.path.join(GLib.get_home_dir(), ".pam_environment")
self.dmrc_path = os.path.join(GLib.get_home_dir(), ".dmrc")
self.dmrc = configparser.ConfigParser()
self.dmrc.optionxform = str # force case sensitivity on ConfigParser
self.dmrc.read(self.dmrc_path)
if not self.dmrc.has_section('Desktop'):
self.dmrc.add_section('Desktop')
current_user = GLib.get_user_name()
self.current_language = None
dmrc_language = None
env_language = os.environ['LANG']
if self.dmrc.has_option('Desktop', 'Language'):
dmrc_language = self.dmrc.get('Desktop', 'Language')
if dmrc_language is not None:
self.current_language = dmrc_language
else:
self.current_language = env_language
print("User language in .dmrc: %s" % dmrc_language)
print("User language in $LANG: %s" % env_language)
print("Current language: %s" % self.current_language)
if 'LC_NUMERIC' in os.environ:
self.current_region = os.environ['LC_NUMERIC']
else:
self.current_region = self.current_language
if os.path.exists(self.pam_environment_path):
with codecs.open(self.pam_environment_path, 'r', encoding='UTF-8') as pam_file:
for line in pam_file:
line = line.strip()
if line.startswith("LC_NUMERIC="):
self.current_region = line.split("=")[1].replace("\"", "").replace("'", "").strip()
print("Current region: %s" % self.current_region)
# Replace utf8 with UTF-8 (lightDM GTK greeter messes that up)
self.current_language = self.current_language.replace(".utf8", ".UTF-8")
self.current_region = self.current_region.replace(".utf8", ".UTF-8")
self.build_lang_list()
self.set_system_locale()
self.set_num_installed()
self.accountService = AccountsService.UserManager.get_default().get_user(current_user)
self.accountService.connect('notify::is-loaded', self.accountservice_ready)
self.accountService.connect('changed::', self.accountservice_changed)
groups = grp.getgrall()
for group in groups:
(name, pw, gid, mem) = group
if name in ("adm", "sudo", "wheel", "root"):
for user in mem:
if current_user == user:
self.system_row.set_no_show_all(False)
self.install_row.set_no_show_all(False)
language_settings.show_all()
break
self.window.show_all()
def on_transaction_progress(self, transaction, progress):
if self.progress_callback is not None:
self.progress_callback(progress)
if self.parent_window is not None:
XApp.set_window_progress(self.parent_window, progress)
def __init__(self):
self.builder = Gtk.Builder()
self.builder.set_translation_domain('cinnamon') # let it translate!
self.builder.add_from_file(config.currentPath +
"/cinnamon-settings.ui")
self.window = XApp.GtkWindow(window_position=Gtk.WindowPosition.CENTER,
default_width=800,
default_height=600)
main_box = self.builder.get_object("main_box")
self.window.add(main_box)
self.top_bar = self.builder.get_object("top_bar")
self.side_view = {}
self.main_stack = self.builder.get_object("main_stack")
self.main_stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
self.main_stack.set_transition_duration(150)
self.header_stack = self.builder.get_object("header_stack")
self.header_stack.set_transition_type(
Gtk.StackTransitionType.CROSSFADE)
self.header_stack.set_transition_duration(150)
self.side_view_container = self.builder.get_object("category_box")
self.side_view_sw = self.builder.get_object("side_view_sw")
context = self.side_view_sw.get_style_context()
context.add_class("cs-category-view")
context.add_class("view")
self.side_view_sw.show_all()
self.content_box = self.builder.get_object("content_box")
self.content_box_sw = self.builder.get_object("content_box_sw")
self.content_box_sw.show_all()
self.button_back = self.builder.get_object("button_back")
self.button_back.set_tooltip_text(_("Back to all settings"))
button_image = self.builder.get_object("image1")
button_image.props.icon_size = Gtk.IconSize.MENU
self.stack_switcher = self.builder.get_object("stack_switcher")
self.search_entry = self.builder.get_object("search_box")
self.search_entry.set_placeholder_text(_("Search"))
self.search_entry.connect("changed", self.onSearchTextChanged)
self.search_entry.connect("icon-press", self.onClearSearchBox)
self.window.connect("destroy", self.quit)
self.builder.connect_signals(self)
self.unsortedSidePages = []
self.sidePages = []
self.settings = Gio.Settings.new("org.cinnamon")
self.current_cat_widget = None
self.current_sidepage = None
self.c_manager = capi.CManager()
self.content_box.c_manager = self.c_manager
self.bar_heights = 0
for module in modules:
try:
mod = module.Module(self.content_box)
if self.loadCheck(mod) and self.setParentRefs(mod):
self.unsortedSidePages.append(
(mod.sidePage, mod.name, mod.category))
except:
print("Failed to load module %s" % module)
traceback.print_exc()
for item in CONTROL_CENTER_MODULES:
ccmodule = SettingsWidgets.CCModule(item[0], item[1], item[2],
item[3], item[4],
self.content_box)
if ccmodule.process(self.c_manager):
self.unsortedSidePages.append(
(ccmodule.sidePage, ccmodule.name, ccmodule.category))
for item in STANDALONE_MODULES:
samodule = SettingsWidgets.SAModule(item[0], item[1], item[2],
item[3], item[4],
self.content_box)
if samodule.process():
self.unsortedSidePages.append(
(samodule.sidePage, samodule.name, samodule.category))
# sort the modules alphabetically according to the current locale
localeStrKey = cmp_to_key(locale.strcoll)
# Apply locale key to the field name of each side page.
sidePagesKey = lambda m: localeStrKey(m[0].name)
self.sidePages = sorted(self.unsortedSidePages, key=sidePagesKey)
# create the backing stores for the side nav-view.
sidePagesIters = {}
self.store = {}
self.storeFilter = {}
for sidepage in self.sidePages:
sp, sp_id, sp_cat = sidepage
if sp_cat not in self.store: # Label Icon sidePage Category
self.store[sidepage[2]] = Gtk.ListStore(str, str, object, str)
for category in CATEGORIES:
if category["id"] == sp_cat:
category["show"] = True
# Don't allow item names (and their translations) to be more than 30 chars long. It looks ugly and it creates huge gaps in the icon views
name = sp.name
if len(name) > 30:
name = "%s..." % name[:30]
sidePagesIters[sp_id] = (self.store[sp_cat].append(
[name, sp.icon, sp, sp_cat]), sp_cat)
self.min_label_length = 0
self.min_pix_length = 0
for key in self.store:
char, pix = self.get_label_min_width(self.store[key])
self.min_label_length = max(char, self.min_label_length)
self.min_pix_length = max(pix, self.min_pix_length)
self.storeFilter[key] = self.store[key].filter_new()
self.storeFilter[key].set_visible_func(
self.filter_visible_function)
self.min_label_length += 2
self.min_pix_length += 4
self.min_label_length = max(self.min_label_length, MIN_LABEL_WIDTH)
self.min_pix_length = max(self.min_pix_length, MIN_PIX_WIDTH)
self.min_label_length = min(self.min_label_length, MAX_LABEL_WIDTH)
self.min_pix_length = min(self.min_pix_length, MAX_PIX_WIDTH)
self.displayCategories()
# set up larger components.
self.window.set_title(_("System Settings"))
self.button_back.connect('clicked', self.back_to_icon_view)
self.calculate_bar_heights()
self.tab = 0 # open 'manage' tab by default
self.sort = 1 # sorted by 'score' by default
# Select the first sidePage
if len(sys.argv) > 1:
arg1 = sys.argv[1]
if arg1 in ARG_REWRITE.keys():
arg1 = ARG_REWRITE[arg1]
if len(sys.argv) > 1 and arg1 in sidePagesIters:
# Analyses arguments to know the tab to open
# and the sort to apply if the tab is the 'more' one.
# Examples:
# cinnamon-settings.py applets --tab=more --sort=date
# cinnamon-settings.py applets --tab=1 --sort=2
# cinnamon-settings.py applets --tab=more --sort=date
# cinnamon-settings.py applets --tab=1 -s 2
# cinnamon-settings.py applets -t 1 -s installed
# cinnamon-settings.py desklets -t 2
# Please note that useless or wrong arguments are ignored.
opts = []
sorts_literal = {
"name": 0,
"score": 1,
"date": 2,
"installed": 3,
"update": 4
}
tabs_literal = {"default": 0}
if arg1 in TABS.keys():
tabs_literal = TABS[arg1]
try:
if len(sys.argv) > 2:
opts = getopt.getopt(sys.argv[2:], "t:s:",
["tab=", "sort="])[0]
except getopt.GetoptError:
pass
for opt, arg in opts:
if opt in ("-t", "--tab"):
if arg.isdecimal():
self.tab = int(arg)
elif arg in tabs_literal.keys():
self.tab = tabs_literal[arg]
if opt in ("-s", "--sort"):
if arg.isdecimal():
self.sort = int(arg)
elif arg in sorts_literal.keys():
self.sort = sorts_literal[arg]
# If we're launching a module directly, set the WM class so GWL
# can consider it as a standalone app and give it its own
# group.
wm_class = "cinnamon-settings %s" % arg1
self.window.set_wmclass(wm_class, wm_class)
self.button_back.hide()
(iter, cat) = sidePagesIters[arg1]
path = self.store[cat].get_path(iter)
if path:
self.go_to_sidepage(cat, path, user_action=False)
self.window.show()
if arg1 in ("mintlocale", "blueberry", "system-config-printer",
"mintlocale-im", "nvidia-settings"):
# These modules do not need to leave the System Settings window open,
# when selected by command line argument.
self.window.close()
else:
self.search_entry.grab_focus()
self.window.show()
else:
self.search_entry.grab_focus()
self.window.connect("key-press-event", self.on_keypress)
self.window.connect("button-press-event", self.on_buttonpress)
self.window.show()
def on_transaction_error(self, transaction, error_code, error_details):
if self.error_callback is not None:
self.error_callback(error_code, error_details)
if self.parent_window is not None:
XApp.set_window_progress(self.parent_window, 0)
