/***************************************************************************
- * Copyright (C) 2005-2015 by the Quassel Project *
+ * Copyright (C) 2005-2018 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
CoreConnection::CoreConnection(QObject *parent)
: QObject(parent),
- _authHandler(0),
- _state(Disconnected),
- _wantReconnect(false),
- _wasReconnect(false),
- _progressMinimum(0),
- _progressMaximum(-1),
- _progressValue(-1),
- _resetting(false)
+ _authHandler(nullptr)
{
qRegisterMetaType<ConnectionState>("CoreConnection::ConnectionState");
}
void CoreConnection::networkDetectionModeChanged(const QVariant &vmode)
{
CoreConnectionSettings s;
- CoreConnectionSettings::NetworkDetectionMode mode = (CoreConnectionSettings::NetworkDetectionMode)vmode.toInt();
+ auto mode = (CoreConnectionSettings::NetworkDetectionMode)vmode.toInt();
if (mode == CoreConnectionSettings::UsePingTimeout)
Client::signalProxy()->setMaxHeartBeatCount(s.pingTimeoutInterval() / 30);
else {
}
+QPointer<Peer> CoreConnection::peer() const
+{
+ if (_peer) {
+ return _peer;
+ }
+ return _authHandler ? _authHandler->peer() : nullptr;
+}
+
+
bool CoreConnection::isEncrypted() const
{
return _peer && _peer->isSecure();
_wantReconnect = wantReconnect;
if (_authHandler) {
- disconnect(_authHandler, 0, this, 0);
+ disconnect(_authHandler, nullptr, this, nullptr);
_authHandler->close();
_authHandler->deleteLater();
- _authHandler = 0;
+ _authHandler = nullptr;
}
if (_peer) {
- disconnect(_peer, 0, this, 0);
+ disconnect(_peer, nullptr, this, nullptr);
// peer belongs to the sigproxy and thus gets deleted by it
_peer->close();
- _peer = 0;
+ _peer = nullptr;
}
_netsToSync.clear();
qWarning() << "Cannot connect to internal core in client-only mode!";
return;
}
- emit startInternalCore();
- InternalPeer *peer = new InternalPeer();
+ auto *peer = new InternalPeer();
_peer = peer;
Client::instance()->signalProxy()->addPeer(peer); // sigproxy will take ownership
+ emit connectionMsg(tr("Initializing..."));
emit connectToInternalCore(peer);
setState(Connected);
-
return;
}
connect(_authHandler, SIGNAL(errorPopup(QString)), SIGNAL(connectionErrorPopup(QString)), Qt::QueuedConnection);
connect(_authHandler, SIGNAL(statusMessage(QString)), SIGNAL(connectionMsg(QString)));
connect(_authHandler, SIGNAL(encrypted(bool)), SIGNAL(encrypted(bool)));
- connect(_authHandler, SIGNAL(startCoreSetup(QVariantList)), SIGNAL(startCoreSetup(QVariantList)));
+ connect(_authHandler, SIGNAL(startCoreSetup(QVariantList, QVariantList)), SIGNAL(startCoreSetup(QVariantList, QVariantList)));
connect(_authHandler, SIGNAL(coreSetupFailed(QString)), SIGNAL(coreSetupFailed(QString)));
connect(_authHandler, SIGNAL(coreSetupSuccessful()), SIGNAL(coreSetupSuccess()));
connect(_authHandler, SIGNAL(userAuthenticationRequired(CoreAccount*,bool*,QString)), SIGNAL(userAuthenticationRequired(CoreAccount*,bool*,QString)));
{
updateProgress(100, 100);
- disconnect(_authHandler, 0, this, 0);
+ disconnect(_authHandler, nullptr, this, nullptr);
_authHandler->deleteLater();
- _authHandler = 0;
+ _authHandler = nullptr;
_peer = peer;
connect(peer, SIGNAL(disconnected()), SLOT(coreSocketDisconnected()));
void CoreConnection::internalSessionStateReceived(const Protocol::SessionState &sessionState)
{
updateProgress(100, 100);
-
- Client::setCoreFeatures(Quassel::features()); // mono connection...
-
setState(Synchronizing);
syncToCore(sessionState);
}
NetworkId netid = networkid.value<NetworkId>();
if (Client::network(netid))
continue;
- Network *net = new Network(netid, Client::instance());
+ auto *net = new Network(netid, Client::instance());
_netsToSync.insert(net);
connect(net, SIGNAL(initDone()), SLOT(networkInitDone()));
connect(net, SIGNAL(destroyed()), SLOT(networkInitDone()));
{
QObject *net = sender();
Q_ASSERT(net);
- disconnect(net, 0, this, 0);
+ disconnect(net, nullptr, this, nullptr);
_netsToSync.remove(net);
updateProgress(_numNetsToSync - _netsToSync.count(), _numNetsToSync);
checkSyncState();