You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
462 lines
14 KiB
462 lines
14 KiB
/***************************************************************************
|
|
*
|
|
* tdenetman-devicestore_dbus.cpp - A NetworkManager frontend for KDE
|
|
*
|
|
* Copyright (C) 2005, 2006 Novell, Inc.
|
|
*
|
|
* Author: Helmut Schaa <hschaa@suse.de>, <helmut.schaa@gmx.de>
|
|
* Author: Timothy Pearson <kb9vqf@pearsoncomputing.net>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* 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
|
|
*
|
|
**************************************************************************/
|
|
|
|
// qt headers
|
|
#include <tqwidget.h>
|
|
#include <tqcombobox.h>
|
|
#include <tqtabwidget.h>
|
|
#include <tqpushbutton.h>
|
|
#include <tqwidgetstack.h>
|
|
#include <tqapplication.h>
|
|
#include <tqlabel.h>
|
|
|
|
// kde headers
|
|
#include <kiconloader.h>
|
|
#include <kdebug.h>
|
|
#include <kpushbutton.h>
|
|
|
|
// TQt DBus headers
|
|
#include <tqdbuserror.h>
|
|
#include <tqdbusobjectpath.h>
|
|
|
|
// knm headers
|
|
#include "tdenetman-connection_setting_widget_interface.h"
|
|
#include "tdenetman-connection_settings_dialog.h"
|
|
#include "tdenetman-connection_setting_cdma_widget.h"
|
|
#include "tdenetman-connection_setting_gsm_widget.h"
|
|
#include "tdenetman-connection_setting_ppp_widget.h"
|
|
#include "tdenetman-connection_setting_serial_widget.h"
|
|
#include "tdenetman-connection_setting_wireless_widget.h"
|
|
#include "tdenetman-connection_setting_wireless_security_widget.h"
|
|
#include "tdenetman-connection_setting_ipv4_widget.h"
|
|
#include "tdenetman-connection_setting_info_widget.h"
|
|
#include "tdenetman-wireless_network.h"
|
|
#include "tdenetman-wireless_manager.h"
|
|
|
|
char use_new_wireless_essid = 0;
|
|
TQByteArray new_wireless_essid;
|
|
|
|
using namespace ConnectionSettings;
|
|
|
|
ConnectionSettingsDialogImpl::ConnectionSettingsDialogImpl(TDENetworkConnection* conn, bool new_conn, TQWidget* parent, const char* name, bool modal, WFlags fl)
|
|
: ConnectionSettingsDialog(parent, name, modal, fl)
|
|
, _conn(conn)
|
|
, _new_conn(new_conn)
|
|
{
|
|
updateDialogForDeviceType();
|
|
|
|
// get notified if device combo changes
|
|
connect(btnConnect, TQT_SIGNAL(clicked()), this, TQT_SLOT( slotConnect()) );
|
|
connect(pbNext, TQT_SIGNAL(clicked()), this, TQT_SLOT( slotNext()) );
|
|
connect(pbBack, TQT_SIGNAL(clicked()), this, TQT_SLOT( slotBack()) );
|
|
connect(pbCancel, TQT_SIGNAL(clicked()), this, TQT_SLOT( slotCancel()) );
|
|
connect(pbSave, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotSave()) );
|
|
|
|
// nice images for the buttons
|
|
btnConnect->setIconSet(SmallIcon ("connect_creating", TQIconSet::Automatic));
|
|
pbNext->setIconSet(SmallIcon ("1rightarrow", TQIconSet::Automatic));
|
|
pbBack->setIconSet(SmallIcon ("1leftarrow", TQIconSet::Automatic));
|
|
pbCancel->setIconSet(SmallIcon("cancel", TQIconSet::Automatic));
|
|
pbSave->setIconSet(SmallIcon("ok", TQIconSet::Automatic));
|
|
|
|
// enable or disable buttons accroding to the current state
|
|
slotEnableButtons();
|
|
}
|
|
|
|
ConnectionSettingsDialogImpl::~ConnectionSettingsDialogImpl()
|
|
{
|
|
kdDebug() << "ConnectionSettingsDialogImpl::~ConnectionSettingsDialogImpl" << endl;
|
|
}
|
|
|
|
TQValueList<WidgetInterface*>
|
|
ConnectionSettingsDialogImpl::createWidgetsForWireless(TDENetworkConnection* conn, bool new_conn)
|
|
{
|
|
TQValueList<WidgetInterface*> ret;
|
|
|
|
// widgetlist for wireless connection
|
|
ret.append(new ConnectionSettings::WirelessWidgetImpl(conn, new_conn));
|
|
ret.append(new ConnectionSettings::WirelessSecurityWidgetImpl(conn, new_conn));
|
|
ret.append(new ConnectionSettings::IPv4WidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::InfoWidgetImpl(conn));
|
|
|
|
if (ret.isEmpty())
|
|
{
|
|
// we have a problem here, NetworkManager asked for a setting we do not have
|
|
kdError() << k_funcinfo << "Unexpected setting requested" << endl;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
TQValueList<WidgetInterface*>
|
|
ConnectionSettingsDialogImpl::createWidgetsForWirelessKnownESSID(TDENetworkConnection* conn, bool new_conn, const TQByteArray& essid)
|
|
{
|
|
TQValueList<WidgetInterface*> ret;
|
|
|
|
// Set ESSID
|
|
// _wireless_setting = dynamic_cast<Wireless*> (conn->getSetting(NM_SETTING_WIRELESS_SETTING_NAME));
|
|
// _info_setting = dynamic_cast<Info*> (conn->getSetting(NM_SETTING_CONNECTION_SETTING_NAME));
|
|
// _wireless_setting->setEssid(essid);
|
|
// if (!_hasName)
|
|
// {
|
|
// // the connection has no name yet -> just take the essid for it
|
|
// _info_setting->setName(essid);
|
|
// }
|
|
|
|
// widgetlist for wireless connection
|
|
ret.append(new ConnectionSettings::WirelessSecurityWidgetImpl(conn, new_conn));
|
|
ret.append(new ConnectionSettings::IPv4WidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::InfoWidgetImpl(conn));
|
|
|
|
if (ret.isEmpty())
|
|
{
|
|
// we have a problem here, NetworkManager asked for a setting we do not have
|
|
kdError() << k_funcinfo << "Unexpected setting requested" << endl;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
TQValueList<WidgetInterface*>
|
|
ConnectionSettingsDialogImpl::createWidgetsForWired(TDENetworkConnection* conn, bool new_conn)
|
|
{
|
|
TQValueList<WidgetInterface*> ret;
|
|
|
|
// widgetlist for wired connection
|
|
ret.append(new ConnectionSettings::IPv4WidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::InfoWidgetImpl(conn));
|
|
|
|
return ret;
|
|
}
|
|
|
|
TQValueList<WidgetInterface*>
|
|
ConnectionSettingsDialogImpl::createWidgetsForVPN(TDENetworkConnection* conn, bool new_conn)
|
|
{
|
|
TQValueList<WidgetInterface*> ret;
|
|
|
|
// widgetlist for wired connection
|
|
// ret.append(new ConnectionSettings::VPNWidgetImpl(conn, new_conn));
|
|
ret.append(new ConnectionSettings::InfoWidgetImpl(conn));
|
|
|
|
return ret;
|
|
}
|
|
|
|
TQValueList<WidgetInterface*>
|
|
ConnectionSettingsDialogImpl::createWidgetsForCDMA(TDENetworkConnection* conn, bool new_conn)
|
|
{
|
|
TQValueList<WidgetInterface*> ret;
|
|
|
|
// widgetlist for wired connection
|
|
ret.append(new ConnectionSettings::CDMAWidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::SerialWidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::PPPWidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::IPv4WidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::InfoWidgetImpl(conn));
|
|
|
|
return ret;
|
|
}
|
|
|
|
TQValueList<WidgetInterface*>
|
|
ConnectionSettingsDialogImpl::createWidgetsForGSM(TDENetworkConnection* conn, bool new_conn)
|
|
{
|
|
TQValueList<WidgetInterface*> ret;
|
|
|
|
// widgetlist for wired connection
|
|
ret.append(new ConnectionSettings::GSMWidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::PPPWidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::SerialWidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::IPv4WidgetImpl(conn));
|
|
ret.append(new ConnectionSettings::InfoWidgetImpl(conn));
|
|
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::createWidgetsForConnection(TDENetworkConnection* conn, bool new_conn)
|
|
{
|
|
/*
|
|
Currently two modes:
|
|
* dev == NULL -> Connection should be edited without the wish to start a connection
|
|
* dev != NULL -> A connection should be edited for connection on this device
|
|
*/
|
|
|
|
if (!conn) {
|
|
// TODO: create an empty widget and show an error
|
|
kdWarning() << k_funcinfo << "Not handled yet" << endl;
|
|
}
|
|
else {
|
|
TQValueList<WidgetInterface*> widgets;
|
|
// TODO: move to a factory class
|
|
if (conn->type() == TDENetworkConnectionType::WiFi) {
|
|
if (use_new_wireless_essid == 0) {
|
|
widgets = createWidgetsForWireless(conn, new_conn);
|
|
}
|
|
else {
|
|
createWidgetsForWirelessKnownESSID(conn, new_conn, new_wireless_essid);
|
|
new_wireless_essid = TQByteArray();
|
|
}
|
|
}
|
|
else if (conn->type() == TDENetworkConnectionType::WiredEthernet) {
|
|
widgets = createWidgetsForWired(conn, new_conn);
|
|
}
|
|
else if (conn->type() == TDENetworkConnectionType::Modem) {
|
|
TDEModemConnection* modemconn = dynamic_cast<TDEModemConnection*>(conn);
|
|
if (modemconn) {
|
|
if (modemconn->type == TDEModemConnectionType::CDMA) {
|
|
widgets = createWidgetsForCDMA(conn, new_conn);
|
|
}
|
|
else if (modemconn->type == TDEModemConnectionType::GSM) {
|
|
widgets = createWidgetsForGSM(conn, new_conn);
|
|
}
|
|
else {
|
|
kdWarning() << k_funcinfo << "Specific modem type not handled yet" << endl;
|
|
}
|
|
}
|
|
}
|
|
// else if (conn->getType() == NM_SETTING_VPN_SETTING_NAME) {
|
|
// widgets = createWidgetsForVPN(conn, new_conn);
|
|
// }
|
|
else {
|
|
kdWarning() << k_funcinfo << "Not handled yet" << endl;
|
|
}
|
|
|
|
int id;
|
|
for (TQValueList<WidgetInterface*>::Iterator it = widgets.begin(); it != widgets.end(); ++it) {
|
|
id = wstackSettings->addWidget(*it);
|
|
_widgetIds.append(id);
|
|
}
|
|
|
|
if (widgets.begin() != widgets.end()) {
|
|
activateWidget(*widgets.begin());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::updateDialogForDeviceType()
|
|
{
|
|
// clear our tabview first
|
|
TQWidget *page = NULL;
|
|
while ( (page = wstackSettings->visibleWidget()) != NULL)
|
|
{
|
|
wstackSettings->removeWidget(page);
|
|
delete page;
|
|
}
|
|
|
|
if (_conn) {
|
|
createWidgetsForConnection(_conn, _new_conn);
|
|
}
|
|
else {
|
|
// this should never happen
|
|
TQLabel* lbl = new TQLabel(wstackSettings, "Unknown Device Type");
|
|
wstackSettings->addWidget(lbl);
|
|
|
|
wstackSettings->raiseWidget(lbl);
|
|
}
|
|
}
|
|
|
|
int
|
|
ConnectionSettingsDialogImpl::getDeviceTypeFromConnection(TDENetworkConnection* conn)
|
|
{
|
|
if (conn->type() == TDENetworkConnectionType::WiFi) {
|
|
return TDENetworkDeviceType::WiFi;
|
|
}
|
|
else if (conn->type() == TDENetworkConnectionType::WiredEthernet) {
|
|
return TDENetworkDeviceType::WiredEthernet;
|
|
}
|
|
else if (conn->type() == TDENetworkConnectionType::Modem) {
|
|
return TDENetworkDeviceType::Modem;
|
|
}
|
|
|
|
return TDENetworkDeviceType::Other;
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::slotConnect()
|
|
{
|
|
TDEGlobalNetworkManager* nm = KGlobal::networkManager();
|
|
|
|
// add/save the connection
|
|
nm->saveConnection(_conn);
|
|
|
|
// activate device
|
|
if (_conn && nm) {
|
|
// // VPN connection needs a special specific object
|
|
// if (_conn->getType() == NM_SETTING_VPN_SETTING_NAME) {
|
|
// TQT_DBusObjectPath act_conn = nm->getDefaultActiveConnection();
|
|
// TQT_DBusObjectPath device = nm->getDeviceForActiveConnection(act_conn);
|
|
// nm->ActivateConnectionAsync(id, "org.freedesktop.NetworkManagerUserSettings", _conn->getObjectPath(), device, act_conn, err);
|
|
// }
|
|
// else {
|
|
// we need to call ActivateDevice async
|
|
nm->initiateConnection(_conn->UUID);
|
|
// }
|
|
}
|
|
|
|
emit connectionSaved();
|
|
this->close(true);
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::slotSave()
|
|
{
|
|
// Make sure settings are committed
|
|
TQValueList<int>::Iterator current = _widgetIds.find(wstackSettings->id(wstackSettings->visibleWidget()));
|
|
if (current != _widgetIds.fromLast())
|
|
{
|
|
WidgetInterface* widget = NULL;
|
|
|
|
// let the widget know about it being the active one
|
|
widget = dynamic_cast<WidgetInterface*>(wstackSettings->widget(*current));
|
|
if (widget) {
|
|
deactivateWidget(widget);
|
|
}
|
|
}
|
|
|
|
TDEGlobalNetworkManager* nm = KGlobal::networkManager();
|
|
|
|
// save the connection
|
|
nm->saveConnection(_conn);
|
|
|
|
emit connectionSaved();
|
|
this->close(true);
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::slotCancel()
|
|
{
|
|
close();
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::slotNext()
|
|
{
|
|
TQValueList<int>::Iterator current = _widgetIds.find(wstackSettings->id(wstackSettings->visibleWidget()));
|
|
if (current != _widgetIds.fromLast())
|
|
{
|
|
WidgetInterface* widget = NULL;
|
|
|
|
// let the widget know about it being the active one
|
|
widget = dynamic_cast<WidgetInterface*>(wstackSettings->widget(*current));
|
|
if (widget)
|
|
deactivateWidget(widget);
|
|
|
|
// next widget
|
|
current++;
|
|
|
|
// let the widget know about it being the active one
|
|
widget = dynamic_cast<WidgetInterface*>(wstackSettings->widget(*current));
|
|
if (widget)
|
|
activateWidget(widget);
|
|
}
|
|
slotEnableButtons();
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::slotBack()
|
|
{
|
|
TQValueList<int>::Iterator current = _widgetIds.find(wstackSettings->id(wstackSettings->visibleWidget()));
|
|
if (current != _widgetIds.begin())
|
|
{
|
|
WidgetInterface* widget = NULL;
|
|
|
|
// let the widget know about it being the active one
|
|
widget = dynamic_cast<WidgetInterface*>(wstackSettings->widget(*current));
|
|
if (widget)
|
|
deactivateWidget(widget);
|
|
|
|
// one back
|
|
current--;
|
|
|
|
// let the widget know about it being the active one
|
|
widget = dynamic_cast<WidgetInterface*>(wstackSettings->widget(*current));
|
|
if (widget)
|
|
activateWidget(widget);
|
|
}
|
|
slotEnableButtons();
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::activateWidget(WidgetInterface* widget)
|
|
{
|
|
// allow the widget to press next
|
|
connect(widget, TQT_SIGNAL(next()), this, TQT_SLOT(slotNext()));
|
|
|
|
// allow the widget to do some initialization
|
|
widget->Activate();
|
|
|
|
// show the widget
|
|
wstackSettings->raiseWidget(widget);
|
|
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::deactivateWidget(WidgetInterface* widget)
|
|
{
|
|
// allow the widget to press next
|
|
disconnect(widget, TQT_SIGNAL(next()), this, TQT_SLOT(slotNext()));
|
|
|
|
// allow the widget to do some initialization
|
|
widget->Deactivate();
|
|
}
|
|
|
|
void
|
|
ConnectionSettingsDialogImpl::slotEnableButtons()
|
|
{
|
|
// enable the buttons according to the current state
|
|
|
|
TQValueList<int>::Iterator current = _widgetIds.find(wstackSettings->id(wstackSettings->visibleWidget()));
|
|
bool enabled;
|
|
|
|
/*
|
|
Next: enabled if another widget is available
|
|
*/
|
|
enabled = true;
|
|
if (current == _widgetIds.fromLast()) {
|
|
enabled = false;
|
|
}
|
|
pbNext->setEnabled(enabled);
|
|
|
|
/*
|
|
Back: enabled if the current widget has a predecessor
|
|
*/
|
|
enabled = true;
|
|
if (current == _widgetIds.begin()) {
|
|
enabled = false;
|
|
}
|
|
pbBack->setEnabled(enabled);
|
|
|
|
/*
|
|
Connect: only show connect if the connection is valid
|
|
*/
|
|
if (_conn) {
|
|
TDEGlobalNetworkManager* nm = KGlobal::networkManager();
|
|
btnConnect->setEnabled(nm->verifyConnectionSettings(_conn));
|
|
pbSave->setEnabled(nm->verifyConnectionSettings(_conn));
|
|
}
|
|
}
|
|
|
|
#include "tdenetman-connection_settings_dialog.moc"
|