src/client/client.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-08 by the Quassel Project                          *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   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.                                           *
   9  *                                                                         *
  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.                          *
  14  *                                                                         *
  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  ***************************************************************************/
  20
  21 #include "client.h"
  22
  23 #include "bufferinfo.h"
  24 #include "global.h"
  25 #include "identity.h"
  26 #include "ircchannel.h"
  27 #include "ircuser.h"
  28 #include "message.h"
  29 #include "network.h"
  30 #include "networkmodel.h"
  31 #include "buffermodel.h"
  32 #include "quasselui.h"
  33 #include "signalproxy.h"
  34 #include "util.h"
  35
  36 QPointer<Client> Client::instanceptr = 0;
  37 AccountId Client::_currentCoreAccount = 0;
  38
  39 /*** Initialization/destruction ***/
  40
  41 Client *Client::instance() {
  42   if(!instanceptr)
  43     instanceptr = new Client();
  44   return instanceptr;
  45 }
  46
  47 void Client::destroy() {
  48   //delete instanceptr;
  49   instanceptr->deleteLater();
  50 }
  51
  52 void Client::init(AbstractUi *ui) {
  53   instance()->mainUi = ui;
  54   instance()->init();
  55 }
  56
  57 Client::Client(QObject *parent)
  58   : QObject(parent),
  59     socket(0),
  60     _signalProxy(new SignalProxy(SignalProxy::Client, this)),
  61     mainUi(0),
  62     _networkModel(0),
  63     _bufferModel(0),
  64     _connectedToCore(false),
  65     _syncedToCore(false)
  66 {
  67   _monitorBuffer = new Buffer(BufferInfo(), this);
  68 }
  69
  70 Client::~Client() {
  71   disconnectFromCore();
  72 }
  73
  74 void Client::init() {
  75   _currentCoreAccount = 0;
  76   _networkModel = new NetworkModel(this);
  77   connect(this, SIGNAL(bufferUpdated(BufferInfo)),
  78           _networkModel, SLOT(bufferUpdated(BufferInfo)));
  79   connect(this, SIGNAL(networkRemoved(NetworkId)),
  80           _networkModel, SLOT(networkRemoved(NetworkId)));
  81
  82   _bufferModel = new BufferModel(_networkModel);
  83
  84   SignalProxy *p = signalProxy();
  85
  86   p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &)));
  87   p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString)));
  88
  89   p->attachSlot(SIGNAL(backlogData(BufferInfo, const QVariantList &, bool)), this, SLOT(recvBacklogData(BufferInfo, const QVariantList &, bool)));
  90   p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), this, SLOT(updateBufferInfo(BufferInfo)));
  91   p->attachSignal(this, SIGNAL(sendInput(BufferInfo, QString)));
  92   p->attachSignal(this, SIGNAL(requestNetworkStates()));
  93
  94   p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &)), SIGNAL(createIdentity(const Identity &)));
  95   p->attachSignal(this, SIGNAL(requestUpdateIdentity(const Identity &)), SIGNAL(updateIdentity(const Identity &)));
  96   p->attachSignal(this, SIGNAL(requestRemoveIdentity(IdentityId)), SIGNAL(removeIdentity(IdentityId)));
  97   p->attachSlot(SIGNAL(identityCreated(const Identity &)), this, SLOT(coreIdentityCreated(const Identity &)));
  98   p->attachSlot(SIGNAL(identityRemoved(IdentityId)), this, SLOT(coreIdentityRemoved(IdentityId)));
  99
 100   p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &)), SIGNAL(createNetwork(const NetworkInfo &)));
 101   p->attachSignal(this, SIGNAL(requestUpdateNetwork(const NetworkInfo &)), SIGNAL(updateNetwork(const NetworkInfo &)));
 102   p->attachSignal(this, SIGNAL(requestRemoveNetwork(NetworkId)), SIGNAL(removeNetwork(NetworkId)));
 103   p->attachSlot(SIGNAL(networkCreated(NetworkId)), this, SLOT(coreNetworkCreated(NetworkId)));
 104   p->attachSlot(SIGNAL(networkRemoved(NetworkId)), this, SLOT(coreNetworkRemoved(NetworkId)));
 105
 106   connect(p, SIGNAL(disconnected()), this, SLOT(disconnectFromCore()));
 107
 108   //connect(mainUi, SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
 109   connect(mainUi, SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
 110   connect(this, SIGNAL(connected()), mainUi, SLOT(connectedToCore()));
 111   connect(this, SIGNAL(disconnected()), mainUi, SLOT(disconnectedFromCore()));
 112
 113   layoutTimer = new QTimer(this);
 114   layoutTimer->setInterval(0);
 115   layoutTimer->setSingleShot(false);
 116   connect(layoutTimer, SIGNAL(timeout()), this, SLOT(layoutMsg()));
 117
 118 }
 119
 120 /*** public static methods ***/
 121
 122 AccountId Client::currentCoreAccount() {
 123   return _currentCoreAccount;
 124 }
 125
 126 void Client::setCurrentCoreAccount(AccountId id) {
 127   _currentCoreAccount = id;
 128 }
 129
 130 QList<BufferInfo> Client::allBufferInfos() {
 131   QList<BufferInfo> bufferids;
 132   foreach(Buffer *buffer, buffers()) {
 133     bufferids << buffer->bufferInfo();
 134   }
 135   return bufferids;
 136 }
 137
 138 QList<Buffer *> Client::buffers() {
 139   return instance()->_buffers.values();
 140 }
 141
 142
 143 // FIXME remove
 144 Buffer *Client::buffer(BufferId bufferId) {
 145   if(instance()->_buffers.contains(bufferId))
 146     return instance()->_buffers[bufferId];
 147   else
 148     return 0;
 149 }
 150
 151 // FIXME remove
 152 Buffer *Client::buffer(BufferInfo bufferInfo) {
 153   Buffer *buff = buffer(bufferInfo.bufferId());
 154
 155   if(!buff) {
 156     Client *client = Client::instance();
 157     buff = new Buffer(bufferInfo, client);
 158     connect(buff, SIGNAL(destroyed()),
 159             client, SLOT(bufferDestroyed()));
 160     client->_buffers[bufferInfo.bufferId()] = buff;
 161     emit client->bufferUpdated(bufferInfo);
 162   }
 163   Q_ASSERT(buff);
 164   return buff;
 165 }
 166
 167 Buffer *Client::monitorBuffer() {
 168   return instance()->_monitorBuffer;
 169 }
 170
 171
 172 NetworkModel *Client::networkModel() {
 173   return instance()->_networkModel;
 174 }
 175
 176 BufferModel *Client::bufferModel() {
 177   return instance()->_bufferModel;
 178 }
 179
 180 SignalProxy *Client::signalProxy() {
 181   return instance()->_signalProxy;
 182 }
 183
 184 bool Client::isConnected() {
 185   return instance()->_connectedToCore;
 186 }
 187
 188 bool Client::isSynced() {
 189   return instance()->_syncedToCore;
 190 }
 191
 192 /*** Network handling ***/
 193
 194 QList<NetworkId> Client::networkIds() {
 195   return instance()->_networks.keys();
 196 }
 197
 198 const Network * Client::network(NetworkId networkid) {
 199   if(instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
 200   else return 0;
 201 }
 202
 203 void Client::createNetwork(const NetworkInfo &info) {
 204   emit instance()->requestCreateNetwork(info);
 205 }
 206
 207 void Client::updateNetwork(const NetworkInfo &info) {
 208   emit instance()->requestUpdateNetwork(info);
 209 }
 210
 211 void Client::removeNetwork(NetworkId id) {
 212   emit instance()->requestRemoveNetwork(id);
 213 }
 214
 215 void Client::addNetwork(Network *net) {
 216   net->setProxy(signalProxy());
 217   signalProxy()->synchronize(net);
 218   networkModel()->attachNetwork(net);
 219   connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed()));
 220   instance()->_networks[net->networkId()] = net;
 221   emit instance()->networkCreated(net->networkId());
 222 }
 223
 224 void Client::coreNetworkCreated(NetworkId id) {
 225   if(_networks.contains(id)) {
 226     qWarning() << "Creation of already existing network requested!";
 227     return;
 228   }
 229   Network *net = new Network(id, this);
 230   addNetwork(net);
 231 }
 232
 233 void Client::coreNetworkRemoved(NetworkId id) {
 234   if(!_networks.contains(id)) return;
 235   Network *net = _networks.take(id);
 236   emit networkRemoved(net->networkId());
 237   net->deleteLater();
 238 }
 239
 240 /*** Identity handling ***/
 241
 242 QList<IdentityId> Client::identityIds() {
 243   return instance()->_identities.keys();
 244 }
 245
 246 const Identity * Client::identity(IdentityId id) {
 247   if(instance()->_identities.contains(id)) return instance()->_identities[id];
 248   else return 0;
 249 }
 250
 251 void Client::createIdentity(const Identity &id) {
 252   emit instance()->requestCreateIdentity(id);
 253 }
 254
 255 void Client::updateIdentity(const Identity &id) {
 256   emit instance()->requestUpdateIdentity(id);
 257 }
 258
 259 void Client::removeIdentity(IdentityId id) {
 260   emit instance()->requestRemoveIdentity(id);
 261 }
 262
 263 void Client::coreIdentityCreated(const Identity &other) {
 264   if(!_identities.contains(other.id())) {
 265     Identity *identity = new Identity(other, this);
 266     _identities[other.id()] = identity;
 267     identity->setInitialized();
 268     signalProxy()->synchronize(identity);
 269     emit identityCreated(other.id());
 270   } else {
 271     qWarning() << tr("Identity already exists in client!");
 272   }
 273 }
 274
 275 void Client::coreIdentityRemoved(IdentityId id) {
 276   if(_identities.contains(id)) {
 277     emit identityRemoved(id);
 278     Identity *i = _identities.take(id);
 279     i->deleteLater();
 280   }
 281 }
 282
 283 /***  ***/
 284 void Client::userInput(BufferInfo bufferInfo, QString message) {
 285   emit instance()->sendInput(bufferInfo, message);
 286 }
 287
 288 /*** core connection stuff ***/
 289
 290 void Client::setConnectedToCore(QIODevice *sock, AccountId id) {
 291   socket = sock;
 292   signalProxy()->addPeer(socket);
 293   _connectedToCore = true;
 294   setCurrentCoreAccount(id);
 295 }
 296
 297 void Client::setSyncedToCore() {
 298   _syncedToCore = true;
 299   emit connected();
 300   emit coreConnectionStateChanged(true);
 301 }
 302
 303 void Client::disconnectFromCore() {
 304   if(socket) {
 305     socket->close();
 306     socket->deleteLater();
 307   }
 308   _connectedToCore = false;
 309   _syncedToCore = false;
 310   setCurrentCoreAccount(0);
 311   emit disconnected();
 312   emit coreConnectionStateChanged(false);
 313
 314   // Clear internal data. Hopefully nothing relies on it at this point.
 315   _networkModel->clear();
 316
 317   QHash<NetworkId, Network*>::iterator netIter = _networks.begin();
 318   while(netIter != _networks.end()) {
 319     Network *net = netIter.value();
 320     emit networkRemoved(net->networkId());
 321     disconnect(net, SIGNAL(destroyed()), this, 0);
 322     netIter = _networks.erase(netIter);
 323     net->deleteLater();
 324   }
 325   Q_ASSERT(_networks.isEmpty());
 326
 327   QHash<BufferId, Buffer *>::iterator bufferIter =  _buffers.begin();
 328   while(bufferIter != _buffers.end()) {
 329     Buffer *buffer = bufferIter.value();
 330     disconnect(buffer, SIGNAL(destroyed()), this, 0);
 331     bufferIter = _buffers.erase(bufferIter);
 332     buffer->deleteLater();
 333   }
 334   Q_ASSERT(_buffers.isEmpty());
 335
 336   QHash<IdentityId, Identity*>::iterator idIter = _identities.begin();
 337   while(idIter != _identities.end()) {
 338     Identity *id = idIter.value();
 339     emit identityRemoved(id->id());
 340     idIter = _identities.erase(idIter);
 341     id->deleteLater();
 342   }
 343   Q_ASSERT(_identities.isEmpty());
 344
 345   layoutQueue.clear();
 346   layoutTimer->stop();
 347 }
 348
 349 void Client::setCoreConfiguration(const QVariantMap &settings) {
 350   SignalProxy::writeDataToDevice(socket, settings);
 351 }
 352
 353 /*** ***/
 354
 355 void Client::updateBufferInfo(BufferInfo id) {
 356   emit bufferUpdated(id);
 357 }
 358
 359 void Client::bufferDestroyed() {
 360   Buffer *buffer = static_cast<Buffer *>(sender());
 361   QHash<BufferId, Buffer *>::iterator iter = _buffers.begin();
 362   while(iter != _buffers.end()) {
 363     if(iter.value() == buffer) {
 364       iter = _buffers.erase(iter);
 365       break;
 366     }
 367     iter++;
 368   }
 369 }
 370
 371 void Client::networkDestroyed() {
 372   Network *net = static_cast<Network *>(sender());
 373   QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
 374   while(netIter != _networks.end()) {
 375     if(*netIter == net) {
 376       netIter = _networks.erase(netIter);
 377       break;
 378     } else {
 379       netIter++;
 380     }
 381   }
 382 }
 383
 384 void Client::recvMessage(const Message &message) {
 385   Message msg = message;
 386   Buffer *b;
 387
 388   if(msg.type() == Message::Error) {
 389     b = buffer(msg.bufferInfo().bufferId());
 390     if(!b) {
 391       // FIXME: if buffer doesn't exist, forward the message to the status or current buffer
 392       b = buffer(msg.bufferInfo());
 393     }
 394   } else {
 395     b = buffer(msg.bufferInfo());
 396   }
 397
 398   checkForHighlight(msg);
 399   b->appendMsg(msg);
 400   networkModel()->updateBufferActivity(msg);
 401
 402   if(msg.type() == Message::Plain || msg.type() == Message::Notice || msg.type() == Message::Action) {
 403     const Network *net = network(msg.bufferInfo().networkId());
 404     QString networkName = net != 0
 405       ? net->networkName() + ":"
 406       : QString();
 407     QString sender = networkName + msg.bufferInfo().bufferName() + ":" + msg.sender();
 408     Message mmsg = Message(msg.timestamp(), msg.bufferInfo(), msg.type(), msg.text(), sender, msg.flags());
 409     monitorBuffer()->appendMsg(mmsg);
 410   }
 411
 412 }
 413
 414 void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
 415   //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
 416 }
 417
 418 void Client::recvBacklogData(BufferInfo id, QVariantList msgs, bool /*done*/) {
 419   Buffer *b = buffer(id);
 420   foreach(QVariant v, msgs) {
 421     Message msg = v.value<Message>();
 422     checkForHighlight(msg);
 423     b->prependMsg(msg);
 424     networkModel()->updateBufferActivity(msg);
 425     if(!layoutQueue.contains(b)) layoutQueue.append(b);
 426   }
 427   if(layoutQueue.count() && !layoutTimer->isActive()) layoutTimer->start();
 428 }
 429
 430 void Client::layoutMsg() {
 431   if(layoutQueue.count()) {
 432     Buffer *b = layoutQueue.takeFirst();  // TODO make this the current buffer
 433     if(b->layoutMsg())
 434       layoutQueue.append(b);  // Buffer has more messages in its queue --> Round Robin
 435   }
 436
 437   if(!layoutQueue.count())
 438     layoutTimer->stop();
 439 }
 440
 441 AbstractUiMsg *Client::layoutMsg(const Message &msg) {
 442   return instance()->mainUi->layoutMsg(msg);
 443 }
 444
 445 void Client::checkForHighlight(Message &msg) const {
 446   const Network *net = network(msg.bufferInfo().networkId());
 447   if(net && !net->myNick().isEmpty()) {
 448     QRegExp nickRegExp("^(.*\\W)?" + QRegExp::escape(net->myNick()) + "(\\W.*)?$");
 449     if((msg.type() & (Message::Plain | Message::Notice | Message::Action)) && nickRegExp.exactMatch(msg.text()))
 450       msg.setFlags(msg.flags() | Message::Highlight);
 451   }
 452 }