Python DesktopEntry.DesktopEntry类代码示例

 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 ?

 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)

 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)

 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)

 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

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

 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

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 ''

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

 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

    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)

    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 _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)                        

 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

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