Beispiel #1
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()))
Beispiel #2
0
    def _find_pdf_viewers(self):
        pdf_viewers = {}
        if platform.system() == "Linux":
            # Find all .desktop files
            for search_path in [
                    "/usr/share/applications",
                    "/usr/local/share/applications",
                    os.path.expanduser("~/.local/share/applications"),
            ]:
                try:
                    for filename in os.listdir(search_path):
                        full_filename = os.path.join(search_path, filename)
                        if os.path.splitext(filename)[1] == ".desktop":

                            # See which ones can open PDFs
                            desktop_entry = DesktopEntry(full_filename)
                            if ("application/pdf"
                                    in desktop_entry.getMimeTypes() and
                                    desktop_entry.getName() != "dangerzone"):
                                pdf_viewers[desktop_entry.getName(
                                )] = desktop_entry.getExec()

                except FileNotFoundError:
                    pass

        return pdf_viewers
Beispiel #3
0
    def from_dotdesktop(cls, app_def: Path,
                        distro: WSLDistro) -> Optional[WSLApp]:
        """
        Return a WSLApp from a .desktop file.

        Args:
            app_def: .desktop file path
        """
        de = DesktopEntry(app_def)
        name = de.getName()
        generic_name = de.getGenericName()
        cmd = de.getExec()
        gui = not de.getTerminal()
        icon = de.getIcon()
        if name:
            return cls(name, generic_name, cmd, gui, icon)
        else:
            # This is a symlink
            linux_path = str(app_def)[str(app_def).index(r"\\wsl$") + 7:]
            linux_path = linux_path[linux_path.index("\\"):].replace("\\", "/")
            # Turn symlink target into Windows Path
            symlink = distro.get_cmd_output(f"readlink -f -e '{linux_path}'")
            app_def = distro._unc_path_from_cmd(symlink)

            de = DesktopEntry(app_def)
            name = de.getName()
            generic_name = de.getGenericName()
            cmd = de.getExec()
            gui = not de.getTerminal()
            icon = de.getIcon()
            if name:
                return cls(name, generic_name, cmd, gui, icon)
        return None
Beispiel #4
0
    def provide(self):
        from fnmatch import fnmatch
        from xdg.DesktopEntry import DesktopEntry

        items = []

        for app_directory in map(os.path.expanduser, self.app_directories):
            for root, dirs, files in os.walk(app_directory):
                for filename in files:
                    if fnmatch(filename, "*.desktop"):
                        app_entry = DesktopEntry(os.path.join(root, filename))

                        icon_theme = Gtk.IconTheme.get_default()

                        if app_entry.getNoDisplay():
                            continue

                        if app_entry.getIcon() == "":
                            icon = Gtk.IconTheme.load_icon(icon_theme, "image-missing", self.icon_size, 0)
                        elif "/" in app_entry.getIcon():
                            try:
                                unscaled_icon = GdkPixbuf.Pixbuf.new_from_file(app_entry.getIcon())
                                icon = unscaled_icon.scale_simple(self.icon_size, self.icon_size, GdkPixbuf.InterpType.BILINEAR)
                            except:
                                icon = Gtk.IconTheme.load_icon(icon_theme, "image-missing", self.icon_size, 0)
                        else:
                            try:
                                unscaled_icon = Gtk.IconTheme.load_icon(icon_theme, app_entry.getIcon(), self.icon_size, 0)
                                icon = unscaled_icon.scale_simple(self.icon_size, self.icon_size, GdkPixbuf.InterpType.BILINEAR)
                            except:
                                icon = Gtk.IconTheme.load_icon(icon_theme, "image-missing", self.icon_size, 0)


                        words = app_entry.getName().split()
                        # words.append(app_entry.getExec())

                        command = self.escape_command(app_entry.getExec())


                        if app_entry.getTerminal():
                            command = "%s '%s'" % (self.terminal_emulator_command, command)

                        item = {
                            "indexer": self,

                            "name": app_entry.getName(),
                            "description": app_entry.getComment(),
                            "icon": icon,

                            "command": command,

                            "words": words,
                        }

                        items.append(item)

        items.sort(key=lambda i: i["name"])

        return items
