test/pythonscript.py - new_source_processing - kuzant24/libre-macros

test/pythonscript.py
1 624 строки61 KB
direct-dev.ru
3.10.167
17 июл 2026, 16:13
17 июл 2026, 16:1354c9f8f
# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
#
# This file is part of the LibreOffice project.
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This file incorporates work covered by the following license notice:
#
#   Licensed to the Apache Software Foundation (ASF) under one or more
#   contributor license agreements. See the NOTICE file distributed
#   with this work for additional information regarding copyright
#   ownership. The ASF licenses this file to you under the Apache
#   License, Version 2.0 (the "License"); you may not use this file
#   except in compliance with the License. You may obtain a copy of
#   the License at http://www.apache.org/licenses/LICENSE-2.0 .
#
# XScript implementation for python
import uno
import unohelper
import sys
import os
import types
import time
import ast
import platform
import subprocess
import threading
from com.sun.star.uri.RelativeUriExcessParentSegments import RETAIN

class LogLevel:
    NONE = 0   # production level
    ERROR = 1  # for script developers
    DEBUG = 2  # for script framework developers

PYSCRIPT_LOG_ENV = "PYSCRIPT_LOG_LEVEL"
PYSCRIPT_LOG_STDOUT_ENV = "PYSCRIPT_LOG_STDOUT"

# Configuration ----------------------------------------------------
LogLevel.use = LogLevel.NONE
if os.environ.get(PYSCRIPT_LOG_ENV) == "ERROR":
    LogLevel.use = LogLevel.ERROR
elif os.environ.get(PYSCRIPT_LOG_ENV) == "DEBUG":
    LogLevel.use = LogLevel.DEBUG

# True, writes to stdout (difficult on windows)
# False, writes to user/Scripts/python/log.txt
LOG_STDOUT = os.environ.get(PYSCRIPT_LOG_STDOUT_ENV, "1") != "0"

ENABLE_EDIT_DIALOG=False                    # offers a minimal editor for editing.
#-------------------------------------------------------------------

def encfile(uni):
    return uni.encode( sys.getfilesystemencoding())

def lastException2String():
    (excType,excInstance,excTraceback) = sys.exc_info()
    ret = str(excType) + ": "+str(excInstance) + "\n" + \
          uno._uno_extract_printable_stacktrace( excTraceback )
    return ret

def logLevel2String( level ):
    ret = " NONE"
    if level == LogLevel.ERROR:
        ret = "ERROR"
    elif level >= LogLevel.DEBUG:
        ret = "DEBUG"
    return ret

def getLogTarget():
    ret = sys.stdout
    if not LOG_STDOUT:
        try:
            pathSubst = uno.getComponentContext().ServiceManager.createInstance(
                "com.sun.star.util.PathSubstitution" )
            userInstallation =  pathSubst.getSubstituteVariableValue( "user" )
            if len( userInstallation ) > 0:
                systemPath = uno.fileUrlToSystemPath( userInstallation + "/Scripts/python/log.txt" )
                ret = open( systemPath , "a" )
        except:
            print("Exception during creation of pythonscript logfile: "+ lastException2String() + "\n, delegating log to stdout\n")
    return ret

class Logger(LogLevel):
    def __init__(self , target ):
        self.target = target

    def isDebugLevel( self ):
        return self.use >= self.DEBUG

    def debug( self, msg ):
        if self.isDebugLevel():
            self.log( self.DEBUG, msg )

    def isErrorLevel( self ):
        return self.use >= self.ERROR

    def error( self, msg ):
        if self.isErrorLevel():
            self.log( self.ERROR, msg )

    def log( self, level, msg ):
        if self.use >= level:
            try:
                self.target.write(
                    time.asctime() +
                    " [" +
                    logLevel2String( level ) +
                    "] " +
                    msg +
                    "\n" )
                self.target.flush()
            except:
                print("Error during writing to stdout: " +lastException2String() + "\n")

log = Logger( getLogTarget() )

log.debug( "pythonscript loading" )

#from com.sun.star.lang import typeOfXServiceInfo, typeOfXTypeProvider
from com.sun.star.uno import RuntimeException
from com.sun.star.lang import IllegalArgumentException
from com.sun.star.container import NoSuchElementException
from com.sun.star.lang import XServiceInfo
from com.sun.star.io import IOException
from com.sun.star.ucb import CommandAbortedException, XCommandEnvironment, XProgressHandler, Command
from com.sun.star.task import XInteractionHandler
from com.sun.star.beans import XPropertySet, Property
from com.sun.star.container import XNameContainer
from com.sun.star.xml.sax import XDocumentHandler, InputSource
from com.sun.star.uno import Exception as UnoException
from com.sun.star.script import XInvocation
from com.sun.star.awt import XActionListener

from com.sun.star.script.provider import XScriptProvider, XScript, XScriptContext, ScriptFrameworkErrorException
from com.sun.star.script.browse import XBrowseNode
from com.sun.star.script.browse.BrowseNodeTypes import SCRIPT, CONTAINER, ROOT
from com.sun.star.util import XModifyListener

LANGUAGENAME = "Python"
GLOBAL_SCRIPTCONTEXT_NAME = "XSCRIPTCONTEXT"
CALLABLE_CONTAINER_NAME =  "g_exportedScripts"

# pythonloader looks for a static g_ImplementationHelper variable
g_ImplementationHelper = unohelper.ImplementationHelper()
g_implName = "org.libreoffice.pyuno.LanguageScriptProviderFor"+LANGUAGENAME



BLOCK_SIZE = 65536
def readTextFromStream( inputStream ):
    # read the file
    code = uno.ByteSequence( b"" )
    while True:
        read,out = inputStream.readBytes( None , BLOCK_SIZE )
        code = code + out
        if read < BLOCK_SIZE:
           break
    return code.value

def toIniName( str ):
    if platform.system() == "Windows":
        return str + ".ini"
    else:
        return str + "rc"


