|
|
|
// This file contains the C++ code necessary marshal and demarshal
|
|
|
|
// all the _simple_ types that dcoppython can understand.
|
|
|
|
// "Simple" types are types that do not contain other types.
|
|
|
|
// So, int and TQString are simple types; TQDict, TQMap and TQStringList are not.
|
|
|
|
// This file is processed by gen_marshal_code.py to produce a header
|
|
|
|
// file, which is included by marshaller.cpp
|
|
|
|
//
|
|
|
|
// Marshalling:
|
|
|
|
// The code in the "marshal" section has the following variables available:
|
|
|
|
// PyObject * obj; // the object to marshal
|
|
|
|
// TQDataStream *str; // the stream to marshal to
|
|
|
|
// The function should return true if the object can be marshalled.
|
|
|
|
// str may be NULL. If so, the function should ignore the actually marshalling
|
|
|
|
// and merely return true or false, depending on whether the object _could_
|
|
|
|
// be marshalled.
|
|
|
|
//
|
|
|
|
// Demarshalling:
|
|
|
|
// The code in the "demarshal" section has the following variables available:
|
|
|
|
// TQDataStream *str; // the stream to demarshal from
|
|
|
|
// The function should return a PyObject* which is a reference to the
|
|
|
|
// newly created object. Ownership of the reference should be passed to
|
|
|
|
// the caller. The function can return null if for any reason it
|
|
|
|
// could not demarshal.
|
|
|
|
|
|
|
|
type: void
|
|
|
|
%% marshall
|
|
|
|
{
|
|
|
|
Q_UNUSED(str); // stop warnings
|
|
|
|
Q_UNUSED(obj);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
Q_UNUSED(str); // stop warnings
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
|
|
|
}
|
|
|
|
|
|
|
|
type: bool
|
|
|
|
%doc as int b (1=True, 2=False)
|
|
|
|
%doc info Any Python object is converted to bool by the standard Python truth test.
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
*ok=true;
|
|
|
|
return PyObject_IsTrue(obj);
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
return PyInt_FromLong(val ? 1 : 0);
|
|
|
|
}
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (str) {
|
|
|
|
bool ok;
|
|
|
|
bool b = fromPyObject_bool(obj,&ok);
|
|
|
|
(*str) << (Q_INT8)b;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
Q_INT8 i;
|
|
|
|
(*str) >> i;
|
|
|
|
return toPyObject_bool(i!=0);
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:int
|
|
|
|
%doc as int i
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (!PyInt_Check(obj)) return false;
|
|
|
|
if (str) {
|
|
|
|
(*str) << (Q_INT32)PyInt_AsLong(obj);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
Q_INT32 i;
|
|
|
|
(*str) >> i;
|
|
|
|
return PyInt_FromLong( (long)i );
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:uint
|
|
|
|
%doc as int i
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (!PyInt_Check(obj)) return false;
|
|
|
|
if (str) {
|
|
|
|
(*str) << (Q_INT32)PyInt_AsLong(obj);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
Q_INT32 i;
|
|
|
|
(*str) >> i;
|
|
|
|
return PyInt_FromLong( (long)i );
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:double
|
|
|
|
%doc as float i
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (!PyFloat_Check(obj)) return false;
|
|
|
|
if (str) {
|
|
|
|
(*str) << PyFloat_AsDouble(obj);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
double d;
|
|
|
|
(*str) >> d;
|
|
|
|
return PyFloat_FromDouble(d);
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:uchar
|
|
|
|
%doc as str c
|
|
|
|
%doc as int c
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (PyString_Check(obj) && PyString_Size(obj)==1) {
|
|
|
|
if (str) {
|
|
|
|
char *c = PyString_AsString(obj);
|
|
|
|
(*str) << (*c);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (PyInt_Check(obj)) {
|
|
|
|
if (str) {
|
|
|
|
long l = PyInt_AsLong(obj);
|
|
|
|
Q_UINT8 c = (Q_UINT8)(l & 0xff);
|
|
|
|
(*str) << c;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
%%demarshal
|
|
|
|
{
|
|
|
|
Q_UINT8 c;
|
|
|
|
(*str) >> c;
|
|
|
|
return PyString_FromStringAndSize((const char *)(&c),1);
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:char
|
|
|
|
%doc as int c
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (PyInt_Check(obj)) {
|
|
|
|
if (str) {
|
|
|
|
long l = PyInt_AsLong(obj);
|
|
|
|
Q_INT8 c = (Q_INT8)(l & 0xff);
|
|
|
|
(*str) << c;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
%%demarshal
|
|
|
|
{
|
|
|
|
Q_INT8 c;
|
|
|
|
(*str) >> c;
|
|
|
|
return PyInt_FromLong((long)c);
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
|
|
|
|
type:TQByteArray
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
|
|
|
|
|
|
|
|
if ( pb && pb->bf_getreadbuffer && pb->bf_getsegcount )
|
|
|
|
{
|
|
|
|
// Get the number of buffer segments
|
|
|
|
int seg_count = (pb->bf_getsegcount)(obj, 0);
|
|
|
|
|
|
|
|
if ( seg_count != 1 )
|
|
|
|
// Can't handle more (or less) than 1 buffer segment
|
|
|
|
// at the moment
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Get buffer size and data
|
|
|
|
void *data;
|
|
|
|
int size;
|
|
|
|
|
|
|
|
if ( (size = (pb->bf_getreadbuffer)(obj, 0, &data)) < 0 )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (str) {
|
|
|
|
TQByteArray a;
|
|
|
|
a.setRawData( (const char*)data, size );
|
|
|
|
(*str) << a;
|
|
|
|
a.resetRawData( (const char*)data, size );
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
// obj does not implement the buffer interface
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
// Demarshal to a writable buffer object
|
|
|
|
TQByteArray a;
|
|
|
|
(*str) >> a;
|
|
|
|
|
|
|
|
uint size = a.size();
|
|
|
|
char *data = a.data();
|
|
|
|
|
|
|
|
// Create a new buffer object and copy the data.
|
|
|
|
// Don't use PyBuffer_FromMemory() and the likes since
|
|
|
|
// that wouldn't give correct allocation and deallocation.
|
|
|
|
|
|
|
|
PyObject *buffer_obj = PyBuffer_New( size );
|
|
|
|
|
|
|
|
if ( !buffer_obj )
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
PyBufferProcs *pb = buffer_obj->ob_type->tp_as_buffer;
|
|
|
|
|
|
|
|
void *buffer_data;
|
|
|
|
|
|
|
|
(pb->bf_getwritebuffer)( buffer_obj, 0, &buffer_data );
|
|
|
|
|
|
|
|
for ( uint i = 0; i < size; i++ )
|
|
|
|
((char*)buffer_data)[i] = data[i];
|
|
|
|
|
|
|
|
return buffer_obj;
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQString
|
|
|
|
%doc as str s
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (!PyString_Check(obj)) return false;
|
|
|
|
if (str) {
|
|
|
|
TQString s( PyString_AsString(obj) );
|
|
|
|
(*str) << s;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
TQString s;
|
|
|
|
(*str) >> s;
|
|
|
|
return PyString_FromString( s.utf8().data() );
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQCString
|
|
|
|
%doc as str s
|
|
|
|
%% marshal
|
|
|
|
{
|
|
|
|
if (!PyString_Check(obj)) return false;
|
|
|
|
if (str) {
|
|
|
|
TQCString s( PyString_AsString(obj) );
|
|
|
|
(*str) << s;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
%% demarshal
|
|
|
|
{
|
|
|
|
TQCString s;
|
|
|
|
(*str) >> s;
|
|
|
|
return PyString_FromString( s.data() );
|
|
|
|
}
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQRect
|
|
|
|
%doc as ( (int x1, int y1), (int x2, int y2) )
|
|
|
|
%doc as ( int x1, int y1, int x2, int y2 )
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
int xp1, yp1, xp2, yp2;
|
|
|
|
TQRect r;
|
|
|
|
*ok=false;
|
|
|
|
if (!PyTuple_Check(obj)) return r;
|
|
|
|
if (!PyArg_ParseTuple(obj, (char*)"(ii)(ii)", &xp1, &yp1, &xp2, &yp2) &&
|
|
|
|
!PyArg_ParseTuple(obj, (char*)"iiii", &xp1, &yp1, &xp2, &yp2))
|
|
|
|
return r;
|
|
|
|
r.setCoords( xp1, yp1, xp2, yp2 );
|
|
|
|
*ok=true;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
int xp1, yp1, xp2, yp2;
|
|
|
|
val.coords(&xp1,&yp1,&xp2,&yp2);
|
|
|
|
return Py_BuildValue((char*)"(ii)(ii)", xp1, yp1, xp2, yp2);
|
|
|
|
}
|
|
|
|
|
|
|
|
%% marshal
|
|
|
|
%defaultcode
|
|
|
|
%% demarshal
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQPoint
|
|
|
|
%doc as (int x, int y)
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
int x,y;
|
|
|
|
TQPoint p;
|
|
|
|
*ok=false;
|
|
|
|
if (!PyTuple_Check(obj)) return p;
|
|
|
|
if (!PyArg_ParseTuple(obj, (char*)"ii", &x, &y))
|
|
|
|
return p;
|
|
|
|
p.setX(x);
|
|
|
|
p.setY(y);
|
|
|
|
*ok=true;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
return Py_BuildValue((char*)"ii", val.x(), val.y() );
|
|
|
|
}
|
|
|
|
%% marshall
|
|
|
|
%defaultcode
|
|
|
|
%% demarshall
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQSize
|
|
|
|
%doc as (int width, int height)
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
int w,h;
|
|
|
|
TQSize sz;
|
|
|
|
*ok=false;
|
|
|
|
if (!PyTuple_Check(obj)) return sz;
|
|
|
|
if (!PyArg_ParseTuple(obj, (char*)"ii", &w, &h))
|
|
|
|
return sz;
|
|
|
|
sz.setWidth(w);
|
|
|
|
sz.setHeight(h);
|
|
|
|
*ok=true;
|
|
|
|
return sz;
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
return Py_BuildValue((char*)"ii", val.width(), val.height() );
|
|
|
|
}
|
|
|
|
%% marshall
|
|
|
|
%defaultcode
|
|
|
|
%% demarshall
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQColor
|
|
|
|
%doc as (int red, int green, int blue)
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
int r,g,b;
|
|
|
|
TQColor c;
|
|
|
|
*ok=false;
|
|
|
|
if (!PyTuple_Check(obj)) return c;
|
|
|
|
if (!PyArg_ParseTuple(obj, (char*)"iii", &r, &g, &b))
|
|
|
|
return c;
|
|
|
|
c.setRgb(r,g,b);
|
|
|
|
*ok=true;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
return Py_BuildValue((char*)"iii", val.red(), val.green(), val.blue() );
|
|
|
|
}
|
|
|
|
%% marshall
|
|
|
|
%defaultcode
|
|
|
|
%% demarshall
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQPointArray
|
|
|
|
%doc as [ (int x, int y), (int x, int y), (int x, int y), ... ]
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
*ok=false;
|
|
|
|
if (!PyList_Check(obj)) return TQPointArray();
|
|
|
|
int size = PyList_Size(obj);
|
|
|
|
TQPointArray pa(size);
|
|
|
|
for(int c=0;c<size;c++) {
|
|
|
|
TQPoint p = fromPyObject_QPoint(PyList_GetItem(obj,c), ok);
|
|
|
|
if (!*ok) return false;
|
|
|
|
pa.setPoint(c,p);
|
|
|
|
}
|
|
|
|
*ok=true;
|
|
|
|
return pa;
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
PyObject *obj = PyList_New(val.size());
|
|
|
|
if (!obj) return NULL;
|
|
|
|
for(uint c=0;c<val.size();c++) {
|
|
|
|
PyObject *tuple = toPyObject_QPoint( val.point(c) );
|
|
|
|
PyList_SetItem(obj, c, tuple);
|
|
|
|
// Py_DECREF(tuple);
|
|
|
|
}
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
%% marshall
|
|
|
|
%defaultcode
|
|
|
|
%% demarshall
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQDate
|
|
|
|
%doc as (int year, int month, int day)
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
*ok=false;
|
|
|
|
if (!PyTuple_Check(obj)) return TQDate();
|
|
|
|
int y,m,d;
|
|
|
|
if (!PyArg_ParseTuple(obj, (char*)"iii", &y, &m, &d))
|
|
|
|
return TQDate();
|
|
|
|
*ok=true;
|
|
|
|
return TQDate(y,m,d);
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
return Py_BuildValue((char*)"iii", val.year(), val.month(), val.day() );
|
|
|
|
}
|
|
|
|
%% marshal
|
|
|
|
%defaultcode
|
|
|
|
%% demarshal
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQTime
|
|
|
|
%doc as (int hour, int minute, int second=0, int millisecond=0)
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
*ok=false;
|
|
|
|
if (!PyTuple_Check(obj)) return TQTime();
|
|
|
|
int h,m,s=0,ms=0;
|
|
|
|
if (!PyArg_ParseTuple(obj, (char*)"ii|ii", &h, &m, &s, &ms))
|
|
|
|
return TQTime();
|
|
|
|
*ok=true;
|
|
|
|
return TQTime(h,m,s,ms);
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
return Py_BuildValue((char*)"iiii", val.hour(), val.minute(), val.second(), val.msec() );
|
|
|
|
}
|
|
|
|
%% marshal
|
|
|
|
%defaultcode
|
|
|
|
%% demarshal
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:TQDateTime
|
|
|
|
%doc as ( (int year, int month, int day), (int hour, int minute, int second=0, int millsecond=0) )
|
|
|
|
%doc as long unixDate
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
*ok=false;
|
|
|
|
|
|
|
|
if (PyLong_Check(obj)) {
|
|
|
|
*ok=true;
|
|
|
|
TQDateTime dt;
|
|
|
|
dt.setTime_t( (uint)PyLong_AsLong(obj) );
|
|
|
|
return dt;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (PyInt_Check(obj)) {
|
|
|
|
*ok=true;
|
|
|
|
TQDateTime dt;
|
|
|
|
dt.setTime_t( (uint)PyInt_AsLong(obj) );
|
|
|
|
return dt;
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject *date_tuple, *time_tuple;
|
|
|
|
if (PyArg_ParseTuple(obj, (char*)"OO", &date_tuple, &time_tuple)) {
|
|
|
|
TQDateTime dt;
|
|
|
|
dt.setTime( fromPyObject_QTime(time_tuple, ok) );
|
|
|
|
if (*ok) dt.setDate( fromPyObject_QDate(date_tuple, ok) );
|
|
|
|
return dt;
|
|
|
|
}
|
|
|
|
|
|
|
|
return TQDateTime();
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
PyObject *date_tuple = toPyObject_QDate( val.date() );
|
|
|
|
PyObject *time_tuple = toPyObject_QTime( val.time() );
|
|
|
|
return Py_BuildValue((char*)"OO", date_tuple, time_tuple );
|
|
|
|
}
|
|
|
|
%% marshal
|
|
|
|
%defaultcode
|
|
|
|
%% demarshal
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:KURL
|
|
|
|
%doc as str url
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
*ok=false;
|
|
|
|
if (!PyString_Check(obj)) return KURL();
|
|
|
|
*ok=true;
|
|
|
|
return KURL( TQString(PyString_AsString(obj)) );
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
return PyString_FromString( val.prettyURL().utf8().data() );
|
|
|
|
}
|
|
|
|
%% marshal
|
|
|
|
%defaultcode
|
|
|
|
%% demarshal
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
type:DCOPRef
|
|
|
|
%% from_pyobj
|
|
|
|
{
|
|
|
|
if (PyInstance_Check(obj) &&
|
|
|
|
PyObject_HasAttrString(obj, (char*)"appname") &&
|
|
|
|
PyObject_HasAttrString(obj, (char*)"name")) {
|
|
|
|
PyObject *appname = PyObject_GetAttrString(obj, (char*)"appname");
|
|
|
|
PyObject *name = PyObject_GetAttrString(obj, (char*)"name");
|
|
|
|
if (PyString_Check(appname) && PyString_Check(name)) {
|
|
|
|
char *c_appname = PyString_AsString(appname);
|
|
|
|
char *c_name = PyString_AsString(name);
|
|
|
|
DCOPRef ref;
|
|
|
|
ref.setRef(TQCString(c_appname), TQCString(c_name) );
|
|
|
|
Py_DECREF(appname);
|
|
|
|
Py_DECREF(name);
|
|
|
|
*ok=true;
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
Py_DECREF(appname);
|
|
|
|
Py_DECREF(name);
|
|
|
|
}
|
|
|
|
*ok=false;
|
|
|
|
return DCOPRef();
|
|
|
|
}
|
|
|
|
%% to_pyobj
|
|
|
|
{
|
|
|
|
if (val.isNull()) {
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
|
|
|
}
|
|
|
|
return ImportedModules::instance()->createDCOPObject(val.app(), val.object() );
|
|
|
|
}
|
|
|
|
%% marshal
|
|
|
|
%defaultcode
|
|
|
|
%% demarshal
|
|
|
|
%defaultcode
|
|
|
|
%%
|
|
|
|
|
|
|
|
|
|
|
|
// type:DCOPRef
|
|
|
|
// %doc as (str app, str obj, str type)
|
|
|
|
// %doc as (str app, str obj)
|
|
|
|
// %% from_pyobj
|
|
|
|
// {
|
|
|
|
// *ok=false;
|
|
|
|
// char *dcopref_app=NULL, *dcopref_obj=NULL, *dcopref_type=NULL;
|
|
|
|
// if (PyArg_ParseTuple(obj,(char*)"ss|s", &dcopref_app, &dcopref_obj, &dcopref_type)) {
|
|
|
|
// *ok=true;
|
|
|
|
// if (dcopref_type) {
|
|
|
|
// DCOPRef dr(TQCString(dcopref_app), TQCString(dcopref_obj), TQCString(dcopref_type));
|
|
|
|
// return dr;
|
|
|
|
// }
|
|
|
|
// DCOPRef dr(TQCString(dcopref_app), TQCString(dcopref_obj));
|
|
|
|
// return dr;
|
|
|
|
// }
|
|
|
|
// return DCOPRef();
|
|
|
|
// }
|
|
|
|
// %% to_pyobj
|
|
|
|
// {
|
|
|
|
// return Py_BuildValue((char*)"sss", val.app().data(), val.obj().data(), val.type().data() );
|
|
|
|
// }
|
|
|
|
// %% marshal
|
|
|
|
// %defaultcode
|
|
|
|
// %% demarshal
|
|
|
|
// %defaultcode
|
|
|
|
// %%
|
|
|
|
|
|
|
|
// type:TQFont
|
|
|
|
// %% marshal
|
|
|
|
// %constructor ("default")
|
|
|
|
// %dict-map family:string,rawName:string
|
|
|
|
// %% demarshal
|
|
|
|
// %dict-map
|
|
|
|
// %%
|