Beispiel #5
0
    def _find_pdf_viewers(self):
        pdf_viewers = {}

        if platform.system() == "Darwin":
            # Get all installed apps that can open PDFs
            bundle_identifiers = LaunchServices.LSCopyAllRoleHandlersForContentType(
                "com.adobe.pdf", CoreServices.kLSRolesAll
            )
            for bundle_identifier in bundle_identifiers:
                # Get the filesystem path of the app
                res = LaunchServices.LSCopyApplicationURLsForBundleIdentifier(
                    bundle_identifier, None
                )
                if res[0] is None:
                    continue
                app_url = res[0][0]
                app_path = str(app_url.path())

                # Load its plist file
                plist_path = os.path.join(app_path, "Contents/Info.plist")

                # Skip if there's not an Info.plist
                if not os.path.exists(plist_path):
                    continue

                with open(plist_path, "rb") as f:
                    plist_data = f.read()
                plist_dict = plistlib.loads(plist_data)

                if plist_dict.get("CFBundleName") and plist_dict["CFBundleName"] != "Dangerzone":
                    pdf_viewers[plist_dict["CFBundleName"]] = bundle_identifier

        elif platform.system() == "Linux":
            # Find all .desktop files
            for search_path in [
                "/usr/share/applications",
                "/usr/local/share/applications",
                os.path.expanduser("~/.local/share/applications"),
            ]:
                try:
                    for filename in os.listdir(search_path):
                        full_filename = os.path.join(search_path, filename)
                        if os.path.splitext(filename)[1] == ".desktop":

                            # See which ones can open PDFs
                            desktop_entry = DesktopEntry(full_filename)
                            if (
                                "application/pdf" in desktop_entry.getMimeTypes()
                                and desktop_entry.getName() != "dangerzone"
                            ):
                                pdf_viewers[
                                    desktop_entry.getName()
                                ] = desktop_entry.getExec()

                except FileNotFoundError:
                    pass

        return pdf_viewers
Beispiel #6
0
    def load_dir(self, dir_path):
        for subdir, dirs, files in os.walk(dir_path):
            for desktop_file in files:
                desktop_file = subdir + "/" + desktop_file
                if desktop_file[-8:] == ".desktop":
                    entry = DesktopEntry(desktop_file)

                    if not (entry.getName() == None or entry.getName() == ""):
                        if not (entry.getExec() == None
                                or entry.getExec() == ""):
                            self.DESKTOP_ENTRIES[entry.getName()] = entry
Beispiel #7
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)
Beispiel #8
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
Beispiel #9
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
Beispiel #10
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)
Beispiel #11
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 ''
Beispiel #12
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('%')]
    }
Beispiel #13
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)                        
Beispiel #14
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 ''
 def parse_xdg(self, path):
     de = DesktopEntry(path)
     # type: popup, notify
     msg_type = de.get('X-CLIP-Msg-Type')
     # mode: info, warning, error
     msg_mode = de.get('X-CLIP-Msg-Mode')
     # content: user message
     msg_cont = de.get('X-CLIP-Msg-Content')
     cache = {'type': msg_type, 'mode': msg_mode, 'cont': msg_cont}
     if self.cache != cache:
         self.cache = cache
         if len(msg_mode) > 0 and len(msg_type) > 0 and len(msg_cont) > 0:
             if msg_type == 'popup':
                 self.popup(de.getName(), msg_cont, msg_mode)
             elif msg_type == 'notify':
                 self.notify(de.getName(), msg_cont, msg_mode)
Beispiel #16
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)
def xdg_name_and_icon(app):
    entry = DesktopEntry()
    for directory in xdg.BaseDirectory.xdg_data_dirs:
        path = os.path.join(directory, "applications", f"{app}.desktop")
        if os.path.exists(path):
            entry.parse(path)
            return entry.getName(), entry.getIcon()
    return None, None