""" definition: storageURI is the system dependent, absolute file url, where the script is stored on disk
                scriptURI is the system independent uri
"""
class MyUriHelper:

    def __init__( self, ctx, location ):
        self.ctx = ctx
        self.s_UriMap = \
        { "share" : "vnd.sun.star.expand:$BRAND_BASE_DIR/$BRAND_SHARE_SUBDIR/Scripts/python" , \
          "share:uno_packages" : "vnd.sun.star.expand:$UNO_SHARED_PACKAGES_CACHE/uno_packages", \
          "user" : "vnd.sun.star.expand:${$BRAND_INI_DIR/" + toIniName( "bootstrap") + "::UserInstallation}/user/Scripts/python" , \
          "user:uno_packages" : "vnd.sun.star.expand:$UNO_USER_PACKAGES_CACHE/uno_packages" }
        self.m_uriRefFac = ctx.ServiceManager.createInstanceWithContext("com.sun.star.uri.UriReferenceFactory",ctx)
        if location.startswith( "vnd.sun.star.tdoc" ):
            self.m_baseUri = location + "/Scripts/python"
            self.m_scriptUriLocation = "document"
        else:
            self.m_baseUri = expandUri( self.s_UriMap[location] )
            self.m_scriptUriLocation = location
        log.debug( "initialized urihelper with baseUri="+self.m_baseUri + ",m_scriptUriLocation="+self.m_scriptUriLocation )

    def getRootStorageURI( self ):
        return self.m_baseUri

    def getStorageURI( self, scriptURI ):
        return self.scriptURI2StorageUri(scriptURI)

    def getScriptURI( self, storageURI ):
        return self.storageURI2ScriptUri(storageURI)

    def storageURI2ScriptUri( self, storageURI ):
        if not storageURI.startswith( self.m_baseUri ):
            message = "pythonscript: storage uri '" + storageURI + "' not in base uri '" + self.m_baseUri + "'"
            log.debug( message )
            raise RuntimeException( message, self.ctx )

        ret = "vnd.sun.star.script:" + \
              storageURI[len(self.m_baseUri)+1:].replace("/","|") + \
              "?language=" + LANGUAGENAME + "&location=" + self.m_scriptUriLocation
        log.debug( "converting storageURI="+storageURI + " to scriptURI=" + ret )
        return ret

    def scriptURI2StorageUri( self, scriptURI ):
        try:
            # base path to the python script location
            sBaseUri = self.m_baseUri + "/"
            xBaseUri = self.m_uriRefFac.parse(sBaseUri)

            # path to the .py file + "$functionname, arguments, etc
            xStorageUri = self.m_uriRefFac.parse(scriptURI)
            # getName will apply url-decoding to the name, so encode back
            sStorageUri = xStorageUri.getName().replace("%", "%25")
            sStorageUri = sStorageUri.replace( "|", "/" )

            # path to the .py file, relative to the base
            funcNameStart = sStorageUri.find("$")
            if funcNameStart != -1:
                sFileUri = sStorageUri[0:funcNameStart]
                sFuncName = sStorageUri[funcNameStart+1:]
            else:
                sFileUri = sStorageUri

            xFileUri = self.m_uriRefFac.parse(sFileUri)
            if not xFileUri:
                message = "pythonscript: invalid relative uri '" + sFileUri+ "'"
                log.debug( message )
                raise RuntimeException( message, self.ctx )

            if not xFileUri.hasRelativePath():
                message = "pythonscript: an absolute uri is invalid '" + sFileUri+ "'"
                log.debug( message )
                raise RuntimeException( message, self.ctx )

            # absolute path to the .py file
            xAbsScriptUri = self.m_uriRefFac.makeAbsolute(xBaseUri, xFileUri, True, RETAIN)
            sAbsScriptUri = xAbsScriptUri.getUriReference()

            # ensure py file is under the base path
            if not sAbsScriptUri.startswith(sBaseUri):
                message = "pythonscript: storage uri '" + sAbsScriptUri + "' not in base uri '" + self.m_baseUri + "'"
                log.debug( message )
                raise RuntimeException( message, self.ctx )

            ret = sAbsScriptUri
            if funcNameStart != -1:
                ret = ret + "$" + sFuncName
            log.debug( "converting scriptURI="+scriptURI + " to storageURI=" + ret )
            return ret
        except UnoException as e:
            log.error( "error during converting scriptURI="+scriptURI + ": " + e.Message)
            raise RuntimeException( "pythonscript:scriptURI2StorageUri: " + e.Message, self.ctx )
        except Exception as e:
            log.error( "error during converting scriptURI="+scriptURI + ": " + str(e))
            raise RuntimeException( "pythonscript:scriptURI2StorageUri: " + str(e), self.ctx )


class ModuleEntry:
    def __init__( self, lastRead, module ):
        self.lastRead = lastRead
        self.module = module

def hasChanged( oldDate, newDate ):
    return newDate.Year > oldDate.Year or \
           newDate.Month > oldDate.Month or \
           newDate.Day > oldDate.Day or \
           newDate.Hours > oldDate.Hours or \
           newDate.Minutes > oldDate.Minutes or \
           newDate.Seconds > oldDate.Seconds or \
           newDate.NanoSeconds > oldDate.NanoSeconds

def ensureSourceState( code ):
    if code.endswith(b"\n"):
        code = code + b"\n"
    code = code.replace(b"\r", b"")
    return code


def checkForPythonPathBesideScript( url ):
    if url.startswith( "file:" ):
        path = unohelper.fileUrlToSystemPath( url+"/pythonpath.zip" );
        log.log( LogLevel.DEBUG,  "checking for existence of " + path )
        if 1 == os.access( encfile(path), os.F_OK) and not path in sys.path:
            log.log( LogLevel.DEBUG, "adding " + path + " to sys.path" )
            sys.path.append( path )

        path = unohelper.fileUrlToSystemPath( url+"/pythonpath" );
        log.log( LogLevel.DEBUG,  "checking for existence of " + path )
        if 1 == os.access( encfile(path), os.F_OK) and not path in sys.path:
            log.log( LogLevel.DEBUG, "adding " + path + " to sys.path" )
            sys.path.append( path )


class ScriptContext(unohelper.Base):
    def __init__( self, ctx, doc, inv ):
        self.ctx = ctx
        self.doc = doc
        self.inv = inv

   # XScriptContext
    def getDocument(self):
        if self.doc:
            return self.doc
        return self.getDesktop().getCurrentComponent()

    def getDesktop(self):
        return self.ctx.ServiceManager.createInstanceWithContext(
            "com.sun.star.frame.Desktop", self.ctx )

    def getComponentContext(self):
        return self.ctx

    def getInvocationContext(self):
        return self.inv

#----------------------------------
# Global Module Administration
# does not fit together with script
# engine lifetime management
#----------------------------------
#g_scriptContext = ScriptContext( uno.getComponentContext(), None )
#g_modules = {}
#def getModuleByUrl( url, sfa ):
#    entry =  g_modules.get(url)
#    load = True
#    lastRead = sfa.getDateTimeModified( url )
#    if entry:
#        if hasChanged( entry.lastRead, lastRead ):
#            log.debug("file " + url + " has changed, reloading")
#        else:
#            load = False
#
#    if load:
#        log.debug( "opening >" + url + "<" )
#
#        code = readTextFromStream( sfa.openFileRead( url ) )

        # execute the module
#        entry = ModuleEntry( lastRead, types.ModuleType("ooo_script_framework") )
#        entry.module.__dict__[GLOBAL_SCRIPTCONTEXT_NAME] = g_scriptContext
#        entry.module.__file__ = url
#        exec code in entry.module.__dict__
#        g_modules[ url ] = entry
#        log.debug( "mapped " + url + " to " + str( entry.module ) )
#    return entry.module

tempDirName = "AlterOfficeScripts"
dirDelimeter = "/"

class ProviderContext:
    def __init__( self, storageType, sfa, uriHelper, scriptContext ):
        self.storageType = storageType
        self.sfa = sfa
        self.uriHelper = uriHelper
        self.scriptContext = scriptContext
        self.modules = {}
        self.rootUrl = None
        self.mapPackageName2Path = None

    def getTransientPartFromUrl( self, url ):
        rest = url.replace( self.rootUrl , "",1 ).replace( "/","",1)
        return rest[0:rest.find("/")]

    def getPackageNameFromUrl( self, url ):
        rest = url.replace( self.rootUrl , "",1 ).replace( "/","",1)
        start = rest.find("/") +1
        return rest[start:rest.find("/",start)]


    def removePackageByUrl( self, url ):
        items = self.mapPackageName2Path.items()
        for i in items:
            if url in i[1].paths:
                self.mapPackageName2Path.pop(i[0])
                break

    def addPackageByUrl( self, url ):
        packageName = self.getPackageNameFromUrl( url )
        transientPart = self.getTransientPartFromUrl( url )
        log.debug( "addPackageByUrl : " + packageName + ", " + transientPart + "("+url+")" + ", rootUrl="+self.rootUrl )
        if packageName in self.mapPackageName2Path:
            package = self.mapPackageName2Path[ packageName ]
            package.paths = package.paths + (url, )
        else:
            package = Package( (url,), transientPart)
            self.mapPackageName2Path[ packageName ] = package

    def isUrlInPackage( self, url ):
        values = self.mapPackageName2Path.values()
        for i in values:
#           print ("checking " + url + " in " + str(i.paths))
            if url in i.paths:
               return True
#        print ("false")
        return False

    def setPackageAttributes( self, mapPackageName2Path, rootUrl ):
        self.mapPackageName2Path = mapPackageName2Path
        self.rootUrl = rootUrl

    def getPersistentUrlFromStorageUrl( self, url ):
        # package name is the second directory
        ret = url
        if self.rootUrl:
            pos = len( self.rootUrl) +1
            ret = url[0:pos]+url[url.find("/",pos)+1:len(url)]
        log.debug( "getPersistentUrlFromStorageUrl " + url +  " -> "+ ret)
        return ret

    def getStorageUrlFromPersistentUrl( self, url):
        ret = url
        if self.rootUrl:
            pos = len(self.rootUrl)+1
            packageName = url[pos:url.find("/",pos+1)]
            package = self.mapPackageName2Path[ packageName ]
            ret = url[0:pos]+ package.transientPathElement + "/" + url[pos:len(url)]
        log.debug( "getStorageUrlFromPersistentUrl " + url + " -> "+ ret)
        return ret

    def getFuncsByUrl( self, url ):
        src = readTextFromStream( self.sfa.openFileRead( url ) )
        checkForPythonPathBesideScript( url[0:url.rfind('/')] )
        src = ensureSourceState( src )

        try:
            code = ast.parse( src )
        except:
            log.isDebugLevel() and log.debug( "pythonscript: getFuncsByUrl: exception while parsing: " + lastException2String())
            raise

        allFuncs = []

        if code is None:
            return allFuncs

        g_exportedScripts = []
        for node in ast.iter_child_nodes(code):
            if isinstance(node, ast.FunctionDef):
                allFuncs.append(node.name)
            elif isinstance(node, ast.Assign):
                for target in node.targets:
                    try:
                        identifier = target.id
                    except AttributeError:
                        identifier = ""
                        pass
                    if identifier == "g_exportedScripts":
                        for value in node.value.elts:
                            g_exportedScripts.append(value.id)
                        return g_exportedScripts

# Python 2 only
#        for node in code.node.nodes:
#            if node.__class__.__name__ == 'Function':
#                allFuncs.append(node.name)
#            elif node.__class__.__name__ == 'Assign':
#                for assignee in node.nodes:
#                    if assignee.name == 'g_exportedScripts':
#                        for item in node.expr.nodes:
#                            if item.__class__.__name__ == 'Name':
#                                g_exportedScripts.append(item.name)
#                        return g_exportedScripts

        return allFuncs

    def getModuleByUrl( self, url ):
        entry =  self.modules.get(url)
        load = True
        lastRead = self.sfa.getDateTimeModified( url )
        if entry:
            if hasChanged( entry.lastRead, lastRead ):
                log.debug( "file " + url + " has changed, reloading" )
            else:
                load = False

        if load:
            log.debug( "opening >" + url + "<" )

            src = readTextFromStream( self.sfa.openFileRead( url ) )
            checkForPythonPathBesideScript( url[0:url.rfind('/')] )
            src = ensureSourceState( src )

            # execute the module
            entry = ModuleEntry( lastRead, types.ModuleType("ooo_script_framework") )
            entry.module.__dict__[GLOBAL_SCRIPTCONTEXT_NAME] = self.scriptContext

            code = None
            splittedUri = ""
            if url.startswith( "file:" ):
                if os.name == 'nt':
                    splittedUri = (uno.fileUrlToSystemPath(url)).split("\\")
                else:
                    splittedUri = (uno.fileUrlToSystemPath(url)).split(dirDelimeter)
            else:
                splittedUri = url.split(dirDelimeter)

            if (len(splittedUri) < 2):
                raise Exception("Incorrect file uri: {}".format(url))
            baseFileName = splittedUri[-1]
            tempFileUrl = uno.tempDirUrl() + dirDelimeter + tempDirName + dirDelimeter + baseFileName
            self.sfa.createFolder(uno.tempDirUrl() + dirDelimeter + tempDirName)
            self.sfa.copy(url, tempFileUrl)
            fileFullUrl = tempFileUrl

            copyFileUrl = fileFullUrl + '.temp'
            with open(fileFullUrl, 'r', encoding="utf-8") as scriptFile, open(copyFileUrl, 'w', encoding="utf-8") as outputFile:
                isInside = False
                for line in scriptFile:
                    # Do not execute any calls outside of functions or classes, we need only dictionary
                    if line.startswith(("from", "import")):
                        if "IDE_utils" not in line:
                            outputFile.write(line)
                    elif line.startswith(("def", "class")):
                        isInside = True
                        outputFile.write(line)
                    elif isInside and line.startswith(" "):
                        outputFile.write(line)
                    elif line.strip():
                        isInside = False

            os.replace(copyFileUrl, fileFullUrl)

            src = readTextFromStream( self.sfa.openFileRead( fileFullUrl ) )
            checkForPythonPathBesideScript( fileFullUrl[0:fileFullUrl.rfind('/')] )
            src = ensureSourceState( src )

            code = compile( src, encfile(fileFullUrl), "exec" )
            os.remove(fileFullUrl)

            thread = threading.Thread(target=exec, args=[code, entry.module.__dict__])
            thread.start()
            thread.join(10)
            entry.module.__file__ = url
            self.modules[ url ] = entry
            log.debug( "mapped " + url + " to " + str( entry.module ) )
        return  entry.module

#--------------------------------------------------
def isScript( candidate ):
    ret = False
    if isinstance( candidate, type(isScript) ):
        ret = True
    return ret

#-------------------------------------------------------
asyncTasksSet = set()
asyncTasksLock = threading.Lock()

class FileData:
    def __init__(self, fileName, browseNode):
        self.fileName = fileName
        self.browseNode = browseNode

    def __eq__(self, other):
        if not isinstance(other, FileData):
            return NotImplemented
        return self.fileName == other.fileName and self.browseNode == other.browseNode

    def __hash__(self):
        return hash((self.fileName, self.browseNode.uri))

watchdogLock = threading.Lock()
watchdogFiles = set()

def checkFileIsInWork(fileData):
    fileName = fileData.fileName
    browseNode = fileData.browseNode
    if os.path.exists(fileName):
        try:
            browseNode.provCtx.sfa.copy(fileName, browseNode.uri)
            return True
        except OSError as e:
            try:
                os.remove(fileName)
            except Exception as e:
                return False
            return False
    else:
        return False
    return True

def watchdogMain():
    global watchdogFiles
    isRequired = True
    while isRequired:
        time.sleep(2)

        watchdogLock.acquire()
        filteredFiles = [fileData for fileData in watchdogFiles if checkFileIsInWork(fileData)]
        watchdogFiles = set(filteredFiles)

        if not watchdogFiles:
            isRequired = False

        watchdogLock.release()

    return None

def removeAsyncTask( task ):
    global watchdogFiles

    asyncTasksLock.acquire()
    asyncTasksSet.discard(task)
    asyncTasksLock.release()
    if not bool(asyncTasksSet):
        watchdogLock.acquire()
        filteredFiles = [fileData for fileData in watchdogFiles if checkFileIsInWork(fileData)]
        watchdogFiles.clear()
        watchdogLock.release()

def addAsyncTask( asyncTask, *taskArgs ):
    def removableAsyncTaskDecorator( asyncTask, *taskArgs ):
        asyncTask(*taskArgs)
        removeAsyncTask(threading.current_thread())
    thread = threading.Thread(target=removableAsyncTaskDecorator, args=[asyncTask, *taskArgs])
    asyncTasksLock.acquire()
    asyncTasksSet.add(thread)
    asyncTasksLock.release()
    thread.start()

