def __init__(self, name, slot, data={}, virtual=False):

if not name:

raise SwineException(self.tr("Shortcut name cannot be empty"))

self.name = unicode(name)

if not data:

self.data = {}

else:

self.data = data

assert slot and isinstance(slot, Slot)

self.slot = slot

self.virtual = virtual

def tr(self, s):

return tr(s, self.__class__.__name__)

def __str__(self):

return self.name

def getSlot(self):

return self.slot

def getName(self):

return self.name

def __setitem__(self, key, value):

self.data[key]=value

if not self.virtual:

self.save()

def __getitem__(self, key):

return self.data.get(key, None)

def __delitem__(self, key):

del self.data[key]

def _storeData(self):

self.slot._storeShortcutData(self.name, self.data)

def _removeData(self):

self.slot._removeShortcutData(self.name)

def save(self):

self.virtual = False

self._storeData()

def delete(self):

self._removeData()

self.removeMenuEntry()

def rename(self, newname):

if not newname:

raise SwineException(self.tr("Shortcut name cannot be empty"))

if newname == self.name:

return

self._removeData()

hasMenuEntry = self.hasMenuEntry()

if hasMenuEntry:

self.removeMenuEntry()

self.name = newname

self._storeData()

if hasMenuEntry:

self.createMenuEntry()

def clone(self, newname):

if not newname:

raise SwineException(self.tr("Shortcut name cannot be empty"))

if self.slot.hasShortcut(newname):

raise SwineException(self.tr("Shortcut already exists"))

shortcut = Shortcut(newname, self.slot, self.data.copy())

shortcut.save()

return shortcut

def isDefault(self):

return self.slot.getDefaultShortcutName() == self.name

def setDefault(self):

self.slot.setDefaultShortcut(self)

def getProgram(self):

return self['program']

def setProgram(self, prog):

assert isinstance(prog, (str, unicode))

self["program"] = prog

def getArguments(self):

return self["arguments"] if self["arguments"] else []

def setArguments(self, args):

assert isinstance(args, (str, unicode, list))

if isinstance(args, (str, unicode)):

args = shlex.split(args)

self['arguments'] = args

def getIcon(self):

if self["icon"]:

path = os.path.join(self.slot.getPath(), self["icon"])

if os.path.exists(path):

with open(path, "r") as fp:

return fp.read()

try:

return base64.b64decode(self["icon"])

except:

pass

return None

def setIcon(self, icon):

if icon:

path = os.path.join(self.slot.getPath(), "icons")

if not os.path.exists(path):

os.mkdir(path)

name = hashlib.md5(icon).hexdigest() + ".png"

path = os.path.join(path, name)

with open(path, "wb") as fp:

fp.write(icon)

self['icon'] = os.path.join("icons", name)

else:

self["icon"] = None

def getWorkingDirectory(self):

return self["working_directory"]

def setWorkingDirectory(self, path):

assert isinstance(path, (str, unicode))

self["working_directory"] = path

def getDesktop(self):

return self["desktop"]

def setDesktop(self, desktop):

assert isinstance(desktop, (str, unicode))

self["desktop"] = desktop

def _exePath(self):

path = self.slot.winPathToUnix(self.getProgram())

if not os.path.exists(path) and os.path.exists(path+".exe"):

path += ".exe"

return path

def _menuEntryPath(self):

return os.path.join(DESKTOP_MENU_DIR, "%s-%s.desktop" % (self.slot.getName(), self.name))

def _menuEntryIconPath(self):

return os.path.join(DESKTOP_MENU_DIR, "%s-%s.png" % (self.slot.getName(), self.name))

def hasMenuEntry(self):

return os.path.exists(self._menuEntryPath())

def createMenuEntry(self):

if not os.path.exists(DESKTOP_MENU_DIR):

os.mkdir(DESKTOP_MENU_DIR)

if self.getIcon():

with open(self._menuEntryIconPath(), "wb") as fp:

fp.write(self.getIcon())

with open(self._menuEntryPath(), "w") as fp:

fp.write("[Desktop Entry]\nEncoding=UTF-8\nVersion=1.0\n")

fp.write("Name=%s: %s\n" % (self.slot.getName(), self.name))

fp.write("Type=Application\n")

fp.write("Exec=swinecli --slot %r --shortcut %r --translate-paths --run %%U\n" % (str(self.slot.getName()), str(self.name)))

if self.getIcon():

fp.write("Icon=%s\n" % self._menuEntryIconPath())

fp.write("Categories=Wine;\n")

def removeMenuEntry(self):

if self.hasMenuEntry():

