pythonQtSignalMapper.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut für Technische Optik (ITO),
    Universität 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
 
    #include "python/pythonWrapper.h"
#endif
 
#include "../global.h"
 
#include <qvariant.h>
#include <qobject.h>
#include <qelapsedtimer.h>
#include <qhash.h>
 
namespace ito
{
 
class PythonQtSignalTarget
{
public:
 
    PythonQtSignalTarget();
 
    PythonQtSignalTarget(IntList &argTypeList, int slotId, int signalId, PyObject* callable, const char *signal, int minRepeatInterval);
 
    PythonQtSignalTarget(const PythonQtSignalTarget &copy);
 
    ~PythonQtSignalTarget();
 
    PythonQtSignalTarget &operator=(const PythonQtSignalTarget &rhs);
 
    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);
 
    inline IntList argTypeList() const { return m_argTypeList; };
 
    bool isSame(int signalId, PyObject* callable) const;
 
private:
    int m_slotId;                  
    int m_signalId;                
    IntList m_argTypeList;         
 
    enum CallableType
    {
        Callable_Invalid, 
 
        Callable_Method,
 
        Callable_Function,
 
        Callable_CFunction
    };
 
    /* If the target is a bounded method, m_boundedMethod is true and
    this member holds a Python weak reference to the method, that acts as slot.
    m_boundedInstance is != NULL then.
 
    If the target is an unbounded function, m_boundedMethod is false and
    this member holds a new reference to the function itself (that acts as slot).
    m_boundedInstance is NULL then. */
    PyObject *m_function;
    PyObject *m_boundedInstance;   
    CallableType m_callableType;   
    QString m_signalName;          
    QElapsedTimer m_elapsedTimer;  
 
    /*
    if > 0, every call of a certain slot by a certain signal with restart m_elapsedTimer. If the same signal-slot-connection is
    called another time, while less than m_minRepeatInterval ms have expired, this new invoke will be ignored.
 
    This can be used to prevent that very fast signal emissions will overflow the call queue for the connected callable python method.
    */
    int m_minRepeatInterval;
};
 
class PythonQtSignalMapperBase : public QObject
{
    Q_OBJECT
public:
    PythonQtSignalMapperBase() {}; 
};
 
class PythonQtSignalMapper : public PythonQtSignalMapperBase
{
 
public:
    PythonQtSignalMapper();
    ~PythonQtSignalMapper();
 
    bool addSignalHandler(QObject *obj, const char* signal, int sigId, PyObject* callable, IntList &argTypeList, int minRepeatInterval);
    bool removeSignalHandler(QObject *obj, int sigId, PyObject* callable);
    void removeSignalHandlers();
 
    virtual int qt_metacall(QMetaObject::Call c, int id, void **arguments);
 
private:
    typedef QMap<int, PythonQtSignalTarget> TargetMap;
 
    /* This list is generated as map, that maps the slotId of the PythonQtSignalTarget
    to the target itself (for a faster indexing).
    */
    TargetMap m_targets;
 
    int m_slotCount;
 
};
 
} //end namespace ito
 
#endif