jyapayne/PySide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

pysidesignal: trivial fixes

Browse source 
Fix typos and coding style

Signed-off-by: Paulo Alcantara <pcacjr@gmail.com>
Reviewed-by: Luciano Wolf <luciano.wolf@openbossa.org>
Reviewed-by: Hugo Parente Lima <hugo.pl@gmail.com>
This commit is contained in:
Paulo Alcantara 2011-12-08 17:41:27 +00:00 • committed by Hugo Parente Lima
commit 66f4ccbe5d
1 changed files with 61 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

120
libpyside/pysidesignal.cpp
View file

@ -19,6 +19,7 @@
* License along with this library; if not, write to the Free Software * License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include <sbkpython.h> #include <sbkpython.h>
#include "pysidesignal.h" #include "pysidesignal.h"
#include "pysidesignal_p.h" #include "pysidesignal_p.h"
@ -31,12 +32,12 @@
#define SIGNAL_INSTANCE_NAME "SignalInstance" #define SIGNAL_INSTANCE_NAME "SignalInstance"
#define QT_SIGNAL_SENTINEL '2' #define QT_SIGNAL_SENTINEL '2'
namespace PySide {
namespace PySide { namespace Signal { namespace Signal {
//aux //aux
static char* buildSignature(const char*, const char*); static char* buildSignature(const char*, const char*);
static void appendSignature(PySideSignal*, char*); static void appendSignature(PySideSignal*, char*);
static void instanceInitialize(PySideSignalInstance*, PyObject*, PySideSignal*, PyObject *, int); static void instanceInitialize(PySideSignalInstance*, PyObject*, PySideSignal*, PyObject*, int);
static char* parseSignature(PyObject*); static char* parseSignature(PyObject*);
static PyObject* buildQtCompatible(const char*); static PyObject* buildQtCompatible(const char*);
} }
@ -45,14 +46,14 @@ namespace PySide { namespace Signal {
extern "C" extern "C"
{ {
//Signal methods // Signal methods
static int signalTpInit(PyObject*, PyObject*, PyObject*); static int signalTpInit(PyObject*, PyObject*, PyObject*);
static void signalFree(void*); static void signalFree(void*);
static void signalInstanceFree(void*); static void signalInstanceFree(void*);
static PyObject* signalGetItem(PyObject* self, PyObject* key); static PyObject* signalGetItem(PyObject* self, PyObject* key);
static PyObject* signalToString(PyObject* self); static PyObject* signalToString(PyObject* self);
//Signal Instance methods // Signal Instance methods
static PyObject* signalInstanceConnect(PyObject*, PyObject*, PyObject*); static PyObject* signalInstanceConnect(PyObject*, PyObject*, PyObject*);
static PyObject* signalInstanceDisconnect(PyObject*, PyObject*); static PyObject* signalInstanceDisconnect(PyObject*, PyObject*);
static PyObject* signalInstanceEmit(PyObject*, PyObject*); static PyObject* signalInstanceEmit(PyObject*, PyObject*);
@ -221,8 +222,8 @@ PyTypeObject PySideSignalInstanceType = {
int signalTpInit(PyObject* self, PyObject* args, PyObject* kwds) int signalTpInit(PyObject* self, PyObject* args, PyObject* kwds)
{ {
static PyObject *emptyTuple = 0; static PyObject* emptyTuple = 0;
static const char *kwlist[] = {"name", 0}; static const char* kwlist[] = {"name", 0};
char* argName = 0; char* argName = 0;
if (emptyTuple == 0) if (emptyTuple == 0)
@ -233,13 +234,13 @@ int signalTpInit(PyObject* self, PyObject* args, PyObject* kwds)
return 0; return 0;
bool tupledArgs = false; bool tupledArgs = false;
PySideSignal *data = reinterpret_cast<PySideSignal*>(self); PySideSignal* data = reinterpret_cast<PySideSignal*>(self);
if (argName) { if (argName) {
data->signalName = strdup(argName); data->signalName = strdup(argName);
} }
for(Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) { for (Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) {
PyObject *arg = PyTuple_GET_ITEM(args, i); PyObject* arg = PyTuple_GET_ITEM(args, i);
if (PySequence_Check(arg) && !Shiboken::String::check(arg)) { if (PySequence_Check(arg) && !Shiboken::String::check(arg)) {
tupledArgs = true; tupledArgs = true;
PySide::Signal::appendSignature(data, PySide::Signal::parseSignature(arg)); PySide::Signal::appendSignature(data, PySide::Signal::parseSignature(arg));
@ -252,12 +253,12 @@ int signalTpInit(PyObject* self, PyObject* args, PyObject* kwds)
return 1; return 1;
} }
void signalFree(void *self) void signalFree(void* self)
{ {
PyObject *pySelf = reinterpret_cast<PyObject*>(self); PyObject* pySelf = reinterpret_cast<PyObject*>(self);
PySideSignal *data = reinterpret_cast<PySideSignal*>(self); PySideSignal* data = reinterpret_cast<PySideSignal*>(self);
for(int i = 0, i_max = data->signaturesSize; i < i_max; i++) { for (int i = 0, i_max = data->signaturesSize; i < i_max; i++) {
if (data->signatures[i]) if (data->signatures[i])
free(data->signatures[i]); free(data->signatures[i]);
} }
@ -319,26 +320,26 @@ void signalInstanceFree(void* self)
PyObject* signalInstanceConnect(PyObject* self, PyObject* args, PyObject* kwds) PyObject* signalInstanceConnect(PyObject* self, PyObject* args, PyObject* kwds)
{ {
PyObject *slot = 0; PyObject* slot = 0;
PyObject *type = 0; PyObject* type = 0;
static const char *kwlist[] = {"slot", "type", 0}; static const char* kwlist[] = {"slot", "type", 0};
if (!PyArg_ParseTupleAndKeywords(args, kwds, if (!PyArg_ParseTupleAndKeywords(args, kwds,
"O|O:"SIGNAL_INSTANCE_NAME, (char**) kwlist, &slot, &type)) "O|O:"SIGNAL_INSTANCE_NAME, (char**) kwlist, &slot, &type))
return 0; return 0;
PySideSignalInstance *source = reinterpret_cast<PySideSignalInstance*>(self); PySideSignalInstance* source = reinterpret_cast<PySideSignalInstance*>(self);
Shiboken::AutoDecRef pyArgs(PyList_New(0)); Shiboken::AutoDecRef pyArgs(PyList_New(0));
bool match = false; bool match = false;
if (slot->ob_type == &PySideSignalInstanceType) { if (slot->ob_type == &PySideSignalInstanceType) {
PySideSignalInstance *sourceWalk = source; PySideSignalInstance* sourceWalk = source;
PySideSignalInstance *targetWalk; PySideSignalInstance* targetWalk;
//find best match //find best match
while(sourceWalk && !match) { while (sourceWalk && !match) {
targetWalk = reinterpret_cast<PySideSignalInstance*>(slot); targetWalk = reinterpret_cast<PySideSignalInstance*>(slot);
while(targetWalk && !match) { while (targetWalk && !match) {
if (QMetaObject::checkConnectArgs(sourceWalk->d->signature, targetWalk->d->signature)) { if (QMetaObject::checkConnectArgs(sourceWalk->d->signature, targetWalk->d->signature)) {
PyList_Append(pyArgs, sourceWalk->d->source); PyList_Append(pyArgs, sourceWalk->d->source);
Shiboken::AutoDecRef sourceSignature(PySide::Signal::buildQtCompatible(sourceWalk->d->signature)); Shiboken::AutoDecRef sourceSignature(PySide::Signal::buildQtCompatible(sourceWalk->d->signature));
@ -377,19 +378,19 @@ PyObject* signalInstanceConnect(PyObject* self, PyObject* args, PyObject* kwds)
Py_XDECREF(result); Py_XDECREF(result);
} }
if (!PyErr_Occurred()) if (!PyErr_Occurred())
PyErr_Format(PyExc_RuntimeError, "Fail to connect signal %s.", source->d->signature); PyErr_Format(PyExc_RuntimeError, "Failed to connect signal %s.", source->d->signature);
return 0; return 0;
} }
PyObject* signalInstanceEmit(PyObject* self, PyObject* args) PyObject* signalInstanceEmit(PyObject* self, PyObject* args)
{ {
PySideSignalInstance *source = reinterpret_cast<PySideSignalInstance*>(self); PySideSignalInstance* source = reinterpret_cast<PySideSignalInstance*>(self);
Shiboken::AutoDecRef pyArgs(PyList_New(0)); Shiboken::AutoDecRef pyArgs(PyList_New(0));
Shiboken::AutoDecRef sourceSignature(PySide::Signal::buildQtCompatible(source->d->signature)); Shiboken::AutoDecRef sourceSignature(PySide::Signal::buildQtCompatible(source->d->signature));
PyList_Append(pyArgs, sourceSignature); PyList_Append(pyArgs, sourceSignature);
for(Py_ssize_t i = 0, max = PyTuple_Size(args); i < max; i++) for (Py_ssize_t i = 0, max = PyTuple_Size(args); i < max; i++)
PyList_Append(pyArgs, PyTuple_GetItem(args, i)); PyList_Append(pyArgs, PyTuple_GetItem(args, i));
Shiboken::AutoDecRef pyMethod(PyObject_GetAttrString(source->d->source, "emit")); Shiboken::AutoDecRef pyMethod(PyObject_GetAttrString(source->d->source, "emit"));
@ -406,15 +407,16 @@ PyObject* signalInstanceGetItem(PyObject* self, PyObject* key)
free(sigKey); free(sigKey);
const char* sigName = data->d->signalName; const char* sigName = data->d->signalName;
while(data) { while (data) {
if (strcmp(data->d->signature, sig) == 0) { if (strcmp(data->d->signature, sig) == 0) {
free(sig); free(sig);
PyObject *result = reinterpret_cast<PyObject*>(data); PyObject* result = reinterpret_cast<PyObject*>(data);
Py_INCREF(result); Py_INCREF(result);
return result; return result;
} }
data = reinterpret_cast<PySideSignalInstance*>(data->d->next); data = reinterpret_cast<PySideSignalInstance*>(data->d->next);
} }
PyErr_Format(PyExc_IndexError, "Signature %s not found for signal: %s", sig, sigName); PyErr_Format(PyExc_IndexError, "Signature %s not found for signal: %s", sig, sigName);
free(sig); free(sig);
return 0; return 0;
@ -433,7 +435,7 @@ PyObject* signalInstanceDisconnect(PyObject* self, PyObject* args)
bool match = false; bool match = false;
if (slot->ob_type == &PySideSignalInstanceType) { if (slot->ob_type == &PySideSignalInstanceType) {
PySideSignalInstance *target = reinterpret_cast<PySideSignalInstance*>(slot); PySideSignalInstance* target = reinterpret_cast<PySideSignalInstance*>(slot);
if (QMetaObject::checkConnectArgs(source->d->signature, target->d->signature)) { if (QMetaObject::checkConnectArgs(source->d->signature, target->d->signature)) {
PyList_Append(pyArgs, source->d->source); PyList_Append(pyArgs, source->d->source);
Shiboken::AutoDecRef source_signature(PySide::Signal::buildQtCompatible(source->d->signature)); Shiboken::AutoDecRef source_signature(PySide::Signal::buildQtCompatible(source->d->signature));
@ -467,7 +469,7 @@ PyObject* signalInstanceDisconnect(PyObject* self, PyObject* args)
Py_DECREF(result); Py_DECREF(result);
} }
PyErr_Format(PyExc_RuntimeError, "Fail to disconnect signal %s.", source->d->signature); PyErr_Format(PyExc_RuntimeError, "Failed to disconnect signal %s.", source->d->signature);
return 0; return 0;
} }
@ -503,7 +505,6 @@ PyObject* signalInstanceCall(PyObject* self, PyObject* args, PyObject* kw)
return PyCFunction_Call(homonymousMethod, args, kw); return PyCFunction_Call(homonymousMethod, args, kw);
} }
static PyObject* metaSignalCheck(PyObject* klass, PyObject* args) static PyObject* metaSignalCheck(PyObject* klass, PyObject* args)
{ {
if (PyType_IsSubtype(args->ob_type, &PySideSignalInstanceType)) if (PyType_IsSubtype(args->ob_type, &PySideSignalInstanceType))
@ -514,7 +515,8 @@ static PyObject* metaSignalCheck(PyObject* klass, PyObject* args)
} // extern "C" } // extern "C"
namespace PySide { namespace Signal { namespace PySide {
namespace Signal {
void init(PyObject* module) void init(PyObject* module)
{ {
@ -542,7 +544,7 @@ bool checkType(PyObject* pyObj)
void updateSourceObject(PyObject* source) void updateSourceObject(PyObject* source)
{ {
PyTypeObject * objType = reinterpret_cast<PyTypeObject *>(PyObject_Type(source)); PyTypeObject* objType = reinterpret_cast<PyTypeObject*>(PyObject_Type(source));
Py_ssize_t pos = 0; Py_ssize_t pos = 0;
PyObject* value; PyObject* value;
@ -562,13 +564,13 @@ void updateSourceObject(PyObject* source)
char* getTypeName(PyObject* type) char* getTypeName(PyObject* type)
{ {
if (PyType_Check(type)) { if (PyType_Check(type)) {
char *typeName = NULL; char* typeName = NULL;
if (PyType_IsSubtype(reinterpret_cast<PyTypeObject*>(type), reinterpret_cast<PyTypeObject*>(&SbkObject_Type))) { if (PyType_IsSubtype(reinterpret_cast<PyTypeObject*>(type), reinterpret_cast<PyTypeObject*>(&SbkObject_Type))) {
SbkObjectType* objType = reinterpret_cast<SbkObjectType*>(type); SbkObjectType* objType = reinterpret_cast<SbkObjectType*>(type);
typeName = strdup(Shiboken::ObjectType::getOriginalName(objType)); typeName = strdup(Shiboken::ObjectType::getOriginalName(objType));
} else { } else {
// Translate python types to Qt names // Translate python types to Qt names
PyTypeObject *objType = reinterpret_cast<PyTypeObject*>(type); PyTypeObject* objType = reinterpret_cast<PyTypeObject*>(type);
if (Shiboken::String::checkType(objType)) if (Shiboken::String::checkType(objType))
typeName = strdup("QString"); typeName = strdup("QString");
else if (objType == &PyInt_Type) else if (objType == &PyInt_Type)
@ -593,7 +595,7 @@ char* getTypeName(PyObject* type)
return 0; return 0;
} }
char* buildSignature(const char *name, const char *signature) char* buildSignature(const char* name, const char* signature)
{ {
QByteArray signal(name); QByteArray signal(name);
signal += '('; signal += '(';
@ -602,13 +604,13 @@ char* buildSignature(const char *name, const char *signature)
return strdup(QMetaObject::normalizedSignature(signal)); return strdup(QMetaObject::normalizedSignature(signal));
} }
char* parseSignature(PyObject *args) char* parseSignature(PyObject* args)
{ {
char *signature = 0; char* signature = 0;
if (args && (Shiboken::String::check(args) || !PySequence_Check(args))) if (args && (Shiboken::String::check(args) || !PySequence_Check(args)))
return getTypeName(args); return getTypeName(args);
for(Py_ssize_t i = 0, i_max = PySequence_Size(args); i < i_max; i++) { for (Py_ssize_t i = 0, i_max = PySequence_Size(args); i < i_max; i++) {
Shiboken::AutoDecRef arg(PySequence_ITEM(args, i)); Shiboken::AutoDecRef arg(PySequence_ITEM(args, i));
char* typeName = getTypeName(arg); char* typeName = getTypeName(arg);
if (typeName) { if (typeName) {
@ -630,14 +632,14 @@ void appendSignature(PySideSignal* self, char* signature)
self->signaturesSize++; self->signaturesSize++;
if (self->signaturesSize > 1) { if (self->signaturesSize > 1) {
self->signatures = (char**) realloc(self->signatures, sizeof(char**) * self->signaturesSize); self->signatures = (char**)realloc(self->signatures, sizeof(char**) * self->signaturesSize);
} else { } else {
self->signatures = (char**) malloc(sizeof(char**)); self->signatures = (char**)malloc(sizeof(char**));
} }
self->signatures[self->signaturesSize-1] = signature; self->signatures[self->signaturesSize - 1] = signature;
} }
PySideSignalInstance* initialize(PySideSignal* self, PyObject* name, PyObject *object) PySideSignalInstance* initialize(PySideSignal* self, PyObject* name, PyObject* object)
{ {
PySideSignalInstance* instance = PyObject_New(PySideSignalInstance, &PySideSignalInstanceType); PySideSignalInstance* instance = PyObject_New(PySideSignalInstance, &PySideSignalInstanceType);
instanceInitialize(instance, name, self, object, 0); instanceInitialize(instance, name, self, object, 0);
@ -681,7 +683,7 @@ bool connect(PyObject* source, const char* signal, PyObject* callback)
Shiboken::AutoDecRef pyArgs(PyTuple_Pack(3, source, pySignature.object(), callback)); Shiboken::AutoDecRef pyArgs(PyTuple_Pack(3, source, pySignature.object(), callback));
PyObject* result = PyObject_CallObject(pyMethod, pyArgs); PyObject* result = PyObject_CallObject(pyMethod, pyArgs);
if (result == Py_False) { if (result == Py_False) {
PyErr_Format(PyExc_RuntimeError, "Fail to connect signal %s, to python callable object.", signal); PyErr_Format(PyExc_RuntimeError, "Failed to connect signal %s, to python callable object.", signal);
Py_DECREF(result); Py_DECREF(result);
result = 0; result = 0;
} }
@ -690,10 +692,10 @@ bool connect(PyObject* source, const char* signal, PyObject* callback)
PySideSignalInstance* newObjectFromMethod(PyObject* source, const QList<QMetaMethod>& methodList) PySideSignalInstance* newObjectFromMethod(PyObject* source, const QList<QMetaMethod>& methodList)
{ {
PySideSignalInstance *root = 0; PySideSignalInstance* root = 0;
PySideSignalInstance *previous = 0; PySideSignalInstance* previous = 0;
foreach(QMetaMethod m, methodList) { foreach(QMetaMethod m, methodList) {
PySideSignalInstance *item = PyObject_New(PySideSignalInstance, &PySideSignalInstanceType); PySideSignalInstance* item = PyObject_New(PySideSignalInstance, &PySideSignalInstanceType);
if (!root) if (!root)
root = item; root = item;
@ -728,7 +730,7 @@ PySideSignal* newObject(const char* name, ...)
va_start(listSignatures, name); va_start(listSignatures, name);
sig = va_arg(listSignatures, char*); sig = va_arg(listSignatures, char*);
while(sig != NULL) { while (sig != NULL) {
if (strcmp(sig, "void") == 0) if (strcmp(sig, "void") == 0)
appendSignature(self, strdup("")); appendSignature(self, strdup(""));
else else
@ -783,7 +785,7 @@ void registerSignals(SbkObjectType* pyObj, const QMetaObject* metaObject)
{ {
typedef QHash<QByteArray, QList<QByteArray> > SignalSigMap; typedef QHash<QByteArray, QList<QByteArray> > SignalSigMap;
SignalSigMap signalsFound; SignalSigMap signalsFound;
for(int i = metaObject->methodOffset(), max = metaObject->methodCount(); i < max; ++i) { for (int i = metaObject->methodOffset(), max = metaObject->methodCount(); i < max; ++i) {
QMetaMethod method = metaObject->method(i); QMetaMethod method = metaObject->method(i);
if (method.methodType() == QMetaMethod::Signal) { if (method.methodType() == QMetaMethod::Signal) {
@ -809,12 +811,12 @@ void registerSignals(SbkObjectType* pyObj, const QMetaObject* metaObject)
SignalSigMap::mapped_type::const_iterator endJ = it.value().end(); SignalSigMap::mapped_type::const_iterator endJ = it.value().end();
for (; j != endJ; ++j) for (; j != endJ; ++j)
appendSignature(self, strdup(j->constData())); appendSignature(self, strdup(j->constData()));
_addSignalToWrapper(pyObj, it.key(), self); _addSignalToWrapper(pyObj, it.key(), self);
Py_DECREF((PyObject*) self); Py_DECREF((PyObject*) self);
} }
} }
PyObject* buildQtCompatible(const char* signature) PyObject* buildQtCompatible(const char* signature)
{ {
QByteArray ba; QByteArray ba;
@ -838,10 +840,9 @@ const char* getSignature(PySideSignalInstance* signal)
return signal->d->signature; return signal->d->signature;
} }
const char** getSignatures(PyObject* signal, int* size)
const char** getSignatures(PyObject* signal, int *size)
{ {
PySideSignal *self = reinterpret_cast<PySideSignal*>(signal); PySideSignal* self = reinterpret_cast<PySideSignal*>(signal);
*size = self->signaturesSize; *size = self->signaturesSize;
return (const char**) self->signatures; return (const char**) self->signatures;
} }
@ -888,10 +889,10 @@ QString getCallbackSignature(const char* signal, QObject* receiver, PyObject* ca
if (receiver) { if (receiver) {
//Search for signature on metaobject //Search for signature on metaobject
const QMetaObject *mo = receiver->metaObject(); const QMetaObject* mo = receiver->metaObject();
QByteArray prefix(functionName); QByteArray prefix(functionName);
prefix += '('; prefix += '(';
for(int i=0; i < mo->methodCount(); i++) { for (int i = 0; i < mo->methodCount(); i++) {
QMetaMethod me = mo->method(i); QMetaMethod me = mo->method(i);
if ((strncmp(me.signature(), prefix, prefix.size()) == 0) && if ((strncmp(me.signature(), prefix, prefix.size()) == 0) &&
QMetaObject::checkConnectArgs(signal, me.signature())) { QMetaObject::checkConnectArgs(signal, me.signature())) {
@ -908,7 +909,7 @@ QString getCallbackSignature(const char* signal, QObject* receiver, PyObject* ca
numArgs = 0; numArgs = 0;
} }
} else if (PyCallable_Check(callback)) { } else if (PyCallable_Check(callback)) {
functionName = "__callback"+QByteArray::number((qlonglong)callback); functionName = "__callback" + QByteArray::number((qlonglong)callback);
} }
Q_ASSERT(!functionName.isEmpty()); Q_ASSERT(!functionName.isEmpty());
@ -949,14 +950,15 @@ bool checkQtSignal(const char* signal)
return true; return true;
} }
QString codeCallbackName(PyObject* callback, const QString& funcName) QString codeCallbackName(PyObject* callback, const QString& funcName)
{ {
if (PyMethod_Check(callback)) { if (PyMethod_Check(callback)) {
PyObject *self = PyMethod_GET_SELF(callback); PyObject* self = PyMethod_GET_SELF(callback);
PyObject *func = PyMethod_GET_FUNCTION(callback); PyObject* func = PyMethod_GET_FUNCTION(callback);
return funcName + QString::number(quint64(self), 16) + QString::number(quint64(func), 16); return funcName + QString::number(quint64(self), 16) + QString::number(quint64(func), 16);
} else } else {
return funcName + QString::number(quint64(callback), 16); return funcName + QString::number(quint64(callback), 16);
}
} }
} //namespace Signal } //namespace Signal