D:/git-itom/sources/itom/Qitom/python/pythonQtSignalMapper.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2013, Institut fuer Technische Optik (ITO),
    Universitaet Stuttgart, Germany

    This file is part of itom.
  
    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.

    itom 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 Library
    General Public Licence for more details.

    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */

#ifndef PYTHONQTSIGNALMAPPER_H
#define PYTHONQTSIGNALMAPPER_H

#ifndef Q_MOC_RUN
    #define PY_ARRAY_UNIQUE_SYMBOL itom_ARRAY_API

    //python
    // see http://vtk.org/gitweb?p=VTK.git;a=commitdiff;h=7f3f750596a105d48ea84ebfe1b1c4ca03e0bab3
    #if (defined _DEBUG) && (!defined linux)
        #undef _DEBUG
        #include "Python.h"
        #define _DEBUG
    #else
        #include "Python.h"
    #endif
#endif

#include "../global.h"

#include <qvariant.h>
#include <qobject.h>

namespace ito
{

class PythonQtSignalTarget
{
public:

    PythonQtSignalTarget() :
        m_slotId(-1),
        m_signalId(-1),
        m_function(NULL),
        m_boundedInstance(NULL),
        m_boundedMethod(false)

    {
    };


    PythonQtSignalTarget(IntList &argTypeList, int slotId, int signalId, PyObject* callable, const char *signal) :
            m_slotId(slotId),
            m_signalId(signalId),
            m_function(NULL),
            m_boundedInstance(NULL),
            m_boundedMethod(false),
            m_signalName(signal)
    {
        m_argTypeList = argTypeList;
        PyObject *temp = NULL;

        if(PyMethod_Check(callable))
        {
            m_boundedMethod = true;
            Py_XDECREF(m_boundedInstance);
            Py_XDECREF(m_function);
            temp = PyMethod_Self(callable); //borrowed
            m_boundedInstance = PyWeakref_NewRef(temp, NULL); //new ref (weak reference used to avoid cyclic garbage collection)
            temp = PyMethod_Function(callable); //borrowed
            m_function = PyWeakref_NewRef(temp, NULL); //new ref
        }
        else if(PyFunction_Check(callable))
        {
            m_boundedMethod = false;
            Py_XDECREF(m_boundedInstance);
            Py_XDECREF(m_function);
            m_function = PyWeakref_NewRef(callable, NULL); //new ref
        }
    };
    
    PythonQtSignalTarget(const PythonQtSignalTarget &copy) :
        m_slotId(-1),
        m_signalId(-1),
        m_function(NULL),
        m_boundedInstance(NULL),
        m_boundedMethod(false),
        m_signalName(copy.m_signalName)
    {
        Py_XDECREF(m_boundedInstance);
        Py_XDECREF(m_function);
        m_slotId = copy.slotId();
        m_signalId = copy.signalId();
        m_argTypeList = copy.argTypeList();

        m_boundedMethod = copy.m_boundedMethod;
        m_function = copy.m_function;
        Py_XINCREF(m_function);
        m_boundedInstance = copy.m_boundedInstance;
        Py_XINCREF(m_boundedInstance);
    }
    
    ~PythonQtSignalTarget()
    {
        Py_XDECREF(m_boundedInstance);
        Py_XDECREF(m_function);
        m_argTypeList.clear();
    }

    inline int signalId() const { return m_signalId; }

    inline int slotId()  const { return m_slotId; }

    // call the python callable with the given arguments (docs see source file)
    void call(void ** arguments) const;

    inline IntList argTypeList() const { return m_argTypeList; };


    bool isSame(int signalId, PyObject* callable) const 
    { 
        if(signalId == m_signalId)
        {
            if(PyMethod_Check(callable))
            {
                return PyMethod_Self(callable) == PyWeakref_GetObject(m_boundedInstance) && PyMethod_Function(callable) == PyWeakref_GetObject(m_function);
            }
            return callable == PyWeakref_GetObject(m_function);
        }
        return false;
    }

private:
    int m_slotId;                
    int m_signalId;                
    IntList m_argTypeList;        
    PyObject *m_function;        
    PyObject *m_boundedInstance; 
    bool m_boundedMethod;        
    QString m_signalName;        
};

class PythonQtSignalMapperBase : public QObject 
{
    Q_OBJECT
public:
    PythonQtSignalMapperBase() {}; 
};


class PythonQtSignalMapper : public PythonQtSignalMapperBase
{

public:
    PythonQtSignalMapper(unsigned int initSlotCount); 
    ~PythonQtSignalMapper();

    bool addSignalHandler(QObject *obj, const char* signal, int sigId, PyObject* callable, IntList &argTypeList);
    bool removeSignalHandler(QObject *obj, const char* signal, int sigId, PyObject* callable);
    void removeSignalHandlers();
    virtual int qt_metacall(QMetaObject::Call c, int id, void **arguments);
   
private:
    QList<PythonQtSignalTarget> m_targets;    
    int m_slotCount;                        
};

} //end namespace ito

#endif