def callEditable( systemEditorUrl, systemFileUrl ):
    cwd = os.getcwd()
    os.chdir(systemEditorUrl[0:systemEditorUrl.rfind(dirDelimeter)])
    process = subprocess.Popen([systemEditorUrl, systemFileUrl], shell = os.name == 'nt')
    os.chdir(cwd)
    process.wait()

def callEditableAsync( browseNode ):
    global watchdogFiles

    systemEditorUrl = browseNode.editorUrl
    systemEditorFullUrl = os.getcwd() + "/" + browseNode.editorUrl
    if os.name == 'nt':
        systemEditorFullUrl = systemEditorFullUrl + ".exe"
    if not os.path.exists(systemEditorFullUrl):
        stream = os.popen('which alteroffice')
        alterofficePath = stream.read()
        stream = os.popen('readlink -f ' + alterofficePath)
        alterofficePath = stream.read().strip()
        systemEditorFullUrl = alterofficePath[:alterofficePath.rfind("/")] + "/" + browseNode.editorUrl
        if not os.path.exists(systemEditorFullUrl):
            raise Exception("There is no editor or IDE specialized: {}".format(systemEditorFullUrl))

    failure = False
    result = ""
    try:
        systemFileUrl = uno.fileUrlToSystemPath(browseNode.uri)
        if not os.path.exists(systemFileUrl):
            failure = True
    except:
        systemFileUrl = callExportable( browseNode, None )
        if not os.path.exists(systemFileUrl):
            failure = False
        else:
            watchdogLock.acquire()
            if not watchdogFiles:
                watchdogThread = threading.Thread(target=watchdogMain)
                watchdogThread.start()
            fileData = FileData(systemFileUrl, browseNode)
            watchdogFiles.add(fileData)
            watchdogLock.release()
            result = systemFileUrl

    if failure:
        raise Exception("Script file doesn't exist: {}".format(browseNode.uri))
    addAsyncTask( callEditable, systemEditorFullUrl, systemFileUrl )
    return result

def callCreatableDir( systemDirUrl, browseNode ):
    browseNode.provCtx.sfa.createFolder(systemDirUrl)

def callCreatableScript( systemScriptUrl, browseNode ):
    try:
        browseNode.provCtx.sfa.openFileWrite(systemScriptUrl)
        if browseNode.provCtx.sfa.exists(systemScriptUrl):
            return
    except Exception as e:
        log.error("callCreatableScript failed base path: " + str(e))

    #hack to create script inside document
    if not browseNode.provCtx.sfa.exists(systemScriptUrl):
        tempFileUrl = uno.tempDirUrl() + dirDelimeter + tempDirName + dirDelimeter + "TempFileName_" + systemScriptUrl.split(dirDelimeter)[-1]
        if browseNode.provCtx.sfa.exists(tempFileUrl):
            raise Exception("Cannot create script, please clear cache or use import option")
        try:
            browseNode.provCtx.sfa.openFileWrite(tempFileUrl)
            browseNode.provCtx.sfa.copy(tempFileUrl, systemScriptUrl)
            os.remove(tempFileUrl)
        except Exception as e:
            os.remove(tempFileUrl)
    else:
        raise Exception("File already exists")

def callCreatableAsync( browseNode, name, type ):
    if not hasattr(browseNode, 'rootUrl'):
        if not hasattr(browseNode, 'dirBrowseNode'):
            raise Exception("Unexpected node for creation")
        nodeUrl = browseNode.dirBrowseNode.rootUrl
    else:
        nodeUrl = browseNode.rootUrl

    try:
        rootStorageUrl = browseNode.provCtx.uriHelper.getRootStorageURI()
        if not browseNode.provCtx.sfa.exists(rootStorageUrl):
            browseNode.provCtx.sfa.createFolder(rootStorageUrl)
        systemDirUrl = uno.fileUrlToSystemPath(nodeUrl)
        if not os.path.exists(systemDirUrl):
            browseNode.provCtx.sfa.createFolder(systemDirUrl)
    except:
        if not browseNode.provCtx.sfa.exists(nodeUrl):
            raise Exception("Path doesn't exist: {}".format(nodeUrl))

    systemPathUrl = nodeUrl + "/" + name
    if type == "File":
        systemPathUrl = systemPathUrl + ".py"
    if browseNode.provCtx.sfa.exists(systemPathUrl):
        raise Exception("Path already exists: {}".format(systemPathUrl))

    if type == "Directory":
        addAsyncTask( callCreatableDir, systemPathUrl, browseNode )
        dirBrowseNode = DirBrowseNode( browseNode.provCtx, name, systemPathUrl )
        dirBrowseNode.isNewlyCreated = True
        return dirBrowseNode
    else:
        addAsyncTask( callCreatableScript, systemPathUrl, browseNode )
        fileBrowseNode = FileBrowseNode( browseNode.provCtx, systemPathUrl, name )
        fileBrowseNode.isNewlyCreated = True
        return fileBrowseNode

def callDeletable( browseNode ):
    systemNodeUrl = browseNode.rootUrl if hasattr(browseNode, 'rootUrl') else browseNode.uri
    browseNode.provCtx.sfa.kill(systemNodeUrl)

def callRenamable( browseNode, name ):
    systemNodeUrl = browseNode.rootUrl if hasattr(browseNode, 'rootUrl') else browseNode.uri
    newNodeUrl = systemNodeUrl[:systemNodeUrl.rfind(dirDelimeter) + 1] + name
    if hasattr(browseNode, 'uri') and browseNode.uri.endswith( ".py" ) and not newNodeUrl.endswith( ".py" ):
        newNodeUrl = newNodeUrl + ".py"
    browseNode.provCtx.sfa.move(systemNodeUrl, newNodeUrl)
    browseNode.name = name
    if hasattr(browseNode, 'rootUrl'):
        browseNode.rootUrl = newNodeUrl
    if hasattr(browseNode, 'uri'):
        browseNode.uri = newNodeUrl

def callExportable( browseNode, systemFileUrl ):
    sfa = browseNode.provCtx.sfa
    if not systemFileUrl:
        tempFileName = browseNode.fileName if hasattr(browseNode, 'fileName') else browseNode.name
        splittedUri = browseNode.uri.split(dirDelimeter)
        if (len(splittedUri) < 2):
            raise Exception("Incorrect file uri: {}".format(browseNode.uri))
        baseFileName = splittedUri[1]

        tempDirUrl = uno.tempDirUrl() + dirDelimeter + tempDirName + dirDelimeter + baseFileName
        sfa.createFolder(tempDirUrl)
        tempFileUrl = tempDirUrl + dirDelimeter + tempFileName + ".py"
        sfa.copy(browseNode.uri, tempFileUrl)
        return tempFileUrl
    else:
        systemNodeUrl = browseNode.rootUrl if hasattr(browseNode, 'rootUrl') else browseNode.uri
        sfa.copy(systemNodeUrl, systemFileUrl)
        return systemFileUrl

