KisAcyclicSignalConnector Class Reference

#include <kis_acyclic_signal_connector.h>

Inheritance diagram for KisAcyclicSignalConnector:

Public Types
typedef std::unique_lock< KisAcyclicSignalConnector >	Blocker

Signals
void	backwardSignalBool (bool value)
void	backwardSignalDouble (double value)
void	backwardSignalInt (int value)
void	backwardSignalKoColor (const KoColor &value)
void	backwardSignalResourcePair (int key, const QVariant &value)
void	backwardSignalVariant (const QVariant &value)
void	backwardSignalVoid ()
void	forwardSignalBool (bool value)
void	forwardSignalDouble (double value)
void	forwardSignalInt (int value)
void	forwardSignalKoColor (const KoColor &value)
void	forwardSignalResourcePair (int key, const QVariant &value)
void	forwardSignalVariant (const QVariant &value)
void	forwardSignalVoid ()

Public Member Functions
void	connectBackwardBool (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectBackwardDouble (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectBackwardInt (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectBackwardKoColor (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectBackwardResourcePair (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectBackwardVariant (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectBackwardVoid (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectForwardBool (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectForwardDouble (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectForwardInt (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectForwardKoColor (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectForwardResourcePair (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectForwardVariant (QObject *sender, const char *signal, QObject *receiver, const char *method)
void	connectForwardVoid (QObject *sender, const char *signal, QObject *receiver, const char *method)
KisAcyclicSignalConnector *	createCoordinatedConnector ()
	create a coordinated connector that can be used for extending the number of self-locking connection.
bool	isLocked () const
	KisAcyclicSignalConnector (QObject *parent=0)
void	lock ()
void	unlock ()
	~KisAcyclicSignalConnector ()

Private Slots
void	backwardSlotBool (bool value)
void	backwardSlotDouble (double value)
void	backwardSlotInt (int value)
void	backwardSlotKoColor (const KoColor &value)
void	backwardSlotResourcePair (int key, const QVariant &resource)
void	backwardSlotVariant (const QVariant &value)
void	backwardSlotVoid ()
void	forwardSlotBool (bool value)
void	forwardSlotDouble (double value)
void	forwardSlotInt (int value)
void	forwardSlotKoColor (const KoColor &value)
void	forwardSlotResourcePair (int key, const QVariant &resource)
void	forwardSlotVariant (const QVariant &value)
void	forwardSlotVoid ()

Private Member Functions
void	coordinatedLock ()
void	coordinatedUnlock ()

Private Attributes
QVector< QPointer< KisAcyclicSignalConnector > >	m_coordinatedConnectors
QPointer< KisAcyclicSignalConnector >	m_parentConnector
int	m_signalsBlocked

Detailed Description

A special class for connecting UI elements to manager classes. It allows to avoid direct calling blockSignals() for the sender UI element all the time. This is the most important when the measured value can be changed not only by the user through the UI, but also by the manager according to some internal rules.

Example:

Suppose we have the following connections:

1) QDoubleSpinBox::valueChanged(double) -> Manager::slotSetValue(double) 2) Manager::valueChanged(double) -> QDoubleSpinBox::setValue(double)

Now if the manager decides to change/correct the value, the spinbox will go into an infinite loop.

See an example in KisToolCropConfigWidget.

NOTE (coordinated connectors):

Please make sure that you don't convert more than one forward and one backward connection to the connector! If you do so, they will become connected to the same forwarding slot and, therefore, both output signals will be emitted on every incoming signal.

To connect multiple connections that block recursive calls, please use "coordinated connectors". Each such connector will have two more connection slots that you can reuse.

Definition at line 52 of file kis_acyclic_signal_connector.h.

Member Typedef Documentation

Blocker

typedef std::unique_lock<KisAcyclicSignalConnector> KisAcyclicSignalConnector::Blocker

Definition at line 56 of file kis_acyclic_signal_connector.h.

Constructor & Destructor Documentation

KisAcyclicSignalConnector()

KisAcyclicSignalConnector::KisAcyclicSignalConnector

(

QObject *

parent = 0

)

Definition at line 12 of file kis_acyclic_signal_connector.cpp.

    : QObject(parent),
      m_signalsBlocked(0)
{
}

~KisAcyclicSignalConnector()

KisAcyclicSignalConnector::~KisAcyclicSignalConnector

(

)

Definition at line 18 of file kis_acyclic_signal_connector.cpp.

{
}

Member Function Documentation

backwardSignalBool

void KisAcyclicSignalConnector::backwardSignalBool ( bool value )

signal

backwardSignalDouble

void KisAcyclicSignalConnector::backwardSignalDouble ( double value )

signal

backwardSignalInt

void KisAcyclicSignalConnector::backwardSignalInt ( int value )

signal

backwardSignalKoColor

void KisAcyclicSignalConnector::backwardSignalKoColor ( const KoColor & value )

signal

backwardSignalResourcePair

void KisAcyclicSignalConnector::backwardSignalResourcePair ( int key, const QVariant & value )

signal

backwardSignalVariant

void KisAcyclicSignalConnector::backwardSignalVariant ( const QVariant & value )

signal

backwardSignalVoid

void KisAcyclicSignalConnector::backwardSignalVoid ( )

signal

backwardSlotBool

void KisAcyclicSignalConnector::backwardSlotBool ( bool value )

privateslot

Definition at line 221 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT backwardSignalBool(value);
    unlock();
}

References backwardSignalBool(), lock(), m_signalsBlocked, unlock(), and value().

backwardSlotDouble

void KisAcyclicSignalConnector::backwardSlotDouble ( double value )

privateslot

Definition at line 185 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT backwardSignalDouble(value);
    unlock();
}

References backwardSignalDouble(), lock(), m_signalsBlocked, unlock(), and value().

backwardSlotInt

void KisAcyclicSignalConnector::backwardSlotInt ( int value )

privateslot

Definition at line 203 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT backwardSignalInt(value);
    unlock();
}

References backwardSignalInt(), lock(), m_signalsBlocked, unlock(), and value().

backwardSlotKoColor

void KisAcyclicSignalConnector::backwardSlotKoColor ( const KoColor & value )

privateslot

Definition at line 293 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT backwardSignalKoColor(value);
    unlock();
}

References backwardSignalKoColor(), lock(), m_signalsBlocked, unlock(), and value().

backwardSlotResourcePair

void KisAcyclicSignalConnector::backwardSlotResourcePair ( int key, const QVariant & resource )

privateslot

Definition at line 275 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT backwardSignalResourcePair(key, resource);
    unlock();
}

References backwardSignalResourcePair(), lock(), m_signalsBlocked, and unlock().

backwardSlotVariant

void KisAcyclicSignalConnector::backwardSlotVariant ( const QVariant & value )

privateslot

Definition at line 257 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT backwardSignalVariant(value);
    unlock();
}

References backwardSignalVariant(), lock(), m_signalsBlocked, unlock(), and value().

backwardSlotVoid

void KisAcyclicSignalConnector::backwardSlotVoid ( )

privateslot

Definition at line 239 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT backwardSignalVoid();
    unlock();
}

References backwardSignalVoid(), lock(), m_signalsBlocked, and unlock().

connectBackwardBool()

void KisAcyclicSignalConnector::connectBackwardBool	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 62 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(backwardSlotBool(bool)), Qt::UniqueConnection);
    connect(this, SIGNAL(backwardSignalBool(bool)), receiver, method, Qt::UniqueConnection);
}

References backwardSignalBool(), backwardSlotBool(), and connect().

connectBackwardDouble()

void KisAcyclicSignalConnector::connectBackwardDouble	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 30 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(backwardSlotDouble(double)), Qt::UniqueConnection);
    connect(this, SIGNAL(backwardSignalDouble(double)), receiver, method, Qt::UniqueConnection);
}

