#include "util.h"
#include "clientauthhandler.h"
-#include <stdio.h>
-#include <stdlib.h>
+#include <cstdio>
+#include <cstdlib>
Client::Client(std::unique_ptr<AbstractUi> ui, QObject *parent)
: QObject(parent), Singleton<Client>(this),
_mainUi(std::move(ui)),
_networkModel(new NetworkModel(this)),
_bufferModel(new BufferModel(_networkModel)),
- _bufferSyncer(0),
- _aliasManager(0),
_backlogManager(new ClientBacklogManager(this)),
- _bufferViewManager(0),
_bufferViewOverlay(new BufferViewOverlay(this)),
_coreInfo(new CoreInfo(this)),
- _dccConfig(0),
_ircListHelper(new ClientIrcListHelper(this)),
_inputHandler(new ClientUserInputHandler(this)),
- _networkConfig(0),
- _ignoreListManager(0),
- _highlightRuleManager(0),
- _transferManager(0),
_transferModel(new TransferModel(this)),
_messageModel(_mainUi->createMessageModel(this)),
_messageProcessor(_mainUi->createMessageProcessor(this)),
_coreAccountModel(new CoreAccountModel(this)),
- _coreConnection(new CoreConnection(this)),
- _connected(false)
+ _coreConnection(new CoreConnection(this))
{
#ifdef EMBED_DATA
Q_INIT_RESOURCE(data);
#endif
- //connect(mainUi(), SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
- connect(mainUi(), SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
- connect(this, SIGNAL(connected()), mainUi(), SLOT(connectedToCore()));
- connect(this, SIGNAL(disconnected()), mainUi(), SLOT(disconnectedFromCore()));
+ connect(mainUi(), &AbstractUi::disconnectFromCore, this, &Client::disconnectFromCore);
+ connect(this, &Client::connected, mainUi(), &AbstractUi::connectedToCore);
+ connect(this, &Client::disconnected, mainUi(), &AbstractUi::disconnectedFromCore);
- connect(this, SIGNAL(networkRemoved(NetworkId)), _networkModel, SLOT(networkRemoved(NetworkId)));
- connect(this, SIGNAL(networkRemoved(NetworkId)), _messageProcessor, SLOT(networkRemoved(NetworkId)));
+ connect(this, &Client::networkRemoved, _networkModel, &NetworkModel::networkRemoved);
+ connect(this, &Client::networkRemoved, _messageProcessor, &AbstractMessageProcessor::networkRemoved);
- connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int)));
- connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState)));
+ connect(backlogManager(), &ClientBacklogManager::messagesReceived, _messageModel, &MessageModel::messagesReceived);
+ connect(coreConnection(), &CoreConnection::stateChanged, this, &Client::connectionStateChanged);
SignalProxy *p = signalProxy();
const Network *Client::network(NetworkId networkid)
{
if (instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
- else return 0;
+ else return nullptr;
}
net->setProxy(signalProxy());
signalProxy()->synchronize(net);
networkModel()->attachNetwork(net);
- connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed()));
+ connect(net, &QObject::destroyed, instance(), &Client::networkDestroyed);
instance()->_networks[net->networkId()] = net;
emit instance()->networkCreated(net->networkId());
}
qWarning() << "Creation of already existing network requested!";
return;
}
- Network *net = new Network(id, this);
+ auto *net = new Network(id, this);
addNetwork(net);
}
const Identity *Client::identity(IdentityId id)
{
if (instance()->_identities.contains(id)) return instance()->_identities[id];
- else return 0;
+ else return nullptr;
}
void Client::coreIdentityCreated(const Identity &other)
{
if (!_identities.contains(other.id())) {
- Identity *identity = new Identity(other, this);
+ auto *identity = new Identity(other, this);
_identities[other.id()] = identity;
identity->setInitialized();
signalProxy()->synchronize(identity);
// create buffersyncer
Q_ASSERT(!_bufferSyncer);
_bufferSyncer = new BufferSyncer(this);
- connect(bufferSyncer(), SIGNAL(lastSeenMsgSet(BufferId, MsgId)), _networkModel, SLOT(setLastSeenMsgId(BufferId, MsgId)));
- connect(bufferSyncer(), SIGNAL(markerLineSet(BufferId, MsgId)), _networkModel, SLOT(setMarkerLineMsgId(BufferId, MsgId)));
- connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId)));
- connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString)));
- connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), this, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
- connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), _messageModel, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
- connect(bufferSyncer(), SIGNAL(bufferMarkedAsRead(BufferId)), SIGNAL(bufferMarkedAsRead(BufferId)));
- connect(bufferSyncer(), SIGNAL(bufferActivityChanged(BufferId, const Message::Types)), _networkModel, SLOT(bufferActivityChanged(BufferId, const Message::Types)));
- connect(bufferSyncer(), SIGNAL(highlightCountChanged(BufferId, int)), _networkModel, SLOT(highlightCountChanged(BufferId, int)));
- connect(networkModel(), SIGNAL(requestSetLastSeenMsg(BufferId, MsgId)), bufferSyncer(), SLOT(requestSetLastSeenMsg(BufferId, const MsgId &)));
+ connect(bufferSyncer(), &BufferSyncer::lastSeenMsgSet, _networkModel, &NetworkModel::setLastSeenMsgId);
+ connect(bufferSyncer(), &BufferSyncer::markerLineSet, _networkModel, &NetworkModel::setMarkerLineMsgId);
+ connect(bufferSyncer(), &BufferSyncer::bufferRemoved, this, &Client::bufferRemoved);
+ connect(bufferSyncer(), &BufferSyncer::bufferRenamed, this, &Client::bufferRenamed);
+ connect(bufferSyncer(), &BufferSyncer::buffersPermanentlyMerged, this, &Client::buffersPermanentlyMerged);
+ connect(bufferSyncer(), &BufferSyncer::buffersPermanentlyMerged, _messageModel, &MessageModel::buffersPermanentlyMerged);
+ connect(bufferSyncer(), &BufferSyncer::bufferMarkedAsRead, this, &Client::bufferMarkedAsRead);
+ connect(bufferSyncer(), &BufferSyncer::bufferActivityChanged, _networkModel, &NetworkModel::bufferActivityChanged);
+ connect(bufferSyncer(), &BufferSyncer::highlightCountChanged, _networkModel, &NetworkModel::highlightCountChanged);
+ connect(networkModel(), &NetworkModel::requestSetLastSeenMsg, bufferSyncer(), &BufferSyncer::requestSetLastSeenMsg);
SignalProxy *p = signalProxy();
p->synchronize(bufferSyncer());
// create a new BufferViewManager
Q_ASSERT(!_bufferViewManager);
_bufferViewManager = new ClientBufferViewManager(p, this);
- connect(_bufferViewManager, SIGNAL(initDone()), _bufferViewOverlay, SLOT(restore()));
+ connect(_bufferViewManager, &SyncableObject::initDone, _bufferViewOverlay, &BufferViewOverlay::restore);
// create AliasManager
Q_ASSERT(!_aliasManager);
_aliasManager = new ClientAliasManager(this);
- connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput()));
+ connect(aliasManager(), &SyncableObject::initDone, this, &Client::sendBufferedUserInput);
p->synchronize(aliasManager());
// create NetworkConfig
_highlightRuleManager = new HighlightRuleManager(this);
p->synchronize(highlightRuleManager());
// Listen to network removed events
- connect(this, SIGNAL(networkRemoved(NetworkId)),
- _highlightRuleManager, SLOT(networkRemoved(NetworkId)));
+ connect(this, &Client::networkRemoved,
+ _highlightRuleManager, &HighlightRuleManager::networkRemoved);
/* not ready yet
// create TransferManager and DccConfig if core supports them
*/
// trigger backlog request once all active bufferviews are initialized
- connect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
+ connect(bufferViewOverlay(), &BufferViewOverlay::initDone, this, &Client::finishConnectionInitialization);
_connected = true;
emit connected();
// triggers this slot. But we have to make sure that we know all buffers yet.
// so we check the BufferSyncer and in case it wasn't initialized we wait for that instead
if (!bufferSyncer()->isInitialized()) {
- disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
- connect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
+ disconnect(bufferViewOverlay(), &BufferViewOverlay::initDone, this, &Client::finishConnectionInitialization);
+ connect(bufferSyncer(), &SyncableObject::initDone, this, &Client::finishConnectionInitialization);
return;
}
- disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
- disconnect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
+ disconnect(bufferViewOverlay(), &BufferViewOverlay::initDone, this, &Client::finishConnectionInitialization);
+ disconnect(bufferSyncer(), &SyncableObject::initDone, this, &Client::finishConnectionInitialization);
requestInitialBacklog();
if (isCoreFeatureEnabled(Quassel::Feature::BufferActivitySync)) {
if (_bufferSyncer) {
_bufferSyncer->deleteLater();
- _bufferSyncer = 0;
+ _bufferSyncer = nullptr;
}
_coreInfo->reset();
if (_bufferViewManager) {
_bufferViewManager->deleteLater();
- _bufferViewManager = 0;
+ _bufferViewManager = nullptr;
}
_bufferViewOverlay->reset();
if (_aliasManager) {
_aliasManager->deleteLater();
- _aliasManager = 0;
+ _aliasManager = nullptr;
}
if (_ignoreListManager) {
_ignoreListManager->deleteLater();
- _ignoreListManager = 0;
+ _ignoreListManager = nullptr;
}
if (_highlightRuleManager) {
while (netIter != _networks.end()) {
Network *net = netIter.value();
emit networkRemoved(net->networkId());
- disconnect(net, SIGNAL(destroyed()), this, 0);
+ disconnect(net, &Network::destroyed, this, nullptr);
netIter = _networks.erase(netIter);
net->deleteLater();
}
if (_networkConfig) {
_networkConfig->deleteLater();
- _networkConfig = 0;
+ _networkConfig = nullptr;
}
}
void Client::networkDestroyed()
{
- Network *net = static_cast<Network *>(sender());
+ auto *net = static_cast<Network *>(sender());
QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
while (netIter != _networks.end()) {
if (*netIter == net) {
{
if (id.isValid() && networkModel())
return networkModel()->markerLineMsgId(id);
- return MsgId();
+ return {};
}
projects / quassel.git / blobdiff