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