| #************************************************************** |
| # |
| # 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 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| #************************************************************** |
| import sys |
| |
| import pyuno |
| try: |
| import __builtin__ as builtins |
| except: |
| import builtins |
| |
| try: |
| unicode |
| bytes = str |
| bytearray = str |
| except NameError: |
| unicode = str |
| |
| import socket # since on Windows sal3.dll no longer calls WSAStartup |
| |
| # all functions and variables starting with a underscore (_) must be considered private |
| # and can be changed at any time. Don't use them |
| _g_ctx = pyuno.getComponentContext( ) |
| _g_delegatee = builtins.__dict__["__import__"] |
| |
| def getComponentContext(): |
| """ returns the UNO component context, that was used to initialize the python runtime. |
| """ |
| return _g_ctx |
| |
| def getConstantByName( constant ): |
| "Looks up the value of a idl constant by giving its explicit name" |
| return pyuno.getConstantByName( constant ) |
| |
| def getTypeByName( typeName): |
| """ returns a uno.Type instance of the type given by typeName. In case the |
| type does not exist, a com.sun.star.uno.RuntimeException is raised. |
| """ |
| return pyuno.getTypeByName( typeName ) |
| |
| def createUnoStruct( typeName, *args ): |
| """creates a uno struct or exception given by typeName. The parameter args may |
| 1) be empty. In this case, you get a default constructed uno structure. |
| ( e.g. createUnoStruct( "com.sun.star.uno.Exception" ) ) |
| 2) be a sequence with exactly one element, that contains an instance of typeName. |
| In this case, a copy constructed instance of typeName is returned |
| ( e.g. createUnoStruct( "com.sun.star.uno.Exception" , e ) ) |
| 3) be a sequence, where the length of the sequence must match the number of |
| elements within typeName (e.g. |
| createUnoStruct( "com.sun.star.uno.Exception", "foo error" , self) ). The |
| elements with in the sequence must match the type of each struct element, |
| otherwise an exception is thrown. |
| """ |
| return getClass(typeName)( *args ) |
| |
| def getClass( typeName ): |
| """returns the class of a concrete uno exception, struct or interface |
| """ |
| return pyuno.getClass(typeName) |
| |
| def isInterface( obj ): |
| """returns true, when obj is a class of a uno interface""" |
| return pyuno.isInterface( obj ) |
| |
| def generateUuid(): |
| "returns a 16 byte sequence containing a newly generated uuid or guid, see rtl/uuid.h " |
| return pyuno.generateUuid() |
| |
| def systemPathToFileUrl( systemPath ): |
| "returns a file-url for the given system path" |
| return pyuno.systemPathToFileUrl( systemPath ) |
| |
| def fileUrlToSystemPath( url ): |
| "returns a system path (determined by the system, the python interpreter is running on)" |
| return pyuno.fileUrlToSystemPath( url ) |
| |
| def absolutize( path, relativeUrl ): |
| "returns an absolute file url from the given urls" |
| return pyuno.absolutize( path, relativeUrl ) |
| |
| def getCurrentContext(): |
| """Returns the currently valid current context. |
| see http://udk.openoffice.org/common/man/concept/uno_contexts.html#current_context |
| for an explanation on the current context concept |
| """ |
| return pyuno.getCurrentContext() |
| |
| def setCurrentContext( newContext ): |
| """Sets newContext as new uno current context. The newContext must |
| implement the XCurrentContext interface. The implemenation should |
| handle the desired properties and delegate unknown properties to the |
| old context. Ensure to reset the old one when you leave your stack ... |
| see http://udk.openoffice.org/common/man/concept/uno_contexts.html#current_context |
| """ |
| return pyuno.setCurrentContext( newContext ) |
| |
| |
| class Enum: |
| "Represents a UNO idl enum, use an instance of this class to explicitly pass a boolean to UNO" |
| #typeName the name of the enum as a string |
| #value the actual value of this enum as a string |
| def __init__(self,typeName, value): |
| self.typeName = typeName |
| self.value = value |
| pyuno.checkEnum( self ) |
| |
| def __repr__(self): |
| return "<uno.Enum %s (%r)>" % (self.typeName, self.value) |
| |
| def __eq__(self, that): |
| if not isinstance(that, Enum): |
| return False |
| return (self.typeName == that.typeName) and (self.value == that.value) |
| |
| class Type: |
| "Represents a UNO type, use an instance of this class to explicitly pass a boolean to UNO" |
| # typeName # Name of the UNO type |
| # typeClass # python Enum of TypeClass, see com/sun/star/uno/TypeClass.idl |
| def __init__(self, typeName, typeClass): |
| self.typeName = typeName |
| self.typeClass = typeClass |
| pyuno.checkType(self) |
| def __repr__(self): |
| return "<Type instance %s (%r)>" % (self.typeName, self.typeClass) |
| |
| def __eq__(self, that): |
| if not isinstance(that, Type): |
| return False |
| return self.typeClass == that.typeClass and self.typeName == that.typeName |
| |
| def __hash__(self): |
| return self.typeName.__hash__() |
| |
| class Bool(object): |
| """Represents a UNO boolean, use an instance of this class to explicitly |
| pass a boolean to UNO. |
| Note: This class is deprecated. Use python's True and False directly instead |
| """ |
| def __new__(cls, value): |
| if isinstance(value, (str, unicode)) and value == "true": |
| return True |
| if isinstance(value, (str, unicode)) and value == "false": |
| return False |
| if value: |
| return True |
| return False |
| |
| class Char: |
| "Represents a UNO char, use an instance of this class to explicitly pass a char to UNO" |
| # @param value pass a Unicode string with length 1 |
| def __init__(self,value): |
| assert isinstance(value, unicode) |
| assert len(value) == 1 |
| self.value=value |
| |
| def __repr__(self): |
| return "<Char instance %s>" % (self.value, ) |
| |
| def __eq__(self, that): |
| if isinstance(that, (str, unicode)): |
| if len(that) > 1: |
| return False |
| return self.value == that[0] |
| if isinstance(that, Char): |
| return self.value == that.value |
| return False |
| |
| class ByteSequence: |
| def __init__(self, value): |
| if isinstance(value, (bytes, bytearray)): |
| self.value = value |
| elif isinstance(value, ByteSequence): |
| self.value = value.value |
| else: |
| raise TypeError("expected string or bytesequence") |
| |
| def __repr__(self): |
| return "<ByteSequence instance '%s'>" % (self.value, ) |
| |
| def __eq__(self, that): |
| if isinstance( that, ByteSequence): |
| return self.value == that.value |
| elif isinstance(that, (bytes, bytearray)): |
| return self.value == that |
| return False |
| |
| def __len__(self): |
| return len(self.value) |
| |
| def __getitem__(self, index): |
| return self.value[index] |
| |
| def __iter__( self ): |
| return self.value.__iter__() |
| |
| def __add__( self , b ): |
| if isinstance( b, (bytes, bytearray) ): |
| return ByteSequence( self.value + b ) |
| elif isinstance( b, ByteSequence ): |
| return ByteSequence( self.value + b.value ) |
| raise TypeError( "expected string or ByteSequence as operand" ) |
| |
| def __hash__( self ): |
| return self.value.hash() |
| |
| |
| class Any: |
| "use only in connection with uno.invoke() to pass an explicit typed any" |
| def __init__(self, type, value ): |
| if isinstance( type, Type ): |
| self.type = type |
| else: |
| self.type = getTypeByName( type ) |
| self.value = value |
| |
| def invoke( object, methodname, argTuple ): |
| "use this function to pass exactly typed anys to the callee (using uno.Any)" |
| return pyuno.invoke( object, methodname, argTuple ) |
| |
| #--------------------------------------------------------------------------------------- |
| # don't use any functions beyond this point, private section, likely to change |
| #--------------------------------------------------------------------------------------- |
| #def _uno_import( name, globals={}, locals={}, fromlist=[], level=-1 ): |
| def _uno_import( name, *optargs, **kwargs ): |
| try: |
| # print "optargs = " + repr(optargs) |
| return _g_delegatee( name, *optargs, **kwargs ) |
| except ImportError: |
| # process optargs |
| globals, locals, fromlist = list(optargs)[:3] + [kwargs.get('globals',{}), kwargs.get('locals',{}), kwargs.get('fromlist',[])][len(optargs):] |
| if not fromlist: |
| raise |
| modnames = name.split( "." ) |
| mod = None |
| d = sys.modules |
| for x in modnames: |
| if x in d: |
| mod = d[x] |
| else: |
| mod = pyuno.__class__(x) # How to create a module ?? |
| d = mod.__dict__ |
| |
| RuntimeException = pyuno.getClass( "com.sun.star.uno.RuntimeException" ) |
| for x in fromlist: |
| if x not in d: |
| if x.startswith( "typeOf" ): |
| try: |
| d[x] = pyuno.getTypeByName( name + "." + x[6:len(x)] ) |
| except RuntimeException as e: |
| raise ImportError( "type " + name + "." + x[6:len(x)] +" is unknown" ) |
| else: |
| try: |
| # check for structs, exceptions or interfaces |
| d[x] = pyuno.getClass( name + "." + x ) |
| except RuntimeException as e: |
| # check for enums |
| try: |
| d[x] = Enum( name , x ) |
| except RuntimeException as e2: |
| # check for constants |
| try: |
| d[x] = getConstantByName( name + "." + x ) |
| except RuntimeException as e3: |
| # no known uno type ! |
| raise ImportError( "type "+ name + "." +x + " is unknown" ) |
| return mod |
| |
| # hook into the __import__ chain |
| builtins.__dict__["__import__"] = _uno_import |
| |
| # private, referenced from the pyuno shared library |
| def _uno_struct__init__(self,*args): |
| if len(args) == 1 and hasattr(args[0], "__class__") and args[0].__class__ == self.__class__ : |
| self.__dict__["value"] = args[0] |
| else: |
| self.__dict__["value"] = pyuno._createUnoStructHelper(self.__class__.__pyunostruct__,args) |
| |
| # private, referenced from the pyuno shared library |
| def _uno_struct__getattr__(self,name): |
| return getattr(self.__dict__["value"],name) |
| |
| # private, referenced from the pyuno shared library |
| def _uno_struct__setattr__(self,name,value): |
| return setattr(self.__dict__["value"],name,value) |
| |
| # private, referenced from the pyuno shared library |
| def _uno_struct__repr__(self): |
| return repr(self.__dict__["value"]) |
| |
| def _uno_struct__str__(self): |
| return str(self.__dict__["value"]) |
| |
| # private, referenced from the pyuno shared library |
| def _uno_struct__eq__(self,cmp): |
| if hasattr(cmp,"value"): |
| return self.__dict__["value"] == cmp.__dict__["value"] |
| return False |
| |
| def _uno_struct__dir__(self): |
| return dir(self.__dict__["value"]) + list(self.__dict__.keys()) + \ |
| list(self.__class__.__dict__.keys()) |
| |
| # referenced from pyuno shared lib and pythonscript.py |
| def _uno_extract_printable_stacktrace( trace ): |
| mod = None |
| try: |
| mod = __import__("traceback") |
| except ImportError as e: |
| pass |
| ret = "" |
| if mod: |
| lst = mod.extract_tb( trace ) |
| max = len(lst) |
| for j in range(max): |
| i = lst[max-j-1] |
| ret = ret + " " + str(i[0]) + ":" + \ |
| str(i[1]) + " in function " + \ |
| str(i[2]) + "() [" + str(i[3]) + "]\n" |
| else: |
| ret = "Couldn't import traceback module" |
| return ret |
