GIT_REPOSITORIES/LPP/PythonQt Commit - r160:7b78560a4b52

fixed isSame to use python comparison...

florianlink -

r160:7b78560a4b52

parent child

Context file:

r160:7b78560a4b52

Collapse all files

src/PythonQtSignalReceiver.cpp +5 0

             /*
              *
              *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library 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
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtSignalReceiver.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtSignalReceiver.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQtConversion.h"
             #include <QMetaObject>
             #include <QMetaMethod>
             #include "funcobject.h"
             void PythonQtSignalTarget::call(void **arguments) const {
               PyObject* result = call(_callable, methodInfo(), arguments);
               if (result) {
                 Py_DECREF(result);
               }
             }
             PyObject* PythonQtSignalTarget::call(PyObject* callable, const PythonQtMethodInfo* methodInfos, void **arguments, bool skipFirstArgumentOfMethodInfo)
             {
               Q_UNUSED(skipFirstArgumentOfMethodInfo)
               // Note: we check if the callable is a PyFunctionObject and has a fixed number of arguments
               // if that is the case, we only pass these arguments to python and skip the additional arguments from the signal
               int numPythonArgs = -1;
               if (PyFunction_Check(callable)) {
                 PyObject* o = callable;
                 PyFunctionObject* func = (PyFunctionObject*)o;
                 PyCodeObject* code = (PyCodeObject*)func->func_code;
                 if (!(code->co_flags & 0x04)) {
                   numPythonArgs = code->co_argcount;
                 } else {
                   // variable numbers of arguments allowed
                 }
               } else if (PyMethod_Check(callable)) {
                 PyObject* o = callable;
                 PyMethodObject* method = (PyMethodObject*)o;
                 if (PyFunction_Check(method->im_func)) {
                   PyFunctionObject* func = (PyFunctionObject*)method->im_func;
                   PyCodeObject* code = (PyCodeObject*)func->func_code;
                   if (!(code->co_flags & 0x04)) {
                     numPythonArgs = code->co_argcount - 1; // we subtract one because the first is "self"
                   } else {
                     // variable numbers of arguments allowed
                   }
                 }
               }
               const PythonQtMethodInfo* m = methodInfos;
               // parameterCount includes return value:
               int count = m->parameterCount();
               if (numPythonArgs!=-1) {
                 if (count>numPythonArgs+1) {
                   // take less arguments
                   count = numPythonArgs+1;
                 }
               }
               PyObject* pargs = NULL;
               if (count>1) {
                 pargs = PyTuple_New(count-1);
               }
               bool err = false;
               // transform Qt values to Python
               const QList<PythonQtMethodInfo::ParameterInfo>& params = m->parameters();
               for (int i = 1; i < count; i++) {
                 const PythonQtMethodInfo::ParameterInfo& param = params.at(i);
                 PyObject* arg = PythonQtConv::ConvertQtValueToPython(param, arguments[i]);
                 if (arg) {
                   // steals reference, no unref
                   PyTuple_SetItem(pargs, i-1,arg);
                 } else {
                   err = true;
                   break;
                 }
               }
               PyObject* result = NULL;
               if (!err) {
                 PyErr_Clear();
                 result = PyObject_CallObject(callable, pargs);
                 if (result) {
                   // ok
                 } else {
                   PythonQt::self()->handleError();
                 }
               }
               if (pargs) {
                 // free the arguments again
                 Py_DECREF(pargs);
               }
               return result;
             }
+            bool PythonQtSignalTarget::isSame( int signalId, PyObject* callable ) const
+            {
+              return PyObject_Compare(callable, _callable) == 0 && signalId==_signalId;
+            }
             //------------------------------------------------------------------------------
             PythonQtSignalReceiver::PythonQtSignalReceiver(QObject* obj):PythonQtSignalReceiverBase(obj)
             {
               _obj = obj;
               // fetch the class info for object, since we will need to for correct enum resolution in
               // signals
               _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
               if (!_objClassInfo || !_objClassInfo->isQObject()) {
                 PythonQt::self()->registerClass(obj->metaObject());
                 _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
               }
               // force decorator/enum creation
               _objClassInfo->decorator();
               _slotCount = staticMetaObject.methodOffset();
             }
             PythonQtSignalReceiver::~PythonQtSignalReceiver()
             {
               PythonQt::priv()->removeSignalEmitter(_obj);
             }
             bool PythonQtSignalReceiver::addSignalHandler(const char* signal, PyObject* callable)
             {
               bool flag = false;
               int sigId = getSignalIndex(signal);
               if (sigId>=0) {
                 // create PythonQtMethodInfo from signal
                 QMetaMethod meta = _obj->metaObject()->method(sigId);
                 const PythonQtMethodInfo* signalInfo = PythonQtMethodInfo::getCachedMethodInfo(meta, _objClassInfo);
                 PythonQtSignalTarget t(sigId, signalInfo, _slotCount, callable);
                 _targets.append(t);
                 // now connect to ourselves with the new slot id
                 QMetaObject::connect(_obj, sigId, this, _slotCount, Qt::AutoConnection, 0);
                 _slotCount++;
                 flag = true;
               }
               return flag;
             }
             bool PythonQtSignalReceiver::removeSignalHandler(const char* signal, PyObject* callable)
             {
               bool found = false;
               int sigId = getSignalIndex(signal);
               if (sigId>=0) {
                 QMutableListIterator<PythonQtSignalTarget> i(_targets);
                 while (i.hasNext()) {
                   if (i.next().isSame(sigId, callable)) {
                     i.remove();
                     found = true;
                     break;
                   }
                 }
               }
               return found;
             }
             void PythonQtSignalReceiver::removeSignalHandlers()
             {
               _targets.clear();
             }
             int PythonQtSignalReceiver::getSignalIndex(const char* signal)
             {
               int sigId = _obj->metaObject()->indexOfSignal(signal+1);
               if (sigId<0) {
                 QByteArray tmpSig = QMetaObject::normalizedSignature(signal+1);
                 sigId = _obj->metaObject()->indexOfSignal(tmpSig);
               }
               return sigId;
             }
             int PythonQtSignalReceiver::qt_metacall(QMetaObject::Call c, int id, void **arguments)
             {
             //  mlabDebugConst("PythonQt", "PythonQtSignalReceiver invoke " << _obj->className() << " " << _obj->name() << " " << id);
               if (c != QMetaObject::InvokeMetaMethod) {
                 QObject::qt_metacall(c, id, arguments);
               }
               bool found = false;
               foreach(const PythonQtSignalTarget& t, _targets) {
                 if (t.slotId() == id) {
                   found = true;
                   t.call(arguments);
                   break;
                 }
               }
               return 0;
             }

src/PythonQtSignalReceiver.h +1 -1

             #ifndef _PYTHONQTSIGNALRECEIVER_H
             #define _PYTHONQTSIGNALRECEIVER_H
             /*
              *
              *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library 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
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtSignalReceiver.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include <Python.h>
             #include "PythonQtSystem.h"
             #include "PythonQtObjectPtr.h"
             class PythonQtMethodInfo;
             class PythonQtClassInfo;
             //! stores information about a signal target
             /*! copy construction and assignment works fine with the C++ standard behavior and are thus not implemented
             */
             class PYTHONQT_EXPORT PythonQtSignalTarget {
             public:
               PythonQtSignalTarget() {
                 _signalId = -1;
                 _methodInfo = NULL;
                 _slotId = -1;
               }
               PythonQtSignalTarget(int signalId,const PythonQtMethodInfo* methodInfo, int slotId, PyObject* callable)
               {
                 _signalId = signalId;
                 _slotId = slotId;
                 _methodInfo = methodInfo;
                 _callable = callable;
               };
               ~PythonQtSignalTarget() {
               };
               //! get the id of the original signal
               int signalId() const { return _signalId; }
               //! get the id that was assigned to this simulated slot
               int slotId()  const { return _slotId; }
               //! get the signals parameter info
               const PythonQtMethodInfo* methodInfo()  const { return _methodInfo; }
               //! call the python callable with the given arguments (as defined in methodInfo)
               void call(void **arguments) const;
               //! check if it is the same signal target
-              bool isSame(int signalId, PyObject* callable) const { return callable==_callable && signalId==_signalId; }
+              bool isSame(int signalId, PyObject* callable) const;
               //! call the given callable with arguments described by PythonQtMethodInfo, returns a new reference as result value (or NULL)
               static PyObject* call(PyObject* callable, const PythonQtMethodInfo* methodInfo, void **arguments, bool skipFirstArgumentOfMethodInfo = false);
             private:
               int       _signalId;
               int       _slotId;
               const PythonQtMethodInfo* _methodInfo;
               PythonQtObjectPtr _callable;
             };
             //! base class for signal receivers
             /*!
             */
             class PythonQtSignalReceiverBase : public QObject {
               Q_OBJECT
             public:
               PythonQtSignalReceiverBase(QObject* obj):QObject(obj) {};
             };
             //! receives all signals for one QObject
             /*! we derive from our base but do not declare the QObject macro because we want to reimplement qt_metacall only.
             */
             class PythonQtSignalReceiver : public PythonQtSignalReceiverBase {
             public:
               PythonQtSignalReceiver(QObject* obj);
               ~PythonQtSignalReceiver();
               //! add a signal handler
               bool addSignalHandler(const char* signal, PyObject* callable);
               //! remove a signal handler
               bool removeSignalHandler(const char* signal, PyObject* callable);
               //! remove all signal handlers
               void removeSignalHandlers();
               //! we implement this method to simulate a number of slots that match the ids in _targets
               virtual int qt_metacall(QMetaObject::Call c, int id, void **arguments);
             private:
               //! get the index of the signal
               int getSignalIndex(const char* signal);
               QObject* _obj;
               PythonQtClassInfo* _objClassInfo;
               int _slotCount;
               // linear list may get slow on multiple targets, but I think typically we have many objects and just a few signals
               QList<PythonQtSignalTarget> _targets;
             };
             #endif

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages