src/uisupport/networkmodelcontroller.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2019 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 "networkmodelcontroller.h"
  22
  23 #include <QComboBox>
  24 #include <QDialogButtonBox>
  25 #include <QGridLayout>
  26 #include <QIcon>
  27 #include <QInputDialog>
  28 #include <QLabel>
  29 #include <QLineEdit>
  30 #include <QMessageBox>
  31 #include <QPushButton>
  32
  33 #include "buffermodel.h"
  34 #include "buffersettings.h"
  35 #include "client.h"
  36 #include "clientidentity.h"
  37 #include "clientignorelistmanager.h"
  38 #include "icon.h"
  39 #include "network.h"
  40 #include "util.h"
  41
  42 NetworkModelController::NetworkModelController(QObject* parent)
  43     : QObject(parent)
  44     , _actionCollection(new ActionCollection(this))
  45 {
  46     connect(_actionCollection, &ActionCollection::actionTriggered, this, &NetworkModelController::actionTriggered);
  47 }
  48
  49 Action* NetworkModelController::registerAction(ActionType type, const QString& text, bool checkable)
  50 {
  51     return registerAction(type, QPixmap(), text, checkable);
  52 }
  53
  54 Action* NetworkModelController::registerAction(ActionType type, const QIcon& icon, const QString& text, bool checkable)
  55 {
  56     Action* act;
  57     if (icon.isNull())
  58         act = new Action(text, this);
  59     else
  60         act = new Action(icon, text, this);
  61
  62     act->setCheckable(checkable);
  63     act->setData(type);
  64
  65     _actionCollection->addAction(QString::number(type, 16), act);
  66     _actionByType[type] = act;
  67     return act;
  68 }
  69
  70 /******** Helper Functions ***********************************************************************/
  71
  72 void NetworkModelController::setIndexList(const QModelIndex& index)
  73 {
  74     _indexList = QList<QModelIndex>() << index;
  75 }
  76
  77 void NetworkModelController::setIndexList(const QList<QModelIndex>& list)
  78 {
  79     _indexList = list;
  80 }
  81
  82 void NetworkModelController::setMessageFilter(MessageFilter* filter)
  83 {
  84     _messageFilter = filter;
  85 }
  86
  87 void NetworkModelController::setContextItem(const QString& contextItem)
  88 {
  89     _contextItem = contextItem;
  90 }
  91
  92 void NetworkModelController::setSlot(ActionSlot slot)
  93 {
  94     _actionSlot = std::move(slot);
  95 }
  96
  97 bool NetworkModelController::checkRequirements(const QModelIndex& index, ItemActiveStates requiredActiveState)
  98 {
  99     if (!index.isValid())
 100         return false;
 101
 102     ItemActiveStates isActive = index.data(NetworkModel::ItemActiveRole).toBool() ? ActiveState : InactiveState;
 103
 104     if (!(isActive & requiredActiveState))
 105         return false;
 106
 107     return true;
 108 }
 109
 110 QString NetworkModelController::nickName(const QModelIndex& index) const
 111 {
 112     auto* ircUser = qobject_cast<IrcUser*>(index.data(NetworkModel::IrcUserRole).value<QObject*>());
 113     if (ircUser)
 114         return ircUser->nick();
 115
 116     BufferInfo bufferInfo = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
 117     if (!bufferInfo.isValid())
 118         return QString();
 119     if (bufferInfo.type() != BufferInfo::QueryBuffer)
 120         return QString();
 121
 122     return bufferInfo.bufferName();  // FIXME this might break with merged queries maybe
 123 }
 124
 125 BufferId NetworkModelController::findQueryBuffer(const QModelIndex& index, const QString& predefinedNick) const
 126 {
 127     NetworkId networkId = index.data(NetworkModel::NetworkIdRole).value<NetworkId>();
 128     if (!networkId.isValid())
 129         return {};
 130
 131     QString nick = predefinedNick.isEmpty() ? nickName(index) : predefinedNick;
 132     if (nick.isEmpty())
 133         return {};
 134
 135     return findQueryBuffer(networkId, nick);
 136 }
 137
 138 BufferId NetworkModelController::findQueryBuffer(NetworkId networkId, const QString& nick) const
 139 {
 140     return Client::networkModel()->bufferId(networkId, nick);
 141 }
 142
 143 void NetworkModelController::removeBuffers(const QModelIndexList& indexList)
 144 {
 145     QList<BufferInfo> inactive;
 146     foreach (QModelIndex index, indexList) {
 147         BufferInfo info = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
 148         if (info.isValid()) {
 149             if (info.type() == BufferInfo::QueryBuffer
 150                 || (info.type() == BufferInfo::ChannelBuffer && !index.data(NetworkModel::ItemActiveRole).toBool()))
 151                 inactive << info;
 152         }
 153     }
 154     QString msg;
 155     if (inactive.count()) {
 156         msg = tr("Do you want to delete the following buffer(s) permanently?", "", inactive.count());
 157         msg += "<ul>";
 158         int count = 0;
 159         foreach (BufferInfo info, inactive) {
 160             if (count < 10) {
 161                 msg += QString("<li>%1</li>").arg(info.bufferName());
 162                 count++;
 163             }
 164             else
 165                 break;
 166         }
 167         msg += "</ul>";
 168         if (count > 9 && inactive.size() - count != 0)
 169             msg += tr("...and <b>%1</b> more<br><br>").arg(inactive.size() - count);
 170         msg += tr(
 171             "<b>Note:</b> This will delete all related data, including all backlog data, from the core's database and cannot be undone.");
 172         if (inactive.count() != indexList.count())
 173             msg += tr("<br>Active channel buffers cannot be deleted, please part the channel first.");
 174
 175         if (QMessageBox::question(nullptr, tr("Remove buffers permanently?"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
 176             == QMessageBox::Yes) {
 177             foreach (BufferInfo info, inactive)
 178                 Client::removeBuffer(info.bufferId());
 179         }
 180     }
 181 }
 182
 183 void NetworkModelController::handleExternalAction(ActionType type, QAction* action)
 184 {
 185     Q_UNUSED(type);
 186     if (_actionSlot) {
 187         _actionSlot(action);
 188     }
 189 }
 190
 191 /******** Handle Actions *************************************************************************/
 192
 193 void NetworkModelController::actionTriggered(QAction* action)
 194 {
 195     ActionType type = (ActionType)action->data().toInt();
 196     if (type > 0) {
 197         if (type & NetworkMask)
 198             handleNetworkAction(type, action);
 199         else if (type & BufferMask)
 200             handleBufferAction(type, action);
 201         else if (type & HideMask)
 202             handleHideAction(type, action);
 203         else if (type & GeneralMask)
 204             handleGeneralAction(type, action);
 205         else if (type & NickMask)
 206             handleNickAction(type, action);
 207         else if (type & ExternalMask)
 208             handleExternalAction(type, action);
 209         else
 210             qWarning() << "NetworkModelController::actionTriggered(): Unhandled action!";
 211     }
 212 }
 213
 214 void NetworkModelController::handleNetworkAction(ActionType type, QAction*)
 215 {
 216     if (type == NetworkConnectAllWithDropdown || type == NetworkDisconnectAllWithDropdown || type == NetworkConnectAll
 217         || type == NetworkDisconnectAll) {
 218         if (type == NetworkConnectAllWithDropdown
 219             && QMessageBox::question(nullptr,
 220                                      tr("Question"),
 221                                      tr("Really Connect to all IRC Networks?"),
 222                                      QMessageBox::Yes | QMessageBox::No,
 223                                      QMessageBox::Yes)
 224                    == QMessageBox::No)
 225             return;
 226         if (type == NetworkDisconnectAllWithDropdown
 227             && QMessageBox::question(nullptr,
 228                                      tr("Question"),
 229                                      tr("Really disconnect from all IRC Networks?"),
 230                                      QMessageBox::Yes | QMessageBox::No,
 231                                      QMessageBox::No)
 232                    == QMessageBox::No)
 233             return;
 234         foreach (NetworkId id, Client::networkIds()) {
 235             const Network* net = Client::network(id);
 236             if ((type == NetworkConnectAllWithDropdown || type == NetworkConnectAll) && net->connectionState() == Network::Disconnected)
 237                 net->requestConnect();
 238             if ((type == NetworkDisconnectAllWithDropdown || type == NetworkDisconnectAll) && net->connectionState() != Network::Disconnected)
 239                 net->requestDisconnect();
 240         }
 241         return;
 242     }
 243
 244     if (!indexList().count())
 245         return;
 246
 247     const Network* network = Client::network(indexList().at(0).data(NetworkModel::NetworkIdRole).value<NetworkId>());
 248     Q_CHECK_PTR(network);
 249     if (!network)
 250         return;
 251
 252     switch (type) {
 253     case NetworkConnect:
 254         network->requestConnect();
 255         break;
 256     case NetworkDisconnect:
 257         network->requestDisconnect();
 258         break;
 259     default:
 260         break;
 261     }
 262 }
 263
 264 void NetworkModelController::handleBufferAction(ActionType type, QAction*)
 265 {
 266     if (type == BufferRemove) {
 267         removeBuffers(indexList());
 268     }
 269     else {
 270         QList<BufferInfo> bufferList;  // create temp list because model indexes might change
 271         foreach (QModelIndex index, indexList()) {
 272             BufferInfo bufferInfo = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
 273             if (bufferInfo.isValid())
 274                 bufferList << bufferInfo;
 275         }
 276
 277         foreach (BufferInfo bufferInfo, bufferList) {
 278             switch (type) {
 279             case BufferJoin:
 280                 Client::userInput(bufferInfo, QString("/JOIN %1").arg(bufferInfo.bufferName()));
 281                 break;
 282             case BufferPart: {
 283                 QString reason = Client::identity(Client::network(bufferInfo.networkId())->identity())->partReason();
 284                 Client::userInput(bufferInfo, QString("/PART %1").arg(reason));
 285                 break;
 286             }
 287             case BufferSwitchTo:
 288                 Client::bufferModel()->switchToBuffer(bufferInfo.bufferId());
 289                 break;
 290             default:
 291                 break;
 292             }
 293         }
 294     }
 295 }
 296
 297 void NetworkModelController::handleHideAction(ActionType type, QAction* action)
 298 {
 299     Q_UNUSED(action)
 300
 301     if (type == HideJoinPartQuit) {
 302         bool anyChecked = NetworkModelController::action(HideJoin)->isChecked();
 303         anyChecked |= NetworkModelController::action(HidePart)->isChecked();
 304         anyChecked |= NetworkModelController::action(HideQuit)->isChecked();
 305
 306         // If any are checked, uncheck them all.
 307         // If none are checked, check them all.
 308         bool newCheckedState = !anyChecked;
 309         NetworkModelController::action(HideJoin)->setChecked(newCheckedState);
 310         NetworkModelController::action(HidePart)->setChecked(newCheckedState);
 311         NetworkModelController::action(HideQuit)->setChecked(newCheckedState);
 312     }
 313
 314     int filter = 0;
 315     if (NetworkModelController::action(HideJoin)->isChecked())
 316         filter |= Message::Join | Message::NetsplitJoin;
 317     if (NetworkModelController::action(HidePart)->isChecked())
 318         filter |= Message::Part;
 319     if (NetworkModelController::action(HideQuit)->isChecked())
 320         filter |= Message::Quit | Message::NetsplitQuit;
 321     if (NetworkModelController::action(HideNick)->isChecked())
 322         filter |= Message::Nick;
 323     if (NetworkModelController::action(HideMode)->isChecked())
 324         filter |= Message::Mode;
 325     if (NetworkModelController::action(HideDayChange)->isChecked())
 326         filter |= Message::DayChange;
 327     if (NetworkModelController::action(HideTopic)->isChecked())
 328         filter |= Message::Topic;
 329
 330     switch (type) {
 331     case HideJoinPartQuit:
 332     case HideJoin:
 333     case HidePart:
 334     case HideQuit:
 335     case HideNick:
 336     case HideMode:
 337     case HideDayChange:
 338     case HideTopic:
 339         if (_messageFilter)
 340             BufferSettings(_messageFilter->idString()).setMessageFilter(filter);
 341         else {
 342             foreach (QModelIndex index, _indexList) {
 343                 BufferId bufferId = index.data(NetworkModel::BufferIdRole).value<BufferId>();
 344                 if (!bufferId.isValid())
 345                     continue;
 346                 BufferSettings(bufferId).setMessageFilter(filter);
 347             }
 348         }
 349         return;
 350     case HideApplyToAll:
 351         BufferSettings().setMessageFilter(filter);
 352         // fallthrough
 353     case HideUseDefaults:
 354         if (_messageFilter)
 355             BufferSettings(_messageFilter->idString()).removeFilter();
 356         else {
 357             foreach (QModelIndex index, _indexList) {
 358                 BufferId bufferId = index.data(NetworkModel::BufferIdRole).value<BufferId>();
 359                 if (!bufferId.isValid())
 360                     continue;
 361                 BufferSettings(bufferId).removeFilter();
 362             }
 363         }
 364         return;
 365     default:
 366         return;
 367     };
 368 }
 369
 370 void NetworkModelController::handleGeneralAction(ActionType type, QAction* action)
 371 {
 372     Q_UNUSED(action)
 373
 374     if (!indexList().count())
 375         return;
 376     NetworkId networkId = indexList().at(0).data(NetworkModel::NetworkIdRole).value<NetworkId>();
 377
 378     switch (type) {
 379     case JoinChannel: {
 380         QString channelName = contextItem();
 381         QString channelPassword;
 382         if (channelName.isEmpty()) {
 383             JoinDlg dlg(indexList().first());
 384             if (dlg.exec() == QDialog::Accepted) {
 385                 channelName = dlg.channelName();
 386                 networkId = dlg.networkId();
 387                 channelPassword = dlg.channelPassword();
 388             }
 389         }
 390         if (!channelName.isEmpty()) {
 391             if (!channelPassword.isEmpty())
 392                 Client::instance()->userInput(BufferInfo::fakeStatusBuffer(networkId),
 393                                               QString("/JOIN %1 %2").arg(channelName).arg(channelPassword));
 394             else
 395                 Client::instance()->userInput(BufferInfo::fakeStatusBuffer(networkId), QString("/JOIN %1").arg(channelName));
 396         }
 397         break;
 398     }
 399     case ShowChannelList:
 400         if (networkId.isValid()) {
 401             // Don't immediately list channels, allowing customization of filter first
 402             emit showChannelList(networkId, {}, false);
 403         }
 404         break;
 405     case ShowNetworkConfig:
 406         if (networkId.isValid())
 407             emit showNetworkConfig(networkId);
 408         break;
 409     case ShowIgnoreList:
 410         if (networkId.isValid())
 411             emit showIgnoreList(QString());
 412         break;
 413     default:
 414         break;
 415     }
 416 }
 417
 418 void NetworkModelController::handleNickAction(ActionType type, QAction* action)
 419 {
 420     foreach (QModelIndex index, indexList()) {
 421         NetworkId networkId = index.data(NetworkModel::NetworkIdRole).value<NetworkId>();
 422         if (!networkId.isValid())
 423             continue;
 424         QString nick = nickName(index);
 425         if (nick.isEmpty())
 426             continue;
 427         BufferInfo bufferInfo = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
 428         if (!bufferInfo.isValid())
 429             continue;
 430
 431         switch (type) {
 432         case NickWhois:
 433             Client::userInput(bufferInfo, QString("/WHOIS %1 %1").arg(nick));
 434             break;
 435         case NickCtcpVersion:
 436             Client::userInput(bufferInfo, QString("/CTCP %1 VERSION").arg(nick));
 437             break;
 438         case NickCtcpPing:
 439             Client::userInput(bufferInfo, QString("/CTCP %1 PING").arg(nick));
 440             break;
 441         case NickCtcpTime:
 442             Client::userInput(bufferInfo, QString("/CTCP %1 TIME").arg(nick));
 443             break;
 444         case NickCtcpClientinfo:
 445             Client::userInput(bufferInfo, QString("/CTCP %1 CLIENTINFO").arg(nick));
 446             break;
 447         case NickOp:
 448             Client::userInput(bufferInfo, QString("/OP %1").arg(nick));
 449             break;
 450         case NickDeop:
 451             Client::userInput(bufferInfo, QString("/DEOP %1").arg(nick));
 452             break;
 453         case NickHalfop:
 454             Client::userInput(bufferInfo, QString("/HALFOP %1").arg(nick));
 455             break;
 456         case NickDehalfop:
 457             Client::userInput(bufferInfo, QString("/DEHALFOP %1").arg(nick));
 458             break;
 459         case NickVoice:
 460             Client::userInput(bufferInfo, QString("/VOICE %1").arg(nick));
 461             break;
 462         case NickDevoice:
 463             Client::userInput(bufferInfo, QString("/DEVOICE %1").arg(nick));
 464             break;
 465         case NickKick:
 466             Client::userInput(bufferInfo, QString("/KICK %1").arg(nick));
 467             break;
 468         case NickBan:
 469             Client::userInput(bufferInfo, QString("/BAN %1").arg(nick));
 470             break;
 471         case NickKickBan:
 472             Client::userInput(bufferInfo, QString("/BAN %1").arg(nick));
 473             Client::userInput(bufferInfo, QString("/KICK %1").arg(nick));
 474             break;
 475         case NickSwitchTo:
 476         case NickQuery:
 477             Client::bufferModel()->switchToOrStartQuery(networkId, nick);
 478             break;
 479         case NickIgnoreUser: {
 480             auto* ircUser = qobject_cast<IrcUser*>(index.data(NetworkModel::IrcUserRole).value<QObject*>());
 481             if (!ircUser)
 482                 break;
 483             Client::ignoreListManager()->requestAddIgnoreListItem(IgnoreListManager::SenderIgnore,
 484                                                                   action->property("ignoreRule").toString(),
 485                                                                   false,
 486                                                                   IgnoreListManager::SoftStrictness,
 487                                                                   IgnoreListManager::NetworkScope,
 488                                                                   ircUser->network()->networkName(),
 489                                                                   true);
 490             break;
 491         }
 492         case NickIgnoreHost: {
 493             auto* ircUser = qobject_cast<IrcUser*>(index.data(NetworkModel::IrcUserRole).value<QObject*>());
 494             if (!ircUser)
 495                 break;
 496             Client::ignoreListManager()->requestAddIgnoreListItem(IgnoreListManager::SenderIgnore,
 497                                                                   action->property("ignoreRule").toString(),
 498                                                                   false,
 499                                                                   IgnoreListManager::SoftStrictness,
 500                                                                   IgnoreListManager::NetworkScope,
 501                                                                   ircUser->network()->networkName(),
 502                                                                   true);
 503             break;
 504         }
 505         case NickIgnoreDomain: {
 506             auto* ircUser = qobject_cast<IrcUser*>(index.data(NetworkModel::IrcUserRole).value<QObject*>());
 507             if (!ircUser)
 508                 break;
 509             Client::ignoreListManager()->requestAddIgnoreListItem(IgnoreListManager::SenderIgnore,
 510                                                                   action->property("ignoreRule").toString(),
 511                                                                   false,
 512                                                                   IgnoreListManager::SoftStrictness,
 513                                                                   IgnoreListManager::NetworkScope,
 514                                                                   ircUser->network()->networkName(),
 515                                                                   true);
 516             break;
 517         }
 518         case NickIgnoreCustom:
 519             // forward that to mainwin since we can access the settingspage only from there
 520             emit showIgnoreList(action->property("ignoreRule").toString());
 521             break;
 522         case NickIgnoreToggleEnabled0:
 523         case NickIgnoreToggleEnabled1:
 524         case NickIgnoreToggleEnabled2:
 525         case NickIgnoreToggleEnabled3:
 526         case NickIgnoreToggleEnabled4:
 527             Client::ignoreListManager()->requestToggleIgnoreRule(action->property("ignoreRule").toString());
 528             break;
 529         default:
 530             qWarning() << "Unhandled nick action";
 531         }
 532     }
 533 }
 534
 535 /***************************************************************************************************************
 536  * JoinDlg
 537  ***************************************************************************************************************/
 538
 539 NetworkModelController::JoinDlg::JoinDlg(const QModelIndex& index, QWidget* parent)
 540     : QDialog(parent)
 541 {
 542     setWindowIcon(icon::get("irc-join-channel"));
 543     setWindowTitle(tr("Join Channel"));
 544
 545     auto* layout = new QGridLayout(this);
 546     layout->addWidget(new QLabel(tr("Network:")), 0, 0);
 547     layout->addWidget(networks = new QComboBox, 0, 1);
 548     layout->addWidget(new QLabel(tr("Channel:")), 1, 0);
 549     layout->addWidget(channel = new QLineEdit, 1, 1);
 550     layout->addWidget(new QLabel(tr("Password:")), 2, 0);
 551     layout->addWidget(password = new QLineEdit, 2, 1);
 552     layout->addWidget(buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel), 3, 0, 1, 2);
 553     setLayout(layout);
 554
 555     channel->setFocus();
 556     buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 557     networks->setInsertPolicy(QComboBox::InsertAlphabetically);
 558     password->setEchoMode(QLineEdit::Password);
 559
 560     connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
 561     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 562     connect(channel, &QLineEdit::textChanged, this, &JoinDlg::on_channel_textChanged);
 563
 564     foreach (NetworkId id, Client::networkIds()) {
 565         const Network* net = Client::network(id);
 566         if (net->isConnected()) {
 567             networks->addItem(net->networkName(), QVariant::fromValue(id));
 568         }
 569     }
 570
 571     if (index.isValid()) {
 572         NetworkId networkId = index.data(NetworkModel::NetworkIdRole).value<NetworkId>();
 573         if (networkId.isValid()) {
 574             networks->setCurrentIndex(networks->findText(Client::network(networkId)->networkName()));
 575             if (index.data(NetworkModel::BufferTypeRole) == BufferInfo::ChannelBuffer && !index.data(NetworkModel::ItemActiveRole).toBool())
 576                 channel->setText(index.data(Qt::DisplayRole).toString());
 577         }
 578     }
 579 }
 580
 581 NetworkId NetworkModelController::JoinDlg::networkId() const
 582 {
 583     return networks->itemData(networks->currentIndex()).value<NetworkId>();
 584 }
 585
 586 QString NetworkModelController::JoinDlg::channelName() const
 587 {
 588     return channel->text();
 589 }
 590
 591 QString NetworkModelController::JoinDlg::channelPassword() const
 592 {
 593     return password->text();
 594 }
 595
 596 void NetworkModelController::JoinDlg::on_channel_textChanged(const QString& text)
 597 {
 598     buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!text.isEmpty());
 599 }