/***************************************************************************
- * Copyright (C) 2005-09 by the Quassel Project *
+ * Copyright (C) 2005-2010 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
// ====================
// Public:
// ====================
+INIT_SYNCABLE_OBJECT(Network)
Network::Network(const NetworkId &networkid, QObject *parent)
: SyncableObject(parent),
_proxy(0),
_prefixModes(QString()),
_useRandomServer(false),
_useAutoIdentify(false),
+ _useSasl(false),
_useAutoReconnect(false),
_autoReconnectInterval(60),
_autoReconnectRetries(10),
info.useAutoIdentify = useAutoIdentify();
info.autoIdentifyService = autoIdentifyService();
info.autoIdentifyPassword = autoIdentifyPassword();
+ info.useSasl = useSasl();
+ info.saslAccount = saslAccount();
+ info.saslPassword = saslPassword();
info.useAutoReconnect = useAutoReconnect();
info.autoReconnectInterval = autoReconnectInterval();
info.autoReconnectRetries = autoReconnectRetries();
if(info.useAutoIdentify != useAutoIdentify()) setUseAutoIdentify(info.useAutoIdentify);
if(info.autoIdentifyService != autoIdentifyService()) setAutoIdentifyService(info.autoIdentifyService);
if(info.autoIdentifyPassword != autoIdentifyPassword()) setAutoIdentifyPassword(info.autoIdentifyPassword);
+ if(info.useSasl != useSasl()) setUseSasl(info.useSasl);
+ if(info.saslAccount != saslAccount()) setSaslAccount(info.saslAccount);
+ if(info.saslPassword != saslPassword()) setSaslPassword(info.saslPassword);
if(info.useAutoReconnect != useAutoReconnect()) setUseAutoReconnect(info.useAutoReconnect);
if(info.autoReconnectInterval != autoReconnectInterval()) setAutoReconnectInterval(info.autoReconnectInterval);
if(info.autoReconnectRetries != autoReconnectRetries()) setAutoReconnectRetries(info.autoReconnectRetries);
IrcUser *Network::newIrcUser(const QString &hostmask, const QVariantMap &initData) {
QString nick(nickFromMask(hostmask).toLower());
if(!_ircUsers.contains(nick)) {
- IrcUser *ircuser = new IrcUser(hostmask, this);
+ IrcUser *ircuser = ircUserFactory(hostmask);
if(!initData.isEmpty()) {
ircuser->fromVariantMap(initData);
ircuser->setInitialized();
_ircUsers[nick] = ircuser;
- emit ircUserAdded(hostmask);
+ SYNC_OTHER(addIrcUser, ARG(hostmask))
+ // emit ircUserAdded(hostmask);
emit ircUserAdded(ircuser);
}
_ircChannels[channelname.toLower()] = channel;
- emit ircChannelAdded(channelname);
+ SYNC_OTHER(addIrcChannel, ARG(channelname))
+ // emit ircChannelAdded(channelname);
emit ircChannelAdded(channel);
}
return _ircChannels[channelname.toLower()];
void Network::setCodecForServer(QTextCodec *codec) {
_codecForServer = codec;
- emit codecForServerSet(codecForServer());
+ QByteArray codecName = codecForServer();
+ SYNC_OTHER(setCodecForServer, ARG(codecName))
+ emit configChanged();
}
QByteArray Network::codecForEncoding() const {
void Network::setCodecForEncoding(QTextCodec *codec) {
_codecForEncoding = codec;
- emit codecForEncodingSet(codecForEncoding());
+ QByteArray codecName = codecForEncoding();
+ SYNC_OTHER(setCodecForEncoding, ARG(codecName))
+ emit configChanged();
}
QByteArray Network::codecForDecoding() const {
void Network::setCodecForDecoding(QTextCodec *codec) {
_codecForDecoding = codec;
- emit codecForDecodingSet(codecForDecoding());
+ QByteArray codecName = codecForDecoding();
+ SYNC_OTHER(setCodecForDecoding, ARG(codecName))
+ emit configChanged();
}
// FIXME use server encoding if appropriate
return info;
}
-
// ====================
// Public Slots:
// ====================
void Network::setNetworkName(const QString &networkName) {
_networkName = networkName;
+ SYNC(ARG(networkName))
emit networkNameSet(networkName);
+ emit configChanged();
}
void Network::setCurrentServer(const QString ¤tServer) {
_currentServer = currentServer;
+ SYNC(ARG(currentServer))
emit currentServerSet(currentServer);
}
setCurrentServer(QString());
removeChansAndUsers();
}
+ SYNC(ARG(connected))
emit connectedSet(connected);
}
void Network::setConnectionState(int state) {
_connectionState = (ConnectionState)state;
//qDebug() << "netstate" << networkId() << networkName() << state;
- emit connectionStateSet(state);
+ SYNC(ARG(state))
emit connectionStateSet(_connectionState);
}
if(!_myNick.isEmpty() && !ircUser(myNick())) {
newIrcUser(myNick());
}
+ SYNC(ARG(nickname))
emit myNickSet(nickname);
}
if(_latency == latency)
return;
_latency = latency;
- emit latencySet(latency);
+ SYNC(ARG(latency))
}
void Network::setIdentity(IdentityId id) {
_identity = id;
+ SYNC(ARG(id))
emit identitySet(id);
+ emit configChanged();
}
void Network::setServerList(const QVariantList &serverList) {
_serverList = fromVariantList<Server>(serverList);
- emit serverListSet(serverList);
+ SYNC(ARG(serverList))
+ emit configChanged();
}
void Network::setUseRandomServer(bool use) {
_useRandomServer = use;
- emit useRandomServerSet(use);
+ SYNC(ARG(use))
+ emit configChanged();
}
void Network::setPerform(const QStringList &perform) {
_perform = perform;
- emit performSet(perform);
+ SYNC(ARG(perform))
+ emit configChanged();
}
void Network::setUseAutoIdentify(bool use) {
_useAutoIdentify = use;
- emit useAutoIdentifySet(use);
+ SYNC(ARG(use))
+ emit configChanged();
}
void Network::setAutoIdentifyService(const QString &service) {
_autoIdentifyService = service;
- emit autoIdentifyServiceSet(service);
+ SYNC(ARG(service))
+ emit configChanged();
}
void Network::setAutoIdentifyPassword(const QString &password) {
_autoIdentifyPassword = password;
- emit autoIdentifyPasswordSet(password);
+ SYNC(ARG(password))
+ emit configChanged();
+}
+
+void Network::setUseSasl(bool use) {
+ _useSasl = use;
+ SYNC(ARG(use))
+ emit configChanged();
+}
+
+void Network::setSaslAccount(const QString &account) {
+ _saslAccount = account;
+ SYNC(ARG(account))
+ emit configChanged();
+}
+
+void Network::setSaslPassword(const QString &password) {
+ _saslPassword = password;
+ SYNC(ARG(password))
+ emit configChanged();
}
void Network::setUseAutoReconnect(bool use) {
_useAutoReconnect = use;
- emit useAutoReconnectSet(use);
+ SYNC(ARG(use))
+ emit configChanged();
}
void Network::setAutoReconnectInterval(quint32 interval) {
_autoReconnectInterval = interval;
- emit autoReconnectIntervalSet(interval);
+ SYNC(ARG(interval))
+ emit configChanged();
}
void Network::setAutoReconnectRetries(quint16 retries) {
_autoReconnectRetries = retries;
- emit autoReconnectRetriesSet(retries);
+ SYNC(ARG(retries))
+ emit configChanged();
}
void Network::setUnlimitedReconnectRetries(bool unlimited) {
_unlimitedReconnectRetries = unlimited;
- emit unlimitedReconnectRetriesSet(unlimited);
+ SYNC(ARG(unlimited))
+ emit configChanged();
}
void Network::setRejoinChannels(bool rejoin) {
_rejoinChannels = rejoin;
- emit rejoinChannelsSet(rejoin);
+ SYNC(ARG(rejoin))
+ emit configChanged();
}
void Network::addSupport(const QString ¶m, const QString &value) {
if(!_supports.contains(param)) {
_supports[param] = value;
- emit supportAdded(param, value);
+ SYNC(ARG(param), ARG(value))
}
}
void Network::removeSupport(const QString ¶m) {
if(_supports.contains(param)) {
_supports.remove(param);
- emit supportRemoved(param);
+ SYNC(ARG(param))
}
}
_prefixModes = defaultPrefixModes;
return;
}
+ // clear the existing modes, just in case we're run multiple times
+ _prefixes = QString();
+ _prefixModes = QString();
// we just assume that in PREFIX are only prefix chars stored
for(int i = 0; i < defaultPrefixes.size(); i++) {
if(prefix.contains(defaultPrefixes[i])) {
- _prefixes += defaultPrefixes[i];
- _prefixModes += defaultPrefixModes[i];
+ _prefixes += defaultPrefixes[i];
+ _prefixModes += defaultPrefixModes[i];
}
}
// check for success
// check if it's only prefix modes
for(int i = 0; i < defaultPrefixes.size(); i++) {
if(prefix.contains(defaultPrefixModes[i])) {
- _prefixes += defaultPrefixes[i];
- _prefixModes += defaultPrefixModes[i];
+ _prefixes += defaultPrefixes[i];
+ _prefixModes += defaultPrefixModes[i];
}
}
// now we've done all we've could...
useRandomServer(false),
useAutoIdentify(false),
autoIdentifyService("NickServ"),
+ useSasl(false),
useAutoReconnect(true),
autoReconnectInterval(60),
autoReconnectRetries(20),
if(useAutoIdentify != other.useAutoIdentify) return false;
if(autoIdentifyService != other.autoIdentifyService) return false;
if(autoIdentifyPassword != other.autoIdentifyPassword) return false;
+ if(useSasl != other.useSasl) return false;
+ if(saslAccount != other.saslAccount) return false;
+ if(saslPassword != other.saslPassword) return false;
if(useAutoReconnect != other.useAutoReconnect) return false;
if(autoReconnectInterval != other.autoReconnectInterval) return false;
if(autoReconnectRetries != other.autoReconnectRetries) return false;
i["UseAutoIdentify"] = info.useAutoIdentify;
i["AutoIdentifyService"] = info.autoIdentifyService;
i["AutoIdentifyPassword"] = info.autoIdentifyPassword;
+ i["UseSasl"] = info.useSasl;
+ i["SaslAccount"] = info.saslAccount;
+ i["SaslPassword"] = info.saslPassword;
i["UseAutoReconnect"] = info.useAutoReconnect;
i["AutoReconnectInterval"] = info.autoReconnectInterval;
i["AutoReconnectRetries"] = info.autoReconnectRetries;
info.useAutoIdentify = i["UseAutoIdentify"].toBool();
info.autoIdentifyService = i["AutoIdentifyService"].toString();
info.autoIdentifyPassword = i["AutoIdentifyPassword"].toString();
+ info.useSasl = i["UseSasl"].toBool();
+ info.saslAccount = i["SaslAccount"].toString();
+ info.saslPassword = i["SaslPassword"].toString();
info.useAutoReconnect = i["UseAutoReconnect"].toBool();
info.autoReconnectInterval = i["AutoReconnectInterval"].toUInt();
info.autoReconnectRetries = i["AutoReconnectRetries"].toInt();
QDebug operator<<(QDebug dbg, const NetworkInfo &i) {
dbg.nospace() << "(id = " << i.networkId << " name = " << i.networkName << " identity = " << i.identity
- << " codecForServer = " << i.codecForServer << " codecForEncoding = " << i.codecForEncoding << " codecForDecoding = " << i.codecForDecoding
- << " serverList = " << i.serverList << " useRandomServer = " << i.useRandomServer << " perform = " << i.perform
- << " useAutoIdentify = " << i.useAutoIdentify << " autoIdentifyService = " << i.autoIdentifyService << " autoIdentifyPassword = " << i.autoIdentifyPassword
- << " useAutoReconnect = " << i.useAutoReconnect << " autoReconnectInterval = " << i.autoReconnectInterval
- << " autoReconnectRetries = " << i.autoReconnectRetries << " unlimitedReconnectRetries = " << i.unlimitedReconnectRetries
- << " rejoinChannels = " << i.rejoinChannels << ")";
+ << " codecForServer = " << i.codecForServer << " codecForEncoding = " << i.codecForEncoding << " codecForDecoding = " << i.codecForDecoding
+ << " serverList = " << i.serverList << " useRandomServer = " << i.useRandomServer << " perform = " << i.perform
+ << " useAutoIdentify = " << i.useAutoIdentify << " autoIdentifyService = " << i.autoIdentifyService << " autoIdentifyPassword = " << i.autoIdentifyPassword
+ << " useSasl = " << i.useSasl << " saslAccount = " << i.saslAccount << " saslPassword = " << i.saslPassword
+ << " useAutoReconnect = " << i.useAutoReconnect << " autoReconnectInterval = " << i.autoReconnectInterval
+ << " autoReconnectRetries = " << i.autoReconnectRetries << " unlimitedReconnectRetries = " << i.unlimitedReconnectRetries
+ << " rejoinChannels = " << i.rejoinChannels << ")";
return dbg.space();
}
projects / quassel.git / blobdiff