#ifndef _PYTHONQTOBJECTPTR_H

#define _PYTHONQTOBJECTPTR_H

#include "PythonQtPythonInclude.h"

#include "PythonQtSystem.h"

#include <QVariant>

#include <QVariantList>

#include <QVariantMap>

class PYTHONQT_EXPORT PythonQtObjectPtr

{

PythonQtObjectPtr():_object(NULL) {}

PythonQtObjectPtr(const PythonQtObjectPtr &p)

:_object(NULL) {

setObject(p.object());

}

//! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.

PythonQtObjectPtr(const QVariant& variant):_object(NULL) {

fromVariant(variant);

}

PythonQtObjectPtr(PyObject* o);

~PythonQtObjectPtr();

//! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.

bool fromVariant(const QVariant& variant);

PythonQtObjectPtr &operator=(const PythonQtObjectPtr &p) {

setObject(p.object());

return *this;

}

PythonQtObjectPtr &operator=(PyObject* o) {

setObject(o);

return *this;

}

PythonQtObjectPtr &operator=(const QVariant& variant) {

fromVariant(variant);

return *this;

}

bool operator==( const PythonQtObjectPtr &p ) const {

return object() == p.object();

}

bool operator!= ( const PythonQtObjectPtr& p ) const {

return !( *this == p );

}

bool operator==( PyObject* p ) const {

return object() == p;

}

bool operator!= ( PyObject* p ) const {

return object() != p;

}

bool isNull() const { return !object(); }

PyObject* operator->() const { return object(); }

PyObject& operator*() const { return *( object() ); }

operator PyObject*() const { return object(); }

//! sets the object and passes the ownership (stealing the reference, in Python slang)

void setNewRef(PyObject* o);

PyObject* object() const {

return _object;

}

//! evaluates the given script code in the context of this object and returns the result value

QVariant evalScript(const QString& script, int start = Py_file_input);

//! 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* pycode);

//! evaluates the given code in the context

void evalFile(const QString& filename);

//! add the given \c object to the \c module as a variable with \c name (it can be removed via clearVariable)

void addObject(const QString& name, QObject* object);

//! add the given variable to the module

void addVariable(const QString& name, const QVariant& v);

//! remove the given variable

void removeVariable(const QString& name);

//! get the variable with the \c name of the \c module, returns an invalid QVariant on error

QVariant getVariable(const QString& name);

//! call the given python object (in the scope of the current object), returns the result converted to a QVariant

QVariant call(const QString& callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());

//! call the contained python object directly, returns the result converted to a QVariant

QVariant call(const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());

void setObject(PyObject* o);

PyObject* _object;

};

Q_DECLARE_METATYPE(PythonQtObjectPtr)

#endif