/*!
\internal
Catch signal disconnections.
*/
void QDBusAbstractInterface::disconnectNotify(const QMetaMethod &signal)
{
// someone disconnecting from one of our signals
Q_D(QDBusAbstractInterface);
if (!d->isValid)
return;
QDBusConnectionPrivate *conn = d->connectionPrivate();
if (conn && signal.isValid() && !isSignalConnected(signal))
return conn->disconnectRelay(d->service, d->path, d->interface,
this, signal);
if (!conn)
return;
// wildcard disconnecting, we need to figure out which of our signals are
// no longer connected to anything
const QMetaObject *mo = metaObject();
int midx = QObject::staticMetaObject.methodCount();
const int end = mo->methodCount();
for ( ; midx < end; ++midx) {
QMetaMethod mm = mo->method(midx);
if (mm.methodType() == QMetaMethod::Signal && !isSignalConnected(mm))
conn->disconnectRelay(d->service, d->path, d->interface, this, mm);
}
}
void JsonClient::dataReadyOnSocket()
{
std::string str(mSocket->readAll());
if (isSignalConnected(messageReceived))
messageReceived.emit(str);
if (isSignalConnected(messageReceivedMap))
messageReceivedMap.emit(toHashTable(str));
}
/*!
\internal
When someone disconnects, disconnect from the engine too if there are no more users of that signal.
*/
void QContactManager::disconnectNotify(const QMetaMethod &signal)
{
if (!isSignalConnected(signal)) {
QMetaMethod sourceSignal = proxyToSourceSignal(signal, d->m_engine);
disconnect(d->m_engine, sourceSignal, this, signal);
}
}
WindowScriptingInterface::WindowScriptingInterface() {
const DomainHandler& domainHandler = DependencyManager::get<NodeList>()->getDomainHandler();
connect(&domainHandler, &DomainHandler::connectedToDomain, this, &WindowScriptingInterface::domainChanged);
connect(&domainHandler, &DomainHandler::disconnectedFromDomain, this, &WindowScriptingInterface::disconnectedFromDomain);
connect(&domainHandler, &DomainHandler::domainConnectionRefused, this, &WindowScriptingInterface::domainConnectionRefused);
connect(&domainHandler, &DomainHandler::redirectErrorStateChanged, this, &WindowScriptingInterface::redirectErrorStateChanged);
connect(qApp, &Application::svoImportRequested, [this](const QString& urlString) {
static const QMetaMethod svoImportRequestedSignal =
QMetaMethod::fromSignal(&WindowScriptingInterface::svoImportRequested);
if (isSignalConnected(svoImportRequestedSignal)) {
QUrl url(urlString);
emit svoImportRequested(url.url());
} else {
OffscreenUi::asyncWarning("Import SVO Error", "You need to be running edit.js to import entities.");
}
});
connect(qApp->getWindow(), &MainWindow::windowGeometryChanged, this, &WindowScriptingInterface::onWindowGeometryChanged);
connect(qApp, &Application::interstitialModeChanged, [this] (bool interstitialMode) {
emit interstitialModeChanged(interstitialMode);
});
}
/*!
Set the \a device used by the JsonStream.
Setting the device to 0 disconnects the stream but does not close
the device nor flush it.
The stream does not take ownership of the device.
*/
void JsonClient::setDevice( AbstractSocket *device )
{
if (mSocket)
{
if (isSignalConnected(device->readyRead))
mSocket->readyRead.slots().begin()->disconnect();
if (isSignalConnected(device->aboutToClose))
mSocket->aboutToClose.slots().begin()->disconnect();
delete mSocket;
}
mSocket = device;
if (device) {
device->readyRead.connect( sigc::mem_fun(this, &JsonClient::dataReadyOnSocket) );
device->aboutToClose.connect( sigc::mem_fun(this, &JsonClient::socketAboutToClose) );
}
}
/*!
\internal
*/
void QBatteryInfo::disconnectNotify(const QMetaMethod &signal)
{
#if defined(Q_OS_LINUX) || defined(Q_OS_WIN) || defined(QT_SIMULATOR) || defined(Q_OS_MAC)
// We can only disconnect with the private implementation, when there is no receivers for the signal.
if (isSignalConnected(signal))
return;
QMetaMethod sourceSignal = proxyToSourceSignal(signal, d_ptr);
disconnect(d_ptr, sourceSignal, this, signal);
#else
Q_UNUSED(signal)
#endif
}
/**
* Returns true if doLog does nothing and need not to be called
*/
bool Logger::isNoop() const
{
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
return false;
#else
static auto signal = QMetaMethod::fromSignal(&Logger::newLog);
if (isSignalConnected(signal)) {
return false;
}
QMutexLocker lock(const_cast<QMutex *>(&_mutex));
return !_logstream;
#endif
}
WindowScriptingInterface::WindowScriptingInterface() {
const DomainHandler& domainHandler = DependencyManager::get<NodeList>()->getDomainHandler();
connect(&domainHandler, &DomainHandler::connectedToDomain, this, &WindowScriptingInterface::domainChanged);
connect(&domainHandler, &DomainHandler::domainConnectionRefused, this, &WindowScriptingInterface::domainConnectionRefused);
connect(qApp, &Application::svoImportRequested, [this](const QString& urlString) {
static const QMetaMethod svoImportRequestedSignal =
QMetaMethod::fromSignal(&WindowScriptingInterface::svoImportRequested);
if (isSignalConnected(svoImportRequestedSignal)) {
QUrl url(urlString);
emit svoImportRequested(url.url());
} else {
OffscreenUi::warning("Import SVO Error", "You need to be running edit.js to import entities.");
}
});
}
void QVariantAnimationPrivate::setCurrentValueForProgress(const qreal progress)
{
Q_Q(QVariantAnimation);
const qreal startProgress = currentInterval.start.first;
const qreal endProgress = currentInterval.end.first;
const qreal localProgress = (progress - startProgress) / (endProgress - startProgress);
QVariant ret = q->interpolated(currentInterval.start.second,
currentInterval.end.second,
localProgress);
qSwap(currentValue, ret);
q->updateCurrentValue(currentValue);
static QBasicAtomicInt changedSignalIndex = Q_BASIC_ATOMIC_INITIALIZER(0);
if (!changedSignalIndex) {
//we keep the mask so that we emit valueChanged only when needed (for performance reasons)
changedSignalIndex.testAndSetRelaxed(0, signalIndex("valueChanged(QVariant)"));
}
if (isSignalConnected(changedSignalIndex) && currentValue != ret) {
//the value has changed
emit q->valueChanged(currentValue);
}
}
void NavigationAttached::customEvent(QEvent *event)
{
if (event->type() == NavEventType)
{
NavEvent *nEvent = static_cast<NavEvent *>(event);
QuickNavEvent qne(nEvent->key(), nEvent->isAutoRepeat());
emit navigationEvent(&qne);
nEvent->setAccepted(qne.isAccepted());
if (!nEvent->isAccepted())
{
switch (nEvent->key())
{
case Navigation::Left:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::left)))
{
qne.setAccepted(true);
emit left(&qne);
}
break;
case Navigation::Right:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::right)))
{
qne.setAccepted(true);
emit right(&qne);
}
break;
case Navigation::Up:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::up)))
{
qne.setAccepted(true);
emit up(&qne);
}
break;
case Navigation::Down:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::down)))
{
qne.setAccepted(true);
emit down(&qne);
}
break;
case Navigation::OK:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::ok)))
{
qne.setAccepted(true);
emit ok(&qne);
}
break;
case Navigation::Back:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::back)))
{
qne.setAccepted(true);
emit back(&qne);
}
break;
case Navigation::Play:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::play)))
{
qne.setAccepted(true);
emit play(&qne);
}
break;
case Navigation::PlayPause:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::playPause)))
{
qne.setAccepted(true);
emit playPause(&qne);
}
break;
case Navigation::Pause:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::pause)))
{
qne.setAccepted(true);
emit pause(&qne);
}
break;
case Navigation::Stop:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::stop)))
{
qne.setAccepted(true);
emit stop(&qne);
}
break;
case Navigation::Next:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::next)))
{
qne.setAccepted(true);
emit next(&qne);
}
break;
case Navigation::Previous:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::previous)))
{
qne.setAccepted(true);
emit previous(&qne);
}
break;
case Navigation::Record:
if (isSignalConnected(QMetaMethod::fromSignal(&NavigationAttached::record)))
{
qne.setAccepted(true);
emit record(&qne);
}
break;
default:
break;
}
event->setAccepted(qne.isAccepted());
}
}
}
bool TrackListModel::canFetchMore(const QModelIndex &parent) const
{
// We can only fetch more if something's receiving notifications when we need more
return !parent.isValid() && isSignalConnected(QMetaMethod::fromSignal(&TrackListModel::needMore));
}
