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