Example #1
0
class PackageInfo:
    DESKTOP_DIR = '/usr/share/app-install/desktop/'

    def __init__(self, name):
        self.name = name
        self.pkg = PACKAGE_WORKER.get_cache()[name]
        self.desktopentry = DesktopEntry(self.DESKTOP_DIR + name + '.desktop')

    def check_installed(self):
        return self.pkg.isInstalled

    def get_comment(self):
        return self.desktopentry.getComment()

    def get_name(self):
        appname = self.desktopentry.getName()
        if appname == '':
            return self.name.title()

        return appname

    def get_version(self):
        try:
            return self.pkg.versions[0].version
        except:
            return ''
Example #2
0
 def test_present(self):
     with io.open(self.test_file, "w", encoding='utf-8') as f:
         f.write(resources.python_desktop)
     
     entry = DesktopEntry(self.test_file)
     res = entry.findTryExec()
     assert res, repr(res)
Example #3
0
def load_desktop_sessions():
    xsessions_dir = "%s/share/xsessions" % sys.prefix
    if not os.path.exists(xsessions_dir) or not os.path.isdir(xsessions_dir):
        return {}
    xsessions = {}
    with IconLoadingContext():
        from xdg.DesktopEntry import DesktopEntry
        for f in os.listdir(xsessions_dir):
            filename = os.path.join(xsessions_dir, f)
            de = DesktopEntry(filename)
            try:
                entry = load_xdg_entry(de)
                if not entry:
                    continue
                name = de.getName()
                if not entry.get("IconData"):
                    names = get_icon_names_for_session(name.lower())
                    v = find_icon(*names)
                    if v:
                        entry["IconData"] = v[0]
                        entry["IconType"] = v[1]
                xsessions[name] = entry
            except Exception as e:
                log("load_desktop_sessions(%s)", remove_icons, exc_info=True)
                log.error("Error loading desktop entry '%s':", filename)
                log.error(" %s", e)
    return xsessions
Example #4
0
 def __new__(cls, desk):
     desk = DesktopEntry(str(a))
     name = desk.getName()
     icon = getIconPath(desk.getIcon())
     exe = shlex.split(re.sub('%[fFuUdDnNickvm]', '', desk.getExec()))
     launch = partial(QProcess.startDetached, exe[0], exe[1:])
     return super().__new__(cls, name, icon, launch)
Example #5
0
def main(argv):
    args = parse_args(argv[1:])

    if args.list_dirs:
        for directory in xdg_data_dirs:
            print(os.path.join(directory, "applications"))
    elif args.list_files:
        for directory in xdg_data_dirs:
            path = os.path.join(directory, "applications")
            try:
                for entry in os.listdir(path):
                    if entry.endswith(".desktop"):
                        if args.verbose:
                            filename = os.path.join(path, entry)
                            desktop = DesktopEntry(filename)
                            print("{:70}  {:40}  {:40}".format(
                                filename, desktop.getName(),
                                desktop.getExec()))
                        else:
                            print(os.path.join(path, entry))
            except FileNotFoundError:
                pass
    else:
        filename = get_desktop_file(args.DESKTOP)
        print(filename)
        desktop = DesktopEntry(filename)
        print("Name: {}".format(desktop.getName()))
        print("Exec: {}".format(desktop.getExec()))
        print("TryExec: {}".format(desktop.getTryExec()))
        print("Mime-Types: {}".format(desktop.getMimeTypes()))
Example #6
0
def load_desktop_entry_with_dropins(filename, dropins):
    desktop_entry = DesktopEntry(filename)
    for dropin in dropins:
        dropin_entry = DesktopEntry(dropin)
        for group_name, group in dropin_entry.content.items():
            desktop_entry.content.setdefault(group_name, {}).update(group)
    return desktop_entry
Example #7
0
 def test_basic(self):
     entry = DesktopEntry(self.test_file)
     assert entry.hasKey("Categories")
     assert not entry.hasKey("TryExec")
     
     assert entry.hasGroup("Desktop Action Window")
     assert not entry.hasGroup("Desktop Action Door")
Example #8
0
 def launch_desktop(self, request, handler, desktop):
     entry = DesktopEntry()
     entry.parse(desktop)
     exec_ = entry.getExec()
     self.launch(
         request, handler, '/bin/bash -c "%s"' % exec_.replace('"', '\\"')
     )  # Is it really necessary to call bash ?
Example #9
0
    def init(self, info, progress):
        """
        If needed, perform long initialisation tasks here.

        info is a dictionary with useful information.  Currently it contains
        the following values:

          "values": a dict mapping index mnemonics to index numbers

        The progress indicator can be used to report progress.
        """

        # Read the value indexes we will use
        values = info['values']
        self.val_popcon = values.get("app-popcon", -1)

        self.indexers = [Indexer(lang, self.val_popcon, progress) for lang in [None] + list(self.langs)]
        self.entries = {}

        progress.begin("Reading .desktop files from %s" % APPINSTALLDIR)
        for f in os.listdir(APPINSTALLDIR):
            if f[0] == '.' or not f.endswith(".desktop"): continue
            entry = DesktopEntry(os.path.join(APPINSTALLDIR, f))
            pkg = entry.get("X-AppInstall-Package")
            self.entries.setdefault(pkg, []).append((f, entry))
        progress.end()
Example #10
0
 def __init__(self, filename):
     DesktopEntry.__init__(self, filename)
     log.debug('NewDesktopEntry: %s' % filename)
     if self.get(self.shortcuts_key):
         self.mode = self.shortcuts_key
     else:
         self.mode = self.actions_key
Example #11
0
    def test_present(self):
        with io.open(self.test_file, "w", encoding='utf-8') as f:
            f.write(resources.python_desktop)

        entry = DesktopEntry(self.test_file)
        res = entry.findTryExec()
        assert res, repr(res)
Example #12
0
    def test_absent(self):
        with io.open(self.test_file, "w", encoding='utf-8') as f:
            f.write(resources.unicode_desktop)

        entry = DesktopEntry(self.test_file)
        res = entry.findTryExec()
        assert res is None, repr(res)
Example #13
0
    def init(self, info, progress):
        """
        If needed, perform long initialisation tasks here.

        info is a dictionary with useful information.  Currently it contains
        the following values:

          "values": a dict mapping index mnemonics to index numbers

        The progress indicator can be used to report progress.
        """

        # Read the value indexes we will use
        values = info["values"]
        self.val_popcon = values.get("app-popcon", -1)

        self.indexers = [Indexer(lang, self.val_popcon, progress) for lang in [None] + list(self.langs)]
        self.entries = {}

        progress.begin("Reading .desktop files from %s" % APPINSTALLDIR)
        for f in os.listdir(APPINSTALLDIR):
            if f[0] == "." or not f.endswith(".desktop"):
                continue
            entry = DesktopEntry(os.path.join(APPINSTALLDIR, f))
            pkg = entry.get("X-AppInstall-Package")
            self.entries.setdefault(pkg, []).append((f, entry))
        progress.end()
Example #14
0
def parse_to_entries(file_name):
	if file_name.endswith('.menu'):
		return xdg.Menu.parse(file_name)
	else:
		result = DesktopEntry()
		result.parse(file_name)
		return result
    def add_applications(self):
        """
		Populates the self.objects.list ListBox with the applications
		in SEARCH_PATH.
		"""

        for path in SEARCH_PATH:

            if not os.path.exists(path): continue

            for application in os.listdir(path):

                # Add the application, if we can
                try:
                    entry = DesktopEntry(os.path.join(path, application))
                    if not "KDE" in entry.getOnlyShowIn(
                    ) and not application in self.desktop_list:

                        # While excluding only KDE is not ideal, we do so
                        # to have consistency with vera's AutostartManager.
                        # This check is obviously a FIXME.

                        row = ApplicationRow(application, 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)

                        GObject.idle_add(self.objects.list.insert, row, -1)

                        self.desktop_list.append(application)
                except:
                    print("Unable to show informations for %s." % application)
