File indexing completed on 2024-05-12 15:56:55
0001 /* 0002 * SPDX-FileCopyrightText: 2014 Dmitry Kazakov <dimula73@gmail.com> 0003 * 0004 * SPDX-License-Identifier: GPL-2.0-or-later 0005 */ 0006 0007 #include "kis_acyclic_signal_connector.h" 0008 0009 #include "kis_debug.h" 0010 0011 0012 KisAcyclicSignalConnector::KisAcyclicSignalConnector(QObject *parent) 0013 : QObject(parent), 0014 m_signalsBlocked(0) 0015 { 0016 } 0017 0018 KisAcyclicSignalConnector::~KisAcyclicSignalConnector() 0019 { 0020 } 0021 0022 void KisAcyclicSignalConnector::connectForwardDouble(QObject *sender, const char *signal, 0023 QObject *receiver, const char *method) 0024 { 0025 0026 connect(sender, signal, this, SLOT(forwardSlotDouble(double)), Qt::UniqueConnection); 0027 connect(this, SIGNAL(forwardSignalDouble(double)), receiver, method, Qt::UniqueConnection); 0028 } 0029 0030 void KisAcyclicSignalConnector::connectBackwardDouble(QObject *sender, const char *signal, 0031 QObject *receiver, const char *method) 0032 { 0033 0034 connect(sender, signal, this, SLOT(backwardSlotDouble(double)), Qt::UniqueConnection); 0035 connect(this, SIGNAL(backwardSignalDouble(double)), receiver, method, Qt::UniqueConnection); 0036 } 0037 0038 void KisAcyclicSignalConnector::connectForwardInt(QObject *sender, const char *signal, 0039 QObject *receiver, const char *method) 0040 { 0041 0042 connect(sender, signal, this, SLOT(forwardSlotInt(int)), Qt::UniqueConnection); 0043 connect(this, SIGNAL(forwardSignalInt(int)), receiver, method, Qt::UniqueConnection); 0044 } 0045 0046 void KisAcyclicSignalConnector::connectBackwardInt(QObject *sender, const char *signal, 0047 QObject *receiver, const char *method) 0048 { 0049 0050 connect(sender, signal, this, SLOT(backwardSlotInt(int)), Qt::UniqueConnection); 0051 connect(this, SIGNAL(backwardSignalInt(int)), receiver, method, Qt::UniqueConnection); 0052 } 0053 0054 void KisAcyclicSignalConnector::connectForwardBool(QObject *sender, const char *signal, 0055 QObject *receiver, const char *method) 0056 { 0057 0058 connect(sender, signal, this, SLOT(forwardSlotBool(bool)), Qt::UniqueConnection); 0059 connect(this, SIGNAL(forwardSignalBool(bool)), receiver, method, Qt::UniqueConnection); 0060 } 0061 0062 void KisAcyclicSignalConnector::connectBackwardBool(QObject *sender, const char *signal, 0063 QObject *receiver, const char *method) 0064 { 0065 0066 connect(sender, signal, this, SLOT(backwardSlotBool(bool)), Qt::UniqueConnection); 0067 connect(this, SIGNAL(backwardSignalBool(bool)), receiver, method, Qt::UniqueConnection); 0068 } 0069 0070 void KisAcyclicSignalConnector::connectForwardVoid(QObject *sender, const char *signal, 0071 QObject *receiver, const char *method) 0072 { 0073 0074 connect(sender, signal, this, SLOT(forwardSlotVoid()), Qt::UniqueConnection); 0075 connect(this, SIGNAL(forwardSignalVoid()), receiver, method, Qt::UniqueConnection); 0076 } 0077 0078 void KisAcyclicSignalConnector::connectBackwardVoid(QObject *sender, const char *signal, 0079 QObject *receiver, const char *method) 0080 { 0081 0082 connect(sender, signal, this, SLOT(backwardSlotVoid()), Qt::UniqueConnection); 0083 connect(this, SIGNAL(backwardSignalVoid()), receiver, method, Qt::UniqueConnection); 0084 } 0085 0086 void KisAcyclicSignalConnector::connectForwardVariant(QObject *sender, const char *signal, 0087 QObject *receiver, const char *method) 0088 { 0089 0090 connect(sender, signal, this, SLOT(forwardSlotVariant(QVariant)), Qt::UniqueConnection); 0091 connect(this, SIGNAL(forwardSignalVariant(QVariant)), receiver, method, Qt::UniqueConnection); 0092 } 0093 0094 void KisAcyclicSignalConnector::connectBackwardVariant(QObject *sender, const char *signal, 0095 QObject *receiver, const char *method) 0096 { 0097 connect(sender, signal, this, SLOT(backwardSlotVariant(QVariant)), Qt::UniqueConnection); 0098 connect(this, SIGNAL(backwardSignalVariant(QVariant)), receiver, method, Qt::UniqueConnection); 0099 } 0100 0101 void KisAcyclicSignalConnector::connectForwardResourcePair(QObject *sender, const char *signal, QObject *receiver, const char *method) 0102 { 0103 connect(sender, signal, this, SLOT(forwardSlotResourcePair(int,QVariant)), Qt::UniqueConnection); 0104 connect(this, SIGNAL(forwardSignalResourcePair(int,QVariant)), receiver, method, Qt::UniqueConnection); 0105 } 0106 0107 void KisAcyclicSignalConnector::connectBackwardResourcePair(QObject *sender, const char *signal, QObject *receiver, const char *method) 0108 { 0109 connect(sender, signal, this, SLOT(backwardSlotResourcePair(int,QVariant)), Qt::UniqueConnection); 0110 connect(this, SIGNAL(backwardSignalResourcePair(int,QVariant)), receiver, method, Qt::UniqueConnection); 0111 } 0112 0113 void KisAcyclicSignalConnector::connectForwardKoColor(QObject *sender, const char *signal, QObject *receiver, const char *method) 0114 { 0115 connect(sender, signal, this, SLOT(forwardSlotKoColor(KoColor)), Qt::UniqueConnection); 0116 connect(this, SIGNAL(forwardSignalKoColor(KoColor)), receiver, method, Qt::UniqueConnection); 0117 } 0118 0119 void KisAcyclicSignalConnector::connectBackwardKoColor(QObject *sender, const char *signal, QObject *receiver, const char *method) 0120 { 0121 connect(sender, signal, this, SLOT(backwardSlotKoColor(KoColor)), Qt::UniqueConnection); 0122 connect(this, SIGNAL(backwardSignalKoColor(KoColor)), receiver, method, Qt::UniqueConnection); 0123 } 0124 0125 void KisAcyclicSignalConnector::lock() 0126 { 0127 if (m_parentConnector) { 0128 m_parentConnector->lock(); 0129 } else { 0130 coordinatedLock(); 0131 0132 Q_FOREACH(QPointer<KisAcyclicSignalConnector> conn, m_coordinatedConnectors) { 0133 if (!conn) continue; 0134 conn->coordinatedLock(); 0135 } 0136 } 0137 } 0138 0139 void KisAcyclicSignalConnector::unlock() 0140 { 0141 if (m_parentConnector) { 0142 m_parentConnector->unlock(); 0143 } else { 0144 Q_FOREACH(QPointer<KisAcyclicSignalConnector> conn, m_coordinatedConnectors) { 0145 if (!conn) continue; 0146 conn->coordinatedUnlock(); 0147 } 0148 0149 coordinatedUnlock(); 0150 } 0151 } 0152 0153 bool KisAcyclicSignalConnector::isLocked() const 0154 { 0155 return m_signalsBlocked; 0156 } 0157 0158 void KisAcyclicSignalConnector::coordinatedLock() 0159 { 0160 m_signalsBlocked++; 0161 } 0162 0163 void KisAcyclicSignalConnector::coordinatedUnlock() 0164 { 0165 m_signalsBlocked--; 0166 } 0167 0168 KisAcyclicSignalConnector *KisAcyclicSignalConnector::createCoordinatedConnector() 0169 { 0170 KisAcyclicSignalConnector *conn = new KisAcyclicSignalConnector(this); 0171 conn->m_parentConnector = this; 0172 m_coordinatedConnectors.append(conn); 0173 return conn; 0174 } 0175 0176 void KisAcyclicSignalConnector::forwardSlotDouble(double value) 0177 { 0178 if (m_signalsBlocked) return; 0179 0180 lock(); 0181 emit forwardSignalDouble(value); 0182 unlock(); 0183 } 0184 0185 void KisAcyclicSignalConnector::backwardSlotDouble(double value) 0186 { 0187 if (m_signalsBlocked) return; 0188 0189 lock(); 0190 emit backwardSignalDouble(value); 0191 unlock(); 0192 } 0193 0194 void KisAcyclicSignalConnector::forwardSlotInt(int value) 0195 { 0196 if (m_signalsBlocked) return; 0197 0198 lock(); 0199 emit forwardSignalInt(value); 0200 unlock(); 0201 } 0202 0203 void KisAcyclicSignalConnector::backwardSlotInt(int value) 0204 { 0205 if (m_signalsBlocked) return; 0206 0207 lock(); 0208 emit backwardSignalInt(value); 0209 unlock(); 0210 } 0211 0212 void KisAcyclicSignalConnector::forwardSlotBool(bool value) 0213 { 0214 if (m_signalsBlocked) return; 0215 0216 lock(); 0217 emit forwardSignalBool(value); 0218 unlock(); 0219 } 0220 0221 void KisAcyclicSignalConnector::backwardSlotBool(bool value) 0222 { 0223 if (m_signalsBlocked) return; 0224 0225 lock(); 0226 emit backwardSignalBool(value); 0227 unlock(); 0228 } 0229 0230 void KisAcyclicSignalConnector::forwardSlotVoid() 0231 { 0232 if (m_signalsBlocked) return; 0233 0234 lock(); 0235 emit forwardSignalVoid(); 0236 unlock(); 0237 } 0238 0239 void KisAcyclicSignalConnector::backwardSlotVoid() 0240 { 0241 if (m_signalsBlocked) return; 0242 0243 lock(); 0244 emit backwardSignalVoid(); 0245 unlock(); 0246 } 0247 0248 void KisAcyclicSignalConnector::forwardSlotVariant(const QVariant &value) 0249 { 0250 if (m_signalsBlocked) return; 0251 0252 lock(); 0253 emit forwardSignalVariant(value); 0254 unlock(); 0255 } 0256 0257 void KisAcyclicSignalConnector::backwardSlotVariant(const QVariant &value) 0258 { 0259 if (m_signalsBlocked) return; 0260 0261 lock(); 0262 emit backwardSignalVariant(value); 0263 unlock(); 0264 } 0265 0266 void KisAcyclicSignalConnector::forwardSlotResourcePair(int key, const QVariant &resource) 0267 { 0268 if (m_signalsBlocked) return; 0269 0270 lock(); 0271 emit forwardSignalResourcePair(key, resource); 0272 unlock(); 0273 } 0274 0275 void KisAcyclicSignalConnector::backwardSlotResourcePair(int key, const QVariant &resource) 0276 { 0277 if (m_signalsBlocked) return; 0278 0279 lock(); 0280 emit backwardSignalResourcePair(key, resource); 0281 unlock(); 0282 } 0283 0284 void KisAcyclicSignalConnector::forwardSlotKoColor(const KoColor &value) 0285 { 0286 if (m_signalsBlocked) return; 0287 0288 lock(); 0289 emit forwardSignalKoColor(value); 0290 unlock(); 0291 } 0292 0293 void KisAcyclicSignalConnector::backwardSlotKoColor(const KoColor &value) 0294 { 0295 if (m_signalsBlocked) return; 0296 0297 lock(); 0298 emit backwardSignalKoColor(value); 0299 unlock(); 0300 }