X-Git-Url: https://git.quassel-irc.org/?a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=92be56ef4e340b6a0d8d73ed5e78905596519faf;hb=b3a8232d4959903591c309d765da9c271d0a761f;hp=1924001bdb75e63a392e3ce3805e00920f19b488;hpb=130ccf5033c21ca3ad0e0357a82953b5727bd0e9;p=quassel.git diff --git a/src/client/client.cpp b/src/client/client.cpp index 1924001b..92be56ef 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-09 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 * @@ -18,337 +18,474 @@ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "gui.h" -#include "guiproxy.h" -#include "mainwin.h" -#include "buffer.h" -//#include "bufferview.h" -#include "bufferviewwidget.h" +#include "client.h" + +#include "abstractmessageprocessor.h" +#include "bufferinfo.h" +#include "buffermodel.h" +#include "buffersettings.h" +#include "buffersyncer.h" +#include "bufferviewconfig.h" +#include "bufferviewmanager.h" +#include "clientbacklogmanager.h" +#include "clientirclisthelper.h" +#include "clientidentity.h" +#include "ircchannel.h" +#include "ircuser.h" +#include "message.h" +#include "messagemodel.h" +#include "network.h" +#include "networkmodel.h" +#include "quassel.h" +#include "quasselui.h" +#include "signalproxy.h" #include "util.h" -Client * Client::instanceptr = 0; +#include +#include -Client::ClientMode Client::clientMode; -QHash Client::buffers; -QHash Client::bufferIds; -QHash > Client::nicks; -QHash Client::connected; -QHash Client::ownNick; -QList Client::coreBuffers; +QPointer Client::instanceptr = 0; +AccountId Client::_currentCoreAccount = 0; +/*** Initialization/destruction ***/ Client *Client::instance() { - if(instanceptr) return instanceptr; - instanceptr = new Client(); - instanceptr->init(); + if(!instanceptr) + instanceptr = new Client(); return instanceptr; } void Client::destroy() { - delete instanceptr; - instanceptr = 0; + if(instanceptr) { + delete instanceptr->mainUi(); + instanceptr->deleteLater(); + instanceptr = 0; + } +} + +void Client::init(AbstractUi *ui) { + instance()->_mainUi = ui; + instance()->init(); +} + +Client::Client(QObject *parent) + : QObject(parent), + _signalProxy(new SignalProxy(SignalProxy::Client, this)), + _mainUi(0), + _networkModel(0), + _bufferModel(0), + _bufferSyncer(0), + _backlogManager(new ClientBacklogManager(this)), + _bufferViewManager(0), + _ircListHelper(new ClientIrcListHelper(this)), + _messageModel(0), + _messageProcessor(0), + _connectedToCore(false), + _syncedToCore(false), + _internalCore(false), + _debugLog(&_debugLogBuffer) +{ + _signalProxy->synchronize(_ircListHelper); +} + +Client::~Client() { + disconnectFromCore(); } -Client::Client() { - clientProxy = ClientProxy::instance(); +void Client::init() { + _currentCoreAccount = 0; + _networkModel = new NetworkModel(this); + + connect(this, SIGNAL(networkRemoved(NetworkId)), + _networkModel, SLOT(networkRemoved(NetworkId))); + + _bufferModel = new BufferModel(_networkModel); + _messageModel = mainUi()->createMessageModel(this); + _messageProcessor = mainUi()->createMessageProcessor(this); + + SignalProxy *p = signalProxy(); + + 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)), _networkModel, SLOT(bufferUpdated(BufferInfo))); + p->attachSignal(this, SIGNAL(sendInput(BufferInfo, QString))); + p->attachSignal(this, SIGNAL(requestNetworkStates())); + + p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &, const QVariantMap &)), SIGNAL(createIdentity(const Identity &, const QVariantMap &))); + 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))); - //mainWin = new MainWin(); + p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &, const QStringList &)), SIGNAL(createNetwork(const NetworkInfo &, const QStringList &))); + 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))); - _bufferModel = new BufferTreeModel(0); // FIXME + connect(p, SIGNAL(disconnected()), this, SLOT(disconnectedFromCore())); - 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 *))); + //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())); - // TODO: make this configurable (allow monolithic client to connect to remote cores) - if(Global::runMode == Global::Monolithic) clientMode = LocalCore; - else clientMode = RemoteCore; + // attach backlog manager + p->synchronize(backlogManager()); + connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int))); } -void Client::init() { - blockSize = 0; - - connect(&socket, SIGNAL(readyRead()), this, SLOT(serverHasData())); - connect(&socket, SIGNAL(connected()), this, SLOT(coreConnected())); - connect(&socket, SIGNAL(disconnected()), this, SLOT(coreDisconnected())); - connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(serverError(QAbstractSocket::SocketError))); - - connect(Global::instance(), SIGNAL(dataPutLocally(UserId, QString)), this, SLOT(updateCoreData(UserId, QString))); - connect(clientProxy, SIGNAL(csUpdateGlobalData(QString, QVariant)), this, SLOT(updateLocalData(QString, QVariant))); - - connect(clientProxy, SIGNAL(send(ClientSignal, QVariant, QVariant, QVariant)), this, SLOT(recvProxySignal(ClientSignal, QVariant, QVariant, QVariant))); - connect(clientProxy, SIGNAL(csServerState(QString, QVariant)), this, SLOT(recvNetworkState(QString, QVariant))); - connect(clientProxy, SIGNAL(csServerConnected(QString)), this, SLOT(networkConnected(QString))); - connect(clientProxy, SIGNAL(csServerDisconnected(QString)), this, SLOT(networkDisconnected(QString))); - connect(clientProxy, SIGNAL(csDisplayMsg(Message)), this, SLOT(recvMessage(Message))); - connect(clientProxy, SIGNAL(csDisplayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString))); - connect(clientProxy, SIGNAL(csTopicSet(QString, QString, QString)), this, SLOT(setTopic(QString, QString, QString))); - connect(clientProxy, SIGNAL(csNickAdded(QString, QString, VarMap)), this, SLOT(addNick(QString, QString, VarMap))); - connect(clientProxy, SIGNAL(csNickRemoved(QString, QString)), this, SLOT(removeNick(QString, QString))); - connect(clientProxy, SIGNAL(csNickRenamed(QString, QString, QString)), this, SLOT(renameNick(QString, QString, QString))); - connect(clientProxy, SIGNAL(csNickUpdated(QString, QString, VarMap)), this, SLOT(updateNick(QString, QString, VarMap))); - connect(clientProxy, SIGNAL(csOwnNickSet(QString, QString)), this, SLOT(setOwnNick(QString, QString))); - connect(clientProxy, SIGNAL(csBacklogData(BufferId, QList, bool)), this, SLOT(recvBacklogData(BufferId, QList, bool))); - connect(clientProxy, SIGNAL(csUpdateBufferId(BufferId)), this, SLOT(updateBufferId(BufferId))); - connect(this, SIGNAL(sendInput(BufferId, QString)), clientProxy, SLOT(gsUserInput(BufferId, QString))); - connect(this, SIGNAL(requestBacklog(BufferId, QVariant, QVariant)), clientProxy, SLOT(gsRequestBacklog(BufferId, QVariant, QVariant))); - - syncToCore(); - - layoutTimer = new QTimer(this); - layoutTimer->setInterval(0); - layoutTimer->setSingleShot(false); - connect(layoutTimer, SIGNAL(timeout()), this, SLOT(layoutMsg())); - - /* make lookups by id faster */ - foreach(BufferId id, coreBuffers) { - bufferIds[id.uid()] = id; // make lookups by id faster - buffer(id); // create all buffers, so we see them in the network views - emit requestBacklog(id, -1, -1); // TODO: use custom settings for backlog request - } +/*** public static methods ***/ - mainWin = new MainWin(); - mainWin->init(); +AbstractUi *Client::mainUi() { + return instance()->_mainUi; +} +AccountId Client::currentCoreAccount() { + return _currentCoreAccount; } -Client::~Client() { - delete mainWin; - delete _bufferModel; - foreach(Buffer *buf, buffers.values()) delete buf; - ClientProxy::destroy(); +void Client::setCurrentCoreAccount(AccountId id) { + _currentCoreAccount = id; +} +bool Client::isConnected() { + return instance()->_connectedToCore; } -BufferTreeModel *Client::bufferModel() { - return instance()->_bufferModel; +bool Client::isSynced() { + return instance()->_syncedToCore; } -void Client::coreConnected() { +/*** Network handling ***/ +QList Client::networkIds() { + return instance()->_networks.keys(); } -void Client::coreDisconnected() { +const Network * Client::network(NetworkId networkid) { + if(instance()->_networks.contains(networkid)) return instance()->_networks[networkid]; + else return 0; +} +void Client::createNetwork(const NetworkInfo &info, const QStringList &persistentChannels) { + emit instance()->requestCreateNetwork(info, persistentChannels); } -void Client::updateCoreData(UserId, QString key) { - if(clientMode == LocalCore) return; - QVariant data = Global::data(key); - recvProxySignal(GS_UPDATE_GLOBAL_DATA, key, data, QVariant()); +void Client::removeNetwork(NetworkId id) { + emit instance()->requestRemoveNetwork(id); } -void Client::updateLocalData(QString key, QVariant data) { - Global::updateData(key, data); +void Client::updateNetwork(const NetworkInfo &info) { + Network *netptr = instance()->_networks.value(info.networkId, 0); + if(!netptr) { + qWarning() << "Update for unknown network requested:" << info; + return; + } + netptr->requestSetNetworkInfo(info); } -void Client::recvProxySignal(ClientSignal sig, QVariant arg1, QVariant arg2, QVariant arg3) { - if(clientMode == LocalCore) return; - QList sigdata; - sigdata.append(sig); sigdata.append(arg1); sigdata.append(arg2); sigdata.append(arg3); - //qDebug() << "Sending signal: " << sigdata; - writeDataToDevice(&socket, QVariant(sigdata)); +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()); } -void Client::connectToCore(QString host, quint16 port) { - // TODO implement SSL - socket.connectToHost(host, port); +void Client::coreNetworkCreated(NetworkId id) { + if(_networks.contains(id)) { + qWarning() << "Creation of already existing network requested!"; + return; + } + Network *net = new Network(id, this); + addNetwork(net); } -void Client::disconnectFromCore() { - socket.close(); +void Client::coreNetworkRemoved(NetworkId id) { + if(!_networks.contains(id)) + return; + Network *net = _networks.take(id); + emit networkRemoved(net->networkId()); + net->deleteLater(); +} + +/*** Identity handling ***/ + +QList Client::identityIds() { + return instance()->_identities.keys(); } -void Client::serverError(QAbstractSocket::SocketError) { - emit coreConnectionError(socket.errorString()); +const Identity *Client::identity(IdentityId id) { + if(instance()->_identities.contains(id)) return instance()->_identities[id]; + else return 0; } -void Client::serverHasData() { - QVariant item; - while(readDataFromDevice(&socket, blockSize, item)) { - emit recvPartialItem(1,1); - QList sigdata = item.toList(); - Q_ASSERT(sigdata.size() == 4); - ClientProxy::instance()->recv((CoreSignal)sigdata[0].toInt(), sigdata[1], sigdata[2], sigdata[3]); - blockSize = 0; +void Client::createIdentity(const CertIdentity &id) { + QVariantMap additional; +#ifdef HAVE_SSL + additional["KeyPem"] = id.sslKey().toPem(); + additional["CertPem"] = id.sslCert().toPem(); +#endif + emit instance()->requestCreateIdentity(id, additional); +} + +void Client::updateIdentity(IdentityId id, const QVariantMap &ser) { + Identity *idptr = instance()->_identities.value(id, 0); + if(!idptr) { + qWarning() << "Update for unknown identity requested:" << id; + return; } - if(blockSize > 0) { - emit recvPartialItem(socket.bytesAvailable(), blockSize); + idptr->requestUpdate(ser); +} + +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!"); } } -/*******************************************************************************************************************/ +void Client::coreIdentityRemoved(IdentityId id) { + if(_identities.contains(id)) { + emit identityRemoved(id); + Identity *i = _identities.take(id); + i->deleteLater(); + } +} -void Client::networkConnected(QString net) { - connected[net] = true; - BufferId id = statusBufferId(net); - Buffer *b = buffer(id); - b->setActive(true); - //b->displayMsg(Message(id, Message::Server, tr("Connected."))); - // TODO buffersUpdated(); +/*** ***/ +void Client::userInput(BufferInfo bufferInfo, QString message) { + emit instance()->sendInput(bufferInfo, message); } -void Client::networkDisconnected(QString net) { - foreach(BufferId id, buffers.keys()) { - if(id.network() != net) continue; - Buffer *b = buffer(id); - //b->displayMsg(Message(id, Message::Server, tr("Server disconnected."))); FIXME - b->setActive(false); +/*** core connection stuff ***/ + +void Client::setConnectedToCore(AccountId id, QIODevice *socket) { + if(socket) { // external core + // if the socket is an orphan, the signalProxy adopts it. + // -> we don't need to care about it anymore + socket->setParent(0); + signalProxy()->addPeer(socket); + } + _internalCore = !socket; + _connectedToCore = true; + setCurrentCoreAccount(id); +} + +void Client::setSyncedToCore() { + // create buffersyncer + Q_ASSERT(!_bufferSyncer); + _bufferSyncer = new BufferSyncer(this); + connect(bufferSyncer(), SIGNAL(lastSeenMsgSet(BufferId, MsgId)), _networkModel, SLOT(setLastSeenMsgId(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(initDone()), this, SLOT(requestInitialBacklog())); + connect(networkModel(), SIGNAL(setLastSeenMsg(BufferId, MsgId)), bufferSyncer(), SLOT(requestSetLastSeenMsg(BufferId, const MsgId &))); + signalProxy()->synchronize(bufferSyncer()); + + // create a new BufferViewManager + Q_ASSERT(!_bufferViewManager); + _bufferViewManager = new BufferViewManager(signalProxy(), this); + connect(bufferViewManager(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog())); + connect(bufferViewManager(), SIGNAL(initDone()), this, SLOT(createDefaultBufferView())); + + createDefaultIdentity(); + createDefaultNetworks(); + + _syncedToCore = true; + emit connected(); + emit coreConnectionStateChanged(true); +} + +void Client::requestInitialBacklog() { + if(bufferViewManager()->isInitialized() && bufferSyncer()->isInitialized()) + Client::backlogManager()->requestInitialBacklog(); +} + +void Client::createDefaultBufferView() { + if(bufferViewManager()->bufferViewConfigs().isEmpty()) { + BufferViewConfig config(-1); + config.setBufferViewName(tr("All Buffers")); + config.initSetBufferList(networkModel()->allBufferIdsSorted()); + bufferViewManager()->requestCreateBufferView(config.toVariantMap()); } - connected[net] = false; } -void Client::updateBufferId(BufferId id) { - bufferIds[id.uid()] = id; // make lookups by id faster - buffer(id); +void Client::createDefaultIdentity() { + if(_identities.isEmpty()) { + Identity identity; + identity.setToDefaults(); + identity.setIdentityName(tr("Default Identity")); + createIdentity(identity); + } } -BufferId Client::bufferId(QString net, QString buf) { - foreach(BufferId id, buffers.keys()) { - if(id.network() == net && id.buffer() == buf) return id; +void Client::createDefaultNetworks() { + if(_networks.isEmpty()) { + QStringList defaultNets = Network::presetNetworks(true); + foreach(QString net, defaultNets) { + NetworkInfo info = Network::networkInfoFromPreset(net); + if(info.networkName.isEmpty()) + continue; + QStringList defaultChans = Network::presetDefaultChannels(net); + createNetwork(info, defaultChans); + } } - Q_ASSERT(false); // should never happen! - return BufferId(); } -BufferId Client::statusBufferId(QString net) { - return bufferId(net, ""); +void Client::disconnectFromCore() { + if(!isConnected()) + return; + + signalProxy()->removeAllPeers(); } +void Client::disconnectedFromCore() { + _connectedToCore = false; + _syncedToCore = false; + emit disconnected(); + emit coreConnectionStateChanged(false); -Buffer * Client::buffer(BufferId id) { - Client *client = Client::instance(); - if(!buffers.contains(id)) { - Buffer *b = new Buffer(id); - b->setOwnNick(ownNick[id.network()]); - connect(b, SIGNAL(userInput(BufferId, QString)), client, SLOT(userInput(BufferId, QString))); - connect(b, SIGNAL(bufferUpdated(Buffer *)), client, SIGNAL(bufferUpdated(Buffer *))); - connect(b, SIGNAL(bufferDestroyed(Buffer *)), client, SIGNAL(bufferDestroyed(Buffer *))); - buffers[id] = b; - emit client->bufferUpdated(b); - } - return buffers[id]; -} - -void Client::recvNetworkState(QString net, QVariant state) { - connected[net] = true; - setOwnNick(net, state.toMap()["OwnNick"].toString()); - buffer(statusBufferId(net))->setActive(true); - VarMap t = state.toMap()["Topics"].toMap(); - VarMap n = state.toMap()["Nicks"].toMap(); - foreach(QVariant v, t.keys()) { - QString buf = v.toString(); - BufferId id = bufferId(net, buf); - buffer(id)->setActive(true); - setTopic(net, buf, t[buf].toString()); + backlogManager()->reset(); + messageProcessor()->reset(); + + // Clear internal data. Hopefully nothing relies on it at this point. + setCurrentCoreAccount(0); + + if(_bufferSyncer) { + _bufferSyncer->deleteLater(); + _bufferSyncer = 0; } - foreach(QString nick, n.keys()) { - addNick(net, nick, n[nick].toMap()); + + if(_bufferViewManager) { + _bufferViewManager->deleteLater(); + _bufferViewManager = 0; } -} -void Client::recvMessage(Message msg) { - Buffer *b = buffer(msg.buffer); + _messageModel->clear(); + _networkModel->clear(); - Buffer::ActivityLevel level = Buffer::OtherActivity; - if(msg.type == Message::Plain || msg.type == Message::Notice){ - level |= Buffer::NewMessage; + 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(); } - if(msg.flags & Message::Highlight){ - level |= Buffer::Highlight; + Q_ASSERT(_networks.isEmpty()); + + QHash::iterator idIter = _identities.begin(); + while(idIter != _identities.end()) { + emit identityRemoved(idIter.key()); + Identity *id = idIter.value(); + idIter = _identities.erase(idIter); + id->deleteLater(); } - emit bufferActivity(level, b); + Q_ASSERT(_identities.isEmpty()); - //b->displayMsg(msg); - b->appendChatLine(new ChatLine(msg)); } -void Client::recvStatusMsg(QString net, QString msg) { - //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg))); +/*** ***/ +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++; + } + } } -void Client::recvBacklogData(BufferId id, QList msgs, bool done) { - foreach(QVariant v, msgs) { - layoutQueue.append(v.value()); - } - if(!layoutTimer->isActive()) layoutTimer->start(); +// Hmm... we never used this... +void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) { + //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg))); } +void Client::recvMessage(const Message &msg) { + Message msg_ = msg; + messageProcessor()->process(msg_); +} -void Client::layoutMsg() { - if(layoutQueue.count()) { - ChatLine *line = new ChatLine(layoutQueue.takeFirst()); - buffer(line->bufferId())->prependChatLine(line); - } - if(!layoutQueue.count()) layoutTimer->stop(); +void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId) { + if(!bufferSyncer()) + return; + bufferSyncer()->requestSetLastSeenMsg(id, msgId); } -void Client::userInput(BufferId id, QString msg) { - emit sendInput(id, msg); +void Client::removeBuffer(BufferId id) { + if(!bufferSyncer()) return; + bufferSyncer()->requestRemoveBuffer(id); } -void Client::setTopic(QString net, QString buf, QString topic) { - BufferId id = bufferId(net, buf); - if(!connected[id.network()]) return; - Buffer *b = buffer(id); - b->setTopic(topic); - //if(!b->isActive()) { - // b->setActive(true); - // buffersUpdated(); - //} +void Client::renameBuffer(BufferId bufferId, const QString &newName) { + if(!bufferSyncer()) + return; + bufferSyncer()->requestRenameBuffer(bufferId, newName); } -void Client::addNick(QString net, QString nick, VarMap props) { - if(!connected[net]) return; - nicks[net][nick] = props; - VarMap chans = props["Channels"].toMap(); - QStringList c = chans.keys(); - foreach(QString bufname, c) { - buffer(bufferId(net, bufname))->addNick(nick, props); - } +void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2) { + if(!bufferSyncer()) + return; + bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2); } -void Client::renameNick(QString net, QString oldnick, QString newnick) { - if(!connected[net]) return; - QStringList chans = nicks[net][oldnick]["Channels"].toMap().keys(); - foreach(QString c, chans) { - buffer(bufferId(net, c))->renameNick(oldnick, newnick); +void Client::bufferRemoved(BufferId bufferId) { + // 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)); } - nicks[net][newnick] = nicks[net].take(oldnick); + + // and remove it from the model + networkModel()->removeBuffer(bufferId); } -void Client::updateNick(QString net, QString nick, VarMap props) { - if(!connected[net]) return; - QStringList oldchans = nicks[net][nick]["Channels"].toMap().keys(); - QStringList newchans = props["Channels"].toMap().keys(); - foreach(QString c, newchans) { - if(oldchans.contains(c)) buffer(bufferId(net, c))->updateNick(nick, props); - else buffer(bufferId(net, c))->addNick(nick, props); - } - foreach(QString c, oldchans) { - if(!newchans.contains(c)) buffer(bufferId(net, c))->removeNick(nick); +void Client::bufferRenamed(BufferId bufferId, const QString &newName) { + QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId); + if(bufferIndex.isValid()) { + networkModel()->setData(bufferIndex, newName, Qt::DisplayRole); } - nicks[net][nick] = props; } -void Client::removeNick(QString net, QString nick) { - if(!connected[net]) return; - VarMap chans = nicks[net][nick]["Channels"].toMap(); - foreach(QString bufname, chans.keys()) { - buffer(bufferId(net, bufname))->removeNick(nick); - } - nicks[net].remove(nick); +void Client::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2) { + QModelIndex idx = networkModel()->bufferIndex(bufferId1); + bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(idx)); + networkModel()->removeBuffer(bufferId2); } -void Client::setOwnNick(QString net, QString nick) { - if(!connected[net]) return; - ownNick[net] = nick; - foreach(BufferId id, buffers.keys()) { - if(id.network() == net) { - buffers[id]->setOwnNick(nick); - } +void Client::logMessage(QtMsgType type, const char *msg) { + fprintf(stderr, "%s\n", msg); + fflush(stderr); + if(type == QtFatalMsg) { + Quassel::logFatalMessage(msg); + } else { + QString msgString = QString("%1\n").arg(msg); + instance()->_debugLog << msgString; + emit instance()->logUpdated(msgString); } } -