os.remove(self._menuEntryPath())

def run(self, args=[]):

prog = [self.getProgram()]+self.getArguments()

workingDirectory = self['working_directory']

runInTerminal = self["interminal"] and int(self["interminal"]) == 1

desktop = self["desktop"]

return self.slot.runWin(prog=prog+args, workingDirectory=workingDirectory, runInTerminal=runInTerminal, desktop=desktop)

def readFromLnk(self, path):

if not os.path.exists(path):

path = self.slot.winPathToUnix(path)

if not os.path.exists(path):

raise Exception(self.tr("File does not exist"))

try:

lnk = shortcutlib.readLnk(path)

except:

print >>sys.stderr, "Failed to read %s" % path

raise

name = os.path.splitext(os.path.basename(path))[0]

self.setProgram(lnk.target)

self.setArguments(str(lnk.commandLineArgs) if lnk.commandLineArgs else "")

self.setWorkingDirectory(str(lnk.workingDirectory) if lnk.workingDirectory else "")

if lnk.description:

self["description"] = lnk.description

if lnk.customIcon:

iconPath = self.slot.winPathToUnix(str(lnk.customIcon), "c:\windows")

else:

iconPath = self.slot.winPathToUnix(lnk.target)

if os.path.splitext(iconPath)[1].lower() == '.exe':

icons = icolib.readExeIcons(iconPath, lnk.iconIndex)

if not icons:

icons = icolib.readExeIcons(iconPath)

else:

icons = icolib.readIcoIcons(iconPath)

bestIco = icolib.bestIcon(icons)

if bestIco:

def __init__(self, name):

if not name:

raise SwineException(self.tr("Slot name cannot be empty."))

assert isinstance(name, (str, unicode))

self.name = name

self.settings = {}

self.shortcutData = {}

def tr(self, s):

return tr(s, self.__class__.__name__)

def __setitem__(self, key, value):

self.settings[key]=value

def __getitem__(self, key):

return self.settings.get(key, config.getValue(key))

def __delitem__(self, key):

del self.settings[key]

def __str__(self):

return self.name

def getName(self):

return self.name

def _storeShortcutData(self, shortcut, data):

if not shortcut:

raise SwineException(self.tr("Shortcut name cannot be empty"))

assert isinstance(data, dict)

self.shortcutData[shortcut] = data

self.saveConfig()

def _removeShortcutData(self, shortcut):

if not shortcut:

raise SwineException(self.tr("Shortcut name cannot be empty"))

if shortcut in self.shortcutData:

del self.shortcutData[shortcut]

if self.getDefaultShortcutName() == shortcut:

self.setDefaultShortcutName(None)

self.saveConfig()

def getPath(self):

return os.path.join(SWINE_SLOT_PATH, self.name)

def getDosDrivesPath(self):

return os.path.join(self.getPath(), "dosdevices")

def getDrivePath(self, drive):

drive = drive.lower()

if not drive.endswith(":"):

drive += ":"

path = os.path.join(self.getDosDrivesPath(), drive)

if not os.path.exists(path):

raise SwineException(self.tr("%s does not exist") % drive)

return path

def getOldConfigFile(self): #Legacy support code

return os.path.join(self.getPath(), "swine.ini")

def getConfigFile(self):

return os.path.join(self.getPath(), "swine_slot.conf")

def migrateOldConfig(self): #Legacy support code

import ConfigParser, ast

config = ConfigParser.ConfigParser()

if os.path.exists(self.getOldConfigFile()):

with codecs.open(self.getOldConfigFile(), "r", "utf8") as fp:

config.readfp(fp)

if not config.has_section("__SYSTEM__"):

config.add_section("__SYSTEM__")

self.settings = dict(config.items("__SYSTEM__"))

for name in config.sections():

if name != "__SYSTEM__":

dat = dict(config.items(name))

if dat["program"] and dat["program"].startswith("["):

args = ast.literal_eval(dat["program"])

else:

args = shlex.split(str(dat["program"]))

dat["program"] = args[0]

if "\\\\" in dat["program"]:

dat["program"] = ast.literal_eval('"'+dat["program"]+'"')

dat["arguments"] = args[1:]

self.shortcutData[name] = dat

def migrateConfig(self):

pass

def loadConfig(self):

if os.path.exists(self.getOldConfigFile()): #Legacy support code

self.migrateOldConfig()

self.saveConfig()

os.rename(self.getOldConfigFile(), self.getOldConfigFile()+".old")

if not os.path.exists(self.getConfigFile()):

return

with open(self.getConfigFile(), "r") as fp:

