def _create_autostarter(self):
autostart_file = self._get_autostart_file_path()
autostart_dir = os.path.dirname(autostart_file)
if not os.path.isdir(autostart_dir):
#create autostart dir
try:
os.mkdir(autostart_dir)
except DirectoryCreationError as e:
print("Creation of autostart dir failed, please make it yourself: {}".format(autostart_dir))
raise e
if not os.path.isfile(autostart_file):
# create autostart entry
starter_item = DesktopEntry(autostart_file)
starter_item.set('Name', 'f.lux indicator applet')
# Use the user's shell to start 'fluxgui', in case
# 'fluxgui' is not installed on a standard system path. We
# use 'sh' to start the users '/etc/passwd' shell via
# '$SHELL', so that this will still work if the user
# changes their shell after the
# 'autostart/fluxgui.desktop' file is created.
#
# See PR #89 for an alternative approach:
#
# https://github.com/xflux-gui/fluxgui/pull/89
#
# The escaping of the 'Exec' field is described in
#
# https://developer.gnome.org/desktop-entry-spec/#exec-variables.
starter_item.set('Exec', r'sh -c "\\"\\$SHELL\\" -c fluxgui"')
starter_item.set('Icon', 'fluxgui')
starter_item.set('X-GNOME-Autostart-enabled', 'true')
starter_item.write()
self.autostart = True
def on_edit_item(self, widget, treeview):
model, iter = treeview.get_selection().get_selected()
if iter:
path = model.get_value(iter, COLUMN_PATH)
if path[1:4] == "etc":
shutil.copy(path, treeview.userdir)
path = os.path.join(treeview.userdir, os.path.basename(path))
dialog = AutoStartDialog(DesktopEntry(path), widget.get_toplevel())
if dialog.run() == gtk.RESPONSE_OK:
name = dialog.pm_name.get_text()
cmd = dialog.pm_cmd.get_text()
if not name:
ErrorDialog(_("The name of the startup program cannot be empty")).launch()
elif not cmd:
ErrorDialog(_("Text was empty (or contained only whitespace)")).launch()
else:
desktopentry = DesktopEntry(path)
desktopentry.set("Name", name, locale = True)
desktopentry.set("Exec", cmd)
desktopentry.set("Comment", dialog.pm_comment.get_text(), locale = True)
desktopentry.write()
treeview.update_items(all = self.show_all_button.get_active(), comment = self.show_comment_button.get_active())
dialog.destroy()
return
dialog.destroy()
def on_add_item(self, widget, treeview):
dialog = AutoStartDialog(parent=widget.get_toplevel())
if dialog.run() == gtk.RESPONSE_OK:
name = dialog.pm_name.get_text()
cmd = dialog.pm_cmd.get_text()
if not name:
ErrorDialog(_("The name of the startup program cannot be empty")).launch()
elif not cmd:
ErrorDialog(_("Text was empty (or contained only whitespace)")).launch()
else:
path = os.path.join(treeview.userdir, os.path.basename(cmd) + ".desktop")
desktopentry = DesktopEntry(path)
desktopentry.set("Name", dialog.pm_name.get_text())
desktopentry.set("Exec", dialog.pm_cmd.get_text())
desktopentry.set("Comment", dialog.pm_comment.get_text())
desktopentry.set("Type", "Application")
desktopentry.set("Version", "1.0")
desktopentry.set("X-GNOME-Autostart-enabled", "true")
desktopentry.write()
treeview.update_items(
all=self.show_all_button.get_active(), comment=self.show_comment_button.get_active()
)
dialog.destroy()
return
dialog.destroy()
def newStarter(self, path, newstart):
myitem = DesktopEntry(path)
myitem.set("Name", newstart.Name)
myitem.set("Exec", newstart.Exec)
myitem.set("Comment", newstart.Comment)
myitem.set("Type", "Application")
myitem.set("Version", "1.0")
myitem.set("X-GNOME-Autostart-enabled", newstart.Autostart)
# Scrive il file .desktop
myitem.write()
def set_autostart(self, enable):
if not os.path.exists(self.autostart_desktop):
if os.path.exists(self.sys_autostart_desktop):
os.system("mkdir -p %s" % os.path.dirname(self.autostart_desktop))
os.system("cp %s %s" % (self.sys_autostart_desktop, self.autostart_desktop))
else:
return False
desktop_entry = DesktopEntry(self.autostart_desktop)
if desktop_entry.getHidden() == enable:
hidden_word = "false" if enable else "true"
desktop_entry.set("Hidden", hidden_word)
desktop_entry.write()
def _create_desktop_file_from_command(self, command):
basename = os.path.basename(command)
path = os.path.expanduser('~/.local/share/applications/%s.desktop' % basename)
desktop = DesktopEntry()
desktop.addGroup('Desktop Entry')
desktop.set('Type', 'Application')
desktop.set('Version', '1.0')
desktop.set('Terminal', 'false')
desktop.set('Exec', command)
desktop.set('Name', basename)
desktop.set('X-Ubuntu-Tweak', 'true')
desktop.write(path)
return '%s.desktop' % basename
def on_remove_item(self, widget, treeview):
model, iter = treeview.get_selection().get_selected()
if iter:
path = model.get_value(iter, COLUMN_PATH)
if path[1:4] == "etc":
shutil.copy(path, treeview.userdir)
desktopentry = DesktopEntry(os.path.join(treeview.userdir, os.path.basename(path)))
else:
desktopentry = DesktopEntry(path)
desktopentry.set("Hidden", "true")
desktopentry.set("X-GNOME-Autostart-enabled", "false")
desktopentry.write()
treeview.update_items(all = self.show_all_button.get_active(), comment = self.show_comment_button.get_active())
def _update_autostart_flag(self):
if self._desktop == 'unknown':
# No se puede autostartear :(
return
desktop_compartir = DesktopEntry(
os.path.join(BaseDirectory.save_config_path('autostart'),
'compartir.desktop')
)
if self._desktop == 'mate':
desktop_compartir.set(
'X-MATE-Autostart-enabled',
'true' if self.compartir.autostart else 'false'
)
desktop_compartir.write()
def test_write_file(self):
de = DesktopEntry()
de.parse(self.test_file)
de.removeKey("Name")
de.addGroup("Hallo")
de.set("key", "value", "Hallo")
new_file = os.path.join(self.tmpdir, "test.desktop")
de.write(new_file, trusted=True)
with io.open(new_file, encoding='utf-8') as f:
contents = f.read()
assert "[Hallo]" in contents, contents
assert re.search("key\s*=\s*value", contents), contents
# This is missing the Name key, and has an unknown Hallo group, so it
# shouldn't validate.
new_entry = DesktopEntry(new_file)
self.assertRaises(ValidationError, new_entry.validate)
def enabled_toggled(self, cell, path, model):
iter = model.get_iter((int(path),))
active = model.get_value(iter, COLUMN_ACTIVE)
path = model.get_value(iter, COLUMN_PATH)
if self.is_defaultitem(path):
shutil.copy(path, self.userdir)
path = os.path.join(self.userdir, os.path.basename(path))
desktopentry = DesktopEntry(path)
desktopentry.set("X-GNOME-Autostart-enabled", "false")
desktopentry.write()
model.set(iter, COLUMN_PATH, path)
else:
if active:
desktopentry = DesktopEntry(path)
desktopentry.set("X-GNOME-Autostart-enabled", "false")
desktopentry.write()
else:
if self.is_in_systemdir(path):
os.remove(path)
path = os.path.join(self.get_systemdir(path), os.path.basename(path))
model.set(iter, COLUMN_PATH, path)
else:
desktopentry = DesktopEntry(path)
desktopentry.set("X-GNOME-Autostart-enabled", "true")
desktopentry.set("Hidden", "false")
desktopentry.write()
active = not active
model.set(iter, COLUMN_ACTIVE, active)
def create_autostarter(self):
"""Adds an entry to the autostart directory to start fluxgui on
startup."""
autostart_file = self._get_autostart_file_path()
autostart_dir = os.path.dirname(autostart_file)
if not os.path.isdir(autostart_dir):
# Create autostart directory.
try:
os.mkdir(autostart_dir)
except OSError:
print ('creation of autostart dir failed, please make it '
'yourself: %s') % autostart_dir
self.exit()
if not os.path.isfile(autostart_file):
#create autostart entry
starter_item = DesktopEntry(autostart_file)
starter_item.set('Name', 'f.lux indicator applet')
starter_item.set('Exec', 'fluxgui')
starter_item.set('Icon', 'fluxgui')
starter_item.set('X-GNOME-Autostart-enabled', 'true')
starter_item.write()
def on_add_new_custom_dialog_response(self, dialog, response_id):
"""
Fired when the user triggered a response on the add_new_custom_dialog.
"""
# Clunky way to see if we have edit mode, but it works
on_edit = dialog.get_widget_for_response(Gtk.ResponseType.NO).props.visible
if not on_edit and response_id == Gtk.ResponseType.OK:
# Obtain a working filename
directory = os.path.expanduser("~/.config/autostart")
if not os.path.exists(directory):
os.makedirs(directory)
filename = os.path.join(
directory,
self.objects.custom_name.get_text().lower().replace(" ","-") + ".custom%s.desktop" %
(random.randint(0,1000),)
)
if os.path.exists(filename):
return on_add_new_custom_dialog_response(dialog, response_id)
desktop_basename = os.path.basename(filename)
entry = DesktopEntry(filename)
entry.set("Version", 1.0)
entry.set("Name", self.objects.custom_name.get_text())
entry.set("Exec", self.objects.custom_command.get_text())
entry.set("X-Vera-Autostart-Phase", "Other")
entry.write()
row = ApplicationRow(desktop_basename, entry)
# Connect the changed signal
row.connect("changed", self.on_row_changed)
# Connect the requests_edit signal
row.connect("requests_edit", self.on_row_requests_edit)
# Prepend the row
self.objects.list.prepend(row)
self.desktop_list.append(desktop_basename)
elif on_edit and response_id == Gtk.ResponseType.OK:
# Edit
self.current_edit_informations["desktop"].set("Name", self.objects.custom_name.get_text(), locale=True)
self.current_edit_informations["desktop"].set("Exec", self.objects.custom_command.get_text())
self.current_edit_informations["desktop"].write()
self.current_edit_informations["row"].name.set_text(self.objects.custom_name.get_text())
elif on_edit and response_id == Gtk.ResponseType.NO:
# Remove
# Cleanup the entry from the ignore list by ensuring that
# it's enabled in its last moments...
self.on_row_changed(
self.current_edit_informations["row"],
os.path.basename(self.current_edit_informations["desktop"].filename),
True
)
# Finally, remove
os.remove(self.current_edit_informations["desktop"].filename)
self.current_edit_informations["row"].destroy()
# Hide
dialog.hide()
# Cleanup
self.objects.custom_name.set_text("")
self.objects.custom_command.set_text("")
self.current_edit_informations = {}
class MenuEntry:
"Wrapper for 'Menu Style' Desktop Entries"
def __init__(self, filename, dir="", prefix=""):
# Create entry
self.DesktopEntry = DesktopEntry(os.path.join(dir,filename))
self.setAttributes(filename, dir, prefix)
# Can be one of Deleted/Hidden/Empty/NotShowIn/NoExec or True
self.Show = True
# Semi-Private
self.Original = None
self.Parents = []
# Private Stuff
self.Allocated = False
self.Add = False
self.MatchedInclude = False
# Caching
self.Categories = self.DesktopEntry.getCategories()
def save(self):
"""Save any changes to the desktop entry."""
if self.DesktopEntry.tainted == True:
self.DesktopEntry.write()
def getDir(self):
"""Return the directory containing the desktop entry file."""
return self.DesktopEntry.filename.replace(self.Filename, '')
def getType(self):
"""Return the type of MenuEntry, System/User/Both"""
if xdg.Config.root_mode == False:
if self.Original:
return "Both"
elif xdg_data_dirs[0] in self.DesktopEntry.filename:
return "User"
else:
return "System"
else:
return "User"
def setAttributes(self, filename, dir="", prefix=""):
self.Filename = filename
self.Prefix = prefix
self.DesktopFileID = os.path.join(prefix,filename).replace("/", "-")
if not os.path.isabs(self.DesktopEntry.filename):
self.__setFilename()
def updateAttributes(self):
if self.getType() == "System":
self.Original = MenuEntry(self.Filename, self.getDir(), self.Prefix)
self.__setFilename()
def __setFilename(self):
if xdg.Config.root_mode == False:
path = xdg_data_dirs[0]
else:
path= xdg_data_dirs[1]
if self.DesktopEntry.getType() == "Application":
dir = os.path.join(path, "applications")
else:
dir = os.path.join(path, "desktop-directories")
self.DesktopEntry.filename = os.path.join(dir, self.Filename)
def __cmp__(self, other):
return locale.strcoll(self.DesktopEntry.getName(), other.DesktopEntry.getName())
def _key(self):
"""Key function for locale-aware sorting."""
return _strxfrm(self.DesktopEntry.getName())
def __lt__(self, other):
try:
other = other._key()
except AttributeError:
pass
return self._key() < other
def __eq__(self, other):
if self.DesktopFileID == str(other):
return True
else:
return False
def __repr__(self):
return self.DesktopFileID
class Autostart(gobject.GObject):
__gsignals__ = {
'changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN,)),
}
def __init__(self):
gobject.GObject.__init__(self)
self.config = Config.Config(tgcm.country_support)
# Determine the path for XDG autostart dirs
self.autofile_name = 'tgcm-%s.desktop' % tgcm.country_support
self.user_autodir = None
for foo in BaseDirectory.load_config_paths('autostart'):
if foo.startswith(os.path.expanduser('~')):
self.user_autodir = foo
else:
self.system_autodir = foo
self.__create_desktop_entry_if_necessary()
# Listen to file changes
myfile = gio.File(self.user_autofile)
self.desktopentry_monitor = myfile.monitor_file()
self.desktopentry_monitor.connect('changed', self.on_desktopentry_changed)
def __create_desktop_entry_if_necessary(self):
# Create user autostart dir if it does not exists
if self.user_autodir is None:
self.user_autodir = BaseDirectory.save_config_path('autostart')
# It it does not exists an autostart file for TGCM in userdir,
# create a copy from the global one
self.user_autofile = os.path.join(self.user_autodir, self.autofile_name)
if not os.path.exists(self.user_autofile):
autofile_path = os.path.join(self.system_autodir, self.autofile_name)
shutil.copy(autofile_path, self.user_autofile)
# Honor 'launch-startup' policy in regional-info.xml file
self.desktopentry = DesktopEntry(self.user_autofile)
is_autostart = self.config.check_policy('launch-startup')
self.set_enabled(is_autostart)
else:
self.desktopentry = DesktopEntry(self.user_autofile)
def is_enabled(self):
self.__create_desktop_entry_if_necessary()
# Check if the DesktopEntry object has an autostart attribute
if self.desktopentry.hasKey('X-GNOME-Autostart-enabled'):
is_autostart = self.desktopentry.get('X-GNOME-Autostart-enabled', \
type='boolean')
else:
is_autostart = True
if self.desktopentry.hasKey('Hidden'):
is_shown = not self.desktopentry.get('Hidden', type='boolean')
else:
is_shown = True
return is_shown and is_autostart
def set_enabled(self, value):
self.__create_desktop_entry_if_necessary()
value = str(value).lower()
self.desktopentry.set('X-GNOME-Autostart-enabled', value)
self.desktopentry.removeKey('Hidden')
self.desktopentry.write()
def on_desktopentry_changed(self, monitor, myfile, other_file, event):
if event == gio.FILE_MONITOR_EVENT_DELETED:
self.__create_desktop_entry_if_necessary()
is_enabled = self.is_enabled()
self.emit('changed', is_enabled)
language = translation.replace(".po","")
self.languages[language] = polib.pofile(os.path.join(source_dir, translation))
catalog = TranslationCatalog("./po/vera-control-center-module-updates")
# Search for desktop files
desktop_files = []
for directory, dirnames, filenames in os.walk("."):
for file_ in filenames:
if file_.endswith(".desktop"):
entry = DesktopEntry(os.path.join(directory, file_))
for key in ("Name", "Comment", "Keywords"):
try:
source = entry.get(key)
except:
continue
for lang, obj in TranslationCatalog.languages.items():
found = obj.find(source)
if found and found.msgstr != "":
# xdg's IniFile supports the locale= keyword,
# but it supports only a boolean value. The locale
# is hardcoded to the one of the current system.
# We workaround this by specifying the right key
# right now.
entry.set("%s[%s]" % (key, lang), found.msgstr)
entry.write()
class Mapping(object):
"""
An object representation of a wiican mapping.
A wiican mapping must be located in a single directory containing a file
with the wminput code, a file containing the metadata (name, description,
author, version) and an optional icon file.
"""
# Mandatory filename for the metadata file
info_filename = "info.desktop"
# Mandatory filename for the wminput config file
mapping_filename = "mapping.wminput"
def __init__(self, path=None):
"""
Builds a mapping object.
Parameters:
path - scans the path for building a mapping object if the needed files
where found. If None it builds an empty mapping. If some of the
needed files wasn't found it tries to build a mapping with the
found info.
The Mapping.info_filename and Mapping.mapping_filename class attributes
marks the requiered filenames for the metadata file and wminput config file
respectively.
The Mapping.mapping_filename file must contain wminput config file code
The Mapping.info_filename follows XDG DesktopEntry syntax.
The Mapping.info_filename contains the source of the optional associated
icon. If no icon found or no icon directive it falls back to default
icon.
There are three posibilities for icon setting:
- An absolute path where the icon it's stored
- Icon filename if it's stored in the same dir as Mapping.info_filename
- Theme-icon-name for auto-getting the icon from the icon theme
"""
self.__path = path
# Getting freedesktop definition file
self.__info = DesktopEntry()
if path and os.path.exists(os.path.join(path, Mapping.info_filename)):
self.__info.parse(os.path.join(path, Mapping.info_filename))
else:
self.__info.new(self.info_filename)
self.__info.set("Type", "Wiican Mapping")
# Getting wminput mapping file
if path and os.path.exists(os.path.join(path, Mapping.mapping_filename)):
mapping_fp = open(os.path.join(path, Mapping.mapping_filename), "r")
self.__mapping = mapping_fp.read()
mapping_fp.close()
else:
self.__mapping = ""
# Getting icon file path
icon_name = self.__info.getIcon()
if path and icon_name in os.listdir(path): # Icon included
self.set_icon(os.path.join(path, icon_name))
elif getIconPath(icon_name): # Theme icon
self.set_icon(getIconPath(icon_name))
else: # Default icon
self.set_icon(ICON_DEFAULT)
def get_path(self):
"""Returns the absolute path where the wiican mapping it's saved.
It returns None if the mapping it's not saved yet"""
return self.__path
def get_name(self):
"""Gets the name of the mapping"""
return self.__info.getName()
def set_name(self, name):
"""Sets the name for the mapping"""
self.__info.set("Name", name)
self.__info.set("Name", name, locale=True)
def get_comment(self):
"""Gets the descriptional comment"""
return self.__info.getComment()
def set_comment(self, comment):
"""Sets the descriptional comment for the mapping"""
self.__info.set("Comment", comment)
self.__info.set("Comment", comment, locale=True)
def get_icon(self):
"""
Gets the associated icon.
If no icon found or no icon directive it falls back to default icon.
"""
icon_name = self.__info.getIcon()
# Icon included
if self.__path and icon_name in os.listdir(self.__path):
return os.path.join(self.__path, icon_name)
# Theme icon
elif getIconPath(icon_name):
return getIconPath(icon_name)
# Default icon
else:
return ICON_DEFAULT
def set_icon(self, icon_path):
"""
Sets the icon for the mapping. There are three posibilities for icon
setting:
- An absolute path where the icon it's stored
- Icon filename if it's stored in the same dir as Mapping.info_filename
- Theme-icon-name for auto-getting the icon from the icon theme
"""
self.__info.set("Icon", icon_path)
def get_authors(self):
"""Gets the mapping author/s"""
return self.__info.get("X-Authors")
def set_authors(self, authors):
"""Sets the author/s for the mapping"""
self.__info.set("X-Authors", authors)
def get_version(self):
"""Gets the version of the mapping"""
return self.__info.get("X-Version")
def set_version(self, version):
"""Sets the version of the mapping"""
self.__info.set("X-Version", version)
def get_mapping(self):
"""Gets the wminput config code"""
return self.__mapping
def set_mapping(self, mapping):
"""Sets the wminput config code"""
self.__mapping = mapping
def write(self, dest_path=None):
"""
Saves the mapping object by writing the files in the mapping directory.
The metadata it's saved in Mapping.info_filename file.
The wminput config code it's saved in Mapping.mapping_filename file.
The associated icon it's copied to the mapping directory.
"""
if not dest_path:
if not self.__path:
raise MappingError, _("No path provided for writing mapping")
dest_path = self.__path
elif not os.path.exists(dest_path):
os.mkdir(dest_path)
icon_path = self.get_icon()
icon_filename = os.path.basename(icon_path)
if not icon_path == os.path.join(dest_path, icon_filename):
shutil.copy(icon_path, dest_path)
self.set_icon(icon_filename)
self.__info.write(os.path.join(dest_path, Mapping.info_filename))
mapping_fp = open(os.path.join(dest_path, Mapping.mapping_filename), "w")
mapping_fp.write(self.__mapping)
mapping_fp.close()
# Clean not useful files
for item in [
x
for x in os.listdir(dest_path)
if not x in [Mapping.info_filename, Mapping.mapping_filename, icon_filename]
]:
os.unlink(os.path.join(dest_path, item))
self.__path = dest_path
def __repr__(self):
return "Mapping <" + self.__info.get("Name", locale=False) + " " + str(self.__info.getVersion()) + ">"
class Autostart(gobject.GObject):
__gsignals__ = {
'changed':
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN, )),
}
def __init__(self):
gobject.GObject.__init__(self)
self.config = Config.Config(tgcm.country_support)
# Determine the path for XDG autostart dirs
self.autofile_name = 'tgcm-%s.desktop' % tgcm.country_support
self.user_autodir = None
for foo in BaseDirectory.load_config_paths('autostart'):
if foo.startswith(os.path.expanduser('~')):
self.user_autodir = foo
else:
self.system_autodir = foo
self.__create_desktop_entry_if_necessary()
# Listen to file changes
myfile = gio.File(self.user_autofile)
self.desktopentry_monitor = myfile.monitor_file()
self.desktopentry_monitor.connect('changed',
self.on_desktopentry_changed)
def __create_desktop_entry_if_necessary(self):
# Create user autostart dir if it does not exists
if self.user_autodir is None:
self.user_autodir = BaseDirectory.save_config_path('autostart')
# It it does not exists an autostart file for TGCM in userdir,
# create a copy from the global one
self.user_autofile = os.path.join(self.user_autodir,
self.autofile_name)
if not os.path.exists(self.user_autofile):
autofile_path = os.path.join(self.system_autodir,
self.autofile_name)
shutil.copy(autofile_path, self.user_autofile)
# Honor 'launch-startup' policy in regional-info.xml file
self.desktopentry = DesktopEntry(self.user_autofile)
is_autostart = self.config.check_policy('launch-startup')
self.set_enabled(is_autostart)
else:
self.desktopentry = DesktopEntry(self.user_autofile)
def is_enabled(self):
self.__create_desktop_entry_if_necessary()
# Check if the DesktopEntry object has an autostart attribute
if self.desktopentry.hasKey('X-GNOME-Autostart-enabled'):
is_autostart = self.desktopentry.get('X-GNOME-Autostart-enabled', \
type='boolean')
else:
is_autostart = True
if self.desktopentry.hasKey('Hidden'):
is_shown = not self.desktopentry.get('Hidden', type='boolean')
else:
is_shown = True
return is_shown and is_autostart
def set_enabled(self, value):
self.__create_desktop_entry_if_necessary()
value = str(value).lower()
self.desktopentry.set('X-GNOME-Autostart-enabled', value)
self.desktopentry.removeKey('Hidden')
self.desktopentry.write()
def on_desktopentry_changed(self, monitor, myfile, other_file, event):
if event == gio.FILE_MONITOR_EVENT_DELETED:
self.__create_desktop_entry_if_necessary()
is_enabled = self.is_enabled()
self.emit('changed', is_enabled)
os.path.join(source_dir, translation))
catalog = TranslationCatalog("./po/vera-control-center")
# Search for desktop files
desktop_files = []
for directory, dirnames, filenames in os.walk("."):
for file_ in filenames:
if file_.endswith(".desktop"):
entry = DesktopEntry(os.path.join(directory, file_))
for key in ("Name", "Comment", "Keywords"):
try:
source = entry.get(key)
except:
continue
for lang, obj in TranslationCatalog.languages.items():
found = obj.find(source)
if found and found.msgstr != "":
# xdg's IniFile supports the locale= keyword,
# but it supports only a boolean value. The locale
# is hardcoded to the one of the current system.
# We workaround this by specifying the right key
# right now.
entry.set("%s[%s]" % (key, lang), found.msgstr)
entry.write()
def on_add_new_custom_dialog_response(self, dialog, response_id):
"""
Fired when the user triggered a response on the add_new_custom_dialog.
"""
# Clunky way to see if we have edit mode, but it works
on_edit = dialog.get_widget_for_response(
Gtk.ResponseType.NO).props.visible
if not on_edit and response_id == Gtk.ResponseType.OK:
# Obtain a working filename
directory = os.path.expanduser("~/.config/autostart")
if not os.path.exists(directory):
os.makedirs(directory)
filename = os.path.join(
directory,
self.objects.custom_name.get_text().lower().replace(" ", "-") +
".custom%s.desktop" % (random.randint(0, 1000), ))
if os.path.exists(filename):
return on_add_new_custom_dialog_response(dialog, response_id)
desktop_basename = os.path.basename(filename)
entry = DesktopEntry(filename)
entry.set("Version", 1.0)
entry.set("Name", self.objects.custom_name.get_text())
entry.set("Exec", self.objects.custom_command.get_text())
entry.set("X-Vera-Autostart-Phase", "Other")
entry.write()
row = ApplicationRow(desktop_basename, entry)
# Connect the changed signal
row.connect("changed", self.on_row_changed)
# Connect the requests_edit signal
row.connect("requests_edit", self.on_row_requests_edit)
# Prepend the row
self.objects.list.prepend(row)
self.desktop_list.append(desktop_basename)
elif on_edit and response_id == Gtk.ResponseType.OK:
# Edit
self.current_edit_informations["desktop"].set(
"Name", self.objects.custom_name.get_text(), locale=True)
self.current_edit_informations["desktop"].set(
"Exec", self.objects.custom_command.get_text())
self.current_edit_informations["desktop"].write()
self.current_edit_informations["row"].name.set_text(
self.objects.custom_name.get_text())
elif on_edit and response_id == Gtk.ResponseType.NO:
# Remove
# Cleanup the entry from the ignore list by ensuring that
# it's enabled in its last moments...
self.on_row_changed(
self.current_edit_informations["row"],
os.path.basename(
self.current_edit_informations["desktop"].filename), True)
# Finally, remove
os.remove(self.current_edit_informations["desktop"].filename)
self.current_edit_informations["row"].destroy()
# Hide
dialog.hide()
# Cleanup
self.objects.custom_name.set_text("")
self.objects.custom_command.set_text("")
self.current_edit_informations = {}