def callImportable( systemFileUrl, browseNode ):
    if not browseNode.provCtx.sfa.exists(systemFileUrl):
        raise Exception("Couldn't import, path doesn't exist: {}".format(systemFileUrl))
    fileName = systemFileUrl.split(dirDelimeter)[-1]
    fileNameInner = (browseNode.rootUrl if hasattr(browseNode, 'rootUrl') else browseNode.provCtx.uriHelper.getRootStorageURI()) + dirDelimeter + fileName
    if not fileNameInner.endswith( ".py" ):
        fileNameInner = fileNameInner + ".py"
    else:
        fileName = fileName[:-3]
    browseNode.provCtx.sfa.createFolder(browseNode.provCtx.uriHelper.getRootStorageURI())

    fileNameInnerResult = fileNameInner
    fileNameResult = fileName
    index = 1
    while browseNode.provCtx.sfa.exists(fileNameInnerResult):
        fileNameInnerResult = fileNameInner[:-3] + str(index) + ".py"
        fileNameResult = fileName + str(index)
        index = index + 1

    browseNode.provCtx.sfa.copy(systemFileUrl, fileNameInnerResult)
    return FileBrowseNode( browseNode.provCtx, fileNameInnerResult, fileNameResult )

#-------------------------------------------------------
class ScriptBrowseNode( unohelper.Base, XBrowseNode , XPropertySet, XInvocation, XActionListener ):
    def __init__( self, provCtx, uri, fileName, funcName ):
        self.fileName = fileName
        self.funcName = funcName
        self.provCtx = provCtx
        self.uri = uri
        self.editorUrl = "pythonide/pyzolauncher"
        self.tempFileUrl = ""

    def __del__(self):
        if os.path.exists(self.tempFileUrl):
            os.remove(self.tempFileUrl)

    def getName( self ):
        return self.funcName

    def getChildNodes(self):
        return ()

    def hasChildNodes(self):
        return False

    def getType( self):
        return SCRIPT

    def getPropertyValue( self, name ):
        ret = None
        try:
            if name == "URI":
                ret = self.provCtx.uriHelper.getScriptURI(
                    self.provCtx.getPersistentUrlFromStorageUrl( self.uri + "$" + self.funcName ) )
            elif name == "Editable":
                ret = True
            elif name == "Exportable":
                ret = True
            elif name == "ReadOnly":
                ret = self.provCtx.sfa.isReadOnly( self.uri )

            log.debug( "ScriptBrowseNode.getPropertyValue called for " + name + ", returning " + str(ret) )
        except:
            log.error( "ScriptBrowseNode.getPropertyValue error " + lastException2String())
            raise

        return ret
    def setPropertyValue( self, name, value ):
        log.debug( "ScriptBrowseNode.setPropertyValue called " + name + "=" +str(value ) )
    def getPropertySetInfo( self ):
        log.debug( "ScriptBrowseNode.getPropertySetInfo called "  )
        return None

    def getIntrospection( self ):
        return None

    def invoke( self, name, params, outparamindex, outparams ):
        if name == "Editable":
            self.tempFileUrl = callEditableAsync(self)
        elif name == "Exportable":
            return callExportable(self, params[0]), (), ()
        return self, (), ()

    def actionPerformed( self, event ):
        try:
            if event.ActionCommand == "Run":
                code = self.editor.getControl("EditorTextField").getText()
                code = ensureSourceState( code )
                mod = types.ModuleType("ooo_script_framework")
                mod.__dict__[GLOBAL_SCRIPTCONTEXT_NAME] = self.provCtx.scriptContext
                exec(code, mod.__dict__)
                values = mod.__dict__.get( CALLABLE_CONTAINER_NAME , None )
                if not values:
                    values = mod.__dict__.values()

                for i in values:
                    if isScript( i ):
                        i()
                        break

            elif event.ActionCommand == "Save":
                toWrite = uno.ByteSequence(
                    self.editor.getControl("EditorTextField").getText().encode(
                    sys.getdefaultencoding()) )
                copyUrl = self.uri + ".orig"
                self.provCtx.sfa.move( self.uri, copyUrl )
                out = self.provCtx.sfa.openFileWrite( self.uri )
                out.writeBytes( toWrite )
                out.close()
                self.provCtx.sfa.kill( copyUrl )
#                log.debug("Save is not implemented yet")
#                text = self.editor.getControl("EditorTextField").getText()
#                log.debug("Would save: " + text)
        except:
            # TODO: add an error box here!
            log.error( lastException2String() )


    def setValue( self, name, value ):
        return None

    def getValue( self, name ):
        return None

    def hasMethod( self, name ):
        return False

    def hasProperty( self, name ):
        return False


#-------------------------------------------------------
class FileBrowseNode( unohelper.Base, XBrowseNode, XPropertySet, XInvocation ):
    def __init__( self, provCtx, uri , name ):
        self.provCtx = provCtx
        self.uri = uri
        self.name = name
        self.funcnames = None
        self.editorUrl = "pythonide/pyzolauncher"
        self.tempFileUrl = ""
        self.isNewlyCreated = False

    def __del__(self):
        if os.path.exists(self.tempFileUrl):
            os.remove(self.tempFileUrl)

    def getName( self ):
        return self.name

    def getChildNodes(self):
        ret = ()
        try:
            self.funcnames = self.provCtx.getFuncsByUrl( self.uri )

            scriptNodeList = []
            for i in self.funcnames:
                scriptNodeList.append(
                    ScriptBrowseNode(
                    self.provCtx, self.uri, self.name, i ))
            ret = tuple( scriptNodeList )
            log.debug( "returning " +str(len(ret)) + " ScriptChildNodes on " + self.uri )
        except:
            text = lastException2String()
            log.error( "Error while evaluating " + self.uri + ":" + text )
            raise
        return ret

    def hasChildNodes(self):
        try:
            return len(self.getChildNodes()) > 0
        except:
            return False

    def getType( self):
        return CONTAINER

    def getPropertyValue( self, name ):
        ret = None
        try:
            if name == "URI":
                ret = self.provCtx.uriHelper.getScriptURI(
                    self.provCtx.getPersistentUrlFromStorageUrl( self.uri + "$" ) )
            elif name == "Editable":
                ret = True
            elif name == "Deletable":
                ret = self.isNewlyCreated or not self.provCtx.sfa.isReadOnly( self.uri )
            elif name == "Renamable":
                ret = self.isNewlyCreated or not self.provCtx.sfa.isReadOnly( self.uri )
            elif name == "Exportable":
                ret = True
            elif name == "ReadOnly":
                ret = not self.isNewlyCreated and self.provCtx.sfa.isReadOnly( self.uri )
            elif name == "FileNode":
                ret = True
        except:
            raise

        return ret

    def setPropertyValue( self, name, value ):
        log.debug( "FileBrowseNode.setPropertyValue called " + name + "=" +str(value ) )

    def getPropertySetInfo( self ):
        log.debug( "FileBrowseNode.getPropertySetInfo called "  )

    def invoke( self, name, params, outparamindex, outparams ):
        if name == "Editable":
            self.tempFileUrl = callEditableAsync(self)
        elif name == "Deletable":
            callDeletable(self)
            return True, (), ()
        elif name == "Renamable":
            callRenamable(self, params[0])
            return self, (), ()
        elif name == "Exportable":
            return callExportable(self, params[0]), (), ()
        return self, (), ()