Beispiel #18
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]
Beispiel #19
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)
Beispiel #20
0
 def test_values(self):
     entry = DesktopEntry(self.test_file)
     self.assertEqual(entry.getName(), 'gedit')
     self.assertEqual(entry.getGenericName(), 'Text Editor')
     self.assertEqual(entry.getNoDisplay(), False)
     self.assertEqual(entry.getComment(), 'Edit text files')
     self.assertEqual(entry.getIcon(), 'accessories-text-editor')
     self.assertEqual(entry.getHidden(), False)
     self.assertEqual(entry.getOnlyShowIn(), [])
     self.assertEqual(entry.getExec(), 'gedit %U')
     self.assertEqual(entry.getTerminal(), False)
     self.assertEqual(entry.getMimeTypes(), ['text/plain'])
     self.assertEqual(entry.getCategories(), ['GNOME', 'GTK', 'Utility', 'TextEditor'])
     self.assertEqual(entry.getTerminal(), False)
Beispiel #21
0
def load_desktop_sessions():
    xsessions_dir = "%s/share/xsessions" % sys.prefix
    xsessions = {}
    if os.path.exists(xsessions_dir):
        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
                if getattr(entry, "IconData", None) is None:
                    names = get_icon_names_for_session(de.getName().lower())
                    v = find_session_icon(*names)
                    if v:
                        entry["IconData"] = v[0]
                        entry["IconType"] = v[1]
                xsessions[de.getName()] = 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
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)
Beispiel #23
0
 def test_values(self):
     entry = DesktopEntry(self.test_file)
     self.assertEqual(entry.getName(), 'gedit')
     self.assertEqual(entry.getGenericName(), 'Text Editor')
     self.assertEqual(entry.getNoDisplay(), False)
     self.assertEqual(entry.getComment(), 'Edit text files')
     self.assertEqual(entry.getIcon(), 'accessories-text-editor')
     self.assertEqual(entry.getHidden(), False)
     self.assertEqual(entry.getOnlyShowIn(), [])
     self.assertEqual(entry.getExec(), 'gedit %U')
     self.assertEqual(entry.getTerminal(), False)
     self.assertEqual(entry.getMimeTypes(), ['text/plain'])
     self.assertEqual(entry.getCategories(),
                      ['GNOME', 'GTK', 'Utility', 'TextEditor'])
     self.assertEqual(entry.getTerminal(), False)
Beispiel #24
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)
Beispiel #25
0
 def add_desktop(self, filename):
     try:
         d = DesktopEntry(filename)
         if d.getHidden() or d.getNoDisplay() or d.getTerminal(
         ) or d.getType() != 'Application':
             return
         app = Application(name=d.getName(),
                           command_line=get_command(d),
                           mtime=datetime.fromtimestamp(
                               os.path.getmtime(filename)),
                           is_desktop=True)
         if d.getPath():
             app.path = d.getPath()
         self.add_app(app)
     except (xdg.Exceptions.ParsingError,
             xdg.Exceptions.DuplicateGroupError,
             xdg.Exceptions.DuplicateKeyError):
         pass
class VeraCCModule:
    """ An object representing a Vera Control Center module. """
    def __init__(self, module_name, module_path):
        """ Initialize the object """

        self.module_is_external = False
        self.module_name = module_name
        self.module_path = module_path

        self.launcher_icon = None
        self.launcher_name = None
        self.launcher_comment = None
        self.launcher_section = None

        self.module_launcher = DesktopEntry(
            os.path.join(self.module_path, "%s.desktop" % self.module_name))

        # Icon
        self.launcher_icon = self.module_launcher.getIcon()
        if not self.launcher_icon:
            self.launcher_icon = "preferences-system"

        #ICON_THEME.connect("changed", lambda x: self.replace_icon(icon))

        # Name
        self.launcher_name = self.module_launcher.getName()

        # Comment
        self.launcher_comment = self.module_launcher.getComment()

        # Section
        self.launcher_section = self.module_launcher.get("X-VeraCC-Section")

        # Keywords
        self.launcher_keywords = [
            x.lower() for x in self.module_launcher.getKeywords()
        ]

        # External?
        _exec = self.module_launcher.getExec()
        if _exec:
            # Yeah!
            self.module_is_external = True
            self.module_path = _exec
Beispiel #27
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
Beispiel #28
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
class VeraCCModule:
	""" An object representing a Vera Control Center module. """
		
	def __init__(self, module_name, module_path):
		""" Initialize the object """
				
		self.module_is_external = False
		self.module_name = module_name
		self.module_path = module_path
	
		self.launcher_icon = None
		self.launcher_name = None
		self.launcher_comment = None
		self.launcher_section = None
			
		self.module_launcher = DesktopEntry(os.path.join(self.module_path, "%s.desktop" % self.module_name))
			
		# Icon
		self.launcher_icon = self.module_launcher.getIcon()
		if not self.launcher_icon:
			self.launcher_icon = "preferences-system"

		#ICON_THEME.connect("changed", lambda x: self.replace_icon(icon))
		
		# Name
		self.launcher_name = self.module_launcher.getName()
		
		# Comment
		self.launcher_comment = self.module_launcher.getComment()
		
		# Section
		self.launcher_section = self.module_launcher.get("X-VeraCC-Section")
		
		# Keywords
		self.launcher_keywords = [x.lower() for x in self.module_launcher.getKeywords()]
		
		# External?
		_exec = self.module_launcher.getExec()
		if _exec:
			# Yeah!
			self.module_is_external = True
			self.module_path = _exec
Beispiel #30
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
Beispiel #31
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
Beispiel #32
0
    def listAndUpdateDesktopFiles(self, path, menuObjs):
        for f in listdir(path):
            fPath = path + f
            if isfile(fPath) and f.endswith(".desktop"):
                xdgObj = DesktopEntry(fPath)

                title    = xdgObj.getName()
                groups   = xdgObj.getCategories()
                comment  = xdgObj.getComment()
                icon     = xdgObj.getIcon()
                mainExec = xdgObj.getExec()
                tryExec  = xdgObj.getTryExec()

                group    = ""
                if "Accessories" in groups or "Utility" in groups:
                    group = "Accessories"
                elif "Multimedia" in groups or "Video" in groups or "Audio" in groups:
                    group = "Multimedia"
                elif "Development" in groups:
                    group = "Development"
                elif "Game" in groups:
                    group = "Game"
                elif "Internet" in groups or "Network" in groups:
                    group = "Internet"
                elif "Graphics" in groups:
                    group = "Graphics"
                elif "Office" in groups:
                    group = "Office"
                elif "System" in groups:
                    group = "System"
                elif "Settings" in groups:
                    group = "Settings"
                elif "Wine" in groups:
                    group = "Wine"
                else:
                    group = "Other"

                menuObjs[group].append( {"title":  title,   "groups": groups,
                                        "comment": comment, "exec": mainExec,
                                        "tryExec": tryExec, "fileName": f,
                                        "filePath": fPath, "icon": icon})
Beispiel #33
0
    def from_dotdesktop(app_def):
        """
        Return a WSLApp from a .desktop file.

        Args:
            app_def: .desktop file path
        """
        de = DesktopEntry(app_def)
        name = de.getName()
        generic_name = de.getGenericName()
        cmd = de.getExec()
        gui = not de.getTerminal()
        icon = de.getIcon()

        return {
            "name": name,
            "generic_name": generic_name,
            "cmd": cmd,
            "gui": gui,
            "icon": icon
        }
Beispiel #34
0
    def _generate_app_actions(self, path):
        app_actions = []
        filename_pattern = os.path.expanduser(os.path.join(
                path,
                AppsOperator.FILE_TYPE
        ))
        for filename in glob.glob(filename_pattern):
            app = DesktopEntry(filename)

            # TODO: Comply with  full DesktopEntries spec - OnlyShowIn, TryExec
            if app.getType() == "Application" and not app.getNoDisplay() and \
                    not app.getHidden() and not app.getTerminal():
                action = AppAction(
                    name=app.getName(),
                    description="application",
                    run=self._launch_application,
                    data={"desktop_entry": app, "cmd": self.get_cmd(app)},
                    icon=get_icon(app.getIcon()),
                )
                app_actions.append(action)
        return app_actions
Beispiel #35
0
    def __post_init__(self):
        if isinstance(self.icon_size, str):
            self.icon_size = utils.parse_size(self.icon_size)
        if isinstance(self.launcher_size, str):
            self.launcher_size = utils.parse_size(self.launcher_size)

        # Load in details from a .desktop file, if there is one.
        if self.desktop_file:
            try:
                de = DesktopEntry(self.desktop_file)
            except PermissionError as e:
                utils.debug(
                    "Access denied on desktop file: {}, {}"
                    .format(self.desktop_file, e)
                )
            else:
                self.name = de.getName()
                self.comment = de.getComment()
                self.icon = de.getIcon()
                self.command = de.getExec()
                self.categories = [c.lower() for c in de.getCategories()]
