##// END OF EJS Templates
GIT_REPOSITORIES » LPP » PythonQt
RSS

Clone from https://github.com/Orochimarufan/PythonQt.git

fixed VC8 compilation...
florianlink -
r72:7af4191e88e0
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,581 +1,585
1 1 /*
2 2 *
3 3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtInstanceWrapper.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtInstanceWrapper.h"
43 43 #include <QObject>
44 44 #include "PythonQt.h"
45 45 #include "PythonQtSlot.h"
46 46 #include "PythonQtClassInfo.h"
47 47 #include "PythonQtConversion.h"
48 48 #include "PythonQtClassWrapper.h"
49 49
50 50 PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo()
51 51 {
52 52 // take the class info from our type object
53 53 return ((PythonQtClassWrapper*)ob_type)->_classInfo;
54 54 }
55 55
56 56 static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) {
57 57
58 58 // is this a C++ wrapper?
59 59 if (self->_wrappedPtr) {
60 60 //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
61 61
62 62 PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr);
63 63 // we own our qobject, so we delete it now:
64 64 delete self->_obj;
65 65 self->_obj = NULL;
66 66 if (force || self->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
67 67 int type = self->classInfo()->metaTypeId();
68 68 if (self->_useQMetaTypeDestroy && type>=0) {
69 69 // use QMetaType to destroy the object
70 70 QMetaType::destroy(type, self->_wrappedPtr);
71 71 } else {
72 72 PythonQtSlotInfo* slot = self->classInfo()->destructor();
73 73 if (slot) {
74 74 void* args[2];
75 75 args[0] = NULL;
76 76 args[1] = &self->_wrappedPtr;
77 77 slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, slot->slotIndex(), args);
78 78 self->_wrappedPtr = NULL;
79 79 } else {
80 80 if (type>=0) {
81 81 // use QMetaType to destroy the object
82 82 QMetaType::destroy(type, self->_wrappedPtr);
83 83 } else {
84 84 // TODO: warn about not being able to destroy the object?
85 85 }
86 86 }
87 87 }
88 88 }
89 89 } else {
90 90 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
91 91 if (self->_objPointerCopy) {
92 92 PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
93 93 }
94 94 if (self->_obj) {
95 95 if (force || self->_ownedByPythonQt) {
96 96 if (force || !self->_obj->parent()) {
97 97 delete self->_obj;
98 98 }
99 99 } else {
100 100 if (self->_obj->parent()==NULL) {
101 101 // tell someone who is interested that the qobject is no longer wrapped, if it has no parent
102 102 PythonQt::qObjectNoLongerWrappedCB(self->_obj);
103 103 }
104 104 }
105 105 }
106 106 }
107 107 self->_obj = NULL;
108 108 }
109 109
110 110 static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self)
111 111 {
112 112 PythonQtInstanceWrapper_deleteObject(self);
113 113 self->_obj.~QPointer<QObject>();
114 114 self->ob_type->tp_free((PyObject*)self);
115 115 }
116 116
117 117 static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
118 118 {
119 119 //PythonQtClassWrapper *classType = (PythonQtClassWrapper*)type;
120 120 PythonQtInstanceWrapper *self;
121 121 static PyObject* emptyTuple = NULL;
122 122 if (emptyTuple==NULL) {
123 123 emptyTuple = PyTuple_New(0);
124 124 }
125 125
126 126 self = (PythonQtInstanceWrapper*)PyBaseObject_Type.tp_new(type, emptyTuple, NULL);
127 127
128 128 if (self != NULL) {
129 129 new (&self->_obj) QPointer<QObject>();
130 130 self->_wrappedPtr = NULL;
131 131 self->_ownedByPythonQt = false;
132 132 self->_useQMetaTypeDestroy = false;
133 133 self->_isShellInstance = false;
134 134 }
135 135 return (PyObject *)self;
136 136 }
137 137
138 138 int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds)
139 139 {
140 140 if (args == PythonQtPrivate::dummyTuple()) {
141 141 // we are called from the internal PythonQt API, so our data will be filled later on...
142 142 return 0;
143 143 }
144 144
145 145 // we are called from python, try to construct our object
146 146 if (self->classInfo()->constructors()) {
147 147 void* directCPPPointer = NULL;
148 148 PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
149 149 if (PyErr_Occurred()) {
150 150 return -1;
151 151 }
152 152 if (directCPPPointer) {
153 153 // change ownershipflag to be owned by PythonQt
154 154 self->_ownedByPythonQt = true;
155 155 self->_useQMetaTypeDestroy = false;
156 156 if (self->classInfo()->isCPPWrapper()) {
157 157 self->_wrappedPtr = directCPPPointer;
158 158 // TODO xxx: if there is a wrapper factory, we might want to generate a wrapper for our class?!
159 159 } else {
160 160 self->setQObject((QObject*)directCPPPointer);
161 161 }
162 162 // register with PythonQt
163 163 PythonQt::priv()->addWrapperPointer(directCPPPointer, self);
164 164
165 165 PythonQtShellSetInstanceWrapperCB* cb = self->classInfo()->shellSetInstanceWrapperCB();
166 166 if (cb) {
167 167 // if we are a derived python class, we set the wrapper
168 168 // to activate the shell class, otherwise we just ignore that it is a shell...
169 169 // we detect it be checking if the type does not have PythonQtInstanceWrapper_Type as direct base class,
170 170 // which is the case for all non-python derived types
171 171 if (((PyObject*)self)->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
172 172 // set the wrapper and remember that we have a shell instance!
173 173 (*cb)(directCPPPointer, self);
174 174 self->_isShellInstance = true;
175 175 }
176 176 }
177 177 }
178 178 } else {
179 179 QString error = QString("No constructors available for ") + self->classInfo()->className();
180 180 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
181 181 return -1;
182 182 }
183 183 return 0;
184 184 }
185 185
186 186 static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj)
187 187 {
188 188 return PyString_FromString(obj->ob_type->tp_name);
189 189 }
190 190
191 191 static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj)
192 192 {
193 193 return PythonQt::self()->helpCalled(obj->classInfo());
194 194 }
195 195
196 196 static PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
197 197 {
198 198 PythonQtInstanceWrapper_deleteObject(self, true);
199 199 Py_INCREF(Py_None);
200 200 return Py_None;
201 201 }
202 202
203 203
204 204 static PyMethodDef PythonQtInstanceWrapper_methods[] = {
205 205 {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS,
206 206 "Return the classname of the object"
207 207 },
208 208 {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS,
209 209 "Shows the help of available methods for this class"
210 210 },
211 211 {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS,
212 212 "Deletes the C++ object (at your own risk, my friend!)"
213 213 },
214 214 {NULL, NULL, 0, NULL} /* Sentinel */
215 215 };
216 216
217 217
218 218 static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
219 219 {
220 220 const char *attributeName;
221 221 PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
222 222
223 223 if ((attributeName = PyString_AsString(name)) == NULL) {
224 224 return NULL;
225 225 }
226 226
227 227 if (qstrcmp(attributeName, "__dict__")==0) {
228 228 PyObject* dict = PyBaseObject_Type.tp_getattro(obj, name);
229 229 dict = PyDict_Copy(dict);
230 230
231 231 // only the properties are missing, the rest is already available from
232 232 // PythonQtClassWrapper...
233 233 QStringList l = wrapper->classInfo()->propertyList();
234 234 foreach (QString name, l) {
235 235 PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
236 236 if (o) {
237 237 PyDict_SetItemString(dict, name.toLatin1().data(), o);
238 238 Py_DECREF(o);
239 239 } else {
240 240 std::cerr << "PythonQtInstanceWrapper: something is wrong, could not get attribute " << name.toLatin1().data();
241 241 }
242 242 }
243 243 // Note: we do not put children into the dict, is would look confusing?!
244 244 return dict;
245 245 }
246 246
247 247 // first look in super, to return derived methods from base object first
248 248 PyObject* superAttr = PyBaseObject_Type.tp_getattro(obj, name);
249 249 if (superAttr) {
250 250 return superAttr;
251 251 }
252 252 PyErr_Clear();
253 253
254 254 if (!wrapper->_obj && !wrapper->_wrappedPtr) {
255 255 QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object";
256 256 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
257 257 return NULL;
258 258 }
259 259
260 260 // mlabDebugConst("Python","get " << attributeName);
261 261
262 262 // TODO: dynamic properties are missing
263 263
264 264 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
265 265 switch (member._type) {
266 266 case PythonQtMemberInfo::Property:
267 267 if (wrapper->_obj) {
268 268 if (member._property.userType() != QVariant::Invalid) {
269 269 return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
270 270 } else {
271 271 Py_INCREF(Py_None);
272 272 return Py_None;
273 273 }
274 274 }
275 275 break;
276 276 case PythonQtMemberInfo::Slot:
277 277 return PythonQtSlotFunction_New(member._slot, obj, NULL);
278 278 break;
279 279 case PythonQtMemberInfo::EnumValue:
280 {
280 281 PyObject* enumValue = member._enumValue;
281 282 Py_INCREF(enumValue);
282 283 return enumValue;
284 }
283 285 break;
284 286 case PythonQtMemberInfo::EnumWrapper:
287 {
285 288 PyObject* enumWrapper = member._enumWrapper;
286 289 Py_INCREF(enumWrapper);
287 290 return enumWrapper;
291 }
288 292 break;
289 293 default:
290 294 // is an invalid type, go on
291 295 break;
292 296 }
293 297
294 298 // look for the interal methods (className(), help())
295 299 PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName);
296 300 if (internalMethod) {
297 301 return internalMethod;
298 302 }
299 303 PyErr_Clear();
300 304
301 305 if (wrapper->_obj) {
302 306 // look for a child
303 307 QObjectList children = wrapper->_obj->children();
304 308 for (int i = 0; i < children.count(); i++) {
305 309 QObject *child = children.at(i);
306 310 if (child->objectName() == attributeName) {
307 311 return PythonQt::self()->priv()->wrapQObject(child);
308 312 }
309 313 }
310 314 }
311 315
312 316 QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
313 317 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
314 318 return NULL;
315 319 }
316 320
317 321 static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
318 322 {
319 323 QString error;
320 324 char *attributeName;
321 325 PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
322 326
323 327 if ((attributeName = PyString_AsString(name)) == NULL)
324 328 return -1;
325 329
326 330 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
327 331 if (member._type == PythonQtMemberInfo::Property) {
328 332
329 333 if (!wrapper->_obj) {
330 334 error = QString("Trying to set property '") + attributeName + "' on a destroyed " + wrapper->classInfo()->className() + " object";
331 335 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
332 336 return -1;
333 337 }
334 338
335 339 QMetaProperty prop = member._property;
336 340 if (prop.isWritable()) {
337 341 QVariant v;
338 342 if (prop.isEnumType()) {
339 343 // this will give us either a string or an int, everything else will probably be an error
340 344 v = PythonQtConv::PyObjToQVariant(value);
341 345 } else {
342 346 int t = prop.userType();
343 347 v = PythonQtConv::PyObjToQVariant(value, t);
344 348 }
345 349 bool success = false;
346 350 if (v.isValid()) {
347 351 success = prop.write(wrapper->_obj, v);
348 352 }
349 353 if (success) {
350 354 return 0;
351 355 } else {
352 356 error = QString("Property '") + attributeName + "' of type '" +
353 357 prop.typeName() + "' does not accept an object of type "
354 358 + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
355 359 }
356 360 } else {
357 361 error = QString("Property '") + attributeName + "' of " + obj->ob_type->tp_name + " object is not writable";
358 362 }
359 363 } else if (member._type == PythonQtMemberInfo::Slot) {
360 364 error = QString("Slot '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
361 365 } else if (member._type == PythonQtMemberInfo::EnumValue) {
362 366 error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
363 367 } else if (member._type == PythonQtMemberInfo::EnumWrapper) {
364 368 error = QString("Enum '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
365 369 } else if (member._type == PythonQtMemberInfo::NotFound) {
366 370 // if we are a derived python class, we allow setting attributes.
367 371 // if we are a direct CPP wrapper, we do NOT allow it, since
368 372 // it would be confusing to allow it because a wrapper will go away when it is not seen by python anymore
369 373 // and when it is recreated from a CPP pointer the attributes are gone...
370 374 if (obj->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
371 375 return PyBaseObject_Type.tp_setattro(obj,name,value);
372 376 } else {
373 377 error = QString("'") + attributeName + "' does not exist on " + obj->ob_type->tp_name + " and creating new attributes on C++ objects is not allowed";
374 378 }
375 379 }
376 380
377 381 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
378 382 return -1;
379 383 }
380 384
381 385 static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
382 386 {
383 387 PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
384 388 const char* typeName = obj->ob_type->tp_name;
385 389 QObject *qobj = wrapper->_obj;
386 390 if (wrapper->_wrappedPtr) {
387 391 QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
388 392 if (!str.isEmpty()) {
389 393 return PyString_FromFormat("%s", str.toLatin1().constData());
390 394 } else
391 395 if (wrapper->_obj) {
392 396 return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
393 397 } else {
394 398 return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
395 399 }
396 400 } else {
397 401 return PyString_FromFormat("%s (QObject %p)", typeName, qobj);
398 402 }
399 403 }
400 404
401 405 static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
402 406 {
403 407 PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
404 408 const char* typeName = obj->ob_type->tp_name;
405 409
406 410 QObject *qobj = wrapper->_obj;
407 411 if (wrapper->_wrappedPtr) {
408 412 QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
409 413 if (!str.isEmpty()) {
410 414 return PyString_FromFormat("%s(%s, %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr);
411 415 } else
412 416 if (wrapper->_obj) {
413 417 return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
414 418 } else {
415 419 return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
416 420 }
417 421 } else {
418 422 return PyString_FromFormat("%s (%s %p)", typeName, wrapper->classInfo()->className(), qobj);
419 423 }
420 424 }
421 425
422 426 static int PythonQtInstanceWrapper_compare(PyObject * obj1, PyObject * obj2)
423 427 {
424 428 if (PyObject_TypeCheck(obj1, &PythonQtInstanceWrapper_Type) &&
425 429 PyObject_TypeCheck(obj2, &PythonQtInstanceWrapper_Type)) {
426 430
427 431 PythonQtInstanceWrapper* w1 = (PythonQtInstanceWrapper*)obj1;
428 432 PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)obj2;
429 433 // check pointers directly first:
430 434 if (w1->_wrappedPtr != NULL) {
431 435 if (w1->_wrappedPtr == w2->_wrappedPtr) {
432 436 return 0;
433 437 }
434 438 } else if (w1->_obj == w2->_obj) {
435 439 return 0;
436 440 }
437 441 const char* class1 = w1->classInfo()->className();
438 442 const char* class2 = w2->classInfo()->className();
439 443 if (strcmp(class1, class2) == 0) {
440 444 // same class names, so we can try the operator_equal
441 445 PythonQtMemberInfo info = w1->classInfo()->member("operator_equal");
442 446 if (info._type == PythonQtMemberInfo::Slot) {
443 447 bool result = false;
444 448 void* obj1 = w1->_wrappedPtr;
445 449 if (!obj1) {
446 450 obj1 = w1->_obj;
447 451 }
448 452 if (!obj1) { return -1; }
449 453 void* obj2 = w2->_wrappedPtr;
450 454 if (!obj2) {
451 455 obj2 = w2->_obj;
452 456 }
453 457 if (!obj2) { return -1; }
454 458 if (info._slot->isInstanceDecorator()) {
455 459 // call on decorator QObject
456 460 void* args[3];
457 461 args[0] = &result;
458 462 args[1] = &obj1; // this is a pointer, so it needs a pointer to a pointer
459 463 args[2] = obj2; // this is a reference, so it needs the direct pointer
460 464 info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
461 465 return result?0:-1;
462 466 } else {
463 467 // call directly on QObject
464 468 if (w1->_obj && w2->_obj) {
465 469 void* args[2];
466 470 args[0] = &result;
467 471 args[2] = obj2; // this is a reference, so it needs the direct pointer
468 472 w1->_obj->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
469 473 }
470 474 }
471 475 }
472 476 }
473 477 }
474 478 return -1;
475 479 }
476 480
477 481 static int PythonQtInstanceWrapper_nonzero(PyObject *obj)
478 482 {
479 483 PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
480 484 return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
481 485 }
482 486
483 487
484 488 static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj)
485 489 {
486 490 if (obj->_wrappedPtr != NULL) {
487 491 return reinterpret_cast<long>(obj->_wrappedPtr);
488 492 } else {
489 493 QObject* qobj = obj->_obj; // get pointer from QPointer wrapper
490 494 return reinterpret_cast<long>(qobj);
491 495 }
492 496 }
493 497
494 498
495 499
496 500 // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
497 501 static PyNumberMethods PythonQtInstanceWrapper_as_number = {
498 502 0, /* nb_add */
499 503 0, /* nb_subtract */
500 504 0, /* nb_multiply */
501 505 0, /* nb_divide */
502 506 0, /* nb_remainder */
503 507 0, /* nb_divmod */
504 508 0, /* nb_power */
505 509 0, /* nb_negative */
506 510 0, /* nb_positive */
507 511 0, /* nb_absolute */
508 512 PythonQtInstanceWrapper_nonzero, /* nb_nonzero */
509 513 0, /* nb_invert */
510 514 0, /* nb_lshift */
511 515 0, /* nb_rshift */
512 516 0, /* nb_and */
513 517 0, /* nb_xor */
514 518 0, /* nb_or */
515 519 0, /* nb_coerce */
516 520 0, /* nb_int */
517 521 0, /* nb_long */
518 522 0, /* nb_float */
519 523 0, /* nb_oct */
520 524 0, /* nb_hex */
521 525 0, /* nb_inplace_add */
522 526 0, /* nb_inplace_subtract */
523 527 0, /* nb_inplace_multiply */
524 528 0, /* nb_inplace_divide */
525 529 0, /* nb_inplace_remainder */
526 530 0, /* nb_inplace_power */
527 531 0, /* nb_inplace_lshift */
528 532 0, /* nb_inplace_rshift */
529 533 0, /* nb_inplace_and */
530 534 0, /* nb_inplace_xor */
531 535 0, /* nb_inplace_or */
532 536 0, /* nb_floor_divide */
533 537 0, /* nb_true_divide */
534 538 0, /* nb_inplace_floor_divide */
535 539 0, /* nb_inplace_true_divide */
536 540 };
537 541
538 542 PyTypeObject PythonQtInstanceWrapper_Type = {
539 543 PyObject_HEAD_INIT(&PythonQtClassWrapper_Type)
540 544 0, /*ob_size*/
541 545 "PythonQt.PythonQtInstanceWrapper", /*tp_name*/
542 546 sizeof(PythonQtInstanceWrapper), /*tp_basicsize*/
543 547 0, /*tp_itemsize*/
544 548 (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
545 549 0, /*tp_print*/
546 550 0, /*tp_getattr*/
547 551 0, /*tp_setattr*/
548 552 PythonQtInstanceWrapper_compare, /*tp_compare*/
549 553 PythonQtInstanceWrapper_repr, /*tp_repr*/
550 554 &PythonQtInstanceWrapper_as_number, /*tp_as_number*/
551 555 0, /*tp_as_sequence*/
552 556 0, /*tp_as_mapping*/
553 557 (hashfunc)PythonQtInstanceWrapper_hash, /*tp_hash */
554 558 0, /*tp_call*/
555 559 PythonQtInstanceWrapper_str, /*tp_str*/
556 560 PythonQtInstanceWrapper_getattro, /*tp_getattro*/
557 561 PythonQtInstanceWrapper_setattro, /*tp_setattro*/
558 562 0, /*tp_as_buffer*/
559 563 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
560 564 "PythonQtInstanceWrapper object", /* tp_doc */
561 565 0, /* tp_traverse */
562 566 0, /* tp_clear */
563 567 0, /* tp_richcompare */
564 568 0, /* tp_weaklistoffset */
565 569 0, /* tp_iter */
566 570 0, /* tp_iternext */
567 571 0, /* tp_methods */
568 572 0, /* tp_members */
569 573 0, /* tp_getset */
570 574 0, /* tp_base */
571 575 0, /* tp_dict */
572 576 0, /* tp_descr_get */
573 577 0, /* tp_descr_set */
574 578 0, /* tp_dictoffset */
575 579 (initproc)PythonQtInstanceWrapper_init, /* tp_init */
576 580 0, /* tp_alloc */
577 581 PythonQtInstanceWrapper_new, /* tp_new */
578 582 };
579 583
580 584 //-------------------------------------------------------
581 585
General Comments 0
You need to be logged in to leave comments. Login now