You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
201 lines
7.6 KiB
201 lines
7.6 KiB
"""
|
|
Copyright 2004 Jim Bublitz
|
|
|
|
Terms and Conditions
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to
|
|
deal in the Software without restriction, including without limitation the
|
|
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
sell copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
|
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
|
|
Except as contained in this notice, the name of the copyright holder shall
|
|
not be used in advertising or otherwise to promote the sale, use or other
|
|
dealings in this Software without prior written authorization from the
|
|
copyright holder.
|
|
"""
|
|
|
|
"""
|
|
This is a re-implementation in Python of pcop.cpp written by Torben Weis
|
|
and Julian Rockey, modified for Python and PyKDE.
|
|
|
|
To "DCOP-enable" an application, subclass DCOPExObj (be sure to call the
|
|
base class' __init__ method) and use 'addMethod' to identify the methods
|
|
which will be exposed via DCOP along with names of the Python methods that
|
|
implement the exposed methods.
|
|
|
|
A DCOP client application when doing DCOPCLient.call (...) will end up
|
|
running the 'process' method which demarshalls the arguments, calls the
|
|
specified Python method with the arg values passed in, and marshalls the
|
|
return value to be returned to the caller.
|
|
|
|
DCOPExMeth is basically a data structure to hold the parsed method info
|
|
(name, arg list, return type, signature)
|
|
|
|
This module requires the dcopext module, but only for the numericTypes and
|
|
stringTypes lists
|
|
"""
|
|
|
|
|
|
from dcop import DCOPObject, DCOPClient
|
|
from tdecore import dcop_add, dcop_next
|
|
from PyTQt.tqt import TQString, TQCString, TQDataStream, IO_ReadOnly, IO_WriteOnly
|
|
|
|
numericTypes = ["char", "bool", "short", "int", "long", "uchar", "ushort", "uint", "ulong",
|
|
"unsigned char", "unsigned short", "unsigned int", "unsigned long",
|
|
"TQ_INT32", "pid_t", "float", "double"]
|
|
stringTypes = ["TQString", "TQCString"]
|
|
|
|
class DCOPExObj (DCOPObject):
|
|
def __init__(self, objid = None):
|
|
if isinstance (objid, bytes):
|
|
DCOPObject.__init__ (self, objid)
|
|
else:
|
|
DCOPObject.__init__ (self)
|
|
|
|
self.methods = {}
|
|
|
|
def process (self, meth, data, replyType, replyData):
|
|
# normalize the method signature received
|
|
_meth = DCOPClient.normalizeFunctionSignature(meth).replace (">", "> ")
|
|
|
|
# see if this method is available from us via DCOP
|
|
# if we don't have it, maybe DCOPObject already provides it (eg - tqt object)
|
|
if not self.matchMethod (_meth):
|
|
return DCOPObject.process(self, _meth, data, replyType, replyData);
|
|
|
|
# demarshall the arg list for the actual method call and call the method
|
|
s = TQDataStream (data, IO_ReadOnly)
|
|
arglist = []
|
|
count = len (self.method.argtypes)
|
|
if count == 0:
|
|
result = self.method.pymethod ()
|
|
else:
|
|
for i in range (len (self.method.argtypes)):
|
|
arglist.append (dcop_next (s, TQCString(self.method.argtypes[i])))
|
|
|
|
result = self.method.pymethod (*arglist)
|
|
|
|
# marshall the result as 'replyData'
|
|
if self.method.rtype != "void":
|
|
s = TQDataStream (replyData, IO_WriteOnly)
|
|
if self.method.rtype in numericTypes:
|
|
dcop_add (s, result, self.method.rtype)
|
|
elif self.method.rtype in stringTypes and isinstance (result, str):
|
|
dcop_add (s, eval ("%s('''%s''')" % (self.method.rtype, result)))
|
|
elif self.method.rtype.startswith ("TQMap") or self.method.rtype.startswith ("TQValueList"):
|
|
dcop_add (params, args [i], self.argtypes [i])
|
|
else:
|
|
if not result:
|
|
dcop_add (s, "")
|
|
else:
|
|
dcop_add (s, result)
|
|
|
|
# use append because we want to return the replyType reference,
|
|
# not a new TQCString
|
|
replyType.append (self.method.rtype)
|
|
|
|
# success
|
|
return True
|
|
|
|
def addMethod (self, signature, pymethod):
|
|
"""
|
|
add a method to the dict - makes it available to DCOP
|
|
signature - a string representing the C++ form of the method declaration
|
|
with arg names removed (eg
|
|
pymethod - the Python method corresponding to the method in signature
|
|
|
|
example:
|
|
def someMethod (a, b):
|
|
return str (a + b)
|
|
|
|
signature = "TQString someMethod (int, int)"
|
|
pymethod = someMethod
|
|
self.addMethod (signature, pymethod)
|
|
|
|
note that in this case you could add a second entry:
|
|
|
|
self.addMethod ("TQString someMethod (float, float)", someMethod)
|
|
|
|
pymethod can also be a class method, for example - self.someMethod or
|
|
someClass.someMethod. In the second case, someClass has to be an instance
|
|
of a class (perhaps SomeClass), not the class itself.
|
|
|
|
self.methods is a dict holding all of the methods exposed, indexed by
|
|
method signature. In the example above, the signature would be:
|
|
|
|
someMethod(TQString,TQString)
|
|
|
|
or everything but the return type, which is stored in the dict entry.
|
|
The dict entry is a DCOPExMeth instance.
|
|
"""
|
|
method = DCOPExMeth (signature, pymethod)
|
|
if method.sig:
|
|
self.methods [method.sig] = method
|
|
return method.sig != None
|
|
|
|
def matchMethod (self, meth):
|
|
# find the method in the dict if it's there
|
|
self.method = None
|
|
_meth = meth.data()
|
|
if _meth in self.methods:
|
|
self.method = self.methods [_meth]
|
|
return self.method != None
|
|
|
|
def functions (self):
|
|
# build the list of methods exposed for 'remoteFunctions' calls
|
|
# from the entries in the self.methods dict
|
|
funcs = DCOPObject.functions (self)
|
|
for func in self.methods.keys ():
|
|
funcs.append((" ".join([self.methods[func].rtype, func])).encode())
|
|
return funcs;
|
|
|
|
class DCOPExMeth:
|
|
"""
|
|
Encapsulates all of the method data - signature, arg list, return type
|
|
and corresponding Python method to be called
|
|
"""
|
|
def __init__ (self, method, pymethod):
|
|
self.pymethod = pymethod
|
|
if not self.parseMethod (method):
|
|
self.fcnname = self.sig = self.rtype = self.argtypes = None
|
|
|
|
def parseMethod (self, method):
|
|
# strip whitespace
|
|
method = DCOPClient.normalizeFunctionSignature(method.encode()).data().replace (">", "> ")
|
|
|
|
# the return type (rtype) and signature (sig)
|
|
self.rtype, tail = method.split (" ", 1)
|
|
self.sig = tail
|
|
if not tail:
|
|
return False
|
|
self.rtype = self.rtype.strip ()
|
|
|
|
i = tail.find ("(")
|
|
if i < 1:
|
|
return False
|
|
|
|
# the name of the method
|
|
self.fcnname = tail [:i].strip () + "("
|
|
|
|
# the list of arg types
|
|
self.argtypes = []
|
|
args = tail [i + 1 : -2].split (",")
|
|
if args and args != [""]:
|
|
for arg in args:
|
|
self.argtypes.append (arg.strip ())
|
|
|
|
return True
|