src/client/client.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2018 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  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include "client.h"
  22
  23 #include "abstractmessageprocessor.h"
  24 #include "abstractui.h"
  25 #include "bufferinfo.h"
  26 #include "buffermodel.h"
  27 #include "buffersettings.h"
  28 #include "buffersyncer.h"
  29 #include "bufferviewconfig.h"
  30 #include "bufferviewoverlay.h"
  31 #include "clientaliasmanager.h"
  32 #include "clientbacklogmanager.h"
  33 #include "clientbufferviewmanager.h"
  34 #include "clientirclisthelper.h"
  35 #include "clientidentity.h"
  36 #include "clientignorelistmanager.h"
  37 #include "clienttransfermanager.h"
  38 #include "clientuserinputhandler.h"
  39 #include "coreaccountmodel.h"
  40 #include "coreconnection.h"
  41 #include "dccconfig.h"
  42 #include "ircchannel.h"
  43 #include "ircuser.h"
  44 #include "message.h"
  45 #include "messagemodel.h"
  46 #include "network.h"
  47 #include "networkconfig.h"
  48 #include "networkmodel.h"
  49 #include "quassel.h"
  50 #include "signalproxy.h"
  51 #include "transfermodel.h"
  52 #include "util.h"
  53 #include "clientauthhandler.h"
  54
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57
  58 QPointer<Client> Client::instanceptr = 0;
  59
  60 /*** Initialization/destruction ***/
  61
  62 bool Client::instanceExists()
  63 {
  64     return instanceptr;
  65 }
  66
  67
  68 Client *Client::instance()
  69 {
  70     if (!instanceptr)
  71         instanceptr = new Client();
  72     return instanceptr;
  73 }
  74
  75
  76 void Client::destroy()
  77 {
  78     if (instanceptr) {
  79         delete instanceptr->mainUi();
  80         instanceptr->deleteLater();
  81         instanceptr = 0;
  82     }
  83 }
  84
  85
  86 void Client::init(AbstractUi *ui)
  87 {
  88     instance()->_mainUi = ui;
  89     instance()->init();
  90 }
  91
  92
  93 Client::Client(QObject *parent)
  94     : QObject(parent),
  95     _signalProxy(new SignalProxy(SignalProxy::Client, this)),
  96     _mainUi(0),
  97     _networkModel(0),
  98     _bufferModel(0),
  99     _bufferSyncer(0),
 100     _aliasManager(0),
 101     _backlogManager(new ClientBacklogManager(this)),
 102     _bufferViewManager(0),
 103     _bufferViewOverlay(new BufferViewOverlay(this)),
 104     _dccConfig(0),
 105     _ircListHelper(new ClientIrcListHelper(this)),
 106     _inputHandler(0),
 107     _networkConfig(0),
 108     _ignoreListManager(0),
 109     _highlightRuleManager(0),
 110     _transferManager(0),
 111     _transferModel(new TransferModel(this)),
 112     _messageModel(0),
 113     _messageProcessor(0),
 114     _coreAccountModel(new CoreAccountModel(this)),
 115     _coreConnection(new CoreConnection(this)),
 116     _connected(false),
 117     _debugLog(&_debugLogBuffer)
 118 {
 119     _signalProxy->synchronize(_ircListHelper);
 120 }
 121
 122
 123 Client::~Client()
 124 {
 125     disconnectFromCore();
 126 }
 127
 128
 129 void Client::init()
 130 {
 131     _networkModel = new NetworkModel(this);
 132
 133     connect(this, SIGNAL(networkRemoved(NetworkId)),
 134         _networkModel, SLOT(networkRemoved(NetworkId)));
 135
 136     _bufferModel = new BufferModel(_networkModel);
 137     _messageModel = mainUi()->createMessageModel(this);
 138     _messageProcessor = mainUi()->createMessageProcessor(this);
 139     _inputHandler = new ClientUserInputHandler(this);
 140
 141     SignalProxy *p = signalProxy();
 142
 143     p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &)));
 144     p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString)));
 145
 146     p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), _networkModel, SLOT(bufferUpdated(BufferInfo)));
 147     p->attachSignal(inputHandler(), SIGNAL(sendInput(BufferInfo, QString)));
 148     p->attachSignal(this, SIGNAL(requestNetworkStates()));
 149
 150     p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &, const QVariantMap &)), SIGNAL(createIdentity(const Identity &, const QVariantMap &)));
 151     p->attachSignal(this, SIGNAL(requestRemoveIdentity(IdentityId)), SIGNAL(removeIdentity(IdentityId)));
 152     p->attachSlot(SIGNAL(identityCreated(const Identity &)), this, SLOT(coreIdentityCreated(const Identity &)));
 153     p->attachSlot(SIGNAL(identityRemoved(IdentityId)), this, SLOT(coreIdentityRemoved(IdentityId)));
 154
 155     p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &, const QStringList &)), SIGNAL(createNetwork(const NetworkInfo &, const QStringList &)));
 156     p->attachSignal(this, SIGNAL(requestRemoveNetwork(NetworkId)), SIGNAL(removeNetwork(NetworkId)));
 157     p->attachSlot(SIGNAL(networkCreated(NetworkId)), this, SLOT(coreNetworkCreated(NetworkId)));
 158     p->attachSlot(SIGNAL(networkRemoved(NetworkId)), this, SLOT(coreNetworkRemoved(NetworkId)));
 159
 160     p->attachSignal(this, SIGNAL(requestPasswordChange(PeerPtr,QString,QString,QString)), SIGNAL(changePassword(PeerPtr,QString,QString,QString)));
 161     p->attachSlot(SIGNAL(passwordChanged(PeerPtr,bool)), this, SLOT(corePasswordChanged(PeerPtr,bool)));
 162
 163     p->attachSignal(this, SIGNAL(requestKickClient(int)), SIGNAL(kickClient(int)));
 164     p->attachSlot(SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
 165
 166     //connect(mainUi(), SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
 167     connect(mainUi(), SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
 168     connect(this, SIGNAL(connected()), mainUi(), SLOT(connectedToCore()));
 169     connect(this, SIGNAL(disconnected()), mainUi(), SLOT(disconnectedFromCore()));
 170
 171     // attach backlog manager
 172     p->synchronize(backlogManager());
 173     connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int)));
 174
 175     coreAccountModel()->load();
 176
 177     connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState)));
 178     coreConnection()->init();
 179 }
 180
 181
 182 /*** public static methods ***/
 183
 184 AbstractUi *Client::mainUi()
 185 {
 186     return instance()->_mainUi;
 187 }
 188
 189
 190 bool Client::isCoreFeatureEnabled(Quassel::Feature feature)
 191 {
 192     return coreConnection()->peer() ? coreConnection()->peer()->hasFeature(feature) : false;
 193 }
 194
 195
 196 bool Client::isConnected()
 197 {
 198     return instance()->_connected;
 199 }
 200
 201
 202 bool Client::internalCore()
 203 {
 204     return currentCoreAccount().isInternal();
 205 }
 206
 207
 208 /*** Network handling ***/
 209
 210 QList<NetworkId> Client::networkIds()
 211 {
 212     return instance()->_networks.keys();
 213 }
 214
 215
 216 const Network *Client::network(NetworkId networkid)
 217 {
 218     if (instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
 219     else return 0;
 220 }
 221
 222
 223 void Client::createNetwork(const NetworkInfo &info, const QStringList &persistentChannels)
 224 {
 225     emit instance()->requestCreateNetwork(info, persistentChannels);
 226 }
 227
 228
 229 void Client::removeNetwork(NetworkId id)
 230 {
 231     emit instance()->requestRemoveNetwork(id);
 232 }
 233
 234
 235 void Client::updateNetwork(const NetworkInfo &info)
 236 {
 237     Network *netptr = instance()->_networks.value(info.networkId, 0);
 238     if (!netptr) {
 239         qWarning() << "Update for unknown network requested:" << info;
 240         return;
 241     }
 242     netptr->requestSetNetworkInfo(info);
 243 }
 244
 245
 246 void Client::addNetwork(Network *net)
 247 {
 248     net->setProxy(signalProxy());
 249     signalProxy()->synchronize(net);
 250     networkModel()->attachNetwork(net);
 251     connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed()));
 252     instance()->_networks[net->networkId()] = net;
 253     emit instance()->networkCreated(net->networkId());
 254 }
 255
 256
 257 void Client::coreNetworkCreated(NetworkId id)
 258 {
 259     if (_networks.contains(id)) {
 260         qWarning() << "Creation of already existing network requested!";
 261         return;
 262     }
 263     Network *net = new Network(id, this);
 264     addNetwork(net);
 265 }
 266
 267
 268 void Client::coreNetworkRemoved(NetworkId id)
 269 {
 270     if (!_networks.contains(id))
 271         return;
 272     Network *net = _networks.take(id);
 273     emit networkRemoved(net->networkId());
 274     net->deleteLater();
 275 }
 276
 277
 278 /*** Identity handling ***/
 279
 280 QList<IdentityId> Client::identityIds()
 281 {
 282     return instance()->_identities.keys();
 283 }
 284
 285
 286 const Identity *Client::identity(IdentityId id)
 287 {
 288     if (instance()->_identities.contains(id)) return instance()->_identities[id];
 289     else return 0;
 290 }
 291
 292
 293 void Client::createIdentity(const CertIdentity &id)
 294 {
 295     QVariantMap additional;
 296 #ifdef HAVE_SSL
 297     additional["KeyPem"] = id.sslKey().toPem();
 298     additional["CertPem"] = id.sslCert().toPem();
 299 #endif
 300     emit instance()->requestCreateIdentity(id, additional);
 301 }
 302
 303
 304 void Client::updateIdentity(IdentityId id, const QVariantMap &ser)
 305 {
 306     Identity *idptr = instance()->_identities.value(id, 0);
 307     if (!idptr) {
 308         qWarning() << "Update for unknown identity requested:" << id;
 309         return;
 310     }
 311     idptr->requestUpdate(ser);
 312 }
 313
 314
 315 void Client::removeIdentity(IdentityId id)
 316 {
 317     emit instance()->requestRemoveIdentity(id);
 318 }
 319
 320
 321 void Client::coreIdentityCreated(const Identity &other)
 322 {
 323     if (!_identities.contains(other.id())) {
 324         Identity *identity = new Identity(other, this);
 325         _identities[other.id()] = identity;
 326         identity->setInitialized();
 327         signalProxy()->synchronize(identity);
 328         emit identityCreated(other.id());
 329     }
 330     else {
 331         qWarning() << tr("Identity already exists in client!");
 332     }
 333 }
 334
 335
 336 void Client::coreIdentityRemoved(IdentityId id)
 337 {
 338     if (_identities.contains(id)) {
 339         emit identityRemoved(id);
 340         Identity *i = _identities.take(id);
 341         i->deleteLater();
 342     }
 343 }
 344
 345
 346 /*** User input handling ***/
 347
 348 void Client::userInput(const BufferInfo &bufferInfo, const QString &message)
 349 {
 350     // we need to make sure that AliasManager is ready before processing input
 351     if (aliasManager() && aliasManager()->isInitialized())
 352         inputHandler()->handleUserInput(bufferInfo, message);
 353     else
 354         instance()->_userInputBuffer.append(qMakePair(bufferInfo, message));
 355 }
 356
 357
 358 void Client::sendBufferedUserInput()
 359 {
 360     for (int i = 0; i < _userInputBuffer.count(); i++)
 361         userInput(_userInputBuffer.at(i).first, _userInputBuffer.at(i).second);
 362
 363     _userInputBuffer.clear();
 364 }
 365
 366
 367 /*** core connection stuff ***/
 368
 369 void Client::connectionStateChanged(CoreConnection::ConnectionState state)
 370 {
 371     switch (state) {
 372     case CoreConnection::Disconnected:
 373         setDisconnectedFromCore();
 374         break;
 375     case CoreConnection::Synchronized:
 376         setSyncedToCore();
 377         break;
 378     default:
 379         break;
 380     }
 381 }
 382
 383
 384 void Client::setSyncedToCore()
 385 {
 386     // create buffersyncer
 387     Q_ASSERT(!_bufferSyncer);
 388     _bufferSyncer = new BufferSyncer(this);
 389     connect(bufferSyncer(), SIGNAL(lastSeenMsgSet(BufferId, MsgId)), _networkModel, SLOT(setLastSeenMsgId(BufferId, MsgId)));
 390     connect(bufferSyncer(), SIGNAL(markerLineSet(BufferId, MsgId)), _networkModel, SLOT(setMarkerLineMsgId(BufferId, MsgId)));
 391     connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId)));
 392     connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString)));
 393     connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), this, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
 394     connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), _messageModel, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
 395     connect(bufferSyncer(), SIGNAL(bufferMarkedAsRead(BufferId)), SIGNAL(bufferMarkedAsRead(BufferId)));
 396     connect(bufferSyncer(), SIGNAL(bufferActivityChanged(BufferId, const Message::Types)), _networkModel, SLOT(bufferActivityChanged(BufferId, const Message::Types)));
 397     connect(bufferSyncer(), SIGNAL(highlightCountChanged(BufferId, int)), _networkModel, SLOT(highlightCountChanged(BufferId, int)));
 398     connect(networkModel(), SIGNAL(requestSetLastSeenMsg(BufferId, MsgId)), bufferSyncer(), SLOT(requestSetLastSeenMsg(BufferId, const MsgId &)));
 399
 400     SignalProxy *p = signalProxy();
 401     p->synchronize(bufferSyncer());
 402
 403     // create a new BufferViewManager
 404     Q_ASSERT(!_bufferViewManager);
 405     _bufferViewManager = new ClientBufferViewManager(p, this);
 406     connect(_bufferViewManager, SIGNAL(initDone()), _bufferViewOverlay, SLOT(restore()));
 407
 408     // create AliasManager
 409     Q_ASSERT(!_aliasManager);
 410     _aliasManager = new ClientAliasManager(this);
 411     connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput()));
 412     p->synchronize(aliasManager());
 413
 414     // create NetworkConfig
 415     Q_ASSERT(!_networkConfig);
 416     _networkConfig = new NetworkConfig("GlobalNetworkConfig", this);
 417     p->synchronize(networkConfig());
 418
 419     // create IgnoreListManager
 420     Q_ASSERT(!_ignoreListManager);
 421     _ignoreListManager = new ClientIgnoreListManager(this);
 422     p->synchronize(ignoreListManager());
 423
 424     // create Core-Side HighlightRuleManager
 425     Q_ASSERT(!_highlightRuleManager);
 426     _highlightRuleManager = new HighlightRuleManager(this);
 427     p->synchronize(highlightRuleManager());
 428
 429 /*  not ready yet
 430     // create TransferManager and DccConfig if core supports them
 431     Q_ASSERT(!_dccConfig);
 432     Q_ASSERT(!_transferManager);
 433     if (isCoreFeatureEnabled(Quassel::Feature::DccFileTransfer)) {
 434         _dccConfig = new DccConfig(this);
 435         p->synchronize(dccConfig());
 436         _transferManager = new ClientTransferManager(this);
 437         _transferModel->setManager(_transferManager);
 438         p->synchronize(transferManager());
 439     }
 440 */
 441
 442     // trigger backlog request once all active bufferviews are initialized
 443     connect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
 444
 445     _connected = true;
 446     emit connected();
 447     emit coreConnectionStateChanged(true);
 448 }
 449
 450 void Client::finishConnectionInitialization()
 451 {
 452     // usually it _should_ take longer until the bufferViews are initialized, so that's what
 453     // triggers this slot. But we have to make sure that we know all buffers yet.
 454     // so we check the BufferSyncer and in case it wasn't initialized we wait for that instead
 455     if (!bufferSyncer()->isInitialized()) {
 456         disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
 457         connect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
 458         return;
 459     }
 460     disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
 461     disconnect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization()));
 462
 463     requestInitialBacklog();
 464     if (isCoreFeatureEnabled(Quassel::Feature::BufferActivitySync)) {
 465         bufferSyncer()->markActivitiesChanged();
 466         bufferSyncer()->markHighlightCountsChanged();
 467     }
 468 }
 469
 470
 471 void Client::requestInitialBacklog()
 472 {
 473     _backlogManager->requestInitialBacklog();
 474 }
 475
 476
 477 void Client::disconnectFromCore()
 478 {
 479     if (!coreConnection()->isConnected())
 480         return;
 481
 482     coreConnection()->disconnectFromCore();
 483 }
 484
 485
 486 void Client::setDisconnectedFromCore()
 487 {
 488     _connected = false;
 489
 490     emit disconnected();
 491     emit coreConnectionStateChanged(false);
 492
 493     backlogManager()->reset();
 494     messageProcessor()->reset();
 495
 496     // Clear internal data. Hopefully nothing relies on it at this point.
 497
 498     if (_bufferSyncer) {
 499         _bufferSyncer->deleteLater();
 500         _bufferSyncer = 0;
 501     }
 502
 503     if (_bufferViewManager) {
 504         _bufferViewManager->deleteLater();
 505         _bufferViewManager = 0;
 506     }
 507
 508     _bufferViewOverlay->reset();
 509
 510     if (_aliasManager) {
 511         _aliasManager->deleteLater();
 512         _aliasManager = 0;
 513     }
 514
 515     if (_ignoreListManager) {
 516         _ignoreListManager->deleteLater();
 517         _ignoreListManager = 0;
 518     }
 519
 520     if (_highlightRuleManager) {
 521         _highlightRuleManager->deleteLater();
 522         _highlightRuleManager = nullptr;
 523     }
 524
 525     if (_transferManager) {
 526         _transferModel->setManager(nullptr);
 527         _transferManager->deleteLater();
 528         _transferManager = nullptr;
 529     }
 530
 531     if (_dccConfig) {
 532         _dccConfig->deleteLater();
 533         _dccConfig = nullptr;
 534     }
 535
 536     // we probably don't want to save pending input for reconnect
 537     _userInputBuffer.clear();
 538
 539     _messageModel->clear();
 540     _networkModel->clear();
 541
 542     QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
 543     while (netIter != _networks.end()) {
 544         Network *net = netIter.value();
 545         emit networkRemoved(net->networkId());
 546         disconnect(net, SIGNAL(destroyed()), this, 0);
 547         netIter = _networks.erase(netIter);
 548         net->deleteLater();
 549     }
 550     Q_ASSERT(_networks.isEmpty());
 551
 552     QHash<IdentityId, Identity *>::iterator idIter = _identities.begin();
 553     while (idIter != _identities.end()) {
 554         emit identityRemoved(idIter.key());
 555         Identity *id = idIter.value();
 556         idIter = _identities.erase(idIter);
 557         id->deleteLater();
 558     }
 559     Q_ASSERT(_identities.isEmpty());
 560
 561     if (_networkConfig) {
 562         _networkConfig->deleteLater();
 563         _networkConfig = 0;
 564     }
 565 }
 566
 567
 568 /*** ***/
 569
 570 void Client::networkDestroyed()
 571 {
 572     Network *net = static_cast<Network *>(sender());
 573     QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
 574     while (netIter != _networks.end()) {
 575         if (*netIter == net) {
 576             netIter = _networks.erase(netIter);
 577             break;
 578         }
 579         else {
 580             ++netIter;
 581         }
 582     }
 583 }
 584
 585
 586 // Hmm... we never used this...
 587 void Client::recvStatusMsg(QString /*net*/, QString /*msg*/)
 588 {
 589     //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
 590 }
 591
 592
 593 void Client::recvMessage(const Message &msg)
 594 {
 595     Message msg_ = msg;
 596     messageProcessor()->process(msg_);
 597 }
 598
 599
 600 void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId)
 601 {
 602     if (bufferSyncer())
 603         bufferSyncer()->requestSetLastSeenMsg(id, msgId);
 604 }
 605
 606
 607 void Client::setMarkerLine(BufferId id, const MsgId &msgId)
 608 {
 609     if (bufferSyncer())
 610         bufferSyncer()->requestSetMarkerLine(id, msgId);
 611 }
 612
 613
 614 MsgId Client::markerLine(BufferId id)
 615 {
 616     if (id.isValid() && networkModel())
 617         return networkModel()->markerLineMsgId(id);
 618     return MsgId();
 619 }
 620
 621
 622 void Client::removeBuffer(BufferId id)
 623 {
 624     if (!bufferSyncer()) return;
 625     bufferSyncer()->requestRemoveBuffer(id);
 626 }
 627
 628
 629 void Client::renameBuffer(BufferId bufferId, const QString &newName)
 630 {
 631     if (!bufferSyncer())
 632         return;
 633     bufferSyncer()->requestRenameBuffer(bufferId, newName);
 634 }
 635
 636
 637 void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2)
 638 {
 639     if (!bufferSyncer())
 640         return;
 641     bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2);
 642 }
 643
 644
 645 void Client::purgeKnownBufferIds()
 646 {
 647     if (!bufferSyncer())
 648         return;
 649     bufferSyncer()->requestPurgeBufferIds();
 650 }
 651
 652
 653 void Client::bufferRemoved(BufferId bufferId)
 654 {
 655     // select a sane buffer (status buffer)
 656     /* we have to manually select a buffer because otherwise inconsitent changes
 657      * to the model might occur:
 658      * the result of a buffer removal triggers a change in the selection model.
 659      * the newly selected buffer might be a channel that hasn't been selected yet
 660      * and a new nickview would be created (which never heard of the "rowsAboutToBeRemoved").
 661      * this new view (and/or) its sort filter will then only receive a "rowsRemoved" signal.
 662      */
 663     QModelIndex current = bufferModel()->currentIndex();
 664     if (current.data(NetworkModel::BufferIdRole).value<BufferId>() == bufferId) {
 665         bufferModel()->setCurrentIndex(current.sibling(0, 0));
 666     }
 667
 668     // and remove it from the model
 669     networkModel()->removeBuffer(bufferId);
 670 }
 671
 672
 673 void Client::bufferRenamed(BufferId bufferId, const QString &newName)
 674 {
 675     QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
 676     if (bufferIndex.isValid()) {
 677         networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);
 678     }
 679 }
 680
 681
 682 void Client::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2)
 683 {
 684     QModelIndex idx = networkModel()->bufferIndex(bufferId1);
 685     bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(idx));
 686     networkModel()->removeBuffer(bufferId2);
 687 }
 688
 689
 690 void Client::markBufferAsRead(BufferId id)
 691 {
 692     if (bufferSyncer() && id.isValid())
 693         bufferSyncer()->requestMarkBufferAsRead(id);
 694 }
 695
 696
 697 void Client::changePassword(const QString &oldPassword, const QString &newPassword) {
 698     CoreAccount account = currentCoreAccount();
 699     account.setPassword(newPassword);
 700     coreAccountModel()->createOrUpdateAccount(account);
 701     emit instance()->requestPasswordChange(nullptr, account.user(), oldPassword, newPassword);
 702 }
 703
 704
 705 void Client::kickClient(int peerId)
 706 {
 707     emit instance()->requestKickClient(peerId);
 708 }
 709
 710
 711 void Client::corePasswordChanged(PeerPtr, bool success)
 712 {
 713     if (success)
 714         coreAccountModel()->save();
 715     emit passwordChanged(success);
 716 }
 717
 718
 719 #if QT_VERSION < 0x050000
 720 void Client::logMessage(QtMsgType type, const char *msg)
 721 {
 722     fprintf(stderr, "%s\n", msg);
 723     fflush(stderr);
 724     if (type == QtFatalMsg) {
 725         Quassel::logFatalMessage(msg);
 726     }
 727     else {
 728         QString msgString = QString("%1\n").arg(msg);
 729
 730         //Check to see if there is an instance around, else we risk recursions
 731         //when calling instance() and creating new ones.
 732         if (!instanceExists())
 733             return;
 734
 735         instance()->_debugLog << msgString;
 736         emit instance()->logUpdated(msgString);
 737     }
 738 }
 739 #else
 740 void Client::logMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 741 {
 742     Q_UNUSED(context);
 743
 744     fprintf(stderr, "%s\n", msg.toLocal8Bit().constData());
 745     fflush(stderr);
 746     if (type == QtFatalMsg) {
 747         Quassel::logFatalMessage(msg.toLocal8Bit().constData());
 748     }
 749     else {
 750         QString msgString = QString("%1\n").arg(msg);
 751
 752         //Check to see if there is an instance around, else we risk recursions
 753         //when calling instance() and creating new ones.
 754         if (!instanceExists())
 755             return;
 756
 757         instance()->_debugLog << msgString;
 758         emit instance()->logUpdated(msgString);
 759     }
 760 }
 761 #endif