 |
itom 2.0.0
|
|
itom 2.0.0
|
One instance of this class acts as wrapper for several import public methods of classes, derived from QObject, which should be made available by the call-method in python. More...
Public Member Functions | |
| WidgetWrapper () | |
| constructor | |
| ~WidgetWrapper () | |
| destructor | |
| MethodDescriptionList | getMethodList (QObject *object) |
| returns a list of MethodDescription, which contains all wrapped methods of the given object and all its base classes. | |
| bool | call (QObject *object, int methodIndex, void **_a) |
| call method which calls a wrapped method of any class derived from QObject at runtime. This call is for exampled executed by UiOrganizer::callMethod. | |
| QMetaProperty | fakeProperty (const QObject *baseObject, const QString &fakePropertyName, QObject **destinationObject) |
| Method is able to handle unexisting properties and map them to existing ones (compatibility to QtDesigner) | |
Private Member Functions | |
| void | initMethodHash () |
| initializes the hash table containing information about all methods which should be wrapped. | |
| MethodDescription | buildMethodDescription (QByteArray signature, QString retType, int methodIndex, bool &ok) |
| creates an instance of MethodDescription which contains all necessary information in order to call the corresponding method at runtime using the method | |
Private Attributes | |
| QHash< QString, MethodDescriptionList > | methodHash |
| bool | initialized |
One instance of this class acts as wrapper for several import public methods of classes, derived from QObject, which should be made available by the call-method in python.
Usually, the huge meta system, provided by QMetaObject, of Qt gives the possibility to call slots and changes properties of all classes, derived from QObject, at runtime. Other public methods of these classes however can not be accessed by this runtime-system. Since the python-bindings which are integrated in the python-class UiDialog and UiDialogMetaObject use the Qt-meta system in order to access properties and connect to signals or call slots, it is also desirable to access other public methods of Qt-based classes. Frameworks, like PythonQt or PyQt have an internal parsing system which automatically creates wrappers for all public methods; here the class WidgetWrapper is a manually created wrapper for the most important methods.
| ito::WidgetWrapper::WidgetWrapper | ( | ) |
constructor
initializes a hash table containing information about all public-methods which should be wrapped and therefore accessed for instance from the python-method "call".
| MethodDescription ito::WidgetWrapper::buildMethodDescription | ( | QByteArray | signature, |
| QString | retType, | ||
| int | methodIndex, | ||
| bool & | ok | ||
| ) | [private] |
creates an instance of MethodDescription which contains all necessary information in order to call the corresponding method at runtime using the method
This method creates the neccesary input for the constructor of MethodDescription, which has pretty much the same functionality than the call of slots in Qt at runtime using the signal/slot and Qt-meta system.
| [in] | signature | is the Qt-like signature string for the method to wrap (e.g. "methodName(argType1,argType2,argType3,...)" without argument names) |
| [in] | typename | of the return value or "void" if no return value. This return type must be known by QMetaType, which is the case for all standard types, else use |
| [in] | a | self defined, unique ID for the method; this ID must only be unique within the corresponding Qt-class. |
| [out] | ok | returns whether the MethodDescription instance could successfully be built (true). |
| bool ito::WidgetWrapper::call | ( | QObject * | object, |
| int | methodIndex, | ||
| void ** | _a | ||
| ) |
call method which calls a wrapped method of any class derived from QObject at runtime. This call is for exampled executed by UiOrganizer::callMethod.
This method uses the class-name of object and checks if there is an call-implementation for the given methodIndex. If so, the call is executed (see switch-case inside of the method). If the method index does not fit, the class name of the base class of object is iteratively checked until either an appropriate method call could be executed or no other base class is available.
Please adapt the switch case in order to check for wrapped methods of other classes. Use the void-array _a and a reinterpret_cast- operation for accessing the necessary parameters and write back the return value of the "real" call to the wrapped public method.
| [in] | object | is the instance casted to its base class QObject, whose wrapped public method should be called |
| [in] | methodIndex | is the ID of the wrapped method to call |
| [in/out] | _a is a void-array containing the value for the return value as first element and the content of all argument as following elements. (similar to qt_metacall) |
| QMetaProperty ito::WidgetWrapper::fakeProperty | ( | const QObject * | baseObject, |
| const QString & | fakePropertyName, | ||
| QObject ** | destinationObject | ||
| ) |
Method is able to handle unexisting properties and map them to existing ones (compatibility to QtDesigner)
In QtDesigner, sometimes it is possible to change properties that are not directly extracted from the QMetaObject-system. However, QtDesigner adds some artifical sets of properties, especially for widgets derived from QTreeView and QTableView. Therefore, if methods UiOrganizer::writeProperties and UiOrganizer::readProperties fail to address the given property, they call this method. In the given property can be transformed into a new property of a new object, then this is returned, else an empty QMetaProperty is returned.
| [in] | baseObject | is the original input object |
| [in] | fakePropertyName | is the artificial property name |
| [out] | destinationObject | will be filled with a pointer to the new object, the new property is valid for (or NULL) |
| MethodDescriptionList ito::WidgetWrapper::getMethodList | ( | QObject * | object | ) |
returns a list of MethodDescription, which contains all wrapped methods of the given object and all its base classes.
Methods, contained in this list, can be accessed for example by python finally using the method call.
| [in] | object | is the pointer to an instance derived from QObject whose wrapped public methods should be returned |
| void ito::WidgetWrapper::initMethodHash | ( | ) | [private] |
initializes the hash table containing information about all methods which should be wrapped.
Every public method of a class derived from QObject can be made available for access by Python if some information about this method are contained in a corresponding instance of the class MethodDescription. A list of such instances is linked to its appropriate class and therefore stored in the hash table methodHash whose key is the Qt-internal name of the corresponding class. Classes which are derived from that class also have access to the recently wrapped methods.
If you want to register new wrapper methods for an Qt-based class with name "newClass", you should at first create a temporary variable of type MethodDescriptionList, which is nothing else but a QList<MethodDescription>. Then you can add elements to this list for example using the helper-method
All wrapped methods can finally be called by the method
bool ito::WidgetWrapper::initialized [private] |
member indicating whether the initMethodHash method already has been executed, which is done in the constructor of WidgetWrapper.
QHash<QString, MethodDescriptionList> ito::WidgetWrapper::methodHash [private] |
Hash-table containing a list of method description for all public methods of a class derived from QObject which should be accessed by the call method of WidgetWrapper at runtime.
1.7.4 