References backwardSignalDouble(), backwardSlotDouble(), and connect().

connectBackwardInt()

void KisAcyclicSignalConnector::connectBackwardInt	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 46 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(backwardSlotInt(int)), Qt::UniqueConnection);
    connect(this, SIGNAL(backwardSignalInt(int)), receiver, method, Qt::UniqueConnection);
}

References backwardSignalInt(), backwardSlotInt(), and connect().

connectBackwardKoColor()

void KisAcyclicSignalConnector::connectBackwardKoColor	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 119 of file kis_acyclic_signal_connector.cpp.

{
    connect(sender, signal, this, SLOT(backwardSlotKoColor(KoColor)), Qt::UniqueConnection);
    connect(this, SIGNAL(backwardSignalKoColor(KoColor)), receiver, method, Qt::UniqueConnection);
}

References backwardSignalKoColor(), backwardSlotKoColor(), and connect().

connectBackwardResourcePair()

void KisAcyclicSignalConnector::connectBackwardResourcePair	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 107 of file kis_acyclic_signal_connector.cpp.

{
    connect(sender, signal, this, SLOT(backwardSlotResourcePair(int,QVariant)), Qt::UniqueConnection);
    connect(this, SIGNAL(backwardSignalResourcePair(int,QVariant)), receiver, method, Qt::UniqueConnection);
}