Beispiel #36
0
def parse_linux_desktop_entry(fpath):
    """Load data from desktop entry with xdg specification."""
    from xdg.DesktopEntry import DesktopEntry

    try:
        entry = DesktopEntry(fpath)
        entry_data = {}
        entry_data['name'] = entry.getName()
        entry_data['icon_path'] = entry.getIcon()
        entry_data['exec'] = entry.getExec()
        entry_data['type'] = entry.getType()
        entry_data['hidden'] = entry.getHidden()
        entry_data['fpath'] = fpath
    except Exception:
        entry_data = {
            'name': '',
            'icon_path': '',
            'hidden': '',
            'exec': '',
            'type': '',
            'fpath': fpath
        }

    return entry_data
Beispiel #37
0
def main(args):
    args =args[1:]
    if len(args )!=1:
        print("takes one argument")
        return
    try:
        desktop =DesktopEntry()
        desktop.parse(args[0])
    except:
        print("parse error" ,args[0])

    name =desktop.getName()
    name =''.join(lazy_pinyin(name))
    AppName=desktop.getName()
    NoDisplay=False;
    if len(AppName)==0:
        AppName=desktop.getGenericName
    AppComment=desktop.getComment()
    AppIcon=desktop.getIcon()
    if not os.path.exists(AppIcon):
        ip=getIconPath(AppIcon,theme="deepin")
        # if ip is None:
        #     ip=getIconPath(AppIcon,theme="hicolor")
    else:
        ip=AppIcon

    if ip is None:
        #TODO add defauult icon
        ip="test"
        pass
    AppIcon=ip


    NoDisplay=desktop.getNoDisplay()
    onlydi=desktop.getOnlyShowIn()

    if NoDisplay is True or len(onlydi)>0:
        AppIcon=""
        AppName=""
        AppComment=""
        NoDisplay="true"
    else:
        NoDisplay="false"




    print('''
<html><head>
<title>''' +name+
          '''</title>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" >
<meta name="AppName" content="'''+AppName+'''" />
<meta name="AppComment" content="'''+AppComment+'''" />
<meta name="AppIcon" content="'''+AppIcon+'''" />
<meta name="AppNoDisplay" content="'''+NoDisplay+'''" />

</head>
<body>
'''+AppName+'''
</body>
</html>

''')
        glob(os.path.join(path, '*.desktop'))
        for path in BaseDirectory.load_data_paths('applications')
):
    desktop = DesktopEntry(dfile)
    fname = os.path.splitext(os.path.basename(dfile))[0]

    try:
        cmd = FILTER.sub('', desktop.getExec()).split(' ', 1)
        cmd[0] = which(cmd[0])
    except ProgramNotFound:
        continue

    if desktop.getTerminal():
        cmd.insert(0, withpty)

    #service_path = os.path.join(generator_dir, fname)
    service_path = os.path.join(generator_dir, fname + "@.service")
    service = IniFile()
    service.addGroup('Unit')
    service.set('SourcePath', dfile, 'Unit')
    if not desktop.getHidden():
        service.set('X-ShowInMenu', "True", 'Unit')
    service.set('Description', desktop.getName(), 'Unit')
    service.addGroup('Service')
    service.set('EnvironmentFile', "%t/sessions/%i/environ", 'Service')
    service.set('ExecStart', " ".join(cmd), 'Service')

    service.defaultGroup = 'Unit'

    service.write(service_path)
Beispiel #39
0
 def test_unicode_name(self):
     with io.open(self.test_file, "w", encoding='utf-8') as f:
         f.write(resources.unicode_desktop)
     
     entry = DesktopEntry(self.test_file)
     self.assertEqual(entry.getName(), u('Abc€þ'))
Beispiel #40
0
    def test_unicode_name(self):
        with io.open(self.test_file, "w", encoding='utf-8') as f:
            f.write(resources.unicode_desktop)

        entry = DesktopEntry(self.test_file)
        self.assertEqual(entry.getName(), u('Abc€þ'))
