src/uisupport/contextmenuactionprovider.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 <QIcon>
  22 #include <QInputDialog>
  23 #include <QMenu>
  24 #include <QMessageBox>
  25 #include <QMap>
  26
  27 #include "contextmenuactionprovider.h"
  28
  29 #include "buffermodel.h"
  30 #include "buffersettings.h"
  31 #include "clientidentity.h"
  32 #include "network.h"
  33 #include "util.h"
  34 #include "client.h"
  35 #include "clientignorelistmanager.h"
  36
  37 ContextMenuActionProvider::ContextMenuActionProvider(QObject *parent) : NetworkModelController(parent)
  38 {
  39     registerAction(NetworkConnect, QIcon::fromTheme("network-connect"), tr("Connect"));
  40     registerAction(NetworkDisconnect, QIcon::fromTheme("network-disconnect"), tr("Disconnect"));
  41
  42     registerAction(BufferJoin, QIcon::fromTheme("irc-join-channel"), tr("Join"));
  43     registerAction(BufferPart, QIcon::fromTheme("irc-close-channel"), tr("Part"));
  44     registerAction(BufferRemove, tr("Delete Chat(s)..."));
  45     registerAction(BufferSwitchTo, tr("Go to Chat"));
  46
  47     registerAction(HideJoinPartQuit, tr("Joins/Parts/Quits"));
  48     registerAction(HideJoin, tr("Joins"), true);
  49     registerAction(HidePart, tr("Parts"), true);
  50     registerAction(HideQuit, tr("Quits"), true);
  51     registerAction(HideNick, tr("Nick Changes"), true);
  52     registerAction(HideMode, tr("Mode Changes"), true);
  53     registerAction(HideDayChange, tr("Day Changes"), true);
  54     registerAction(HideTopic, tr("Topic Changes"), true);
  55     registerAction(HideApplyToAll, tr("Set as Default..."));
  56     registerAction(HideUseDefaults, tr("Use Defaults..."));
  57
  58     registerAction(JoinChannel, QIcon::fromTheme("irc-join-channel"), tr("Join Channel..."));
  59
  60     registerAction(NickQuery, tr("Start Query"));
  61     registerAction(NickSwitchTo, tr("Show Query"));
  62     registerAction(NickWhois, tr("Whois"));
  63
  64     registerAction(NickCtcpVersion, tr("Version"));
  65     registerAction(NickCtcpTime, tr("Time"));
  66     registerAction(NickCtcpPing, tr("Ping"));
  67     registerAction(NickCtcpClientinfo, tr("Client info"));
  68     registerAction(NickIgnoreCustom, tr("Custom..."));
  69
  70     // these texts are only dummies! don't think about tr() here!
  71     registerAction(NickIgnoreUser, "*!ident@host.domain.tld");
  72     registerAction(NickIgnoreHost, "*!*@host.domain.tld");
  73     registerAction(NickIgnoreDomain, "*!ident@*.domain.tld");
  74     registerAction(NickIgnoreToggleEnabled0, "Enable", true);
  75     registerAction(NickIgnoreToggleEnabled1, "Enable", true);
  76     registerAction(NickIgnoreToggleEnabled2, "Enable", true);
  77     registerAction(NickIgnoreToggleEnabled3, "Enable", true);
  78     registerAction(NickIgnoreToggleEnabled4, "Enable", true);
  79
  80     registerAction(NickOp, QIcon::fromTheme("irc-operator"), tr("Give Operator Status"));
  81     registerAction(NickDeop, QIcon::fromTheme("irc-remove-operator"), tr("Take Operator Status"));
  82     registerAction(NickHalfop, QIcon::fromTheme("irc-voice"), tr("Give Half-Operator Status"));
  83     registerAction(NickDehalfop, QIcon::fromTheme("irc-unvoice"), tr("Take Half-Operator Status"));
  84     registerAction(NickVoice, QIcon::fromTheme("irc-voice"), tr("Give Voice"));
  85     registerAction(NickDevoice, QIcon::fromTheme("irc-unvoice"), tr("Take Voice"));
  86     registerAction(NickKick, QIcon::fromTheme("im-kick-user"), tr("Kick From Channel"));
  87     registerAction(NickBan, QIcon::fromTheme("im-ban-user"), tr("Ban From Channel"));
  88     registerAction(NickKickBan, QIcon::fromTheme("im-ban-kick-user"), tr("Kick && Ban"));
  89
  90     registerAction(HideBufferTemporarily, tr("Hide Chat(s) Temporarily"));
  91     registerAction(HideBufferPermanently, tr("Hide Chat(s) Permanently"));
  92     registerAction(ShowChannelList, tr("Show Channel List"));
  93     registerAction(ShowNetworkConfig, tr("Configure"));
  94     registerAction(ShowIgnoreList, tr("Show Ignore List"));
  95
  96     QMenu *hideEventsMenu = new QMenu();
  97     hideEventsMenu->addAction(action(HideJoinPartQuit));
  98     hideEventsMenu->addSeparator();
  99     hideEventsMenu->addAction(action(HideJoin));
 100     hideEventsMenu->addAction(action(HidePart));
 101     hideEventsMenu->addAction(action(HideQuit));
 102     hideEventsMenu->addAction(action(HideNick));
 103     hideEventsMenu->addAction(action(HideMode));
 104     hideEventsMenu->addAction(action(HideTopic));
 105     hideEventsMenu->addAction(action(HideDayChange));
 106     hideEventsMenu->addSeparator();
 107     hideEventsMenu->addAction(action(HideApplyToAll));
 108     hideEventsMenu->addAction(action(HideUseDefaults));
 109     _hideEventsMenuAction = new Action(tr("Hide Events"), 0);
 110     _hideEventsMenuAction->setMenu(hideEventsMenu);
 111
 112     QMenu *nickCtcpMenu = new QMenu();
 113     nickCtcpMenu->addAction(action(NickCtcpPing));
 114     nickCtcpMenu->addAction(action(NickCtcpVersion));
 115     nickCtcpMenu->addAction(action(NickCtcpTime));
 116     nickCtcpMenu->addAction(action(NickCtcpClientinfo));
 117     _nickCtcpMenuAction = new Action(tr("CTCP"), 0);
 118     _nickCtcpMenuAction->setMenu(nickCtcpMenu);
 119
 120     QMenu *nickModeMenu = new QMenu();
 121     nickModeMenu->addAction(action(NickOp));
 122     nickModeMenu->addAction(action(NickDeop));
 123     // this is where the halfops will be placed if available
 124     nickModeMenu->addAction(action(NickHalfop));
 125     nickModeMenu->addAction(action(NickDehalfop));
 126     nickModeMenu->addAction(action(NickVoice));
 127     nickModeMenu->addAction(action(NickDevoice));
 128     nickModeMenu->addSeparator();
 129     nickModeMenu->addAction(action(NickKick));
 130     nickModeMenu->addAction(action(NickBan));
 131     nickModeMenu->addAction(action(NickKickBan));
 132     _nickModeMenuAction = new Action(tr("Actions"), 0);
 133     _nickModeMenuAction->setMenu(nickModeMenu);
 134
 135     QMenu *ignoreMenu = new QMenu();
 136     _nickIgnoreMenuAction = new Action(tr("Ignore"), 0);
 137     _nickIgnoreMenuAction->setMenu(ignoreMenu);
 138
 139     // These are disabled actions used as descriptions
 140     // They don't need any of the Action fancyness so we use plain QActions
 141     _ignoreDescriptions << new QAction(tr("Add Ignore Rule"), this);
 142     _ignoreDescriptions << new QAction(tr("Existing Rules"), this);
 143     foreach(QAction *act, _ignoreDescriptions)
 144     act->setEnabled(false);
 145 }
 146
 147
 148 ContextMenuActionProvider::~ContextMenuActionProvider()
 149 {
 150     _hideEventsMenuAction->menu()->deleteLater();
 151     _hideEventsMenuAction->deleteLater();
 152     _nickCtcpMenuAction->menu()->deleteLater();
 153     _nickCtcpMenuAction->deleteLater();
 154     _nickModeMenuAction->menu()->deleteLater();
 155     _nickModeMenuAction->deleteLater();
 156     _nickIgnoreMenuAction->menu()->deleteLater();
 157     _nickIgnoreMenuAction->deleteLater();
 158     qDeleteAll(_ignoreDescriptions);
 159     _ignoreDescriptions.clear();
 160 }
 161
 162
 163 void ContextMenuActionProvider::addActions(QMenu *menu, BufferId bufId, QObject *receiver, const char *method)
 164 {
 165     if (!bufId.isValid())
 166         return;
 167     addActions(menu, Client::networkModel()->bufferIndex(bufId), receiver, method);
 168 }
 169
 170
 171 void ContextMenuActionProvider::addActions(QMenu *menu, const QModelIndex &index, QObject *receiver, const char *method, bool isCustomBufferView)
 172 {
 173     if (!index.isValid())
 174         return;
 175     addActions(menu, QList<QModelIndex>() << index, 0, QString(), receiver, method, isCustomBufferView);
 176 }
 177
 178
 179 void ContextMenuActionProvider::addActions(QMenu *menu, MessageFilter *filter, BufferId msgBuffer, QObject *receiver, const char *slot)
 180 {
 181     addActions(menu, filter, msgBuffer, QString(), receiver, slot);
 182 }
 183
 184
 185 void ContextMenuActionProvider::addActions(QMenu *menu, MessageFilter *filter, BufferId msgBuffer, const QString &chanOrNick, QObject *receiver, const char *method)
 186 {
 187     if (!filter)
 188         return;
 189     addActions(menu, QList<QModelIndex>() << Client::networkModel()->bufferIndex(msgBuffer), filter, chanOrNick, receiver, method, false);
 190 }
 191
 192
 193 void ContextMenuActionProvider::addActions(QMenu *menu, const QList<QModelIndex> &indexList, QObject *receiver,  const char *method, bool isCustomBufferView)
 194 {
 195     addActions(menu, indexList, 0, QString(), receiver, method, isCustomBufferView);
 196 }
 197
 198
 199 // add a list of actions sensible for the current item(s)
 200 void ContextMenuActionProvider::addActions(QMenu *menu,
 201     const QList<QModelIndex> &indexList_,
 202     MessageFilter *filter_,
 203     const QString &contextItem_,
 204     QObject *receiver_,
 205     const char *method_,
 206     bool isCustomBufferView)
 207 {
 208     if (!indexList_.count())
 209         return;
 210
 211     setIndexList(indexList_);
 212     setMessageFilter(filter_);
 213     setContextItem(contextItem_);
 214     setSlot(receiver_, method_);
 215
 216     if (!messageFilter()) {
 217         // this means we are in a BufferView (or NickView) rather than a ChatView
 218
 219         // first index in list determines the menu type (just in case we have both buffers and networks selected, for example)
 220         QModelIndex index = indexList().at(0);
 221         NetworkModel::ItemType itemType = static_cast<NetworkModel::ItemType>(index.data(NetworkModel::ItemTypeRole).toInt());
 222
 223         switch (itemType) {
 224         case NetworkModel::NetworkItemType:
 225             addNetworkItemActions(menu, index);
 226             break;
 227         case NetworkModel::BufferItemType:
 228             addBufferItemActions(menu, index, isCustomBufferView);
 229             break;
 230         case NetworkModel::IrcUserItemType:
 231             addIrcUserActions(menu, index);
 232             break;
 233         default:
 234             return;
 235         }
 236     }
 237     else {
 238         // ChatView actions
 239         if (contextItem().isEmpty()) {
 240             // a) query buffer: handle like ircuser
 241             // b) general chatview: handle like channel iff it displays a single buffer
 242             // NOTE stuff breaks probably with merged buffers, need to rework a lot around here then
 243             if (messageFilter()->containedBuffers().count() == 1) {
 244                 // we can handle this like a single bufferItem
 245                 QModelIndex index = Client::networkModel()->bufferIndex(messageFilter()->containedBuffers().values().at(0));
 246                 setIndexList(index);
 247                 addBufferItemActions(menu, index);
 248                 return;
 249             }
 250             else {
 251                 // TODO: actions for merged buffers... _indexList contains the index of the message we clicked on
 252             }
 253         }
 254         else {
 255             // context item = chan or nick, _indexList = buf where the msg clicked on originated
 256             if (isChannelName(contextItem())) {
 257                 QModelIndex msgIdx = indexList().at(0);
 258                 if (!msgIdx.isValid())
 259                     return;
 260                 NetworkId networkId = msgIdx.data(NetworkModel::NetworkIdRole).value<NetworkId>();
 261                 BufferId bufId = Client::networkModel()->bufferId(networkId, contextItem());
 262                 if (bufId.isValid()) {
 263                     QModelIndex targetIdx = Client::networkModel()->bufferIndex(bufId);
 264                     setIndexList(targetIdx);
 265                     addAction(BufferJoin, menu, targetIdx, InactiveState);
 266                     addAction(BufferSwitchTo, menu, targetIdx, ActiveState);
 267                 }
 268                 else
 269                     addAction(JoinChannel, menu);
 270             }
 271             else {
 272                 // TODO: actions for a nick
 273             }
 274         }
 275     }
 276 }
 277
 278
 279 void ContextMenuActionProvider::addNetworkItemActions(QMenu *menu, const QModelIndex &index)
 280 {
 281     NetworkId networkId = index.data(NetworkModel::NetworkIdRole).value<NetworkId>();
 282     if (!networkId.isValid())
 283         return;
 284     const Network *network = Client::network(networkId);
 285     Q_CHECK_PTR(network);
 286     if (!network)
 287         return;
 288
 289     addAction(ShowNetworkConfig, menu, index);
 290     menu->addSeparator();
 291     addAction(NetworkConnect, menu, network->connectionState() == Network::Disconnected);
 292     addAction(NetworkDisconnect, menu, network->connectionState() != Network::Disconnected);
 293     menu->addSeparator();
 294     addAction(ShowChannelList, menu, index, ActiveState);
 295     addAction(JoinChannel, menu, index, ActiveState);
 296 }
 297
 298
 299 void ContextMenuActionProvider::addBufferItemActions(QMenu *menu, const QModelIndex &index, bool isCustomBufferView)
 300 {
 301     BufferInfo bufferInfo = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
 302
 303     menu->addSeparator();
 304     switch (bufferInfo.type()) {
 305     case BufferInfo::ChannelBuffer:
 306         addAction(BufferJoin, menu, index, InactiveState);
 307         addAction(BufferPart, menu, index, ActiveState);
 308         menu->addSeparator();
 309         addHideEventsMenu(menu, bufferInfo.bufferId());
 310         menu->addSeparator();
 311         addAction(HideBufferTemporarily, menu, isCustomBufferView);
 312         addAction(HideBufferPermanently, menu, isCustomBufferView);
 313         addAction(BufferRemove, menu, index, InactiveState);
 314         break;
 315
 316     case BufferInfo::QueryBuffer:
 317     {
 318         //IrcUser *ircUser = qobject_cast<IrcUser *>(index.data(NetworkModel::IrcUserRole).value<QObject *>());
 319         //if(ircUser) {
 320         addIrcUserActions(menu, index);
 321         menu->addSeparator();
 322         //}
 323         addHideEventsMenu(menu, bufferInfo.bufferId());
 324         menu->addSeparator();
 325         addAction(HideBufferTemporarily, menu, isCustomBufferView);
 326         addAction(HideBufferPermanently, menu, isCustomBufferView);
 327         addAction(BufferRemove, menu, index);
 328         break;
 329     }
 330
 331     default:
 332         addAction(HideBufferTemporarily, menu, isCustomBufferView);
 333         addAction(HideBufferPermanently, menu, isCustomBufferView);
 334     }
 335 }
 336
 337
 338 void ContextMenuActionProvider::addIrcUserActions(QMenu *menu, const QModelIndex &index)
 339 {
 340     // this can be called: a) as a nicklist context menu (index has IrcUserItemType)
 341     //                     b) as a query buffer context menu (index has BufferItemType and is a QueryBufferItem)
 342     //                     c) right-click in a query chatview (same as b), index will be the corresponding QueryBufferItem)
 343     //                     d) right-click on some nickname (_contextItem will be non-null, _filter -> chatview, index -> message buffer)
 344
 345     if (contextItem().isNull()) {
 346         // cases a, b, c
 347         bool haveQuery = indexList().count() == 1 && findQueryBuffer(index).isValid();
 348         NetworkModel::ItemType itemType = static_cast<NetworkModel::ItemType>(index.data(NetworkModel::ItemTypeRole).toInt());
 349         addAction(_nickModeMenuAction, menu, itemType == NetworkModel::IrcUserItemType);
 350         addAction(_nickCtcpMenuAction, menu);
 351
 352         IrcUser *ircUser = qobject_cast<IrcUser *>(index.data(NetworkModel::IrcUserRole).value<QObject *>());
 353         if (ircUser) {
 354             Network *network = ircUser->network();
 355             // only show entries for usermode +h if server supports it
 356             if (network && network->prefixModes().contains('h')) {
 357                 action(NickHalfop)->setVisible(true);
 358                 action(NickDehalfop)->setVisible(true);
 359             }
 360             else {
 361                 action(NickHalfop)->setVisible(false);
 362                 action(NickDehalfop)->setVisible(false);
 363             }
 364             // ignoreliststuff
 365             QString bufferName;
 366             BufferInfo bufferInfo = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
 367             if (bufferInfo.type() == BufferInfo::ChannelBuffer)
 368                 bufferName = bufferInfo.bufferName();
 369             QMap<QString, bool> ignoreMap = Client::ignoreListManager()->matchingRulesForHostmask(ircUser->hostmask(), ircUser->network()->networkName(), bufferName);
 370             addIgnoreMenu(menu, ircUser->hostmask(), ignoreMap);
 371             // end of ignoreliststuff
 372         }
 373         menu->addSeparator();
 374         addAction(NickQuery, menu, itemType == NetworkModel::IrcUserItemType && !haveQuery && indexList().count() == 1);
 375         addAction(NickSwitchTo, menu, itemType == NetworkModel::IrcUserItemType && haveQuery);
 376         menu->addSeparator();
 377         addAction(NickWhois, menu, true);
 378     }
 379     else if (!contextItem().isEmpty() && messageFilter()) {
 380         // case d
 381         // TODO
 382     }
 383 }
 384
 385
 386 Action *ContextMenuActionProvider::addAction(ActionType type, QMenu *menu, const QModelIndex &index, ItemActiveStates requiredActiveState)
 387 {
 388     return addAction(action(type), menu, checkRequirements(index, requiredActiveState));
 389 }
 390
 391
 392 Action *ContextMenuActionProvider::addAction(Action *action, QMenu *menu, const QModelIndex &index, ItemActiveStates requiredActiveState)
 393 {
 394     return addAction(action, menu, checkRequirements(index, requiredActiveState));
 395 }
 396
 397
 398 Action *ContextMenuActionProvider::addAction(ActionType type, QMenu *menu, bool condition)
 399 {
 400     return addAction(action(type), menu, condition);
 401 }
 402
 403
 404 Action *ContextMenuActionProvider::addAction(Action *action, QMenu *menu, bool condition)
 405 {
 406     if (condition) {
 407         menu->addAction(action);
 408         action->setVisible(true);
 409     }
 410     else {
 411         action->setVisible(false);
 412     }
 413     return action;
 414 }
 415
 416
 417 void ContextMenuActionProvider::addHideEventsMenu(QMenu *menu, BufferId bufferId)
 418 {
 419     if (BufferSettings(bufferId).hasFilter())
 420         addHideEventsMenu(menu, BufferSettings(bufferId).messageFilter());
 421     else
 422         addHideEventsMenu(menu);
 423 }
 424
 425
 426 void ContextMenuActionProvider::addHideEventsMenu(QMenu *menu, MessageFilter *msgFilter)
 427 {
 428     if (BufferSettings(msgFilter->idString()).hasFilter())
 429         addHideEventsMenu(menu, BufferSettings(msgFilter->idString()).messageFilter());
 430     else
 431         addHideEventsMenu(menu);
 432 }
 433
 434
 435 void ContextMenuActionProvider::addHideEventsMenu(QMenu *menu, int filter)
 436 {
 437     action(HideApplyToAll)->setEnabled(filter != -1);
 438     action(HideUseDefaults)->setEnabled(filter != -1);
 439     if (filter == -1)
 440         filter = BufferSettings().messageFilter();
 441
 442     action(HideJoin)->setChecked(filter & Message::Join);
 443     action(HidePart)->setChecked(filter & Message::Part);
 444     action(HideQuit)->setChecked(filter & Message::Quit);
 445     action(HideNick)->setChecked(filter & Message::Nick);
 446     action(HideMode)->setChecked(filter & Message::Mode);
 447     action(HideDayChange)->setChecked(filter & Message::DayChange);
 448     action(HideTopic)->setChecked(filter & Message::Topic);
 449
 450     menu->addAction(_hideEventsMenuAction);
 451 }
 452
 453
 454 void ContextMenuActionProvider::addIgnoreMenu(QMenu *menu, const QString &hostmask, const QMap<QString, bool> &ignoreMap)
 455 {
 456     QMenu *ignoreMenu = _nickIgnoreMenuAction->menu();
 457     ignoreMenu->clear();
 458     QString nick = nickFromMask(hostmask);
 459     QString ident = userFromMask(hostmask);
 460     QString host = hostFromMask(hostmask);
 461     QString domain = host;
 462     QRegExp domainRx = QRegExp("(\\.[^.]+\\.\\w+\\D)$");
 463     if (domainRx.indexIn(host) != -1)
 464         domain = domainRx.cap(1);
 465     // we can't rely on who-data
 466     // if we don't have the data, we skip actions where we would need it
 467     bool haveWhoData = !ident.isEmpty() && !host.isEmpty();
 468
 469     // add "Add Ignore Rule" description
 470     ignoreMenu->addAction(_ignoreDescriptions.at(0));
 471
 472     if (haveWhoData) {
 473         QString text;
 474         text = QString("*!%1@%2").arg(ident, host);
 475         action(NickIgnoreUser)->setText(text);
 476         action(NickIgnoreUser)->setProperty("ignoreRule", text);
 477
 478         text = QString("*!*@%1").arg(host);
 479         action(NickIgnoreHost)->setText(text);
 480         action(NickIgnoreHost)->setProperty("ignoreRule", text);
 481
 482         text = domain.at(0) == '.' ? QString("*!%1@*%2").arg(ident, domain)
 483                : QString("*!%1@%2").arg(ident, domain);
 484
 485         action(NickIgnoreDomain)->setText(text);
 486         action(NickIgnoreDomain)->setProperty("ignoreRule", text);
 487
 488         if (!ignoreMap.contains(action(NickIgnoreUser)->property("ignoreRule").toString()))
 489             ignoreMenu->addAction(action(NickIgnoreUser));
 490         if (!ignoreMap.contains(action(NickIgnoreHost)->property("ignoreRule").toString()))
 491             ignoreMenu->addAction(action(NickIgnoreHost));
 492         // we only add that NickIgnoreDomain if it isn't the same as NickIgnoreUser
 493         // as happens with @foobar.com hostmasks and ips
 494         if (!ignoreMap.contains(action(NickIgnoreDomain)->property("ignoreRule").toString())
 495             && action(NickIgnoreUser)->property("ignoreRule").toString() != action(NickIgnoreDomain)->property("ignoreRule").toString())
 496             ignoreMenu->addAction(action(NickIgnoreDomain));
 497     }
 498
 499     action(NickIgnoreCustom)->setProperty("ignoreRule", hostmask);
 500     ignoreMenu->addAction(action(NickIgnoreCustom));
 501
 502     ignoreMenu->addSeparator();
 503
 504     if (haveWhoData) {
 505         QMap<QString, bool>::const_iterator ruleIter = ignoreMap.begin();
 506         int counter = 0;
 507         if (!ignoreMap.isEmpty())
 508             // add "Existing Rules" description
 509             ignoreMenu->addAction(_ignoreDescriptions.at(1));
 510         while (ruleIter != ignoreMap.constEnd()) {
 511             if (counter < 5) {
 512                 ActionType type = static_cast<ActionType>(NickIgnoreToggleEnabled0 + counter*0x100000);
 513                 Action *act = action(type);
 514                 act->setText(ruleIter.key());
 515                 act->setProperty("ignoreRule", ruleIter.key());
 516                 act->setChecked(ruleIter.value());
 517                 ignoreMenu->addAction(act);
 518             }
 519             counter++;
 520             ++ruleIter;
 521         }
 522         if (counter)
 523             ignoreMenu->addSeparator();
 524     }
 525     ignoreMenu->addAction(action(ShowIgnoreList));
 526     addAction(_nickIgnoreMenuAction, menu);
 527 }