Kross::WrapperInterface

Kross
WrapperInterface

#include <wrapperinterface.h>

Public Member Functions
virtual	~WrapperInterface ()

virtual void *	wrappedObject () const =0

Detailed Description

Wrapper-class used to provide handlers for custom types.

Custom types are types other than QObject*, QWidget* or one of the base types supported by QVariant. By using the Kross::registerMetaTypeHandler() method such custom handlers can be registered and used to either translate various types to a by QVariant supported type or by providing on the fly an own wrapper class that inherits from QObject and does provide access to the functionality of the wrapped custom type.

Following sample demonstrates the usage by registering a handler for the type "TestObject*". Once such a type got returned by a C++ class, the handler got called. If we return a QObject that implements the WrapperInterface, what is not needed, then the wrappedObject() method will be used to translate the wrapper back to the wrapped object if a C++ function got called and the wrapper is passed as argument.

// This is our wrapper class we are using to e.g. provide
// additional functionality on the fly or to provide access
// to a C++ type that does not inherit from QObject.
class MyWrapper : public QObject, public Kross::WrapperInterface {
    public:
        MyWrapper(QObject* obj) : QObject(obj) {}
        void* wrappedObject() const { return parent(); }
};
// This function will be called by Kross if a type named
// "TestObject*" got returned by a C++ method.
QVariant TestObjectHandler(void* ptr)
{
    TestObject* obj = static_cast<TestObject*>(ptr);
    MyWrapper* w = new MyWrapper(obj);
    QVariant r;
    r.setValue( (QObject*)w );
    return r;
}
// and somewhere else we finally register our function.
Kross::Manager::self().registerMetaTypeHandler("TestObject*", TestObjectHandler);