/***************************************************************************
- * Copyright (C) 2005-08 by the Quassel IRC Team *
+ * Copyright (C) 2005-09 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
#include "networkssettingspage.h"
#include "client.h"
-#include "global.h"
+#include "iconloader.h"
#include "identity.h"
#include "network.h"
-
+#include "util.h"
NetworksSettingsPage::NetworksSettingsPage(QWidget *parent) : SettingsPage(tr("General"), tr("Networks"), parent) {
ui.setupUi(this);
- connectedIcon = QIcon(":/22x22/actions/network-connect");
- connectingIcon = QIcon(":/22x22/actions/gear");
- disconnectedIcon = QIcon(":/22x22/actions/network-disconnect");
+ // set up icons
+ ui.renameNetwork->setIcon(SmallIcon("edit-rename"));
+ ui.addNetwork->setIcon(SmallIcon("list-add"));
+ ui.deleteNetwork->setIcon(SmallIcon("edit-delete"));
+ ui.addServer->setIcon(SmallIcon("list-add"));
+ ui.deleteServer->setIcon(SmallIcon("edit-delete"));
+ ui.editServer->setIcon(SmallIcon("configure"));
+ ui.upServer->setIcon(SmallIcon("go-up"));
+ ui.downServer->setIcon(SmallIcon("go-down"));
+ ui.editIdentities->setIcon(SmallIcon("configure"));
+
+ _ignoreWidgetChanges = false;
+
+ connectedIcon = SmallIcon("network-connect");
+ connectingIcon = SmallIcon("network-wired"); // FIXME network-connecting
+ disconnectedIcon = SmallIcon("network-disconnect");
foreach(int mib, QTextCodec::availableMibs()) {
QByteArray codec = QTextCodec::codecForMib(mib)->name();
ui.sendEncoding->addItem(codec);
ui.recvEncoding->addItem(codec);
+ ui.serverEncoding->addItem(codec);
}
ui.sendEncoding->model()->sort(0);
ui.recvEncoding->model()->sort(0);
+ ui.serverEncoding->model()->sort(0);
currentId = 0;
setEnabled(Client::isConnected()); // need a core connection!
setWidgetStates();
connect(Client::instance(), SIGNAL(identityRemoved(IdentityId)), this, SLOT(clientIdentityRemoved(IdentityId)));
connect(ui.identityList, SIGNAL(currentIndexChanged(int)), this, SLOT(widgetHasChanged()));
- connect(ui.randomServer, SIGNAL(clicked(bool)), this, SLOT(widgetHasChanged()));
+ //connect(ui.randomServer, SIGNAL(clicked(bool)), this, SLOT(widgetHasChanged()));
connect(ui.performEdit, SIGNAL(textChanged()), this, SLOT(widgetHasChanged()));
connect(ui.autoIdentify, SIGNAL(clicked(bool)), this, SLOT(widgetHasChanged()));
connect(ui.autoIdentifyService, SIGNAL(textEdited(const QString &)), this, SLOT(widgetHasChanged()));
connect(ui.autoIdentifyPassword, SIGNAL(textEdited(const QString &)), this, SLOT(widgetHasChanged()));
- connect(ui.useDefaultEncodings, SIGNAL(clicked(bool)), this, SLOT(widgetHasChanged()));
+ connect(ui.useCustomEncodings, SIGNAL(clicked(bool)), this, SLOT(widgetHasChanged()));
connect(ui.sendEncoding, SIGNAL(currentIndexChanged(int)), this, SLOT(widgetHasChanged()));
connect(ui.recvEncoding, SIGNAL(currentIndexChanged(int)), this, SLOT(widgetHasChanged()));
+ connect(ui.serverEncoding, SIGNAL(currentIndexChanged(int)), this, SLOT(widgetHasChanged()));
connect(ui.autoReconnect, SIGNAL(clicked(bool)), this, SLOT(widgetHasChanged()));
connect(ui.reconnectInterval, SIGNAL(valueChanged(int)), this, SLOT(widgetHasChanged()));
connect(ui.reconnectRetries, SIGNAL(valueChanged(int)), this, SLOT(widgetHasChanged()));
}
void NetworksSettingsPage::widgetHasChanged() {
+ if(_ignoreWidgetChanges) return;
bool changed = testHasChanged();
if(changed != hasChanged()) setChangedState(changed);
}
// network list
if(ui.networkList->selectedItems().count()) {
NetworkId id = ui.networkList->selectedItems()[0]->data(Qt::UserRole).value<NetworkId>();
+ const Network *net = 0;
+ if(id > 0) net = Client::network(id);
ui.detailsBox->setEnabled(true);
ui.renameNetwork->setEnabled(true);
ui.deleteNetwork->setEnabled(true);
- ui.connectNow->setEnabled(id > 0
- && (Client::network(id)->connectionState() == Network::Initialized
- || Client::network(id)->connectionState() == Network::Disconnected));
- if(Client::network(id) && Client::network(id)->isConnected()) {
- ui.connectNow->setIcon(disconnectedIcon);
- ui.connectNow->setText(tr("Disconnect"));
+ /* button disabled for now
+ ui.connectNow->setEnabled(net);
+ // && (Client::network(id)->connectionState() == Network::Initialized
+ // || Client::network(id)->connectionState() == Network::Disconnected));
+ if(net) {
+ if(net->connectionState() == Network::Disconnected) {
+ ui.connectNow->setIcon(connectedIcon);
+ ui.connectNow->setText(tr("Connect"));
+ } else {
+ ui.connectNow->setIcon(disconnectedIcon);
+ ui.connectNow->setText(tr("Disconnect"));
+ }
} else {
- ui.connectNow->setIcon(connectedIcon);
- ui.connectNow->setText(tr("Connect"));
- }
+ ui.connectNow->setIcon(QIcon());
+ ui.connectNow->setText(tr("Apply first!"));
+ } */
} else {
ui.renameNetwork->setEnabled(false);
ui.deleteNetwork->setEnabled(false);
- ui.connectNow->setEnabled(false);
+ //ui.connectNow->setEnabled(false);
ui.detailsBox->setEnabled(false);
}
// network details
foreach(QListWidgetItem *i, items) {
NetworkId oldid = i->data(Qt::UserRole).value<NetworkId>();
if(oldid > 0) continue; // only locally created nets should be replaced
- if(oldid == currentId) select = true;
+ if(oldid == currentId) {
+ select = true;
+ currentId = 0;
+ ui.networkList->clearSelection();
+ }
int row = ui.networkList->row(i);
- if(row >= 0) delete ui.networkList->takeItem(row);
+ if(row >= 0) {
+ QListWidgetItem *olditem = ui.networkList->takeItem(row);
+ Q_ASSERT(olditem);
+ delete olditem;
+ }
networkInfos.remove(oldid);
break;
}
if(currentId != 0) saveToNetworkInfo(networkInfos[currentId]);
//ui.identityList->removeItem(ui.identityList->findData(id.toInt()));
foreach(NetworkInfo info, networkInfos.values()) {
- qDebug() << info.networkName << info.networkId << info.identity;
+ //qDebug() << info.networkName << info.networkId << info.identity;
if(info.identity == id) {
if(info.networkId == currentId) ui.identityList->setCurrentIndex(0);
info.identity = 1; // set to default
}
QListWidgetItem *NetworksSettingsPage::networkItem(NetworkId id) const {
- for(int i = 0; i < ui.networkList->count(); i++) {
+ for(int i = 0; i < ui.networkList->count(); i++) {
QListWidgetItem *item = ui.networkList->item(i);
if(item->data(Qt::UserRole).value<NetworkId>() == id) return item;
}
void NetworksSettingsPage::clientNetworkAdded(NetworkId id) {
insertNetwork(id);
- connect(Client::network(id), SIGNAL(updatedRemotely()), this, SLOT(clientNetworkUpdated()));
+ //connect(Client::network(id), SIGNAL(updatedRemotely()), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(identitySet(IdentityId)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(networkNameSet(const QString &)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(serverListSet(QVariantList)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(useRandomServerSet(bool)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(performSet(const QStringList &)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(useAutoIdentifySet(bool)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(autoIdentifyServiceSet(const QString &)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(autoIdentifyPasswordSet(const QString &)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(useAutoReconnectSet(bool)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(autoReconnectIntervalSet(quint32)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(autoReconnectRetriesSet(quint16)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(unlimitedReconnectRetriesSet(bool)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(rejoinChannelsSet(bool)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(codecForServerSet(const QByteArray &)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(codecForEncodingSet(const QByteArray &)), this, SLOT(clientNetworkUpdated()));
+ connect(Client::network(id), SIGNAL(codecForDecodingSet(const QByteArray &)), this, SLOT(clientNetworkUpdated()));
+
connect(Client::network(id), SIGNAL(connectionStateSet(Network::ConnectionState)), this, SLOT(networkConnectionStateChanged(Network::ConnectionState)));
connect(Client::network(id), SIGNAL(connectionError(const QString &)), this, SLOT(networkConnectionError(const QString &)));
}
if(id == currentId) displayNetwork(0);
NetworkInfo info = networkInfos.take(id);
QList<QListWidgetItem *> items = ui.networkList->findItems(info.networkName, Qt::MatchExactly);
- if(items.count()) {
- Q_ASSERT(items[0]->data(Qt::UserRole).value<NetworkId>() == id);
- delete ui.networkList->takeItem(ui.networkList->row(items[0]));
+ foreach(QListWidgetItem *item, items) {
+ if(item->data(Qt::UserRole).value<NetworkId>() == id)
+ delete ui.networkList->takeItem(ui.networkList->row(item));
}
setWidgetStates();
widgetHasChanged();
}
void NetworksSettingsPage::networkConnectionStateChanged(Network::ConnectionState state) {
+ Q_UNUSED(state);
const Network *net = qobject_cast<const Network *>(sender());
if(!net) return;
+ /*
if(net->networkId() == currentId) {
ui.connectNow->setEnabled(state == Network::Initialized || state == Network::Disconnected);
}
+ */
setItemState(net->networkId());
+ setWidgetStates();
}
void NetworksSettingsPage::networkConnectionError(const QString &) {
}
void NetworksSettingsPage::displayNetwork(NetworkId id) {
+ _ignoreWidgetChanges = true;
if(id != 0) {
NetworkInfo info = networkInfos[id];
ui.identityList->setCurrentIndex(ui.identityList->findData(info.identity.toInt()));
ui.serverList->clear();
- foreach(QVariant v, info.serverList) {
- ui.serverList->addItem(QString("%1:%2").arg(v.toMap()["Host"].toString()).arg(v.toMap()["Port"].toUInt()));
+ foreach(Network::Server server, info.serverList) {
+ QListWidgetItem *item = new QListWidgetItem(QString("%1:%2").arg(server.host).arg(server.port));
+ if(server.useSsl)
+ item->setIcon(SmallIcon("document-encrypt"));
+ ui.serverList->addItem(item);
}
- setItemState(id);
- ui.randomServer->setChecked(info.useRandomServer);
+ //setItemState(id);
+ //ui.randomServer->setChecked(info.useRandomServer);
ui.performEdit->setPlainText(info.perform.join("\n"));
ui.autoIdentify->setChecked(info.useAutoIdentify);
ui.autoIdentifyService->setText(info.autoIdentifyService);
if(info.codecForEncoding.isEmpty()) {
ui.sendEncoding->setCurrentIndex(ui.sendEncoding->findText(Network::defaultCodecForEncoding()));
ui.recvEncoding->setCurrentIndex(ui.recvEncoding->findText(Network::defaultCodecForDecoding()));
- ui.useDefaultEncodings->setChecked(true);
+ ui.serverEncoding->setCurrentIndex(ui.serverEncoding->findText(Network::defaultCodecForServer()));
+ ui.useCustomEncodings->setChecked(false);
} else {
ui.sendEncoding->setCurrentIndex(ui.sendEncoding->findText(info.codecForEncoding));
ui.recvEncoding->setCurrentIndex(ui.recvEncoding->findText(info.codecForDecoding));
- ui.useDefaultEncodings->setChecked(false);
+ ui.serverEncoding->setCurrentIndex(ui.serverEncoding->findText(info.codecForServer));
+ ui.useCustomEncodings->setChecked(true);
}
ui.autoReconnect->setChecked(info.useAutoReconnect);
ui.reconnectInterval->setValue(info.autoReconnectInterval);
ui.identityList->setCurrentIndex(-1);
ui.serverList->clear();
ui.performEdit->clear();
+ ui.autoIdentifyService->clear();
+ ui.autoIdentifyPassword->clear();
setWidgetStates();
}
+ _ignoreWidgetChanges = false;
currentId = id;
}
void NetworksSettingsPage::saveToNetworkInfo(NetworkInfo &info) {
info.identity = ui.identityList->itemData(ui.identityList->currentIndex()).toInt();
- info.useRandomServer = ui.randomServer->isChecked();
+ //info.useRandomServer = ui.randomServer->isChecked();
info.perform = ui.performEdit->toPlainText().split("\n");
info.useAutoIdentify = ui.autoIdentify->isChecked();
info.autoIdentifyService = ui.autoIdentifyService->text();
info.autoIdentifyPassword = ui.autoIdentifyPassword->text();
- if(ui.useDefaultEncodings->isChecked()) {
+ if(!ui.useCustomEncodings->isChecked()) {
info.codecForEncoding.clear();
info.codecForDecoding.clear();
+ info.codecForServer.clear();
} else {
info.codecForEncoding = ui.sendEncoding->currentText().toLatin1();
info.codecForDecoding = ui.recvEncoding->currentText().toLatin1();
+ info.codecForServer = ui.serverEncoding->currentText().toLatin1();
}
info.useAutoReconnect = ui.autoReconnect->isChecked();
info.autoReconnectInterval = ui.reconnectInterval->value();
void NetworksSettingsPage::on_addNetwork_clicked() {
QStringList existing;
for(int i = 0; i < ui.networkList->count(); i++) existing << ui.networkList->item(i)->text();
- NetworkEditDlg dlg(QString(), existing, this);
+ NetworkAddDlg dlg(existing, this);
if(dlg.exec() == QDialog::Accepted) {
NetworkId id;
for(id = 1; id <= networkInfos.count(); id++) {
if(!networkInfos.keys().contains(-id.toInt())) break;
}
id = -id.toInt();
- NetworkInfo info;
+
+ NetworkInfo info = dlg.networkInfo();
+ if(info.networkName.isEmpty())
+ return; // sanity check
info.networkId = id;
- info.networkName = dlg.networkName();
info.identity = 1;
// defaults
}
}
+/*
void NetworksSettingsPage::on_connectNow_clicked() {
if(!ui.networkList->selectedItems().count()) return;
NetworkId id = ui.networkList->selectedItems()[0]->data(Qt::UserRole).value<NetworkId>();
const Network *net = Client::network(id);
if(!net) return;
- if(!net->isConnected()) net->requestConnect();
+ if(net->connectionState() == Network::Disconnected) net->requestConnect();
else net->requestDisconnect();
}
+*/
/*** Server list ***/
void NetworksSettingsPage::on_addServer_clicked() {
if(currentId == 0) return;
- ServerEditDlg dlg(QVariantMap(), this);
+ ServerEditDlg dlg(Network::Server(), this);
if(dlg.exec() == QDialog::Accepted) {
networkInfos[currentId].serverList.append(dlg.serverData());
displayNetwork(currentId);
ui.serverList->setCurrentRow(ui.serverList->count()-1);
widgetHasChanged();
}
-
}
void NetworksSettingsPage::on_editServer_clicked() {
void NetworksSettingsPage::on_upServer_clicked() {
int cur = ui.serverList->currentRow();
- QVariant foo = networkInfos[currentId].serverList.takeAt(cur);
- networkInfos[currentId].serverList.insert(cur-1, foo);
+ Network::Server server = networkInfos[currentId].serverList.takeAt(cur);
+ networkInfos[currentId].serverList.insert(cur-1, server);
displayNetwork(currentId);
ui.serverList->setCurrentRow(cur-1);
widgetHasChanged();
void NetworksSettingsPage::on_downServer_clicked() {
int cur = ui.serverList->currentRow();
- QVariant foo = networkInfos[currentId].serverList.takeAt(cur);
- networkInfos[currentId].serverList.insert(cur+1, foo);
+ Network::Server server = networkInfos[currentId].serverList.takeAt(cur);
+ networkInfos[currentId].serverList.insert(cur+1, server);
displayNetwork(currentId);
ui.serverList->setCurrentRow(cur+1);
widgetHasChanged();
}
+/**************************************************************************
+* NetworkAddDlg
+*************************************************************************/
+
+NetworkAddDlg::NetworkAddDlg(const QStringList &exist, QWidget *parent) : QDialog(parent), existing(exist) {
+ ui.setupUi(this);
+ ui.useSSL->setIcon(SmallIcon("document-encrypt"));
+
+ // read preset networks
+ networksFilePath = findDataFilePath("networks.ini");
+ if(!networksFilePath.isEmpty()) {
+ QSettings s(networksFilePath, QSettings::IniFormat);
+ QStringList networks = s.childGroups();
+ foreach(QString s, existing)
+ networks.removeAll(s);
+ if(!networks.isEmpty()) {
+ QMap<QString, QString> sorted;
+ foreach(QString net, networks)
+ sorted[net.toLower()] = net;
+ ui.presetList->addItems(sorted.values());
+ }
+ }
+ if(!ui.presetList->count()) {
+ ui.useManual->setChecked(true);
+ ui.usePreset->setEnabled(false);
+ }
+ connect(ui.networkName, SIGNAL(textChanged(const QString &)), SLOT(setButtonStates()));
+ connect(ui.serverAddress, SIGNAL(textChanged(const QString &)), SLOT(setButtonStates()));
+ setButtonStates();
+}
+
+NetworkInfo NetworkAddDlg::networkInfo() const {
+ NetworkInfo info;
+
+ if(ui.useManual->isChecked()) {
+ info.networkName = ui.networkName->text().trimmed();
+ info.serverList << Network::Server(ui.serverAddress->text().trimmed(), ui.port->value(), ui.serverPassword->text(), ui.useSSL->isChecked());
+ } else {
+ info.networkName = ui.presetList->currentText();
+ QSettings s(networksFilePath, QSettings::IniFormat);
+ s.beginGroup(info.networkName);
+ foreach(QString server, s.value("Servers").toStringList()) {
+ bool ssl = false;
+ QStringList splitserver = server.split(':', QString::SkipEmptyParts);
+ if(splitserver.count() != 2) {
+ qWarning() << "Invalid server entry in networks.conf:" << server;
+ continue;
+ }
+ if(splitserver[1].at(0) == '+')
+ ssl = true;
+ uint port = splitserver[1].toUInt();
+ if(!port) {
+ qWarning() << "Invalid port entry in networks.conf:" << server;
+ continue;
+ }
+ info.serverList << Network::Server(splitserver[0].trimmed(), port, QString(), ssl);
+ }
+ }
+
+ return info;
+}
+
+void NetworkAddDlg::setButtonStates() {
+ bool ok = false;
+ if(ui.usePreset->isChecked() && ui.presetList->count())
+ ok = true;
+ else if(ui.useManual->isChecked()) {
+ ok = !ui.networkName->text().trimmed().isEmpty() && !existing.contains(ui.networkName->text().trimmed())
+ && !ui.serverAddress->text().isEmpty();
+ }
+ ui.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(ok);
+}
+
/**************************************************************************
* NetworkEditDlg
*************************************************************************/
}
QString NetworkEditDlg::networkName() const {
- return ui.networkEdit->text();
+ return ui.networkEdit->text().trimmed();
}
void NetworkEditDlg::on_networkEdit_textChanged(const QString &text) {
- ui.buttonBox->button(QDialogButtonBox::Ok)->setDisabled(text.isEmpty() || existing.contains(text));
+ ui.buttonBox->button(QDialogButtonBox::Ok)->setDisabled(text.isEmpty() || existing.contains(text.trimmed()));
}
-
/**************************************************************************
* ServerEditDlg
*************************************************************************/
-
-ServerEditDlg::ServerEditDlg(const QVariant &_serverData, QWidget *parent) : QDialog(parent) {
+ServerEditDlg::ServerEditDlg(const Network::Server &server, QWidget *parent) : QDialog(parent) {
ui.setupUi(this);
- QVariantMap serverData = _serverData.toMap();
- if(serverData.count()) {
- ui.host->setText(serverData["Host"].toString());
- ui.port->setValue(serverData["Port"].toUInt());
- ui.password->setText(serverData["Password"].toString());
- ui.useSSL->setChecked(serverData["UseSSL"].toBool());
- } else {
- ui.port->setValue(6667);
- }
+ ui.useSSL->setIcon(SmallIcon("document-encrypt"));
+ ui.host->setText(server.host);
+ ui.port->setValue(server.port);
+ ui.password->setText(server.password);
+ ui.useSSL->setChecked(server.useSsl);
+ ui.sslVersion->setCurrentIndex(server.sslVersion);
+ ui.useProxy->setChecked(server.useProxy);
+ ui.proxyType->setCurrentIndex(server.proxyType == QNetworkProxy::Socks5Proxy ? 0 : 1);
+ ui.proxyHost->setText(server.proxyHost);
+ ui.proxyPort->setValue(server.proxyPort);
+ ui.proxyUsername->setText(server.proxyUser);
+ ui.proxyPassword->setText(server.proxyPass);
on_host_textChanged();
}
-QVariant ServerEditDlg::serverData() const {
- QVariantMap _serverData;
- _serverData["Host"] = ui.host->text();
- _serverData["Port"] = ui.port->value();
- _serverData["Password"] = ui.password->text();
- _serverData["UseSSL"] = ui.useSSL->isChecked();
- return _serverData;
+Network::Server ServerEditDlg::serverData() const {
+ Network::Server server(ui.host->text().trimmed(), ui.port->value(), ui.password->text(), ui.useSSL->isChecked());
+ server.sslVersion = ui.sslVersion->currentIndex();
+ server.useProxy = ui.useProxy->isChecked();
+ server.proxyType = ui.proxyType->currentIndex() == 0 ? QNetworkProxy::Socks5Proxy : QNetworkProxy::HttpProxy;
+ server.proxyHost = ui.proxyHost->text();
+ server.proxyPort = ui.proxyPort->value();
+ server.proxyUser = ui.proxyUsername->text();
+ server.proxyPass = ui.proxyPassword->text();
+ return server;
}
void ServerEditDlg::on_host_textChanged() {
- ui.buttonBox->button(QDialogButtonBox::Ok)->setDisabled(ui.host->text().isEmpty());
+ ui.buttonBox->button(QDialogButtonBox::Ok)->setDisabled(ui.host->text().trimmed().isEmpty());
}
/**************************************************************************
connect(Client::instance(), SIGNAL(networkCreated(NetworkId)), this, SLOT(clientEvent()));
connect(Client::instance(), SIGNAL(networkRemoved(NetworkId)), this, SLOT(clientEvent()));
+ foreach(NetworkId id, toRemove) {
+ Client::removeNetwork(id);
+ }
foreach(NetworkInfo info, toCreate) {
Client::createNetwork(info);
}
connect(net, SIGNAL(updatedRemotely()), this, SLOT(clientEvent()));
Client::updateNetwork(info);
}
- foreach(NetworkId id, toRemove) {
- Client::removeNetwork(id);
- }
} else {
qWarning() << "Sync dialog called without stuff to change!";
accept();
projects / quassel.git / blobdiff