References backwardSignalResourcePair(), backwardSlotResourcePair(), and connect().

connectBackwardVariant()

void KisAcyclicSignalConnector::connectBackwardVariant	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 94 of file kis_acyclic_signal_connector.cpp.

{
    connect(sender, signal, this, SLOT(backwardSlotVariant(QVariant)), Qt::UniqueConnection);
    connect(this, SIGNAL(backwardSignalVariant(QVariant)), receiver, method, Qt::UniqueConnection);
}

References backwardSignalVariant(), backwardSlotVariant(), and connect().

connectBackwardVoid()

void KisAcyclicSignalConnector::connectBackwardVoid	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 78 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(backwardSlotVoid()), Qt::UniqueConnection);
    connect(this, SIGNAL(backwardSignalVoid()), receiver, method, Qt::UniqueConnection);
}

References backwardSignalVoid(), backwardSlotVoid(), and connect().

connectForwardBool()

void KisAcyclicSignalConnector::connectForwardBool	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 54 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(forwardSlotBool(bool)), Qt::UniqueConnection);
    connect(this, SIGNAL(forwardSignalBool(bool)), receiver, method, Qt::UniqueConnection);
}

References connect(), forwardSignalBool(), and forwardSlotBool().

connectForwardDouble()

void KisAcyclicSignalConnector::connectForwardDouble	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 22 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(forwardSlotDouble(double)), Qt::UniqueConnection);
    connect(this, SIGNAL(forwardSignalDouble(double)), receiver, method, Qt::UniqueConnection);
}

References connect(), forwardSignalDouble(), and forwardSlotDouble().

connectForwardInt()

void KisAcyclicSignalConnector::connectForwardInt	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 38 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(forwardSlotInt(int)), Qt::UniqueConnection);
    connect(this, SIGNAL(forwardSignalInt(int)), receiver, method, Qt::UniqueConnection);
}

References connect(), forwardSignalInt(), and forwardSlotInt().

connectForwardKoColor()

void KisAcyclicSignalConnector::connectForwardKoColor	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 113 of file kis_acyclic_signal_connector.cpp.

{
    connect(sender, signal, this, SLOT(forwardSlotKoColor(KoColor)), Qt::UniqueConnection);
    connect(this, SIGNAL(forwardSignalKoColor(KoColor)), receiver, method, Qt::UniqueConnection);
}

References connect(), forwardSignalKoColor(), and forwardSlotKoColor().

connectForwardResourcePair()

void KisAcyclicSignalConnector::connectForwardResourcePair	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 101 of file kis_acyclic_signal_connector.cpp.