Example #16
0
 def ShowAll(self):#elenca tutti i file nelle 4 cartelle di autostart
     autolist = []
     
     path = self.user_autostart
     for file_name in os.listdir(path):
         myitem = DesktopEntry(path + '/' + file_name)
         #print(path + '/' + file_name)
         a = DeskStruct()
         a.Name = myitem.getName()
         a.Exec = myitem.getExec()
         a.Icon = myitem.getIcon()
         a.Comment = myitem.getComment()
         autolist.append(a) #lista di oggetti Deskstruct
           
     
     #path=self.xdg_autostart
     #autolist.append('     XDG files')
     #for file_name in os.listdir(path):
     #    autolist.append(path+'/'+file_name)
     #
     #path=self.sys_autostart
     #autolist.append('     Sys Files')
     #for file_name in os.listdir(path):
     #    autolist.append(path+'/'+file_name)
     #path=self.gdm_autostart
     #autolist.append('     GDM files')
     #for file_name in os.listdir(path):
     #    autolist.append(path+'/'+file_name)
     return autolist
    def _extract_desktop_entry(self, app):
        '''Get DesktopEntry for desktop file and verify it'''
        d = self.manifest['hooks'][app]['desktop']
        fn = os.path.join(self.unpack_dir, d)

        bn = os.path.basename(fn)
        if not os.path.exists(fn):
            error("Could not find '%s'" % bn)

        fh = open_file_read(fn)
        contents = ""
        for line in fh.readlines():
            contents += line
        fh.close()

        try:
            de = DesktopEntry(fn)
        except xdgParsingError as e:
            error("desktop file unparseable: %s (%s):\n%s" %
                  (bn, str(e), contents))
        try:
            de.parse(fn)
        except Exception as e:
            error("desktop file unparseable: %s (%s):\n%s" %
                  (bn, str(e), contents))
        return de, fn
Example #18
0
def parse_to_entries(file_name):
    if file_name.endswith('.menu'):
        return xdg.Menu.parse(file_name)
    else:
        result = DesktopEntry()
        result.parse(file_name)
        return result
Example #19
0
 def launch_desktop(self, request, handler, desktop):
     entry = DesktopEntry()
     entry.parse(desktop)
     exec_ = entry.getExec()
     self.launch(
         request, handler, '/bin/bash -c "%s"' %
         exec_.replace('"', '\\"'))  # Is it really necessary to call bash ?
Example #20
0
    def desktop(self):
        '''
        Returns desktop file object which may be written to disk.
        '''
        self.desktop_file = DesktopEntry()
        self.desktop_file.addGroup('Desktop Entry')

        if self.type == TargetType.URL:
            self.desktop_file.set('Type', 'Link')
        else:
            self.desktop_file.set('Type', 'Application')

        self.desktop_file.set('Version', '1.0')
        self.desktop_file.set('Name', self.name)

        if self.type == TargetType.URL:
            self.desktop_file.set('URL', self.path)
        else:
            self.desktop_file.set('Terminal', 'false')
            self.desktop_file.set('Exec',
                                  '{} {}'.format(self.path, self.arguments))

        if self.icon:
            self.desktop_file.set('Icon', self.icon)

        return self.desktop_file
Example #21
0
class PackageInfo:
    DESKTOP_DIR = '/usr/share/app-install/desktop/'

    def __init__(self, name):
        self.name = name
        self.pkg = AptWorker.get_cache()[name]
        self.desktopentry = DesktopEntry(self.DESKTOP_DIR + name + '.desktop')

    def check_installed(self):
        return self.pkg.isInstalled

    def get_comment(self):
        return self.desktopentry.getComment()

    def get_name(self):
        appname = self.desktopentry.getName()
        if appname == '':
            return self.name.title()

        return appname

    def get_version(self):
        try:
            return self.pkg.versions[0].version
        except:
            return ''
Example #22
0
 def test_absent(self):
     with io.open(self.test_file, "w", encoding='utf-8') as f:
         f.write(resources.unicode_desktop)
     
     entry = DesktopEntry(self.test_file)
     res = entry.findTryExec()
     assert res is None, repr(res)
Example #23
0
    def run(self, term):
        data = []
        for file in os.listdir("/usr/share/applications"):
            if file.endswith(".desktop"):
                entry = DesktopEntry(
                    os.path.join("/usr/share/applications", file))
                data.append(Datum(entry.getName(), entry.getComment()))

        return [datum for datum in data if term in datum.title]
Example #24
0
def get_desktop_entry(desktop_file):
    if os.path.isabs(desktop_file):
        return DesktopEntry(desktop_file)
    else:
        filename = get_desktop_file(desktop_file)
        if filename is not None:
            return DesktopEntry(filename)
        else:
            return None
Example #25
0
 def get_autostart(self):
     if os.path.exists(self.autostart_desktop):
         desktop_entry = DesktopEntry(self.autostart_desktop)
         return not desktop_entry.getHidden()
     elif os.path.exists(self.sys_autostart_desktop):
         desktop_entry = DesktopEntry(self.sys_autostart_desktop)
         return not desktop_entry.getHidden()
     else:
         return False