self.config = json_load(fp)

self.migrateConfig()

self.settings = self.config.get("settings", {})

self.shortcutData = self.config.get("shortcuts", {})

def saveConfig(self):

with open(self.getConfigFile(), "w") as fp:

json.dump({"settings": self.settings, "shortcuts": self.shortcutData}, fp, indent=2)

def exists(self):

return os.path.exists(self.getPath())

def create(self):

if self.exists():

raise SwineException(self.tr("Slot already exists: %s") % self.name)

self.runWineboot()

self.loadConfig()

self.saveConfig()

def delete(self):

if self.name == SWINE_DEFAULT_SLOT_NAME:

raise SwineException(self.tr("Default slot cannot be deleted"))

if not self.exists():

raise SwineException(self.tr("Slot does not exist: %s") % self.name)

for s in self.getAllShortcuts():

s.delete()

shutil.rmtree(self.getPath())

def clone(self, newname):

if not newname:

raise SwineException(self.tr("Slot name cannot be empty"))

if not self.exists():

raise SwineException(self.tr("Slot does not exist: %s") % self.name)

assert isinstance(newname, (str, unicode))

slot = Slot(newname)

if slot.exists():

raise SwineException(self.tr("Slot does already exist: %s") % newname)

shutil.copytree(self.getPath(), slot.getPath(), True)

slot.loadConfig()

return slot

def rename(self, newname):

if not newname:

raise SwineException(self.tr("Slot name cannot be empty"))

if self.name == SWINE_DEFAULT_SLOT_NAME:

raise SwineException(self.tr("Default slot cannot be renamed"))

if not self.exists():

raise SwineException(self.tr("Slot does not exist: %s") % self.name)

dummySlot = Slot(newname)

if dummySlot.exists():

raise SwineException(self.tr("Slot does already exist: %s") % newname)

shortcutMenus = []

for s in self.getAllShortcuts():

if s.hasMenuEntry():

shortcutMenus.append(s)

s.removeMenuEntry()

shutil.move(self.getPath(), dummySlot.getPath())

self.name = newname

for s in shortcutMenus:

s.createMenuEntry()

def getAllShortcuts(self):

shortcuts = []

for name in self.shortcutData:

shortcuts.append(self.loadShortcut(name))

return shortcuts

def hasShortcut(self, name):

assert name

return name in self.shortcutData

def loadShortcut(self,name):

assert name

if not self.hasShortcut(name):

return None

return Shortcut(name, self, dict(self.shortcutData[name]))

def getWinePath(self):

return self["wine_path"]

def setWinePath(self, path):

self["wine_path"] = path

self.saveConfig()

def getDefaultShortcutName(self):

return self['default_shortcut']

def setDefaultShortcutName(self, name):

self['default_shortcut'] = name

self.saveConfig()

def setDefaultShortcut(self, shortcut):

assert shortcut

self.setDefaultShortcutName(shortcut.getName())

def unsetDefaultShortcut(self):

self.setDefaultShortcutName(None)

def loadDefaultShortcut(self):

try:

return self.loadShortcut(self.getDefaultShortcutName())

except:

return None

def createShortcutFromFile(self, path):

name = os.path.splitext(os.path.basename(path))[0]

shortcut = Shortcut(name, self, virtual=True)

shortcut.readFromLnk(path)

return shortcut

def findLnkFiles(self, onlyNew=False):

files = []

for root, dnames, fnames in os.walk(os.path.join(self.getPath(), "drive_c")):

for fname in fnames:

if os.path.splitext(fname)[1].lower() == ".lnk":

files.append(self.unixPathToWin(os.path.join(root,fname)))

oldfiles = self["known_lnk_files"]

self["known_lnk_files"] = files

self.saveConfig()

if oldfiles and onlyNew:

files = list(set(files) - set(oldfiles))

return files

def runNative(self, prog, cwd=None, env=None, stdin=None, stdout=None, stderr=None):

"""Run any native program (no windows binaries)

Parameters:

prog: this is the program with all paramters as a list

cwd: the working directory (unix-path)

env: custom environment, NOTE: this overwrites the normal environment

stdin, stdout, stderr: if this is set to "subprocess.PIPE" a new pipe is created to be accessed later

if this is set to a file descriptor, the file is used as input/output

"""

if not cwd and self.exists():

cwd = self.getPath()

proc = Popen(prog, stdin=stdin, stderr=stderr, stdout=stdout, cwd=cwd, env=env)

(proc.stdout_data, proc.stderr_data) = proc.communicate()

return proc

