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
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
def ShowAll(self):#elenca tutti i file nelle 4 cartelle di autostart
autolist = []
path = self.user_autostart
for file_name in os.listdir(path):
myitem = DesktopEntry(path + '/' + file_name)
#print(path + '/' + file_name)
a = DeskStruct()
a.Name = myitem.getName()
a.Exec = myitem.getExec()
a.Icon = myitem.getIcon()
a.Comment = myitem.getComment()
autolist.append(a) #lista di oggetti Deskstruct
#path=self.xdg_autostart
#autolist.append(' XDG files')
#for file_name in os.listdir(path):
# autolist.append(path+'/'+file_name)
#
#path=self.sys_autostart
#autolist.append(' Sys Files')
#for file_name in os.listdir(path):
# autolist.append(path+'/'+file_name)
#path=self.gdm_autostart
#autolist.append(' GDM files')
#for file_name in os.listdir(path):
# autolist.append(path+'/'+file_name)
return autolist
def __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 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
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 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)
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)
def _get_icon_from_desktop_file(
workdir: str, desktop_file_paths: List[str]) -> Optional[str]:
# Icons in the desktop file can be either a full path to the icon file, or a name
# to be searched in the standard locations. If the path is specified, use that,
# otherwise look for the icon in the hicolor theme (also covers icon type="stock").
# See https://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
# for further information.
for path in desktop_file_paths:
entry = DesktopEntry()
entry.parse(os.path.join(workdir, path))
icon = entry.getIcon()
icon_path = (icon if os.path.isabs(icon) else _get_icon_from_theme(
workdir, "hicolor", icon))
return icon_path
return None
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
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
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
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})
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
}
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()]
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
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
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>
''')
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)
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
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)
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()) + ">"