xref: /aoo4110/main/pyuno/source/module/uno.py (revision b1cdbd2c)
1#**************************************************************
2#
3#  Licensed to the Apache Software Foundation (ASF) under one
4#  or more contributor license agreements.  See the NOTICE file
5#  distributed with this work for additional information
6#  regarding copyright ownership.  The ASF licenses this file
7#  to you under the Apache License, Version 2.0 (the
8#  "License"); you may not use this file except in compliance
9#  with the License.  You may obtain a copy of the License at
10#
11#    http://www.apache.org/licenses/LICENSE-2.0
12#
13#  Unless required by applicable law or agreed to in writing,
14#  software distributed under the License is distributed on an
15#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16#  KIND, either express or implied.  See the License for the
17#  specific language governing permissions and limitations
18#  under the License.
19#
20#**************************************************************
21import sys
22
23import pyuno
24try:
25    import __builtin__ as builtins
26except:
27    import builtins
28
29try:
30    unicode
31    bytes = str
32    bytearray = str
33except NameError:
34    unicode = str
35
36import socket # since on Windows sal3.dll no longer calls WSAStartup
37
38# all functions and variables starting with a underscore (_) must be considered private
39# and can be changed at any time. Don't use them
40_g_ctx = pyuno.getComponentContext( )
41_g_delegatee = builtins.__dict__["__import__"]
42
43def getComponentContext():
44    """ returns the UNO component context, that was used to initialize the python runtime.
45    """
46    return _g_ctx
47
48def getConstantByName( constant ):
49    "Looks up the value of a idl constant by giving its explicit name"
50    return pyuno.getConstantByName( constant )
51
52def getTypeByName( typeName):
53    """ returns a uno.Type instance of the type given by typeName. In case the
54        type does not exist, a com.sun.star.uno.RuntimeException is raised.
55    """
56    return pyuno.getTypeByName( typeName )
57
58def createUnoStruct( typeName, *args ):
59    """creates a uno struct or exception given by typeName. The parameter args may
60    1) be empty. In this case, you get a default constructed uno structure.
61       ( e.g. createUnoStruct( "com.sun.star.uno.Exception" ) )
62    2) be a sequence with exactly one element, that contains an instance of typeName.
63       In this case, a copy constructed instance of typeName is returned
64       ( e.g. createUnoStruct( "com.sun.star.uno.Exception" , e ) )
65    3) be a sequence, where the length of the sequence must match the number of
66       elements within typeName (e.g.
67       createUnoStruct( "com.sun.star.uno.Exception", "foo error" , self) ). The
68       elements with in the sequence must match the type of each struct element,
69       otherwise an exception is thrown.
70    """
71    return getClass(typeName)( *args )
72
73def getClass( typeName ):
74    """returns the class of a concrete uno exception, struct or interface
75    """
76    return pyuno.getClass(typeName)
77
78def isInterface( obj ):
79    """returns true, when obj is a class of a uno interface"""
80    return pyuno.isInterface( obj )
81
82def generateUuid():
83    "returns a 16 byte sequence containing a newly generated uuid or guid, see rtl/uuid.h "
84    return pyuno.generateUuid()
85
86def systemPathToFileUrl( systemPath ):
87    "returns a file-url for the given system path"
88    return pyuno.systemPathToFileUrl( systemPath )
89
90def fileUrlToSystemPath( url ):
91    "returns a system path (determined by the system, the python interpreter is running on)"
92    return pyuno.fileUrlToSystemPath( url )
93
94def absolutize( path, relativeUrl ):
95    "returns an absolute file url from the given urls"
96    return pyuno.absolutize( path, relativeUrl )
97
98def getCurrentContext():
99    """Returns the currently valid current context.
100       see http://udk.openoffice.org/common/man/concept/uno_contexts.html#current_context
101       for an explanation on the current context concept
102    """
103    return pyuno.getCurrentContext()
104
105def setCurrentContext( newContext ):
106    """Sets newContext as new uno current context. The newContext must
107    implement the XCurrentContext interface. The implemenation should
108    handle the desired properties and delegate unknown properties to the
109    old context. Ensure to reset the old one when you leave your stack ...
110    see http://udk.openoffice.org/common/man/concept/uno_contexts.html#current_context
111    """
112    return pyuno.setCurrentContext( newContext )
113
114
115class Enum:
116    "Represents a UNO idl enum, use an instance of this class to explicitly pass a boolean to UNO"
117    #typeName the name of the enum as a string
118    #value    the actual value of this enum as a string
119    def __init__(self,typeName, value):
120        self.typeName = typeName
121        self.value = value
122        pyuno.checkEnum( self )
123
124    def __repr__(self):
125        return "<uno.Enum %s (%r)>" % (self.typeName, self.value)
126
127    def __eq__(self, that):
128        if not isinstance(that, Enum):
129            return False
130        return (self.typeName == that.typeName) and (self.value == that.value)
131
132class Type:
133    "Represents a UNO type, use an instance of this class to explicitly pass a boolean to UNO"
134#    typeName                 # Name of the UNO type
135#    typeClass                # python Enum of TypeClass,  see com/sun/star/uno/TypeClass.idl
136    def __init__(self, typeName, typeClass):
137        self.typeName = typeName
138        self.typeClass = typeClass
139        pyuno.checkType(self)
140    def __repr__(self):
141        return "<Type instance %s (%r)>" % (self.typeName, self.typeClass)
142
143    def __eq__(self, that):
144        if not isinstance(that, Type):
145            return False
146        return self.typeClass == that.typeClass and self.typeName == that.typeName
147
148    def __hash__(self):
149        return self.typeName.__hash__()
150
151class Bool(object):
152    """Represents a UNO boolean, use an instance of this class to explicitly
153       pass a boolean to UNO.
154       Note: This class is deprecated. Use python's True and False directly instead
155    """
156    def __new__(cls, value):
157        if isinstance(value, (str, unicode)) and value == "true":
158            return True
159        if isinstance(value, (str, unicode)) and value == "false":
160            return False
161        if value:
162            return True
163        return False
164
165class Char:
166    "Represents a UNO char, use an instance of this class to explicitly pass a char to UNO"
167    # @param value pass a Unicode string with length 1
168    def __init__(self,value):
169        assert isinstance(value, unicode)
170        assert len(value) == 1
171        self.value=value
172
173    def __repr__(self):
174        return "<Char instance %s>" % (self.value, )
175
176    def __eq__(self, that):
177        if isinstance(that, (str, unicode)):
178            if len(that) > 1:
179                return False
180            return self.value == that[0]
181        if isinstance(that, Char):
182            return self.value == that.value
183        return False
184
185class ByteSequence:
186    def __init__(self, value):
187        if isinstance(value, (bytes, bytearray)):
188            self.value = value
189        elif isinstance(value, ByteSequence):
190            self.value = value.value
191        else:
192            raise TypeError("expected string or bytesequence")
193
194    def __repr__(self):
195        return "<ByteSequence instance '%s'>" % (self.value, )
196
197    def __eq__(self, that):
198        if isinstance( that, ByteSequence):
199            return self.value == that.value
200        elif isinstance(that, (bytes, bytearray)):
201            return self.value == that
202        return False
203
204    def __len__(self):
205        return len(self.value)
206
207    def __getitem__(self, index):
208        return self.value[index]
209
210    def __iter__( self ):
211        return self.value.__iter__()
212
213    def __add__( self , b ):
214        if isinstance( b, (bytes, bytearray) ):
215            return ByteSequence( self.value + b )
216        elif isinstance( b, ByteSequence ):
217            return ByteSequence( self.value + b.value )
218        raise TypeError( "expected string or ByteSequence as operand" )
219
220    def __hash__( self ):
221        return self.value.hash()
222
223
224class Any:
225    "use only in connection with uno.invoke() to pass an explicit typed any"
226    def __init__(self, type, value ):
227        if isinstance( type, Type ):
228            self.type = type
229        else:
230            self.type = getTypeByName( type )
231        self.value = value
232
233def invoke( object, methodname, argTuple ):
234    "use this function to pass exactly typed anys to the callee (using uno.Any)"
235    return pyuno.invoke( object, methodname, argTuple )
236
237#---------------------------------------------------------------------------------------
238# don't use any functions beyond this point, private section, likely to change
239#---------------------------------------------------------------------------------------
240#def _uno_import( name, globals={}, locals={}, fromlist=[], level=-1 ):
241def _uno_import( name, *optargs, **kwargs ):
242    try:
243#       print "optargs = " + repr(optargs)
244        return _g_delegatee( name, *optargs, **kwargs )
245    except ImportError:
246        # process optargs
247        globals, locals, fromlist = list(optargs)[:3] + [kwargs.get('globals',{}), kwargs.get('locals',{}), kwargs.get('fromlist',[])][len(optargs):]
248        if not fromlist:
249            raise
250    modnames = name.split( "." )
251    mod = None
252    d = sys.modules
253    for x in modnames:
254        if x in d:
255            mod = d[x]
256        else:
257            mod = pyuno.__class__(x)  # How to create a module ??
258        d = mod.__dict__
259
260    RuntimeException = pyuno.getClass( "com.sun.star.uno.RuntimeException" )
261    for x in fromlist:
262        if x not in d:
263            if x.startswith( "typeOf" ):
264                try:
265                    d[x] = pyuno.getTypeByName( name + "." + x[6:len(x)] )
266                except RuntimeException as e:
267                    raise ImportError( "type " + name + "." + x[6:len(x)] +" is unknown" )
268            else:
269                try:
270                    # check for structs, exceptions or interfaces
271                    d[x] = pyuno.getClass( name + "." + x )
272                except RuntimeException as e:
273                    # check for enums
274                    try:
275                        d[x] = Enum( name , x )
276                    except RuntimeException as e2:
277                        # check for constants
278                        try:
279                            d[x] = getConstantByName( name + "." + x )
280                        except RuntimeException as e3:
281                            # no known uno type !
282                            raise ImportError( "type "+ name + "." +x + " is unknown" )
283    return mod
284
285# hook into the __import__ chain
286builtins.__dict__["__import__"] = _uno_import
287
288# private, referenced from the pyuno shared library
289def _uno_struct__init__(self,*args):
290    if len(args) == 1 and hasattr(args[0], "__class__") and args[0].__class__ == self.__class__ :
291        self.__dict__["value"] = args[0]
292    else:
293        self.__dict__["value"] = pyuno._createUnoStructHelper(self.__class__.__pyunostruct__,args)
294
295# private, referenced from the pyuno shared library
296def _uno_struct__getattr__(self,name):
297    return getattr(self.__dict__["value"],name)
298
299# private, referenced from the pyuno shared library
300def _uno_struct__setattr__(self,name,value):
301    return setattr(self.__dict__["value"],name,value)
302
303# private, referenced from the pyuno shared library
304def _uno_struct__repr__(self):
305    return repr(self.__dict__["value"])
306
307def _uno_struct__str__(self):
308    return str(self.__dict__["value"])
309
310# private, referenced from the pyuno shared library
311def _uno_struct__eq__(self,cmp):
312    if hasattr(cmp,"value"):
313        return self.__dict__["value"] == cmp.__dict__["value"]
314    return False
315
316def _uno_struct__dir__(self):
317    return dir(self.__dict__["value"]) + list(self.__dict__.keys()) + \
318                list(self.__class__.__dict__.keys())
319
320# referenced from pyuno shared lib and pythonscript.py
321def _uno_extract_printable_stacktrace( trace ):
322    mod = None
323    try:
324        mod = __import__("traceback")
325    except ImportError as e:
326        pass
327    ret = ""
328    if mod:
329        lst = mod.extract_tb( trace )
330        max = len(lst)
331        for j in range(max):
332            i = lst[max-j-1]
333            ret = ret + "  " + str(i[0]) + ":" + \
334                  str(i[1]) + " in function " + \
335                  str(i[2])  + "() [" + str(i[3]) + "]\n"
336    else:
337        ret = "Couldn't import traceback module"
338    return ret
339