Beispiel #41
0
    def __init__(self, parent=None, **kwargs):
        """Construct a LaunchButton"""
        super(LaunchButton, self).__init__(parent)
        self.setObjectName("LaunchButton")
        self.launcher_size = kwargs.get("launcher_size")
        self.icon_size = kwargs.get("icon_size")
        self.name = None
        self.comment = None
        self.icon = None
        self.command = None
        self.categories = None

        # Load in details from a .desktop file, if there is one.
        desktop_file = kwargs.get("desktop_file")
        if desktop_file:
            if os.access(desktop_file, os.R_OK):
                de = DesktopEntry(desktop_file)
                self.name = de.getName()
                self.comment = de.getComment()
                self.icon = de.getIcon()
                self.command = de.getExec()
                self.categories = [c.lower() for c in de.getCategories()]
            else:
                sys.stderr.write(
                    "Read access denied on manually-specified "
                    "desktop file {}.  Button may be missing data.\n".format(
                        desktop_file))

        # 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.clicked.connect(self.callback)
Beispiel #42
0
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
Beispiel #43
0
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()) + ">"
Beispiel #44
0
class AutostartFile:
    def __init__(self, path):
        self.path = path
        self.filename = os.path.basename(path)
        self.dirname = os.path.dirname(path)
        self.de = DesktopEntry(path)

    def __eq__(self, other):
        return self.filename == other.filename

    def __str__(self):
        return self.path + " : " + self.de.getName()

    def _isexecfile(self, path):
        return os.access(path, os.X_OK)

    def _findFile(self, path, search, match_func):
        # check empty path
        if not path:
            return None
        # check absolute path
        if path[0] == "/":
            if match_func(path):
                return path
            else:
                return None
        else:
            # check relative path
            for dirname in search.split(os.pathsep):
                if dirname != "":
                    candidate = os.path.join(dirname, path)
                    if match_func(candidate):
                        return candidate

    def _alert(self, mstr, info=False):
        if info:
            print("\t " + mstr)
        else:
            print("\t*" + mstr)

    def _showInEnvironment(self, envs, verbose=False):
        default = not self.de.getOnlyShowIn()
        noshow = False
        force = False
        for i in self.de.getOnlyShowIn():
            if i in envs:
                force = True
        for i in self.de.getNotShowIn():
            if i in envs:
                noshow = True

        if verbose:
            if not default and not force:
                s = ""
                for i in self.de.getOnlyShowIn():
                    if s:
                        s += ", "
                    s += i
                self._alert("Excluded by: OnlyShowIn (" + s + ")")
            if default and noshow and not force:
                s = ""
                for i in self.de.getNotShowIn():
                    if s:
                        s += ", "
                    s += i
                self._alert("Excluded by: NotShowIn (" + s + ")")
        return (default and not noshow) or force

    def _shouldRun(self, envs, verbose=False):
        if not self.de.getExec():
            if verbose:
                self._alert("Excluded by: Missing Exec field")
            return False
        if self.de.getHidden():
            if verbose:
                self._alert("Excluded by: Hidden")
            return False
        if self.de.getTryExec():
            if not self._findFile(self.de.getTryExec(), os.getenv("PATH"), self._isexecfile):
                if verbose:
                    self._alert("Excluded by: TryExec (" + self.de.getTryExec() + ")")
                return False
        if not self._showInEnvironment(envs, verbose):
            return False
        return True

    def display(self, envs):
        if self._shouldRun(envs):
            print("[*] " + self.de.getName())
        else:
            print("[ ] " + self.de.getName())
        self._alert("File: " + self.path, info=True)
        if self.de.getExec():
            self._alert("Executes: " + self.de.getExec(), info=True)
        self._shouldRun(envs, True)
        print

    def run(self, envs):
        here = os.getcwd()
        if self.de.getPath():
            os.chdir(self.de.getPath())
        if self._shouldRun(envs):
            args = ["/bin/sh", "-c", "exec " + self.de.getExec()]
            os.spawnv(os.P_NOWAIT, args[0], args)
        os.chdir(here)
#!/usr/bin/env python3
# Author: Juho Teperi

from xdg.BaseDirectory import load_data_paths
from xdg.DesktopEntry import DesktopEntry
from glob import glob
from re import sub
from os.path import basename

# To remove duplicates
data = {}

for d in load_data_paths("applications"):
    for app in glob(d + "/*.desktop"):
        desktop = DesktopEntry(app)
        name = desktop.getName()

        if (not desktop.getHidden() and not desktop.getNoDisplay()) and name not in data:
            data[name] = basename(app)

for name, cmd in data.items():
    print('{}\t{}'.format(name, cmd))
Beispiel #46
0
def parseMenu(menu, menuJSON):
    for submenu in menu.Entries:
      if isinstance(submenu, Menu):
          newmenu=parseMenu(submenu, []);
          #print ("Submenu icon: "+submenu.getIcon() + " is "+theme.getIconPath(submenu.getIcon()))
          iconpath=theme.getIconPath(submenu.getIcon(), None, 'Numix-Circle')
          #iconpath=theme.getIconPath(submenu.getIcon(), 128, 'future-green')
          #iconpath=theme.getIconPath(submenu.getIcon(), 128, 'Numix-Circle')
          iconpath=give_me_png(iconpath)
          
          if iconpath==None:
              iconpath=''
          print "cat icon: "+submenu.getIcon()+" is "+iconpath
          menuJSON.append({"id": unicode(submenu).replace(" ", "_"), "name":submenu.getName(), "icon":iconpath, "children":newmenu});

      elif isinstance(submenu, MenuEntry):
          # Description at
          # http://pyxdg.readthedocs.org/en/latest/_modules/xdg/DesktopEntry.html
          newitem={}
          
          filename="/usr/share/applications/"+unicode(submenu);
          item=False
          if (os.path.isfile(filename)):
            item=DesktopEntry(filename)
          else:
            # is kde4- prexifed?
            if (unicode(submenu)[0:5]=="kde4-"):
              filename="/usr/share/applications/kde4/"+unicode(submenu)[5:];
              item=DesktopEntry(filename)
            
          #print "!!"+item;
          if item is not False:
         
            newitem["id"]=unicode(submenu).replace(" ", "_")
            newitem["name"]=item.getName()
            #newitem["icon"]=item.getIcon()
            
            newitem["comment"]=item.getComment()
            newitem["tryexec"]=item.getTryExec()
            newitem["exec"]=item.getExec()
            newitem["path"]=item.getPath()
            iconpath=theme.getIconPath(item.getIcon(), 128, 'Numix-Circle')
            #iconpath=theme.getIconPath(item.getIcon(), 128, 'future-green')
            
            #iconname=item.getIcon();    # Convert png if not exists...
            #iconpath=give_me_png(iconname);
            iconpath=give_me_png(iconpath);
            
            
            if iconpath==None:
                iconpath=''
            #print "icon: "+item.getIcon()+" is "+iconpath
            #print ("Icon: "+item.getIcon() + " is "+iconpath)
            newitem["icon"]=iconpath
            #newitem["name"]=a.getName();
            #newitem["id"]=unicode(submenu)
  
            # Only Append if it's executable
  
            #if (item.findTryExec()):
            #     menuJSON.append(newitem);
            #if newitem["name"]!="":
            menuJSON.append(newitem);
          

    return menuJSON
Beispiel #47
0
    def __init__(self, parent=None, **kwargs):
        """Construct a LaunchButton"""
        super(LaunchButton, self).__init__(parent)
        self.setObjectName("LaunchButton")
        self.launcher_size = kwargs.get("launcher_size")
        self.icon_size = kwargs.get("icon_size")
        self.name = None
        self.comment = None
        self.icon = None
        self.command = None
        self.categories = None

        # Load in details from a .desktop file, if there is one.
        desktop_file = kwargs.get("desktop_file")
        if desktop_file:
            if os.access(desktop_file, os.R_OK):
                de = DesktopEntry(desktop_file)
                self.name = de.getName()
                self.comment = de.getComment()
                self.icon = de.getIcon()
                self.command = de.getExec()
                self.categories = [c.lower() for c in de.getCategories()]
            else:
                sys.stderr.write(
                    "Read access denied on manually-specified "
                    "desktop file {}.  Button may be missing data.\n"
                    .format(desktop_file))

        # 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.clicked.connect(self.callback)