--- /dev/null
+"""
+Implementation of the XDG Menu Specification Version 1.0.draft-1
+http://standards.freedesktop.org/menu-spec/
+"""
+
+from __future__ import generators
+import locale, os, xml.dom.minidom
+
+from xdg.BaseDirectory import *
+from xdg.DesktopEntry import *
+from xdg.Exceptions import *
+
+import xdg.Locale
+import xdg.Config
+
+ELEMENT_NODE = xml.dom.Node.ELEMENT_NODE
+
+# for python <= 2.3
+try:
+ reversed = reversed
+except NameError:
+ def reversed(x):
+ return x[::-1]
+
+class Menu:
+ def __init__(self):
+ # Public stuff
+ self.Name = ""
+ self.Directory = None
+ self.Entries = []
+ self.Doc = ""
+ self.Filename = ""
+ self.Depth = 0
+ self.Parent = None
+ self.NotInXml = False
+
+ # Can be one of Deleted/NoDisplay/Hidden/Empty/NotShowIn or True
+ self.Show = True
+ self.Visible = 0
+
+ # Private stuff, only needed for parsing
+ self.AppDirs = []
+ self.DefaultLayout = None
+ self.Deleted = "notset"
+ self.Directories = []
+ self.DirectoryDirs = []
+ self.Layout = None
+ self.MenuEntries = []
+ self.Moves = []
+ self.OnlyUnallocated = "notset"
+ self.Rules = []
+ self.Submenus = []
+
+ def __str__(self):
+ return self.Name
+
+ def __add__(self, other):
+ for dir in other.AppDirs:
+ self.AppDirs.append(dir)
+
+ for dir in other.DirectoryDirs:
+ self.DirectoryDirs.append(dir)
+
+ for directory in other.Directories:
+ self.Directories.append(directory)
+
+ if other.Deleted != "notset":
+ self.Deleted = other.Deleted
+
+ if other.OnlyUnallocated != "notset":
+ self.OnlyUnallocated = other.OnlyUnallocated
+
+ if other.Layout:
+ self.Layout = other.Layout
+
+ if other.DefaultLayout:
+ self.DefaultLayout = other.DefaultLayout
+
+ for rule in other.Rules:
+ self.Rules.append(rule)
+
+ for move in other.Moves:
+ self.Moves.append(move)
+
+ for submenu in other.Submenus:
+ self.addSubmenu(submenu)
+
+ return self
+
+ # FIXME: Performance: cache getName()
+ def __cmp__(self, other):
+ return locale.strcoll(self.getName(), other.getName())
+
+ def __eq__(self, other):
+ if self.Name == str(other):
+ return True
+ else:
+ return False
+
+ """ PUBLIC STUFF """
+ def getEntries(self, hidden=False):
+ for entry in self.Entries:
+ if hidden == True:
+ yield entry
+ elif entry.Show == True:
+ yield entry
+
+ # FIXME: Add searchEntry/seaqrchMenu function
+ # search for name/comment/genericname/desktopfileide
+ # return multiple items
+
+ def getMenuEntry(self, desktopfileid, deep = False):
+ for menuentry in self.MenuEntries:
+ if menuentry.DesktopFileID == desktopfileid:
+ return menuentry
+ if deep == True:
+ for submenu in self.Submenus:
+ submenu.getMenuEntry(desktopfileid, deep)
+
+ def getMenu(self, path):
+ array = path.split("/", 1)
+ for submenu in self.Submenus:
+ if submenu.Name == array[0]:
+ if len(array) > 1:
+ return submenu.getMenu(array[1])
+ else:
+ return submenu
+
+ def getPath(self, org=False, toplevel=False):
+ parent = self
+ names=[]
+ while 1:
+ if org:
+ names.append(parent.Name)
+ else:
+ names.append(parent.getName())
+ if parent.Depth > 0:
+ parent = parent.Parent
+ else:
+ break
+ names.reverse()
+ path = ""
+ if toplevel == False:
+ names.pop(0)
+ for name in names:
+ path = os.path.join(path, name)
+ return path
+
+ def getName(self):
+ try:
+ return self.Directory.DesktopEntry.getName()
+ except AttributeError:
+ return self.Name
+
+ def getGenericName(self):
+ try:
+ return self.Directory.DesktopEntry.getGenericName()
+ except AttributeError:
+ return ""
+
+ def getComment(self):
+ try:
+ return self.Directory.DesktopEntry.getComment()
+ except AttributeError:
+ return ""
+
+ def getIcon(self):
+ try:
+ return self.Directory.DesktopEntry.getIcon()
+ except AttributeError:
+ return ""
+
+ """ PRIVATE STUFF """
+ def addSubmenu(self, newmenu):
+ for submenu in self.Submenus:
+ if submenu == newmenu:
+ submenu += newmenu
+ break
+ else:
+ self.Submenus.append(newmenu)
+ newmenu.Parent = self
+ newmenu.Depth = self.Depth + 1
+
+class Move:
+ "A move operation"
+ def __init__(self, node=None):
+ if node:
+ self.parseNode(node)
+ else:
+ self.Old = ""
+ self.New = ""
+
+ def __cmp__(self, other):
+ return cmp(self.Old, other.Old)
+
+ def parseNode(self, node):
+ for child in node.childNodes:
+ if child.nodeType == ELEMENT_NODE:
+ if child.tagName == "Old":
+ try:
+ self.parseOld(child.childNodes[0].nodeValue)
+ except IndexError:
+ raise ValidationError('Old cannot be empty', '??')
+ elif child.tagName == "New":
+ try:
+ self.parseNew(child.childNodes[0].nodeValue)
+ except IndexError:
+ raise ValidationError('New cannot be empty', '??')
+
+ def parseOld(self, value):
+ self.Old = value
+ def parseNew(self, value):
+ self.New = value
+
+
+class Layout:
+ "Menu Layout class"
+ def __init__(self, node=None):
+ self.order = []
+ if node:
+ self.show_empty = node.getAttribute("show_empty") or "false"
+ self.inline = node.getAttribute("inline") or "false"
+ self.inline_limit = node.getAttribute("inline_limit") or 4
+ self.inline_header = node.getAttribute("inline_header") or "true"
+ self.inline_alias = node.getAttribute("inline_alias") or "false"
+ self.inline_limit = int(self.inline_limit)
+ self.parseNode(node)
+ else:
+ self.show_empty = "false"
+ self.inline = "false"
+ self.inline_limit = 4
+ self.inline_header = "true"
+ self.inline_alias = "false"
+ self.order.append(["Merge", "menus"])
+ self.order.append(["Merge", "files"])
+
+ def parseNode(self, node):
+ for child in node.childNodes:
+ if child.nodeType == ELEMENT_NODE:
+ if child.tagName == "Menuname":
+ try:
+ self.parseMenuname(
+ child.childNodes[0].nodeValue,
+ child.getAttribute("show_empty") or "false",
+ child.getAttribute("inline") or "false",
+ child.getAttribute("inline_limit") or 4,
+ child.getAttribute("inline_header") or "true",
+ child.getAttribute("inline_alias") or "false" )
+ except IndexError:
+ raise ValidationError('Menuname cannot be empty', "")
+ elif child.tagName == "Separator":
+ self.parseSeparator()
+ elif child.tagName == "Filename":
+ try:
+ self.parseFilename(child.childNodes[0].nodeValue)
+ except IndexError:
+ raise ValidationError('Filename cannot be empty', "")
+ elif child.tagName == "Merge":
+ self.parseMerge(child.getAttribute("type") or "all")
+
+ def parseMenuname(self, value, empty="false", inline="false", inline_limit=4, inline_header="true", inline_alias="false"):
+ self.order.append(["Menuname", value, empty, inline, inline_limit, inline_header, inline_alias])
+ self.order[-1][4] = int(self.order[-1][4])
+
+ def parseSeparator(self):
+ self.order.append(["Separator"])
+
+ def parseFilename(self, value):
+ self.order.append(["Filename", value])
+
+ def parseMerge(self, type="all"):
+ self.order.append(["Merge", type])
+
+
+class Rule:
+ "Inlcude / Exclude Rules Class"
+ def __init__(self, type, node=None):
+ # Type is Include or Exclude
+ self.Type = type
+ # Rule is a python expression
+ self.Rule = ""
+
+ # Private attributes, only needed for parsing
+ self.Depth = 0
+ self.Expr = [ "or" ]
+ self.New = True
+
+ # Begin parsing
+ if node:
+ self.parseNode(node)
+ self.compile()
+
+ def __str__(self):
+ return self.Rule
+
+ def compile(self):
+ exec("""
+def do(menuentries, type, run):
+ for menuentry in menuentries:
+ if run == 2 and ( menuentry.MatchedInclude == True \
+ or menuentry.Allocated == True ):
+ continue
+ elif %s:
+ if type == "Include":
+ menuentry.Add = True
+ menuentry.MatchedInclude = True
+ else:
+ menuentry.Add = False
+ return menuentries
+""" % self.Rule) in self.__dict__
+
+ def parseNode(self, node):
+ for child in node.childNodes:
+ if child.nodeType == ELEMENT_NODE:
+ if child.tagName == 'Filename':
+ try:
+ self.parseFilename(child.childNodes[0].nodeValue)
+ except IndexError:
+ raise ValidationError('Filename cannot be empty', "???")
+ elif child.tagName == 'Category':
+ try:
+ self.parseCategory(child.childNodes[0].nodeValue)
+ except IndexError:
+ raise ValidationError('Category cannot be empty', "???")
+ elif child.tagName == 'All':
+ self.parseAll()
+ elif child.tagName == 'And':
+ self.parseAnd(child)
+ elif child.tagName == 'Or':
+ self.parseOr(child)
+ elif child.tagName == 'Not':
+ self.parseNot(child)
+
+ def parseNew(self, set=True):
+ if not self.New:
+ self.Rule += " " + self.Expr[self.Depth] + " "
+ if not set:
+ self.New = True
+ elif set:
+ self.New = False
+
+ def parseFilename(self, value):
+ self.parseNew()
+ self.Rule += "menuentry.DesktopFileID == '%s'" % value.strip().replace("\\", r"\\").replace("'", r"\'")
+
+ def parseCategory(self, value):
+ self.parseNew()
+ self.Rule += "'%s' in menuentry.Categories" % value.strip()
+
+ def parseAll(self):
+ self.parseNew()
+ self.Rule += "True"
+
+ def parseAnd(self, node):
+ self.parseNew(False)
+ self.Rule += "("
+ self.Depth += 1
+ self.Expr.append("and")
+ self.parseNode(node)
+ self.Depth -= 1
+ self.Expr.pop()
+ self.Rule += ")"
+
+ def parseOr(self, node):
+ self.parseNew(False)
+ self.Rule += "("
+ self.Depth += 1
+ self.Expr.append("or")
+ self.parseNode(node)
+ self.Depth -= 1
+ self.Expr.pop()
+ self.Rule += ")"
+
+ def parseNot(self, node):
+ self.parseNew(False)
+ self.Rule += "not ("
+ self.Depth += 1
+ self.Expr.append("or")
+ self.parseNode(node)
+ self.Depth -= 1
+ self.Expr.pop()
+ self.Rule += ")"
+
+
+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):
+ if self.DesktopEntry.tainted == True:
+ self.DesktopEntry.write()
+
+ def getDir(self):
+ return self.DesktopEntry.filename.replace(self.Filename, '')
+
+ def getType(self):
+ # Can be one of 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 __eq__(self, other):
+ if self.DesktopFileID == str(other):
+ return True
+ else:
+ return False
+
+ def __repr__(self):
+ return self.DesktopFileID
+
+
+class Separator:
+ "Just a dummy class for Separators"
+ def __init__(self, parent):
+ self.Parent = parent
+ self.Show = True
+
+
+class Header:
+ "Class for Inline Headers"
+ def __init__(self, name, generic_name, comment):
+ self.Name = name
+ self.GenericName = generic_name
+ self.Comment = comment
+
+ def __str__(self):
+ return self.Name
+
+
+tmp = {}
+
+def __getFileName(filename):
+ dirs = xdg_config_dirs[:]
+ if xdg.Config.root_mode == True:
+ dirs.pop(0)
+
+ for dir in dirs:
+ menuname = os.path.join (dir, "menus" , filename)
+ if os.path.isdir(dir) and os.path.isfile(menuname):
+ return menuname
+
+def parse(filename=None):
+ # conver to absolute path
+ if filename and not os.path.isabs(filename):
+ filename = __getFileName(filename)
+
+ # use default if no filename given
+ if not filename:
+ candidate = os.environ.get('XDG_MENU_PREFIX', '') + "applications.menu"
+ filename = __getFileName(candidate)
+
+ if not filename:
+ raise ParsingError('File not found', "/etc/xdg/menus/%s" % candidate)
+
+ # check if it is a .menu file
+ if not os.path.splitext(filename)[1] == ".menu":
+ raise ParsingError('Not a .menu file', filename)
+
+ # create xml parser
+ try:
+ doc = xml.dom.minidom.parse(filename)
+ except xml.parsers.expat.ExpatError:
+ raise ParsingError('Not a valid .menu file', filename)
+
+ # parse menufile
+ tmp["Root"] = ""
+ tmp["mergeFiles"] = []
+ tmp["DirectoryDirs"] = []
+ tmp["cache"] = MenuEntryCache()
+
+ __parse(doc, filename, tmp["Root"])
+ __parsemove(tmp["Root"])
+ __postparse(tmp["Root"])
+
+ tmp["Root"].Doc = doc
+ tmp["Root"].Filename = filename
+
+ # generate the menu
+ __genmenuNotOnlyAllocated(tmp["Root"])
+ __genmenuOnlyAllocated(tmp["Root"])
+
+ # and finally sort
+ sort(tmp["Root"])
+
+ return tmp["Root"]
+
+
+def __parse(node, filename, parent=None):
+ for child in node.childNodes:
+ if child.nodeType == ELEMENT_NODE:
+ if child.tagName == 'Menu':
+ __parseMenu(child, filename, parent)
+ elif child.tagName == 'AppDir':
+ try:
+ __parseAppDir(child.childNodes[0].nodeValue, filename, parent)
+ except IndexError:
+ raise ValidationError('AppDir cannot be empty', filename)
+ elif child.tagName == 'DefaultAppDirs':
+ __parseDefaultAppDir(filename, parent)
+ elif child.tagName == 'DirectoryDir':
+ try:
+ __parseDirectoryDir(child.childNodes[0].nodeValue, filename, parent)
+ except IndexError:
+ raise ValidationError('DirectoryDir cannot be empty', filename)
+ elif child.tagName == 'DefaultDirectoryDirs':
+ __parseDefaultDirectoryDir(filename, parent)
+ elif child.tagName == 'Name' :
+ try:
+ parent.Name = child.childNodes[0].nodeValue
+ except IndexError:
+ raise ValidationError('Name cannot be empty', filename)
+ elif child.tagName == 'Directory' :
+ try:
+ parent.Directories.append(child.childNodes[0].nodeValue)
+ except IndexError:
+ raise ValidationError('Directory cannot be empty', filename)
+ elif child.tagName == 'OnlyUnallocated':
+ parent.OnlyUnallocated = True
+ elif child.tagName == 'NotOnlyUnallocated':
+ parent.OnlyUnallocated = False
+ elif child.tagName == 'Deleted':
+ parent.Deleted = True
+ elif child.tagName == 'NotDeleted':
+ parent.Deleted = False
+ elif child.tagName == 'Include' or child.tagName == 'Exclude':
+ parent.Rules.append(Rule(child.tagName, child))
+ elif child.tagName == 'MergeFile':
+ try:
+ if child.getAttribute("type") == "parent":
+ __parseMergeFile("applications.menu", child, filename, parent)
+ else:
+ __parseMergeFile(child.childNodes[0].nodeValue, child, filename, parent)
+ except IndexError:
+ raise ValidationError('MergeFile cannot be empty', filename)
+ elif child.tagName == 'MergeDir':
+ try:
+ __parseMergeDir(child.childNodes[0].nodeValue, child, filename, parent)
+ except IndexError:
+ raise ValidationError('MergeDir cannot be empty', filename)
+ elif child.tagName == 'DefaultMergeDirs':
+ __parseDefaultMergeDirs(child, filename, parent)
+ elif child.tagName == 'Move':
+ parent.Moves.append(Move(child))
+ elif child.tagName == 'Layout':
+ if len(child.childNodes) > 1:
+ parent.Layout = Layout(child)
+ elif child.tagName == 'DefaultLayout':
+ if len(child.childNodes) > 1:
+ parent.DefaultLayout = Layout(child)
+ elif child.tagName == 'LegacyDir':
+ try:
+ __parseLegacyDir(child.childNodes[0].nodeValue, child.getAttribute("prefix"), filename, parent)
+ except IndexError:
+ raise ValidationError('LegacyDir cannot be empty', filename)
+ elif child.tagName == 'KDELegacyDirs':
+ __parseKDELegacyDirs(filename, parent)
+
+def __parsemove(menu):
+ for submenu in menu.Submenus:
+ __parsemove(submenu)
+
+ # parse move operations
+ for move in menu.Moves:
+ move_from_menu = menu.getMenu(move.Old)
+ if move_from_menu:
+ move_to_menu = menu.getMenu(move.New)
+
+ menus = move.New.split("/")
+ oldparent = None
+ while len(menus) > 0:
+ if not oldparent:
+ oldparent = menu
+ newmenu = oldparent.getMenu(menus[0])
+ if not newmenu:
+ newmenu = Menu()
+ newmenu.Name = menus[0]
+ if len(menus) > 1:
+ newmenu.NotInXml = True
+ oldparent.addSubmenu(newmenu)
+ oldparent = newmenu
+ menus.pop(0)
+
+ newmenu += move_from_menu
+ move_from_menu.Parent.Submenus.remove(move_from_menu)
+
+def __postparse(menu):
+ # unallocated / deleted
+ if menu.Deleted == "notset":
+ menu.Deleted = False
+ if menu.OnlyUnallocated == "notset":
+ menu.OnlyUnallocated = False
+
+ # Layout Tags
+ if not menu.Layout or not menu.DefaultLayout:
+ if menu.DefaultLayout:
+ menu.Layout = menu.DefaultLayout
+ elif menu.Layout:
+ if menu.Depth > 0:
+ menu.DefaultLayout = menu.Parent.DefaultLayout
+ else:
+ menu.DefaultLayout = Layout()
+ else:
+ if menu.Depth > 0:
+ menu.Layout = menu.Parent.DefaultLayout
+ menu.DefaultLayout = menu.Parent.DefaultLayout
+ else:
+ menu.Layout = Layout()
+ menu.DefaultLayout = Layout()
+
+ # add parent's app/directory dirs
+ if menu.Depth > 0:
+ menu.AppDirs = menu.Parent.AppDirs + menu.AppDirs
+ menu.DirectoryDirs = menu.Parent.DirectoryDirs + menu.DirectoryDirs
+
+ # remove duplicates
+ menu.Directories = __removeDuplicates(menu.Directories)
+ menu.DirectoryDirs = __removeDuplicates(menu.DirectoryDirs)
+ menu.AppDirs = __removeDuplicates(menu.AppDirs)
+
+ # go recursive through all menus
+ for submenu in menu.Submenus:
+ __postparse(submenu)
+
+ # reverse so handling is easier
+ menu.Directories.reverse()
+ menu.DirectoryDirs.reverse()
+ menu.AppDirs.reverse()
+
+ # get the valid .directory file out of the list
+ for directory in menu.Directories:
+ for dir in menu.DirectoryDirs:
+ if os.path.isfile(os.path.join(dir, directory)):
+ menuentry = MenuEntry(directory, dir)
+ if not menu.Directory:
+ menu.Directory = menuentry
+ elif menuentry.getType() == "System":
+ if menu.Directory.getType() == "User":
+ menu.Directory.Original = menuentry
+ if menu.Directory:
+ break
+
+
+# Menu parsing stuff
+def __parseMenu(child, filename, parent):
+ m = Menu()
+ __parse(child, filename, m)
+ if parent:
+ parent.addSubmenu(m)
+ else:
+ tmp["Root"] = m
+
+# helper function
+def __check(value, filename, type):
+ path = os.path.dirname(filename)
+
+ if not os.path.isabs(value):
+ value = os.path.join(path, value)
+
+ value = os.path.abspath(value)
+
+ if type == "dir" and os.path.exists(value) and os.path.isdir(value):
+ return value
+ elif type == "file" and os.path.exists(value) and os.path.isfile(value):
+ return value
+ else:
+ return False
+
+# App/Directory Dir Stuff
+def __parseAppDir(value, filename, parent):
+ value = __check(value, filename, "dir")
+ if value:
+ parent.AppDirs.append(value)
+
+def __parseDefaultAppDir(filename, parent):
+ for dir in reversed(xdg_data_dirs):
+ __parseAppDir(os.path.join(dir, "applications"), filename, parent)
+
+def __parseDirectoryDir(value, filename, parent):
+ value = __check(value, filename, "dir")
+ if value:
+ parent.DirectoryDirs.append(value)
+
+def __parseDefaultDirectoryDir(filename, parent):
+ for dir in reversed(xdg_data_dirs):
+ __parseDirectoryDir(os.path.join(dir, "desktop-directories"), filename, parent)
+
+# Merge Stuff
+def __parseMergeFile(value, child, filename, parent):
+ if child.getAttribute("type") == "parent":
+ for dir in xdg_config_dirs:
+ rel_file = filename.replace(dir, "").strip("/")
+ if rel_file != filename:
+ for p in xdg_config_dirs:
+ if dir == p:
+ continue
+ if os.path.isfile(os.path.join(p,rel_file)):
+ __mergeFile(os.path.join(p,rel_file),child,parent)
+ break
+ else:
+ value = __check(value, filename, "file")
+ if value:
+ __mergeFile(value, child, parent)
+
+def __parseMergeDir(value, child, filename, parent):
+ value = __check(value, filename, "dir")
+ if value:
+ for item in os.listdir(value):
+ try:
+ if os.path.splitext(item)[1] == ".menu":
+ __mergeFile(os.path.join(value, item), child, parent)
+ except UnicodeDecodeError:
+ continue
+
+def __parseDefaultMergeDirs(child, filename, parent):
+ basename = os.path.splitext(os.path.basename(filename))[0]
+ for dir in reversed(xdg_config_dirs):
+ __parseMergeDir(os.path.join(dir, "menus", basename + "-merged"), child, filename, parent)
+
+def __mergeFile(filename, child, parent):
+ # check for infinite loops
+ if filename in tmp["mergeFiles"]:
+ if debug:
+ raise ParsingError('Infinite MergeFile loop detected', filename)
+ else:
+ return
+
+ tmp["mergeFiles"].append(filename)
+
+ # load file
+ try:
+ doc = xml.dom.minidom.parse(filename)
+ except IOError:
+ if debug:
+ raise ParsingError('File not found', filename)
+ else:
+ return
+ except xml.parsers.expat.ExpatError:
+ if debug:
+ raise ParsingError('Not a valid .menu file', filename)
+ else:
+ return
+
+ # append file
+ for child in doc.childNodes:
+ if child.nodeType == ELEMENT_NODE:
+ __parse(child,filename,parent)
+ break
+
+# Legacy Dir Stuff
+def __parseLegacyDir(dir, prefix, filename, parent):
+ m = __mergeLegacyDir(dir,prefix,filename,parent)
+ if m:
+ parent += m
+
+def __mergeLegacyDir(dir, prefix, filename, parent):
+ dir = __check(dir,filename,"dir")
+ if dir and dir not in tmp["DirectoryDirs"]:
+ tmp["DirectoryDirs"].append(dir)
+
+ m = Menu()
+ m.AppDirs.append(dir)
+ m.DirectoryDirs.append(dir)
+ m.Name = os.path.basename(dir)
+ m.NotInXml = True
+
+ for item in os.listdir(dir):
+ try:
+ if item == ".directory":
+ m.Directories.append(item)
+ elif os.path.isdir(os.path.join(dir,item)):
+ m.addSubmenu(__mergeLegacyDir(os.path.join(dir,item), prefix, filename, parent))
+ except UnicodeDecodeError:
+ continue
+
+ tmp["cache"].addMenuEntries([dir],prefix, True)
+ menuentries = tmp["cache"].getMenuEntries([dir], False)
+
+ for menuentry in menuentries:
+ categories = menuentry.Categories
+ if len(categories) == 0:
+ r = Rule("Include")
+ r.parseFilename(menuentry.DesktopFileID)
+ r.compile()
+ m.Rules.append(r)
+ if not dir in parent.AppDirs:
+ categories.append("Legacy")
+ menuentry.Categories = categories
+
+ return m
+
+def __parseKDELegacyDirs(filename, parent):
+ f=os.popen3("kde-config --path apps")
+ output = f[1].readlines()
+ try:
+ for dir in output[0].split(":"):
+ __parseLegacyDir(dir,"kde", filename, parent)
+ except IndexError:
+ pass
+
+# remove duplicate entries from a list
+def __removeDuplicates(list):
+ set = {}
+ list.reverse()
+ list = [set.setdefault(e,e) for e in list if e not in set]
+ list.reverse()
+ return list
+
+# Finally generate the menu
+def __genmenuNotOnlyAllocated(menu):
+ for submenu in menu.Submenus:
+ __genmenuNotOnlyAllocated(submenu)
+
+ if menu.OnlyUnallocated == False:
+ tmp["cache"].addMenuEntries(menu.AppDirs)
+ menuentries = []
+ for rule in menu.Rules:
+ menuentries = rule.do(tmp["cache"].getMenuEntries(menu.AppDirs), rule.Type, 1)
+ for menuentry in menuentries:
+ if menuentry.Add == True:
+ menuentry.Parents.append(menu)
+ menuentry.Add = False
+ menuentry.Allocated = True
+ menu.MenuEntries.append(menuentry)
+
+def __genmenuOnlyAllocated(menu):
+ for submenu in menu.Submenus:
+ __genmenuOnlyAllocated(submenu)
+
+ if menu.OnlyUnallocated == True:
+ tmp["cache"].addMenuEntries(menu.AppDirs)
+ menuentries = []
+ for rule in menu.Rules:
+ menuentries = rule.do(tmp["cache"].getMenuEntries(menu.AppDirs), rule.Type, 2)
+ for menuentry in menuentries:
+ if menuentry.Add == True:
+ menuentry.Parents.append(menu)
+ # menuentry.Add = False
+ # menuentry.Allocated = True
+ menu.MenuEntries.append(menuentry)
+
+# And sorting ...
+def sort(menu):
+ menu.Entries = []
+ menu.Visible = 0
+
+ for submenu in menu.Submenus:
+ sort(submenu)
+
+ tmp_s = []
+ tmp_e = []
+
+ for order in menu.Layout.order:
+ if order[0] == "Filename":
+ tmp_e.append(order[1])
+ elif order[0] == "Menuname":
+ tmp_s.append(order[1])
+
+ for order in menu.Layout.order:
+ if order[0] == "Separator":
+ separator = Separator(menu)
+ if len(menu.Entries) > 0 and isinstance(menu.Entries[-1], Separator):
+ separator.Show = False
+ menu.Entries.append(separator)
+ elif order[0] == "Filename":
+ menuentry = menu.getMenuEntry(order[1])
+ if menuentry:
+ menu.Entries.append(menuentry)
+ elif order[0] == "Menuname":
+ submenu = menu.getMenu(order[1])
+ if submenu:
+ __parse_inline(submenu, menu)
+ elif order[0] == "Merge":
+ if order[1] == "files" or order[1] == "all":
+ menu.MenuEntries.sort()
+ for menuentry in menu.MenuEntries:
+ if menuentry not in tmp_e:
+ menu.Entries.append(menuentry)
+ elif order[1] == "menus" or order[1] == "all":
+ menu.Submenus.sort()
+ for submenu in menu.Submenus:
+ if submenu.Name not in tmp_s:
+ __parse_inline(submenu, menu)
+
+ # getHidden / NoDisplay / OnlyShowIn / NotOnlyShowIn / Deleted / NoExec
+ for entry in menu.Entries:
+ entry.Show = True
+ menu.Visible += 1
+ if isinstance(entry, Menu):
+ if entry.Deleted == True:
+ entry.Show = "Deleted"
+ menu.Visible -= 1
+ elif isinstance(entry.Directory, MenuEntry):
+ if entry.Directory.DesktopEntry.getNoDisplay() == True:
+ entry.Show = "NoDisplay"
+ menu.Visible -= 1
+ elif entry.Directory.DesktopEntry.getHidden() == True:
+ entry.Show = "Hidden"
+ menu.Visible -= 1
+ elif isinstance(entry, MenuEntry):
+ if entry.DesktopEntry.getNoDisplay() == True:
+ entry.Show = "NoDisplay"
+ menu.Visible -= 1
+ elif entry.DesktopEntry.getHidden() == True:
+ entry.Show = "Hidden"
+ menu.Visible -= 1
+ elif entry.DesktopEntry.getTryExec() and not __try_exec(entry.DesktopEntry.getTryExec()):
+ entry.Show = "NoExec"
+ menu.Visible -= 1
+ elif xdg.Config.windowmanager:
+ if ( entry.DesktopEntry.getOnlyShowIn() != [] and xdg.Config.windowmanager not in entry.DesktopEntry.getOnlyShowIn() ) \
+ or xdg.Config.windowmanager in entry.DesktopEntry.getNotShowIn():
+ entry.Show = "NotShowIn"
+ menu.Visible -= 1
+ elif isinstance(entry,Separator):
+ menu.Visible -= 1
+
+ # remove separators at the beginning and at the end
+ if len(menu.Entries) > 0:
+ if isinstance(menu.Entries[0], Separator):
+ menu.Entries[0].Show = False
+ if len(menu.Entries) > 1:
+ if isinstance(menu.Entries[-1], Separator):
+ menu.Entries[-1].Show = False
+
+ # show_empty tag
+ for entry in menu.Entries:
+ if isinstance(entry,Menu) and entry.Layout.show_empty == "false" and entry.Visible == 0:
+ entry.Show = "Empty"
+ menu.Visible -= 1
+ if entry.NotInXml == True:
+ menu.Entries.remove(entry)
+
+def __try_exec(executable):
+ paths = os.environ['PATH'].split(os.pathsep)
+ if not os.path.isfile(executable):
+ for p in paths:
+ f = os.path.join(p, executable)
+ if os.path.isfile(f):
+ if os.access(f, os.X_OK):
+ return True
+ else:
+ if os.access(executable, os.X_OK):
+ return True
+ return False
+
+# inline tags
+def __parse_inline(submenu, menu):
+ if submenu.Layout.inline == "true":
+ if len(submenu.Entries) == 1 and submenu.Layout.inline_alias == "true":
+ menuentry = submenu.Entries[0]
+ menuentry.DesktopEntry.set("Name", submenu.getName(), locale = True)
+ menuentry.DesktopEntry.set("GenericName", submenu.getGenericName(), locale = True)
+ menuentry.DesktopEntry.set("Comment", submenu.getComment(), locale = True)
+ menu.Entries.append(menuentry)
+ elif len(submenu.Entries) <= submenu.Layout.inline_limit or submenu.Layout.inline_limit == 0:
+ if submenu.Layout.inline_header == "true":
+ header = Header(submenu.getName(), submenu.getGenericName(), submenu.getComment())
+ menu.Entries.append(header)
+ for entry in submenu.Entries:
+ menu.Entries.append(entry)
+ else:
+ menu.Entries.append(submenu)
+ else:
+ menu.Entries.append(submenu)
+
+class MenuEntryCache:
+ "Class to cache Desktop Entries"
+ def __init__(self):
+ self.cacheEntries = {}
+ self.cacheEntries['legacy'] = []
+ self.cache = {}
+
+ def addMenuEntries(self, dirs, prefix="", legacy=False):
+ for dir in dirs:
+ if not self.cacheEntries.has_key(dir):
+ self.cacheEntries[dir] = []
+ self.__addFiles(dir, "", prefix, legacy)
+
+ def __addFiles(self, dir, subdir, prefix, legacy):
+ for item in os.listdir(os.path.join(dir,subdir)):
+ if os.path.splitext(item)[1] == ".desktop":
+ try:
+ menuentry = MenuEntry(os.path.join(subdir,item), dir, prefix)
+ except ParsingError:
+ continue
+
+ self.cacheEntries[dir].append(menuentry)
+ if legacy == True:
+ self.cacheEntries['legacy'].append(menuentry)
+ elif os.path.isdir(os.path.join(dir,subdir,item)) and legacy == False:
+ self.__addFiles(dir, os.path.join(subdir,item), prefix, legacy)
+
+ def getMenuEntries(self, dirs, legacy=True):
+ list = []
+ ids = []
+ # handle legacy items
+ appdirs = dirs[:]
+ if legacy == True:
+ appdirs.append("legacy")
+ # cache the results again
+ key = "".join(appdirs)
+ try:
+ return self.cache[key]
+ except KeyError:
+ pass
+ for dir in appdirs:
+ for menuentry in self.cacheEntries[dir]:
+ try:
+ if menuentry.DesktopFileID not in ids:
+ ids.append(menuentry.DesktopFileID)
+ list.append(menuentry)
+ elif menuentry.getType() == "System":
+ # FIXME: This is only 99% correct, but still...
+ i = list.index(menuentry)
+ e = list[i]
+ if e.getType() == "User":
+ e.Original = menuentry
+ except UnicodeDecodeError:
+ continue
+ self.cache[key] = list
+ return list
projects / drlaunch / blobdiff