*****************************************/
// we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
// category strings anyway.
+// TODO make this translateable depending on the number of users in a category
+// -> we can't set the real string here, because tr() needs to get the actual number as second param
+// -> tr("%n User(s)", n) needs to be used somewhere where we do know the user number n
const QList<UserCategoryItem::Category> UserCategoryItem::categories = QList<UserCategoryItem::Category>()
<< UserCategoryItem::Category('q', tr("Owners"))
<< UserCategoryItem::Category('a', tr("Admins"))
quasselTranslator.load(QString(":i18n/quassel_%1").arg(locale.name()));
app.installTranslator(&quasselTranslator);
+ Network::setDefaultCodecForServer("UTF-8");
Network::setDefaultCodecForEncoding("UTF-8");
Network::setDefaultCodecForDecoding("ISO-8859-15");
#include "util.h"
+QTextCodec *Network::_defaultCodecForServer = 0;
QTextCodec *Network::_defaultCodecForEncoding = 0;
QTextCodec *Network::_defaultCodecForDecoding = 0;
_prefixes(QString()),
_prefixModes(QString()),
_proxy(0),
+ _useRandomServer(false),
+ _useAutoIdentify(false),
+ _useAutoReconnect(false),
+ _autoReconnectInterval(60),
+ _autoReconnectRetries(10),
+ _unlimitedReconnectRetries(false),
+ _codecForServer(0),
_codecForEncoding(0),
_codecForDecoding(0)
{
// we don't set our ID!
if(!info.networkName.isEmpty() && info.networkName != networkName()) setNetworkName(info.networkName);
if(info.identity > 0 && info.identity != identity()) setIdentity(info.identity);
+ if(info.codecForServer != codecForServer()) setCodecForServer(QTextCodec::codecForName(info.codecForServer));
if(info.codecForEncoding != codecForEncoding()) setCodecForEncoding(QTextCodec::codecForName(info.codecForEncoding));
if(info.codecForDecoding != codecForDecoding()) setCodecForDecoding(QTextCodec::codecForName(info.codecForDecoding));
if(info.serverList.count()) setServerList(info.serverList); // FIXME compare components
if(info.useAutoReconnect != useAutoReconnect()) setUseAutoReconnect(info.useAutoReconnect);
if(info.autoReconnectInterval != autoReconnectInterval()) setAutoReconnectInterval(info.autoReconnectInterval);
if(info.autoReconnectRetries != autoReconnectRetries()) setAutoReconnectRetries(info.autoReconnectRetries);
+ if(info.unlimitedReconnectRetries != unlimitedReconnectRetries()) setUnlimitedReconnectRetries(info.unlimitedReconnectRetries);
if(info.rejoinChannels != rejoinChannels()) setRejoinChannels(info.rejoinChannels);
}
return _autoReconnectInterval;
}
-qint16 Network::autoReconnectRetries() const {
+quint16 Network::autoReconnectRetries() const {
return _autoReconnectRetries;
}
+bool Network::unlimitedReconnectRetries() const {
+ return _unlimitedReconnectRetries;
+}
+
bool Network::rejoinChannels() const {
return _rejoinChannels;
}
return _ircChannels.count();
}
+QByteArray Network::defaultCodecForServer() {
+ if(_defaultCodecForServer) return _defaultCodecForServer->name();
+ return QByteArray();
+}
+
+void Network::setDefaultCodecForServer(const QByteArray &name) {
+ _defaultCodecForServer = QTextCodec::codecForName(name);
+}
+
QByteArray Network::defaultCodecForEncoding() {
if(_defaultCodecForEncoding) return _defaultCodecForEncoding->name();
return QByteArray();
_defaultCodecForDecoding = QTextCodec::codecForName(name);
}
+QByteArray Network::codecForServer() const {
+ if(_codecForServer) return _codecForServer->name();
+ return QByteArray();
+}
+
+void Network::setCodecForServer(const QByteArray &name) {
+ setCodecForServer(QTextCodec::codecForName(name));
+}
+
+void Network::setCodecForServer(QTextCodec *codec) {
+ _codecForServer = codec;
+ emit codecForServerSet(codecForServer());
+}
+
QByteArray Network::codecForEncoding() const {
if(_codecForEncoding) return _codecForEncoding->name();
return QByteArray();
emit codecForDecodingSet(codecForDecoding());
}
+// FIXME use server encoding if appropriate
QString Network::decodeString(const QByteArray &text) const {
if(_codecForDecoding) return ::decodeString(text, _codecForDecoding);
else return ::decodeString(text, _defaultCodecForDecoding);
emit autoReconnectIntervalSet(interval);
}
-void Network::setAutoReconnectRetries(qint16 retries) {
+void Network::setAutoReconnectRetries(quint16 retries) {
_autoReconnectRetries = retries;
emit autoReconnectRetriesSet(retries);
}
+void Network::setUnlimitedReconnectRetries(bool unlimited) {
+ _unlimitedReconnectRetries = unlimited;
+ emit unlimitedReconnectRetriesSet(unlimited);
+}
+
void Network::setRejoinChannels(bool rejoin) {
_rejoinChannels = rejoin;
emit rejoinChannelsSet(rejoin);
if(networkId != other.networkId) return false;
if(networkName != other.networkName) return false;
if(identity != other.identity) return false;
+ if(codecForServer != other.codecForServer) return false;
if(codecForEncoding != other.codecForEncoding) return false;
if(codecForDecoding != other.codecForDecoding) return false;
if(serverList != other.serverList) return false;
if(useAutoReconnect != other.useAutoReconnect) return false;
if(autoReconnectInterval != other.autoReconnectInterval) return false;
if(autoReconnectRetries != other.autoReconnectRetries) return false;
+ if(unlimitedReconnectRetries != other.unlimitedReconnectRetries) return false;
if(rejoinChannels != other.rejoinChannels) return false;
return true;
}
i["NetworkId"] = QVariant::fromValue<NetworkId>(info.networkId);
i["NetworkName"] = info.networkName;
i["Identity"] = QVariant::fromValue<IdentityId>(info.identity);
+ i["CodecForServer"] = info.codecForServer;
i["CodecForEncoding"] = info.codecForEncoding;
i["CodecForDecoding"] = info.codecForDecoding;
i["ServerList"] = info.serverList;
i["UseAutoReconnect"] = info.useAutoReconnect;
i["AutoReconnectInterval"] = info.autoReconnectInterval;
i["AutoReconnectRetries"] = info.autoReconnectRetries;
+ i["UnlimitedReconnectRetries"] = info.unlimitedReconnectRetries;
i["RejoinChannels"] = info.rejoinChannels;
out << i;
return out;
info.networkId = i["NetworkId"].value<NetworkId>();
info.networkName = i["NetworkName"].toString();
info.identity = i["Identity"].value<IdentityId>();
+ info.codecForServer = i["CodecForServer"].toByteArray();
info.codecForEncoding = i["CodecForEncoding"].toByteArray();
info.codecForDecoding = i["CodecForDecoding"].toByteArray();
info.serverList = i["ServerList"].toList();
info.useAutoReconnect = i["UseAutoReconnect"].toBool();
info.autoReconnectInterval = i["AutoReconnectInterval"].toUInt();
info.autoReconnectRetries = i["AutoReconnectRetries"].toInt();
+ info.unlimitedReconnectRetries = i["UnlimitedReconnectRetries"].toBool();
info.rejoinChannels = i["RejoinChannels"].toBool();
return in;
}
Q_PROPERTY(QString networkName READ networkName WRITE setNetworkName STORED false)
Q_PROPERTY(QString currentServer READ currentServer WRITE setCurrentServer STORED false)
Q_PROPERTY(QString myNick READ myNick WRITE setMyNick STORED false)
+ Q_PROPERTY(QByteArray codecForServer READ codecForServer WRITE setCodecForServer STORED false)
Q_PROPERTY(QByteArray codecForEncoding READ codecForEncoding WRITE setCodecForEncoding STORED false)
Q_PROPERTY(QByteArray codecForDecoding READ codecForDecoding WRITE setCodecForDecoding STORED false)
Q_PROPERTY(IdentityId identityId READ identity WRITE setIdentity STORED false)
Q_PROPERTY(QString autoIdentifyPassword READ autoIdentifyPassword WRITE setAutoIdentifyPassword STORED false)
Q_PROPERTY(bool useAutoReconnect READ useAutoReconnect WRITE setUseAutoReconnect STORED false)
Q_PROPERTY(quint32 autoReconnectInterval READ autoReconnectInterval WRITE setAutoReconnectInterval STORED false)
- Q_PROPERTY(qint16 autoReconnectRetries READ autoReconnectRetries WRITE setAutoReconnectRetries STORED false)
+ Q_PROPERTY(quint16 autoReconnectRetries READ autoReconnectRetries WRITE setAutoReconnectRetries STORED false)
+ Q_PROPERTY(bool unlimitedReconnectRetries READ unlimitedReconnectRetries WRITE setUnlimitedReconnectRetries STORED false)
Q_PROPERTY(bool rejoinChannels READ rejoinChannels WRITE setRejoinChannels STORED false)
public:
QString autoIdentifyPassword() const;
bool useAutoReconnect() const;
quint32 autoReconnectInterval() const;
- qint16 autoReconnectRetries() const; // -1 => unlimited
+ quint16 autoReconnectRetries() const;
+ bool unlimitedReconnectRetries() const;
bool rejoinChannels() const;
NetworkInfo networkInfo() const;
QList<IrcChannel *> ircChannels() const;
quint32 ircChannelCount() const;
+ QByteArray codecForServer() const;
QByteArray codecForEncoding() const;
QByteArray codecForDecoding() const;
+ void setCodecForServer(QTextCodec *codec);
void setCodecForEncoding(QTextCodec *codec);
void setCodecForDecoding(QTextCodec *codec);
QString decodeString(const QByteArray &text) const;
QByteArray encodeString(const QString string) const;
+ static QByteArray defaultCodecForServer();
static QByteArray defaultCodecForEncoding();
static QByteArray defaultCodecForDecoding();
+ static void setDefaultCodecForServer(const QByteArray &name);
static void setDefaultCodecForEncoding(const QByteArray &name);
static void setDefaultCodecForDecoding(const QByteArray &name);
void setAutoIdentifyPassword(const QString &);
void setUseAutoReconnect(bool);
void setAutoReconnectInterval(quint32);
- void setAutoReconnectRetries(qint16);
+ void setAutoReconnectRetries(quint16);
+ void setUnlimitedReconnectRetries(bool);
void setRejoinChannels(bool);
+ void setCodecForServer(const QByteArray &codecName);
void setCodecForEncoding(const QByteArray &codecName);
void setCodecForDecoding(const QByteArray &codecName);
void useAutoReconnectSet(bool);
void autoReconnectIntervalSet(quint32);
void autoReconnectRetriesSet(qint16);
+ void unlimitedReconnectRetriesSet(bool);
void rejoinChannelsSet(bool);
+ void codecForServerSet(const QByteArray &codecName);
void codecForEncodingSet(const QByteArray &codecName);
void codecForDecodingSet(const QByteArray &codecName);
bool _useAutoReconnect;
quint32 _autoReconnectInterval;
- qint16 _autoReconnectRetries;
+ quint16 _autoReconnectRetries;
+ bool _unlimitedReconnectRetries;
bool _rejoinChannels;
QPointer<SignalProxy> _proxy;
void determinePrefixes();
+ QTextCodec *_codecForServer;
QTextCodec *_codecForEncoding;
QTextCodec *_codecForDecoding;
+ static QTextCodec *_defaultCodecForServer;
static QTextCodec *_defaultCodecForEncoding;
static QTextCodec *_defaultCodecForDecoding;
};
QString networkName;
IdentityId identity;
- bool useCustomEncodings;
+ bool useCustomEncodings; // not used!
+ QByteArray codecForServer;
QByteArray codecForEncoding;
QByteArray codecForDecoding;
bool useAutoReconnect;
quint32 autoReconnectInterval;
- qint16 autoReconnectRetries; // -1 => Unlimited
+ quint16 autoReconnectRetries;
+ bool unlimitedReconnectRetries;
bool rejoinChannels;
bool operator==(const NetworkInfo &other) const;
info.useAutoReconnect = true;
info.autoReconnectInterval = 60;
info.autoReconnectRetries = 20;
+ info.unlimitedReconnectRetries = false;
info.useAutoIdentify = false;
info.autoIdentifyService = "NickServ";
info.rejoinChannels = true;
}
ui.autoReconnect->setChecked(info.useAutoReconnect);
ui.reconnectInterval->setValue(info.autoReconnectInterval);
- if(info.autoReconnectRetries >= 0) {
- ui.reconnectRetries->setValue(info.autoReconnectRetries);
- ui.unlimitedRetries->setChecked(false);
- } else {
- ui.reconnectRetries->setValue(1);
- ui.unlimitedRetries->setChecked(true);
- }
+ ui.reconnectRetries->setValue(info.autoReconnectRetries);
+ ui.unlimitedRetries->setChecked(info.unlimitedReconnectRetries);
ui.rejoinOnReconnect->setChecked(info.rejoinChannels);
} else {
// just clear widgets
}
info.useAutoReconnect = ui.autoReconnect->isChecked();
info.autoReconnectInterval = ui.reconnectInterval->value();
- if(ui.unlimitedRetries->isChecked()) info.autoReconnectRetries = -1;
- else info.autoReconnectRetries = ui.reconnectRetries->value();
+ info.autoReconnectRetries = ui.reconnectRetries->value();
+ info.unlimitedReconnectRetries = ui.unlimitedRetries->isChecked();
info.rejoinChannels = ui.rejoinOnReconnect->isChecked();
}
/*** Network list ***/
info.useAutoReconnect = true;
info.autoReconnectInterval = 60;
info.autoReconnectRetries = 20;
+ info.unlimitedReconnectRetries = false;
info.useAutoIdentify = false;
info.autoIdentifyService = "NickServ";
info.rejoinChannels = true;
<bool>true</bool>
</property>
<property name="currentIndex" >
- <number>0</number>
+ <number>2</number>
</property>
<widget class="QWidget" name="serversTab" >
<property name="enabled" >