{
    connect(sender, signal, this, SLOT(forwardSlotResourcePair(int,QVariant)), Qt::UniqueConnection);
    connect(this, SIGNAL(forwardSignalResourcePair(int,QVariant)), receiver, method, Qt::UniqueConnection);
}

References connect(), forwardSignalResourcePair(), and forwardSlotResourcePair().

connectForwardVariant()

void KisAcyclicSignalConnector::connectForwardVariant	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 86 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(forwardSlotVariant(QVariant)), Qt::UniqueConnection);
    connect(this, SIGNAL(forwardSignalVariant(QVariant)), receiver, method, Qt::UniqueConnection);
}

References connect(), forwardSignalVariant(), and forwardSlotVariant().

connectForwardVoid()

void KisAcyclicSignalConnector::connectForwardVoid	(	QObject *	sender,
		const char *	signal,
		QObject *	receiver,
		const char *	method )

Definition at line 70 of file kis_acyclic_signal_connector.cpp.

{
 
    connect(sender, signal, this, SLOT(forwardSlotVoid()), Qt::UniqueConnection);
    connect(this, SIGNAL(forwardSignalVoid()), receiver, method, Qt::UniqueConnection);
}

References connect(), forwardSignalVoid(), and forwardSlotVoid().

coordinatedLock()

void KisAcyclicSignalConnector::coordinatedLock ( )

private

Lock this connector only.

Definition at line 158 of file kis_acyclic_signal_connector.cpp.

{
    m_signalsBlocked++;
}

References m_signalsBlocked.

coordinatedUnlock()

void KisAcyclicSignalConnector::coordinatedUnlock ( )

private

Unlock this connector only.

Definition at line 163 of file kis_acyclic_signal_connector.cpp.

{
    m_signalsBlocked--;
}

References m_signalsBlocked.

createCoordinatedConnector()

KisAcyclicSignalConnector * KisAcyclicSignalConnector::createCoordinatedConnector

(

)

create a coordinated connector that can be used for extending the number of self-locking connection.

The coordinated connector can be used to extend the number of self-locking connections. Each coordinated connector adds two more connection slots (forward and backward). Lock of any connector in a coordinated group will lock the whole group.

The created connector is owned by *this, don't delete it!

Definition at line 168 of file kis_acyclic_signal_connector.cpp.

{
    KisAcyclicSignalConnector *conn = new KisAcyclicSignalConnector(this);
    conn->m_parentConnector = this;
    m_coordinatedConnectors.append(conn);
    return conn;
}

References KisAcyclicSignalConnector(), m_coordinatedConnectors, and m_parentConnector.

forwardSignalBool

void KisAcyclicSignalConnector::forwardSignalBool ( bool value )

signal

forwardSignalDouble

void KisAcyclicSignalConnector::forwardSignalDouble ( double value )

signal

forwardSignalInt

void KisAcyclicSignalConnector::forwardSignalInt ( int value )

signal

forwardSignalKoColor

void KisAcyclicSignalConnector::forwardSignalKoColor ( const KoColor & value )

signal

forwardSignalResourcePair

void KisAcyclicSignalConnector::forwardSignalResourcePair ( int key, const QVariant & value )

signal

forwardSignalVariant

void KisAcyclicSignalConnector::forwardSignalVariant ( const QVariant & value )

signal

forwardSignalVoid

void KisAcyclicSignalConnector::forwardSignalVoid ( )

signal

forwardSlotBool

void KisAcyclicSignalConnector::forwardSlotBool ( bool value )

privateslot

Definition at line 212 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT forwardSignalBool(value);
    unlock();
}

References forwardSignalBool(), lock(), m_signalsBlocked, unlock(), and value().

forwardSlotDouble

void KisAcyclicSignalConnector::forwardSlotDouble ( double value )

privateslot

Definition at line 176 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT forwardSignalDouble(value);
    unlock();
}

References forwardSignalDouble(), lock(), m_signalsBlocked, unlock(), and value().

forwardSlotInt

void KisAcyclicSignalConnector::forwardSlotInt ( int value )

privateslot

Definition at line 194 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT forwardSignalInt(value);
    unlock();
}

References forwardSignalInt(), lock(), m_signalsBlocked, unlock(), and value().

forwardSlotKoColor

void KisAcyclicSignalConnector::forwardSlotKoColor ( const KoColor & value )

privateslot

Definition at line 284 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT forwardSignalKoColor(value);
    unlock();
}

References forwardSignalKoColor(), lock(), m_signalsBlocked, unlock(), and value().

forwardSlotResourcePair

void KisAcyclicSignalConnector::forwardSlotResourcePair ( int key, const QVariant & resource )

privateslot

Definition at line 266 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT forwardSignalResourcePair(key, resource);
    unlock();
}

References forwardSignalResourcePair(), lock(), m_signalsBlocked, and unlock().

forwardSlotVariant

void KisAcyclicSignalConnector::forwardSlotVariant ( const QVariant & value )

privateslot

Definition at line 248 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT forwardSignalVariant(value);
    unlock();
}

References forwardSignalVariant(), lock(), m_signalsBlocked, unlock(), and value().

forwardSlotVoid

void KisAcyclicSignalConnector::forwardSlotVoid ( )

privateslot

Definition at line 230 of file kis_acyclic_signal_connector.cpp.

{
    if (m_signalsBlocked) return;
 
    lock();
    Q_EMIT forwardSignalVoid();
    unlock();
}

References forwardSignalVoid(), lock(), m_signalsBlocked, and unlock().

isLocked()

bool KisAcyclicSignalConnector::isLocked

(

)

const

Returns

true if the connector is locked by some signal or manually. Used for debugging purposes mostly.

Definition at line 153 of file kis_acyclic_signal_connector.cpp.

{
    return m_signalsBlocked;
}

References m_signalsBlocked.

lock()

void KisAcyclicSignalConnector::lock

(

)

Lock the connector and all its coordinated child connectors

Definition at line 125 of file kis_acyclic_signal_connector.cpp.

{
    if (m_parentConnector) {
        m_parentConnector->lock();
    } else {
        coordinatedLock();
 
        Q_FOREACH(QPointer<KisAcyclicSignalConnector> conn, m_coordinatedConnectors) {
            if (!conn) continue;
            conn->coordinatedLock();
        }
    }
}

References coordinatedLock(), m_coordinatedConnectors, and m_parentConnector.

unlock()

void KisAcyclicSignalConnector::unlock

(

)

Unlock the connector and all its coordinated child connectors

Definition at line 139 of file kis_acyclic_signal_connector.cpp.

{
    if (m_parentConnector) {
        m_parentConnector->unlock();
    } else {
        Q_FOREACH(QPointer<KisAcyclicSignalConnector> conn, m_coordinatedConnectors) {
            if (!conn) continue;
            conn->coordinatedUnlock();
        }
 
        coordinatedUnlock();
    }
}

References coordinatedUnlock(), m_coordinatedConnectors, and m_parentConnector.

Member Data Documentation

m_coordinatedConnectors

QVector<QPointer<KisAcyclicSignalConnector> > KisAcyclicSignalConnector::m_coordinatedConnectors

private

Definition at line 192 of file kis_acyclic_signal_connector.h.

m_parentConnector

QPointer<KisAcyclicSignalConnector> KisAcyclicSignalConnector::m_parentConnector

private

Definition at line 193 of file kis_acyclic_signal_connector.h.

m_signalsBlocked

int KisAcyclicSignalConnector::m_signalsBlocked

private

Definition at line 191 of file kis_acyclic_signal_connector.h.

---

The documentation for this class was generated from the following files:

• libs/global/kis_acyclic_signal_connector.h
• libs/global/kis_acyclic_signal_connector.cpp