X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=eeb25d5847e4faf35f261b2025391f199955fa4f;hp=95748cb1e8c4e6c08207b0bfa706de0531e1707c;hb=bd37d2c94e49e791d2ba44baab4270e030442832;hpb=6609a6b6f50274e90ecca1aca2c0e2e9ad2e6327 diff --git a/src/client/client.cpp b/src/client/client.cpp index 95748cb1..eeb25d58 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -1,11 +1,11 @@ /*************************************************************************** - * Copyright (C) 2005-07 by The Quassel Team * + * Copyright (C) 2005-08 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * - * (at your option) any later version. * + * (at your option) version 3. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * @@ -20,24 +20,30 @@ #include "client.h" -#include "networkinfo.h" -#include "ircuser.h" +#include "bufferinfo.h" +#include "buffermodel.h" +#include "buffersettings.h" +#include "buffersyncer.h" +#include "bufferviewmanager.h" +#include "clientbacklogmanager.h" +#include "clientirclisthelper.h" +#include "global.h" +#include "identity.h" #include "ircchannel.h" - +#include "ircuser.h" #include "message.h" - -#include "bufferinfo.h" -#include "buffertreemodel.h" +#include "messagemodel.h" +#include "network.h" +#include "networkmodel.h" #include "quasselui.h" #include "signalproxy.h" -#include "synchronizer.h" #include "util.h" QPointer Client::instanceptr = 0; +AccountId Client::_currentCoreAccount = 0; + +/*** Initialization/destruction ***/ -// ============================== -// public Static Methods -// ============================== Client *Client::instance() { if(!instanceptr) instanceptr = new Client(); @@ -45,7 +51,8 @@ Client *Client::instance() { } void Client::destroy() { - delete instanceptr; + //delete instanceptr; + instanceptr->deleteLater(); } void Client::init(AbstractUi *ui) { @@ -53,134 +60,68 @@ void Client::init(AbstractUi *ui) { instance()->init(); } -QList Client::networkInfos() { - return instance()->_networkInfo.values(); -} - -NetworkInfo *Client::networkInfo(uint networkid) { - if(instance()->_networkInfo.contains(networkid)) - return instance()->_networkInfo[networkid]; - else - return 0; -} - -QList Client::allBufferInfos() { - QList bufferids; - foreach(Buffer *buffer, buffers()) { - bufferids << buffer->bufferInfo(); - } - return bufferids; -} - -QList Client::buffers() { - return instance()->_buffers.values(); -} - -Buffer *Client::buffer(uint bufferUid) { - if(instance()->_buffers.contains(bufferUid)) - return instance()->_buffers[bufferUid]; - else - return 0; -} - -Buffer *Client::buffer(BufferInfo id) { - Buffer *buff = buffer(id.uid()); - - if(!buff) { - Client *client = Client::instance(); - buff = new Buffer(id, client); - - connect(buff, SIGNAL(userInput(BufferInfo, QString)), - client, SLOT(userInput(BufferInfo, QString))); - connect(buff, SIGNAL(bufferUpdated(Buffer *)), - client, SIGNAL(bufferUpdated(Buffer *))); - connect(buff, SIGNAL(bufferDestroyed(Buffer *)), - client, SIGNAL(bufferDestroyed(Buffer *))); - connect(buff, SIGNAL(bufferDestroyed(Buffer *)), - client, SLOT(removeBuffer(Buffer *))); - - client->_buffers[id.uid()] = buff; - emit client->bufferUpdated(buff); - } - Q_ASSERT(buff); - return buff; -} - -// FIXME switch to netids! -// WHEN IS THIS NEEDED ANYHOW!? -BufferInfo Client::bufferInfo(QString net, QString buf) { - foreach(Buffer *buffer_, buffers()) { - BufferInfo bufferInfo = buffer_->bufferInfo(); - if(bufferInfo.network() == net && bufferInfo.buffer() == buf) - return bufferInfo; - } - Q_ASSERT(false); // should never happen! - return BufferInfo(); -} - -BufferInfo Client::statusBufferInfo(QString net) { - return bufferInfo(net, ""); -} - -BufferTreeModel *Client::bufferModel() { - return instance()->_bufferModel; -} - -SignalProxy *Client::signalProxy() { - return instance()->_signalProxy; -} - -// ============================== -// Constructor / Decon -// ============================== Client::Client(QObject *parent) : QObject(parent), socket(0), - _signalProxy(new SignalProxy(SignalProxy::Client, 0, this)), + _signalProxy(new SignalProxy(SignalProxy::Client, this)), mainUi(0), + _networkModel(0), _bufferModel(0), - connectedToCore(false) + _bufferSyncer(0), + _backlogManager(new ClientBacklogManager(this)), + _bufferViewManager(0), + _ircListHelper(new ClientIrcListHelper(this)), + _messageModel(0), + _connectedToCore(false), + _syncedToCore(false) { + _monitorBuffer = new Buffer(BufferInfo(), this); + _signalProxy->synchronize(_ircListHelper); + + connect(_backlogManager, SIGNAL(backlog(BufferId, const QVariantList &)), + this, SLOT(receiveBacklog(BufferId, const QVariantList &))); } Client::~Client() { + disconnectFromCore(); } void Client::init() { - blockSize = 0; + _currentCoreAccount = 0; + _networkModel = new NetworkModel(this); - _bufferModel = new BufferTreeModel(this); + connect(this, SIGNAL(bufferUpdated(BufferInfo)), + _networkModel, SLOT(bufferUpdated(BufferInfo))); + connect(this, SIGNAL(networkRemoved(NetworkId)), + _networkModel, SLOT(networkRemoved(NetworkId))); - connect(this, SIGNAL(bufferSelected(Buffer *)), - _bufferModel, SLOT(selectBuffer(Buffer *))); - connect(this, SIGNAL(bufferUpdated(Buffer *)), - _bufferModel, SLOT(bufferUpdated(Buffer *))); - connect(this, SIGNAL(bufferActivity(Buffer::ActivityLevel, Buffer *)), - _bufferModel, SLOT(bufferActivity(Buffer::ActivityLevel, Buffer *))); + _bufferModel = new BufferModel(_networkModel); + _messageModel = mainUi->createMessageModel(this); SignalProxy *p = signalProxy(); - p->attachSignal(this, SIGNAL(sendSessionData(const QString &, const QVariant &)), - SIGNAL(clientSessionDataChanged(const QString &, const QVariant &))); - p->attachSlot(SIGNAL(coreSessionDataChanged(const QString &, const QVariant &)), - this, SLOT(recvSessionData(const QString &, const QVariant &))); - p->attachSlot(SIGNAL(coreState(const QVariant &)), - this, SLOT(recvCoreState(const QVariant &))); - p->attachSlot(SIGNAL(networkConnected(uint)), - this, SLOT(networkConnected(uint))); - p->attachSlot(SIGNAL(networkDisconnected(uint)), - this, SLOT(networkDisconnected(uint))); - p->attachSlot(SIGNAL(displayMsg(const Message &)), - this, SLOT(recvMessage(const Message &))); - p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), - this, SLOT(recvStatusMsg(QString, QString))); - - - p->attachSlot(SIGNAL(backlogData(BufferInfo, const QVariantList &, bool)), this, SLOT(recvBacklogData(BufferInfo, const QVariantList &, bool))); + + p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &))); + p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString))); + p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), this, SLOT(updateBufferInfo(BufferInfo))); p->attachSignal(this, SIGNAL(sendInput(BufferInfo, QString))); p->attachSignal(this, SIGNAL(requestNetworkStates())); - connect(mainUi, SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &))); + p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &)), SIGNAL(createIdentity(const Identity &))); + p->attachSignal(this, SIGNAL(requestUpdateIdentity(const Identity &)), SIGNAL(updateIdentity(const Identity &))); + p->attachSignal(this, SIGNAL(requestRemoveIdentity(IdentityId)), SIGNAL(removeIdentity(IdentityId))); + p->attachSlot(SIGNAL(identityCreated(const Identity &)), this, SLOT(coreIdentityCreated(const Identity &))); + p->attachSlot(SIGNAL(identityRemoved(IdentityId)), this, SLOT(coreIdentityRemoved(IdentityId))); + + p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &)), SIGNAL(createNetwork(const NetworkInfo &))); + p->attachSignal(this, SIGNAL(requestUpdateNetwork(const NetworkInfo &)), SIGNAL(updateNetwork(const NetworkInfo &))); + p->attachSignal(this, SIGNAL(requestRemoveNetwork(NetworkId)), SIGNAL(removeNetwork(NetworkId))); + p->attachSlot(SIGNAL(networkCreated(NetworkId)), this, SLOT(coreNetworkCreated(NetworkId))); + p->attachSlot(SIGNAL(networkRemoved(NetworkId)), this, SLOT(coreNetworkRemoved(NetworkId))); + + connect(p, SIGNAL(disconnected()), this, SLOT(disconnectFromCore())); + + //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())); @@ -192,300 +133,346 @@ void Client::init() { } -bool Client::isConnected() { - return instance()->connectedToCore; +/*** public static methods ***/ + +AccountId Client::currentCoreAccount() { + return _currentCoreAccount; } -void Client::connectToCore(const QVariantMap &conn) { - // TODO implement SSL - coreConnectionInfo = conn; - - if(isConnected()) { - emit coreConnectionError(tr("Already connected to Core!")); - return; - } - - if(socket != 0) - socket->deleteLater(); - - if(conn["Host"].toString().isEmpty()) { - clientMode = LocalCore; - socket = new QBuffer(this); - connect(socket, SIGNAL(readyRead()), this, SLOT(coreHasData())); - socket->open(QIODevice::ReadWrite); - //QVariant state = connectToLocalCore(coreConnectionInfo["User"].toString(), coreConnectionInfo["Password"].toString()); - //syncToCore(state); - coreSocketConnected(); - } else { - clientMode = RemoteCore; - emit coreConnectionMsg(tr("Connecting...")); - Q_ASSERT(!socket); - QTcpSocket *sock = new QTcpSocket(this); - socket = sock; - connect(sock, SIGNAL(readyRead()), this, SLOT(coreHasData())); - connect(sock, SIGNAL(connected()), this, SLOT(coreSocketConnected())); - connect(sock, SIGNAL(disconnected()), this, SLOT(coreSocketDisconnected())); - connect(signalProxy(), SIGNAL(peerDisconnected()), this, SLOT(coreSocketDisconnected())); - //connect(sock, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(coreSocketStateChanged(QAbstractSocket::SocketState))); - connect(sock, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(coreSocketError(QAbstractSocket::SocketError))); - sock->connectToHost(conn["Host"].toString(), conn["Port"].toUInt()); +void Client::setCurrentCoreAccount(AccountId id) { + _currentCoreAccount = id; +} + +QList Client::allBufferInfos() { + QList bufferids; + foreach(Buffer *buffer, buffers()) { + bufferids << buffer->bufferInfo(); } + return bufferids; } -void Client::disconnectFromCore() { - socket->close(); - if(clientMode == LocalCore) - coreSocketDisconnected(); +QList Client::buffers() { + return instance()->_buffers.values(); } -void Client::coreSocketConnected() { - connect(this, SIGNAL(recvPartialItem(uint, uint)), this, SIGNAL(coreConnectionProgress(uint, uint))); - emit coreConnectionMsg(tr("Synchronizing to core...")); - QVariantMap clientInit; - clientInit["GuiProtocol"] = GUI_PROTOCOL; - clientInit["User"] = coreConnectionInfo["User"].toString(); - clientInit["Password"] = coreConnectionInfo["Password"].toString(); - writeDataToDevice(socket, clientInit); + +Buffer *Client::statusBuffer(const NetworkId &networkId) const { + if(_statusBuffers.contains(networkId)) + return _statusBuffers[networkId]; + else + return 0; } -void Client::coreSocketDisconnected() { - instance()->connectedToCore = false; - emit disconnected(); - socket->deleteLater(); - blockSize = 0; +Buffer *Client::buffer(BufferId bufferId) { + if(instance()->_buffers.contains(bufferId)) + return instance()->_buffers[bufferId]; + else + return 0; +} - /* Clear internal data. Hopefully nothing relies on it at this point. */ - _bufferModel->clear(); +Buffer *Client::buffer(BufferInfo bufferInfo) { + Buffer *buff = buffer(bufferInfo.bufferId()); - foreach(Buffer *buffer, _buffers.values()) { - delete buffer; + if(!buff) { + Client *client = Client::instance(); + buff = new Buffer(bufferInfo, client); + connect(buff, SIGNAL(destroyed()), client, SLOT(bufferDestroyed())); + client->_buffers[bufferInfo.bufferId()] = buff; + if(bufferInfo.type() == BufferInfo::StatusBuffer) + client->_statusBuffers[bufferInfo.networkId()] = buff; + + emit client->bufferUpdated(bufferInfo); + + // I don't like this: but currently there isn't really a prettier way: + if(isSynced()) { // this slows down syncing a lot, so disable it during sync + QModelIndex bufferIdx = networkModel()->bufferIndex(bufferInfo.bufferId()); + bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(bufferIdx)); + } } - Q_ASSERT(_buffers.empty()); + Q_ASSERT(buff); + return buff; +} - foreach(NetworkInfo *networkinfo, _networkInfo.values()) { - delete networkinfo; - } - Q_ASSERT(_networkInfo.empty()); +bool Client::isConnected() { + return instance()->_connectedToCore; +} - coreConnectionInfo.clear(); - sessionData.clear(); - layoutQueue.clear(); - layoutTimer->stop(); +bool Client::isSynced() { + return instance()->_syncedToCore; } -void Client::coreSocketStateChanged(QAbstractSocket::SocketState state) { - if(state == QAbstractSocket::UnconnectedState) coreSocketDisconnected(); +/*** Network handling ***/ + +QList Client::networkIds() { + return instance()->_networks.keys(); } -void Client::recvCoreState(const QVariant &state) { - disconnect(this, SIGNAL(recvPartialItem(uint, uint)), this, SIGNAL(coreConnectionProgress(uint, uint))); - disconnect(socket, 0, this, 0); // rest of communication happens through SignalProxy - signalProxy()->addPeer(socket); - syncToCore(state); +const Network * Client::network(NetworkId networkid) { + if(instance()->_networks.contains(networkid)) return instance()->_networks[networkid]; + else return 0; } -// TODO: auth errors -void Client::syncToCore(const QVariant &coreState) { - if(!coreState.toMap().contains("SessionState")) { - emit coreConnectionError(tr("Invalid data received from core!")); - disconnectFromCore(); - return; - } +void Client::createNetwork(const NetworkInfo &info) { + emit instance()->requestCreateNetwork(info); +} - QVariantMap sessionState = coreState.toMap()["SessionState"].toMap(); +void Client::updateNetwork(const NetworkInfo &info) { + emit instance()->requestUpdateNetwork(info); +} - // store sessionData - QVariantMap sessData = sessionState["SessionData"].toMap(); - foreach(QString key, sessData.keys()) - recvSessionData(key, sessData[key]); +void Client::removeNetwork(NetworkId id) { + emit instance()->requestRemoveNetwork(id); +} - // store Buffer details - QVariantList coreBuffers = sessionState["Buffers"].toList(); - /* make lookups by id faster */ - foreach(QVariant vid, coreBuffers) { - buffer(vid.value()); // create all buffers, so we see them in the network views - } +void Client::addNetwork(Network *net) { + net->setProxy(signalProxy()); + signalProxy()->synchronize(net); + networkModel()->attachNetwork(net); + connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed())); + instance()->_networks[net->networkId()] = net; + emit instance()->networkCreated(net->networkId()); +} - // create networkInfo objects - QVariantList networkids = sessionState["Networks"].toList(); - foreach(QVariant networkid, networkids) { - networkConnected(networkid.toUInt()); +void Client::coreNetworkCreated(NetworkId id) { + if(_networks.contains(id)) { + qWarning() << "Creation of already existing network requested!"; + return; } - - instance()->connectedToCore = true; - updateCoreConnectionProgress(); + Network *net = new Network(id, this); + addNetwork(net); } -void Client::updateCoreConnectionProgress() { - // we'll do this in three steps: - // 1.) networks - // 2.) channels - // 3.) ircusers +void Client::coreNetworkRemoved(NetworkId id) { + if(!_networks.contains(id)) + return; + Network *net = _networks.take(id); + emit networkRemoved(net->networkId()); + net->deleteLater(); +} - int numNets = networkInfos().count(); - int numNetsWaiting = 0; +/*** Identity handling ***/ - int numIrcUsers = 0; - int numIrcUsersWaiting = 0; +QList Client::identityIds() { + return instance()->_identities.keys(); +} - int numChannels = 0; - int numChannelsWaiting = 0; +const Identity * Client::identity(IdentityId id) { + if(instance()->_identities.contains(id)) return instance()->_identities[id]; + else return 0; +} - foreach(NetworkInfo *net, networkInfos()) { - if(! net->initialized()) - numNetsWaiting++; +void Client::createIdentity(const Identity &id) { + emit instance()->requestCreateIdentity(id); +} - numIrcUsers += net->ircUsers().count(); - foreach(IrcUser *user, net->ircUsers()) { - if(! user->initialized()) - numIrcUsersWaiting++; - } +void Client::updateIdentity(const Identity &id) { + emit instance()->requestUpdateIdentity(id); +} - numChannels += net->ircChannels().count(); - foreach(IrcChannel *channel, net->ircChannels()) { - if(! channel->initialized()) - numChannelsWaiting++; - } +void Client::removeIdentity(IdentityId id) { + emit instance()->requestRemoveIdentity(id); +} +void Client::coreIdentityCreated(const Identity &other) { + if(!_identities.contains(other.id())) { + Identity *identity = new Identity(other, this); + _identities[other.id()] = identity; + identity->setInitialized(); + signalProxy()->synchronize(identity); + emit identityCreated(other.id()); + } else { + qWarning() << tr("Identity already exists in client!"); } +} - if(numNetsWaiting > 0) { - emit coreConnectionMsg(tr("Requesting network states...")); - emit coreConnectionProgress(numNets - numNetsWaiting, numNets); - return; +void Client::coreIdentityRemoved(IdentityId id) { + if(_identities.contains(id)) { + emit identityRemoved(id); + Identity *i = _identities.take(id); + i->deleteLater(); } +} - if(numIrcUsersWaiting > 0) { - emit coreConnectionMsg(tr("Requesting User states...")); - emit coreConnectionProgress(numIrcUsers - numIrcUsersWaiting, numIrcUsers); - return; - } +/*** ***/ +void Client::userInput(BufferInfo bufferInfo, QString message) { + emit instance()->sendInput(bufferInfo, message); +} - if(numChannelsWaiting > 0) { - emit coreConnectionMsg(tr("Requesting Channel states...")); - emit coreConnectionProgress(numChannels - numChannelsWaiting, numChannels); - return; - } +/*** core connection stuff ***/ - emit coreConnectionProgress(1,1); - emit connected(); +void Client::setConnectedToCore(QIODevice *sock, AccountId id) { + socket = sock; + signalProxy()->addPeer(socket); + _connectedToCore = true; + setCurrentCoreAccount(id); } -void Client::recvSessionData(const QString &key, const QVariant &data) { - sessionData[key] = data; - emit sessionDataChanged(key, data); - emit sessionDataChanged(key); -} +void Client::setSyncedToCore() { + // create buffersyncer + Q_ASSERT(!_bufferSyncer); + _bufferSyncer = new BufferSyncer(this); + connect(bufferSyncer(), SIGNAL(lastSeenMsgSet(BufferId, MsgId)), this, SLOT(updateLastSeenMsg(BufferId, MsgId))); + connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId))); + connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString))); + signalProxy()->synchronize(bufferSyncer()); -void Client::storeSessionData(const QString &key, const QVariant &data) { - // Not sure if this is a good idea, but we'll try it anyway: - // Calling this function only sends a signal to core. Data is stored upon reception of the update signal, - // rather than immediately. - emit instance()->sendSessionData(key, data); -} + // attach backlog manager + signalProxy()->synchronize(backlogManager()); -QVariant Client::retrieveSessionData(const QString &key, const QVariant &def) { - if(instance()->sessionData.contains(key)) return instance()->sessionData[key]; - else return def; -} + // create a new BufferViewManager + _bufferViewManager = new BufferViewManager(signalProxy(), this); -QStringList Client::sessionDataKeys() { - return instance()->sessionData.keys(); + _syncedToCore = true; + emit connected(); + emit coreConnectionStateChanged(true); } -void Client::coreSocketError(QAbstractSocket::SocketError) { - emit coreConnectionError(socket->errorString()); - socket->deleteLater(); +void Client::setSecuredConnection() { + emit securedConnection(); } -void Client::coreHasData() { - QVariant item; - if(readDataFromDevice(socket, blockSize, item)) { - emit recvPartialItem(1,1); - recvCoreState(item); - blockSize = 0; +void Client::disconnectFromCore() { + if(!isConnected()) return; + _connectedToCore = false; + + if(socket) { + socket->close(); + socket->deleteLater(); } - if(blockSize > 0) { - emit recvPartialItem(socket->bytesAvailable(), blockSize); + _syncedToCore = false; + emit disconnected(); + emit coreConnectionStateChanged(false); + + // Clear internal data. Hopefully nothing relies on it at this point. + setCurrentCoreAccount(0); + + if(_bufferSyncer) { + _bufferSyncer->deleteLater(); + _bufferSyncer = 0; } -} -void Client::networkConnected(uint netid) { - // TODO: create statusBuffer / switch to networkids - //BufferInfo id = statusBufferInfo(net); - //Buffer *b = buffer(id); - //b->setActive(true); + if(_bufferViewManager) { + _bufferViewManager->deleteLater(); + _bufferViewManager = 0; + } - NetworkInfo *netinfo = new NetworkInfo(netid, signalProxy(), this); - connect(netinfo, SIGNAL(initDone()), this, SLOT(updateCoreConnectionProgress())); - connect(netinfo, SIGNAL(ircUserInitDone()), this, SLOT(updateCoreConnectionProgress())); - connect(netinfo, SIGNAL(ircChannelInitDone()), this, SLOT(updateCoreConnectionProgress())); - _networkInfo[netid] = netinfo; -} + _messageModel->clear(); + _networkModel->clear(); -void Client::networkDisconnected(uint networkid) { - foreach(Buffer *buffer, buffers()) { - if(buffer->bufferInfo().networkId() != networkid) - continue; + QHash::iterator bufferIter = _buffers.begin(); + while(bufferIter != _buffers.end()) { + Buffer *buffer = bufferIter.value(); + disconnect(buffer, SIGNAL(destroyed()), this, 0); + bufferIter = _buffers.erase(bufferIter); + buffer->deleteLater(); + } + Q_ASSERT(_buffers.isEmpty()); - //buffer->displayMsg(Message(bufferid, Message::Server, tr("Server disconnected."))); FIXME - buffer->setActive(false); + _statusBuffers.clear(); + + QHash::iterator netIter = _networks.begin(); + while(netIter != _networks.end()) { + Network *net = netIter.value(); + emit networkRemoved(net->networkId()); + disconnect(net, SIGNAL(destroyed()), this, 0); + netIter = _networks.erase(netIter); + net->deleteLater(); } - - Q_ASSERT(networkInfo(networkid)); - if(!networkInfo(networkid)->initialized()) { - qDebug() << "Network" << networkid << "disconnected while not yet initialized!"; - updateCoreConnectionProgress(); + Q_ASSERT(_networks.isEmpty()); + + QHash::iterator idIter = _identities.begin(); + while(idIter != _identities.end()) { + Identity *id = idIter.value(); + emit identityRemoved(id->id()); + idIter = _identities.erase(idIter); + id->deleteLater(); } + Q_ASSERT(_identities.isEmpty()); + + layoutQueue.clear(); + layoutTimer->stop(); } -void Client::updateBufferInfo(BufferInfo id) { - buffer(id)->updateBufferInfo(id); +void Client::setCoreConfiguration(const QVariantMap &settings) { + SignalProxy::writeDataToDevice(socket, settings); } +/*** ***/ -void Client::removeBuffer(Buffer *b) { - _buffers.remove(b->bufferInfo().uid()); +void Client::updateBufferInfo(BufferInfo id) { + emit bufferUpdated(id); } -void Client::recvMessage(const Message &msg) { - Buffer *b = buffer(msg.buffer()); +void Client::bufferDestroyed() { + Buffer *buffer = static_cast(sender()); + QHash::iterator iter = _buffers.begin(); + while(iter != _buffers.end()) { + if(iter.value() == buffer) { + iter = _buffers.erase(iter); + break; + } + iter++; + } - Buffer::ActivityLevel level = Buffer::OtherActivity; - if(msg.type() == Message::Plain || msg.type() == Message::Notice){ - level |= Buffer::NewMessage; + QHash::iterator statusIter = _statusBuffers.begin(); + while(statusIter != _statusBuffers.end()) { + if(statusIter.value() == buffer) { + statusIter = _statusBuffers.erase(statusIter); + break; + } + statusIter++; } - if(msg.flags() & Message::Highlight){ - level |= Buffer::Highlight; +} + +void Client::networkDestroyed() { + Network *net = static_cast(sender()); + QHash::iterator netIter = _networks.begin(); + while(netIter != _networks.end()) { + if(*netIter == net) { + netIter = _networks.erase(netIter); + break; + } else { + netIter++; + } } - emit bufferActivity(level, b); +} - b->appendMsg(msg); +void Client::recvMessage(const Message &msg_) { + Message msg = msg_; + checkForHighlight(msg); + _messageModel->insertMessage(msg); + buffer(msg.bufferInfo())->updateActivityLevel(msg); } void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) { //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg))); } -void Client::recvBacklogData(BufferInfo id, QVariantList msgs, bool /*done*/) { - Buffer *b = buffer(id); +void Client::receiveBacklog(BufferId bufferId, const QVariantList &msgs) { + //QTime start = QTime::currentTime(); foreach(QVariant v, msgs) { Message msg = v.value(); - b->prependMsg(msg); - if(!layoutQueue.contains(b)) layoutQueue.append(b); + checkForHighlight(msg); + _messageModel->insertMessage(msg); + buffer(msg.bufferInfo())->updateActivityLevel(msg); } - if(layoutQueue.count() && !layoutTimer->isActive()) layoutTimer->start(); + //qDebug() << "processed" << msgs.count() << "backlog lines in" << start.msecsTo(QTime::currentTime()); } void Client::layoutMsg() { - if(layoutQueue.count()) { - Buffer *b = layoutQueue.takeFirst(); // TODO make this the current buffer - if(b->layoutMsg()) - layoutQueue.append(b); // Buffer has more messages in its queue --> Round Robin + if(layoutQueue.isEmpty()) { + layoutTimer->stop(); + return; + } + + Buffer *buffer = layoutQueue.takeFirst(); + if(buffer->layoutMsg()) { + layoutQueue.append(buffer); // Buffer has more messages in its queue --> Round Robin + return; } - - if(!layoutQueue.count()) + + if(layoutQueue.isEmpty()) layoutTimer->stop(); } @@ -493,7 +480,102 @@ AbstractUiMsg *Client::layoutMsg(const Message &msg) { return instance()->mainUi->layoutMsg(msg); } -void Client::userInput(BufferInfo id, QString msg) { - emit sendInput(id, msg); +// TODO optimize checkForHighlight +void Client::checkForHighlight(Message &msg) { + if(!((msg.type() & (Message::Plain | Message::Notice | Message::Action)) && !(msg.flags() & Message::Self))) + return; + + NotificationSettings notificationSettings; + const Network *net = network(msg.bufferInfo().networkId()); + if(net && !net->myNick().isEmpty()) { + QStringList nickList; + if(notificationSettings.highlightNick() == NotificationSettings::CurrentNick) { + nickList << net->myNick(); + } else if(notificationSettings.highlightNick() == NotificationSettings::AllNicks) { + const Identity *myIdentity = identity(net->identity()); + if(myIdentity) + nickList = myIdentity->nicks(); + } + foreach(QString nickname, nickList) { + QRegExp nickRegExp("^(.*\\W)?" + QRegExp::escape(nickname) + "(\\W.*)?$"); + if(nickRegExp.exactMatch(msg.contents())) { + msg.setFlags(msg.flags() | Message::Highlight); + return; + } + } + + foreach(QVariant highlight, notificationSettings.highlightList()) { + QVariantMap highlightRule = highlight.toMap(); + if(!highlightRule["enable"].toBool()) + continue; + Qt::CaseSensitivity caseSensitivity = highlightRule["cs"].toBool() ? Qt::CaseSensitive : Qt::CaseInsensitive; + QString name = highlightRule["name"].toString(); + QRegExp userRegExp; + if(highlightRule["regex"].toBool()) { + userRegExp = QRegExp(name, caseSensitivity); + } else { + userRegExp = QRegExp("^(.*\\W)?" + QRegExp::escape(name) + "(\\W.*)?$", caseSensitivity); + } + if(userRegExp.exactMatch(msg.contents())) { + msg.setFlags(msg.flags() | Message::Highlight); + return; + } + } + } +} + +void Client::updateLastSeenMsg(BufferId id, const MsgId &msgId) { + Buffer *b = buffer(id); + if(!b) { + qWarning() << "Client::updateLastSeen(): Unknown buffer" << id; + return; + } + b->setLastSeenMsg(msgId); +} + +void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId) { + if(!bufferSyncer()) + return; + bufferSyncer()->requestSetLastSeenMsg(id, msgId); +} + +void Client::removeBuffer(BufferId id) { + if(!bufferSyncer()) return; + bufferSyncer()->requestRemoveBuffer(id); } +void Client::bufferRemoved(BufferId bufferId) { + // first remove the buffer from hash. this prohibits further lastSeenUpdates + Buffer *buff = 0; + if(_buffers.contains(bufferId)) { + buff = _buffers.take(bufferId); + layoutQueue.removeAll(buff); + disconnect(buff, 0, this, 0); + } + + // then we select a sane buffer (status buffer) + /* we have to manually select a buffer because otherwise inconsitent changes + * to the model might occur: + * the result of a buffer removal triggers a change in the selection model. + * the newly selected buffer might be a channel that hasn't been selected yet + * and a new nickview would be created (which never heard of the "rowsAboutToBeRemoved"). + * this new view (and/or) its sort filter will then only receive a "rowsRemoved" signal. + */ + QModelIndex current = bufferModel()->currentIndex(); + if(current.data(NetworkModel::BufferIdRole).value() == bufferId) { + bufferModel()->setCurrentIndex(current.sibling(0,0)); + } + + // and remove it from the model + networkModel()->removeBuffer(bufferId); + + if(buff) + buff->deleteLater(); +} + +void Client::bufferRenamed(BufferId bufferId, const QString &newName) { + QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId); + if(bufferIndex.isValid()) { + networkModel()->setData(bufferIndex, newName, Qt::DisplayRole); + } +}