/***************************************************************************
- * Copyright (C) 2005-08 by the Quassel Project *
+ * Copyright (C) 2005-2016 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
- * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "ircchannel.h"
#include "network.h"
-//#include "nicktreemodel.h"
-#include "signalproxy.h"
#include "ircuser.h"
#include "util.h"
#include <QDebug>
-
-IrcChannel::IrcChannel(const QString &channelname, Network *network)
- : SyncableObject(network),
+INIT_SYNCABLE_OBJECT(IrcChannel)
+IrcChannel::IrcChannel(const QString &channelname, Network *network)
+ : SyncableObject(network),
_initialized(false),
_name(channelname),
_topic(QString()),
- network(network)
+ _encrypted(false),
+ _network(network),
+ _codecForEncoding(0),
+ _codecForDecoding(0)
{
- setObjectName(QString::number(network->networkId()) + "/" + channelname);
+ setObjectName(QString::number(network->networkId().toInt()) + "/" + channelname);
}
-IrcChannel::~IrcChannel() {
+IrcChannel::~IrcChannel()
+{
}
+
// ====================
// PUBLIC:
// ====================
-bool IrcChannel::isKnownUser(IrcUser *ircuser) const {
- if(ircuser == 0) {
- qWarning() << "Channel" << name() << "received IrcUser Nullpointer!";
- return false;
- }
-
- if(!_userModes.contains(ircuser)) {
- qWarning() << "Channel" << name() << "received data for unknown User" << ircuser->nick();
- return false;
- }
+bool IrcChannel::isKnownUser(IrcUser *ircuser) const
+{
+ if (ircuser == 0) {
+ qWarning() << "Channel" << name() << "received IrcUser Nullpointer!";
+ return false;
+ }
- return true;
-}
+ if (!_userModes.contains(ircuser)) {
+ qWarning() << "Channel" << name() << "received data for unknown User" << ircuser->nick();
+ return false;
+ }
-bool IrcChannel::isValidChannelUserMode(const QString &mode) const {
- bool isvalid = true;
- if(mode.size() > 1) {
- qWarning() << "Channel" << name() << "received Channel User Mode which is longer then 1 Char:" << mode;
- isvalid = false;
- }
- return isvalid;
+ return true;
}
-bool IrcChannel::initialized() const {
- return _initialized;
-}
-QString IrcChannel::name() const {
- return _name;
+bool IrcChannel::isValidChannelUserMode(const QString &mode) const
+{
+ bool isvalid = true;
+ if (mode.size() > 1) {
+ qWarning() << "Channel" << name() << "received Channel User Mode which is longer than 1 Char:" << mode;
+ isvalid = false;
+ }
+ return isvalid;
}
-QString IrcChannel::topic() const {
- return _topic;
-}
-QList<IrcUser *> IrcChannel::ircUsers() const {
- return _userModes.keys();
+QString IrcChannel::userModes(IrcUser *ircuser) const
+{
+ if (_userModes.contains(ircuser))
+ return _userModes[ircuser];
+ else
+ return QString();
}
-QString IrcChannel::userModes(IrcUser *ircuser) const {
- if(_userModes.contains(ircuser))
- return _userModes[ircuser];
- else
- return QString();
-}
-QString IrcChannel::userModes(const QString &nick) const {
- return userModes(network->ircUser(nick));
+QString IrcChannel::userModes(const QString &nick) const
+{
+ return userModes(network()->ircUser(nick));
}
-QTextCodec *IrcChannel::codecForEncoding() const {
- return _codecForEncoding;
-}
-void IrcChannel::setCodecForEncoding(const QString &name) {
- setCodecForEncoding(QTextCodec::codecForName(name.toAscii()));
+void IrcChannel::setCodecForEncoding(const QString &name)
+{
+ setCodecForEncoding(QTextCodec::codecForName(name.toLatin1()));
}
-void IrcChannel::setCodecForEncoding(QTextCodec *codec) {
- _codecForEncoding = codec;
-}
-QTextCodec *IrcChannel::codecForDecoding() const {
- return _codecForDecoding;
+void IrcChannel::setCodecForEncoding(QTextCodec *codec)
+{
+ _codecForEncoding = codec;
}
-void IrcChannel::setCodecForDecoding(const QString &name) {
- setCodecForDecoding(QTextCodec::codecForName(name.toAscii()));
+
+void IrcChannel::setCodecForDecoding(const QString &name)
+{
+ setCodecForDecoding(QTextCodec::codecForName(name.toLatin1()));
}
-void IrcChannel::setCodecForDecoding(QTextCodec *codec) {
- _codecForDecoding = codec;
+
+void IrcChannel::setCodecForDecoding(QTextCodec *codec)
+{
+ _codecForDecoding = codec;
}
-QString IrcChannel::decodeString(const QByteArray &text) const {
- if(!codecForDecoding()) return network->decodeString(text);
- return ::decodeString(text, _codecForDecoding);
+
+QString IrcChannel::decodeString(const QByteArray &text) const
+{
+ if (!codecForDecoding()) return network()->decodeString(text);
+ return ::decodeString(text, _codecForDecoding);
}
-QByteArray IrcChannel::encodeString(const QString string) const {
- if(codecForEncoding()) {
- return _codecForEncoding->fromUnicode(string);
- }
- return network->encodeString(string);
+
+QByteArray IrcChannel::encodeString(const QString &string) const
+{
+ if (codecForEncoding()) {
+ return _codecForEncoding->fromUnicode(string);
+ }
+ return network()->encodeString(string);
}
+
// ====================
// PUBLIC SLOTS:
// ====================
-void IrcChannel::setTopic(const QString &topic) {
- _topic = topic;
- emit topicSet(topic);
+void IrcChannel::setTopic(const QString &topic)
+{
+ _topic = topic;
+ SYNC(ARG(topic))
+ emit topicSet(topic);
}
-void IrcChannel::join(IrcUser *ircuser) {
- if(!_userModes.contains(ircuser) && ircuser) {
- _userModes[ircuser] = QString();
- ircuser->joinChannel(name());
- //qDebug() << "JOIN" << name() << ircuser->nick() << ircUsers().count();
- connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickSet(QString)));
- connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
- // if you wonder why there is no counterpart to ircUserJoined:
- // the joines are propagted by the ircuser. the signal ircUserJoined is only for convenience
- emit ircUserJoined(ircuser);
- }
+
+void IrcChannel::setPassword(const QString &password)
+{
+ _password = password;
+ SYNC(ARG(password))
}
-void IrcChannel::join(const QString &nick) {
- join(network->ircUser(nick));
+void IrcChannel::setEncrypted(bool encrypted)
+{
+ _encrypted = encrypted;
+ SYNC(ARG(encrypted))
+ emit encryptedSet(encrypted);
}
-void IrcChannel::part(IrcUser *ircuser) {
- if(isKnownUser(ircuser)) {
- _userModes.remove(ircuser);
- ircuser->partChannel(name());
- //qDebug() << "PART" << name() << ircuser->nick() << ircUsers().count();
- // if you wonder why there is no counterpart to ircUserParted:
- // the joines are propagted by the ircuser. the signal ircUserParted is only for convenience
- emit ircUserParted(ircuser);
- if(network->isMyNick(ircuser))
- deleteLater();
- }
+
+void IrcChannel::joinIrcUsers(const QList<IrcUser *> &users, const QStringList &modes)
+{
+ if (users.isEmpty())
+ return;
+
+ if (users.count() != modes.count()) {
+ qWarning() << "IrcChannel::addUsers(): number of nicks does not match number of modes!";
+ return;
+ }
+
+ QStringList newNicks;
+ QStringList newModes;
+ QList<IrcUser *> newUsers;
+
+ IrcUser *ircuser;
+ for (int i = 0; i < users.count(); i++) {
+ ircuser = users[i];
+ if (!ircuser || _userModes.contains(ircuser)) {
+ if (modes[i].count() > 1) {
+ // Multiple modes received, do it one at a time
+ // TODO Better way of syncing this without breaking protocol?
+ for (int i_m = 0; i_m < modes[i].count(); ++i_m) {
+ addUserMode(ircuser, modes[i][i_m]);
+ }
+ } else {
+ addUserMode(ircuser, modes[i]);
+ }
+ continue;
+ }
+
+ _userModes[ircuser] = modes[i];
+ ircuser->joinChannel(this, true);
+ connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickSet(QString)));
+
+ // connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
+ // If you wonder why there is no counterpart to ircUserJoined:
+ // the joins are propagated by the ircuser. The signal ircUserJoined is only for convenience
+
+ newNicks << ircuser->nick();
+ newModes << modes[i];
+ newUsers << ircuser;
+ }
+
+ if (newNicks.isEmpty())
+ return;
+
+ SYNC_OTHER(joinIrcUsers, ARG(newNicks), ARG(newModes));
+ emit ircUsersJoined(newUsers);
+}
+
+
+void IrcChannel::joinIrcUsers(const QStringList &nicks, const QStringList &modes)
+{
+ QList<IrcUser *> users;
+ foreach(QString nick, nicks)
+ users << network()->newIrcUser(nick);
+ joinIrcUsers(users, modes);
}
-void IrcChannel::part(const QString &nick) {
- part(network->ircUser(nick));
+
+void IrcChannel::joinIrcUser(IrcUser *ircuser)
+{
+ QList<IrcUser *> users;
+ users << ircuser;
+ QStringList modes;
+ modes << QString();
+ joinIrcUsers(users, modes);
+}
+
+
+void IrcChannel::part(IrcUser *ircuser)
+{
+ if (isKnownUser(ircuser)) {
+ _userModes.remove(ircuser);
+ ircuser->partChannel(this);
+ // If you wonder why there is no counterpart to ircUserParted:
+ // the joins are propagted by the ircuser. The signal ircUserParted is only for convenience
+ disconnect(ircuser, 0, this, 0);
+ emit ircUserParted(ircuser);
+
+ if (network()->isMe(ircuser) || _userModes.isEmpty()) {
+ // in either case we're no longer in the channel
+ // -> clean up the channel and destroy it
+ QList<IrcUser *> users = _userModes.keys();
+ _userModes.clear();
+ foreach(IrcUser *user, users) {
+ disconnect(user, 0, this, 0);
+ user->partChannel(this);
+ }
+ emit parted();
+ network()->removeIrcChannel(this);
+ }
+ }
+}
+
+
+void IrcChannel::part(const QString &nick)
+{
+ part(network()->ircUser(nick));
}
+
// SET USER MODE
-void IrcChannel::setUserModes(IrcUser *ircuser, const QString &modes) {
- if(isKnownUser(ircuser)) {
- _userModes[ircuser] = modes;
- emit userModesSet(ircuser->nick(), modes);
- emit ircUserModesSet(ircuser, modes);
- }
+void IrcChannel::setUserModes(IrcUser *ircuser, const QString &modes)
+{
+ if (isKnownUser(ircuser)) {
+ _userModes[ircuser] = modes;
+ QString nick = ircuser->nick();
+ SYNC_OTHER(setUserModes, ARG(nick), ARG(modes))
+ emit ircUserModesSet(ircuser, modes);
+ }
}
-void IrcChannel::setUserModes(const QString &nick, const QString &modes) {
- setUserModes(network->ircUser(nick), modes);
+
+void IrcChannel::setUserModes(const QString &nick, const QString &modes)
+{
+ setUserModes(network()->ircUser(nick), modes);
}
-// ADD USER MODE
-void IrcChannel::addUserMode(IrcUser *ircuser, const QString &mode) {
- if(!isKnownUser(ircuser) || !isValidChannelUserMode(mode))
- return;
- if(!_userModes[ircuser].contains(mode)) {
- _userModes[ircuser] += mode;
- emit userModeAdded(ircuser->nick(), mode);
- emit ircUserModeAdded(ircuser, mode);
- }
+// ADD USER MODE
+void IrcChannel::addUserMode(IrcUser *ircuser, const QString &mode)
+{
+ if (!isKnownUser(ircuser) || !isValidChannelUserMode(mode))
+ return;
+ if (!_userModes[ircuser].contains(mode)) {
+ _userModes[ircuser] += mode;
+ QString nick = ircuser->nick();
+ SYNC_OTHER(addUserMode, ARG(nick), ARG(mode))
+ emit ircUserModeAdded(ircuser, mode);
+ }
}
-void IrcChannel::addUserMode(const QString &nick, const QString &mode) {
- addUserMode(network->ircUser(nick), mode);
+
+void IrcChannel::addUserMode(const QString &nick, const QString &mode)
+{
+ addUserMode(network()->ircUser(nick), mode);
}
-// REMOVE USER MODE
-void IrcChannel::removeUserMode(IrcUser *ircuser, const QString &mode) {
- if(!isKnownUser(ircuser) || !isValidChannelUserMode(mode))
- return;
- if(_userModes[ircuser].contains(mode)) {
- _userModes[ircuser].remove(mode);
- emit userModeRemoved(ircuser->nick(), mode);
- emit ircUserModeRemoved(ircuser, mode);
- }
+// REMOVE USER MODE
+void IrcChannel::removeUserMode(IrcUser *ircuser, const QString &mode)
+{
+ if (!isKnownUser(ircuser) || !isValidChannelUserMode(mode))
+ return;
+ if (_userModes[ircuser].contains(mode)) {
+ _userModes[ircuser].remove(mode);
+ QString nick = ircuser->nick();
+ SYNC_OTHER(removeUserMode, ARG(nick), ARG(mode));
+ emit ircUserModeRemoved(ircuser, mode);
+ }
}
-void IrcChannel::removeUserMode(const QString &nick, const QString &mode) {
- removeUserMode(network->ircUser(nick), mode);
+
+void IrcChannel::removeUserMode(const QString &nick, const QString &mode)
+{
+ removeUserMode(network()->ircUser(nick), mode);
}
+
// INIT SET USER MODES
-QVariantMap IrcChannel::initUserModes() const {
- QVariantMap usermodes;
- QHash<IrcUser *, QString>::const_iterator iter = _userModes.constBegin();
- while(iter != _userModes.constEnd()) {
- usermodes[iter.key()->nick()] = iter.value();
- iter++;
- }
- return usermodes;
+QVariantMap IrcChannel::initUserModes() const
+{
+ QVariantMap usermodes;
+ QHash<IrcUser *, QString>::const_iterator iter = _userModes.constBegin();
+ while (iter != _userModes.constEnd()) {
+ usermodes[iter.key()->nick()] = iter.value();
+ ++iter;
+ }
+ return usermodes;
}
-void IrcChannel::initSetUserModes(const QVariantMap &usermodes) {
- QMapIterator<QString, QVariant> iter(usermodes);
- while(iter.hasNext()) {
- iter.next();
- setUserModes(iter.key(), iter.value().toString());
- }
+
+void IrcChannel::initSetUserModes(const QVariantMap &usermodes)
+{
+ QList<IrcUser *> users;
+ QStringList modes;
+ QVariantMap::const_iterator iter = usermodes.constBegin();
+ while (iter != usermodes.constEnd()) {
+ users << network()->newIrcUser(iter.key());
+ modes << iter.value().toString();
+ ++iter;
+ }
+ joinIrcUsers(users, modes);
}
-void IrcChannel::ircUserDestroyed() {
- IrcUser *ircUser = static_cast<IrcUser *>(sender());
- Q_ASSERT(ircUser);
- _userModes.remove(ircUser);
- emit ircUserParted(ircUser);
- //qDebug() << "DEST" << name() << ircUsers().count();
+
+QVariantMap IrcChannel::initChanModes() const
+{
+ QVariantMap channelModes;
+
+ QVariantMap A_modes;
+ QHash<QChar, QStringList>::const_iterator A_iter = _A_channelModes.constBegin();
+ while (A_iter != _A_channelModes.constEnd()) {
+ A_modes[A_iter.key()] = A_iter.value();
+ ++A_iter;
+ }
+ channelModes["A"] = A_modes;
+
+ QVariantMap B_modes;
+ QHash<QChar, QString>::const_iterator B_iter = _B_channelModes.constBegin();
+ while (B_iter != _B_channelModes.constEnd()) {
+ B_modes[B_iter.key()] = B_iter.value();
+ ++B_iter;
+ }
+ channelModes["B"] = B_modes;
+
+ QVariantMap C_modes;
+ QHash<QChar, QString>::const_iterator C_iter = _C_channelModes.constBegin();
+ while (C_iter != _C_channelModes.constEnd()) {
+ C_modes[C_iter.key()] = C_iter.value();
+ ++C_iter;
+ }
+ channelModes["C"] = C_modes;
+
+ QString D_modes;
+ QSet<QChar>::const_iterator D_iter = _D_channelModes.constBegin();
+ while (D_iter != _D_channelModes.constEnd()) {
+ D_modes += *D_iter;
+ ++D_iter;
+ }
+ channelModes["D"] = D_modes;
+
+ return channelModes;
+}
+
+
+void IrcChannel::initSetChanModes(const QVariantMap &channelModes)
+{
+ QVariantMap::const_iterator iter = channelModes["A"].toMap().constBegin();
+ QVariantMap::const_iterator iterEnd = channelModes["A"].toMap().constEnd();
+ while (iter != iterEnd) {
+ _A_channelModes[iter.key()[0]] = iter.value().toStringList();
+ ++iter;
+ }
+
+ iter = channelModes["B"].toMap().constBegin();
+ iterEnd = channelModes["B"].toMap().constEnd();
+ while (iter != iterEnd) {
+ _B_channelModes[iter.key()[0]] = iter.value().toString();
+ ++iter;
+ }
+
+ iter = channelModes["C"].toMap().constBegin();
+ iterEnd = channelModes["C"].toMap().constEnd();
+ while (iter != iterEnd) {
+ _C_channelModes[iter.key()[0]] = iter.value().toString();
+ ++iter;
+ }
+
+ QString D_modes = channelModes["D"].toString();
+ for (int i = 0; i < D_modes.count(); i++) {
+ _D_channelModes << D_modes[i];
+ }
+}
+
+
+void IrcChannel::ircUserDestroyed()
+{
+ IrcUser *ircUser = static_cast<IrcUser *>(sender());
+ Q_ASSERT(ircUser);
+ _userModes.remove(ircUser);
+ // no further propagation.
+ // this leads only to fuck ups.
}
-void IrcChannel::ircUserNickSet(QString nick) {
- IrcUser *ircUser = qobject_cast<IrcUser *>(sender());
- Q_ASSERT(ircUser);
- emit ircUserNickSet(ircUser, nick);
+
+void IrcChannel::ircUserNickSet(QString nick)
+{
+ IrcUser *ircUser = qobject_cast<IrcUser *>(sender());
+ Q_ASSERT(ircUser);
+ emit ircUserNickSet(ircUser, nick);
+}
+
+
+/*******************************************************************************
+ *
+ * 3.3 CHANMODES
+ *
+ * o CHANMODES=A,B,C,D
+ *
+ * The CHANMODES token specifies the modes that may be set on a channel.
+ * These modes are split into four categories, as follows:
+ *
+ * o Type A: Modes that add or remove an address to or from a list.
+ * These modes always take a parameter when sent by the server to a
+ * client; when sent by a client, they may be specified without a
+ * parameter, which requests the server to display the current
+ * contents of the corresponding list on the channel to the client.
+ * o Type B: Modes that change a setting on the channel. These modes
+ * always take a parameter.
+ * o Type C: Modes that change a setting on the channel. These modes
+ * take a parameter only when set; the parameter is absent when the
+ * mode is removed both in the client's and server's MODE command.
+ * o Type D: Modes that change a setting on the channel. These modes
+ * never take a parameter.
+ *
+ * If the server sends any additional types after these 4, the client
+ * MUST ignore them; this is intended to allow future extension of this
+ * token.
+ *
+ * The IRC server MUST NOT list modes in CHANMODES which are also
+ * present in the PREFIX parameter; however, for completeness, modes
+ * described in PREFIX may be treated as type B modes.
+ *
+ ******************************************************************************/
+
+/*******************************************************************************
+ * Short Version:
+ * A --> add/remove from List
+ * B --> set value or remove
+ * C --> set value or remove
+ * D --> on/off
+ *
+ * B and C behave very similar... we store the data in different datastructures
+ * for future compatibility
+ ******************************************************************************/
+
+// NOTE: the behavior of addChannelMode and removeChannelMode depends on the type of mode
+// see list above for chanmode types
+void IrcChannel::addChannelMode(const QChar &mode, const QString &value)
+{
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
+
+ switch (modeType) {
+ case Network::NOT_A_CHANMODE:
+ return;
+ case Network::A_CHANMODE:
+ if (!_A_channelModes.contains(mode))
+ _A_channelModes[mode] = QStringList(value);
+ else if (!_A_channelModes[mode].contains(value))
+ _A_channelModes[mode] << value;
+ break;
+
+ case Network::B_CHANMODE:
+ _B_channelModes[mode] = value;
+ break;
+
+ case Network::C_CHANMODE:
+ _C_channelModes[mode] = value;
+ break;
+
+ case Network::D_CHANMODE:
+ _D_channelModes << mode;
+ break;
+ }
+ SYNC(ARG(mode), ARG(value))
+}
+
+
+void IrcChannel::removeChannelMode(const QChar &mode, const QString &value)
+{
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
+
+ switch (modeType) {
+ case Network::NOT_A_CHANMODE:
+ return;
+ case Network::A_CHANMODE:
+ if (_A_channelModes.contains(mode))
+ _A_channelModes[mode].removeAll(value);
+ break;
+
+ case Network::B_CHANMODE:
+ _B_channelModes.remove(mode);
+ break;
+
+ case Network::C_CHANMODE:
+ _C_channelModes.remove(mode);
+ break;
+
+ case Network::D_CHANMODE:
+ _D_channelModes.remove(mode);
+ break;
+ }
+ SYNC(ARG(mode), ARG(value))
}
-void IrcChannel::setInitialized() {
- _initialized = true;
- emit initDone();
+
+bool IrcChannel::hasMode(const QChar &mode) const
+{
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
+
+ switch (modeType) {
+ case Network::NOT_A_CHANMODE:
+ return false;
+ case Network::A_CHANMODE:
+ return _A_channelModes.contains(mode);
+ case Network::B_CHANMODE:
+ return _B_channelModes.contains(mode);
+ case Network::C_CHANMODE:
+ return _C_channelModes.contains(mode);
+ case Network::D_CHANMODE:
+ return _D_channelModes.contains(mode);
+ default:
+ return false;
+ }
+}
+
+
+QString IrcChannel::modeValue(const QChar &mode) const
+{
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
+
+ switch (modeType) {
+ case Network::B_CHANMODE:
+ if (_B_channelModes.contains(mode))
+ return _B_channelModes[mode];
+ else
+ return QString();
+ case Network::C_CHANMODE:
+ if (_C_channelModes.contains(mode))
+ return _C_channelModes[mode];
+ else
+ return QString();
+ default:
+ return QString();
+ }
+}
+
+
+QStringList IrcChannel::modeValueList(const QChar &mode) const
+{
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
+
+ switch (modeType) {
+ case Network::A_CHANMODE:
+ if (_A_channelModes.contains(mode))
+ return _A_channelModes[mode];
+ default:
+ return QStringList();
+ }
}
+
+QString IrcChannel::channelModeString() const
+{
+ QStringList params;
+ QString modeString;
+
+ QSet<QChar>::const_iterator D_iter = _D_channelModes.constBegin();
+ while (D_iter != _D_channelModes.constEnd()) {
+ modeString += *D_iter;
+ ++D_iter;
+ }
+
+ QHash<QChar, QString>::const_iterator BC_iter = _C_channelModes.constBegin();
+ while (BC_iter != _C_channelModes.constEnd()) {
+ modeString += BC_iter.key();
+ params << BC_iter.value();
+ ++BC_iter;
+ }
+
+ BC_iter = _B_channelModes.constBegin();
+ while (BC_iter != _B_channelModes.constEnd()) {
+ modeString += BC_iter.key();
+ params << BC_iter.value();
+ ++BC_iter;
+ }
+ if (modeString.isEmpty())
+ return modeString;
+ else
+ return QString("+%1 %2").arg(modeString).arg(params.join(" "));
+}