1 /***************************************************************************
2 * Copyright (C) 2005-08 by the Quassel Project *
3 * devel@quassel-irc.org *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) version 3. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
23 #include "bufferinfo.h"
24 #include "buffersyncer.h"
27 #include "ircchannel.h"
31 #include "networkmodel.h"
32 #include "buffermodel.h"
33 #include "quasselui.h"
34 #include "signalproxy.h"
36 #include "buffersettings.h"
38 QPointer<Client> Client::instanceptr = 0;
39 AccountId Client::_currentCoreAccount = 0;
41 /*** Initialization/destruction ***/
43 Client *Client::instance() {
45 instanceptr = new Client();
49 void Client::destroy() {
51 instanceptr->deleteLater();
54 void Client::init(AbstractUi *ui) {
55 instance()->mainUi = ui;
59 Client::Client(QObject *parent)
62 _signalProxy(new SignalProxy(SignalProxy::Client, this)),
67 _connectedToCore(false),
70 _monitorBuffer = new Buffer(BufferInfo(), this);
78 _currentCoreAccount = 0;
79 _networkModel = new NetworkModel(this);
80 connect(this, SIGNAL(bufferUpdated(BufferInfo)),
81 _networkModel, SLOT(bufferUpdated(BufferInfo)));
82 connect(this, SIGNAL(networkRemoved(NetworkId)),
83 _networkModel, SLOT(networkRemoved(NetworkId)));
85 _bufferModel = new BufferModel(_networkModel);
87 SignalProxy *p = signalProxy();
89 p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &)));
90 p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString)));
92 p->attachSlot(SIGNAL(backlogData(BufferInfo, const QVariantList &, bool)), this, SLOT(recvBacklogData(BufferInfo, const QVariantList &, bool)));
93 p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), this, SLOT(updateBufferInfo(BufferInfo)));
94 p->attachSignal(this, SIGNAL(sendInput(BufferInfo, QString)));
95 p->attachSignal(this, SIGNAL(requestNetworkStates()));
97 p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &)), SIGNAL(createIdentity(const Identity &)));
98 p->attachSignal(this, SIGNAL(requestUpdateIdentity(const Identity &)), SIGNAL(updateIdentity(const Identity &)));
99 p->attachSignal(this, SIGNAL(requestRemoveIdentity(IdentityId)), SIGNAL(removeIdentity(IdentityId)));
100 p->attachSlot(SIGNAL(identityCreated(const Identity &)), this, SLOT(coreIdentityCreated(const Identity &)));
101 p->attachSlot(SIGNAL(identityRemoved(IdentityId)), this, SLOT(coreIdentityRemoved(IdentityId)));
103 p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &)), SIGNAL(createNetwork(const NetworkInfo &)));
104 p->attachSignal(this, SIGNAL(requestUpdateNetwork(const NetworkInfo &)), SIGNAL(updateNetwork(const NetworkInfo &)));
105 p->attachSignal(this, SIGNAL(requestRemoveNetwork(NetworkId)), SIGNAL(removeNetwork(NetworkId)));
106 p->attachSlot(SIGNAL(networkCreated(NetworkId)), this, SLOT(coreNetworkCreated(NetworkId)));
107 p->attachSlot(SIGNAL(networkRemoved(NetworkId)), this, SLOT(coreNetworkRemoved(NetworkId)));
109 connect(p, SIGNAL(disconnected()), this, SLOT(disconnectFromCore()));
111 //connect(mainUi, SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
112 connect(mainUi, SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
113 connect(this, SIGNAL(connected()), mainUi, SLOT(connectedToCore()));
114 connect(this, SIGNAL(disconnected()), mainUi, SLOT(disconnectedFromCore()));
116 layoutTimer = new QTimer(this);
117 layoutTimer->setInterval(0);
118 layoutTimer->setSingleShot(false);
119 connect(layoutTimer, SIGNAL(timeout()), this, SLOT(layoutMsg()));
123 /*** public static methods ***/
125 AccountId Client::currentCoreAccount() {
126 return _currentCoreAccount;
129 void Client::setCurrentCoreAccount(AccountId id) {
130 _currentCoreAccount = id;
133 QList<BufferInfo> Client::allBufferInfos() {
134 QList<BufferInfo> bufferids;
135 foreach(Buffer *buffer, buffers()) {
136 bufferids << buffer->bufferInfo();
141 QList<Buffer *> Client::buffers() {
142 return instance()->_buffers.values();
146 Buffer *Client::statusBuffer(const NetworkId &networkId) const {
147 if(_statusBuffers.contains(networkId))
148 return _statusBuffers[networkId];
153 Buffer *Client::buffer(BufferId bufferId) {
154 if(instance()->_buffers.contains(bufferId))
155 return instance()->_buffers[bufferId];
160 Buffer *Client::buffer(BufferInfo bufferInfo) {
161 Buffer *buff = buffer(bufferInfo.bufferId());
164 Client *client = Client::instance();
165 buff = new Buffer(bufferInfo, client);
166 connect(buff, SIGNAL(destroyed()), client, SLOT(bufferDestroyed()));
167 client->_buffers[bufferInfo.bufferId()] = buff;
168 if(bufferInfo.type() == BufferInfo::StatusBuffer)
169 client->_statusBuffers[bufferInfo.networkId()] = buff;
171 emit client->bufferUpdated(bufferInfo);
173 // I don't like this: but currently there isn't really a prettier way:
174 QModelIndex bufferIdx = networkModel()->bufferIndex(bufferInfo.bufferId());
175 bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(bufferIdx));
181 bool Client::isConnected() {
182 return instance()->_connectedToCore;
185 bool Client::isSynced() {
186 return instance()->_syncedToCore;
189 /*** Network handling ***/
191 QList<NetworkId> Client::networkIds() {
192 return instance()->_networks.keys();
195 const Network * Client::network(NetworkId networkid) {
196 if(instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
200 void Client::createNetwork(const NetworkInfo &info) {
201 emit instance()->requestCreateNetwork(info);
204 void Client::updateNetwork(const NetworkInfo &info) {
205 emit instance()->requestUpdateNetwork(info);
208 void Client::removeNetwork(NetworkId id) {
209 emit instance()->requestRemoveNetwork(id);
212 void Client::addNetwork(Network *net) {
213 net->setProxy(signalProxy());
214 signalProxy()->synchronize(net);
215 networkModel()->attachNetwork(net);
216 connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed()));
217 instance()->_networks[net->networkId()] = net;
218 emit instance()->networkCreated(net->networkId());
221 void Client::coreNetworkCreated(NetworkId id) {
222 if(_networks.contains(id)) {
223 qWarning() << "Creation of already existing network requested!";
226 Network *net = new Network(id, this);
230 void Client::coreNetworkRemoved(NetworkId id) {
231 if(!_networks.contains(id)) return;
232 Network *net = _networks.take(id);
233 emit networkRemoved(net->networkId());
237 /*** Identity handling ***/
239 QList<IdentityId> Client::identityIds() {
240 return instance()->_identities.keys();
243 const Identity * Client::identity(IdentityId id) {
244 if(instance()->_identities.contains(id)) return instance()->_identities[id];
248 void Client::createIdentity(const Identity &id) {
249 emit instance()->requestCreateIdentity(id);
252 void Client::updateIdentity(const Identity &id) {
253 emit instance()->requestUpdateIdentity(id);
256 void Client::removeIdentity(IdentityId id) {
257 emit instance()->requestRemoveIdentity(id);
260 void Client::coreIdentityCreated(const Identity &other) {
261 if(!_identities.contains(other.id())) {
262 Identity *identity = new Identity(other, this);
263 _identities[other.id()] = identity;
264 identity->setInitialized();
265 signalProxy()->synchronize(identity);
266 emit identityCreated(other.id());
268 qWarning() << tr("Identity already exists in client!");
272 void Client::coreIdentityRemoved(IdentityId id) {
273 if(_identities.contains(id)) {
274 emit identityRemoved(id);
275 Identity *i = _identities.take(id);
281 void Client::userInput(BufferInfo bufferInfo, QString message) {
282 emit instance()->sendInput(bufferInfo, message);
285 /*** core connection stuff ***/
287 void Client::setConnectedToCore(QIODevice *sock, AccountId id) {
289 signalProxy()->addPeer(socket);
290 _connectedToCore = true;
291 setCurrentCoreAccount(id);
294 void Client::setSyncedToCore() {
295 // create buffersyncer
296 Q_ASSERT(!_bufferSyncer);
297 _bufferSyncer = new BufferSyncer(this);
298 connect(bufferSyncer(), SIGNAL(lastSeenSet(BufferId, const QDateTime &)), this, SLOT(updateLastSeen(BufferId, const QDateTime &)));
299 connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId)));
300 connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString)));
301 signalProxy()->synchronize(bufferSyncer());
303 _syncedToCore = true;
305 emit coreConnectionStateChanged(true);
308 void Client::disconnectFromCore() {
314 socket->deleteLater();
316 _connectedToCore = false;
317 _syncedToCore = false;
318 setCurrentCoreAccount(0);
320 emit coreConnectionStateChanged(false);
322 // Clear internal data. Hopefully nothing relies on it at this point.
324 _bufferSyncer->deleteLater();
327 _networkModel->clear();
329 QHash<BufferId, Buffer *>::iterator bufferIter = _buffers.begin();
330 while(bufferIter != _buffers.end()) {
331 Buffer *buffer = bufferIter.value();
332 disconnect(buffer, SIGNAL(destroyed()), this, 0);
333 bufferIter = _buffers.erase(bufferIter);
334 buffer->deleteLater();
336 Q_ASSERT(_buffers.isEmpty());
338 _statusBuffers.clear();
340 QHash<NetworkId, Network*>::iterator netIter = _networks.begin();
341 while(netIter != _networks.end()) {
342 Network *net = netIter.value();
343 emit networkRemoved(net->networkId());
344 disconnect(net, SIGNAL(destroyed()), this, 0);
345 netIter = _networks.erase(netIter);
348 Q_ASSERT(_networks.isEmpty());
350 QHash<IdentityId, Identity*>::iterator idIter = _identities.begin();
351 while(idIter != _identities.end()) {
352 Identity *id = idIter.value();
353 emit identityRemoved(id->id());
354 idIter = _identities.erase(idIter);
357 Q_ASSERT(_identities.isEmpty());
363 void Client::setCoreConfiguration(const QVariantMap &settings) {
364 SignalProxy::writeDataToDevice(socket, settings);
369 void Client::updateBufferInfo(BufferInfo id) {
370 emit bufferUpdated(id);
373 void Client::bufferDestroyed() {
374 Buffer *buffer = static_cast<Buffer *>(sender());
375 QHash<BufferId, Buffer *>::iterator iter = _buffers.begin();
376 while(iter != _buffers.end()) {
377 if(iter.value() == buffer) {
378 iter = _buffers.erase(iter);
384 QHash<NetworkId, Buffer *>::iterator statusIter = _statusBuffers.begin();
385 while(statusIter != _statusBuffers.end()) {
386 if(statusIter.value() == buffer) {
387 statusIter = _statusBuffers.erase(statusIter);
394 void Client::networkDestroyed() {
395 Network *net = static_cast<Network *>(sender());
396 QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
397 while(netIter != _networks.end()) {
398 if(*netIter == net) {
399 netIter = _networks.erase(netIter);
407 void Client::recvMessage(const Message &message) {
408 Message msg = message;
411 checkForHighlight(msg);
413 if(msg.flags() & Message::Redirected) {
414 BufferSettings bufferSettings;
415 bool inStatus = bufferSettings.value("UserMessagesInStatusBuffer", QVariant(true)).toBool();
416 bool inQuery = bufferSettings.value("UserMessagesInQueryBuffer", QVariant(false)).toBool();
417 bool inCurrent = bufferSettings.value("UserMessagesInCurrentBuffer", QVariant(false)).toBool();
420 b = statusBuffer(msg.bufferInfo().networkId());
423 } else if(!inQuery && !inCurrent) { // make sure the message get's shown somewhere
424 b = buffer(msg.bufferInfo());
430 b = buffer(msg.bufferInfo().bufferId());
433 } else if(!inStatus && !inCurrent) { // make sure the message get's shown somewhere
434 b = statusBuffer(msg.bufferInfo().networkId());
436 b = buffer(msg.bufferInfo()); // seems like we have to create the buffer anyways...
442 BufferId currentId = bufferModel()->currentIndex().data(NetworkModel::BufferIdRole).value<BufferId>();
443 b = buffer(currentId);
444 if(b && currentId != msg.bufferInfo().bufferId() && !inQuery) {
446 } else if(!inStatus && !inQuery) { // make sure the message get's shown somewhere
447 b = statusBuffer(msg.bufferInfo().networkId());
449 b = buffer(msg.bufferInfo()); // seems like we have to create the buffer anyways...
454 // the regular case: we can deliver where it was supposed to go
455 b = buffer(msg.bufferInfo());
459 //bufferModel()->updateBufferActivity(msg);
461 if(msg.type() == Message::Plain || msg.type() == Message::Notice || msg.type() == Message::Action) {
462 const Network *net = network(msg.bufferInfo().networkId());
463 QString networkName = net != 0
464 ? net->networkName() + ":"
466 QString sender = networkName + msg.bufferInfo().bufferName() + ":" + msg.sender();
467 Message mmsg = Message(msg.timestamp(), msg.bufferInfo(), msg.type(), msg.text(), sender, msg.flags());
468 monitorBuffer()->appendMsg(mmsg);
472 void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
473 //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
476 void Client::recvBacklogData(BufferInfo id, QVariantList msgs, bool /*done*/) {
477 Buffer *b = buffer(id);
479 qWarning() << "Client::recvBacklogData(): received Backlog for unknown Buffer:" << id;
483 foreach(QVariant v, msgs) {
484 Message msg = v.value<Message>();
485 checkForHighlight(msg);
487 //networkModel()->updateBufferActivity(msg);
488 if(!layoutQueue.contains(b)) layoutQueue.append(b);
490 if(layoutQueue.count() && !layoutTimer->isActive()) layoutTimer->start();
493 void Client::layoutMsg() {
494 if(layoutQueue.count()) {
495 Buffer *b = layoutQueue.takeFirst(); // TODO make this the current buffer
497 layoutQueue.append(b); // Buffer has more messages in its queue --> Round Robin
500 if(!layoutQueue.count())
504 AbstractUiMsg *Client::layoutMsg(const Message &msg) {
505 return instance()->mainUi->layoutMsg(msg);
508 void Client::checkForHighlight(Message &msg) {
509 const Network *net = network(msg.bufferInfo().networkId());
510 if(net && !net->myNick().isEmpty()) {
511 QRegExp nickRegExp("^(.*\\W)?" + QRegExp::escape(net->myNick()) + "(\\W.*)?$");
512 if((msg.type() & (Message::Plain | Message::Notice | Message::Action)) && nickRegExp.exactMatch(msg.text()))
513 msg.setFlags(msg.flags() | Message::Highlight);
517 void Client::updateLastSeen(BufferId id, const QDateTime &lastSeen) {
518 Buffer *b = buffer(id);
520 qWarning() << "Client::updateLastSeen(): Unknown buffer" << id;
523 b->setLastSeen(lastSeen);
526 void Client::setBufferLastSeen(BufferId id, const QDateTime &lastSeen) {
527 if(!bufferSyncer()) return;
528 bufferSyncer()->requestSetLastSeen(id, lastSeen);
531 void Client::removeBuffer(BufferId id) {
532 if(!bufferSyncer()) return;
533 bufferSyncer()->requestRemoveBuffer(id);
536 void Client::bufferRemoved(BufferId bufferId) {
537 QModelIndex current = bufferModel()->currentIndex();
538 if(current.data(NetworkModel::BufferIdRole).value<BufferId>() == bufferId) {
539 // select the status buffer if the currently displayed buffer is about to be removed
540 bufferModel()->setCurrentIndex(current.sibling(0,0));
543 networkModel()->removeBuffer(bufferId);
544 if(_buffers.contains(bufferId)) {
545 Buffer *buff = _buffers.take(bufferId);
546 disconnect(buff, 0, this, 0);
551 void Client::bufferRenamed(BufferId bufferId, const QString &newName) {
552 QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
553 if(bufferIndex.isValid()) {
554 networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);