src/client/client.cpp

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