def runWineTool(self, prog, cwd=None, stdin=None, stdout=None, stderr=None, debug=None, winePath=False):

"""Run a wine tool (eg wine itself) with prefix and debug environment set

This is only a wrapper for runNative

"""

env = os.environ.copy()

env["WINEPREFIX"] = self.getPath()

env["WINEARCH"] = self["architecture"] if not os.path.exists(os.path.join(self.getPath(), "system.reg")) else ""

env["WINEDEBUG"] = debug if debug else self["debug_line"]

if not self["allow_menu_entry_creation"]:

env["WINEDLLOVERRIDES"] = "winemenubuilder.exe=d" #do not add shortcuts to desktop or menu

env["WINETRICKS_OPT_SHAREDPREFIX"] = "1" #disable wintricks prefix management

global WINE_WRAPPER

if WINE_WRAPPER and os.path.exists(self.getPath()):

open(os.path.join(self.getPath(), ".no_prelaunch_window_flag"),"wc").close()

if winePath is False:

winePath = self.getWinePath()

if winePath:

binPaths = filter(os.path.exists, (os.path.join(winePath, binDir) for binDir in ["bin", "usr/bin"]))

if binPaths:

env["PATH"] = os.pathsep.join(binPaths+[os.environ["PATH"]])

env["WINE"] = filter(os.path.exists, [os.path.join(p, "wine") for p in env["PATH"].split(os.pathsep)])[0]

libPaths = filter(os.path.exists, (os.path.join(winePath, binDir) for binDir in ["lib", "usr/lib", "lib64", "usr/lib64"]))

if libPaths:

env["LD_LIBRARY_PATH"] = os.pathsep.join(libPaths+[os.environ.get("LD_LIBRARY_PATH", os.pathsep.join(["/usr/lib","/lib","/usr/lib64","/lib64"]))])

return self.runNative(prog, cwd, env, stdin, stdout, stderr)

def runVerb(self, verbFile):

return self.runWineTool(["xterm", "-T", "Verb %s" % verbFile, "-hold", "-e", winetricks.WINETRICKS, "--gui", "--no-isolate", verbFile])

def runWinetricks(self, prog):

"""Run a winetricks command

This is only a wrapper for runNative

"""

return self.runWineTool(["xterm", "-T", "Winetricks %s" % prog, "-hold", "-e", winetricks.WINETRICKS, unicode(prog)])

def runWin(self, prog, workingDirectory=".", runInTerminal=False, desktop=None, debug=None, log=None, winePath=False):

"""Run a windows program

Parameters:

prog: this is the program with all paramters as a list

workingDirectory: the working directory, unix- and windows-paths will work

runInTerminal: if this is set the wine call is done with wineconsole instead of wine

debug: user-defined WINEDEBUG-String (see wine manpage)

log: if this is set, wine stderr output will be written to that file

desktop: if this is set, program will be run in a window

"""

if not prog[0].lower().endswith(".exe"):

prog.insert(0, "start")

if os.path.exists(prog[1]): #Path is unix path

prog.insert(1, "/UNIX")

prog.insert(1, "/W")

if desktop:

prog.insert(0, "explorer")

prog.insert(1, "/desktop=%s" % desktop)

if runInTerminal:

prog.insert(0, "wineconsole")

prog.insert(1, "--backend=user")

else:

prog.insert(0, "wine")

cwd = None

if os.path.exists(workingDirectory):

cwd = workingDirectory

if os.path.exists(self.winPathToUnix(workingDirectory)):

cwd = self.winPathToUnix(workingDirectory)

res = self.runWineTool(prog, cwd, stderr=subprocess.PIPE, debug=debug, winePath=winePath)

if log:

with open(log, "w") as fp:

fp.write(res.stderr_data)

return res

def runWinecfg(self, winePath=False):

return self.runWineTool(["wine", "winecfg"], winePath=winePath)

def runRegedit(self, winePath=False):

return self.runWineTool(["wine", "regedit"], winePath=winePath)

def runWineboot(self, winePath=False):

return self.runWineTool(["wine", "wineboot"], winePath=winePath)

def runWinefile(self, directory="C:", winePath=False):

return self.runWineTool(["wine", "winefile", directory], winePath=winePath)

def runUninstaller(self, winePath=False):

return self.runWineTool(["wine", "uninstaller"], winePath=winePath)

def runWineControl(self, winePath=False):

return self.runWineTool(["wine", "control"], winePath=winePath)

def runEject(self, winePath=False):

return self.runWin(["wine", "eject"], winePath=winePath)

def isWindowsPath(path):

return W_SEP in path

def _normalizePath(self, path, sep):

res = []

for el in path.split(sep):

if el == DIR_CUR:

continue

elif el == DIR_UP:

if res:

res.pop()

else:

res.append(el)

return sep.join(res)

def winPathToUnix(self, winPath, basedir=None):

#Handle case-sensitive ambiguities by using existing files/folders when possible

if (D_SEP + W_SEP) in winPath: #path is absolute

drive, rest = winPath.split(D_SEP + W_SEP)

drive = drive.lower()

unixPath = self.getDosDrivesPath() + U_SEP + drive + D_SEP

else:

rest = winPath.replace(W_SEP, U_SEP)

unixPath = self.winPathToUnix(basedir) if basedir else os.path.curdir

winEls = rest.split(W_SEP)

for el in winEls:

if not os.path.exists(unixPath) or os.path.exists(unixPath + U_SEP + el):

unixPath += U_SEP + el

else:

if "~" in el:

globStr = "".join([char if char.upper() == char.lower() else "[%s%s]" % (char.upper(), char.lower()) for char in el.split("~")[0]]) + "*"

else:

globStr = "".join([char if char.upper() == char.lower() else "[%s%s]" % (char.upper(), char.lower()) for char in el])

cands = glob.glob(unixPath + U_SEP + globStr)

if len(cands) == 1:

unixPath = cands[0]

else:

unixPath += U_SEP + el

return os.path.realpath(unixPath)

def unixPathToWin(self, unixPath, basedir=None, drive=None):

if not os.path.isabs(unixPath) and basedir:

unixPath = basedir + U_SEP + unixPath

if drive:

unixPath = os.path.realpath(unixPath)

drivePath = os.path.realpath(self.getDosDrivesPath() + U_SEP + drive + D_SEP)

rel = os.path.relpath(unixPath, drivePath)

if not rel.startswith(DIR_UP):

rel = rel.replace(U_SEP, W_SEP)

return drive + D_SEP + W_SEP + rel

else:

path = None

for drive in os.listdir(self.getDosDrivesPath()):

driveName = drive.replace(D_SEP, '')

p = self.unixPathToWin(unixPath, drive=driveName)

if not p:

continue

if not path or len(p) < len(path):

path = p

return path

def exportData(self, archive):

if not archive:

raise SwineException(self.tr("File name cannot be empty"))

os.chdir(self.getPath())

with TarFile.gzopen(archive, "w") as tar:

tar.add(".") #recursive

def importData(self, archive):

if not archive:

raise SwineException(self.tr("File name cannot be empty"))

os.chdir(self.getPath())

with TarFile.gzopen(archive, "r") as tar:

tar.extractall(".")

if not archive:

raise SwineException(self.tr("File name cannot be empty"))

slot = Slot(name)

slot.create()

slot.importData(archive)

if not os.path.exists(target):

return target

base_list = (os.path.abspath(base)).split(os.sep)

target_list = (os.path.abspath(target)).split(os.sep)

for i in range(min(len(base_list), len(target_list))):

if base_list[i] <> target_list[i]:

break

else:

i+=1

rel_list = [os.pardir] * (len(base_list)-i) + target_list[i:]

try:

config.load()

except:

import traceback

traceback.print_exc()

print >>sys.stderr, tr("Config could not be loaded")

for path in [WINE_PATH, SWINE_PATH, SWINE_SLOT_PATH]:

if not os.path.exists(path):

os.mkdir(path)

print tr("created %s") % path

if not os.path.exists(SWINE_DEFAULT_SLOT_PATH):

os.symlink(WINE_PATH, SWINE_DEFAULT_SLOT_PATH)

print tr("symlinked %s to %s") % (SWINE_DEFAULT_SLOT_PATH, WINE_PATH)

global WINE_WRAPPER

WINE_WRAPPER = "text" in os.popen('file `which wine`', 'r').read()

global defaultSlot

defaultSlot = loadDefaultSlot()

slist = os.listdir(SWINE_SLOT_PATH)

slist.sort()

slots = []

for slot in slist:

if os.path.isdir(os.path.join(SWINE_SLOT_PATH, slot)):

slots.append(loadSlot(slot))

slot = Slot(name)

if not slot.exists():

raise SwineException(tr("Slot does not exist: %s") % name)

slot.loadConfig()

if path:

valid = True

for f in ["bin/wine", "lib/wine/fakedlls"]:

valid = valid and os.path.exists(os.path.join(path, f))

if not valid:

return None

proc = defaultSlot.runWineTool(["wine", "--version"], winePath=path, stdout=subprocess.PIPE)