class DirBrowseNode( unohelper.Base, XBrowseNode, XPropertySet, XInvocation ):
    def __init__( self, provCtx, name, rootUrl ):
        self.provCtx = provCtx
        self.name = name
        self.rootUrl = rootUrl
        self.isNewlyCreated = False

    def getName( self ):
        return self.name

    def getChildNodes( self ):
        try:
            log.debug( "DirBrowseNode.getChildNodes called for " + self.rootUrl )
            contents = self.provCtx.sfa.getFolderContents( self.rootUrl, True )
            browseNodeList = []
            for i in contents:
                if i.endswith( ".py" ):
                    log.debug( "adding filenode " + i )
                    browseNodeList.append(
                        FileBrowseNode( self.provCtx, i, i[i.rfind("/")+1:len(i)-3] ) )
                elif self.provCtx.sfa.isFolder( i ) and not i.endswith("/pythonpath"):
                    log.debug( "adding DirBrowseNode " + i )
                    browseNodeList.append( DirBrowseNode( self.provCtx, i[i.rfind("/")+1:len(i)],i))
            return tuple( browseNodeList )
        except Exception as e:
            text = lastException2String()
            log.error( "DirBrowseNode error: " + str(e) + " while evaluating " + self.rootUrl)
            log.error( text)
            return ()

    def hasChildNodes( self ):
        return True

    def getType( self ):
        return CONTAINER

    def getScript( self, uri ):
        log.debug( "DirBrowseNode getScript " + uri + " invoked" )
        raise IllegalArgumentException( "DirBrowseNode couldn't instantiate script " + uri , self , 0 )

    def getPropertyValue( self, name ):
        ret = None
        try:
            if name == "Creatable":
                ret = self.isNewlyCreated or not self.provCtx.sfa.isReadOnly( self.rootUrl )
            elif name == "Deletable":
                ret = self.isNewlyCreated or not self.provCtx.sfa.isReadOnly( self.rootUrl )
            elif name == "Renamable":
                ret = self.isNewlyCreated or not self.provCtx.sfa.isReadOnly( self.rootUrl )
            elif name == "Exportable":
                ret = True
            elif name == "Importable":
                ret = self.isNewlyCreated or not self.provCtx.sfa.isReadOnly( self.rootUrl )
            elif name == "ReadOnly":
                ret = not self.isNewlyCreated and self.provCtx.sfa.isReadOnly( self.rootUrl )
        except:
            raise

        return ret

    def setPropertyValue( self, name, value ):
        log.debug( "DirBrowseNode.setPropertyValue called " + name + "=" +str(value ) )

    def getPropertySetInfo( self ):
        log.debug( "DirBrowseNode.getPropertySetInfo called "  )

    def invoke( self, name, params, outparamindex, outparams ):
        if name == "Creatable":
            return callCreatableAsync(self, params[0], params[1]), (), ()
        elif name == "Deletable":
            callDeletable(self)
            return True, (), ()
        elif name == "Renamable":
            callRenamable(self, params[0])
            return self, (), ()
        elif name == "Exportable":
            return callExportable(self, params[0]), (), ()
        elif name == "Importable":
            return callImportable(params[0], self), (), ()
        return self, (), ()


class ManifestHandler( XDocumentHandler, unohelper.Base ):
    def __init__( self, rootUrl ):
        self.rootUrl = rootUrl

    def startDocument( self ):
        self.urlList = []

    def endDocument( self ):
        pass

    def startElement( self , name, attlist):
        if name == "manifest:file-entry":
            if attlist.getValueByName( "manifest:media-type" ) == "application/vnd.sun.star.framework-script":
                self.urlList.append(
                    self.rootUrl + "/" + attlist.getValueByName( "manifest:full-path" ) )

    def endElement( self, name ):
        pass

    def characters ( self, chars ):
        pass

    def ignoreableWhitespace( self, chars ):
        pass

    def setDocumentLocator( self, locator ):
        pass

def isPyFileInPath( sfa, path ):
    ret = False
    contents = sfa.getFolderContents( path, True )
    for i in contents:
        if sfa.isFolder(i):
            ret = isPyFileInPath(sfa,i)
        else:
            if i.endswith(".py"):
                ret = True
        if ret:
            break
    return ret

# extracts META-INF directory from
def getPathsFromPackage( rootUrl, sfa ):
    ret = ()
    try:
        fileUrl = rootUrl + "/META-INF/manifest.xml"
        inputStream = sfa.openFileRead( fileUrl )
        parser = uno.getComponentContext().ServiceManager.createInstance( "com.sun.star.xml.sax.Parser" )
        handler = ManifestHandler( rootUrl )
        parser.setDocumentHandler( handler )
        parser.parseStream( InputSource( inputStream , "", fileUrl, fileUrl ) )
        for i in tuple(handler.urlList):
            if not isPyFileInPath( sfa, i ):
                handler.urlList.remove(i)
        ret = tuple( handler.urlList )
    except UnoException:
        text = lastException2String()
        log.debug( "getPathsFromPackage " + fileUrl + " Exception: " +text )
        pass
    return ret


class Package:
    def __init__( self, paths, transientPathElement ):
        self.paths = paths
        self.transientPathElement = transientPathElement

class DummyInteractionHandler( unohelper.Base, XInteractionHandler ):
    def __init__( self ):
        pass
    def handle( self, event):
        log.debug( "pythonscript: DummyInteractionHandler.handle " + str( event ) )

class DummyProgressHandler( unohelper.Base, XProgressHandler ):
    def __init__( self ):
        pass

    def push( self,status ):
        log.debug( "pythonscript: DummyProgressHandler.push " + str( status ) )
    def update( self,status ):
        log.debug( "pythonscript: DummyProgressHandler.update " + str( status ) )
    def pop( self, event ):
        log.debug( "pythonscript: DummyProgressHandler.push " + str( event ) )

class CommandEnvironment(unohelper.Base, XCommandEnvironment):
    def __init__( self ):
        self.progressHandler = DummyProgressHandler()
        self.interactionHandler = DummyInteractionHandler()
    def getInteractionHandler( self ):
        return self.interactionHandler
    def getProgressHandler( self ):
        return self.progressHandler

#maybe useful for debugging purposes
#class ModifyListener( unohelper.Base, XModifyListener ):
#    def __init__( self ):
#        pass
#    def modified( self, event ):
#        log.debug( "pythonscript: ModifyListener.modified " + str( event ) )
#    def disposing( self, event ):
#        log.debug( "pythonscript: ModifyListener.disposing " + str( event ) )

def getModelFromDocUrl(ctx, url):
    """Get document model from document url."""
    doc = None
    args = ("Local", "Office")
    ucb = ctx.getServiceManager().createInstanceWithArgumentsAndContext(
        "com.sun.star.ucb.UniversalContentBroker", args, ctx)
    identifier = ucb.createContentIdentifier(url)
    content = ucb.queryContent(identifier)
    p = Property()
    p.Name = "DocumentModel"
    p.Handle = -1

    c = Command()
    c.Handle = -1
    c.Name = "getPropertyValues"
    c.Argument = uno.Any("[]com.sun.star.beans.Property", (p,))

    env = CommandEnvironment()
    try:
        ret = content.execute(c, 0, env)
        doc = ret.getObject(1, None)
    except Exception as e:
        log.isErrorLevel() and log.error("getModelFromDocUrl: %s" % url)
    return doc

def mapStorageType2PackageContext( storageType ):
    ret = storageType
    if( storageType == "share:uno_packages" ):
        ret = "shared"
    if( storageType == "user:uno_packages" ):
        ret = "user"
    return ret

def getPackageName2PathMap( sfa, storageType ):
    ret = {}
    packageManagerFactory = uno.getComponentContext().getValueByName(
        "/singletons/com.sun.star.deployment.thePackageManagerFactory" )
    packageManager = packageManagerFactory.getPackageManager(
        mapStorageType2PackageContext(storageType))
#    packageManager.addModifyListener( ModifyListener() )
    log.debug( "pythonscript: getPackageName2PathMap start getDeployedPackages" )
    packages = packageManager.getDeployedPackages(
        packageManager.createAbortChannel(), CommandEnvironment( ) )
    log.debug( "pythonscript: getPackageName2PathMap end getDeployedPackages (" + str(len(packages))+")" )

    for i in packages:
        log.debug( "inspecting package " + i.Name + "("+i.Identifier.Value+")" )
        transientPathElement = penultimateElement( i.URL )
        j = expandUri( i.URL )
        paths = getPathsFromPackage( j, sfa )
        if len( paths ) > 0:
            # map package name to url, we need this later
            log.isErrorLevel() and log.error( "adding Package " + transientPathElement + " " + str( paths ) )
            ret[ lastElement( j ) ] = Package( paths, transientPathElement )
    return ret

