/usr/include/PythonQt/PythonQt.h is in libpythonqt-dev 2.1.0~svn247-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 | #ifndef _PYTHONQT_H
#define _PYTHONQT_H
/*
*
* Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
* 28359 Bremen, Germany or:
*
* http://www.mevis.de
*
*/
//----------------------------------------------------------------------------------
/*!
// \file PythonQt.h
// \author Florian Link
// \author Last changed by $Author: florian $
// \date 2006-05
*/
//----------------------------------------------------------------------------------
#include "PythonQtSystem.h"
#include "PythonQtInstanceWrapper.h"
#include "PythonQtClassWrapper.h"
#include "PythonQtSlot.h"
#include "PythonQtObjectPtr.h"
#include "PythonQtStdIn.h"
#include <QObject>
#include <QVariant>
#include <QList>
#include <QHash>
#include <QByteArray>
#include <QStringList>
#include <QtDebug>
#include <iostream>
class PythonQtClassInfo;
class PythonQtPrivate;
class PythonQtMethodInfo;
class PythonQtSignalReceiver;
class PythonQtImportFileInterface;
class PythonQtCppWrapperFactory;
class PythonQtForeignWrapperFactory;
class PythonQtQFileImporter;
typedef void PythonQtQObjectWrappedCB(QObject* object);
typedef void PythonQtQObjectNoLongerWrappedCB(QObject* object);
typedef void* PythonQtPolymorphicHandlerCB(const void *ptr, const char **class_name);
typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* wrapper);
template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) {
(reinterpret_cast<T*>(object))->_wrapper = wrapper;
}
//! returns the offset that needs to be added to upcast an object of type T1 to T2
template<class T1, class T2> int PythonQtUpcastingOffset() {
return ((reinterpret_cast<char*>(static_cast<T2*>(reinterpret_cast<T1*>(0x100))))
- (reinterpret_cast<char*>(reinterpret_cast<T1*>(0x100))));
}
//! callback to create a QObject lazily
typedef QObject* PythonQtQObjectCreatorFunctionCB();
//! helper template to create a derived QObject class
template<class T> QObject* PythonQtCreateObject() { return new T(); };
//! The main interface to the Python Qt binding, realized as a singleton
/*!
Use PythonQt::init() to initialize the singleton and PythonQt::self() to access it.
While there can be only one PythonQt instance, you can have any number of Python context to do scripting in.
One possibility is to use createModuleFromFile(), createModuleFromScript() or createUniqueModule() to get a context
that is separated from the other contexts. Alternatively you can use Python dicts as contexts for script evaluation,
but you will need to populate the dict with the __builtins__ instance to have all Pythons available when running
code in the scope of a dict.
*/
class PYTHONQT_EXPORT PythonQt : public QObject {
Q_OBJECT
public:
//! flags that can be passed to PythonQt::init()
enum InitFlags {
RedirectStdOut = 1, //!<< sets if the std out/err is redirected to pythonStdOut() and pythonStdErr() signals
IgnoreSiteModule = 2, //!<< sets if Python should ignore the site module
ExternalHelp = 4, //!<< sets if help() calls on PythonQt modules are forwarded to the pythonHelpRequest() signal
PythonAlreadyInitialized = 8 //!<< sets that PythonQt should not can PyInitialize, since it is already done
};
//! flags that tell PythonQt which operators to expect on the registered type
enum TypeSlots {
Type_Add = 1,
Type_Subtract = 1 << 1,
Type_Multiply = 1 << 2,
Type_Divide = 1 << 3,
Type_Mod = 1 << 4,
Type_And = 1 << 5,
Type_Or = 1 << 6,
Type_Xor = 1 << 7,
Type_LShift = 1 << 8,
Type_RShift = 1 << 9,
Type_InplaceAdd = 1 << 10,
Type_InplaceSubtract = 1 << 11,
Type_InplaceMultiply = 1 << 12,
Type_InplaceDivide = 1 << 13,
Type_InplaceMod = 1 << 14,
Type_InplaceAnd = 1 << 15,
Type_InplaceOr = 1 << 16,
Type_InplaceXor = 1 << 17,
Type_InplaceLShift = 1 << 18,
Type_InplaceRShift = 1 << 19,
// Not yet needed/nicely mappable/generated...
//Type_Positive = 1 << 29,
//Type_Negative = 1 << 29,
//Type_Abs = 1 << 29,
//Type_Hash = 1 << 29,
Type_Invert = 1 << 29,
Type_RichCompare = 1 << 30,
Type_NonZero = 1 << 31,
};
//! enum for profiling callback
enum ProfilingCallbackState {
Enter = 1,
Leave = 2
};
//! callback for profiling. className and methodName are only passed when state == Enter, otherwise
//! they are NULL.
typedef void ProfilingCB(ProfilingCallbackState state, const char* className, const char* methodName);
//---------------------------------------------------------------------------
//! \name Singleton Initialization
//@{
//! initialize the python qt binding (flags are a or combination of PythonQt::InitFlags), if \c pythonQtModuleName is given
//! it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used.
//! This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.
static void init(int flags = IgnoreSiteModule | RedirectStdOut, const QByteArray& pythonQtModuleName = QByteArray());
//! cleanup of the singleton
static void cleanup();
//! get the singleton instance
static PythonQt* self();
//@}
//! defines the object types for introspection
enum ObjectType {
Class,
Function,
Variable,
Module,
Anything,
CallOverloads
};
//---------------------------------------------------------------------------
//! \name Standard input handling
//@{
//! Overwrite default handling of stdin using a custom callback. It internally backup
//! the original 'sys.stdin' into 'sys.pythonqt_original_stdin'
void setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData = 0);
//! Enable or disable stdin custom callback. It resets 'sys.stdin' using either 'sys.pythonqt_stdin'
//! or 'sys.pythonqt_original_stdin'
void setRedirectStdInCallbackEnabled(bool enabled);
//@}
//---------------------------------------------------------------------------
//! \name Modules
//@{
//! get the __main__ module of python
PythonQtObjectPtr getMainModule();
//! import the given module and return a reference to it (useful to import e.g. "sys" and call something on it)
//! If a module is already imported, this returns the already imported module.
PythonQtObjectPtr importModule(const QString& name);
//! creates the new module \c name and evaluates the given file in the context of that module
//! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
//! to a module later on.
//! The user needs to make sure that the \c name is unique in the python module dictionary.
PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);
//! creates the new module \c name and evaluates the given script in the context of that module.
//! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
//! to a module later on.
//! The user needs to make sure that the \c name is unique in the python module dictionary.
PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());
//! create a uniquely named module, you can use evalFile or evalScript to populate the module with
//! script code
PythonQtObjectPtr createUniqueModule();
//@}
//---------------------------------------------------------------------------
//! \name Importing/Paths
//@{
//! overwrite the python sys path (call this directly after PythonQt::init() if you want to change the std python sys path)
void overwriteSysPath(const QStringList& paths);
//! prepend a path to sys.path to allow importing from it
void addSysPath(const QString& path);
//! sets the __path__ list of a module to the given list (important for local imports)
void setModuleImportPath(PyObject* module, const QStringList& paths);
//@}
//---------------------------------------------------------------------------
//! \name Registering Classes
//@{
//! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
/* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
//! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
//! (ownership of wrapper is passed to PythonQt)
/*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
This will add a wrapper object that is used to make calls to the given classname \c typeName.
All slots that take a pointer to typeName as the first argument will be callable from Python on
a variant object that contains such a type.
*/
void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
//! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
//! and it will register the classes when it first sees a pointer to such a derived class
void registerQObjectClassNames(const QStringList& names);
//! add a parent class relation to the \c given typeName, the upcastingOffset is needed for multiple inheritance
//! and can be calculated using PythonQtUpcastingOffset<type,parentType>(), which also verifies that
//! type is really derived from parentType.
//! Returns false if the typeName was not yet registered.
bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset=0);
//! add a handler for polymorphic downcasting
void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
//@}
//---------------------------------------------------------------------------
//! \name Script Parsing and Evaluation
//@{
//! parses the given file and returns the python code object, this can then be used to call evalCode()
PythonQtObjectPtr parseFile(const QString& filename);
//! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string)
//! If pycode is NULL, a python error is printed.
QVariant evalCode(PyObject* object, PyObject* pycode);
//! evaluates the given script code and returns the result value
QVariant evalScript(PyObject* object, const QString& script, int start = Py_file_input);
//! evaluates the given script code from file
void evalFile(PyObject* object, const QString& filename);
//@}
//---------------------------------------------------------------------------
//! \name Signal Handlers
//@{
//! add a signal handler to the given \c signal of \c obj and connect it to a callable \c objectname in module
bool addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
//! remove a signal handler from the given \c signal of \c obj
bool removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
//! add a signal handler to the given \c signal of \c obj and connect it to a callable \c receiver
bool addSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
//! remove a signal handler from the given \c signal of \c obj
bool removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
//@}
//---------------------------------------------------------------------------
//! \name Variable access
//@{
//! add the given \c qObject to the python \c object as a variable with \c name (it can be removed via clearVariable)
void addObject(PyObject* object, const QString& name, QObject* qObject);
//! add the given variable to the object
void addVariable(PyObject* object, const QString& name, const QVariant& v);
//! remove the given variable
void removeVariable(PyObject* module, const QString& name);
//! get the variable with the \c name of the \c object, returns an invalid QVariant on error
QVariant getVariable(PyObject* object, const QString& name);
//! read vars etc. in scope of an \c object, optional looking inside of an object \c objectname
QStringList introspection(PyObject* object, const QString& objectname, ObjectType type);
//! read vars etc. in scope of the given \c object
QStringList introspectObject(PyObject* object, ObjectType type);
//! read vars etc. in scope of the type object called \c typename. First the typename
//! of the form module.type is split into module and type. Then the module is looked up
//! in sys.modules. If the module or type is not found there, then the type is looked up in
//! the __builtin__ module.
QStringList introspectType(const QString& typeName, ObjectType type);
//! returns the found callable object or NULL
//! @return new reference
PythonQtObjectPtr lookupCallable(PyObject* object, const QString& name);
//! returns the return type of the method of a wrapped c++ object referenced by \c objectname
QString getReturnTypeOfWrappedMethod(PyObject* module, const QString& objectname);
//! returns the return type of the method \c methodName of a wrapped c++ type referenced by \c typeName
QString getReturnTypeOfWrappedMethod(const QString& typeName, const QString& methodName);
//@}
//---------------------------------------------------------------------------
//! \name Calling Python Objects
//@{
//! call the given python \c callable in the scope of object, returns the result converted to a QVariant
QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
//! call the given python object, returns the result converted to a QVariant
QVariant call(PyObject* callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
//! call the given python object, returns the result as new PyObject
PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
//@}
//---------------------------------------------------------------------------
//! \name Decorations, Constructors, Wrappers...
//@{
//! add an object whose slots will be used as decorator slots for
//! other QObjects or CPP classes. The slots need to follow the
//! convention that the first argument is a pointer to the wrapped object.
//! (ownership is passed to PythonQt)
/*!
Example:
A slot with the signature
\code
bool doSomething(QWidget* w, int a)
\endcode
will extend QWidget instances (and derived classes) with a "bool doSomething(int a)" slot
that will be called with the concrete instance as first argument.
So in Python you can now e.g. call
\code
someWidget.doSomething(12)
\endcode
without QWidget really having this method. This allows to easily make normal methods
of Qt classes callable by forwarding them with such decorator slots
or to make CPP classes (which are not derived from QObject) callable from Python.
*/
void addInstanceDecorators(QObject* o);
//! add an object whose slots will be used as decorator slots for
//! class objects (ownership is passed to PythonQt)
/*!
The slots need to follow the following convention:
- SomeClass* new_SomeClass(...)
- QVariant new_SomeClass(...)
- void delete_SomeClass(SomeClass*)
- ... static_SomeClass_someName(...)
This will add:
- a constructor
- a constructor which generates a QVariant
- a destructor (only useful for CPP objects)
- a static decorator slot which will be available on the MetaObject (visible in PythonQt module)
*/
void addClassDecorators(QObject* o);
//! this will add the object both as class and instance decorator (ownership is passed to PythonQt)
void addDecorators(QObject* o);
//! add the given factory to PythonQt (ownership stays with caller)
void addWrapperFactory(PythonQtCppWrapperFactory* factory);
//! add the given factory to PythonQt (ownership stays with caller)
void addWrapperFactory(PythonQtForeignWrapperFactory* factory);
//! remove the wrapper factory
void removeWrapperFactory(PythonQtCppWrapperFactory* factory);
//! remove the wrapper factory
void removeWrapperFactory(PythonQtForeignWrapperFactory* factory);
//@}
//---------------------------------------------------------------------------
//! \name Custom Importer
//@{
//! replace the internal import implementation and use the supplied interface to load files (both py and pyc files)
//! (this method should be called directly after initialization of init() and before calling overwriteSysPath().
//! On the first call to this method, it will install a generic PythonQt importer in Pythons "path_hooks".
//! This is not reversible, so even setting setImporter(NULL) afterwards will
//! keep the custom PythonQt importer with a QFile default import interface.
//! Subsequent python import calls will make use of the passed importInterface
//! which forwards all import calls to the given \c importInterface.
//! Passing NULL will install a default QFile importer.
//! (\c importInterface ownership stays with caller)
void setImporter(PythonQtImportFileInterface* importInterface);
//! this installs the default QFile importer (which effectively does a setImporter(NULL))
//! (without calling setImporter or installDefaultImporter at least once, the default python import
//! mechanism is in place)
//! the default importer allows to import files from anywhere QFile can read from,
//! including the Qt resource system using ":". Keep in mind that you need to extend
//! "sys.path" with ":" to be able to import from the Qt resources.
void installDefaultImporter() { setImporter(NULL); }
//! set paths that the importer should ignore
void setImporterIgnorePaths(const QStringList& paths);
//! get paths that the importer should ignore
const QStringList& getImporterIgnorePaths();
//! get access to the file importer (if set)
static PythonQtImportFileInterface* importInterface();
//@}
//---------------------------------------------------------------------------
//! \name Other Stuff
//@{
//! get access to internal data (should not be used on the public API, but is used by some C functions)
static PythonQtPrivate* priv() { return _self->_p; }
//! clear all NotFound entries on all class infos, to ensure that
//! newly loaded wrappers can add methods even when the object was wrapped by PythonQt before the wrapper was loaded
void clearNotFoundCachedMembers();
//! handle a python error, call this when a python function fails. If no error occurred, it returns false.
//! The error is currently just output to the python stderr, future version might implement better trace printing
bool handleError();
//! return \a true if \a handleError() has been called and an error occured.
bool hadError()const;
//! reset error flag. After calling this, hadError() will return false.
//! \sa hadError()
void clearError();
//! if set to true, the systemExitExceptionRaised signal will be emitted if exception SystemExit is caught
//! \sa handleError()
void setSystemExitExceptionHandlerEnabled(bool value);
//! return \a true if SystemExit exception is handled by PythonQt
//! \sa setSystemExitExceptionHandlerEnabled()
bool systemExitExceptionHandlerEnabled() const;
//! set a callback that is called when a QObject with parent == NULL is wrapped by PythonQt
void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
//! set a callback that is called when a QObject with parent == NULL is no longer wrapped by PythonQt
void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);
//! call the callback if it is set
static void qObjectNoLongerWrappedCB(QObject* o);
//! called by internal help methods
PyObject* helpCalled(PythonQtClassInfo* info);
//! returns the found object or NULL
//! @return new reference
PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);
//! sets a callback that is called before and after function calls for profiling
void setProfilingCallback(ProfilingCB* cb);
//@}
signals:
//! emitted when python outputs something to stdout (and redirection is turned on)
void pythonStdOut(const QString& str);
//! emitted when python outputs something to stderr (and redirection is turned on)
void pythonStdErr(const QString& str);
//! emitted when help() is called on a PythonQt object and \c ExternalHelp is enabled
void pythonHelpRequest(const QByteArray& cppClassName);
//! emitted when both custom SystemExit exception handler is enabled and a SystemExit
//! exception is raised.
//! \sa setSystemExitExceptionHandlerEnabled(bool)
void systemExitExceptionRaised(int exitCode);
private:
void initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName);
QString getReturnTypeOfWrappedMethodHelper(const PythonQtObjectPtr& variableObject, const QString& methodName, const QString& context);
PyObject* getObjectByType(const QString& typeName);
//! callback for stdout redirection, emits pythonStdOut signal
static void stdOutRedirectCB(const QString& str);
//! callback for stderr redirection, emits pythonStdErr signal
static void stdErrRedirectCB(const QString& str);
//! get (and create if not available) the signal receiver of that QObject, signal receiver is made child of the passed \c obj
PythonQtSignalReceiver* getSignalReceiver(QObject* obj);
PythonQt(int flags, const QByteArray& pythonQtModuleName);
~PythonQt();
static PythonQt* _self;
static int _uniqueModuleCount;
PythonQtPrivate* _p;
};
//! internal PythonQt details
class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
Q_OBJECT
public:
PythonQtPrivate();
~PythonQtPrivate();
enum DecoratorTypes {
StaticDecorator = 1,
ConstructorDecorator = 2,
DestructorDecorator = 4,
InstanceDecorator = 8,
AllDecorators = 0xffff
};
//! get the suffixes that are used for shared libraries
const QStringList& sharedLibrarySuffixes() { return _sharedLibrarySuffixes; }
//! returns if the id is the id for PythonQtObjectPtr
bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }
//! add the wrapper pointer (for reuse if the same obj appears while wrapper still exists)
void addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper);
//! remove the wrapper ptr again
void removeWrapperPointer(void* obj);
//! called by destructor of shells to allow invalidation of the Python wrapper
void shellClassDeleted(void* shellClass);
//! try to unwrap the given object to a C++ pointer using the foreign wrapper factories
void* unwrapForeignWrapper(const QByteArray& classname, PyObject* obj);
//! add parent class relation
bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset);
//! add a handler for polymorphic downcasting
void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
//! lookup existing classinfo and return new if not yet present
PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);
//! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map
void removeSignalEmitter(QObject* obj);
//! wrap the given QObject into a Python object (or return existing wrapper!)
PyObject* wrapQObject(QObject* obj);
//! wrap the given ptr into a Python object (or return existing wrapper!) if there is a known QObject of that name or a known wrapper in the factory
PyObject* wrapPtr(void* ptr, const QByteArray& name);
//! create a read-only buffer object from the given memory
static PyObject* wrapMemoryAsBuffer(const void* data, Py_ssize_t size);
//! create a read-write buffer object from the given memory
static PyObject* wrapMemoryAsBuffer(void* data, Py_ssize_t size);
//! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
/* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
//! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
//! (ownership of wrapper is passed to PythonQt)
/*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
This will add a wrapper object that is used to make calls to the given classname \c typeName.
All slots that take a pointer to typeName as the first argument will be callable from Python on
a variant object that contains such a type.
*/
void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
//! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
//! and it will register the classes when it first sees a pointer to such a derived class
void registerQObjectClassNames(const QStringList& names);
//! add a decorator object
void addDecorators(QObject* o, int decoTypes);
//! helper method that creates a PythonQtClassWrapper object (returns a new reference)
PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* module);
//! create a new instance of the given enum type with given value (returns a new reference)
static PyObject* createEnumValueInstance(PyObject* enumType, unsigned int enumValue);
//! helper that creates a new int derived class that represents the enum of the given name (returns a new reference)
static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
//! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
//! get the class info for a meta object (if available)
PythonQtClassInfo* getClassInfo(const QMetaObject* meta) { return _knownClassInfos.value(meta->className()); }
//! get the class info for a meta object (if available)
PythonQtClassInfo* getClassInfo(const QByteArray& className) { return _knownClassInfos.value(className); }
//! creates the new module from the given pycode
PythonQtObjectPtr createModule(const QString& name, PyObject* pycode);
//! get the current class info (for the next PythonQtClassWrapper that is created) and reset it to NULL again
PythonQtClassInfo* currentClassInfoForClassWrapperCreation();
//! the dummy tuple (which is empty and may be used to detected that a wrapper is called from internal wrapper creation
static PyObject* dummyTuple();
//! called by virtual overloads when a python return value can not be converted to the required Qt type
void handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result);
//! get access to the PythonQt module
PythonQtObjectPtr pythonQtModule() const { return _pythonQtModule; }
//! returns the profiling callback, which may be NULL
PythonQt::ProfilingCB* profilingCB() const { return _profilingCB; }
//! determines the signature of the given callable object (similar as pydoc)
QString getSignature(PyObject* object);
//! returns true if the object is a method descriptor (same as inspect.ismethoddescriptor() in inspect.py)
bool isMethodDescriptor(PyObject* object) const;
private:
//! Setup the shared library suffixes by getting them from the "imp" module.
void setupSharedLibrarySuffixes();
//! create a new pythonqt class wrapper and place it in the pythonqt module
void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = NULL);
//! get/create new package module (the returned object is a borrowed reference)
PyObject* packageByName(const char* name);
//! get the wrapper for a given pointer (and remove a wrapper of an already destroyed qobject)
PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);
//! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects;
//! stores the meta info of known Qt classes
QHash<QByteArray, PythonQtClassInfo *> _knownClassInfos;
//! names of qobject derived classes that can be casted to qobject savely
QHash<QByteArray, bool> _knownQObjectClassNames;
//! stores signal receivers for QObjects
QHash<QObject* , PythonQtSignalReceiver *> _signalReceivers;
//! the PythonQt python module
PythonQtObjectPtr _pythonQtModule;
//! the name of the PythonQt python module
QByteArray _pythonQtModuleName;
//! the importer interface (if set)
PythonQtImportFileInterface* _importInterface;
//! the default importer
PythonQtQFileImporter* _defaultImporter;
PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
PythonQtQObjectWrappedCB* _wrappedCB;
QStringList _importIgnorePaths;
QStringList _sharedLibrarySuffixes;
//! the cpp object wrapper factories
QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;
QList<PythonQtForeignWrapperFactory*> _foreignWrapperFactories;
QHash<QByteArray, PyObject*> _packages;
PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
PythonQt::ProfilingCB* _profilingCB;
int _initFlags;
int _PythonQtObjectPtr_metaId;
bool _hadError;
bool _systemExitExceptionHandlerEnabled;
friend class PythonQt;
};
#endif
|