Russian Qt Forum

class С1
{
signals:
    void A();
    void B();
};

class С2
{
public slots:
    void A(int param = 0);
    void B(int param = 0);
};

....

connect(c1, SIGNAL(A()), c2, SLOT(A()));
connect(c1, SIGNAL(B()), c2, SLOT(B()));

signalId = THIS_SIGNAL_ID;
emit thisSignal(); 

Mapper::onSignal() 
{
  Emitter* e = qobject_cast<Emitter*> sender();
  if (e) {
    int id = e->getSignalId();
    // emit blabla(id);
   // c2->slot(id);
   // invoke...... etc  
 }
}

class C2:
  def connect2C1(self, c1):
    def gen_wrap(i):
       return lambda: self.slot(i)
    for i, signal in enumerate(('S1', 'S2', ... , 'Sn')):
       self.connect(c1, QtCore.SIGNAL(signal), gen_wrap(i))

void setStateByEvent(int event) {
     setState(m_States[event]);
}

class С2
{
public slots:
    void A(int param = 0);
    void B(int param = 0);
    void Common(int);
};

void C2::Common(int why)
{
switch(why)
 case valueA : A();break;
 case valueB : B();break;
default : errorHandler(why);
}

class С2
{
public slots:
    void A(int param = 0);
    void B(int param = 0);
    void Common(int);
};

void C2::Common(int why)
{
switch(why)
 case valueA : A();break;
 case valueB : B();break;
default : errorHandler(why);
}

#ifndef SIGNAL_WATCHER
#define SIGNAL_WATCHER

#include <QObject>

class SignalWatcher : public QObject
{
	Q_OBJECT
public:
	SignalWatcher( QObject* obj );	
private slots:
	void dummy();	
signals:	
	void emitted(int);
private:
	bool event( QEvent* e );	
	QObject* wObj;	
};

#endif // SIGNAL_WATCHER

#include "sigwatcher.h"
#include <QEvent>
#include <QMetaMethod>

#include <qobject_p.h> // hmmm... you can find it in $QTDIR/src/corelib/kernel

SignalWatcher::SignalWatcher( QObject* obj )
			: QObject(obj), wObj(obj)
{
	const QMetaObject* mo = wObj->metaObject();
	int n = mo->methodCount();
	for ( int i = 0; i < n; i++ ) {
		QMetaMethod meth = mo->method(i);
		if ( meth.methodType() == QMetaMethod::Signal ) {
		    QByteArray sign = "0";
		    sign[0] = sign[0] + QSIGNAL_CODE;
		    sign += meth.signature();
		    connect( wObj, sign, this, SLOT(dummy()), Qt::QueuedConnection );
		}
	}
}

bool SignalWatcher::event( QEvent* e )
{
	if ( e->type() == QEvent::MetaCall ) {
		QMetaCallEvent* me = (QMetaCallEvent*) e;
		int sigId = me->signalIdStart();		
		emit emitted(sigId);
	//debug
		const QMetaObject* mo = wObj->metaObject();
		QMetaMethod meth = mo->method(sigId);
		qDebug("Signal %s emitted", meth.signature() );
	//-----	
		return true;
	}
	return false;
}

void SignalWatcher::dummy()
{
}

class SignalMapper : public QObject {
	Q_OBJECT
public:
	SignalMapper(QObject *parent = 0):QObject(parent) {}

	void setMapping(QObject *object, const char *signal, int id);

signals:
	void mapped(int id);

private:
	QSignalMapper* freeMapper(QObject *object);

	QMultiMap<QObject*, QSignalMapper*> m_SignalMappers;
};

void SignalMapper::setMapping(QObject *object, const char *signal, int id) {
	QSignalMapper *mapper = freeMapper(object);
	connect(object, signal, mapper, SLOT(map()));
	mapper->setMapping(object, id);
}
QSignalMapper* SignalMapper::freeMapper(QObject *object) {
	
	QList<QSignalMapper*> mappers = m_SignalMappers.values();
	for (int i=0; i<mappers.size(); i++) {
		if (!m_SignalMappers.keys(mappers[i]).contains(object)) {
			m_SignalMappers.insert(object, mappers[i]);
			return mappers[i]; 
		}
	}
	
	QSignalMapper *mapper = new QSignalMapper(this);
	m_SignalMappers.insert(object, mapper);
	
	connect(mapper, SIGNAL(mapped(int)), SIGNAL(mapped(int)));
	
	return mapper;
}