Example #26
0
    def __init__(self, parent=None, **kwargs):
        super(LaunchButton, self).__init__(parent)
        self.setObjectName("LaunchButton")
        self.launcher_size = kwargs.get("launcher_size")
        self.icon_size = kwargs.get("icon_size")
        self.name, self.comment, self.icon, self.command = None, None, None, None

        # Load in details from a .desktop file, if there is one.
        if kwargs.get("desktop_file"):
            de = DesktopEntry(kwargs.get("desktop_file"))
            self.name = de.getName()
            self.comment = de.getComment()
            self.icon = de.getIcon()
            self.command = de.getExec()

        # This allows for overriding the settings in DesktopEntry
        self.name = kwargs.get("name", self.name)
        self.comment = kwargs.get("comment", self.comment)
        self.icon = kwargs.get("icon", self.icon)
        self.command =  kwargs.get("command", self.command)

        # Create the layouts and widgets to hold the information
        toplayout = QHBoxLayout()
        leftlayout = QVBoxLayout()

        # The button's title
        title = QLabel(self.name)
        title.setObjectName("LaunchButtonTitle")
        leftlayout.addWidget(title)

        # The button's descriptive comment
        comment = QLabel(self.comment)
        comment.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        comment.setWordWrap(True)
        comment.setObjectName("LaunchButtonDescription")
        leftlayout.addWidget(comment)

        # The button's icon, if there is one
        iconpane = QLabel()
        icon = (self.icon and icon_anyway_you_can(self.icon, kwargs.get("aggressive_icon_search", False))) or QIcon()
        pixmap = icon.pixmap(*self.icon_size)
        if not pixmap.isNull():
            pixmap = pixmap.scaled(*self.icon_size)
        iconpane.setPixmap(pixmap)

        # Add everything to layouts and layouts to the button
        toplayout.addWidget(iconpane)
        toplayout.addLayout(leftlayout)
        self.setLayout(toplayout)

        # Set the button's size from config.
        self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self.setMinimumSize(QSize(*self.launcher_size))

        # Connect the callback
        self.connect(self, SIGNAL("clicked()"), self.callback)
Example #27
0
def getDesktopFile(url):
    #TODO nfs??
    url = str(url[7:])
    desktop = DesktopEntry()
    try:
        desktop.parse(url)
    except (ParsingError, DuplicateGroupError, DuplicateKeyError) as e:
        print(e)
        return None
    return desktop
Example #28
0
    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()
Example #29
0
def get_browser_desktop_list():
	browsers_xdg_files = []

	for DIR in APPLICATIONS_DIRS:
		for f in DIR.iterdir():
			if not f.is_file(): continue
			try: de = DesktopEntry(f)
			except xdg.Exceptions.ParsingError: continue
			if 'WebBrowser' in de.getCategories():
				browsers_xdg_files.append(de)
	return browsers_xdg_files
Example #30
0
 def __init__(self, _file, upload_service, supported_icons, issues_list):
     if not path.exists(_file):
         raise DesktopFileNotFound
     DesktopEntry.__init__(self, filename=_file)
     self.issues_list = issues_list
     self.upload_service = upload_service
     self.desktop_file = path.basename(_file)
     self.supported_icons = supported_icons
     self.path = _file.replace(self.desktop_file, "")
     self.issue_url = None
     self.get_icon_informations()
Example #31
0
    def desktop(self, dest=None):
        '''
        Returns desktop file object which may be written to disk.
        '''
        if dest:
            self.desktop_file = DesktopEntry(dest)
        else:
            self.desktop_file = DesktopEntry()
            self.desktop_file.addGroup('Desktop Entry')
            self.desktop_file.set('Version', '1.0')
        self._update_desktop()

        return self.desktop_file
Example #32
0
    def desktop(self):
        '''
        Returns desktop file object which may be written to disk.
        '''
        self.desktop_file = DesktopEntry()
        self.desktop_file.addGroup('Desktop Entry')
        self.desktop_file.set('Type', 'Application')
        self.desktop_file.set('Version', '1.0')
        self.desktop_file.set('Terminal', 'false')
        self.desktop_file.set('Exec', '{} {}'.format(self.path,
                                                     self.arguments))
        self.desktop_file.set('Name', self.name)

        return self.desktop_file
Example #33
0
 def _get_app_list(self, directory, user):
     for root, dirs, files in os.walk(directory):
         for name in files:
             if name.endswith(".desktop"):
               
                 app_path = root + "/" + name
                 
                 # setup desktop entry to access its elements                    
                 xgd_de = DesktopEntry(app_path)
                 
                 #                    
                 self.app_entry = Desktop_Entry(
                     name,
                     xgd_de.getName( ),
                     xgd_de.getGenericName( ),
                     xgd_de.getNoDisplay( ),
                     xgd_de.getHidden( ),
                     xgd_de.getOnlyShowIn( ),
                     xgd_de.getNotShowIn( ),
                     xgd_de.getCategories( ),
                     app_path,
                     user,
                     False
                 )   
                  
                 # Just as a note, skip no display or hidden .desktop                    
                 if not (self.app_entry.de_nodisp or self.app_entry.de_hidden):
                     self._add_entry(self.app_entry)                        
Example #34
0
    def on_drag_data_received(self, widget, context, x, y, selection, target,
                              timestamp, box):
        droppeduris = selection.get_uris()

        # url-unquote the list, strip file:// schemes, handle .desktop-s
        pathlist = []
        app = None
        for uri in droppeduris:
            scheme, _, path, _, _ = urlsplit(uri)

            if scheme != "file":
                pathlist.append(uri)
            else:
                filename = url2pathname(path)

                desktopentry = DesktopEntry()
                try:
                    desktopentry.parse(filename)
                except xdg.Exceptions.ParsingError:
                    pathlist.append(filename)
                    continue

                if desktopentry.getType() == 'Link':
                    pathlist.append(desktopentry.getURL())

                if desktopentry.getType() == 'Application':
                    app = desktopentry.getExec()

        if app and len(droppeduris) == 1:
            text = app
        else:
            text = str.join("", (shell_quote(path) + " " for path in pathlist))

        box.terminal.feed_child(text)
        return True
Example #35
0
 def __init__(self, stage):
  self._apps = list()
  self._rdsk = re.compile(u".*\.desktop$")
  self._icon_actor_cache = dict()
  HOME = os.getenv("HOME")
  l = list()
  l += self._get_all_desktop_files(u'/usr/share/applications')
  if HOME:
   l += self._get_all_desktop_files(os.path.join(HOME, u'.local/share/applications'))
  for f in l:
   de = DesktopEntry(f)
   if de.getType() == u"Application" and not de.getHidden():
    self._apps.append(apps_entry(stage, de))
  self._apps.sort(key=lambda x: x.name)
  pass
Example #36
0
 def __init__(self, stage):
     self._apps = list()
     self._rdsk = re.compile(u".*\.desktop$")
     self._icon_actor_cache = dict()
     HOME = os.getenv("HOME")
     l = list()
     l += self._get_all_desktop_files(u'/usr/share/applications')
     if HOME:
         l += self._get_all_desktop_files(
             os.path.join(HOME, u'.local/share/applications'))
     for f in l:
         de = DesktopEntry(f)
         if de.getType() == u"Application" and not de.getHidden():
             self._apps.append(apps_entry(stage, de))
     self._apps.sort(key=lambda x: x.name)
     pass
Example #37
0
    def test_invalid_unicode(self):
        test_file = os.path.join(self.tmpdir, "gnome-alsamixer.desktop")
        with io.open(test_file, "w", encoding='latin-1') as f:
            f.write(resources.gnome_alsamixer_desktop)

        # Just check this doesn't throw a UnicodeError.
        DesktopEntry(test_file)
Example #38
0
def _get_icon_from_desktop_file(
        workdir: str, desktop_file_paths: List[str]) -> Optional[str]:
    # Icons in the desktop file can be either a full path to the icon file, or a name
    # to be searched in the standard locations. If the path is specified, use that,
    # otherwise look for the icon in the hicolor theme (also covers icon type="stock").
    # See https://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
    # for further information.
    for path in desktop_file_paths:
        entry = DesktopEntry()
        entry.parse(os.path.join(workdir, path))
        icon = entry.getIcon()
        icon_path = (icon if os.path.isabs(icon) else _get_icon_from_theme(
            workdir, "hicolor", icon))
        return icon_path

    return None
Example #39
0
    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()