def penultimateElement( aStr ):
    lastSlash = aStr.rindex("/")
    penultimateSlash = aStr.rindex("/",0,lastSlash-1)
    return  aStr[ penultimateSlash+1:lastSlash ]

def lastElement( aStr):
    return aStr[ aStr.rfind( "/" )+1:len(aStr)]

class PackageBrowseNode( unohelper.Base, XBrowseNode, XPropertySet, XInvocation ):
    def __init__( self, provCtx, name, rootUrl ):
        self.provCtx = provCtx
        self.name = name
        self.rootUrl = rootUrl

    def getName( self ):
        return self.name

    def getChildNodes( self ):
        items = self.provCtx.mapPackageName2Path.items()
        browseNodeList = []
        for i in items:
            if len( i[1].paths ) == 1:
                browseNodeList.append(
                    DirBrowseNode( self.provCtx, i[0], i[1].paths[0] ))
            else:
                for j in i[1].paths:
                    browseNodeList.append(
                        DirBrowseNode( self.provCtx, i[0]+"."+lastElement(j), j ) )
        return tuple( browseNodeList )

    def hasChildNodes( self ):
        return len( self.provCtx.mapPackageName2Path ) > 0

    def getType( self ):
        return CONTAINER

    def getScript( self, uri ):
        log.debug( "PackageBrowseNode getScript " + uri + " invoked" )
        raise IllegalArgumentException( "PackageBrowseNode couldn't instantiate script " + uri , self , 0 )

    def getPropertyValue( self, name ):
        ret = None
        try:
            if name == "Creatable":
                ret = not self.provCtx.sfa.isReadOnly( self.rootUrl )
            elif name == "Deletable":
                ret = not self.provCtx.sfa.isReadOnly( self.rootUrl )
            elif name == "Renamable":
                ret = not self.provCtx.sfa.isReadOnly( self.rootUrl )
            elif name == "ReadOnly":
                ret = self.provCtx.sfa.isReadOnly( self.rootUrl )
        except:
            raise

        return ret

    def setPropertyValue( self, name, value ):
        log.debug( "PackageBrowseNode.setPropertyValue called " + name + "=" +str(value ) )

    def getPropertySetInfo( self ):
        log.debug( "PackageBrowseNode.getPropertySetInfo called "  )

    def invoke( self, name, params, outparamindex, outparams ):
        if name == "Creatable":
            return callCreatableAsync(self, params[0], params[1]), (), ()
        elif name == "Deletable":
            callDeletable(self)
            return True, (), ()
        elif name == "Renamable":
            callRenamable(self, params[0])
            return self, (), ()
        return self, (), ()

class PythonScript( unohelper.Base, XScript ):
    def __init__( self, func, mod, args ):
        self.func = func
        self.mod = mod
        self.args = args

    def invoke(self, args, out, outindex ):
        log.debug( "PythonScript.invoke " + str( args ) )
        try:
            if (self.args):
                args += self.args
            ret = self.func( *args )
        except UnoException as e:
            # UNO Exception continue to fly ...
            text = lastException2String()
            complete = "Error during invoking function " + \
                str(self.func.__name__) + " in module " + \
                self.mod.__file__ + " (" + text + ")"
            log.debug( complete )
            # some people may beat me up for modifying the exception text,
            # but otherwise office just shows
            # the type name and message text with no more information,
            # this is really bad for most users.
            e.Message = e.Message + " (" + complete + ")"
            raise
        except Exception as e:
            # General python exception are converted to uno RuntimeException
            text = lastException2String()
            complete = "Error during invoking function " + \
                str(self.func.__name__) + " in module " + \
                self.mod.__file__ + " (" + text + ")"
            log.debug( complete )
            raise RuntimeException( complete , self )
        log.debug( "PythonScript.invoke ret = " + str( ret ) )
        return ret, (), ()

def expandUri(  uri ):
    if uri.startswith( "vnd.sun.star.expand:" ):
        uri = uri.replace( "vnd.sun.star.expand:", "",1)
        uri = uno.getComponentContext().getByName(
                    "/singletons/com.sun.star.util.theMacroExpander" ).expandMacros( uri )
    if uri.startswith( "file:" ):
        uri = uno.absolutize("",uri)   # necessary to get rid of .. in uri
    return uri

#--------------------------------------------------------------
class PythonScriptProvider( unohelper.Base, XBrowseNode, XScriptProvider, XNameContainer, XPropertySet, XInvocation ):
    def __init__( self, ctx, *args ):
        if log.isDebugLevel():
            mystr = ""
            for i in args:
                if len(mystr) > 0:
                    mystr = mystr +","
                mystr = mystr + str(i)
            log.debug( "Entering PythonScriptProvider.ctor" + mystr )

        doc = None
        inv = None
        storageType = ""

        if isinstance(args[0], str):
            storageType = args[0]
            if storageType.startswith( "vnd.sun.star.tdoc" ):
                doc = getModelFromDocUrl(ctx, storageType)
        else:
            inv = args[0]
            try:
                doc = inv.ScriptContainer
                content = ctx.getServiceManager().createInstanceWithContext(
                    "com.sun.star.frame.TransientDocumentsDocumentContentFactory",
                    ctx).createDocumentContent(doc)
                storageType = content.getIdentifier().getContentIdentifier()
            except Exception as e:
                text = lastException2String()
                log.error( text )

        isPackage = storageType.endswith( ":uno_packages" )

        try:
#            urlHelper = ctx.ServiceManager.createInstanceWithArgumentsAndContext(
#                "com.sun.star.script.provider.ScriptURIHelper", (LANGUAGENAME, storageType), ctx)
            urlHelper = MyUriHelper( ctx, storageType )
            log.debug( "got urlHelper " + str( urlHelper ) )

            rootUrl = expandUri( urlHelper.getRootStorageURI() )
            log.debug( storageType + " transformed to " + rootUrl )

            ucbService = "com.sun.star.ucb.SimpleFileAccess"
            sfa = ctx.ServiceManager.createInstanceWithContext( ucbService, ctx )
            if not sfa:
                log.debug("PythonScriptProvider couldn't instantiate " +ucbService)
                raise RuntimeException(
                    "PythonScriptProvider couldn't instantiate " +ucbService, self)
            self.provCtx = ProviderContext(
                storageType, sfa, urlHelper, ScriptContext( uno.getComponentContext(), doc, inv ) )
            if isPackage:
                mapPackageName2Path = getPackageName2PathMap( sfa, storageType )
                self.provCtx.setPackageAttributes( mapPackageName2Path , rootUrl )
                self.dirBrowseNode = PackageBrowseNode( self.provCtx, LANGUAGENAME, rootUrl )
            else:
                self.dirBrowseNode = DirBrowseNode( self.provCtx, LANGUAGENAME, rootUrl )
                if not sfa.exists( rootUrl ):
                    sfa.createFolder( rootUrl )

        except Exception as e:
            text = lastException2String()
            log.debug( "PythonScriptProvider could not be instantiated because of : " + text )
            raise e

    def getName( self ):
        return self.dirBrowseNode.getName()

    def getChildNodes( self ):
        return self.dirBrowseNode.getChildNodes()

    def hasChildNodes( self ):
        return self.dirBrowseNode.hasChildNodes()

    def getType( self ):
        return self.dirBrowseNode.getType()

    # retrieve function args in parenthesis
    def getFunctionArguments(self, func_signature):
        nOpenParenthesis = func_signature.find( "(" )
        if -1 == nOpenParenthesis:
            function_name = func_signature
            arguments = None
        else:
            function_name = func_signature[0:nOpenParenthesis]
            arg_part = func_signature[nOpenParenthesis+1:len(func_signature)]
            nCloseParenthesis = arg_part.find( ")" )
            if -1 == nCloseParenthesis:
                raise IllegalArgumentException( "PythonLoader: mismatch parenthesis " + func_signature, self, 0 )
            arguments = arg_part[0:nCloseParenthesis].strip()
            if arguments == "":
                arguments = None
            else:
                arguments = tuple([x.strip().strip('"') for x in arguments.split(",")])
        return function_name, arguments

    def getScript( self, scriptUri ):
        try:
            log.debug( "getScript " + scriptUri + " invoked")

            storageUri = self.provCtx.getStorageUrlFromPersistentUrl(
                self.provCtx.uriHelper.getStorageURI(scriptUri) );
            log.debug( "getScript: storageUri = " + storageUri)
            nameIndex = storageUri.find( "$" )
            fileUri = storageUri[0:nameIndex]
            funcName = storageUri[nameIndex+1:len(storageUri)]

            funcArgs = None
            mod = types.ModuleType("ooo_script_framework")
            if funcName:
                mod = self.provCtx.getModuleByUrl( fileUri )
                log.debug( " got mod " + str(mod) )
                # retrieve arguments in parenthesis
                funcName, funcArgs = self.getFunctionArguments(funcName)
                log.debug( " getScript : parsed funcname " + str(funcName) )
                log.debug( " getScript : func args " + str(funcArgs) )
            else:
                mod.__file__ = fileUri

            def runModule():
                systemFullUrl = os.getcwd() + "/python"
                if os.name == 'nt':
                    systemFullUrl = systemFullUrl + ".exe"
                if not os.path.exists(systemFullUrl):
                    stream = os.popen('which alteroffice')
                    alterofficePath = stream.read()
                    stream = os.popen('readlink -f ' + alterofficePath)
                    alterofficePath = stream.read().strip()
                    systemFullUrl = alterofficePath[:alterofficePath.rfind("/")] + "/python"

                fileFullUrl = fileUri
                tempFileCreated = False
                if not os.path.exists(fileUri):
                    splittedUri = fileUri.split(dirDelimeter)
                    if (len(splittedUri) < 2):
                        raise Exception("Incorrect file uri: {}".format(fileUri))
                    baseFileName = splittedUri[-1]
                    tempFileUrl = uno.tempDirUrl() + dirDelimeter + tempDirName + dirDelimeter + baseFileName
                    self.provCtx.sfa.createFolder(uno.tempDirUrl() + dirDelimeter + tempDirName)
                    self.provCtx.sfa.copy(fileUri, tempFileUrl)
                    fileFullUrl = tempFileUrl
                    tempFileCreated = True

                if os.name == 'nt':
                    si = subprocess.STARTUPINFO()
                    si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                    si.wShowWindow = subprocess.SW_HIDE
                    process = subprocess.Popen([systemFullUrl, fileFullUrl], startupinfo=si)
                    process.wait()
                else:
                    process = subprocess.Popen([systemFullUrl, fileFullUrl])
                    process.wait()

                if tempFileCreated:
                    os.remove(fileFullUrl)

            def runModuleAsync():
                addAsyncTask(runModule,)

            if not funcName:
                func = runModuleAsync
            else:
                if funcName in mod.__dict__:
                    func = mod.__dict__[ funcName ]
                else:
                    raise Exception("  {}. Probably full file should be run.".format(funcName))

            log.debug( "got func " + str( func ) )
            return PythonScript( func, mod, funcArgs )
        except:
            text = lastException2String()
            log.error( text )
            raise ScriptFrameworkErrorException( text, self, scriptUri, LANGUAGENAME, 0 )


    # XServiceInfo
    def getSupportedServices( self ):
        return g_ImplementationHelper.getSupportedServices(g_implName)

    def supportsService( self, ServiceName ):
        return g_ImplementationHelper.supportsService( g_implName, ServiceName )

    def getImplementationName(self):
        return g_implName

    def getByName( self, name ):
        log.debug( "getByName called" + str( name ))
        return None


    def getElementNames( self ):
        log.debug( "getElementNames called")
        return ()

    def hasByName( self, name ):
        try:
            log.debug( "hasByName called " + str( name ))
            uri = expandUri(name)
            ret = self.provCtx.isUrlInPackage( uri )
            log.debug( "hasByName " + uri + " " +str( ret ) )
            return ret
        except:
            text = lastException2String()
            log.debug( "Error in hasByName:" +  text )
            return False

    def removeByName( self, name ):
        log.debug( "removeByName called" + str( name ))
        uri = expandUri( name )
        if self.provCtx.isUrlInPackage( uri ):
            self.provCtx.removePackageByUrl( uri )
        else:
            log.debug( "removeByName unknown uri " + str( name ) + ", ignoring" )
            raise NoSuchElementException( uri + "is not in package" , self )
        log.debug( "removeByName called" + str( uri ) + " successful" )

    def insertByName( self, name, value ):
        log.debug( "insertByName called " + str( name ) + " " + str( value ))
        uri = expandUri( name )
        if isPyFileInPath( self.provCtx.sfa, uri ):
            self.provCtx.addPackageByUrl( uri )
        else:
            # package is no python package ...
            log.debug( "insertByName: no python files in " + str( uri ) + ", ignoring" )
            raise IllegalArgumentException( uri + " does not contain .py files", self, 1 )
        log.debug( "insertByName called " + str( uri ) + " successful" )

    def replaceByName( self, name, value ):
        log.debug( "replaceByName called " + str( name ) + " " + str( value ))
        uri = expandUri( name )
        self.removeByName( name )
        self.insertByName( name, value )
        log.debug( "replaceByName called" + str( uri ) + " successful" )

    def getElementType( self ):
        log.debug( "getElementType called" )
        return uno.getTypeByName( "void" )

    def hasElements( self ):
        log.debug( "hasElements got called")
        return False

    def getPropertyValue( self, name ):
        ret = None
        try:
            if name == "Creatable":
                ret = not self.provCtx.sfa.isReadOnly( self.dirBrowseNode.rootUrl )
            elif name == "Importable":
                ret = not self.provCtx.sfa.isReadOnly( self.dirBrowseNode.rootUrl )
            elif name == "ReadOnly":
                ret = self.provCtx.sfa.isReadOnly( self.dirBrowseNode.rootUrl )
        except:
            raise

        return ret

    def setPropertyValue( self, name, value ):
        log.debug( "PythonScriptProvider.setPropertyValue called " + name + "=" +str(value ) )

    def getPropertySetInfo( self ):
        log.debug( "PythonScriptProvider.getPropertySetInfo called "  )

    def invoke( self, name, params, outparamindex, outparams ):
        if name == "Creatable":
            return callCreatableAsync(self, params[0], params[1]), (), ()
        if name == "Importable":
            return callImportable(params[0], self), (), ()
        return self, (), ()

g_ImplementationHelper.addImplementation( \
    PythonScriptProvider,g_implName, \
    ("com.sun.star.script.provider.LanguageScriptProvider",
     "com.sun.star.script.provider.ScriptProviderFor"+ LANGUAGENAME,),)


log.debug( "pythonscript finished initializing" )

# vim: set shiftwidth=4 softtabstop=4 expandtab: