← Back to branch summary

~ubuntu-branches/ubuntu/saucy/quassel/saucy-proposed

« back to all changes in this revision

Viewing changes to src/client/clientsettings.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-02-17 12:49:50 UTC
  • mto: This revision was merged to the branch mainline in revision 59.
  • Revision ID: james.westby@ubuntu.com-20100217124950-v9hajw5d2xa6fszn
Tags: upstream-0.6~beta1
Import upstream version 0.6~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/client/clientsettings.cpp
47
47
}
48
48
 
49
49
void CoreAccountSettings::notify(const QString &key, QObject *receiver, const char *slot) {
50
 
  ClientSettings::notify(QString("%1/%2/%3").arg(Client::currentCoreAccount().toInt()).arg(_subgroup).arg(key), receiver, slot);
 
50
  ClientSettings::notify(QString("%1/%2/%3").arg(Client::currentCoreAccount().accountId().toInt()).arg(_subgroup).arg(key), receiver, slot);
51
51
}
52
52
 
53
53
QList<AccountId> CoreAccountSettings::knownAccounts() {
54
54
  QList<AccountId> ids;
55
 
  foreach(QString key, localChildGroups()) {
 
55
  foreach(const QString &key, localChildGroups()) {
56
56
    AccountId acc = key.toInt();
57
 
    if(acc.isValid()) ids << acc;
 
57
    if(acc.isValid())
 
58
      ids << acc;
58
59
  }
59
60
  return ids;
60
61
}
75
76
  setLocalValue("AutoConnectAccount", account.toInt());
76
77
}
77
78
 
 
79
bool CoreAccountSettings::autoConnectOnStartup() {
 
80
  return localValue("AutoConnectOnStartup", false).toBool();
 
81
}
 
82
 
 
83
void CoreAccountSettings::setAutoConnectOnStartup(bool b) {
 
84
  setLocalValue("AutoConnectOnStartup", b);
 
85
}
 
86
 
 
87
bool CoreAccountSettings::autoConnectToFixedAccount() {
 
88
  return localValue("AutoConnectToFixedAccount", false).toBool();
 
89
}
 
90
 
 
91
void CoreAccountSettings::setAutoConnectToFixedAccount(bool b) {
 
92
  setLocalValue("AutoConnectToFixedAccount", b);
 
93
}
 
94
 
78
95
void CoreAccountSettings::storeAccountData(AccountId id, const QVariantMap &data) {
79
 
  setLocalValue(QString("%1/Connection").arg(id.toInt()), data);
 
96
  QString base = QString::number(id.toInt());
 
97
  foreach(const QString &key, data.keys()) {
 
98
    setLocalValue(base + "/" + key, data.value(key));
 
99
  }
 
100
 
 
101
  // FIXME Migration from 0.5 -> 0.6
 
102
  removeLocalKey(QString("%1/Connection").arg(base));
80
103
}
81
104
 
82
105
QVariantMap CoreAccountSettings::retrieveAccountData(AccountId id) {
83
 
  return localValue(QString("%1/Connection").arg(id.toInt()), QVariant()).toMap();
 
106
  QVariantMap map;
 
107
  QString base = QString::number(id.toInt());
 
108
  foreach(const QString &key, localChildKeys(base)) {
 
109
    map[key] = localValue(base + "/" + key);
 
110
  }
 
111
 
 
112
  // FIXME Migration from 0.5 -> 0.6
 
113
  if(!map.contains("Uuid") && map.contains("Connection")) {
 
114
    QVariantMap oldmap = map.value("Connection").toMap();
 
115
    map["AccountName"] = oldmap.value("AccountName");
 
116
    map["HostName"] = oldmap.value("Host");
 
117
    map["Port"] = oldmap.value("Port");
 
118
    map["User"] = oldmap.value("User");
 
119
    map["Password"] = oldmap.value("Password");
 
120
    map["StorePassword"] = oldmap.value("RememberPasswd");
 
121
    map["UseSSL"] = oldmap.value("useSsl");
 
122
    map["UseProxy"] = oldmap.value("useProxy");
 
123
    map["ProxyHostName"] = oldmap.value("proxyHost");
 
124
    map["ProxyPort"] = oldmap.value("proxyPort");
 
125
    map["ProxyUser"] = oldmap.value("proxyUser");
 
126
    map["ProxyPassword"] = oldmap.value("proxyPassword");
 
127
    map["ProxyType"] = oldmap.value("proxyType");
 
128
 
 
129
    map["AccountId"] = id.toInt();
 
130
    map["Uuid"] = QUuid::createUuid().toString();
 
131
  }
 
132
 
 
133
  return map;
84
134
}
85
135
 
86
136
void CoreAccountSettings::setAccountValue(const QString &key, const QVariant &value) {
87
 
  if(!Client::currentCoreAccount().isValid()) return;
88
 
  setLocalValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().toInt()).arg(_subgroup).arg(key), value);
 
137
  if(!Client::currentCoreAccount().isValid())
 
138
    return;
 
139
  setLocalValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().accountId().toInt()).arg(_subgroup).arg(key), value);
89
140
}
90
141
 
91
142
QVariant CoreAccountSettings::accountValue(const QString &key, const QVariant &def) {
92
 
  if(!Client::currentCoreAccount().isValid()) return QVariant();
93
 
  return localValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().toInt()).arg(_subgroup).arg(key), def);
 
143
  if(!Client::currentCoreAccount().isValid())
 
144
    return QVariant();
 
145
  return localValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().accountId().toInt()).arg(_subgroup).arg(key), def);
94
146
}
95
147
 
96
148
void CoreAccountSettings::setJumpKeyMap(const QHash<int, BufferId> &keyMap) {
98
150
  QHash<int, BufferId>::const_iterator mapIter = keyMap.constBegin();
99
151
  while(mapIter != keyMap.constEnd()) {
100
152
    variants[QString::number(mapIter.key())] = qVariantFromValue(mapIter.value());
101
 
    mapIter++;
 
153
    ++mapIter;
102
154
  }
103
 
  setLocalValue("JumpKeyMap", variants);
 
155
  setAccountValue("JumpKeyMap", variants);
104
156
}
105
157
 
106
158
QHash<int, BufferId> CoreAccountSettings::jumpKeyMap() {
107
159
  QHash<int, BufferId> keyMap;
108
 
  QVariantMap variants = localValue("JumpKeyMap", QVariant()).toMap();
 
160
  QVariantMap variants = accountValue("JumpKeyMap", QVariant()).toMap();
109
161
  QVariantMap::const_iterator mapIter = variants.constBegin();
110
162
  while(mapIter != variants.constEnd()) {
111
163
    keyMap[mapIter.key().toInt()] = mapIter.value().value<BufferId>();
112
 
    mapIter++;
 
164
    ++mapIter;
113
165
  }
114
166
  return keyMap;
115
167
}
118
170
  removeLocalKey(QString("%1").arg(id.toInt()));
119
171
}
120
172
 
 
173
void CoreAccountSettings::clearAccounts() {
 
174
  foreach(const QString &key, localChildGroups())
 
175
    removeLocalKey(key);
 
176
}
 
177
 
 
178
/***********************************************************************************************/
 
179
// CoreConnectionSettings:
 
180
 
 
181
CoreConnectionSettings::CoreConnectionSettings() : ClientSettings("CoreConnection") {}
 
182
 
 
183
void CoreConnectionSettings::setNetworkDetectionMode(NetworkDetectionMode mode) {
 
184
  setLocalValue("NetworkDetectionMode", mode);
 
185
}
 
186
 
 
187
CoreConnectionSettings::NetworkDetectionMode CoreConnectionSettings::networkDetectionMode() {
 
188
#ifdef HAVE_KDE
 
189
  NetworkDetectionMode def = UseSolid;
 
190
#else
 
191
  NetworkDetectionMode def = UsePingTimeout;
 
192
#endif
 
193
  return (NetworkDetectionMode)localValue("NetworkDetectionMode", def).toInt();
 
194
}
 
195
 
 
196
void CoreConnectionSettings::setAutoReconnect(bool autoReconnect) {
 
197
  setLocalValue("AutoReconnect", autoReconnect);
 
198
}
 
199
 
 
200
bool CoreConnectionSettings::autoReconnect() {
 
201
  return localValue("AutoReconnect", true).toBool();
 
202
}
 
203
 
 
204
void CoreConnectionSettings::setPingTimeoutInterval(int interval) {
 
205
  setLocalValue("PingTimeoutInterval", interval);
 
206
}
 
207
 
 
208
int CoreConnectionSettings::pingTimeoutInterval() {
 
209
  return localValue("PingTimeoutInterval", 60).toInt();
 
210
}
 
211
 
 
212
void CoreConnectionSettings::setReconnectInterval(int interval) {
 
213
  setLocalValue("ReconnectInterval", interval);
 
214
}
 
215
 
 
216
int CoreConnectionSettings::reconnectInterval() {
 
217
  return localValue("ReconnectInterval", 60).toInt();
 
218
}
121
219
 
122
220
/***********************************************************************************************/
123
221
// NotificationSettings:
149
247
  return localValue("Highlights/NicksCaseSensitive", false).toBool();
150
248
}
151
249
 
152
 
 
153
 
// ========================================
154
 
//  KnownHostsSettings
155
 
// ========================================
156
 
KnownHostsSettings::KnownHostsSettings()
157
 
  : ClientSettings("KnownHosts")
158
 
{
159
 
}
160
 
 
161
 
QByteArray KnownHostsSettings::knownDigest(const QHostAddress &address) {
162
 
  return localValue(address.toString(), QByteArray()).toByteArray();
163
 
}
164
 
 
165
 
void KnownHostsSettings::saveKnownHost(const QHostAddress &address, const QByteArray &certDigest) {
166
 
  setLocalValue(address.toString(), certDigest);
167
 
}
168
 
 
169
 
bool KnownHostsSettings::isKnownHost(const QHostAddress &address, const QByteArray &certDigest) {
170
 
  return certDigest == localValue(address.toString(), QByteArray()).toByteArray();
171
 
}
172
 
 
173
 
#ifdef HAVE_SSL
174
 
QByteArray KnownHostsSettings::knownDigest(const QSslSocket *socket) {
175
 
  return knownDigest(socket->peerAddress());
176
 
}
177
 
 
178
 
void KnownHostsSettings::saveKnownHost(const QSslSocket *socket) {
179
 
  Q_ASSERT(socket);
180
 
  saveKnownHost(socket->peerAddress(), socket->peerCertificate().digest());
181
 
}
182
 
 
183
 
bool KnownHostsSettings::isKnownHost(const QSslSocket *socket) {
184
 
  Q_ASSERT(socket);
185
 
  return isKnownHost(socket->peerAddress(), socket->peerCertificate().digest());
186
 
}
187
 
#endif
188
 
 
189
 
 
190
250
// ========================================
191
251
//  TabCompletionSettings
192
252
// ========================================