Example #40
0
    def __create_model(self, all=False, comment=False):
        model = self.get_model()
        model.clear()

        allitems = []
        allitems.extend(self.useritems)
        allitems.extend(self.systemitems)

        for item in allitems:
            try:
                desktopentry = DesktopEntry(item)
            except:
                continue

            if desktopentry.get("Hidden"):
                if not all:
                    continue
            iter = model.append()
            enable = desktopentry.get("X-GNOME-Autostart-enabled")
            if enable == "false":
                enable = False
            else:
                enable = True

            iconname = desktopentry.get('Icon', locale=False)
            if not iconname:
                iconname = desktopentry.get('Name', locale=False)
                if not iconname:
                    iconname = desktopentry.getName()

            pixbuf = icon.get_from_name(iconname, size=32)

            try:
                name = desktopentry.getName()
            except:
                name = desktopentry.get('Name', locale=False)

            if comment:
                comment = desktopentry.getComment()
                if not comment:
                    comment = _("No description")
                description = "<b>%s</b>\n%s" % (name, comment)
            else:
                description = "<b>%s</b>" % name

            model.set(iter, COLUMN_ACTIVE, enable, COLUMN_ICON, pixbuf,
                      COLUMN_PROGRAM, description, COLUMN_PATH, item)
Example #41
0
 def populate_command(self):
     log("populate_command()")
     self.command_combo.get_model().clear()
     if self.xsessions is None:
         assert xdg
         from xdg.DesktopEntry import DesktopEntry
         xsessions_dir = "%s/share/xsessions" % sys.prefix
         self.xsessions = {}
         if os.path.exists(xsessions_dir):
             for f in os.listdir(xsessions_dir):
                 filename = os.path.join(xsessions_dir, f)
                 de = DesktopEntry(filename)
                 self.xsessions[de.getName()] = de
     log("populate_command() xsessions=%s", self.xsessions)
     for name in sorted(self.xsessions.keys()):
         self.command_combo.append_text(name)
     self.command_combo.set_active(0)
Example #42
0
def get_desktop_entries():

    starts = ((os.path.expanduser('~'), 'local'), (os.sep, 'usr'))
    end = ('share', 'applications', '*.desktop')

    for start in starts:
        pattern = os.path.join(*(start + end))

        for desktop_entry in glob.iglob(pattern):
            entry = DesktopEntry(desktop_entry)
            if entry.getNoDisplay():
                continue
            if entry.getOnlyShowIn():
                continue
            if entry.getTerminal():
                continue
            yield entry
Example #43
0
def getPrograms():
    return {
        desktop.getName(): desktop
        for desktop in (DesktopEntry(dfile) for dfile in itertools.chain(
            *(glob(os.path.join(path, '*.desktop'))
              for path in BaseDirectory.load_data_paths('applications'))))
        if not desktop.getHidden()
    }
Example #44
0
def parse(desktop_file, debug_enabled):
    """
    Returns a dict if the .desktop entry should be included in the dmenu, or
    none if not applicable
    """
    application = DesktopEntry(desktop_file)
    if debug_enabled:
        eprint('PARSED: ' + desktop_file)
    if application.getHidden():
        if debug_enabled:
            eprint('HIDDEN: ' + desktop_file)
        return None
    if application.getNoDisplay():
        if debug_enabled:
            eprint('NODISPLAY: ' + desktop_file)
        return None
    executable = application.getTryExec()
    if not executable:
        executable = application.getExec()
    if not executable:
        if debug_enabled:
            eprint('NO EXECUTABLE: ' + desktop_file)
        return None
    return {
        application.getName():
        [part for part in executable.split(' ') if not part.startswith('%')]
    }
Example #45
0
    def __create_model(self, all = False, comment = False):
        model = self.get_model()
        model.clear()

        allitems = []
        allitems.extend(self.useritems)
        allitems.extend(self.systemitems)

        for item in allitems:
            try:
                desktopentry = DesktopEntry(item)
            except:
                continue

            if desktopentry.get("Hidden"):
                if not all:
                    continue
            iter = model.append()
            enable = desktopentry.get("X-GNOME-Autostart-enabled")
            if enable == "false":
                enable = False
            else:
                enable = True
            
            iconname = desktopentry.get('Icon', locale = False)
            if not iconname:
               iconname = desktopentry.get('Name', locale = False)
               if not iconname:
                   iconname = desktopentry.getName()

            icon = get_icon_with_name(iconname, 32)

            try:
                name = desktopentry.getName()
            except:
                name = desktopentry.get('Name', locale=False)

            if comment:
                comment = desktopentry.getComment()
                if not comment:
                    comment = _("No description")
                description = "<b>%s</b>\n%s" % (name, comment)
            else:
                description = "<b>%s</b>" % name

            model.set(iter,
                      COLUMN_ACTIVE, enable,
                      COLUMN_ICON, icon,
                      COLUMN_PROGRAM, description,
                      COLUMN_PATH, item)
Example #46
0
    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)
Example #47
0
    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())
Example #48
0
    def _populate(self):
        for item in self.EDITORS:
            if os.path.isfile(item):
                args = self.EDITORS[item]
                desktop_entry = DesktopEntry(item)
                command = desktop_entry.getExec()

                # For .desktop files with ' %U' or ' # %F'
                command = command.split(" ")[0]

                name = desktop_entry.getName()
                icon_name = desktop_entry.getIcon()

                self._add_item(icon_name, name, command, args)

        if len(self.get_model()):
            self.empty = False
        else:
            self.empty = True
Example #49
0
    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)
Example #50
0
class PackageInfo:
    DESKTOP_DIR = "/usr/share/app-install/desktop/"

    def __init__(self, name):
        self.name = name
        self.pkg = cache[name]
        self.desktopentry = DesktopEntry(self.DESKTOP_DIR + name + ".desktop")

    def check_installed(self):
        return self.pkg.isInstalled

    def get_comment(self):
        return self.desktopentry.getComment()

    def get_name(self):
        appname = self.desktopentry.getName()
        if appname == "":
            return self.name.title()

        return appname
Example #51
0
class PackageInfo:
    DESKTOP_DIR = '/usr/share/app-install/desktop/'

    def __init__(self, name):
        self.name = name
        self.pkg = package_worker.get_cache()[name]
        self.desktopentry = DesktopEntry(self.DESKTOP_DIR + name + '.desktop')

    def check_installed(self):
        return self.pkg.isInstalled

    def get_comment(self):
        return self.desktopentry.getComment()

    def get_name(self):
        appname = self.desktopentry.getName()
        if appname == '':
            return self.name.title()

        return appname
Example #52
0
    def verify_desktop_files(self, problems):
        desktop_dir = self._relative('batis_info', 'desktop')
        if not os.path.exists(desktop_dir):
            # This is fine, it's optional
            return

        if not os.path.isdir(desktop_dir):
            problems.append('batis_info/desktop should be a directory')
            return

        for name in os.listdir(desktop_dir):
            if os.path.splitext(name)[1] != '.desktop':
                problems.append('Non .desktop file in batis_info/desktop: %r' % name)
            else:
                path = os.path.join(desktop_dir, name)
                try:
                    de = DesktopEntry(path)
                    de.validate()
                except (IniFile.ParsingError, IniFile.ValidationError) as e:
                    problems.append('Invalid desktop entry file (%s):\n%s'
                                        % (path, e))
Example #53
0
def addDesktopEntry(file):
    entry=DesktopEntry()
    try:
        entry.parse(file)
    except:
        return
    if entry.getNoDisplay():
        return
    tryexec=entry.getTryExec()
    if tryexec and not os.path.exists(tryexec):
        return

    entry.setLocale("C")
    display_name=entry.getName()
    catalog.insertEntry(file, display_name, run)
Example #54
0
    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 add_applications(self):
		"""
		Populates the self.objects.list ListBox with the applications
		in SEARCH_PATH.
		"""
		
		for path in SEARCH_PATH:
			
			if not os.path.exists(path): continue
			
			for application in os.listdir(path):
				
				# Add the application, if we can
				try:
					entry = DesktopEntry(os.path.join(path, application))
					if not "KDE" in entry.getOnlyShowIn() and not application in self.desktop_list:
						
						# While excluding only KDE is not ideal, we do so
						# to have consistency with vera's AutostartManager.
						# This check is obviously a FIXME.
						
						row = ApplicationRow(application, 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)
						
						GObject.idle_add(self.objects.list.insert,
							row,
							-1
						)
						
						self.desktop_list.append(application)
				except:
					print("Unable to show informations for %s." % application)
Example #56
0
    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()
Example #57
0
    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()
Example #58
0
    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()