39 files changed, 10069 insertions, 33 deletions
diff --git a/noncore/settings/networksettings/main.cpp b/noncore/settings/networksettings/main.cpp index a9d1a87..1b74d62 100644 --- a/noncore/settings/networksettings/main.cpp +++ b/noncore/settings/networksettings/main.cpp diff --git a/noncore/settings/networksettings/ppp/accounts.cpp b/noncore/settings/networksettings/ppp/accounts.cpp new file mode 100644 index 0000000..d902517 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/accounts.cpp @@ -0,0 +1,491 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <qdir.h> +#include <stdlib.h> +#include <qlayout.h> +#include <qtabwidget.h> +#include <qtabdialog.h> +#include <qwhatsthis.h> +#include <qmessagebox.h> + +#include <qapplication.h> +#include <qbuttongroup.h> +#include <qmessagebox.h> +//#include <klocale.h> +#define i18n QObject::tr +//#include <kglobal.h> +//#include <kwin.h> +//#include <kdialogbase.h> +#include <qvgroupbox.h> + +#include "pppdata.h" +#include "accounts.h" +//#include "accounting.h" +//#include "providerdb.h" +#include "edit.h" + +void parseargs(char* buf, char** args); + +AccountWidget::AccountWidget( QWidget *parent, const char *name ) + : QWidget( parent, name ) +{ + int min = 0; + QVBoxLayout *l1 = new QVBoxLayout(this, 10, 10); + + // add a hbox +// QHBoxLayout *l11 = new QHBoxLayout; +// l1->addLayout(l11); + + accountlist_l = new QListBox(this); + accountlist_l->setMinimumSize(160, 128); + connect(accountlist_l, SIGNAL(highlighted(int)), + this, SLOT(slotListBoxSelect(int))); + connect(accountlist_l, SIGNAL(selected(int)), + this, SLOT(editaccount())); + l1->addWidget(accountlist_l, 10); + +// QVBoxLayout *l111 = new QVBoxLayout(this); +// l11->addLayout(l111, 1); + edit_b = new QPushButton(i18n("&Edit..."), this); + connect(edit_b, SIGNAL(clicked()), SLOT(editaccount())); + QWhatsThis::add(edit_b, i18n("Allows you to modify the selected account")); + + min = edit_b->sizeHint().width(); + min = QMAX(70,min); + edit_b->setMinimumWidth(min); + + l1->addWidget(edit_b); + + new_b = new QPushButton(i18n("&New..."), this); + connect(new_b, SIGNAL(clicked()), SLOT(newaccount())); + l1->addWidget(new_b); + QWhatsThis::add(new_b, i18n("Create a new dialup connection\n" + "to the Internet")); + + copy_b = new QPushButton(i18n("Co&py"), this); + connect(copy_b, SIGNAL(clicked()), SLOT(copyaccount())); + l1->addWidget(copy_b); + QWhatsThis::add(copy_b, + i18n("Makes a copy of the selected account. All\n" + "settings of the selected account are copied\n" + "to a new account, that you can modify to fit your\n" + "needs")); + + delete_b = new QPushButton(i18n("De&lete"), this); + connect(delete_b, SIGNAL(clicked()), SLOT(deleteaccount())); + l1->addWidget(delete_b); + QWhatsThis::add(delete_b, + i18n("<p>Deletes the selected account\n\n" + "<font color=\"red\"><b>Use with care!</b></font>")); + + QHBoxLayout *l12 = new QHBoxLayout; + l1->addStretch(1); + l1->addLayout(l12); + +// QVBoxLayout *l121 = new QVBoxLayout; +// l12->addLayout(l121); +// l121->addStretch(1); + // costlabel = new QLabel(i18n("Phone costs:"), parent); +// costlabel->setEnabled(FALSE); +// l121->addWidget(costlabel); + +// costedit = new QLineEdit(parent); +// costedit->setFocusPolicy(QWidget::NoFocus); +// costedit->setFixedHeight(costedit->sizeHint().height()); +// costedit->setEnabled(FALSE); +// l121->addWidget(costedit); +// l121->addStretch(1); +// QString tmp = i18n("<p>This shows the accumulated phone costs\n" +// "for the selected account.\n" +// "\n" +// "<b>Important</b>: If you have more than one \n" +// "account - beware, this is <b>NOT</b> the sum \n" +// "of the phone costs of all your accounts!"); +// QWhatsThis::add(costlabel, tmp); +// QWhatsThis::add(costedit, tmp); + +// vollabel = new QLabel(i18n("Volume:"), parent); +// vollabel->setEnabled(FALSE); +// l121->addWidget(vollabel); + +// voledit = new QLineEdit(parent,"voledit"); +// voledit->setFocusPolicy(QWidget::NoFocus); +// voledit->setFixedHeight(voledit->sizeHint().height()); +// voledit->setEnabled(FALSE); +// l121->addWidget(voledit); +// tmp = i18n("<p>This shows the number of bytes transferred\n" +// "for the selected account (not for all of your\n" +// "accounts. You can select what to display in\n" +// "the accounting dialog.\n" +// "\n" +// "<a href=\"#volaccounting\">More on volume accounting</a>"); + +// QWhatsThis::add(vollabel,tmp); +// QWhatsThis::add(voledit, tmp); + +// QVBoxLayout *l122 = new QVBoxLayout; +// l12->addStretch(1); +// l12->addLayout(l122); + +// l122->addStretch(1); +// reset = new QPushButton(i18n("&Reset..."), parent); +// reset->setEnabled(FALSE); +// connect(reset, SIGNAL(clicked()), +// this, SLOT(resetClicked())); +// l122->addWidget(reset); + +// log = new QPushButton(i18n("&View Logs"), this); +// connect(log, SIGNAL(clicked()), +// this, SLOT(viewLogClicked())); +// l122->addWidget(log); +// l122->addStretch(1); + + //load up account list from gppdata to the list box + if(gpppdata.count() > 0) { + for(int i=0; i <= gpppdata.count()-1; i++) { + gpppdata.setAccountbyIndex(i); + accountlist_l->insertItem(gpppdata.accname()); + } + } + + slotListBoxSelect(accountlist_l->currentItem()); + + l1->activate(); +} + + + +void AccountWidget::slotListBoxSelect(int idx) { + delete_b->setEnabled((bool)(idx != -1)); + edit_b->setEnabled((bool)(idx != -1)); + copy_b->setEnabled((bool)(idx != -1)); + if(idx!=-1) { + QString account = gpppdata.accname(); + gpppdata.setAccountbyIndex(accountlist_l->currentItem()); +// reset->setEnabled(TRUE); +// costlabel->setEnabled(TRUE); +// costedit->setEnabled(TRUE); +// costedit->setText(AccountingBase::getCosts(accountlist_l->text(accountlist_l->currentItem()))); + +// vollabel->setEnabled(TRUE); +// voledit->setEnabled(TRUE); + int bytes = gpppdata.totalBytes(); +// voledit->setText(prettyPrintVolume(bytes)); + gpppdata.setAccount(account); + } else{ + // reset->setEnabled(FALSE); +// costlabel->setEnabled(FALSE); +// costedit->setText(""); +// costedit->setEnabled(FALSE); +// vollabel->setEnabled(FALSE); +// voledit->setText(""); +// voledit->setEnabled(FALSE); + } +} + + +// void AccountWidget::viewLogClicked(){ + +// QApplication::flushX(); +// if(fork() == 0) { +// setgid(getgid()); +// setuid(getuid()); +// system("kppplogview -kppp"); +// _exit(0); +// } +// } + + +// void AccountWidget::resetClicked(){ +// if(accountlist_l->currentItem() == -1) +// return; + +// // QueryReset dlg(this); +// // int what = dlg.exec(); + +// // if(what && QueryReset::COSTS) { +// // emit resetCosts(accountlist_l->text(accountlist_l->currentItem())); +// // costedit->setText("0"); +// // } + +// // if(what && QueryReset::VOLUME) { +// // emit resetVolume(accountlist_l->text(accountlist_l->currentItem())); +// // voledit->setText(prettyPrintVolume(0)); +// // } +// } + + +void AccountWidget::editaccount() { + gpppdata.setAccount(accountlist_l->text(accountlist_l->currentItem())); + + int result = doTab(); + + if(result == QDialog::Accepted) { + accountlist_l->changeItem(gpppdata.accname(),accountlist_l->currentItem()); +// emit resetaccounts(); + gpppdata.save(); + } +} + + +void AccountWidget::newaccount() { + if(accountlist_l->count() == MAX_ACCOUNTS) { + QMessageBox::information(this, "sorry", i18n("Maximum number of accounts reached.")); + return; + } + + int result; +// int query = QMessageBox::information(this, +// i18n("Do you want to use the wizard to create the new account or the " +// "standard, dialog-based setup?\n" +// "The wizard is easier and sufficient in most cases. If you need " +// "very special settings, you might want to try the standard, " +// "dialog-based setup."), +// i18n("Create New Account"), +// i18n("Wizard"), i18n("Dialog Setup"), i18n("Cancel")); + +// switch(query) { +// case QMessageBox::Yes: +// { +// if (gpppdata.newaccount() == -1) +// return; +// // ProviderDB pdb(this); +// // result = pdb.exec(); +// break; +// } +// case QMessageBox::No: + if (gpppdata.newaccount() == -1){ + qDebug("gpppdata.newaccount() == -1"); + return; + } + result = doTab(); +// break; +// default: +// return; +// } + + if(result == QDialog::Accepted) { + accountlist_l->insertItem(gpppdata.accname()); + accountlist_l->setSelected(accountlist_l->findItem(gpppdata.accname()), + true); +// emit resetaccounts(); + gpppdata.save(); + } else + gpppdata.deleteAccount(); +} + + +void AccountWidget::copyaccount() { + if(accountlist_l->count() == MAX_ACCOUNTS) { + QMessageBox::information(this, "sorry", i18n("Maximum number of accounts reached.")); + return; + } + + if(accountlist_l->currentItem()<0) { + QMessageBox::information(this, "sorry", i18n("No account selected.")); + return; + } + + gpppdata.copyaccount(accountlist_l->currentItem()); + + accountlist_l->insertItem(gpppdata.accname()); +// emit resetaccounts(); + gpppdata.save(); +} + + +void AccountWidget::deleteaccount() { + + QString s = i18n("Are you sure you want to delete\nthe account \"%1\"?") + .arg(accountlist_l->text(accountlist_l->currentItem())); + + if(QMessageBox::warning(this, s, i18n("Confirm")) != QMessageBox::Yes) + return; + + if(gpppdata.deleteAccount(accountlist_l->text(accountlist_l->currentItem()))) + accountlist_l->removeItem(accountlist_l->currentItem()); + + emit resetaccounts(); + gpppdata.save(); + + slotListBoxSelect(accountlist_l->currentItem()); + +} + + +int AccountWidget::doTab(){ + QDialog *dlg = new QDialog( this ); + tabWindow = new QTabWidget( dlg ); + // tabWindow = new KDialogBase( KDialogBase::Tabbed, QString::null, +// KDialogBase::Ok|KDialogBase::Cancel, KDialogBase::Ok, +// 0, 0, true); +// KWin::setIcons(tabWindow->winId(), kapp->icon(), kapp->miniIcon()); + bool isnewaccount; + + if(gpppdata.accname().isEmpty()) { + tabWindow->setCaption(i18n("New Account")); + isnewaccount = true; + } else { + QString tit = i18n("Edit Account: "); + tit += gpppdata.accname(); + tabWindow->setCaption(tit); + isnewaccount = false; + } + + dial_w = new DialWidget( tabWindow ); + tabWindow->addTab( dial_w, i18n("Dial") );//, i18n("Dial Setup")), isnewaccount); + ip_w = new IPWidget( tabWindow ); + tabWindow->addTab( ip_w, i18n("IP") );//, i18n("IP Setup")), isnewaccount); + gateway_w = new GatewayWidget( tabWindow ); + tabWindow->addTab( gateway_w, i18n("Gateway") );//, i18n("Gateway Setup")), isnewaccount); + dns_w = new DNSWidget( tabWindow ); + tabWindow->addTab( dns_w, i18n("DNS") );//, i18n("DNS Servers")), isnewaccount); + script_w = new ScriptWidget( tabWindow ); + tabWindow->addTab( script_w, i18n("Login Script") ); //, i18n("Edit Login Script")), isnewaccount); + ExecWidget *exec_w = new ExecWidget( tabWindow ); + tabWindow->addTab( exec_w, i18n("Execute") );//, i18n("Execute Programs")), isnewaccount); +// acct = new AccountingSelector( tabWindow, isnewaccount ); +// tabWindow->addTab( acct, i18n("Accounting")); + + int result = 0; + bool ok = false; + while (!ok){ + + result = dlg->exec(); + ok = true; + + if(result == QDialog::Accepted) { + if (script_w->check()) { + if(dial_w->save()) { + ip_w->save(); + dns_w->save(); + gateway_w->save(); + script_w->save(); + exec_w->save(); +// acct->save(); + } else { + QMessageBox::critical(this, "error", i18n( "You must enter a unique\n" + "account name")); + ok = false; + } + } else { + QMessageBox::critical(this, "error", i18n("Login script has unbalanced " + "loop Start/End")); + ok = false; + } + } + } + + delete tabWindow; + return result; +} + + +QString AccountWidget::prettyPrintVolume(unsigned int n) { + int idx = 0; + const QString quant[] = {i18n("Byte"), i18n("KB"), + i18n("MB"), i18n("GB"), QString::null}; + + float n1 = n; + while(n >= 1024 && quant[idx] != QString::null) { + idx++; + n /= 1024; + } + + int i = idx; + while(i--) + n1 = n1 / 1024.0; + + QString s = QString::number( n1, 'f', idx==0 ? 0 : 1 ); + s += " " + quant[idx]; + return s; +} + + +///////////////////////////////////////////////////////////////////////////// +// +// Queries the user what to reset: costs, volume or both +// +///////////////////////////////////////////////////////////////////////////// +QueryReset::QueryReset(QWidget *parent) : QDialog(parent, 0, true) { +// KWin::setIcons(winId(), kapp->icon(), kapp->miniIcon()); + setCaption(i18n("Reset Accounting")); + + QVBoxLayout *tl = new QVBoxLayout(this, 10, 10); + QVGroupBox *f = new QVGroupBox(i18n("What to Reset"), this); + + QVBoxLayout *l1 = new QVBoxLayout(this, 10, 10); +// costs = new QCheckBox(i18n("Reset the accumulated phone costs"), f); +// costs->setChecked(true); +// l1->addWidget(costs); +// QWhatsThis::add(costs, i18n("Check this to set the phone costs\n" +// "to zero. Typically you'll want to\n" +// "do this once a month.")); + +// volume = new QCheckBox(i18n("Reset volume accounting"), f); +// volume->setChecked(true); +// l1->addWidget(volume); +// QWhatsThis::add(volume, i18n("Check this to set the volume accounting\n" +// "to zero. Typically you'll want to do this\n" +// "once a month.")); + + l1->activate(); + + // this activates the f-layout and sets minimumSize() + f->show(); + + tl->addWidget(f); + + QButtonGroup *bbox = new QButtonGroup(this); +// bbox->addStretch(1); + QPushButton *ok = new QPushButton( bbox, i18n("OK") ); + bbox->insert(ok); + ok->setDefault(true); + QPushButton *cancel = new QPushButton( bbox, i18n("Cancel") ); + bbox->insert(cancel); + + connect(ok, SIGNAL(clicked()), + this, SLOT(accepted())); + connect(cancel, SIGNAL(clicked()), + this, SLOT(reject())); + + bbox->layout(); + tl->addWidget(bbox); + + // TODO: activate if KGroupBox is fixed + // setFixedSize(sizeHint()); +} + + +void QueryReset::accepted() { + int result = costs->isChecked() ? COSTS : 0; + result += volume->isChecked() ? VOLUME : 0; + + done(result); +} + + diff --git a/noncore/settings/networksettings/ppp/accounts.h b/noncore/settings/networksettings/ppp/accounts.h new file mode 100644 index 0000000..751a414 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/accounts.h @@ -0,0 +1,110 @@ +/* -*- C++ -*- + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _ACCOUNTS_H_ +#define _ACCOUNTS_H_ + +#include <qwidget.h> +#include <qdialog.h> +#include <qpushbutton.h> +#include <qlistbox.h> +//#include "acctselect.h" + +class QDialog; +class QCheckBox; +class QLineEdit; +class QTabWidget; +class DialWidget; +class ScriptWidget; +class IPWidget; +class DNSWidget; +class GatewayWidget; + +class AccountWidget : public QWidget { + Q_OBJECT +public: + AccountWidget( QWidget *parent=0, const char *name=0 ); + ~AccountWidget() {} + +private slots: + void editaccount(); + void copyaccount(); + void newaccount(); + void deleteaccount(); + void slotListBoxSelect(int); +// void resetClicked(); +// void viewLogClicked(); + +private: + int doTab(); + +signals: + void resetaccounts(); +// void resetCosts(const QString &); +// void resetVolume(const QString &); + +private: + QString prettyPrintVolume(unsigned int); + + QTabWidget *tabWindow; + DialWidget *dial_w; +// AccountingSelector *acct; + IPWidget *ip_w; + DNSWidget *dns_w; + GatewayWidget *gateway_w; + ScriptWidget *script_w; + +// QPushButton *reset; +// QPushButton *log; +// QLabel *costlabel; +// QLineEdit *costedit; +// QLabel *vollabel; +// QLineEdit *voledit; + + QListBox *accountlist_l; + QPushButton *edit_b; + QPushButton *copy_b; + QPushButton *new_b; + QPushButton *delete_b; +}; + + +class QueryReset : public QDialog { + Q_OBJECT +public: + QueryReset(QWidget *parent); + + enum {COSTS=1, VOLUME=2}; + +private slots: + void accepted(); + +private: + QCheckBox *costs, *volume; +}; + +#endif + diff --git a/noncore/settings/networksettings/ppp/auth.h b/noncore/settings/networksettings/ppp/auth.h new file mode 100644 index 0000000..d497b10 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/auth.h @@ -0,0 +1,36 @@ +/* + * + * kPPP: A pppd Front End for the KDE project + * + * $Id$ + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * This file was contributed by Mario Weilguni <mweilguni@sime.com> + * Thanks Mario! + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef __AUTH__H__ +#define __AUTH__H__ + +#define AUTH_SCRIPT 0 +#define AUTH_PAP 1 +#define AUTH_TERMINAL 2 +#define AUTH_CHAP 3 +#define AUTH_PAPCHAP 4 + +#endif diff --git a/noncore/settings/networksettings/ppp/connect.cpp b/noncore/settings/networksettings/ppp/connect.cpp new file mode 100644 index 0000000..b7e229e --- a/dev/null +++ b/noncore/settings/networksettings/ppp/connect.cpp @@ -0,0 +1,1438 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * Copyright (C) 1998-2001 Harri Porten <porten@kde.org> + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +//#include <config.h> + +#include <qlayout.h> +#include <qregexp.h> + +#include <qapplication.h> +//#include <kdebug.h> +//#include <klocale.h> +#define i18n QObject::tr +#include <qmessagebox.h> +#include <qpushbutton.h> + +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#include <netdb.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include <sys/ioctl.h> +#include <assert.h> + +#ifdef _XPG4_2 +#define __xnet_connect connect +#endif + +#include <errno.h> + +#ifdef HAVE_SYS_PARAM_H +#include <sys/param.h> +#endif + +#ifdef __linux__ +#include "runtests.h" +#endif + +#include "auth.h" +#include "connect.h" +//#include "docking.h" +//#include "main.h" +#include "modem.h" +#include "kpppconfig.h" +#include "pppdata.h" +#include "kpppwidget.h" +//#include "requester.h" +//#include "utils.h" +#define execute_command system + +extern KPPPWidget *p_kppp; + +QString old_hostname; +bool modified_hostname; + + +ConnectWidget::ConnectWidget(QWidget *parent, const char *name) + : QWidget(parent, name), + // initialize some important variables + myreadbuffer(""), + main_timer_ID(0), + vmain(0), + substate(-1), + scriptindex(0), + loopnest(0), + loopend(false), + semaphore(false), + expecting(false), + readbuffer(""), + scanvar(""), + scanning(false), + pausing(false), +// termwindow(0), +// stats(st), + dialnumber(0) +{ + modified_hostname = false; + + QVBoxLayout *tl = new QVBoxLayout(this, 8, 10); + QString tit = i18n("Connecting to: "); + setCaption(tit); + + QHBoxLayout *l0 = new QHBoxLayout(10); + tl->addLayout(l0); + l0->addSpacing(10); + messg = new QLabel(this, "messg"); + messg->setFrameStyle(QFrame::Panel|QFrame::Sunken); + messg->setAlignment(AlignCenter); + messg->setText(i18n("Unable to create modem lock file.")); + messg->setMinimumHeight(messg->sizeHint().height() + 5); + int messw = (messg->sizeHint().width() * 12) / 10; + messw = QMAX(messw,280); + messg->setMinimumWidth(messw); + messg->setText(i18n("Looking for modem...")); + l0->addSpacing(10); + l0->addWidget(messg); + l0->addSpacing(10); + + QHBoxLayout *l1 = new QHBoxLayout(10); + tl->addLayout(l1); + l1->addStretch(1); + + debug = new QPushButton(i18n("Log"), this); + debug->setToggleButton(true); + connect(debug, SIGNAL(clicked()), SIGNAL(toggleDebugWindow())); + + cancel = new QPushButton(i18n("Cancel"), this); + cancel->setFocus(); + connect(cancel, SIGNAL(clicked()), SLOT(cancelbutton())); + + int maxw = QMAX(cancel->sizeHint().width(), + debug->sizeHint().width()); + maxw = QMAX(maxw,65); + debug->setFixedWidth(maxw); + cancel->setFixedWidth(maxw); + l1->addWidget(debug); + l1->addWidget(cancel); + + setFixedSize(sizeHint()); + + pausetimer = new QTimer(this); + connect(pausetimer, SIGNAL(timeout()), SLOT(pause())); + + qApp->processEvents(); + + timeout_timer = new QTimer(this); + connect(timeout_timer, SIGNAL(timeout()), SLOT(script_timed_out())); + + inittimer = new QTimer(this); + connect(inittimer, SIGNAL(timeout()), SLOT(init())); + + if_timeout_timer = new QTimer(this); + connect(if_timeout_timer, SIGNAL(timeout()), SLOT(if_waiting_timed_out())); + + connect(this,SIGNAL(if_waiting_signal()),this,SLOT(if_waiting_slot())); + + prompt = new PWEntry( this, "pw" ); + if_timer = new QTimer(this); + connect(if_timer,SIGNAL(timeout()), SLOT(if_waiting_slot())); +} + + +ConnectWidget::~ConnectWidget() { +} + + +void ConnectWidget::preinit() { + // this is all just to keep the GUI nice and snappy .... + // you have to see to believe ... + messg->setText(i18n("Looking for modem...")); + inittimer->start(100); +} + + +void ConnectWidget::init() { + gpppdata.setpppdError(0); + inittimer->stop(); + vmain = 0; + substate = -1; + expecting = false; + pausing = false; + scriptindex = 0; + myreadbuffer = ""; + scanning = false; + scanvar = ""; + firstrunID = true; + firstrunPW = true; +// stats->totalbytes = 0; + dialnumber = 0; + + p_kppp->con_speed = ""; + +// p_kppp->setQuitOnDisconnect (p_kppp->quitOnDisconnect() || gpppdata.quit_on_disconnect()); + + comlist = &gpppdata.scriptType(); + arglist = &gpppdata.script(); + + QString tit = i18n("Connecting to: %1").arg(gpppdata.accname()); + setCaption(tit); + + qApp->processEvents(); + + // run the "before-connect" command + if (!gpppdata.command_before_connect().isEmpty()) { + messg->setText(i18n("Running pre-startup command...")); + emit debugMessage(i18n("Running pre-startup command...")); + + qApp->processEvents(); + QApplication::flushX(); + pid_t id = execute_command(gpppdata.command_before_connect()); +// int i, status; + +// do { +// qApp->processEvents(); +// i = waitpid(id, &status, WNOHANG); +// usleep(100000); +// } while (i == 0 && errno == 0); + } + + int lock = Modem::modem->lockdevice(); + + if (lock == 1) { + messg->setText(i18n("Modem device is locked.")); + vmain = 20; // wait until cancel is pressed + return; + } + + if (lock == -1) { + messg->setText(i18n("Unable to create modem lock file.")); + vmain = 20; // wait until cancel is pressed + return; + } + + if(Modem::modem->opentty()) { + messg->setText(Modem::modem->modemMessage()); + qApp->processEvents(); + if(Modem::modem->hangup()) { + + qApp->processEvents(); + + semaphore = false; + + Modem::modem->stop(); + Modem::modem->notify(this, SLOT(readChar(unsigned char))); + + // if we are stuck anywhere we will time out + timeout_timer->start(gpppdata.modemTimeout()*1000); + + // this timer will run the script etc. + main_timer_ID = startTimer(10); + + return; + } + } + + // initialization failed + messg->setText(Modem::modem->modemMessage()); + vmain = 20; // wait until cancel is pressed + Modem::modem->unlockdevice(); +} + + +void ConnectWidget::timerEvent(QTimerEvent *) { + if (semaphore || pausing) + return; + + if(vmain == 0) { +#ifdef DEBUG_WO_DIALING + vmain = 10; + return; +#endif + + assert(PPPData::NumInitStrings > 0); + // first init string ? + if(substate == -1) { + messg->setText(i18n("Initializing modem...")); + emit debugMessage(i18n("Initializing modem...")); + substate = 0; + } + + QString initStr = gpppdata.modemInitStr(substate); + if (!initStr.isEmpty()) { + // send a carriage return and then wait a bit so that the modem will + // let us issue commands. + if(gpppdata.modemPreInitDelay() > 0) { + usleep(gpppdata.modemPreInitDelay() * 5000); + writeline(""); + usleep(gpppdata.modemPreInitDelay() * 5000); + } + setExpect(gpppdata.modemInitResp()); + writeline(initStr); + usleep(gpppdata.modemInitDelay() * 10000); // 0.01 - 3.0 sec + } + + substate++; + + /* + * FIXME after 3.0: Make it possible to disable ATS11 since it + * seems to be incompatible with some ISDN adapters (e.g. DataBox + * Speed Dragon). Even better would be to detect this when doing + * a "Modem Query" + */ + if (MODEM_TONEDURATION != gpppdata.modemToneDuration()) + vmain = 5; + else + vmain = 3; + + return; + } + + if (vmain == 5) { + if(!expecting) { + QString sToneDuration = "ATS11=" + QString::number(gpppdata.modemToneDuration()); + QString msg = i18n("Setting ") + sToneDuration; + messg->setText(msg); + emit debugMessage(msg); + setExpect(gpppdata.modemInitResp()); + writeline(sToneDuration); + } + vmain = 3; + return; + } + + if(vmain == 3) { + if(!expecting) { + // done with all init strings ? + if(substate < PPPData::NumInitStrings) { + vmain = 0; + return; + } + substate = -1; + // skip setting the volume if command is empty + if(gpppdata.volumeInitString().isEmpty()) { + vmain = 4; + return; + } + messg->setText(i18n("Setting speaker volume...")); + emit debugMessage(i18n("Setting speaker volume...")); + + setExpect(gpppdata.modemInitResp()); + QString vol("AT"); + vol += gpppdata.volumeInitString(); + writeline(vol); + usleep(gpppdata.modemInitDelay() * 10000); // 0.01 - 3.0 sec + vmain = 4; + return; + } + } + + if(vmain == 4) { + if(!expecting) { + if(!gpppdata.waitForDialTone()) { + QString msg = i18n("Turning off dial tone waiting..."); + messg->setText(msg); + emit debugMessage(msg); + setExpect(gpppdata.modemInitResp()); + writeline(gpppdata.modemNoDialToneDetectionStr()); + } + vmain = 1; + return; + } + } + + // dial the number and wait to connect + if(vmain == 1) { + if(!expecting) { + + timeout_timer->stop(); + timeout_timer->start(gpppdata.modemTimeout()*1000); + + QStringList &plist = gpppdata.phonenumbers(); + QString bmarg= gpppdata.dialPrefix(); + bmarg += *plist.at(dialnumber); + QString bm = i18n("Dialing %1").arg(bmarg); + messg->setText(bm); + emit debugMessage(bm); + + QString pn = gpppdata.modemDialStr(); + pn += gpppdata.dialPrefix(); + pn += *plist.at(dialnumber); + if(++dialnumber >= plist.count()) + dialnumber = 0; + writeline(pn); + + setExpect(gpppdata.modemConnectResp()); + vmain = 100; + return; + } + } + + // wait for connect, but redial if BUSY or wait for user cancel + // if NO CARRIER or NO DIALTONE + if(vmain == 100) { + if(!expecting) { + myreadbuffer = gpppdata.modemConnectResp(); + setExpect("\n"); + vmain = 101; + return; + } + + if(readbuffer.contains(gpppdata.modemBusyResp())) { + timeout_timer->stop(); + timeout_timer->start(gpppdata.modemTimeout()*1000); + + messg->setText(i18n("Line busy. Hanging up...")); + emit debugPutChar('\n'); + Modem::modem->hangup(); + + if(gpppdata.busyWait() > 0) { + QString bm = i18n("Line busy. Waiting: %1 seconds").arg(gpppdata.busyWait()); + messg->setText(bm); + emit debugMessage(bm); + + pausing = true; + + pausetimer->start(gpppdata.busyWait()*1000, true); + timeout_timer->stop(); + } + + Modem::modem->setDataMode(false); + vmain = 0; + substate = -1; + return; + } + + if(readbuffer.contains(gpppdata.modemNoDialtoneResp())) { + timeout_timer->stop(); + + messg->setText(i18n("No Dialtone")); + vmain = 20; + Modem::modem->unlockdevice(); + return; + } + + if(readbuffer.contains(gpppdata.modemNoCarrierResp())) { + timeout_timer->stop(); + + messg->setText(i18n("No Carrier")); + vmain = 20; + Modem::modem->unlockdevice(); + return; + } + } + + // wait for newline after CONNECT response (so we get the speed) + if(vmain == 101) { + if(!expecting) { + Modem::modem->setDataMode(true); // modem will no longer respond to AT commands + + emit startAccounting(); +// p_kppp->con_win->startClock(); + + vmain = 2; + scriptTimeout=gpppdata.modemTimeout()*1000; + return; + } + } + + // execute the script + if(vmain == 2) { + if(!expecting && !pausing && !scanning) { + + timeout_timer->stop(); + timeout_timer->start(scriptTimeout); + + if((unsigned) scriptindex < comlist->count()) { + scriptCommand = *(comlist->at(scriptindex)); + scriptArgument = *(arglist->at(scriptindex)); + } else { + qDebug( "End of script" ); + vmain = 10; + return; + } + + if (scriptCommand == "Scan") { + QString bm = i18n("Scanning %1").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + setScan(scriptArgument); + scriptindex++; + return; + } + + if (scriptCommand == "Save") { + QString bm = i18n("Saving %1").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + if (scriptArgument.lower() == "password") { + gpppdata.setPassword(scanvar); + p_kppp->setPW_Edit(scanvar); + if(gpppdata.storePassword()) + gpppdata.setStoredPassword(scanvar); + firstrunPW = true; + } + + scriptindex++; + return; + } + + + if (scriptCommand == "Send" || scriptCommand == "SendNoEcho") { + QString bm = i18n("Sending %1"); + + // replace %USERNAME% and %PASSWORD% + QString arg = scriptArgument; + QRegExp re1("%USERNAME%"); + QRegExp re2("%PASSWORD%"); + arg = arg.replace(re1, gpppdata.storedUsername()); + arg = arg.replace(re2, gpppdata.storedPassword()); + + if (scriptCommand == "Send") + bm = bm.arg(scriptArgument); + else { + for(uint i = 0; i < scriptArgument.length(); i++) + bm = bm.arg("*"); + } + + messg->setText(bm); + emit debugMessage(bm); + + writeline(scriptArgument); + scriptindex++; + return; + } + + if (scriptCommand == "Expect") { + QString bm = i18n("Expecting %1").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + // The incrementing of the scriptindex MUST be before the + // call to setExpect otherwise the expect will miss a string that is + // already in the buffer. + scriptindex++; + setExpect(scriptArgument); + return; + } + + + if (scriptCommand == "Pause") { + QString bm = i18n("Pause %1 seconds").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + pausing = true; + + pausetimer->start(scriptArgument.toInt()*1000, true); + timeout_timer->stop(); + + scriptindex++; + return; + } + + if (scriptCommand == "Timeout") { + + timeout_timer->stop(); + + QString bm = i18n("Timeout %1 seconds").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + scriptTimeout=scriptArgument.toInt()*1000; + timeout_timer->start(scriptTimeout); + + scriptindex++; + return; + } + + if (scriptCommand == "Hangup") { + messg->setText(i18n("Hangup")); + emit debugMessage(i18n("Hangup")); + + writeline(gpppdata.modemHangupStr()); + setExpect(gpppdata.modemHangupResp()); + + scriptindex++; + return; + } + + if (scriptCommand == "Answer") { + + timeout_timer->stop(); + + messg->setText(i18n("Answer")); + emit debugMessage(i18n("Answer")); + + setExpect(gpppdata.modemRingResp()); + vmain = 150; + return; + } + + if (scriptCommand == "ID") { + QString bm = i18n("ID %1").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + QString idstring = gpppdata.storedUsername(); + + if(!idstring.isEmpty() && firstrunID) { + // the user entered an Id on the main kppp dialog + writeline(idstring); + firstrunID = false; + scriptindex++; + } + else { + // the user didn't enter and Id on the main kppp dialog + // let's query for an ID + /* if not around yet, then post window... */ + if (prompt->Consumed()) { + if (!(prompt->isVisible())) { + prompt->setPrompt(scriptArgument); + prompt->setEchoModeNormal(); + prompt->show(); + } + } else { + /* if prompt withdrawn ... then, */ + if(!(prompt->isVisible())) { + writeline(prompt->text()); + prompt->setConsumed(); + scriptindex++; + return; + } + /* replace timeout value */ + } + } + } + + if (scriptCommand == "Password") { + QString bm = i18n("Password %1").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + QString pwstring = gpppdata.password(); + + if(!pwstring.isEmpty() && firstrunPW) { + // the user entered a password on the main kppp dialog + writeline(pwstring); + firstrunPW = false; + scriptindex++; + } + else { + // the user didn't enter a password on the main kppp dialog + // let's query for a password + /* if not around yet, then post window... */ + if (prompt->Consumed()) { + if (!(prompt->isVisible())) { + prompt->setPrompt(scriptArgument); + prompt->setEchoModePassword(); + prompt->show(); + } + } else { + /* if prompt withdrawn ... then, */ + if(!(prompt->isVisible())) { + p_kppp->setPW_Edit(prompt->text()); + writeline(prompt->text()); + prompt->setConsumed(); + scriptindex++; + return; + } + /* replace timeout value */ + } + } + } + + if (scriptCommand == "Prompt") { + QString bm = i18n("Prompting %1"); + + // if the scriptindex (aka the prompt text) includes a ## marker + // this marker should get substituted with the contents of our stored + // variable (from the subsequent scan). + + QString ts = scriptArgument; + int vstart = ts.find( "##" ); + if( vstart != -1 ) { + ts.remove( vstart, 2 ); + ts.insert( vstart, scanvar ); + } + + bm = bm.arg(ts); + messg->setText(bm); + emit debugMessage(bm); + + /* if not around yet, then post window... */ + if (prompt->Consumed()) { + if (!(prompt->isVisible())) { + prompt->setPrompt( ts ); + prompt->setEchoModeNormal(); + prompt->show(); + } + } else { + /* if prompt withdrawn ... then, */ + if (!(prompt->isVisible())) { + writeline(prompt->text()); + prompt->setConsumed(); + scriptindex++; + return; + } + /* replace timeout value */ + } + } + + if (scriptCommand == "PWPrompt") { + QString bm = i18n("PW Prompt %1").arg(scriptArgument); + messg->setText(bm); + emit debugMessage(bm); + + /* if not around yet, then post window... */ + if (prompt->Consumed()) { + if (!(prompt->isVisible())) { + prompt->setPrompt(scriptArgument); + prompt->setEchoModePassword(); + prompt->show(); + } + } else { + /* if prompt withdrawn ... then, */ + if (!(prompt->isVisible())) { + writeline(prompt->text()); + prompt->setConsumed(); + scriptindex++; + return; + } + /* replace timeout value */ + } + } + + if (scriptCommand == "LoopStart") { + + QString bm = i18n("Loop Start %1").arg(scriptArgument); + + // The incrementing of the scriptindex MUST be before the + // call to setExpect otherwise the expect will miss a string that is + // already in the buffer. + scriptindex++; + + if ( loopnest > (MAXLOOPNEST-2) ) { + bm += i18n("ERROR: Nested too deep, ignored."); + vmain=20; + cancelbutton(); + QMessageBox::critical(0, "error", i18n("Loops nested too deeply!")); + } else { + setExpect(scriptArgument); + loopstartindex[loopnest] = scriptindex; + loopstr[loopnest] = scriptArgument; + loopend = false; + loopnest++; + } + messg->setText(bm); + emit debugMessage(bm); + + } + + if (scriptCommand == "LoopEnd") { + QString bm = i18n("Loop End %1").arg(scriptArgument); + if ( loopnest <= 0 ) { + bm = i18n("LoopEnd without matching Start! Line: %1").arg(bm); + vmain=20; + cancelbutton(); + QMessageBox::critical(0, "error", bm); + return; + } else { + // NB! The incrementing of the scriptindex MUST be before the + // call to setExpect otherwise the expect will miss a string + // that is already in the buffer. + scriptindex++; + setExpect(scriptArgument); + loopnest--; + loopend = true; + } + messg->setText(bm); + emit debugMessage(bm); + + } + } + } + + // this is a subroutine for the "Answer" script option + + if(vmain == 150) { + if(!expecting) { + writeline(gpppdata.modemAnswerStr()); + setExpect(gpppdata.modemAnswerResp()); + + vmain = 2; + scriptindex++; + return; + } + } + + if(vmain == 30) { +// if (termwindow->isVisible()) +// return; +// if (termwindow->pressedContinue()) +// vmain = 10; +// else + cancelbutton(); + } + + if(vmain == 10) { + if(!expecting) { + + int result; + + timeout_timer->stop(); + if_timeout_timer->stop(); // better be sure. + + // stop reading of data + Modem::modem->stop(); + + if(gpppdata.authMethod() == AUTH_TERMINAL) { + // if (termwindow) { +// delete termwindow; +// termwindow = 0L; +// this->show(); +// } else { +// termwindow = new LoginTerm(0L, 0L); +// hide(); +// termwindow->show(); +// vmain = 30; +// return; +// } + } + + // Close the tty. This prevents the QTimer::singleShot() in + // Modem::readtty() from re-enabling the socket notifier. + // The port is still held open by the helper process. + Modem::modem->closetty(); + + killTimer( main_timer_ID ); + + if_timeout_timer->start(gpppdata.pppdTimeout()*1000); + qDebug( "started if timeout timer with %i", gpppdata.pppdTimeout()*1000); + + // find out PPP interface and notify the stats module +// stats->setUnit(pppInterfaceNumber()); + + qApp->flushX(); + semaphore = true; + result = execppp(); + + emit debugMessage(i18n("Starting pppd...")); + qDebug("execppp() returned with return-code %i", result ); + + if(result) { + if(!gpppdata.autoDNS()) + adddns(); + + // O.K we are done here, let's change over to the if_waiting loop + // where we wait for the ppp if (interface) to come up. + + emit if_waiting_signal(); + } else { + + // starting pppd wasn't successful. Error messages were + // handled by execppp(); + if_timeout_timer->stop(); + this->hide(); + messg->setText(""); + p_kppp->quit_b->setFocus(); + p_kppp->show(); + qApp->processEvents(); + Modem::modem->hangup(); + emit stopAccounting(); +// p_kppp->con_win->stopClock(); + Modem::modem->closetty(); + Modem::modem->unlockdevice(); + + } + + return; + } + } + + // this is a "wait until cancel" entry + + if(vmain == 20) { + } +} + + +void ConnectWidget::set_con_speed_string() { + // Here we are trying to determine the speed at which we are connected. + // Usually the modem responds after connect with something like + // CONNECT 115200, so all we need to do is find the number after CONNECT + // or whatever the modemConnectResp() is. + p_kppp->con_speed = Modem::modem->parseModemSpeed(myreadbuffer); +} + + + +void ConnectWidget::readChar(unsigned char c) { + if(semaphore) + return; + + readbuffer += c; + myreadbuffer += c; + + // While in scanning mode store each char to the scan buffer + // for use in the prompt command + if( scanning ) + scanbuffer += c; + + // add to debug window + emit debugPutChar(c); + + checkBuffers(); +} + + +void ConnectWidget::checkBuffers() { + // Let's check if we are finished with scanning: + // The scanstring have to be in the buffer and the latest character + // was a carriage return or an linefeed (depending on modem setup) + if( scanning && scanbuffer.contains(scanstr) && + ( scanbuffer.right(1) == "\n" || scanbuffer.right(1) == "\r") ) { + scanning = false; + + int vstart = scanbuffer.find( scanstr ) + scanstr.length(); + scanvar = scanbuffer.mid( vstart, scanbuffer.length() - vstart); + scanvar = scanvar.stripWhiteSpace(); + + // Show the Variabel content in the debug window + QString sv = i18n("Scan Var: %1").arg(scanvar); + emit debugMessage(sv); + } + + if(expecting) { + if(readbuffer.contains(expectstr)) { + expecting = false; + // keep everything after the expected string + readbuffer.remove(0, readbuffer.find(expectstr) + expectstr.length()); + + QString ts = i18n("Found: %1").arg(expectstr); + emit debugMessage(ts); + + if (loopend) { + loopend=false; + } + } + + if (loopend && readbuffer.contains(loopstr[loopnest])) { + expecting = false; + readbuffer = ""; + QString ts = i18n("Looping: %1").arg(loopstr[loopnest]); + emit debugMessage(ts); + scriptindex = loopstartindex[loopnest]; + loopend = false; + loopnest++; + } + // notify event loop if expected string was found + if(!expecting) + timerEvent((QTimerEvent *) 0); + } +} + + + +void ConnectWidget::pause() { + pausing = false; + pausetimer->stop(); +} + + +void ConnectWidget::cancelbutton() { + Modem::modem->stop(); + killTimer(main_timer_ID); + timeout_timer->stop(); + if_timer->stop(); + if_timeout_timer->stop(); + +// if (termwindow) { +// delete termwindow; +// termwindow = 0L; +// this->show(); +// } + + messg->setText(i18n("One moment please...")); + + // just to be sure + Modem::modem->removeSecret(AUTH_PAP); + Modem::modem->removeSecret(AUTH_CHAP); + removedns(); + + qApp->processEvents(); + + Modem::modem->killPPPDaemon(); + Modem::modem->hangup(); + + this->hide(); + messg->setText(""); + p_kppp->quit_b->setFocus(); + p_kppp->show(); + emit stopAccounting(); // just to be sure +// p_kppp->con_win->stopClock(); + Modem::modem->closetty(); + Modem::modem->unlockdevice(); + + //abort prompt window... + if (prompt->isVisible()) { + prompt->hide(); + } + prompt->setConsumed(); + +// if(p_kppp->quitOnDisconnect()) +// qApp->exit(0); +} + + +void ConnectWidget::script_timed_out() { + if(vmain == 20) { // we are in the 'wait for the user to cancel' state + timeout_timer->stop(); + emit stopAccounting(); +// p_kppp->con_win->stopClock(); + return; + } + + if (prompt->isVisible()) + prompt->hide(); + + prompt->setConsumed(); + messg->setText(i18n("Script timed out!")); + Modem::modem->hangup(); + emit stopAccounting(); +// p_kppp->con_win->stopClock(); + + vmain = 0; // let's try again. + substate = -1; +} + + +void ConnectWidget::setScan(const QString &n) { + scanning = true; + scanstr = n; + scanbuffer = ""; + + QString ts = i18n("Scanning: %1").arg(n); + emit debugMessage(ts); +} + + +void ConnectWidget::setExpect(const QString &n) { + expecting = true; + expectstr = n; + + QString ts = i18n("Expecting: %1").arg(n); + ts.replace(QRegExp("\n"), "<LF>"); + emit debugMessage(ts); + + // check if the expected string is in the read buffer already. + checkBuffers(); +} + + +void ConnectWidget::if_waiting_timed_out() { + if_timer->stop(); + if_timeout_timer->stop(); + qDebug("if_waiting_timed_out()"); + + gpppdata.setpppdError(E_IF_TIMEOUT); + + // let's kill the stuck pppd + Modem::modem->killPPPDaemon(); + + emit stopAccounting(); +// p_kppp->con_win->stopClock(); + + + // killing ppp will generate a SIGCHLD which will be caught in pppdie() + // in main.cpp what happens next will depend on the boolean + // reconnect_on_disconnect which is set in ConnectWidget::init(); +} + +void ConnectWidget::pppdDied() +{ + if_timer->stop(); + if_timeout_timer->stop(); +} + +void ConnectWidget::if_waiting_slot() { + messg->setText(i18n("Logging on to network...")); + +// if(!stats->ifIsUp()) { + +// if(gpppdata.pppdError() != 0) { +// // we are here if pppd died immediately after starting it. +// pppdDied(); +// // error message handled in main.cpp: sigPPPDDied() +// return; +// } + +// if_timer->start(100, TRUE); // single shot +// return; +// } + + // O.K the ppp interface is up and running + // give it a few time to come up completly (0.2 seconds) + if_timeout_timer->stop(); + if_timer->stop(); + usleep(200000); + + if(gpppdata.autoDNS()) + addpeerdns(); + + // Close the debugging window. If we are connected, we + // are not really interested in debug output + emit closeDebugWindow(); +// p_kppp->statdlg->take_stats(); // start taking ppp statistics + auto_hostname(); + + if(!gpppdata.command_on_connect().isEmpty()) { + messg->setText(i18n("Running startup command...")); + + // make sure that we don't get any async errors + qApp->flushX(); + execute_command(gpppdata.command_on_connect()); + messg->setText(i18n("Done")); + } + + // remove the authentication file + Modem::modem->removeSecret(AUTH_PAP); + Modem::modem->removeSecret(AUTH_CHAP); + + emit debugMessage(i18n("Done")); + set_con_speed_string(); + +// p_kppp->con_win->setConnectionSpeed(p_kppp->con_speed); + this->hide(); + messg->setText(""); + + // prepare the con_win so as to have the right size for + // accounting / non-accounting mode +// if(p_kppp->acct != 0) +// p_kppp->con_win->accounting(p_kppp->acct->running()); +// else +// p_kppp->con_win->accounting(false); + + if (gpppdata.get_dock_into_panel()) { +// DockWidget::dock_widget->show(); +// DockWidget::dock_widget->take_stats(); +// this->hide(); + } + else { +// p_kppp->con_win->show(); + + if(gpppdata.get_iconify_on_connect()) { + // p_kppp->con_win->showMinimized(); + } + } + + Modem::modem->closetty(); +} + + +bool ConnectWidget::execppp() { + QString command; + + command = "pppd"; + + // as of version 2.3.6 pppd falls back to the real user rights when + // opening a device given in a command line. To avoid permission conflicts + // we'll simply leave this argument away. pppd will then use the default tty + // which is the serial port we connected stdin/stdout to in opener.cpp. + // command += " "; + // command += gpppdata.modemDevice(); + + command += " " + gpppdata.speed(); + + command += " -detach"; + + if(gpppdata.ipaddr() != "0.0.0.0" || + gpppdata.gateway() != "0.0.0.0") { + if(gpppdata.ipaddr() != "0.0.0.0") { + command += " "; + command += gpppdata.ipaddr(); + command += ":"; + } + else { + command += " "; + command += ":"; + } + + if(gpppdata.gateway() != "0.0.0.0") + command += gpppdata.gateway(); + } + + if(gpppdata.subnetmask() != "0.0.0.0") + command += " netmask " + gpppdata.subnetmask(); + + if(gpppdata.flowcontrol() != "None") { + if(gpppdata.flowcontrol() == "CRTSCTS") + command += " crtscts"; + else + command += " xonxoff"; + } + + if(gpppdata.defaultroute()) + command += " defaultroute"; + + if(gpppdata.autoDNS()) + command += " usepeerdns"; + + QStringList &arglist = gpppdata.pppdArgument(); + for ( QStringList::Iterator it = arglist.begin(); + it != arglist.end(); + ++it ) + { + command += " " + *it; + } + + // PAP settings + if(gpppdata.authMethod() == AUTH_PAP) { + command += " -chap user "; + command = command + "\"" + gpppdata.storedUsername() + "\""; + } + + // CHAP settings + if(gpppdata.authMethod() == AUTH_CHAP) { + command += " -pap user "; + command = command + "\"" + gpppdata.storedUsername() + "\""; + } + + // PAP/CHAP settings + if(gpppdata.authMethod() == AUTH_PAPCHAP) { + command += " user "; + command = command + "\"" + gpppdata.storedUsername() + "\""; + } + + // check for debug + if(gpppdata.getPPPDebug()) + command += " debug"; + + if (command.length() > MAX_CMDLEN) { + QMessageBox::critical(this, "error", i18n( + "pppd command + command-line arguments exceed " + "2024 characters in length." + )); + + return false; // nonsensically long command which would bust my buffer buf. + } + + qApp->flushX(); + + return Modem::modem->execPPPDaemon(command); +} + + +void ConnectWidget::closeEvent( QCloseEvent *e ) { + e->ignore(); + emit cancelbutton(); +} + + +void ConnectWidget::setMsg(const QString &msg) { + messg->setText(msg); +} + +void ConnectWidget::writeline(const QString &s) { + Modem::modem->writeLine(s.local8Bit()); +} + +// Set the hostname and domain from DNS Server +void auto_hostname() { + struct in_addr local_ip; + struct hostent *hostname_entry; + QString new_hostname; + int dot; + char tmp_str[100]; // buffer overflow safe + + gethostname(tmp_str, sizeof(tmp_str)); + tmp_str[sizeof(tmp_str)-1]=0; // panic + old_hostname=tmp_str; // copy to QString + + // if (!p_kppp->stats->local_ip_address.isEmpty() && gpppdata.autoname()) { + if ( gpppdata.autoname()) { +// local_ip.s_addr=inet_addr(p_kppp->stats->local_ip_address.ascii()); + hostname_entry=gethostbyaddr((const char *)&local_ip,sizeof(in_addr),AF_INET); + + if (hostname_entry != 0L) { + new_hostname=hostname_entry->h_name; + dot=new_hostname.find('.'); + new_hostname=new_hostname.remove(dot,new_hostname.length()-dot); + Modem::modem->setHostname(new_hostname); + modified_hostname = TRUE; + + new_hostname=hostname_entry->h_name; + new_hostname.remove(0,dot+1); + + add_domain(new_hostname); + } + } + +} + +// Replace the DNS domain entry in the /etc/resolv.conf file and +// disable the nameserver entries if option is enabled +void add_domain(const QString &domain) { + + int fd; + char c; + QString resolv[MAX_RESOLVCONF_LINES]; + + if (domain.isEmpty()) + return; + + if((fd = Modem::modem->openResolv(O_RDONLY)) >= 0) { + + int i=0; + while((read(fd, &c, 1) == 1) && (i < MAX_RESOLVCONF_LINES)) { + if(c == '\n') { + i++; + } + else { + resolv[i] += c; + } + } + close(fd); + if ((c != '\n') && (i < MAX_RESOLVCONF_LINES)) i++; + + if((fd = Modem::modem->openResolv(O_WRONLY|O_TRUNC)) >= 0) { + QCString tmp = "domain " + domain.local8Bit() + + " \t\t#kppp temp entry\n"; + write(fd, tmp.data(), tmp.length()); + + for(int j=0; j < i; j++) { + if((resolv[j].contains("domain") || + ( resolv[j].contains("nameserver") + && !resolv[j].contains("#kppp temp entry") + && gpppdata.exDNSDisabled())) + && !resolv[j].contains("#entry disabled by kppp")) { + QCString tmp = "# " + resolv[j].local8Bit() + + " \t#entry disabled by kppp\n"; + write(fd, tmp, tmp.length()); + } + else { + QCString tmp = resolv[j].local8Bit() + "\n"; + write(fd, tmp, tmp.length()); + } + } + } + close(fd); + } +} + + +// adds the DNS entries in the /etc/resolv.conf file +void adddns() +{ + int fd; + + if ((fd = Modem::modem->openResolv(O_WRONLY|O_APPEND)) >= 0) { + QStringList &dnslist = gpppdata.dns(); + for ( QStringList::Iterator it = dnslist.begin(); + it != dnslist.end(); + ++it ) + { + QCString dns = "nameserver " + (*it).local8Bit() + + " \t#kppp temp entry\n"; + write(fd, dns.data(), dns.length()); + } + close(fd); + } + add_domain(gpppdata.domain()); +} + +void addpeerdns() { + int fd, fd2; + + if((fd = Modem::modem->openResolv(O_WRONLY|O_APPEND)) >= 0) { + if((fd2 = open("/etc/ppp/resolv.conf", O_RDONLY)) >= 0) { + char c; + int i = 0; + while(i++ < 100 && read(fd2, &c, 1) == 1) { + if(c == '\n') + write(fd, "\t#kppp temp entry\n", 18); + else + write(fd, &c, 1); + } + close(fd2); + } else + fprintf(stderr, "failed to read from /etc/ppp/resolv.conf\n"); + close(fd); + } + add_domain(gpppdata.domain()); +} + +// remove the dns entries from the /etc/resolv.conf file +void removedns() { + + int fd; + char c; + QString resolv[MAX_RESOLVCONF_LINES]; + + if((fd = Modem::modem->openResolv(O_RDONLY)) >= 0) { + + int i=0; + while(read(fd, &c, 1) == 1 && i < MAX_RESOLVCONF_LINES) { + if(c == '\n') { + i++; + } + else { + resolv[i] += c; + } + } + close(fd); + + if((fd = Modem::modem->openResolv(O_WRONLY|O_TRUNC)) >= 0) { + for(int j=0; j < i; j++) { + if(resolv[j].contains("#kppp temp entry")) continue; + if(resolv[j].contains("#entry disabled by kppp")) { + QCString tmp = resolv[j].local8Bit(); + write(fd, tmp.data()+2, tmp.length() - 27); + write(fd, "\n", 1); + } + else { + QCString tmp = resolv[j].local8Bit() + "\n"; + write(fd, tmp, tmp.length()); + } + } + } + close(fd); + + } + + if ( modified_hostname ) { + Modem::modem->setHostname(old_hostname); + modified_hostname = FALSE; + } + +} + + diff --git a/noncore/settings/networksettings/ppp/connect.h b/noncore/settings/networksettings/ppp/connect.h new file mode 100644 index 0000000..3127236 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/connect.h @@ -0,0 +1,152 @@ +/* -*- C++ -*- + * + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _CONNECT_H_ +#define _CONNECT_H_ + +#include <qtimer.h> +#include <qpushbutton.h> +#include <qlabel.h> +#include <qevent.h> + +#include "kpppconfig.h" +#include "pwentry.h" +//#include "docking.h" +//#include "loginterm.h" + +#define MAXLOOPNEST (MAX_SCRIPT_ENTRIES/2) + +class PPPStats; + +class ConnectWidget : public QWidget { + Q_OBJECT +public: + ConnectWidget(QWidget *parent, const char *name); + ~ConnectWidget(); + +public: + void set_con_speed_string(); + void setMsg(const QString &); + void pppdDied(); + +protected: + void timerEvent(QTimerEvent *); + void closeEvent( QCloseEvent *e ); + +private slots: + void readChar(unsigned char); + void pause(); + void if_waiting_slot(); + +public slots: + void init(); + void preinit(); + void script_timed_out(); + void if_waiting_timed_out(); + void cancelbutton(); + +signals: + void if_waiting_signal(); + void debugMessage(const QString &); + void toggleDebugWindow(); + void closeDebugWindow(); + void debugPutChar(unsigned char); + void startAccounting(); + void stopAccounting(); + +public: + QString myreadbuffer; // we want to keep every thing in order to fish for the + + // connection speed later on + QPushButton *debug; + int main_timer_ID; + +private: + int vmain; + int substate; + int scriptindex; + QString scriptCommand, scriptArgument; + QStringList *comlist, *arglist; + + // static const int maxloopnest=(MAX_SCRIPT_ENTRIES/2); + int loopnest; + int loopstartindex[MAXLOOPNEST]; + bool loopend; + QString loopstr[MAXLOOPNEST]; + + bool semaphore; + QTimer *inittimer; + + QTimer *timeout_timer; + bool execppp(); + void writeline(const QString &); + void checkBuffers(); + + void setExpect(const QString &); + bool expecting; + QString expectstr; + + QString readbuffer; + + void setScan(const QString &); + QString scanvar; + QString scanstr; + QString scanbuffer; + bool scanning; + + bool pausing; + PWEntry *prompt; +// LoginTerm *termwindow; + + int scriptTimeout; + QTimer *pausetimer; + QTimer *if_timer; + QTimer *if_timeout_timer; + + QLabel *messg; + QPushButton *cancel; + + bool firstrunID; + bool firstrunPW; + + unsigned int dialnumber; // the current number to dial + +// PPPStats *stats; +}; + + +// non-member function to kill&wait on the pppd child process +extern void killppp(); +void adddns(); +void addpeerdns(); +void removedns(); +void add_domain(const QString & newdomain); +void auto_hostname(); + +#endif + diff --git a/noncore/settings/networksettings/ppp/conwindow.cpp b/noncore/settings/networksettings/ppp/conwindow.cpp new file mode 100644 index 0000000..d6b3fbe --- a/dev/null +++ b/noncore/settings/networksettings/ppp/conwindow.cpp @@ -0,0 +1,341 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <qtooltip.h> +#include <qdialog.h> +#include "conwindow.h" +//#include "docking.h" +#include "pppdata.h" +// #include "pppstats.h" +// #include <klocale.h> +#define i18n QObject::tr +// #include <kglobal.h> + +extern PPPData gpppdata; + +ConWindow::ConWindow(QWidget *parent, const char *name, QDialog *mainwidget ) +// PPPStats *st) + : QWidget(parent, name, 0), + minutes(0), + seconds(0), + hours(0), + days(0), + tl1(0), +// stats(st), + accountingEnabled(false), + volumeAccountingEnabled(false) +{ + info1 = new QLabel(i18n("Connected at:"), this); + info2 = new QLabel("", this); + + timelabel1 = new QLabel(i18n("Time connected:"), this); + timelabel2 = new QLabel("000:00:00", this); + + vollabel = new QLabel(i18n("Volume:"), this); + volinfo = new QLabel("", this); + + // now the stuff for accounting + session_bill_l = new QLabel(i18n("Session Bill:"), this); + session_bill = new QLabel("", this); + total_bill_l = new QLabel(i18n("Total Bill:"), this); + total_bill = new QLabel("", this); + + this->setCaption("kppp"); + + cancelbutton = new QPushButton(this); + cancelbutton->setText(i18n("Disconnect")); + connect(cancelbutton, SIGNAL(clicked()), mainwidget, SLOT(disconnect())); + + // statsbutton = new QPushButton(this); +// statsbutton->setText(i18n("Details")); +// statsbutton->setFocus(); +// connect(statsbutton, SIGNAL(clicked()), mainwidget, SLOT(showStats())); + + clocktimer = new QTimer(this); + connect(clocktimer, SIGNAL(timeout()), SLOT(timeclick())); + + // read window position from config file + int p_x, p_y; + gpppdata.winPosConWin(p_x, p_y); + setGeometry(p_x, p_y, 320, 110); +} + +ConWindow::~ConWindow() { + stopClock(); +} + +// save window position when window was closed +bool ConWindow::event(QEvent *e) { + if (e->type() == QEvent::Hide) + { + gpppdata.setWinPosConWin(x(), y()); + return true; + } + else + return QWidget::event(e); +} + +QString ConWindow::prettyPrintVolume(unsigned int n) { + int idx = 0; + const QString quant[] = {i18n("Byte"), i18n("KB"), + i18n("MB"), i18n("GB"), QString::null}; + + float n1 = n; + while(n >= 1024 && quant[idx] != QString::null) { + idx++; + n /= 1024; + } + + int i = idx; + while(i--) + n1 = n1 / 1024.0; + + QString s = QString::number( n1, 'f', idx==0 ? 0 : 1 ); //KGlobal::locale()->formatNumber( n1, idx==0 ? 0 : 1 ); + s += " " + quant[idx]; + return s; +} + +void ConWindow::accounting(bool on) { + // cache accounting settings + accountingEnabled = on; + volumeAccountingEnabled = gpppdata.VolAcctEnabled(); + + // delete old layout + if(tl1 != 0) + delete tl1; + + // add layout now + tl1 = new QVBoxLayout(this, 10, 10); + tl1->addSpacing(5); + QHBoxLayout *tl = new QHBoxLayout; + tl1->addLayout(tl); + tl->addSpacing(20); + QGridLayout *l1; + + int vol_lines = 0; + if(gpppdata.VolAcctEnabled()) + vol_lines = 1; + + if(accountingEnabled) + l1 = new QGridLayout(4 + vol_lines, 2, 5); + else + l1 = new QGridLayout(2 + vol_lines, 2, 5); + tl->addLayout(l1); + l1->setColStretch(0, 0); + l1->setColStretch(1, 1); + + info2->setAlignment(AlignRight|AlignVCenter); + timelabel2->setAlignment(AlignRight|AlignVCenter); + session_bill->setAlignment(AlignRight|AlignVCenter); + total_bill->setAlignment(AlignRight|AlignVCenter); + volinfo->setAlignment(AlignRight|AlignVCenter); + // make sure that there's enough space for the bills + QString s1 = session_bill->text(); + QString s2 = total_bill->text(); + QString s3 = volinfo->text(); + + session_bill->setText("888888.88 XXX"); + total_bill->setText("888888.88 XXX"); + volinfo->setText("8888.8 MB"); + session_bill->setFixedSize(session_bill->sizeHint()); + total_bill->setFixedSize(total_bill->sizeHint()); + volinfo->setFixedSize(volinfo->sizeHint()); + session_bill->setText(s1); + total_bill->setText(s2); + volinfo->setText(s3); + + l1->addWidget(info1, 0, 0); + l1->addWidget(info2, 0, 1); + l1->addWidget(timelabel1, 1, 0); + l1->addWidget(timelabel2, 1, 1); + if(accountingEnabled) { + session_bill_l->show(); + session_bill->show(); + total_bill_l->show(); + total_bill->show(); + l1->addWidget(session_bill_l, 2, 0); + l1->addWidget(session_bill, 2, 1); + l1->addWidget(total_bill_l, 3, 0); + l1->addWidget(total_bill, 3, 1); + + if(volumeAccountingEnabled) { + vollabel->show(); + volinfo->show(); + l1->addWidget(vollabel, 4, 0); + l1->addWidget(volinfo, 4, 1); + } else { + vollabel->hide(); + volinfo->hide(); + } + + } else { + session_bill_l->hide(); + session_bill->hide(); + total_bill_l->hide(); + total_bill->hide(); + + if(volumeAccountingEnabled) { + vollabel->show(); + volinfo->show(); + l1->addWidget(vollabel, 2, 0); + l1->addWidget(volinfo, 2, 1); + } else { + vollabel->hide(); + volinfo->hide(); + } + } + + tl->addSpacing(10); + QVBoxLayout *l2 = new QVBoxLayout(5); + tl->addLayout(l2); + l2->addStretch(1); +// l2->addWidget(statsbutton); + l2->addWidget(cancelbutton); + + l2->addStretch(1); + + tl1->addSpacing(5); + + setFixedSize(sizeHint()); +/* + do not overwrite position read from config + setGeometry((QApplication::desktop()->width() - width()) / 2, + (QApplication::desktop()->height() - height())/2, + width(), + height()); +*/ +} + + +void ConWindow::dock() { +// DockWidget::dock_widget->show(); + this->hide(); +} + + +void ConWindow::startClock() { + minutes = 0; + seconds = 0; + hours = 0; + QString title ; + + title = gpppdata.accname(); + + if(gpppdata.get_show_clock_on_caption()){ + title += " 00:00" ; + } + this->setCaption(title); + + timelabel2->setText("00:00:00"); + clocktimer->start(1000); +} + + +void ConWindow::setConnectionSpeed(const QString &speed) { + info2->setText(speed); +} + + +void ConWindow::stopClock() { + clocktimer->stop(); +} + + +void ConWindow::timeclick() { + QString tooltip = i18n("Connection: %1\n" + "Connected at: %2\n" + "Time connected: %3") + .arg(gpppdata.accname()).arg(info2->text()) + .arg(time_string2); + + if(accountingEnabled) + tooltip += i18n("\nSession Bill: %1\nTotal Bill: %2") + .arg(session_bill->text()).arg(total_bill->text()); + // volume accounting + if(volumeAccountingEnabled) { + + volinfo->setEnabled(TRUE); + int bytes = gpppdata.totalBytes(); + volinfo->setText(prettyPrintVolume(bytes)); + } + + seconds++; + + if(seconds >= 60 ) { + minutes ++; + seconds = 0; + } + + if (minutes >= 60){ + minutes = 0; + hours ++; + } + + if( hours >= 24){ + days ++; + hours = 0; + } + + time_string.sprintf("%02d:%02d",hours,minutes); + time_string2 = ""; + if (days) + time_string2.sprintf("%d d %02d:%02d:%02d", + days,hours,minutes,seconds); + + else + time_string2.sprintf("%02d:%02d:%02d",hours,minutes,seconds); + + caption_string = gpppdata.accname(); + caption_string += " "; + caption_string += time_string; + + + timelabel2->setText(time_string2); + + if(gpppdata.get_show_clock_on_caption() && (seconds == 1)){ + // we update the Caption only once per minute not every second + // otherwise I get a flickering icon + this->setCaption(caption_string); + } + +// QToolTip::add(DockWidget::dock_widget, tooltip); +} + + +void ConWindow::closeEvent( QCloseEvent *e ){ + // we don't want to lose the + // conwindow since this is our last connection kppp. + // if we lost it we could only kill the program by hand to get on with life. + e->ignore(); + + if(gpppdata.get_dock_into_panel()) + dock(); +} + + +void ConWindow::slotAccounting(QString total, QString session) { + total_bill->setText(total); + session_bill->setText(session); +} + + diff --git a/noncore/settings/networksettings/ppp/conwindow.h b/noncore/settings/networksettings/ppp/conwindow.h new file mode 100644 index 0000000..20d3579 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/conwindow.h @@ -0,0 +1,96 @@ +/* -*- C++ -*- + * + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _CONWINDOW_H_ +#define _CONWINDOW_H_ + + +#include <qtimer.h> +#include <qpushbutton.h> +#include <qlabel.h> +#include <qdialog.h> +#include <qframe.h> +#include <qevent.h> +#include <qlayout.h> + +//class PPPStats; + +class ConWindow : public QWidget { +Q_OBJECT + +public: + ConWindow(QWidget *parent, const char *name, QDialog* ); + ~ConWindow(); + +protected: + void closeEvent( QCloseEvent *e ); + bool event( QEvent *e ); + +private slots: + void timeclick(); + void dock(); + +public: + void setConnectionSpeed(const QString&); + void startClock(); + void stopClock(); + void accounting(bool); // show/ hide accounting info + +public slots: + void slotAccounting(QString, QString); + +private: + QLabel *info1; + QLabel *info2; + QPushButton *cancelbutton; + QPushButton *statsbutton; + QString prettyPrintVolume(unsigned int); + int minutes; + int seconds; + int hours; + int days; + QFrame *fline; + QLabel *timelabel1; + QLabel *timelabel2; + QLabel *total_bill, *total_bill_l; + QLabel *session_bill, *session_bill_l; + QString caption_string; + QString time_string2; + QString time_string; + QTimer *clocktimer; + QVBoxLayout *tl1; + QLabel *vollabel; + QLabel *volinfo; +// PPPStats *stats; + bool accountingEnabled; + bool volumeAccountingEnabled; +}; + + +#endif + + + + + diff --git a/noncore/settings/networksettings/ppp/debug.cpp b/noncore/settings/networksettings/ppp/debug.cpp new file mode 100644 index 0000000..8652931 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/debug.cpp @@ -0,0 +1,141 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * Copyright (C) 1997 Bernd Wuebben + * wuebben@math.cornel.edu + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "debug.h" +//#include "main.h" +#include "pppdata.h" +//#include <klocale.h> +#define i18n QObject::tr +#include "kpppwidget.h" +#include <assert.h> + +extern KPPPWidget *p_kppp; + +myMultiEdit::myMultiEdit(QWidget *parent, const char *name) + : QMultiLineEdit(parent, name) +{ + setReadOnly(true); +} + +void myMultiEdit::insertChar(unsigned char c) { + QMultiLineEdit::insert(QChar(c)); +} + + +void myMultiEdit::newLine() { + QMultiLineEdit::newLine(); +} + + +DebugWidget::DebugWidget(QWidget *parent, const char *name) + : QDialog(parent, name, FALSE) +{ + setCaption(i18n("Login Script Debug Window")); + + text_window = new myMultiEdit(this,"debugwindow"); + text_window->setGeometry(2,5,400, 300); + // text_window->setReadOnly(FALSE); + + statuslabel = new QLabel("", this, "statuslabel"); + + statuslabel->setFrameStyle( QFrame::Panel | QFrame::Sunken ); + statuslabel->setAlignment( AlignLeft|AlignVCenter ); + statuslabel->setGeometry(2, 307, 400, 20); + //statusPageLabel->setFont( QFont("helvetica",12,QFont::Normal) ); + + dismiss = new QPushButton(this); + dismiss->setGeometry(330,340,70,30); + dismiss->setText(i18n("Close")); + dismiss->setFocus(); + connect(dismiss, SIGNAL(clicked()), SLOT(hide())); + + + /* fline = new QFrame(this,"line"); + fline->setFrameStyle(QFrame::HLine |QFrame::Sunken); + fline->setGeometry(2,332,398,5);*/ + adjustSize(); + setMinimumSize(width(),height()); + +} + +void DebugWidget::hideEvent(QHideEvent *) +{ + assert(p_kppp); +// p_kppp->con->debug->setOn(false); +} + +void DebugWidget::clear() { + text_window->clear(); +} + + +void DebugWidget::addChar(unsigned char c) { + QString stuff; + + if(c == '\r' || c == '\n') { + if(c == '\n') + text_window->newLine(); + } else + text_window->insertChar(c); +} + + +void DebugWidget::statusLabel(const QString &s) { + statuslabel->setText(s); +} + + +/* +void DebugWidget::keyPressEvent(QKeyEvent *k) { +} + +*/ +void DebugWidget::resizeEvent(QResizeEvent *e){ + int w = width() ; + int h = height(); + e = e; + + text_window->setGeometry(2,5,w - 2 ,h - 63); + statuslabel->setGeometry(2, h - 56 , w -2 , 20); + dismiss->setGeometry(w - 72 , h - 32, 70, 30); + // fline->setGeometry(2,h -70 ,w - 4,5); +} + + +void DebugWidget::enter() { + text_window->append("\r\n"); +} + + +void DebugWidget::toggleVisibility() { + if(isVisible()) + hide(); + else + show(); + + bool showlog = isVisible(); + gpppdata.set_show_log_window(showlog); +} + + + + diff --git a/noncore/settings/networksettings/ppp/debug.h b/noncore/settings/networksettings/ppp/debug.h new file mode 100644 index 0000000..3565cec --- a/dev/null +++ b/noncore/settings/networksettings/ppp/debug.h @@ -0,0 +1,70 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * Copyright (C) 1997 Bernd Wuebben + * wuebben@math.cornel.edu + * + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _DEBUGWIDGET_ +#define _DEBUGWIDGET_ + +#include <qdialog.h> +#include <qstring.h> +#include <qlabel.h> +#include <qmultilineedit.h> +#include <qpushbutton.h> + + +class myMultiEdit : public QMultiLineEdit { +public: + + myMultiEdit(QWidget *parent=0, const char *name=0); + + void newLine(); + void insertChar(unsigned char c); +}; + + +class DebugWidget : public QDialog { + Q_OBJECT +public: + DebugWidget(QWidget *parent=0, const char *name=0); + + void clear(); + +public slots: + void statusLabel(const QString &); + void toggleVisibility(); + void addChar(unsigned char); + +protected: + virtual void hideEvent(QHideEvent *); + virtual void resizeEvent(QResizeEvent *e); + +private: + void enter(); + QFrame *fline; + QPushButton *dismiss; + myMultiEdit *text_window; + + QLabel *statuslabel; +}; + +#endif + diff --git a/noncore/settings/networksettings/ppp/edit.cpp b/noncore/settings/networksettings/ppp/edit.cpp new file mode 100644 index 0000000..961047b --- a/dev/null +++ b/noncore/settings/networksettings/ppp/edit.cpp @@ -0,0 +1,1193 @@ +/* + * kPPP: A pppd Front End for the KDE project + * + * $Id$ + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <string.h> +#include <termios.h> +#include <qlayout.h> +#include <qmessagebox.h> +#include <qwhatsthis.h> +#include <qregexp.h> +#include <qapplication.h> +//#include <kiconloader.h> +#include <qbuttongroup.h> +//#include <klocale.h> +#define i18n QObject::tr +#include <qvgroupbox.h> +#include <qhbox.h> +#include <qdialog.h> +//#include <kwin.h> + +#include "edit.h" +#include "pppdata.h" +#include "newwidget.h" +#include "iplined.h" +#include "auth.h" + +DialWidget::DialWidget( QWidget *parent, bool isnewaccount, const char *name ) + : QWidget(parent, name) +{ + const int GRIDROWS = 6; + + QGridLayout *tl = new QGridLayout(parent, GRIDROWS, 2, 0 );//, KDialog::spacingHint()); + + connect_label = new QLabel(i18n("Connection name:"), parent); + tl->addWidget(connect_label, 0, 0); + + connectname_l = new QLineEdit(parent); + connectname_l->setMaxLength(ACCNAME_SIZE); + tl->addWidget(connectname_l, 0, 1); + QString tmp = i18n("Type in a unique name for this connection"); + + QWhatsThis::add(connect_label,tmp); + QWhatsThis::add(connectname_l,tmp); + + + number_label = new QLabel(i18n("Phone number:"), parent); + number_label->setAlignment(AlignTop|AlignLeft); + tl->addWidget(number_label, 1, 0); + + QHBoxLayout *lpn = new QHBoxLayout(5); + tl->addLayout(lpn, 1, 1); + numbers = new QListBox(parent); + numbers->setMinimumSize(120, 70); + lpn->addWidget(numbers); + QVBoxLayout *lpn1 = new QVBoxLayout; + lpn->addLayout(lpn1); + add = new QPushButton(i18n("&Add..."), parent); + del = new QPushButton(i18n("&Remove"), parent); + + up = new QPushButton(parent); +//FIXME: QPixmap pm = BarIcon("up"); +// up->setPixmap(pm); + down = new QPushButton(parent); +//FIXME: pm = BarIcon("down"); +// down->setPixmap(pm); + lpn1->addWidget(add); + lpn1->addWidget(del); + lpn1->addStretch(1); + lpn1->addWidget(up); + lpn1->addWidget(down); + connect(add, SIGNAL(clicked()), + this, SLOT(addNumber())); + connect(del, SIGNAL(clicked()), + this, SLOT(delNumber())); + connect(up, SIGNAL(clicked()), + this, SLOT(upNumber())); + connect(down, SIGNAL(clicked()), + this, SLOT(downNumber())); + connect(numbers, SIGNAL(highlighted(int)), + this, SLOT(selectionChanged(int))); + numbersChanged(); + + tmp = i18n("<p>Specifies the phone numbers to dial. You\n" + "can supply multiple numbers here, simply\n" + "click on \"Add\". You can arrange the\n" + "order the numbers are tried by using the\n" + "arrow buttons.\n\n" + "When a number is busy or fails, <i>kppp</i> will \n" + "try the next number and so on"); + + QWhatsThis::add(number_label,tmp); + QWhatsThis::add(numbers,tmp); + + auth_l = new QLabel(i18n("Authentication:"), parent); + tl->addWidget(auth_l, 3, 0); + + auth = new QComboBox(parent); + auth->insertItem(i18n("Script-based")); + auth->insertItem(i18n("PAP")); + auth->insertItem(i18n("Terminal-based")); + auth->insertItem(i18n("CHAP")); + auth->insertItem(i18n("PAP/CHAP")); + tl->addWidget(auth, 3, 1); + tmp = i18n("<p>Specifies the method used to identify yourself to\n" + "the PPP server. Most universities still use\n" + "<b>Terminal</b>- or <b>Script</b>-based authentication,\n" + "while most ISP use <b>PAP</b> and/or <b>CHAP</b>. If\n" + "unsure, contact your ISP.\n" + "\n" + "If you can choose between PAP and CHAP,\n" + "choose CHAP, because it's much safer. If you don't know\n" + "whether PAP or CHAP is right, choose PAP/CHAP."); + + QWhatsThis::add(auth_l,tmp); + QWhatsThis::add(auth,tmp); + + store_password = new QCheckBox(i18n("Store password"), parent); + store_password->setChecked(true); + tl->addMultiCellWidget(store_password, 4, 4, 0, 1, AlignRight); + QWhatsThis::add(store_password, + i18n("<p>When this is turned on, your ISP password\n" + "will be saved in <i>kppp</i>'s config file, so\n" + "you do not need to type it in every time.\n" + "\n" + "<b><font color=\"red\">Warning:</font> your password will be stored as\n" + "plain text in the config file, which is\n" + "readable only to you. Make sure nobody\n" + "gains access to this file!")); + + pppdargs = new QPushButton(i18n("Customize pppd Arguments..."), parent); + connect(pppdargs, SIGNAL(clicked()), SLOT(pppdargsbutton())); + tl->addMultiCellWidget(pppdargs, 5, 5, 0, 1, AlignCenter); + + // Set defaults if editing an existing connection + if(!isnewaccount) { + connectname_l->setText(gpppdata.accname()); + + // insert the phone numbers into the listbox + QString n = gpppdata.phonenumber(); + QString tmp = ""; + uint idx = 0; + while(idx != n.length()) { + if(n[idx] == ':') { + if(tmp.length() > 0) + numbers->insertItem(tmp); + tmp = ""; + } else + tmp += n[idx]; + idx++; + } + if(tmp.length() > 0) + numbers->insertItem(tmp); + + auth->setCurrentItem(gpppdata.authMethod()); + store_password->setChecked(gpppdata.storePassword()); + } else { + // select PAP/CHAP as default + auth->setCurrentItem(AUTH_PAPCHAP); + } + + numbersChanged(); + tl->activate(); +} + + +bool DialWidget::save() { + //first check to make sure that the account name is unique! + if(connectname_l->text().isEmpty() || + !gpppdata.isUniqueAccname(connectname_l->text())) { + return false; + } else { + gpppdata.setAccname(connectname_l->text()); + + QString number = ""; + for(uint i = 0; i < numbers->count(); i++) { + if(i != 0) + number += ":"; + number += numbers->text(i); + } + + gpppdata.setPhonenumber(number); + gpppdata.setAuthMethod(auth->currentItem()); + gpppdata.setStorePassword(store_password->isChecked()); + return true; + } +} + + +void DialWidget::numbersChanged() { + int sel = numbers->currentItem(); + + del->setEnabled(sel != -1); + up->setEnabled(sel != -1 && sel != 0); + down->setEnabled(sel != -1 && sel != (int)numbers->count()-1); +} + + +void DialWidget::selectionChanged(int) { + numbersChanged(); +} + + +void DialWidget::addNumber() { + PhoneNumberDialog dlg(this); + if(dlg.exec()) { + numbers->insertItem(dlg.phoneNumber()); + numbersChanged(); + } +} + + +void DialWidget::delNumber() { + if(numbers->currentItem() != -1) { + numbers->removeItem(numbers->currentItem()); + numbersChanged(); + } +} + + +void DialWidget::upNumber() { + int idx = numbers->currentItem(); + if(idx != -1) { + QString item = numbers->text(idx); + numbers->removeItem(idx); + numbers->insertItem(item, idx-1); + numbers->setCurrentItem(idx-1); + numbersChanged(); + } +} + + +void DialWidget::downNumber() { + int idx = numbers->currentItem(); + if(idx != -1) { + QString item = numbers->text(idx); + numbers->removeItem(idx); + numbers->insertItem(item, idx+1); + numbers->setCurrentItem(idx+1); + numbersChanged(); + } +} + + +void DialWidget::pppdargsbutton() { + PPPdArguments pa(this); + pa.exec(); +} + + + +///////////////////////////////////////////////////////////////////////////// +// ExecWidget +///////////////////////////////////////////////////////////////////////////// +ExecWidget::ExecWidget(QWidget *parent, bool isnewaccount, const char *name) : + QWidget(parent, name) +{ + QVBoxLayout *tl = new QVBoxLayout(parent, 0 );//, KDialog::spacingHint()); + + QLabel *l = new QLabel(\ +i18n("Here you can select commands to run at certain stages of the\n" + "connection. The commands are run with your real user id, so\n" + "you cannot run any commands here requiring root permissions\n" + "(unless, of course, you are root).\n\n" + "Be sure to supply the whole path to the program otherwise\n" + "kppp might be unable to find it."), parent); + l->setMinimumHeight(l->sizeHint().height()); + tl->addWidget(l); + tl->addStretch(1); + + QGridLayout *l1 = new QGridLayout(4, 2, 10); + tl->addLayout(l1); + l1->setColStretch(0, 0); + l1->setColStretch(1, 1); + + before_connect_l = new QLabel(i18n("Before connect:"), parent); + before_connect_l->setAlignment(AlignVCenter); + l1->addWidget(before_connect_l, 0, 0); + before_connect = new QLineEdit(parent); + before_connect->setMaxLength(COMMAND_SIZE); + l1->addWidget(before_connect, 0, 1); + QString tmp = i18n("Allows you to run a program <b>before</b> a connection\n" + "is established. It is called immediately before\n" + "dialing has begun.\n\n" + "This might be useful, e.g. to stop HylaFAX blocking the\n" + "modem."); + + QWhatsThis::add(before_connect_l,tmp); + QWhatsThis::add(before_connect,tmp); + + command_label = new QLabel(i18n("Upon connect:"), parent); + command_label->setAlignment(AlignVCenter); + l1->addWidget(command_label, 1, 0); + command = new QLineEdit(parent); + command->setMaxLength(COMMAND_SIZE); + l1->addWidget(command, 1, 1); + tmp = i18n("Allows you to run a program <b>after</b> a connection\n" + "is established. When your program is called, all\n" + "preparations for an Internet connection are finished.\n" + "\n" + "Very useful for fetching mail and news"); + + QWhatsThis::add(command_label,tmp); + QWhatsThis::add(command,tmp); + + predisconnect_label = new QLabel(i18n("Before disconnect:"), + parent); + predisconnect_label->setAlignment(AlignVCenter); + l1->addWidget(predisconnect_label, 2, 0); + predisconnect = new QLineEdit(parent); + predisconnect->setMaxLength(COMMAND_SIZE); + l1->addWidget(predisconnect, 2, 1); + tmp = i18n("Allows you to run a program <b>before</b> a connection\n" + "is closed. The connection will stay open until\n" + "the program exits."); + + QWhatsThis::add(predisconnect_label,tmp); + QWhatsThis::add(predisconnect,tmp); + + discommand_label = new QLabel(i18n("Upon disconnect:"), + parent); + discommand_label->setAlignment(AlignVCenter); + l1->addWidget(discommand_label, 3, 0); + + discommand = new QLineEdit(parent); + discommand->setMaxLength(COMMAND_SIZE); + l1->addWidget(discommand, 3, 1); + tmp = i18n("Allows you to run a program <b>after</b> a connection\n" + "has been closed."); + + QWhatsThis::add(discommand_label,tmp); + QWhatsThis::add(discommand,tmp); + + // extra space between entries + l1->addRowSpacing(1, 5); + l1->addRowSpacing(3, 5); + + tl->addStretch(1); + tl->activate(); + + // Set defaults if editing an existing connection + if(!isnewaccount) { + before_connect->setText(gpppdata.command_before_connect()); + command->setText(gpppdata.command_on_connect()); + discommand->setText(gpppdata.command_on_disconnect()); + predisconnect->setText(gpppdata.command_before_disconnect()); + } +} + + +bool ExecWidget::save() { + gpppdata.setCommand_before_connect(before_connect->text()); + gpppdata.setCommand_on_connect(command->text()); + gpppdata.setCommand_before_disconnect(predisconnect->text()); + gpppdata.setCommand_on_disconnect(discommand->text()); + return true; +} + + + +///////////////////////////////////////////////////////////////////////////// +// +// IPWidget +// +///////////////////////////////////////////////////////////////////////////// +IPWidget::IPWidget( QWidget *parent, bool isnewaccount, const char *name ) + : QWidget(parent, name) +{ + QVBoxLayout *topLayout = new QVBoxLayout(parent); + topLayout->setSpacing( 3 );//KDialog::spacingHint()); + + box = new QVGroupBox(i18n("Configuration"), parent); +// box->setInsideSpacing( 1 );//KDialog::spacingHint()); + + rb = new QButtonGroup(parent); + rb->hide(); + connect(rb, SIGNAL(clicked(int)), + SLOT(hitIPSelect(int))); + + dynamicadd_rb = new QRadioButton(box); + dynamicadd_rb->setText(i18n("Dynamic IP address")); + QWhatsThis::add(dynamicadd_rb, + i18n("Select this option when your computer gets an\n" + "internet address (IP) every time a\n" + "connection is made.\n" + "\n" + "Almost every Internet Service Provider uses\n" + "this method, so this should be turned on.")); + + staticadd_rb = new QRadioButton(box); + staticadd_rb->setText(i18n("Static IP address")); + rb->insert(dynamicadd_rb, 0); + rb->insert(staticadd_rb, 1); + QWhatsThis::add(staticadd_rb, + i18n("Select this option when your computer has a\n" + "fixed internet address (IP). Most computers\n" + "don't have this, so you should probably select\n" + "dynamic IP addressing unless you know what you\n" + "are doing.")); + + QWidget *ipWidget = new QWidget(box); + QGridLayout *ipLayout = new QGridLayout(ipWidget, 2, 2); + ipLayout->setSpacing( 2 );//KDialog::spacingHint()); + + ipaddress_label = new QLabel(i18n("IP address:"), ipWidget); + QString tmp = i18n("If your computer has a permanent internet\n" + "address, you must supply your IP address here."); + ipLayout->addWidget(ipaddress_label, 0, 0); + + ipaddress_l = new IPLineEdit(ipWidget); + ipLayout->addWidget(ipaddress_l, 0, 1); + + QWhatsThis::add(ipaddress_label,tmp); + QWhatsThis::add(ipaddress_l,tmp); + + sub_label = new QLabel(i18n("Subnet mask:"), ipWidget); + tmp = i18n("<p>If your computer has a static Internet address,\n" + "you must supply a network mask here. In almost\n" + "all cases this netmask will be <b>255.255.255.0</b>,\n" + "but your mileage may vary.\n" + "\n" + "If unsure, contact your Internet Service Provider"); + ipLayout->addWidget(sub_label, 1, 0); + + subnetmask_l = new IPLineEdit(ipWidget); + ipLayout->addWidget(subnetmask_l, 1, 1); + + QWhatsThis::add(sub_label,tmp); + QWhatsThis::add(subnetmask_l,tmp); + + autoname = new QCheckBox(i18n("Auto-configure hostname from this IP"), parent); + autoname->setChecked(gpppdata.autoname()); + connect(autoname,SIGNAL(toggled(bool)), + this,SLOT(autoname_t(bool))); + + QWhatsThis::add(autoname, + i18n("<p>Whenever you connect, this reconfigures\n" + "your hostname to match the IP address you\n" + "got from the PPP server. This may be useful\n" + "if you need to use a protocol which depends\n" + "on this information, but it can also cause several\n" + "<a href=\"kppp-7.html#autohostname\">problems</a>.\n" + "\n" + "Don't enable this unless you really need it.")); + + topLayout->addWidget(box); + topLayout->addWidget(autoname); + topLayout->addStretch(); + + //load info from gpppdata + if(!isnewaccount) { + if(gpppdata.ipaddr() == "0.0.0.0" && + gpppdata.subnetmask() == "0.0.0.0") { + dynamicadd_rb->setChecked(true); + hitIPSelect(0); + autoname->setChecked(gpppdata.autoname()); + } + else { + ipaddress_l->setText(gpppdata.ipaddr()); + subnetmask_l->setText(gpppdata.subnetmask()); + staticadd_rb->setChecked(true); + autoname->setChecked(false); + } + } + else { + dynamicadd_rb->setChecked(true); + hitIPSelect(0); + } + +} + +void IPWidget::autoname_t(bool on) { + static bool was_warned = false; + + // big-fat warning when selecting the auto configure hostname option + if(on && !was_warned) { + QMessageBox::information(this, + i18n("Selecting this option might cause some weird " + "problems with the X-server and applications " + "while kppp is connected. Don't use it until " + "you know what you are doing!\n" + "For more information take a look at the " + "handbook (or help) in the section \"Frequently " + "asked questions\"."), + i18n("Warning")); + was_warned = true; + } +} + + +void IPWidget::save() { + if(dynamicadd_rb->isChecked()) { + gpppdata.setIpaddr("0.0.0.0"); + gpppdata.setSubnetmask("0.0.0.0"); + } else { + gpppdata.setIpaddr(ipaddress_l->text()); + gpppdata.setSubnetmask(subnetmask_l->text()); + } + gpppdata.setAutoname(autoname->isChecked()); +} + + +void IPWidget::hitIPSelect( int i ) { + if(i == 0) { + ipaddress_label->setEnabled(false); + sub_label->setEnabled(false); + ipaddress_l->setEnabled(false); + subnetmask_l->setEnabled(false); + } + else { + ipaddress_label->setEnabled(true); + sub_label->setEnabled(true); + ipaddress_l->setEnabled(true); + subnetmask_l->setEnabled(true); + } +} + + + +DNSWidget::DNSWidget( QWidget *parent, bool isnewaccount, const char *name ) + : QWidget(parent, name) +{ + // box = new QGroupBox(parent); + QGridLayout *tl = new QGridLayout(parent, 7, 2, 0 );//, KDialog::spacingHint()); + + dnsdomain_label = new QLabel(i18n("Domain name:"), parent); + tl->addWidget(dnsdomain_label, 0, 0); + + dnsdomain = new QLineEdit(parent); + dnsdomain->setMaxLength(DOMAIN_SIZE); + tl->addWidget(dnsdomain, 0, 1); + QString tmp = i18n("If you enter a domain name here, this domain\n" + "name is used for your computer while you are\n" + "connected. When the connection is closed, the\n" + "original domain name of your computer is\n" + "restored.\n" + "\n" + "If you leave this field blank, no changes are\n" + "made to the domain name."); + + QWhatsThis::add(dnsdomain_label,tmp); + QWhatsThis::add(dnsdomain,tmp); + + conf_label = new QLabel(i18n("Configuration:"), parent); + tl->addWidget(conf_label, 1, 0); + + bg = new QButtonGroup("Group", this); + connect(bg, SIGNAL(clicked(int)), SLOT(DNS_Mode_Selected(int))); + bg->hide(); + + autodns = new QRadioButton(i18n("Automatic"), parent); + bg->insert(autodns, 0); + tl->addWidget(autodns, 1, 1); + // no automatic DNS detection for pppd < 2.3.7 + if(!gpppdata.pppdVersionMin(2, 3, 7)) + autodns->setEnabled(false); + + mandns = new QRadioButton(i18n("Manual"), parent); + bg->insert(mandns, 1); + tl->addWidget(mandns, 2, 1); + + dns_label = new QLabel(i18n("DNS IP address:"), parent); + tl->addWidget(dns_label, 3, 0); + + QHBoxLayout *l2 = new QHBoxLayout; + tl->addLayout(l2, 3, 1); + dnsipaddr = new IPLineEdit(parent); + connect(dnsipaddr, SIGNAL(returnPressed()), + SLOT(adddns())); + connect(dnsipaddr, SIGNAL(textChanged(const QString &)), + SLOT(DNS_Edit_Changed(const QString &))); + l2->addWidget(dnsipaddr, 1); + l2->addStretch(1); + tmp = i18n("<p>Allows you to specify a new DNS server to be\n" + "used while you are connected. When the\n" + "connection is closed, this DNS entry will be\n" + "removed again.\n" + "\n" + "To add a DNS server, type in the IP address of\n" + "the DNS server here and click on <b>Add</b>"); + + QWhatsThis::add(dns_label, tmp); + QWhatsThis::add(dnsipaddr, tmp); + + QHBoxLayout *l1 = new QHBoxLayout; + tl->addLayout(l1, 4, 1); + add = new QPushButton(i18n("Add"), parent); + connect(add, SIGNAL(clicked()), SLOT(adddns())); + int width = add->sizeHint().width(); + width = QMAX(width,60); + add->setMinimumWidth(width); + l1->addWidget(add); + l1->addStretch(1); + QWhatsThis::add(add, + i18n("Click this button to add the DNS server\n" + "specified in the field above. The entry\n" + "will then be added to the list below")); + + remove = new QPushButton(i18n("Remove"), parent); + connect(remove, SIGNAL(clicked()), SLOT(removedns())); + width = remove->sizeHint().width(); + width = QMAX(width,60); + remove->setMinimumWidth(width); + l1->addWidget(remove); + QWhatsThis::add(remove, + i18n("Click this button to remove the selected DNS\n" + "server entry from the list below")); + + servers_label = new QLabel(i18n("DNS address list:"), parent); + servers_label->setAlignment(AlignTop|AlignLeft); + tl->addWidget(servers_label, 5, 0); + + dnsservers = new QListBox(parent); + dnsservers->setMinimumSize(150, 80); + connect(dnsservers, SIGNAL(highlighted(int)), + SLOT(DNS_Entry_Selected(int))); + tl->addWidget(dnsservers, 5, 1); + tmp = i18n("<p>This shows all defined DNS servers to use\n" + "while you are connected. Use the <b>Add</b> and\n" + "<b>Remove</b> buttons to modify the list"); + + QWhatsThis::add(servers_label,tmp); + QWhatsThis::add(dnsservers,tmp); + + exdnsdisabled_toggle = new QCheckBox(i18n( \ +"Disable existing DNS servers during connection"), + parent); + exdnsdisabled_toggle->setChecked(gpppdata.exDNSDisabled()); + tl->addMultiCellWidget(exdnsdisabled_toggle, 6, 6, 0, 1, AlignCenter); + QWhatsThis::add(exdnsdisabled_toggle, + i18n("<p>When this option is selected, all DNS\n" + "servers specified in <tt>/etc/resolv.conf</tt> are\n" + "temporary disabled while the dialup connection\n" + "is established. After the connection is\n" + "closed, the servers will be re-enabled\n" + "\n" + "Typically, there is no reason to use this\n" + "option, but it may become useful under \n" + "some circumstances.")); + + + // restore data if editing + if(!isnewaccount) { + dnsservers->insertStringList(gpppdata.dns()); + dnsdomain->setText(gpppdata.domain()); + } + + int mode = gpppdata.autoDNS() ? 0 : 1; + bg->setButton(mode); + DNS_Mode_Selected(mode); + + tl->activate(); +} + +void DNSWidget::DNS_Edit_Changed(const QString &text) { + QRegExp r("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+"); + add->setEnabled(text.find(r) != -1); +} + +void DNSWidget::DNS_Entry_Selected(int) { + remove->setEnabled(true); +} + +void DNSWidget::DNS_Mode_Selected(int mode) { + bool on = (mode == 1); + dns_label->setEnabled(on); + servers_label->setEnabled(on); + dnsipaddr->setText(""); + dnsipaddr->setEnabled(on); + add->setEnabled(false); + remove->setEnabled(dnsservers->count()>0 && on); + dnsservers->clearSelection(); + dnsservers->setEnabled(on); + dnsservers->triggerUpdate(false); +} + +void DNSWidget::save() { + gpppdata.setAutoDNS(bg->id(bg->selected()) == 0); + QStringList serverlist; + for(uint i=0; i < dnsservers->count(); i++) + serverlist.append(dnsservers->text(i)); + gpppdata.setDns(serverlist); + + // strip leading dot + QString s(dnsdomain->text()); + if(s.left(1) == ".") + gpppdata.setDomain(s.mid(1)); + else + gpppdata.setDomain(dnsdomain->text()); + + gpppdata.setExDNSDisabled(exdnsdisabled_toggle->isChecked()); +} + + +void DNSWidget::adddns() { + if(dnsservers->count() < MAX_DNS_ENTRIES) { + dnsservers->insertItem(dnsipaddr->text()); + dnsipaddr->setText(""); + } +} + + +void DNSWidget::removedns() { + int i; + i = dnsservers->currentItem(); + if(i != -1) + dnsservers->removeItem(i); + remove->setEnabled(dnsservers->count()>0); +} + + +// +// GatewayWidget +// +GatewayWidget::GatewayWidget( QWidget *parent, bool isnewaccount, const char *name ) + : QWidget(parent, name) +{ + QVBoxLayout *topLayout = new QVBoxLayout(parent); + topLayout->setSpacing( 2 );//KDialog::spacingHint()); + + box = new QVGroupBox(i18n("Configuration"), parent); +// box->setInsideSpacing( 2 );//KDialog::spacingHint()); + + rb = new QButtonGroup(parent); + rb->hide(); + connect(rb, SIGNAL(clicked(int)), SLOT(hitGatewaySelect(int))); + + defaultgateway = new QRadioButton(box); + defaultgateway->setText(i18n("Default gateway")); + rb->insert(defaultgateway, 0); + QWhatsThis::add(defaultgateway, + i18n("This makes the PPP peer computer (the computer\n" + "you are connected to with your modem) to act as\n" + "a gateway. Your computer will send all packets not\n" + "going to a computer inside your local net to this\n" + "computer, which will route these packets.\n" + "\n" + "This is the default for most ISPs, so you should\n" + "probably leave this option on.")); + + + staticgateway = new QRadioButton(box); + staticgateway->setText(i18n("Static gateway")); + rb->insert(staticgateway, 1); + QWhatsThis::add(staticgateway, + i18n("<p>Allows you to specify which computer you want\n" + "to use as gateway (see <i>Default Gateway</i> above)")); + + QHBox *gateBox = new QHBox(box); + gate_label = new QLabel(i18n("Gateway IP address:"), gateBox); + gatewayaddr = new IPLineEdit(gateBox); + + defaultroute = new QCheckBox(i18n("Assign the default route to this gateway"), + parent); + QWhatsThis::add(defaultroute, + i18n("If this option is enabled, all packets not\n" + "going to the local net are routed through\n" + "the PPP connection.\n" + "\n" + "Normally, you should turn this on")); + + topLayout->addWidget(box); + topLayout->addWidget(defaultroute); + topLayout->addStretch(); + + //load info from gpppdata + if(!isnewaccount) { + if(gpppdata.gateway() == "0.0.0.0") { + defaultgateway->setChecked(true); + hitGatewaySelect(0); + } + else { + gatewayaddr->setText(gpppdata.gateway()); + staticgateway->setChecked(true); + } + defaultroute->setChecked(gpppdata.defaultroute()); + } + else { + defaultgateway->setChecked(true); + hitGatewaySelect(0); + defaultroute->setChecked(true); + } +} + +void GatewayWidget::save() { + gpppdata.setGateway(gatewayaddr->text()); + gpppdata.setDefaultroute(defaultroute->isChecked()); +} + + +void GatewayWidget::hitGatewaySelect( int i ) { + if(i == 0) { + gatewayaddr->setText("0.0.0.0"); + gatewayaddr->setEnabled(false); + gate_label->setEnabled(false); + } + else { + gatewayaddr->setEnabled(true); + gatewayaddr->setText(""); + gate_label->setEnabled(true); + } +} + + + +ScriptWidget::ScriptWidget( QWidget *parent, bool isnewaccount, const char *name ) + : QWidget(parent, name) +{ + QVBoxLayout *tl = new QVBoxLayout(parent, 0 );//, KDialog::spacingHint()); + se = new ScriptEdit(parent); + connect(se, SIGNAL(returnPressed()), SLOT(addButton())); + tl->addWidget(se); + + // insert equal-sized buttons + QButtonGroup *bbox = new QButtonGroup(parent); + add = new QPushButton( bbox, i18n("Add") ); + bbox->insert(add); + connect(add, SIGNAL(clicked()), SLOT(addButton())); +// bbox->addStretch(1); + insert = new QPushButton( bbox, i18n("Insert") ); + bbox->insert(insert); + connect(insert, SIGNAL(clicked()), SLOT(insertButton())); +// bbox->addStretch(1); + remove = new QPushButton( bbox, i18n("Remove") ); + bbox->insert(remove); + connect(remove, SIGNAL(clicked()), SLOT(removeButton())); + bbox->layout(); + tl->addWidget(bbox); + + QHBoxLayout *l12 = new QHBoxLayout(0); + tl->addLayout(l12); + stl = new QListBox(parent); + stl->setVScrollBarMode( QScrollView::AlwaysOff ); + connect(stl, SIGNAL(highlighted(int)), SLOT(stlhighlighted(int))); + stl->setMinimumSize(QSize(70, 140)); + + sl = new QListBox(parent); + sl->setVScrollBarMode( QScrollView::AlwaysOff ); + connect(sl, SIGNAL(highlighted(int)), SLOT(slhighlighted(int))); + sl->setMinimumSize(QSize(150, 140)); + + slb = new QScrollBar(parent); + slb->setFixedWidth(slb->sizeHint().width()); + connect(slb, SIGNAL(valueChanged(int)), SLOT(scrolling(int))); + + l12->addWidget(stl, 1); + l12->addWidget(sl, 3); + l12->addWidget(slb, 0); + + //load data from gpppdata + if(!isnewaccount) { + QStringList &comlist = gpppdata.scriptType(); + QStringList &arglist = gpppdata.script(); + QStringList::Iterator itcom = comlist.begin(); + QStringList::Iterator itarg = arglist.begin(); + + for ( ; + itcom != comlist.end() && itarg != arglist.end(); + ++itcom, ++itarg ) + { + stl->insertItem(*itcom); + sl->insertItem(*itarg); + } + } + + insert->setEnabled(false); + remove->setEnabled(false); + adjustScrollBar(); + tl->activate(); +} + +bool ScriptWidget::check() { + uint lstart = 0; + uint lend = 0; + uint errcnt = 0; + + if(sl->count() > 0) { + for( uint i=0; i <= sl->count()-1; i++) { + if(stl->text(i) == "LoopStart") { + lstart++; + } + if (stl->text(i) == "LoopEnd") { + lend++; + } + if ( lend > lstart ) errcnt++; + } + return ( (errcnt == 0 ) && (lstart == lend) ); + } + return true; +} + + +void ScriptWidget::save() { + QStringList typelist, arglist; + for(uint i=0; i < sl->count(); i++) { + typelist.append(stl->text(i)); + arglist.append(sl->text(i)); + } + gpppdata.setScriptType(typelist); + gpppdata.setScript(arglist); +} + + + +void ScriptWidget::adjustScrollBar() { + if((int)sl->count() <= sl->numItemsVisible()) + slb->setRange(0, 0); + else + slb->setRange(0, (sl->count() - sl->numItemsVisible())+1); +} + + +void ScriptWidget::scrolling(int i) { + sl->setTopItem(i); + stl->setTopItem(i); +} + + +void ScriptWidget::slhighlighted(int i) { + insert->setEnabled(true); + remove->setEnabled(true); + stl->setCurrentItem(i); +} + + +void ScriptWidget::stlhighlighted(int i) { + insert->setEnabled(true); + remove->setEnabled(true); + sl->setCurrentItem(i); +} + + +void ScriptWidget::addButton() { + //don't allow more than the maximum script entries + if(sl->count() == MAX_SCRIPT_ENTRIES-1) + return; + + switch(se->type()) { + case ScriptEdit::Expect: + stl->insertItem("Expect"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::Send: + stl->insertItem("Send"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::SendNoEcho: + stl->insertItem("SendNoEcho"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::Pause: + stl->insertItem("Pause"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::Hangup: + stl->insertItem("Hangup"); + sl->insertItem(""); + break; + + case ScriptEdit::Answer: + stl->insertItem("Answer"); + sl->insertItem(""); + break; + + case ScriptEdit::Timeout: + stl->insertItem("Timeout"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::Password: + stl->insertItem("Password"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::ID: + stl->insertItem("ID"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::Prompt: + stl->insertItem("Prompt"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::PWPrompt: + stl->insertItem("PWPrompt"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::LoopStart: + stl->insertItem("LoopStart"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::LoopEnd: + stl->insertItem("LoopEnd"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::Scan: + stl->insertItem("Scan"); + sl->insertItem(se->text()); + break; + + case ScriptEdit::Save: + stl->insertItem("Save"); + sl->insertItem(se->text()); + break; + + default: + break; + } + + //get the scrollbar adjusted, and scroll the list so we can see what + //we're adding to + adjustScrollBar(); + slb->setValue(slb->maxValue()); + + //clear the text in the entry box + se->setText(""); +} + + +void ScriptWidget::insertButton() { + //exit if there is no highlighted item, or we've reached the + //maximum entries in the script list + if(sl->currentItem() < 0 || (sl->count() == MAX_SCRIPT_ENTRIES-1)) + return; + + switch(se->type()) { + case ScriptEdit::Expect: + stl->insertItem("Expect", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::Send: + stl->insertItem("Send", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::SendNoEcho: + stl->insertItem("SendNoEcho", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::Pause: + stl->insertItem("Pause", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::Hangup: + stl->insertItem("Hangup", stl->currentItem()); + sl->insertItem("", sl->currentItem()); + break; + + case ScriptEdit::Answer: + stl->insertItem("Answer", stl->currentItem()); + sl->insertItem("", sl->currentItem()); + break; + + case ScriptEdit::Timeout: + stl->insertItem("Timeout", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::Password: + stl->insertItem("Password", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::ID: + stl->insertItem("ID", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::Prompt: + stl->insertItem("Prompt", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::PWPrompt: + stl->insertItem("PWPrompt", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::LoopStart: + stl->insertItem("LoopStart", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::LoopEnd: + stl->insertItem("LoopEnd", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::Scan: + stl->insertItem("Scan", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + case ScriptEdit::Save: + stl->insertItem("Save", stl->currentItem()); + sl->insertItem(se->text(), sl->currentItem()); + break; + + default: + break; + } + adjustScrollBar(); + se->setText(""); +} + + +void ScriptWidget::removeButton() { + if(sl->currentItem() >= 0) { + int stlc = stl->currentItem(); + sl->removeItem(sl->currentItem()); + stl->removeItem(stlc); + adjustScrollBar(); + insert->setEnabled(sl->currentItem() != -1); + remove->setEnabled(sl->currentItem() != -1); + } +} + + + +///////////////////////////////////////////////////////////////////////////// +// +// Used to specify a new phone number +// +///////////////////////////////////////////////////////////////////////////// +PhoneNumberDialog::PhoneNumberDialog(QWidget *parent) + : QDialog(parent, 0, true ) { + setCaption( i18n("Add Phone Number") ); +// KWin::setIcons(winId(), kapp->icon(), kapp->miniIcon()); + + QHBox *hbox = new QHBox(this); +// setMainWidget(hbox); + + hbox->setSpacing( 2 );//KDialog::spacingHint()); + + new QLabel(i18n("Enter a phone number:"), hbox); + + le = newLineEdit(14, hbox); + le->setMinimumWidth(125); + + connect(le, SIGNAL(textChanged(const QString &)), + this, SLOT(textChanged(const QString &))); + + le->setFocus(); + textChanged(""); + +// enableButtonSeparator(true); +} + + +QString PhoneNumberDialog::phoneNumber() { + QString s = le->text(); + + return s; +} + + +void PhoneNumberDialog::textChanged(const QString &s) { +// enableButtonOK(s.length() > 0); +} + + +//#include "edit.moc" diff --git a/noncore/settings/networksettings/ppp/edit.h b/noncore/settings/networksettings/ppp/edit.h new file mode 100644 index 0000000..cd0161f --- a/dev/null +++ b/noncore/settings/networksettings/ppp/edit.h @@ -0,0 +1,251 @@ +/* -*- C++ -*- + * + * kPPP: A pppd Front End for the KDE project + * + * $Id$ + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _EDIT_H_ +#define _EDIT_H_ + +#include <qdialog.h> +#include <qpushbutton.h> +#include <qgroupbox.h> +#include <qvgroupbox.h> +#include <qscrollbar.h> +#include <qcombobox.h> +#include <qlineedit.h> +#include <qlistbox.h> +#include <qradiobutton.h> +#include <qbuttongroup.h> +#include <qcheckbox.h> +#include <qlabel.h> +//#include <kdialogbase.h> +#include "scriptedit.h" +#include "kpppconfig.h" +#include "pppdargs.h" + +class IPLineEdit; + +class DialWidget : public QWidget { + Q_OBJECT +public: + DialWidget( QWidget *parent=0, bool isnewaccount = true, const char *name=0 ); + ~DialWidget() {} + +public slots: + bool save(); + void pppdargsbutton(); + void numbersChanged(); + void selectionChanged(int); + void addNumber(); + void delNumber(); + void upNumber(); + void downNumber(); + +private: + QLineEdit *connectname_l; + QLabel *connect_label; + QLabel *number_label; + QPushButton *pppdargs; + QComboBox *auth; + QLabel *auth_l; + QCheckBox *store_password; + + // for the phonenumber selection + QPushButton *add, *del, *up, *down; + QListBox *numbers; +}; + + +///////////////////////////////////////////////////////////////////////////// +// +// tab-window to select what to execute when +// +///////////////////////////////////////////////////////////////////////////// +class ExecWidget : public QWidget { + Q_OBJECT +public: + ExecWidget(QWidget *parent=0, bool isnewaccount=true, const char *name=0); + +public slots: + bool save(); + +private: + QLineEdit *before_connect; + QLabel *before_connect_l; + + QLineEdit *command; + QLabel *command_label; + + QLineEdit *predisconnect; + QLabel *predisconnect_label; + + QLineEdit *discommand; + QLabel *discommand_label; +}; + + +class IPWidget : public QWidget { + Q_OBJECT +public: + IPWidget( QWidget *parent=0, bool isnewaccount = true, const char *name=0 ); + ~IPWidget() {} + +public slots: + void save(); + +protected slots: + void hitIPSelect( int ); + void autoname_t(bool on); + +private: + QLabel *ipaddress_label; + QLabel *sub_label; + QGroupBox *box1; + QVGroupBox *box; + + QButtonGroup *rb; + QRadioButton *dynamicadd_rb; + QRadioButton *staticadd_rb; + + IPLineEdit *ipaddress_l; + IPLineEdit *subnetmask_l; + + QCheckBox *autoname; +}; + + +class DNSWidget : public QWidget { + Q_OBJECT +public: + DNSWidget( QWidget *parent=0, bool isnewaccount = true, const char *name=0 ); + ~DNSWidget() {} + +public slots: + void save(); + +protected slots: + void adddns(); + void removedns(); + void DNS_Edit_Changed(const QString &); + void DNS_Entry_Selected(int); + void DNS_Mode_Selected(int); + +private: + QLabel *conf_label; + QButtonGroup *bg; + QRadioButton *autodns, *mandns; + QLabel *dns_label; + QLabel *servers_label; + IPLineEdit *dnsipaddr; + QPushButton *add; + QPushButton *remove; + QListBox *dnsservers; + QLineEdit *dnsdomain; + QLabel *dnsdomain_label; + QCheckBox *exdnsdisabled_toggle; +}; + + +class GatewayWidget : public QWidget { + Q_OBJECT +public: + GatewayWidget( QWidget *parent=0, bool isnewaccount = true, const char *name=0 ); + ~GatewayWidget() {} + +public slots: + void save(); + +private slots: + void hitGatewaySelect( int ); + +private: + QGroupBox *box; + QLabel *gate_label; + QGroupBox *box1; + QButtonGroup *rb; + QRadioButton *defaultgateway; + QRadioButton *staticgateway; + IPLineEdit *gatewayaddr; + QCheckBox *defaultroute; +}; + + +class ScriptWidget : public QWidget { + Q_OBJECT +public: + ScriptWidget( QWidget *parent=0, bool isnewaccount = true, const char *name=0 ); + ~ScriptWidget() {} + +public slots: + void save(); + bool check(); + +private slots: + void addButton(); + void insertButton(); + void removeButton(); + + //signals linked to the scroll bar + void scrolling(int); + + //signals to keep the two listboxes highlighted in sync + void slhighlighted(int); + void stlhighlighted(int); + +private: + void adjustScrollBar(); + + ScriptEdit *se; + QPushButton *add; + QPushButton *remove; + QPushButton *insert; + QListBox *sl, *stl; + + QScrollBar *slb; +}; + + +///////////////////////////////////////////////////////////////////////////// +// +// Used to specify a new phone number +// +///////////////////////////////////////////////////////////////////////////// +class PhoneNumberDialog : public QDialog { + Q_OBJECT +public: + PhoneNumberDialog(QWidget *parent = 0); + + QString phoneNumber(); + +private slots: + void textChanged(const QString &); + +private: + QLineEdit *le; +}; + + +#endif diff --git a/noncore/settings/networksettings/ppp/general.cpp b/noncore/settings/networksettings/ppp/general.cpp new file mode 100644 index 0000000..f803628 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/general.cpp @@ -0,0 +1,421 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <termios.h> +#include <string.h> +#include <qwhatsthis.h> + +#include "knuminput.h" +#include <qslider.h> +#include <qlayout.h> +#include "general.h" +//#include "version.h" +//#include "miniterm.h" +#include "modeminfo.h" +#include "modemcmds.h" +#include "devices.h" +#include "pppdata.h" +//#include <klocale.h> +#define i18n QObject::tr + + + +ModemWidget::ModemWidget( QWidget *parent, const char *name) + : QWidget(parent, name) +{ + int k; + + QGridLayout *tl = new QGridLayout(this, 8, 2, 0 );//, KDialog::spacingHint()); + + label1 = new QLabel(i18n("Modem de&vice:"), this); + tl->addWidget(label1, 0, 0); + + modemdevice = new QComboBox(false, this); + label1->setBuddy(modemdevice); + + for(k = 0; devices[k]; k++) + modemdevice->insertItem(devices[k]); + + tl->addWidget(modemdevice, 0, 1); + connect(modemdevice, SIGNAL(activated(int)), + SLOT(setmodemdc(int))); + QString tmp = i18n("This specifies the serial port your modem is attached \n" + "to. On Linux/x86, typically this is either /dev/ttyS0 \n" + "(COM1 under DOS) or /dev/ttyS1 (COM2 under DOS).\n" + "\n" + "If you have an internal ISDN card with AT command\n" + "emulation (most cards under Linux support this), you\n" + "should select one of the /dev/ttyIx devices."); + + QWhatsThis::add(label1,tmp); + QWhatsThis::add(modemdevice,tmp); + + + label2 = new QLabel(i18n("&Flow control:"), this); + tl->addWidget(label2, 1, 0); + + flowcontrol = new QComboBox(false, this); + label2->setBuddy(flowcontrol); + flowcontrol->insertItem(i18n("Hardware [CRTSCTS]")); + flowcontrol->insertItem(i18n("Software [XON/XOFF]")); + flowcontrol->insertItem(i18n("None")); + tl->addWidget(flowcontrol, 1, 1); + connect(flowcontrol, SIGNAL(activated(int)), + SLOT(setflowcontrol(int))); + + tmp = i18n("<p>Specifies how the serial port and modem\n" + "communicate. You should not change this unless\n" + "you know what you are doing.\n" + "\n" + "<b>Default</b>: CRTSCTS"); + + QWhatsThis::add(label2,tmp); + QWhatsThis::add(flowcontrol,tmp); + + labelenter = new QLabel(i18n("&Line termination:"), this); + tl->addWidget(labelenter, 2, 0); + + enter = new QComboBox(false, this); + labelenter->setBuddy(enter); + enter->insertItem("CR"); + enter->insertItem("LF"); + enter->insertItem("CR/LF"); + tl->addWidget(enter, 2, 1); + connect(enter, SIGNAL(activated(int)), SLOT(setenter(int))); + tmp = i18n("<p>Specifies how AT commands are sent to your\n" + "modem. Most modems will work fine with the\n" + "default <i>CR/LF</i>. If your modem does not react\n" + "to the init string, you should try different\n" + "settings here\n" + "\n" + "<b>Default</b>: CR/LF"); + + QWhatsThis::add(labelenter,tmp); + QWhatsThis::add(enter, tmp); + + baud_label = new QLabel(i18n("Co&nnection speed:"), this); + tl->addWidget(baud_label, 3, 0); + baud_c = new QComboBox(this); + baud_label->setBuddy(baud_c); + + static const char *baudrates[] = { + +#ifdef B460800 + "460800", +#endif + +#ifdef B230400 + "230400", +#endif + +#ifdef B115200 + "115200", +#endif + +#ifdef B57600 + "57600", +#endif + + "38400", + "19200", + "9600", + "2400", + 0}; + + for(k = 0; baudrates[k]; k++) + baud_c->insertItem(baudrates[k]); + + baud_c->setCurrentItem(3); + connect(baud_c, SIGNAL(activated(int)), + this, SLOT(speed_selection(int))); + tl->addWidget(baud_c, 3, 1); + + tmp = i18n("Specifies the speed your modem and the serial\n" + "port talk to each other. You should begin with\n" + "the default of 38400 bits/sec. If everything\n" + "works you can try to increase this value, but to\n" + "no more than 115200 bits/sec (unless you know\n" + "that your serial port supports higher speeds)."); + + QWhatsThis::add(baud_label,tmp); + QWhatsThis::add(baud_c,tmp); + + for(int i=0; i <= enter->count()-1; i++) { + if(gpppdata.enter() == enter->text(i)) + enter->setCurrentItem(i); + } + + tl->addRowSpacing(4, 10); + + //Modem Lock File + modemlockfile = new QCheckBox(i18n("&Use lock file"), this); + + modemlockfile->setChecked(gpppdata.modemLockFile()); + connect(modemlockfile, SIGNAL(toggled(bool)), + SLOT(modemlockfilechanged(bool))); + tl->addMultiCellWidget(modemlockfile, 5, 5, 0, 1); + // l12->addStretch(1); + QWhatsThis::add(modemlockfile, + i18n("<p>To prevent other programs from accessing the\n" + "modem while a connection is established, a\n" + "file can be created to indicate that the modem\n" + "is in use. On Linux an example file would be\n" + "<tt>/var/lock/LCK..ttyS1</tt>\n" + "Here you can select whether this locking will\n" + "be done.\n" + "\n" + "<b>Default</b>: On")); + + // Modem Timeout Line Edit Box + + modemtimeout = new KIntNumInput(gpppdata.modemTimeout(), this); + modemtimeout->setLabel(i18n("Modem &timeout:")); + modemtimeout->setRange(1, 120, 1); + modemtimeout->setSuffix(i18n(" sec")); + connect(modemtimeout, SIGNAL(valueChanged(int)), + SLOT(modemtimeoutchanged(int))); + tl->addMultiCellWidget(modemtimeout, 6, 6, 0, 1); + + QWhatsThis::add(modemtimeout, + i18n("This specifies how long <i>kppp</i> waits for a\n" + "<i>CONNECT</i> response from your modem. The\n" + "recommended value is 30 seconds.")); + + //set stuff from gpppdata + for(int i=0; i <= enter->count()-1; i++) { + if(gpppdata.enter() == enter->text(i)) + enter->setCurrentItem(i); + } + + for(int i=0; i <= modemdevice->count()-1; i++) { + if(gpppdata.modemDevice() == modemdevice->text(i)) + modemdevice->setCurrentItem(i); + } + + for(int i=0; i <= flowcontrol->count()-1; i++) { + if(gpppdata.flowcontrol() == flowcontrol->text(i)) + flowcontrol->setCurrentItem(i); + } + + //set the modem speed + for(int i=0; i < baud_c->count(); i++) + if(baud_c->text(i) == gpppdata.speed()) + baud_c->setCurrentItem(i); + + tl->setRowStretch(7, 1); +} + + +void ModemWidget::speed_selection(int) { + gpppdata.setSpeed(baud_c->text(baud_c->currentItem())); +} + + +void ModemWidget::setenter(int ) { + gpppdata.setEnter(enter->text(enter->currentItem())); +} + + +void ModemWidget::setmodemdc(int i) { + gpppdata.setModemDevice(modemdevice->text(i)); +} + + +void ModemWidget::setflowcontrol(int i) { + gpppdata.setFlowcontrol(flowcontrol->text(i)); +} + + +void ModemWidget::modemlockfilechanged(bool set) { + gpppdata.setModemLockFile(set); +} + + +void ModemWidget::modemtimeoutchanged(int n) { + gpppdata.setModemTimeout(n); +} + + +ModemWidget2::ModemWidget2( QWidget *parent, const char *name) + : QWidget(parent, name) +{ + QVBoxLayout *l1 = new QVBoxLayout(this, 0 );//, KDialog::spacingHint()); + + + waitfordt = new QCheckBox(i18n("&Wait for dial tone before dialing"), this); + waitfordt->setChecked(gpppdata.waitForDialTone()); + connect(waitfordt, SIGNAL(toggled(bool)), SLOT(waitfordtchanged(bool))); + l1->addWidget(waitfordt); + QWhatsThis::add(waitfordt, + i18n("<p>Normally the modem waits for a dial tone\n" + "from your phone line, indicating that it can\n" + "start to dial a number. If your modem does not\n" + "recognize this sound, or your local phone system\n" + "does not emit such a tone, uncheck this option\n" + "\n" + "<b>Default:</b>: On")); + + busywait = new KIntNumInput(gpppdata.busyWait(), this); + busywait->setLabel(i18n("B&usy wait:")); + busywait->setRange(0, 300, 5, true); + busywait->setSuffix(i18n(" sec")); + connect(busywait, SIGNAL(valueChanged(int)), SLOT(busywaitchanged(int))); + l1->addWidget(busywait); + + QWhatsThis::add(busywait, + i18n("Specifies the number of seconds to wait before\n" + "redial if all dialed numbers are busy. This is\n" + "necessary because some modems get stuck if the\n" + "same number is busy too often.\n" + "\n" + "The default is 0 seconds, you should not change\n" + "this unless you need to.")); + + l1->addSpacing(10); + + QHBoxLayout *hbl = new QHBoxLayout; + hbl->setSpacing(2);//KDialog::spacingHint()); + + QLabel *volumeLabel = new QLabel(i18n("Modem &volume:"), this); + hbl->addWidget(volumeLabel); + volume = new QSlider(0, 2, 1, gpppdata.volume(), QSlider::Horizontal, this); + volumeLabel->setBuddy(volume); + volume->setTickmarks(QSlider::Below); + hbl->addWidget(volume); + + l1->addLayout(hbl); + + connect(volume, SIGNAL(valueChanged(int)), + this, SLOT(volumeChanged(int))); + QString tmp = i18n("Most modems have a speaker which makes\n" + "a lot of noise when dialing. Here you can\n" + "either turn this completely off or select a\n" + "lower volume.\n" + "\n" + "If this does not work for your modem,\n" + "you must modify the modem volume command."); + + QWhatsThis::add(volumeLabel,tmp); + QWhatsThis::add(volume, tmp); + + l1->addSpacing(20); + +#if 0 + chkbox1 = new QCheckBox(i18n("Modem asserts CD line"), this); + chkbox1->setChecked(gpppdata.UseCDLine()); + connect(chkbox1,SIGNAL(toggled(bool)), + this,SLOT(use_cdline_toggled(bool))); + l12->addWidget(chkbox1); + l12->addStretch(1); + l1->addStretch(1); + QWhatsThis::add(chkbox1, + i18n("This controls how <i>kppp</i> detects that the modem\n" + "is not responding. Unless you are having\n" + "problems with this, do not modify this setting.\n" + "\n" + "<b>Default</b>: Off")); +#endif + + modemcmds = new QPushButton(i18n("Mod&em Commands..."), this); + QWhatsThis::add(modemcmds, + i18n("Allows you to change the AT command for\n" + "your modem.")); + + modeminfo_button = new QPushButton(i18n("&Query Modem..."), this); + QWhatsThis::add(modeminfo_button, + i18n("Most modems support the ATI command set to\n" + "find out vendor and revision of your modem.\n" + "\n" + "Press this button to query your modem for\n" + "this information. It can be useful to help\n" + "you setup the modem")); + +// terminal_button = new QPushButton(i18n("&Terminal..."), this); +// QWhatsThis::add(terminal_button, +// i18n("Opens the built-in terminal program. You\n" +// "can use this if you want to play around\n" +// "with your modem's AT command set")); + + QHBoxLayout *hbox = new QHBoxLayout(); + l1->addLayout(hbox); + hbox->addStretch(1); + QVBoxLayout *vbox = new QVBoxLayout(); + hbox->addLayout(vbox); + + vbox->addWidget(modemcmds); + vbox->addWidget(modeminfo_button); +// vbox->addWidget(terminal_button); + + hbox->addStretch(1); + l1->addStretch(1); + + connect(modemcmds, SIGNAL(clicked()), + SLOT(modemcmdsbutton())); + connect(modeminfo_button, SIGNAL(clicked()), + SLOT(query_modem())); +// connect(terminal_button, SIGNAL(clicked()), +// SLOT(terminal())); +} + + +void ModemWidget2::modemcmdsbutton() { + ModemCommands mc(this); + mc.showMaximized(); + mc.exec(); +} + + +void ModemWidget2::query_modem() { + ModemTransfer mt(this); + mt.exec(); +} + + +// void ModemWidget2::terminal() { +// MiniTerm terminal(NULL,NULL); +// terminal.exec(); +// } + + +#if 0 +void ModemWidget2::use_cdline_toggled(bool on) { + gpppdata.setUseCDLine(on); +} +#endif + +void ModemWidget2::waitfordtchanged(bool b) { + gpppdata.setWaitForDialTone((int)b); +} + +void ModemWidget2::busywaitchanged(int n) { + gpppdata.setbusyWait(n); +} + + +void ModemWidget2::volumeChanged(int v) { + gpppdata.setVolume(v); +} + diff --git a/noncore/settings/networksettings/ppp/general.h b/noncore/settings/networksettings/ppp/general.h new file mode 100644 index 0000000..66a9eec --- a/dev/null +++ b/noncore/settings/networksettings/ppp/general.h @@ -0,0 +1,100 @@ +/* + * + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _GENERAL_H_ +#define _GENERAL_H_ + +#include <qwidget.h> +#include <qcombobox.h> +#include <qlabel.h> +#include <qcheckbox.h> +#include <qgroupbox.h> +#include <qpushbutton.h> +//#include <kcolorbutton.h> + +class QSlider; +class KIntNumInput; + + + +class ModemWidget : public QWidget { + Q_OBJECT +public: + ModemWidget( QWidget *parent=0, const char *name=0 ); + +private slots: + void setmodemdc(int); + void setflowcontrol(int); + void modemtimeoutchanged(int); + void modemlockfilechanged(bool); + void setenter(int); + void speed_selection(int); + +private: + QComboBox *enter; + QLabel *label1; + QLabel *label2; + QLabel *labeltmp; + QLabel *labelenter; + QComboBox *modemdevice; + QComboBox *flowcontrol; + + QComboBox *baud_c; + QLabel *baud_label; + + KIntNumInput *modemtimeout; + QCheckBox *modemlockfile; +}; + + +class ModemWidget2 : public QWidget { + Q_OBJECT +public: + ModemWidget2( QWidget *parent=0, const char *name=0 ); + +private slots: + void waitfordtchanged(bool); + void busywaitchanged(int); +// void use_cdline_toggled(bool); + void modemcmdsbutton(); + // void terminal(); + void query_modem(); + void volumeChanged(int); + +private: + QLabel *labeltmp; + QPushButton *modemcmds; + QPushButton *modeminfo_button; + // QPushButton *terminal_button; + QFrame *fline; + QCheckBox *waitfordt; + KIntNumInput *busywait; + QCheckBox *chkbox1; + QSlider *volume; +}; + +#endif + + diff --git a/noncore/settings/networksettings/ppp/iplined.cpp b/noncore/settings/networksettings/ppp/iplined.cpp new file mode 100644 index 0000000..f4fc370 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/iplined.cpp @@ -0,0 +1,42 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "iplined.h" + +IPLineEdit::IPLineEdit( QWidget *parent, const char *name ) + : QLineEdit(parent, name )//, "0123456789.") +{ + setMaxLength(3 * 4 + 1 * 3); +} + +QSize IPLineEdit::sizeHint() const { + QFontMetrics fm = fontMetrics(); + + QSize s; + s.setHeight(QLineEdit::sizeHint().height()); + s.setWidth(fm.boundingRect("888.888.888.888XX").width()); + return s; +} diff --git a/noncore/settings/networksettings/ppp/iplined.h b/noncore/settings/networksettings/ppp/iplined.h new file mode 100644 index 0000000..825f0ac --- a/dev/null +++ b/noncore/settings/networksettings/ppp/iplined.h @@ -0,0 +1,40 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _IPLINED_H_ +#define _IPLINED_H_ + +#include <qlineedit.h> + +class IPLineEdit : public QLineEdit { +public: + IPLineEdit( QWidget *parent=0, const char *name=0 ); + ~IPLineEdit() {} + + virtual QSize sizeHint() const; +}; + +#endif diff --git a/noncore/settings/networksettings/ppp/knuminput.cpp b/noncore/settings/networksettings/ppp/knuminput.cpp new file mode 100644 index 0000000..afaa581 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/knuminput.cpp @@ -0,0 +1,1103 @@ +// -*- c-basic-offset: 4 -*- +/* + * knuminput.cpp + * + * Initial implementation: + * Copyright (c) 1997 Patrick Dowler <dowler@morgul.fsh.uvic.ca> + * Rewritten and maintained by: + * Copyright (c) 2000 Dirk A. Mueller <mueller@kde.org> + * KDoubleSpinBox: + * Copyright (c) 2002 Marc Mutz <mutz@kde.org> + * + * Requires the Qt widget libraries, available at no cost at + * http://www.troll.no/ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +//#include <config.h> +#ifdef HAVE_LIMITS_H +#include <limits.h> +#endif +#include <assert.h> +#include <math.h> +#include <algorithm> + +#include <qlabel.h> +#include <qlineedit.h> +#include <qsize.h> +#include <qslider.h> +#include <qspinbox.h> +#include <qstyle.h> + +//#include <kglobal.h> + +template<class T> +inline const T& kMin (const T& a, const T& b) { return a < b ? a : b; } + +template<class T> +inline const T& kMax (const T& a, const T& b) { return b < a ? a : b; } + +//#include <klocale.h> +#define i18n QObject::tr +//#include <kdebug.h> + +#include "knumvalidator.h" +#include "knuminput.h" + +static inline int calcDiffByTen( int x, int y ) { + // calculate ( x - y ) / 10 without overflowing ints: + return ( x / 10 ) - ( y / 10 ) + ( x % 10 - y % 10 ) / 10; +}; + +// ---------------------------------------------------------------------------- + +KNumInput::KNumInput(QWidget* parent, const char* name) + : QWidget(parent, name) +{ + init(); +} + +KNumInput::KNumInput(KNumInput* below, QWidget* parent, const char* name) + : QWidget(parent, name) +{ + init(); + + if(below) { + m_next = below->m_next; + m_prev = below; + below->m_next = this; + if(m_next) + m_next->m_prev = this; + } +} + +void KNumInput::init() +{ + m_prev = m_next = 0; + m_colw1 = m_colw2 = 0; + + m_label = 0; + m_slider = 0; + m_alignment = 0; +} + +KNumInput::~KNumInput() +{ + if(m_prev) + m_prev->m_next = m_next; + + if(m_next) + m_next->m_prev = m_prev; +} + +void KNumInput::setLabel(const QString & label, int a) +{ + if(label.isEmpty()) { + delete m_label; + m_label = 0; + m_alignment = 0; + } + else { + if (m_label) m_label->setText(label); + else m_label = new QLabel(label, this, "KNumInput::QLabel"); + m_label->setAlignment((a & (~(AlignTop|AlignBottom|AlignVCenter))) + | AlignVCenter); + // if no vertical alignment set, use Top alignment + if(!(a & (AlignTop|AlignBottom|AlignVCenter))) + a |= AlignTop; + m_alignment = a; + } + + layout(true); +} + +QString KNumInput::label() const +{ + if (m_label) return m_label->text(); + return QString::null; +} + +void KNumInput::layout(bool deep) +{ + int w1 = m_colw1; + int w2 = m_colw2; + + // label sizeHint + m_sizeLabel = (m_label ? m_label->sizeHint() : QSize(0,0)); + + if(m_label && (m_alignment & AlignVCenter)) + m_colw1 = m_sizeLabel.width() + 4; + else + m_colw1 = 0; + + // slider sizeHint + m_sizeSlider = (m_slider ? m_slider->sizeHint() : QSize(0, 0)); + + doLayout(); + + if(!deep) { + m_colw1 = w1; + m_colw2 = w2; + return; + } + + KNumInput* p = this; + while(p) { + p->doLayout(); + w1 = QMAX(w1, p->m_colw1); + w2 = QMAX(w2, p->m_colw2); + p = p->m_prev; + } + + p = m_next; + while(p) { + p->doLayout(); + w1 = QMAX(w1, p->m_colw1); + w2 = QMAX(w2, p->m_colw2); + p = p->m_next; + } + + p = this; + while(p) { + p->m_colw1 = w1; + p->m_colw2 = w2; + p = p->m_prev; + } + + p = m_next; + while(p) { + p->m_colw1 = w1; + p->m_colw2 = w2; + p = p->m_next; + } + +// kdDebug() << "w1 " << w1 << " w2 " << w2 << endl; +} + +QSizePolicy KNumInput::sizePolicy() const +{ + return QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Fixed ); +} + +QSize KNumInput::sizeHint() const +{ + return minimumSizeHint(); +} + +void KNumInput::setSteps(int minor, int major) +{ + if(m_slider) + m_slider->setSteps( minor, major ); +} + + +// ---------------------------------------------------------------------------- + +KIntSpinBox::KIntSpinBox(QWidget *parent, const char *name) + : QSpinBox(0, 99, 1, parent, name) +{ + editor()->setAlignment(AlignRight); + val_base = 10; + setValue(0); +} + +KIntSpinBox::~KIntSpinBox() +{ +} + +KIntSpinBox::KIntSpinBox(int lower, int upper, int step, int value, int base, + QWidget* parent, const char* name) + : QSpinBox(lower, upper, step, parent, name) +{ + editor()->setAlignment(AlignRight); + val_base = base; + setValue(value); +} + +void KIntSpinBox::setBase(int base) +{ + val_base = base; +} + + +int KIntSpinBox::base() const +{ + return val_base; +} + +QString KIntSpinBox::mapValueToText(int v) +{ + return QString::number(v, val_base); +} + +int KIntSpinBox::mapTextToValue(bool* ok) +{ + return cleanText().toInt(ok, val_base); +} + +void KIntSpinBox::setEditFocus(bool mark) +{ + editor()->setFocus(); + if(mark) + editor()->selectAll(); +} + + +// ---------------------------------------------------------------------------- + +class KIntNumInput::KIntNumInputPrivate { +public: + int referencePoint; + short blockRelative; + KIntNumInputPrivate( int r ) + : referencePoint( r ), + blockRelative( 0 ) {} +}; + + +KIntNumInput::KIntNumInput(KNumInput* below, int val, QWidget* parent, + int _base, const char* name) + : KNumInput(below, parent, name) +{ + init(val, _base); +} + +KIntNumInput::KIntNumInput(QWidget *parent, const char *name) + : KNumInput(parent, name) +{ + init(0, 10); +} + +KIntNumInput::KIntNumInput(int val, QWidget *parent, int _base, const char *name) + : KNumInput(parent, name) +{ + init(val, _base); + +} + +void KIntNumInput::init(int val, int _base) +{ + d = new KIntNumInputPrivate( val ); + m_spin = new KIntSpinBox(INT_MIN, INT_MAX, 1, val, _base, this, "KIntNumInput::KIntSpinBox"); + m_spin->setValidator(new KIntValidator(this, _base, "KNumInput::KIntValidtr")); + connect(m_spin, SIGNAL(valueChanged(int)), SLOT(spinValueChanged(int))); + connect(this, SIGNAL(valueChanged(int)), + SLOT(slotEmitRelativeValueChanged(int))); + + setFocusProxy(m_spin); + layout(true); +} + +void KIntNumInput::setReferencePoint( int ref ) { + // clip to valid range: + ref = kMin( maxValue(), kMax( minValue(), ref ) ); + d->referencePoint = ref; +} + +int KIntNumInput::referencePoint() const { + return d->referencePoint; +} + +void KIntNumInput::spinValueChanged(int val) +{ + if(m_slider) + m_slider->setValue(val); + + emit valueChanged(val); +} + +void KIntNumInput::slotEmitRelativeValueChanged( int value ) { + if ( d->blockRelative || !d->referencePoint ) return; + emit relativeValueChanged( double( value ) / double( d->referencePoint ) ); +} + +void KIntNumInput::setRange(int lower, int upper, int step, bool slider) +{ + upper = kMax(upper, lower); + lower = kMin(upper, lower); + m_spin->setMinValue(lower); + m_spin->setMaxValue(upper); + m_spin->setLineStep(step); + + step = m_spin->lineStep(); // maybe QRangeControl didn't like out lineStep? + + if(slider) { + if (m_slider) + m_slider->setRange(lower, upper); + else { + m_slider = new QSlider(lower, upper, step, m_spin->value(), + QSlider::Horizontal, this); + m_slider->setTickmarks(QSlider::Below); + connect(m_slider, SIGNAL(valueChanged(int)), + m_spin, SLOT(setValue(int))); + } + + // calculate (upper-lower)/10 without overflowing int's: + int major = calcDiffByTen( upper, lower ); + if ( major==0 ) major = step; // #### workaround Qt bug in 2.1-beta4 + + m_slider->setSteps(step, major); + m_slider->setTickInterval(major); + } + else { + delete m_slider; + m_slider = 0; + } + + // check that reference point is still inside valid range: + setReferencePoint( referencePoint() ); + + layout(true); +} + +void KIntNumInput::setMinValue(int min) +{ + setRange(min, m_spin->maxValue(), m_spin->lineStep(), m_slider); +} + +int KIntNumInput::minValue() const +{ + return m_spin->minValue(); +} + +void KIntNumInput::setMaxValue(int max) +{ + setRange(m_spin->minValue(), max, m_spin->lineStep(), m_slider); +} + +int KIntNumInput::maxValue() const +{ + return m_spin->maxValue(); +} + +void KIntNumInput::setSuffix(const QString &suffix) +{ + m_spin->setSuffix(suffix); + + layout(true); +} + +QString KIntNumInput::suffix() const +{ + return m_spin->suffix(); +} + +void KIntNumInput::setPrefix(const QString &prefix) +{ + m_spin->setPrefix(prefix); + + layout(true); +} + +QString KIntNumInput::prefix() const +{ + return m_spin->prefix(); +} + +void KIntNumInput::setEditFocus(bool mark) +{ + m_spin->setEditFocus(mark); +} + +QSize KIntNumInput::minimumSizeHint() const +{ + constPolish(); + + int w; + int h; + + h = 2 + QMAX(m_sizeSpin.height(), m_sizeSlider.height()); + + // if in extra row, then count it here + if(m_label && (m_alignment & (AlignBottom|AlignTop))) + h += 4 + m_sizeLabel.height(); + else + // label is in the same row as the other widgets + h = QMAX(h, m_sizeLabel.height() + 2); + + w = m_slider ? m_slider->sizeHint().width() + 8 : 0; + w += m_colw1 + m_colw2; + + if(m_alignment & (AlignTop|AlignBottom)) + w = QMAX(w, m_sizeLabel.width() + 4); + + return QSize(w, h); +} + +void KIntNumInput::doLayout() +{ + m_sizeSpin = m_spin->sizeHint(); + m_colw2 = m_sizeSpin.width(); + + if (m_label) + m_label->setBuddy(m_spin); +} + +void KIntNumInput::resizeEvent(QResizeEvent* e) +{ + int w = m_colw1; + int h = 0; + + if(m_label && (m_alignment & AlignTop)) { + m_label->setGeometry(0, 0, e->size().width(), m_sizeLabel.height()); + h += m_sizeLabel.height() + 4; + } + + if(m_label && (m_alignment & AlignVCenter)) + m_label->setGeometry(0, 0, w, m_sizeSpin.height()); + + m_spin->setGeometry(w, h, m_slider ? m_colw2 : QMAX(m_colw2, e->size().width() - w), m_sizeSpin.height()); + w += m_colw2 + 8; + + if(m_slider) + m_slider->setGeometry(w, h, e->size().width() - w, m_sizeSpin.height()); + + h += m_sizeSpin.height() + 2; + + if(m_label && (m_alignment & AlignBottom)) + m_label->setGeometry(0, h, m_sizeLabel.width(), m_sizeLabel.height()); +} + +KIntNumInput::~KIntNumInput() +{ + delete d; +} + +void KIntNumInput::setValue(int val) +{ + m_spin->setValue(val); + // slider value is changed by spinValueChanged +} + +void KIntNumInput::setRelativeValue( double r ) { + if ( !d->referencePoint ) return; + ++d->blockRelative; + setValue( int( d->referencePoint * r + 0.5 ) ); + --d->blockRelative; +} + +double KIntNumInput::relativeValue() const { + if ( !d->referencePoint ) return 0; + return double( value() ) / double ( d->referencePoint ); +} + +int KIntNumInput::value() const +{ + return m_spin->value(); +} + +void KIntNumInput::setSpecialValueText(const QString& text) +{ + m_spin->setSpecialValueText(text); + layout(true); +}; + +QString KIntNumInput::specialValueText() const +{ + return m_spin->specialValueText(); +} + +void KIntNumInput::setLabel(const QString & label, int a) +{ + KNumInput::setLabel(label, a); + + if(m_label) + m_label->setBuddy(m_spin); +} + +// ---------------------------------------------------------------------------- + +class KDoubleNumInput::KDoubleNumInputPrivate { +public: + KDoubleNumInputPrivate( double r ) + : spin( 0 ), + referencePoint( r ), + blockRelative ( 0 ) {} + KDoubleSpinBox * spin; + double referencePoint; + short blockRelative; +}; + +KDoubleNumInput::KDoubleNumInput(QWidget *parent, const char *name) + : KNumInput(parent, name) +{ + init(0.0, 0.0, 9999.0, 0.01, 2); +} + +KDoubleNumInput::KDoubleNumInput(double lower, double upper, double value, + double step, int precision, QWidget* parent, + const char *name) + : KNumInput(parent, name) +{ + init(value, lower, upper, step, precision); +} + +KDoubleNumInput::KDoubleNumInput(KNumInput *below, + double lower, double upper, double value, + double step, int precision, QWidget* parent, + const char *name) + : KNumInput(below, parent, name) +{ + init(value, lower, upper, step, precision); +} + +KDoubleNumInput::KDoubleNumInput(double value, QWidget *parent, const char *name) + : KNumInput(parent, name) +{ + init(value, kMin(0.0, value), kMax(0.0, value), 0.01, 2 ); +} + +KDoubleNumInput::KDoubleNumInput(KNumInput* below, double value, QWidget* parent, + const char* name) + : KNumInput(below, parent, name) +{ + init( value, kMin(0.0, value), kMax(0.0, value), 0.01, 2 ); +} + +KDoubleNumInput::~KDoubleNumInput() +{ + delete d; +} + +// ### remove when BIC changes are allowed again: + +bool KDoubleNumInput::eventFilter( QObject * o, QEvent * e ) { + return KNumInput::eventFilter( o, e ); +} + +void KDoubleNumInput::resetEditBox() { + +} + +// ### end stuff to remove when BIC changes are allowed again + + + +void KDoubleNumInput::init(double value, double lower, double upper, + double step, int precision ) +{ + // ### init no longer used members: + edit = 0; + m_range = true; + m_value = 0.0; + m_precision = 2; + // ### end + + d = new KDoubleNumInputPrivate( value ); + + d->spin = new KDoubleSpinBox( lower, upper, step, value, precision, + this, "KDoubleNumInput::d->spin" ); + setFocusProxy(d->spin); + connect( d->spin, SIGNAL(valueChanged(double)), + this, SIGNAL(valueChanged(double)) ); + connect( this, SIGNAL(valueChanged(double)), + this, SLOT(slotEmitRelativeValueChanged(double)) ); + + updateLegacyMembers(); + + layout(true); +} + +void KDoubleNumInput::updateLegacyMembers() { + // ### update legacy members that are either not private or for + // which an inlined getter exists: + m_lower = minValue(); + m_upper = maxValue(); + m_step = d->spin->lineStep(); + m_specialvalue = specialValueText(); +} + + +double KDoubleNumInput::mapSliderToSpin( int val ) const +{ + // map [slidemin,slidemax] to [spinmin,spinmax] + double spinmin = d->spin->minValue(); + double spinmax = d->spin->maxValue(); + double slidemin = m_slider->minValue(); // cast int to double to avoid + double slidemax = m_slider->maxValue(); // overflow in rel denominator + double rel = ( double(val) - slidemin ) / ( slidemax - slidemin ); + return spinmin + rel * ( spinmax - spinmin ); +} + +void KDoubleNumInput::sliderMoved(int val) +{ + d->spin->setValue( mapSliderToSpin( val ) ); +} + +void KDoubleNumInput::slotEmitRelativeValueChanged( double value ) +{ + if ( !d->referencePoint ) return; + emit relativeValueChanged( value / d->referencePoint ); +} + +QSize KDoubleNumInput::minimumSizeHint() const +{ + constPolish(); + + int w; + int h; + + h = 2 + QMAX(m_sizeEdit.height(), m_sizeSlider.height()); + + // if in extra row, then count it here + if(m_label && (m_alignment & (AlignBottom|AlignTop))) + h += 4 + m_sizeLabel.height(); + else + // label is in the same row as the other widgets + h = QMAX(h, m_sizeLabel.height() + 2); + + w = m_slider ? m_slider->sizeHint().width() + 8 : 0; + w += m_colw1 + m_colw2; + + if(m_alignment & (AlignTop|AlignBottom)) + w = QMAX(w, m_sizeLabel.width() + 4); + + return QSize(w, h); +} + +void KDoubleNumInput::resizeEvent(QResizeEvent* e) +{ + int w = m_colw1; + int h = 0; + + if(m_label && (m_alignment & AlignTop)) { + m_label->setGeometry(0, 0, e->size().width(), m_sizeLabel.height()); + h += m_sizeLabel.height() + 4; + } + + if(m_label && (m_alignment & AlignVCenter)) + m_label->setGeometry(0, 0, w, m_sizeEdit.height()); + + d->spin->setGeometry(w, h, m_slider ? m_colw2 + : e->size().width() - w, m_sizeEdit.height()); + w += m_colw2 + 8; + + if(m_slider) + m_slider->setGeometry(w, h, e->size().width() - w, m_sizeEdit.height()); + + h += m_sizeEdit.height() + 2; + + if(m_label && (m_alignment & AlignBottom)) + m_label->setGeometry(0, h, m_sizeLabel.width(), m_sizeLabel.height()); +} + +void KDoubleNumInput::doLayout() +{ + m_sizeEdit = d->spin->sizeHint(); + m_colw2 = m_sizeEdit.width(); +} + +void KDoubleNumInput::setValue(double val) +{ + d->spin->setValue( val ); +} + +void KDoubleNumInput::setRelativeValue( double r ) +{ + if ( !d->referencePoint ) return; + ++d->blockRelative; + setValue( r * d->referencePoint ); + --d->blockRelative; +} + +void KDoubleNumInput::setReferencePoint( double ref ) +{ + // clip to valid range: + ref = kMin( maxValue(), kMax( minValue(), ref ) ); + d->referencePoint = ref; +} + +void KDoubleNumInput::setRange(double lower, double upper, double step, + bool slider) +{ + if( m_slider ) { + // don't update the slider to avoid an endless recursion + QSpinBox * spin = d->spin; + disconnect(spin, SIGNAL(valueChanged(int)), + m_slider, SLOT(setValue(int)) ); + } + d->spin->setRange( lower, upper, step, d->spin->precision() ); + + if(slider) { + // upcast to base type to get the min/maxValue in int form: + QSpinBox * spin = d->spin; + int slmax = spin->maxValue(); + int slmin = spin->minValue(); + int slvalue = spin->value(); + int slstep = spin->lineStep(); + if (m_slider) { + m_slider->setRange(slmin, slmax); + m_slider->setLineStep(slstep); + m_slider->setValue(slvalue); + } else { + m_slider = new QSlider(slmin, slmax, slstep, slvalue, + QSlider::Horizontal, this); + m_slider->setTickmarks(QSlider::Below); + // feedback line: when one moves, the other moves, too: + connect(m_slider, SIGNAL(valueChanged(int)), + SLOT(sliderMoved(int)) ); + } + connect(spin, SIGNAL(valueChanged(int)), + m_slider, SLOT(setValue(int)) ); + // calculate ( slmax - slmin ) / 10 without overflowing ints: + int major = calcDiffByTen( slmax, slmin ); + if ( !major ) major = slstep; // ### needed? + m_slider->setTickInterval(major); + } else { + delete m_slider; + m_slider = 0; + } + + setReferencePoint( referencePoint() ); + + layout(true); + updateLegacyMembers(); +} + +void KDoubleNumInput::setMinValue(double min) +{ + setRange(min, maxValue(), d->spin->lineStep(), m_slider); +} + +double KDoubleNumInput::minValue() const +{ + return d->spin->minValue(); +} + +void KDoubleNumInput::setMaxValue(double max) +{ + setRange(minValue(), max, d->spin->lineStep(), m_slider); +} + +double KDoubleNumInput::maxValue() const +{ + return d->spin->maxValue(); +} + +double KDoubleNumInput::value() const +{ + return d->spin->value(); +} + +double KDoubleNumInput::relativeValue() const +{ + if ( !d->referencePoint ) return 0; + return value() / d->referencePoint; +} + +double KDoubleNumInput::referencePoint() const +{ + return d->referencePoint; +} + +QString KDoubleNumInput::suffix() const +{ + return d->spin->suffix(); +} + +QString KDoubleNumInput::prefix() const +{ + return d->spin->prefix(); +} + +void KDoubleNumInput::setSuffix(const QString &suffix) +{ + d->spin->setSuffix( suffix ); + + layout(true); +} + +void KDoubleNumInput::setPrefix(const QString &prefix) +{ + d->spin->setPrefix( prefix ); + + layout(true); +} + +void KDoubleNumInput::setPrecision(int precision) +{ + d->spin->setPrecision( precision ); + + layout(true); +} + +int KDoubleNumInput::precision() const +{ + return d->spin->precision(); +} + +void KDoubleNumInput::setSpecialValueText(const QString& text) +{ + d->spin->setSpecialValueText( text ); + + layout(true); + updateLegacyMembers(); +}; + +void KDoubleNumInput::setLabel(const QString & label, int a) +{ + KNumInput::setLabel(label, a); + + if(m_label) + m_label->setBuddy(d->spin); + +} + +// ---------------------------------------------------------------------------- + + +// We use a kind of fixed-point arithmetic to represent the range of +// doubles [mLower,mUpper] in steps of 10^(-mPrecision). Thus, the +// following relations hold: +// +// 1. factor = 10^mPrecision +// 2. basicStep = 1/factor = 10^(-mPrecision); +// 3. lowerInt = lower * factor; +// 4. upperInt = upper * factor; +// 5. lower = lowerInt * basicStep; +// 6. upper = upperInt * basicStep; +class KDoubleSpinBox::Private { +public: + Private( int precision=1 ) + : mPrecision( precision ), + mValidator( 0 ) + { + } + + int factor() const { + int f = 1; + for ( int i = 0 ; i < mPrecision ; ++i ) f *= 10; + return f; + } + + double basicStep() const { + return 1.0/double(factor()); + } + + int mapToInt( double value, bool * ok ) const { + assert( ok ); + const double f = factor(); + if ( value > double(INT_MAX) / f ) { +// kdWarning() << "KDoubleSpinBox: can't represent value " << value +// << "in terms of fixed-point numbers with precision " +// << mPrecision << endl; + *ok = false; + return INT_MAX; + } else if ( value < double(INT_MIN) / f ) { +// kdWarning() << "KDoubleSpinBox: can't represent value " << value +// << "in terms of fixed-point numbers with precision " +// << mPrecision << endl; + *ok = false; + return INT_MIN; + } else { + *ok = true; + return int( value * f + ( value < 0 ? -0.5 : 0.5 ) ); + } + } + + double mapToDouble( int value ) const { + return double(value) * basicStep(); + } + + int mPrecision; + KDoubleValidator * mValidator; +}; + +KDoubleSpinBox::KDoubleSpinBox( QWidget * parent, const char * name ) + : QSpinBox( parent, name ) +{ + editor()->setAlignment( Qt::AlignRight ); + d = new Private(); + updateValidator(); +} + +KDoubleSpinBox::KDoubleSpinBox( double lower, double upper, double step, + double value, int precision, + QWidget * parent, const char * name ) + : QSpinBox( parent, name ) +{ + editor()->setAlignment( Qt::AlignRight ); + d = new Private(); + setRange( lower, upper, step, precision ); + setValue( value ); + connect( this, SIGNAL(valueChanged(int)), SLOT(slotValueChanged(int)) ); +} + +KDoubleSpinBox::~KDoubleSpinBox() { + delete d; d = 0; +} + +bool KDoubleSpinBox::acceptLocalizedNumbers() const { + if ( !d->mValidator ) return true; // we'll set one that does; + // can't do it now, since we're const + return d->mValidator->acceptLocalizedNumbers(); +} + +void KDoubleSpinBox::setAcceptLocalizedNumbers( bool accept ) { + if ( !d->mValidator ) updateValidator(); + d->mValidator->setAcceptLocalizedNumbers( accept ); +} + +void KDoubleSpinBox::setRange( double lower, double upper, double step, + int precision ) { + lower = kMin(upper, lower); + upper = kMax(upper, lower); + setPrecision( precision, true ); // disable bounds checking, since + setMinValue( lower ); // it's done in set{Min,Max}Value + setMaxValue( upper ); // anyway and we want lower, upper + setLineStep( step ); // and step to have the right precision +} + +int KDoubleSpinBox::precision() const { + return d->mPrecision; +} + +void KDoubleSpinBox::setPrecision( int precision ) { + setPrecision( precision, false ); +} + +void KDoubleSpinBox::setPrecision( int precision, bool force ) { + if ( precision < 1 ) return; + if ( !force ) { + int maxPrec = maxPrecision(); + if ( precision > maxPrec ) + precision = maxPrec; + } + d->mPrecision = precision; + updateValidator(); +} + +int KDoubleSpinBox::maxPrecision() const { + // INT_MAX must be > maxAbsValue * 10^precision + // ==> 10^precision < INT_MAX / maxAbsValue + // ==> precision < log10 ( INT_MAX / maxAbsValue ) + // ==> maxPrecision = floor( log10 ( INT_MAX / maxAbsValue ) ); + double maxAbsValue = kMax( fabs(minValue()), fabs(maxValue()) ); + if ( maxAbsValue == 0 ) return 6; // return arbitrary value to avoid dbz... + + return int( floor( log10( double(INT_MAX) / maxAbsValue ) ) ); +} + +double KDoubleSpinBox::value() const { + return d->mapToDouble( base::value() ); +} + +void KDoubleSpinBox::setValue( double value ) { + if ( value == this->value() ) return; + if ( value < minValue() ) + base::setValue( base::minValue() ); + else if ( value > maxValue() ) + base::setValue( base::maxValue() ); + else { + bool ok = false; + base::setValue( d->mapToInt( value, &ok ) ); + assert( ok ); + } +} + +double KDoubleSpinBox::minValue() const { + return d->mapToDouble( base::minValue() ); +} + +void KDoubleSpinBox::setMinValue( double value ) { + bool ok = false; + int min = d->mapToInt( value, &ok ); + if ( !ok ) return; + base::setMinValue( min ); + updateValidator(); +} + + +double KDoubleSpinBox::maxValue() const { + return d->mapToDouble( base::maxValue() ); +} + +void KDoubleSpinBox::setMaxValue( double value ) { + bool ok = false; + int max = d->mapToInt( value, &ok ); + if ( !ok ) return; + base::setMaxValue( max ); + updateValidator(); +} + +double KDoubleSpinBox::lineStep() const { + return d->mapToDouble( base::lineStep() ); +} + +void KDoubleSpinBox::setLineStep( double step ) { + bool ok = false; + if ( step > maxValue() - minValue() ) + base::setLineStep( 1 ); + else + base::setLineStep( kMax( d->mapToInt( step, &ok ), 1 ) ); +} + +QString KDoubleSpinBox::mapValueToText( int value ) { +// if ( acceptLocalizedNumbers() ) +// return KGlobal::locale() +// ->formatNumber( d->mapToDouble( value ), d->mPrecision ); +// else + return QString().setNum( d->mapToDouble( value ), 'f', d->mPrecision ); +} + +int KDoubleSpinBox::mapTextToValue( bool * ok ) { + double value; +// if ( acceptLocalizedNumbers() ) +// value = KGlobal::locale()->readNumber( cleanText(), ok ); +// else + value = cleanText().toDouble( ok ); + if ( !*ok ) return 0; + if ( value > maxValue() ) + value = maxValue(); + else if ( value < minValue() ) + value = minValue(); + return d->mapToInt( value, ok ); +} + +void KDoubleSpinBox::setValidator( const QValidator * ) { + // silently discard the new validator. We don't want another one ;-) +} + +void KDoubleSpinBox::slotValueChanged( int value ) { + emit valueChanged( d->mapToDouble( value ) ); +} + +void KDoubleSpinBox::updateValidator() { + if ( !d->mValidator ) { + d->mValidator = new KDoubleValidator( minValue(), maxValue(), precision(), + this, "d->mValidator" ); + base::setValidator( d->mValidator ); + } else + d->mValidator->setRange( minValue(), maxValue(), precision() ); +} + +void KNumInput::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +void KIntNumInput::virtual_hook( int id, void* data ) +{ KNumInput::virtual_hook( id, data ); } + +void KDoubleNumInput::virtual_hook( int id, void* data ) +{ KNumInput::virtual_hook( id, data ); } + +void KIntSpinBox::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +void KDoubleSpinBox::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +//#include "knuminput.moc" diff --git a/noncore/settings/networksettings/ppp/knuminput.h b/noncore/settings/networksettings/ppp/knuminput.h new file mode 100644 index 0000000..67f3b44 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/knuminput.h @@ -0,0 +1,947 @@ +/* + * knuminput.h + * + * Copyright (c) 1997 Patrick Dowler <dowler@morgul.fsh.uvic.ca> + * Copyright (c) 2000 Dirk A. Mueller <mueller@kde.org> + * Copyright (c) 2002 Marc Mutz <mutz@kde.org> + * + * Requires the Qt widget libraries, available at no cost at + * http://www.troll.no/ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef K_NUMINPUT_H +#define K_NUMINPUT_H + +#include <qwidget.h> +#include <qspinbox.h> + +class QLabel; +class QSlider; +class QLineEdit; +class QLayout; +class QValidator; + +class KIntSpinBox; + +/* ------------------------------------------------------------------------ */ + +/** + * You need to inherit from this class if you want to implement K*NumInput + * for a different variable type + * + */ +class KNumInput : public QWidget +{ + Q_OBJECT + Q_PROPERTY( QString label READ label WRITE setLabel ) +public: + /** + * Default constructor + * + */ + KNumInput(QWidget* parent=0, const char* name=0); + + /** + * @param below A pointer to another KNumInput. + * + */ + KNumInput(KNumInput* below, QWidget* parent=0, const char* name=0); + ~KNumInput(); + + /** + * Sets the text and alignment of the main description label. + * + * @param label The text of the label. + * Use QString::null to remove an existing one. + * + * @param a one of @p AlignLeft, @p AlignHCenter, YAlignRight and + * @p AlignTop, @p AlignVCenter, @p AlignBottom. + * default is @p AlignLeft | @p AlignTop. + * + * The vertical alignment flags have special meaning with this + * widget: + * + * @li @p AlignTop The label is placed above the edit/slider + * @li @p AlignVCenter The label is placed left beside the edit + * @li @p AlignBottom The label is placed below the edit/slider + * + */ + virtual void setLabel(const QString & label, int a = AlignLeft | AlignTop); + + /** + * @return the text of the label. + */ + QString label() const; + + /** + * @return if the num input has a slider. + * @since 3.1 + */ + bool showSlider() const { return m_slider; } + + /** + * Sets the spacing of tickmarks for the slider. + * + * @param minor Minor tickmark separation. + * @param major Major tickmark separation. + */ + void setSteps(int minor, int major); + + /** + * Specifies that this widget may stretch horizontally, but is + * fixed vertically (like @ref QSpinBox itself). + */ + QSizePolicy sizePolicy() const; + + /** + * Returns a size which fits the contents of the control. + * + * @return the preferred size necessary to show the control + */ + virtual QSize sizeHint() const; + +protected: + /** + * Call this function whenever you change something in the geometry + * of your KNumInput child. + * + */ + void layout(bool deep); + + /** + * You need to overwrite this method and implement your layout + * calculations there. + * + * See KIntNumInput::doLayout and KDoubleNumInput::doLayout implementation + * for details. + * + */ + virtual void doLayout() = 0; + + KNumInput* m_prev, *m_next; + int m_colw1, m_colw2; + + QLabel* m_label; + QSlider* m_slider; + QSize m_sizeSlider, m_sizeLabel; + + int m_alignment; + +private: + void init(); + +protected: + virtual void virtual_hook( int id, void* data ); +private: + class KNumInputPrivate; + KNumInputPrivate *d; +}; + +/* ------------------------------------------------------------------------ */ + +/** + * KIntNumInput combines a @ref QSpinBox and optionally a @ref QSlider + * with a label to make an easy to use control for setting some integer + * parameter. This is especially nice for configuration dialogs, + * which can have many such combinated controls. + * + * The slider is created only when the user specifies a range + * for the control using the setRange function with the slider + * parameter set to "true". + * + * A special feature of KIntNumInput, designed specifically for + * the situation when there are several KIntNumInputs in a column, + * is that you can specify what portion of the control is taken by the + * QSpinBox (the remaining portion is used by the slider). This makes + * it very simple to have all the sliders in a column be the same size. + * + * It uses @ref KIntValidator validator class. KIntNumInput enforces the + * value to be in the given range, and can display it in any base + * between 2 and 36. + * + * @short An input widget for integer numbers, consisting of a spinbox and a slider. + * @version $Id$ + */ + +class KIntNumInput : public KNumInput +{ + Q_OBJECT + Q_PROPERTY( int value READ value WRITE setValue ) + Q_PROPERTY( int minValue READ minValue WRITE setMinValue ) + Q_PROPERTY( int maxValue READ maxValue WRITE setMaxValue ) + Q_PROPERTY( int referencePoint READ referencePoint WRITE setReferencePoint ) + Q_PROPERTY( QString suffix READ suffix WRITE setSuffix ) + Q_PROPERTY( QString prefix READ prefix WRITE setPrefix ) + Q_PROPERTY( QString specialValueText READ specialValueText WRITE setSpecialValueText ) + +public: + /** + * Constructs an input control for integer values + * with base 10 and initial value 0. + */ + KIntNumInput(QWidget *parent=0, const char *name=0); + /** + * Constructor + * It constructs a QSpinBox that allows the input of integer numbers + * in the range of -INT_MAX to +INT_MAX. To set a descriptive label, + * use setLabel(). To enforce the value being in a range and optionally to + * attach a slider to it, use setRange(). + * + * @param value initial value for the control + * @param base numeric base used for display + * @param parent parent QWidget + * @param name internal name for this widget + */ + KIntNumInput(int value, QWidget* parent=0, int base = 10, const char *name=0); + + /** + * Constructor + * + * the difference to the one above is the "below" parameter. It tells + * this instance that it is visually put below some other KNumInput widget. + * Note that these two KNumInput's need not to have the same parent widget + * or be in the same layout group. + * The effect is that it'll adjust it's layout in correspondence + * with the layout of the other KNumInput's (you can build an arbitary long + * chain). + * + * @param below append KIntNumInput to the KNumInput chain + * @param value initial value for the control + * @param base numeric base used for display + * @param parent parent QWidget + * @param name internal name for this widget + */ + KIntNumInput(KNumInput* below, int value, QWidget* parent=0, int base = 10, const char *name=0); + + /** + * Destructor + * + * + */ + virtual ~KIntNumInput(); + + /** + * @return the current value. + */ + int value() const; + + /** + * @return the curent value in units of the @ref referencePoint. + * @since 3.1 + */ + double relativeValue() const; + + /** + * @return the current reference point + * @since 3.1 + */ + int referencePoint() const; + + /** + * @return the suffix displayed behind the value. + * @see #setSuffix() + */ + QString suffix() const; + /** + * @return the prefix displayed in front of the value. + * @see #setPrefix() + */ + QString prefix() const; + /** + * @return the string displayed for a special value. + * @see #setSpecialValueText() + */ + QString specialValueText() const; + + /** + * @param min minimum value + * @param max maximum value + * @param step step size for the QSlider + */ + void setRange(int min, int max, int step=1, bool slider=true); + /** + * Sets the minimum value. + */ + void setMinValue(int min); + /** + * @return the minimum value. + */ + int minValue() const; + /** + * Sets the maximum value. + */ + void setMaxValue(int max); + /** + * @return the maximum value. + */ + int maxValue() const; + + /** + * Sets the special value text. If set, the SpinBox will display + * this text instead of the numeric value whenever the current + * value is equal to minVal(). Typically this is used for indicating + * that the choice has a special (default) meaning. + */ + void setSpecialValueText(const QString& text); + + /** + * @reimplemented + */ + virtual void setLabel(const QString & label, int a = AlignLeft | AlignTop); + + /** + * This method returns the minimum size necessary to display the + * control. The minimum size is enough to show all the labels + * in the current font (font change may invalidate the return value). + * + * @return the minimum size necessary to show the control + */ + virtual QSize minimumSizeHint() const; + +public slots: + /** + * Sets the value of the control. + */ + void setValue(int); + + /** + * Sets the value in units of the @ref referencePoint + * @since 3.1 + */ + void setRelativeValue(double); + + /** + * Sets the reference point for @ref relativeValue. + * @since 3.1 + */ + void setReferencePoint(int); + + /** + * Sets the suffix to @p suffix. + * Use QString::null to disable this feature. + * Formatting has to be provided (e.g. a space separator between the + * prepended @p value and the suffix's text has to be provided + * as the first character in the suffix). + * + * @see QSpinBox::setSuffix(), #setPrefix() + */ + void setSuffix(const QString &suffix); + + /** + * Sets the prefix to @p prefix. + * Use QString::null to disable this feature. + * Formatting has to be provided (see above). + * + * @see QSpinBox::setPrefix(), #setSuffix() + */ + void setPrefix(const QString &prefix); + + /** + * sets focus to the edit widget and marks all text in if mark == true + * + */ + void setEditFocus( bool mark = true ); + +signals: + /** + * Emitted every time the value changes (by calling @ref setValue() or + * by user interaction). + */ + void valueChanged(int); + + /** + * Emitted whenever @ref #valueChanged is. Contains the change + * relative to the @ref referencePoint. + * @since 3.1 + */ + void relativeValueChanged(double); + +private slots: + void spinValueChanged(int); + void slotEmitRelativeValueChanged(int); + +protected: + /** + * @reimplemented + */ + virtual void doLayout(); + /** + * @reimplemented + */ + void resizeEvent ( QResizeEvent * ); + + KIntSpinBox* m_spin; + QSize m_sizeSpin; + +private: + void init(int value, int _base); + +protected: + virtual void virtual_hook( int id, void* data ); +private: + class KIntNumInputPrivate; + KIntNumInputPrivate *d; +}; + + +/* ------------------------------------------------------------------------ */ + +class KDoubleLine; + +/** + * KDoubleNumInput combines a @ref QSpinBox and optionally a @ref QSlider + * with a label to make an easy to use control for setting some float + * parameter. This is especially nice for configuration dialogs, + * which can have many such combinated controls. + * + * The slider is created only when the user specifies a range + * for the control using the setRange function with the slider + * parameter set to "true". + * + * A special feature of KDoubleNumInput, designed specifically for + * the situation when there are several instances in a column, + * is that you can specify what portion of the control is taken by the + * QSpinBox (the remaining portion is used by the slider). This makes + * it very simple to have all the sliders in a column be the same size. + * + * It uses the @ref KDoubleValidator validator class. KDoubleNumInput + * enforces the value to be in the given range, but see the class + * documentation of @ref KDoubleSpinBox for the tricky + * interrelationship of precision and values. All of what is said + * there applies here, too. + * + * @see KIntNumInput, KDoubleSpinBox + * @short An input control for real numbers, consisting of a spinbox and a slider. + */ + +class KDoubleNumInput : public KNumInput +{ + Q_OBJECT + Q_PROPERTY( double value READ value WRITE setValue ) + Q_PROPERTY( double minValue READ minValue WRITE setMinValue ) + Q_PROPERTY( double maxValue READ maxValue WRITE setMaxValue ) + Q_PROPERTY( QString suffix READ suffix WRITE setSuffix ) + Q_PROPERTY( QString prefix READ prefix WRITE setPrefix ) + Q_PROPERTY( QString specialValueText READ specialValueText WRITE setSpecialValueText ) + +public: + /** + * Constructs an input control for double values + * with initial value 0.00. + */ + KDoubleNumInput(QWidget *parent=0, const char *name=0); + + /** + * @deprecated (value is rounded to a multiple of 1/100) + * Constructor + * + * @param value initial value for the control + * @param parent parent QWidget + * @param name internal name for this widget + */ + KDoubleNumInput(double value, QWidget *parent=0, const char *name=0); + + /** + * Constructor + * + * @param lower lower boundary value + * @param upper upper boundary value + * @param value initial value for the control + * @param step step size to use for up/down arrow clicks + * @param precision number of digits after the decimal point + * @param parent parent QWidget + * @param name internal name for this widget + * @since 3.1 + */ + KDoubleNumInput(double lower, double upper, double value, double step=0.01, + int precision=2, QWidget *parent=0, const char *name=0); + + /** + * destructor + */ + virtual ~KDoubleNumInput(); + + /** + * @deprecated (rounds @p value to a mulitple of 1/100) + * Constructor + * + * puts it below other KNumInput + * + * @param below + * @param value initial value for the control + * @param parent parent QWidget + * @param name internal name for this widget + **/ + KDoubleNumInput(KNumInput* below, double value, QWidget* parent=0, const char* name=0); + + /** + * Constructor + * + * puts it below other KNumInput + * + * @param lower lower boundary value + * @param upper upper boundary value + * @param value initial value for the control + * @param step step size to use for up/down arrow clicks + * @param precision number of digits after the decimal point + * @param parent parent QWidget + * @param name internal name for this widget + * @since 3.1 + */ + KDoubleNumInput(KNumInput* below, + double lower, double upper, double value, double step=0.02, + int precision=2, QWidget *parent=0, const char *name=0); + + /** + * @return the current value. + */ + double value() const; + + /** + * @return the suffix. + * @see #setSuffix() + */ + QString suffix() const; + + /** + * @return the prefix. + * @see #setPrefix() + */ + QString prefix() const; + + /** + * @return the precision. + * @see #setPrecision() + */ + int precision() const; + + /** + * @return the string displayed for a special value. + * @see #setSpecialValueText() + */ + QString specialValueText() const { return m_specialvalue; } + + /** + * @param min minimum value + * @param max maximum value + * @param step step size for the QSlider + */ + void setRange(double min, double max, double step=1, bool slider=true); + /** + * Sets the minimum value. + */ + void setMinValue(double min); + /** + * @return the minimum value. + */ + double minValue() const; + /** + * Sets the maximum value. + */ + void setMaxValue(double max); + /** + * @return the maximum value. + */ + double maxValue() const; + + /** + * Specifies the number of digits to use. + */ + void setPrecision(int precision); + + /** + * @return the reference point for @ref #relativeValue calculation + * @since 3.1 + */ + double referencePoint() const; + + /** + * @return the current value in units of @ref #referencePoint. + * @since 3.1 + */ + double relativeValue() const; + + /** + * Sets the special value text. If set, the spin box will display + * this text instead of the numeric value whenever the current + * value is equal to @ref #minVal(). Typically this is used for indicating + * that the choice has a special (default) meaning. + */ + void setSpecialValueText(const QString& text); + + /** + * @reimplemented + */ + virtual void setLabel(const QString & label, int a = AlignLeft | AlignTop); + /** + * @reimplemented + */ + virtual QSize minimumSizeHint() const; + /** + * @reimplemented + */ + virtual bool eventFilter(QObject*, QEvent*); + +public slots: + /** + * Sets the value of the control. + */ + void setValue(double); + + /** + * Sets the value in units of @ref #referencePoint. + * @since 3.1 + */ + void setRelativeValue(double); + + /** + * Sets the reference Point to @p ref. It @p ref == 0, emitting of + * @ref #relativeValueChanged is blocked and @ref #relativeValue + * just returns 0. + * @since 3.1 + */ + void setReferencePoint(double ref); + + /** + * Sets the suffix to be displayed to @p suffix. Use QString::null to disable + * this feature. Note that the suffix is attached to the value without any + * spacing. So if you prefer to display a space separator, set suffix + * to something like " cm". + * @see #setSuffix() + */ + void setSuffix(const QString &suffix); + + /** + * Sets the prefix to be displayed to @p prefix. Use QString::null to disable + * this feature. Note that the prefix is attached to the value without any + * spacing. + * @see #setPrefix() + */ + void setPrefix(const QString &prefix); + +signals: + /** + * Emitted every time the value changes (by calling @ref setValue() or + * by user interaction). + */ + void valueChanged(double); + /** + * This is an overloaded member function, provided for + * convenience. It essentially behaves like the above function. + * + * Contains the value in units of @ref #referencePoint. + * @since 3.1 + */ + void relativeValueChanged(double); + +private slots: + void sliderMoved(int); + void slotEmitRelativeValueChanged(double); + +protected: + + /** + * @reimplemented + */ + virtual void doLayout(); + /** + * @reimplemented + */ + void resizeEvent ( QResizeEvent * ); + virtual void resetEditBox(); + + // ### no longer used, remove when BIC allowed + KDoubleLine* edit; + + bool m_range; + double m_lower, m_upper, m_step; + // ### end no longer used + + QSize m_sizeEdit; + + friend class KDoubleLine; +private: + void init(double value, double lower, double upper, + double step, int precision); + double mapSliderToSpin(int) const; + void updateLegacyMembers(); + // ### no longer used, remove when BIC allowed: + QString m_specialvalue, m_prefix, m_suffix; + double m_value; + short m_precision; + // ### end remove when BIC allowed + +protected: + virtual void virtual_hook( int id, void* data ); +private: + class KDoubleNumInputPrivate; + KDoubleNumInputPrivate *d; +}; + + +/* ------------------------------------------------------------------------ */ + +/** + * A @ref QSpinBox with support for arbitrary base numbers + * (e.g. hexadecimal). + * + * The class provides an easy interface to use other + * numeric systems then the decimal. + * + * @short A @ref QSpinBox with support for arbitrary base numbers. + */ +class KIntSpinBox : public QSpinBox +{ + Q_OBJECT + Q_PROPERTY( int base READ base WRITE setBase ) + +public: + + /** + * Constructor. + * + * Constructs a widget with an integer inputline with a little scrollbar + * and a slider, with minimal value 0, maximal value 99, step 1, base 10 + * and initial value 0. + */ + KIntSpinBox( QWidget *parent=0, const char *name=0); + + /** + * Constructor. + * + * Constructs a widget with an integer inputline with a little scrollbar + * and a slider. + * + * @param lower The lowest valid value. + * @param upper The greatest valid value. + * @param step The step size of the scrollbar. + * @param value The actual value. + * @param base The base of the used number system. + * @param parent The parent of the widget. + * @param name The Name of the widget. + */ + KIntSpinBox(int lower, int upper, int step, int value, int base = 10, + QWidget* parent = 0, const char* name = 0); + + /** + * Destructor. + */ + virtual ~KIntSpinBox(); + + /** + * Sets the base in which the numbers in the spin box are represented. + */ + void setBase(int base); + /** + * @return the base in which numbers in the spin box are represented. + */ + int base() const; + /** + * sets focus and optionally marks all text + * + */ + void setEditFocus(bool mark); + +protected: + + /** + * Overloaded the method in QSpinBox + * to make use of the base given in the constructor. + */ + virtual QString mapValueToText(int); + + /** + * Overloaded the method in QSpinBox + * to make use of the base given in the constructor. + */ + virtual int mapTextToValue(bool*); + +private: + int val_base; +protected: + virtual void virtual_hook( int id, void* data ); +private: + class KIntSpinBoxPrivate; + KIntSpinBoxPrivate *d; +}; + + +/* --------------------------------------------------------------------------- */ + +/** + This class provides a spin box for fractional numbers. + + @sect Parameters + + There are a number of interdependent parameters whose relation to + each other you need to understand in order to make successful use + of the spin box. + + @li precision: The number of decimals after the decimal point. + @li maxValue/minValue: upper and lower bound of the valid range + @li lineStep: the size of the step that is taken when the user hits + the up or down buttons + + Since we work with fixed-point numbers internally, the maximum + precision is a function of the valid range and vice versa. More + precisely, the following relations hold: + <pre> + max( abs(minValue()), abs(maxValue() ) <= INT_MAX/10^precision + maxPrecision = floor( log10( INT_MAX/max(abs(minValue()),abs(maxValue())) ) ) + </pre> + + Since the value, bounds and step are rounded to the current + precision, you may experience that the order of setting above + parameters matters. E.g. the following are @em not equivalent (try + it!): + + <pre> + // sets precision, + // then min/max value (rounded to precison and clipped to obtainable range if needed) + // then value and lineStep + KDoubleSpinBox * spin = new KDoubleSpinBox( 0, 9.999, 0.001, 4.321, 3, this ); + + // sets minValue to 0; maxValue to 10.00(!); value to 4.32(!) and only then + // increases the precision - too late, since e.g. value has already been rounded... + KDpubleSpinBox * spin = new KDoubleSpinBox( this ); + spin->setMinValue( 0 ); + spin->setMaxValue( 9.999 ); + spin->setValue( 4.321 ); + spin->setPrecision( 3 ); + </pre> + + @short A spin box for fractional numbers. + @author Marc Mutz <mutz@kde.org> + @version $Id$ + @since 3.1 +**/ + +class KDoubleSpinBox : public QSpinBox { + Q_OBJECT + Q_PROPERTY( bool acceptLocalizedNumbers READ acceptLocalizedNumbers WRITE setAcceptLocalizedNumbers ) + Q_OVERRIDE( double maxValue READ maxValue WRITE setMaxValue ) + Q_OVERRIDE( double minValue READ minValue WRITE setMinValue ) + Q_OVERRIDE( double lineStep READ lineStep WRITE setLineStep ) + Q_OVERRIDE( double value READ value WRITE setValue ) + Q_PROPERTY( int precision READ precision WRITE setPrecision ) + +public: + /** Constructs a @ref KDoubleSpinBox with parent @p parent and + default values for range and value (whatever @ref QRangeControl + uses) and precision (2). */ + KDoubleSpinBox( QWidget * parent=0, const char * name=0 ); + /** Constructs a @ref KDoubleSpinBox with parent @p parent, range + [@p lower,@p upper], @ref lineStep @p step, @ref precision @p + precision and initial value @p value. */ + KDoubleSpinBox( double lower, double upper, double step, double value, + int precision=2, QWidget * parent=0, const char * name=0 ); + + virtual ~KDoubleSpinBox(); + + /** @return whether the spinbox uses localized numbers */ + bool acceptLocalizedNumbers() const; + /** Sets whether to use and accept localized numbers as returned by + @ref KLocale::formatNumber() */ + virtual void setAcceptLocalizedNumbers( bool accept ); + + /** Sets a new range for the spin box values. Note that @p lower, @p + upper and @p step are rounded to @p precision decimal points + first. */ + void setRange( double lower, double upper, double step=0.01, int precision=2 ); + + /** @return the current number of decimal points displayed. */ + int precision() const; + /** Equivalent to @ref setPrecsion( @p precison, @p false ); Needed + since Qt's moc doesn't ignore trailing parameters with default + args when searching for a property setter method. */ + void setPrecision( int precision ); + /** Sets the number of decimal points to use. Note that there is a + tradeoff between the precision used and the available range of + values. See the class docs for more. + @param precision the new number of decimal points to use + + @param force disables checking of bound violations that can + arise if you increase the precision so much that the + minimum and maximum values can't be represented + anymore. Disabling is useful if you don't want to keep + the current min and max values anyway. This is what + e.g. @ref setRange() does. + **/ + virtual void setPrecision( int precision, bool force ); + + /** @return the current value */ + double value() const; + /** @return the current lower bound */ + double minValue() const; + /** Sets the lower bound of the range to @p value, subject to the + contraints that @p value is first rounded to the current + precision and then clipped to the maximum representable + interval. + @see maxValue, minValue, setMaxValue, setRange + */ + void setMinValue( double value ); + /** @return the current upper bound */ + double maxValue() const; + /** Sets the upper bound of the range to @p value, subject to the + contraints that @p value is first rounded to the current + precision and then clipped to the maximum representable + interval. + @see minValue, maxValue, setMinValue, setRange + */ + void setMaxValue( double value ); + + /** @return the current step size */ + double lineStep() const; + /** Sets the step size for clicking the up/down buttons to @p step, + subject to the constraints that @p step is first rounded to the + current precision and then clipped to the meaningful interval + [1, @p maxValue - @p minValue]. */ + void setLineStep( double step ); + + /** Overridden to ignore any setValidator() calls. */ + void setValidator( const QValidator * ); + +signals: + /** Emitted whenever @ref QSpinBox::valueChanged( int ) is emitted. */ + void valueChanged( double value ); + +public slots: + /** Sets the current value to @p value, cubject to the constraints + that @p value is frist rounded to the current precision and then + clipped to the interval [@p minvalue(),@p maxValue()]. */ + virtual void setValue( double value ); + +protected: + virtual QString mapValueToText(int); + virtual int mapTextToValue(bool*); + +protected slots: + void slotValueChanged( int value ); + +protected: + virtual void virtual_hook( int id, void* data ); +private: + typedef QSpinBox base; + void updateValidator(); + int maxPrecision() const; + + class Private; + Private * d; +}; + +#endif // K_NUMINPUT_H diff --git a/noncore/settings/networksettings/ppp/knumvalidator.cpp b/noncore/settings/networksettings/ppp/knumvalidator.cpp new file mode 100644 index 0000000..44f7a60 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/knumvalidator.cpp @@ -0,0 +1,376 @@ +/********************************************************************** +** +** $Id$ +** +** KIntValidator, KFloatValidator: +** Copyright (C) 1999 Glen Parker <glenebob@nwlink.com> +** KDoubleValidator: +** Copyright (c) 2002 Marc Mutz <mutz@kde.org> +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Library General Public +** License as published by the Free Software Foundation; either +** version 2 of the License, or (at your option) any later version. +** +** This library 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 +** Library General Public License for more details. +** +** You should have received a copy of the GNU Library General Public +** License along with this library; if not, write to the Free +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +*****************************************************************************/ + +#include <qwidget.h> +#include <qstring.h> + +#include "knumvalidator.h" +//#include <klocale.h> +#define i18n QObject::tr +//#include <kglobal.h> +//#include <kdebug.h> + +/////////////////////////////////////////////////////////////// +// Implementation of KIntValidator +// + +KIntValidator::KIntValidator ( QWidget * parent, int base, const char * name ) + : QValidator(parent, name) +{ + _base = base; + if (_base < 2) _base = 2; + if (_base > 36) _base = 36; + + _min = _max = 0; +} + +KIntValidator::KIntValidator ( int bottom, int top, QWidget * parent, int base, const char * name ) + : QValidator(parent, name) +{ + _base = base; + if (_base > 36) _base = 36; + + _min = bottom; + _max = top; +} + +KIntValidator::~KIntValidator () +{} + +QValidator::State KIntValidator::validate ( QString &str, int & ) const +{ + bool ok; + int val = 0; + QString newStr; + + newStr = str.stripWhiteSpace(); + if (_base > 10) + newStr = newStr.upper(); + + if (newStr == QString::fromLatin1("-")) // a special case + if ((_min || _max) && _min >= 0) + ok = false; + else + return QValidator::Acceptable; + else if (newStr.length()) + val = newStr.toInt(&ok, _base); + else { + val = 0; + ok = true; + } + + if (! ok) + return QValidator::Invalid; + + if ((! _min && ! _max) || (val >= _min && val <= _max)) + return QValidator::Acceptable; + + if (_max && _min >= 0 && val < 0) + return QValidator::Invalid; + + return QValidator::Valid; +} + +void KIntValidator::fixup ( QString &str ) const +{ + int dummy; + int val; + QValidator::State state; + + state = validate(str, dummy); + + if (state == QValidator::Invalid || state == QValidator::Acceptable) + return; + + if (! _min && ! _max) + return; + + val = str.toInt(0, _base); + + if (val < _min) val = _min; + if (val > _max) val = _max; + + str.setNum(val, _base); +} + +void KIntValidator::setRange ( int bottom, int top ) +{ + _min = bottom; + _max = top; + + if (_max < _min) + _max = _min; +} + +void KIntValidator::setBase ( int base ) +{ + _base = base; + if (_base < 2) _base = 2; +} + +int KIntValidator::bottom () const +{ + return _min; +} + +int KIntValidator::top () const +{ + return _max; +} + +int KIntValidator::base () const +{ + return _base; +} + + +/////////////////////////////////////////////////////////////// +// Implementation of KFloatValidator +// + +class KFloatValidatorPrivate +{ +public: + KFloatValidatorPrivate() + { + } + ~KFloatValidatorPrivate() + { + } + bool acceptLocalizedNumbers; +}; + + +KFloatValidator::KFloatValidator ( QWidget * parent, const char * name ) + : QValidator(parent, name) +{ + d = new KFloatValidatorPrivate; + d->acceptLocalizedNumbers=false; + _min = _max = 0; +} + +KFloatValidator::KFloatValidator ( double bottom, double top, QWidget * parent, const char * name ) + : QValidator(parent, name) +{ + d = new KFloatValidatorPrivate; + d->acceptLocalizedNumbers=false; + _min = bottom; + _max = top; +} + +KFloatValidator::KFloatValidator ( double bottom, double top, bool localeAware, QWidget * parent, const char * name ) + : QValidator(parent, name) +{ + d = new KFloatValidatorPrivate; + d->acceptLocalizedNumbers = localeAware; + _min = bottom; + _max = top; +} + +KFloatValidator::~KFloatValidator () +{ + delete d; +} + +void KFloatValidator::setAcceptLocalizedNumbers(bool _b) +{ + d->acceptLocalizedNumbers=_b; +} + +bool KFloatValidator::acceptLocalizedNumbers() const +{ + return d->acceptLocalizedNumbers; +} + +//#include <kdebug.h> +QValidator::State KFloatValidator::validate ( QString &str, int & ) const +{ + bool ok; + double val = 0; + QString newStr; + newStr = str.stripWhiteSpace(); + + if (newStr == QString::fromLatin1("-")) // a special case + if ((_min || _max) && _min >= 0) + ok = false; + else + return QValidator::Acceptable; + else if (newStr == QString::fromLatin1(".") ) // FIXME :|| (d->acceptLocalizedNumbers && newStr==KGlobal::locale()->decimalSymbol())) // another special case + return QValidator::Acceptable; + else if (newStr.length()) + { + val = newStr.toDouble(&ok); +// if(!ok && d->acceptLocalizedNumbers) +// val= KGlobal::locale()->readNumber(newStr,&ok); + } + else { + val = 0; + ok = true; + } + + if (! ok) + return QValidator::Invalid; + + if (( !_min && !_max) || (val >= _min && val <= _max)) + return QValidator::Acceptable; + + if (_max && _min >= 0 && val < 0) + return QValidator::Invalid; + + if ( (_min || _max) && (val < _min || val > _max)) + return QValidator::Invalid; + + return QValidator::Valid; +} + +void KFloatValidator::fixup ( QString &str ) const +{ + int dummy; + double val; + QValidator::State state; + + state = validate(str, dummy); + + if (state == QValidator::Invalid || state == QValidator::Acceptable) + return; + + if (! _min && ! _max) + return; + + val = str.toDouble(); + + if (val < _min) val = _min; + if (val > _max) val = _max; + + str.setNum(val); +} + +void KFloatValidator::setRange ( double bottom, double top ) +{ + _min = bottom; + _max = top; + + if (_max < _min) + _max = _min; +} + +double KFloatValidator::bottom () const +{ + return _min; +} + +double KFloatValidator::top () const +{ + return _max; +} + + + + +/////////////////////////////////////////////////////////////// +// Implementation of KDoubleValidator +// + +class KDoubleValidator::Private { +public: + Private( bool accept=false ) : acceptLocalizedNumbers( accept ) {} + + bool acceptLocalizedNumbers; +}; + +//KDoubleValidator::KDoubleValidator( QObject * parent, const char * name ) +KDoubleValidator::KDoubleValidator( QWidget * parent, const char * name ) + : QDoubleValidator( parent, name ), d( 0 ) +{ + d = new Private(); +} + +KDoubleValidator::KDoubleValidator( double bottom, double top, int decimals, +// QObject * parent, const char * name ) + QWidget * parent, const char * name ) + : QDoubleValidator( bottom, top, decimals, parent, name ), d( 0 ) +{ + d = new Private(); +} + +KDoubleValidator::~KDoubleValidator() +{ + delete d; +} + +bool KDoubleValidator::acceptLocalizedNumbers() const { + return d->acceptLocalizedNumbers; +} + +void KDoubleValidator::setAcceptLocalizedNumbers( bool accept ) { + d->acceptLocalizedNumbers = accept; +} + +QValidator::State KDoubleValidator::validate( QString & input, int & p ) const { + QString s = input; + if ( acceptLocalizedNumbers() ) { + // KLocale * l = KGlobal::locale(); + // ok, we have to re-format the number to have: + // 1. decimalSymbol == '.' + // 2. negativeSign == '-' + // 3. positiveSign == <empty> + // 4. thousandsSeparator() == <empty> (we don't check that there + // are exactly three decimals between each separator): + QString d = ".",//l->decimalSymbol(), + n = "-",//l->negativeSign(), + p = "", //l->positiveSign(), + t = "";//l->thousandsSeparator(); + // first, delete p's and t's: + if ( !p.isEmpty() ) + for ( int idx = s.find( p ) ; idx >= 0 ; idx = s.find( p, idx ) ) + s.remove( idx, p.length() ); + + + if ( !t.isEmpty() ) + for ( int idx = s.find( t ) ; idx >= 0 ; idx = s.find( t, idx ) ) + s.remove( idx, t.length() ); + + // then, replace the d's and n's + if ( ( !n.isEmpty() && n.find('.') != -1 ) || + ( !d.isEmpty() && d.find('-') != -1 ) ) { + // make sure we don't replace something twice: + // kdWarning() << "KDoubleValidator: decimal symbol contains '-' or " +// "negative sign contains '.' -> improve algorithm" << endl; + return Invalid; + } + + if ( !d.isEmpty() && d != "." ) + for ( int idx = s.find( d ) ; idx >= 0 ; idx = s.find( d, idx + 1 ) ) + s.replace( idx, d.length(), "."); + + if ( !n.isEmpty() && n != "-" ) + for ( int idx = s.find( n ) ; idx >= 0 ; idx = s.find( n, idx + 1 ) ) + s.replace( idx, n.length(), "-" ); + } + + return base::validate( s, p ); +} + +//#include "knumvalidator.moc" diff --git a/noncore/settings/networksettings/ppp/knumvalidator.h b/noncore/settings/networksettings/ppp/knumvalidator.h new file mode 100644 index 0000000..c95293a --- a/dev/null +++ b/noncore/settings/networksettings/ppp/knumvalidator.h @@ -0,0 +1,211 @@ +/********************************************************************** +** +** $Id$ +** +** Copyright (C) 1999 Glen Parker <glenebob@nwlink.com> +** Copyright (C) 2002 Marc Mutz <mutz@kde.org> +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Library General Public +** License as published by the Free Software Foundation; either +** version 2 of the License, or (at your option) any later version. +** +** This library 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 +** Library General Public License for more details. +** +** You should have received a copy of the GNU Library General Public +** License along with this library; if not, write to the Free +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +*****************************************************************************/ + +#ifndef __KNUMVALIDATOR_H +#define __KNUMVALIDATOR_H + +#include <qvalidator.h> + +class QWidget; +class QString; + +/** + * @ref QValidator for integers. + + This can be used by @ref QLineEdit or subclass to provide validated + text entry. Can be provided with a base value (default is 10), to allow + the proper entry of hexadecimal, octal, or any other base numeric data. + + @author Glen Parker <glenebob@nwlink.com> + @version 0.0.1 +*/ +class KIntValidator : public QValidator { + + public: + /** + Constuctor. Also sets the base value. + */ + KIntValidator ( QWidget * parent, int base = 10, const char * name = 0 ); + /** + * Constructor. Also sets the minimum, maximum, and numeric base values. + */ + KIntValidator ( int bottom, int top, QWidget * parent, int base = 10, const char * name = 0 ); + /** + * Destructs the validator. + */ + virtual ~KIntValidator (); + /** + * Validates the text, and return the result. Does not modify the parameters. + */ + virtual State validate ( QString &, int & ) const; + /** + * Fixes the text if possible, providing a valid string. The parameter may be modified. + */ + virtual void fixup ( QString & ) const; + /** + * Sets the minimum and maximum values allowed. + */ + virtual void setRange ( int bottom, int top ); + /** + * Sets the numeric base value. + */ + virtual void setBase ( int base ); + /** + * Returns the current minimum value allowed. + */ + virtual int bottom () const; + /** + * Returns the current maximum value allowed. + */ + virtual int top () const; + /** + * Returns the current numeric base. + */ + virtual int base () const; + + private: + int _base; + int _min; + int _max; + +}; + +class KFloatValidatorPrivate; + +/** + @obsolete Use @ref KDoubleValidator + + @ref QValidator for floating point entry. + Extends the QValidator class to properly validate double numeric data. + This can be used by @ref QLineEdit or subclass to provide validated + text entry. + + @author Glen Parker <glenebob@nwlink.com> + @version 0.0.1 +*/ +class KFloatValidator : public QValidator { + + public: + /** + * Constructor. + */ + KFloatValidator ( QWidget * parent, const char * name = 0 ); + /** + * Constructor. Also sets the minimum and maximum values. + */ + KFloatValidator ( double bottom, double top, QWidget * parent, const char * name = 0 ); + /** + * Constructor. Sets the validator to be locale aware if @p localeAware is true. + */ + KFloatValidator ( double bottom, double top, bool localeAware, QWidget * parent, const char * name = 0 ); + /** + * Destructs the validator. + */ + virtual ~KFloatValidator (); + /** + * Validates the text, and return the result. Does not modify the parameters. + */ + virtual State validate ( QString &, int & ) const; + /** + * Fixes the text if possible, providing a valid string. The parameter may be modified. + */ + virtual void fixup ( QString & ) const; + /** + * Sets the minimum and maximum value allowed. + */ + virtual void setRange ( double bottom, double top ); + /** + * Returns the current minimum value allowed. + */ + virtual double bottom () const; + /** + * Returns the current maximum value allowed. + */ + virtual double top () const; + /** + * Sets the validator to be locale aware if @p is true. In this case, the + * character KLocale::decimalSymbol() from the global locale is recognized + * as decimal separator. + */ + void setAcceptLocalizedNumbers(bool b); + /** + * Returns true if the validator is locale aware. + * @see setAcceptLocalizedNumbers(). + */ + bool acceptLocalizedNumbers() const; + + private: + double _min; + double _max; + + KFloatValidatorPrivate *d; +}; + +/** + KDoubleValidator extends @ref QDoubleValidator to be + locale-aware. That means that - subject to not being disabled - + @ref KLocale::decimalPoint(), @ref KLocale::thousandsSeparator() + and @ref KLocale::positiveSign() and @ref KLocale::negativeSign() + are respected. + + @short A locale-aware @ref QDoubleValidator + @author Marc Mutz <mutz@kde.org> + @version $Id$ + @see KIntValidator + @since 3.1 +**/ + +class KDoubleValidator : public QDoubleValidator { + Q_OBJECT + Q_PROPERTY( bool acceptLocalizedNumbers READ acceptLocalizedNumbers WRITE setAcceptLocalizedNumbers ) +public: + /** Constuct a locale-aware KDoubleValidator with default range + (whatever @ref QDoubleValidator uses for that) and parent @p + parent */ + // KDoubleValidator( QObject * parent, const char * name=0 ); + KDoubleValidator( QWidget * parent, const char * name=0 ); + /** Constuct a locale-aware KDoubleValidator for range [@p bottom,@p + top] and a precision of @p decimals decimals after the decimal + point. */ + KDoubleValidator( double bottom, double top, int decimals, + QWidget * parent, const char * name=0 ); + // QObject * parent, const char * name=0 ); + /** Destructs the validator. + */ + virtual ~KDoubleValidator(); + + /** Overloaded for internal reasons. The API is not affected. */ + virtual QValidator::State validate( QString & input, int & pos ) const; + + /** @return whether localized numbers are accepted (default: true) */ + bool acceptLocalizedNumbers() const; + /** Sets whether to accept localized numbers (default: true) */ + void setAcceptLocalizedNumbers( bool accept ); + +private: + typedef QDoubleValidator base; + class Private; + Private * d; +}; + +#endif diff --git a/noncore/settings/networksettings/ppp/kpppwidget.cpp b/noncore/settings/networksettings/ppp/kpppwidget.cpp new file mode 100644 index 0000000..2f9feda --- a/dev/null +++ b/noncore/settings/networksettings/ppp/kpppwidget.cpp @@ -0,0 +1,905 @@ +/* + * + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * Copyright (C) 1998-2002 Harri Porten <porten@kde.org> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "kpppwidget.h" + +#include <qapplication.h> +#include <qcombobox.h> +#include <qdir.h> +#include <qevent.h> +#include <qdialog.h> +#include <qlabel.h> +#include <qpushbutton.h> +#include <qregexp.h> +#include <qtabwidget.h> +#include <qdialog.h> +#include <qwhatsthis.h> + +// #include <kaboutdata.h> +// #include <kapplication.h> +#include <qbuttongroup.h> +//#include <kcmdlineargs.h> +//#include <kconfig.h> +//#include <kdebug.h> +#define i18n QObject::tr +//#include <kiconloader.h> // For BarIcon +//#include <klocale.h> +#include <qmessagebox.h> +// #include <kseparator.h> +// #include <kstandarddirs.h> +// #include <kwin.h> +// #include <khelpmenu.h> +#include <qpushbutton.h> +//#include <kguiitem.h> + +#include <stdlib.h> +#include <errno.h> +#include <signal.h> + +#include "runtests.h" + +//#include "main.h" +#include "auth.h" +#include "modem.h" +//#include "ppplog.h" +//#include "opener.h" +//#include "requester.h" +//#include "pppstats.h" +#include "pppdata.h" +#include "general.h" + +#define execute_command system + +KPPPWidget *p_kppp = 0; + +KPPPWidget::KPPPWidget( QWidget *parent, const char *name, bool modal, WFlags fl ) + : QDialog(parent, name, modal, fl) +// , acct(0) +// , m_bCmdlAccount (false) +{ +// tabWindow = 0; + p_kppp = this; + // before doing anything else, run a few tests + + int result = runTests(); + if(result == TEST_CRITICAL) + exit(4); + +// installEventFilter(this); + +// QVBoxLayout *tl = new QVBoxLayout(this, 10, 10); + +// QGridLayout *l1 = new QGridLayout(3, 4); +// tl->addLayout(l1); +// l1->addColSpacing(0, 10); +// l1->addColSpacing(3, 10); +// l1->setColStretch(1, 3); +// l1->setColStretch(2, 4); + +// label1 = new QLabel(i18n("C&onnect to: "), this); +// l1->addWidget(label1, 0, 1); + +// connectto_c = new QComboBox(false, this); +// label1->setBuddy(connectto_c); + +// connect(connectto_c, SIGNAL(activated(int)), +// SLOT(newdefaultaccount(int))); +// l1->addWidget(connectto_c, 0, 2); + +// ID_Label = new QLabel(i18n("&Login ID:"), this); +// l1->addWidget(ID_Label, 1, 1); + +// // the entry line for usernames +// ID_Edit = new QLineEdit(this); +// ID_Label->setBuddy(ID_Edit); +// l1->addWidget(ID_Edit, 1, 2); +// connect(ID_Edit, SIGNAL(returnPressed()), +// this, SLOT(enterPressedInID())); +// QString tmp = i18n("<p>Type in the username that you got from your\n" +// "ISP. This is especially important for PAP\n" +// "and CHAP. You may omit this when you use\n" +// "terminal-based or script-based authentication.\n" +// "\n" +// "<b>Important</b>: case is important here:\n" +// "<i>myusername</i> is not the same as <i>MyUserName</i>!"); + +// QWhatsThis::add(ID_Label,tmp); +// QWhatsThis::add(ID_Edit,tmp); + +// PW_Label = new QLabel(i18n("&Password:"), this); +// l1->addWidget(PW_Label, 2, 1); + +// PW_Edit= new QLineEdit(this); +// PW_Label->setBuddy(PW_Edit); +// PW_Edit->setEchoMode(QLineEdit::Password); +// l1->addWidget(PW_Edit, 2, 2); +// connect(PW_Edit, SIGNAL(returnPressed()), +// this, SLOT(enterPressedInPW())); + +// tmp = i18n("<p>Type in the password that you got from your\n" +// "ISP. This is especially important for PAP\n" +// "and CHAP. You may omit this when you use\n" +// "terminal-based or script-based authentication.\n" +// "\n" +// "<b>Important</b>: case is important here:\n" +// "<i>mypassword</i> is not the same as <i>MyPassword</i>!"); + +// QWhatsThis::add(PW_Label,tmp); +// QWhatsThis::add(PW_Edit,tmp); + +// QHBoxLayout *l3 = new QHBoxLayout; +// tl->addSpacing(5); +// tl->addLayout(l3); +// tl->addSpacing(5); +// l3->addSpacing(10); +// log = new QCheckBox(i18n("Show lo&g window"), this); +// connect(log, SIGNAL(toggled(bool)), +// this, SLOT(log_window_toggled(bool))); +// log->setChecked(gpppdata.get_show_log_window()); +// l3->addWidget(log); + +// QWhatsThis::add(log, +// i18n("<p>This controls whether a log window is shown.\n" +// "A log window shows the communication between\n" +// "<i>kppp</i> and your modem. This will help you\n" +// "in tracking down problems.\n" +// "\n" +// "Turn it off if <i>kppp</i> routinely connects without\n" +// "problems")); + +// // fline = new QSeparator( KSeparator::HLine, this); +// // tl->addWidget(fline); + +// QHBoxLayout *l2 = new QHBoxLayout(this); +// tl->addLayout(l2); + +// int minw = 0; +// quit_b = new QPushButton(i18n("&Quit"), this); +// // quit_b-> setGuiItem (KGuiItem(i18n("&Quit"), "exit" ) ); +// connect( quit_b, SIGNAL(clicked()), SLOT(quitbutton())); +// if(quit_b->sizeHint().width() > minw) +// minw = quit_b->sizeHint().width(); + +// setup_b = new QPushButton(i18n("&Setup..."), this); +// // setup_b->setGuiItem (KGuiItem(i18n("&Setup...")) ); +// connect( setup_b, SIGNAL(clicked()), SLOT(expandbutton())); +// if(setup_b->sizeHint().width() > minw) +// minw = setup_b->sizeHint().width(); + + + +// if(gpppdata.access() != KConfig::ReadWrite) +// setup_b->setEnabled(false); + +// help_b = new QPushButton(i18n("&Help"), this); +// connect( help_b, SIGNAL(clicked()), SLOT(helpbutton())); + +// KHelpMenu *helpMenu = new KHelpMenu(this, KGlobal::instance()->aboutData(), true); +// help_b->setPopup((QPopupMenu*)helpMenu->menu()); +// help_b->setGuiItem (KGuiItem(i18n("&Help"), "help" ) ); + +// if(help_b->sizeHint().width() > minw) +// minw = help_b->sizeHint().width(); + +// connect_b = new QPushButton(i18n("&Connect"), this); +// connect_b->setDefault(true); +// connect_b->setFocus(); +// connect(connect_b, SIGNAL(clicked()), SLOT(beginConnect())); +// if(connect_b->sizeHint().width() > minw) +// minw = connect_b->sizeHint().width(); + +// quit_b->setFixedWidth(minw); +// setup_b->setFixedWidth(minw); +// // help_b->setFixedWidth(help_b->sizeHint().width()); +// connect_b->setFixedWidth(minw); + +// l2->addWidget(quit_b); +// l2->addWidget(setup_b); +// // l2->addWidget(help_b); +// l2->addSpacing(20); +// l2->addWidget(connect_b); + + setFixedSize(sizeHint()); + + (void)new Modem; + + // we also connect cmld_start to the beginConnect so that I can run + // the dialer through a command line argument + connect(this,SIGNAL(cmdl_start()),this,SLOT(beginConnect())); + +// stats = new PPPStats; + + // KWin::setIcons(winId(), kapp->icon(), kapp->miniIcon()); + + // constructor of con_win reads position from config file +// con_win = new ConWindow(0, "conw", this); + // KWin::setIcons(con_win->winId(), kapp->icon(), kapp->miniIcon()); + +// statdlg = new PPPStatsDlg(0, "stats", this, stats); +// statdlg->hide(); + + debugwindow = new DebugWidget(0,"debugwindow"); + // KWin::setIcons(debugwindow->winId(), kapp->icon(), kapp->miniIcon()); + debugwindow->hide(); + + // load up the accounts combo box + +// resetaccounts(); +// con = new ConnectWidget(0, "con"); + //KWin::setIcons(con->winId(), kapp->icon(), kapp->miniIcon() ); +// connect(this, SIGNAL(begin_connect()),con, SLOT(preinit())); + // Is this the best we can do here? it's not right. +// QRect desk = QApplication::desktop()->screenGeometry( +// QApplication::desktop()->screenNumber(topLevelWidget())); +// con->setGeometry(desk.center().x()-175, desk.center().y()-55, 350,110); + + // connect the ConnectWidgets various signals +// connect(con, SIGNAL(closeDebugWindow()), +// debugwindow, SLOT(hide())); +// connect(con, SIGNAL(debugMessage(const QString &)), +// debugwindow, SLOT(statusLabel(const QString &))); +// connect(con, SIGNAL(toggleDebugWindow()), +// debugwindow, SLOT(toggleVisibility())); +// connect(con, SIGNAL(debugPutChar(unsigned char)), +// debugwindow, SLOT(addChar(unsigned char))); +// // connect(con, SIGNAL(startAccounting()), +// // this, SLOT(startAccounting())); +// // connect(con, SIGNAL(stopAccounting()), +// // this, SLOT(stopAccounting())); +// connect(qApp, SIGNAL(saveYourself()), +// this, SLOT(saveMyself())); +// connect(qApp, SIGNAL(shutDown()), +// this, SLOT(shutDown())); + +// debugwindow->setGeometry(desk.center().x()+190, desk.center().y()-55, +// debugwindow->width(),debugwindow->height()); + +// move(desk.center().x()-width()/2, desk.center().y()-height()/2); + + +// KCmdLineArgs *args = KCmdLineArgs::parsedArgs(); + +// m_strCmdlAccount = args->getOption("c"); +// m_bQuitOnDisconnect = args->isSet("q"); + +// if(!m_strCmdlAccount.isEmpty()) { +// m_bCmdlAccount = true; +// kdDebug(5002) << "cmdl_account: " << m_bCmdlAccount << endl; +// } + +// if(m_bCmdlAccount){ +// bool result = gpppdata.setAccount(m_strCmdlAccount); +// if (!result){ +// QString string; +// string = i18n("No such Account:\n%1").arg(m_strCmdlAccount); +// KMessageBox::error(this, string); +// m_bCmdlAccount = false; +// this->show(); +// } else { +// beginConnect(); +// } +// } else +// expandbutton(); +// show(); + + +//#define KPPP_SHOW_NEWS +#ifdef KPPP_SHOW_NEWS + // keep user informed about recent changes + if(!m_bCmdlAccount) + showNews(); +#endif +} + +KPPPWidget::~KPPPWidget() +{ + p_kppp = 0; +// delete stats; +} + +// bool KPPPWidget::eventFilter(QObject *o, QEvent *e) { +// if(e->type() == QEvent::User) { +// switch(((SignalEvent*)e)->sigType()) { +// case SIGINT: +// qDebug( "Received a SIGINT" ); +// interruptConnection(); +// break; +// case SIGCHLD: +// sigChld(); +// break; +// case SIGUSR1: +// sigPPPDDied(); +// break; +// } +// return true; +// } + +// if(o == connect_b) { +// if(e->type() == QEvent::KeyPress) { +// if(connect_b->hasFocus() && ((QKeyEvent *)e)->key() == Qt::Key_Return) { +// beginConnect(); +// return true; +// } +// } +// } + +// return false; +// } + + + + +void KPPPWidget::enterPressedInID() { + PW_Edit->setFocus(); +} + + +void KPPPWidget::enterPressedInPW() { + connect_b->setFocus(); +} + +// triggered by the session manager +void KPPPWidget::saveMyself() { + gpppdata.save(); +} + +void KPPPWidget::shutDown() { + interruptConnection(); + saveMyself(); +} + +void KPPPWidget::log_window_toggled(bool on) { + gpppdata.set_show_log_window(on); +} + + + + +// void KPPPWidget::resetaccounts() { +// connectto_c->clear(); + +// int count = gpppdata.count(); + +// // enable/disable controls +// connectto_c->setEnabled(count > 0); +// connect_b->setEnabled(count > 0); +// log->setEnabled(count > 0); +// ID_Edit->setEnabled(count > 0); +// PW_Edit->setEnabled(count > 0); + +// //load the accounts +// for(int i=0; i < count; i++) { +// gpppdata.setAccountbyIndex(i); +// connectto_c->insertItem(gpppdata.accname()); +// } + +// //set the default account +// if(!gpppdata.defaultAccount().isEmpty()) { +// for(int i=0; i < count; i++) +// if(gpppdata.defaultAccount() == connectto_c->text(i)) { +// connectto_c->setCurrentItem(i); +// gpppdata.setAccountbyIndex(i); + +// ID_Edit->setText(gpppdata.storedUsername()); +// PW_Edit->setText(gpppdata.storedPassword()); +// } +// } +// else +// if(count > 0) { +// gpppdata.setDefaultAccount(connectto_c->text(0)); +// gpppdata.save(); +// ID_Edit->setText(gpppdata.storedUsername()); +// PW_Edit->setText(gpppdata.storedPassword()); +// } + +// connect(ID_Edit, SIGNAL(textChanged(const QString &)), +// this, SLOT(usernameChanged(const QString &))); + +// connect(PW_Edit, SIGNAL(textChanged(const QString &)), +// this, SLOT(passwordChanged(const QString &))); + +// if (ID_Edit->text().isEmpty()) +// ID_Edit->setFocus(); +// else if (PW_Edit->text().isEmpty()) +// PW_Edit->setFocus(); +// } + + +void KPPPWidget::interruptConnection() { + // interrupt dial up +// if (con->isVisible()) +// emit con->cancelbutton(); + + // disconnect if online + if (gpppdata.pppdRunning()) + emit disconnect(); +} + + +void KPPPWidget::sigPPPDDied() { + qDebug( "Received a SIGUSR1" ); + + // if we are not connected pppdpid is -1 so have have to check for that + // in the followin line to make sure that we don't raise a false alarm + // such as would be the case when the log file viewer exits. + if(gpppdata.pppdRunning() || gpppdata.pppdError()) { + qDebug( "It was pppd that died" ); + + // when we killpppd() on Cancel in ConnectWidget + // we set pppid to -1 so we won't + // enter this block + + // just to be sure + + Modem::modem->removeSecret(AUTH_PAP); + Modem::modem->removeSecret(AUTH_CHAP); + + gpppdata.setpppdRunning(false); + + qDebug( "Executing command on disconnect since pppd has died." ); + QApplication::flushX(); + execute_command(gpppdata.command_on_disconnect()); + +// stopAccounting(); + +// con_win->stopClock(); +// DockWidget::dock_widget->stop_stats(); +// DockWidget::dock_widget->hide(); + + if(!gpppdata.pppdError()) + gpppdata.setpppdError(E_PPPD_DIED); + removedns(); + Modem::modem->unlockdevice(); + // con->pppdDied(); + + if(!gpppdata.automatic_redial()) { + quit_b->setFocus(); + show(); +// con_win->stopClock(); +// stopAccounting(); +// con_win->hide(); +// con->hide(); + + gpppdata.setpppdRunning(false); + // // not in a signal handler !!! KNotifyClient::beep(); + QString msg; + if (gpppdata.pppdError() == E_IF_TIMEOUT) + msg = i18n("Timeout expired while waiting for the PPP interface " + "to come up!"); + else { + msg = i18n("<p>The pppd daemon died unexpectedly!</p>"); + Modem::modem->pppdExitStatus(); + if (Modem::modem->lastStatus != 99) { // more recent pppds only + msg += i18n("<p>Exit status: %1").arg(Modem::modem->lastStatus); + msg += i18n("</p><p>See 'man pppd' for an explanation of the error " + "codes or take a look at the kppp FAQ on " + " <a href=http://devel-home.kde.org/~kppp/index.html>" + "http://devel-home.kde.org/~kppp/index.html</a></p>"); + } + } + +// if(QMessageBox::warning(0, msg, i18n("Error"), i18n("&OK"), i18n("&Details...")) == QMessageBox::No) +// // PPPL_ShowLog(); +// } else { /* reconnect on disconnect */ + if (false){ + qDebug( "Trying to reconnect... " ); + + if(gpppdata.authMethod() == AUTH_PAP || + gpppdata.authMethod() == AUTH_CHAP || + gpppdata.authMethod() == AUTH_PAPCHAP) + Modem::modem->setSecret(gpppdata.authMethod(), + encodeWord(gpppdata.storedUsername()), + encodeWord(gpppdata.password())); + +// con_win->hide(); + // con_win->stopClock(); +// stopAccounting(); + gpppdata.setpppdRunning(false); + // not in a signal handler !!! KNotifyClient::beep(); + emit cmdl_start(); + } + } + gpppdata.setpppdError(0); + } +} + +// void KPPPWidget::sigChld() { +// qDebug( "sigchld()" ); +// // pid_t id = wait(0L); +// // if(id == helperPid && helperPid != -1) { +// // kdDebug(5002) << "It was the setuid child that died" << endl; +// // helperPid = -1; +// QString msg = i18n("kppp's helper process just died.\n" +// "Since a further execution would be pointless, " +// "kppp will shut down now."); +// QMessageBox::warning(0L,"error", msg); +// //remove_pidfile(); +// exit(1); +// // } +// } + + +void KPPPWidget::newdefaultaccount(int i) { + gpppdata.setDefaultAccount(connectto_c->text(i)); + gpppdata.save(); + ID_Edit->setText(gpppdata.storedUsername()); + PW_Edit->setText(gpppdata.storedPassword()); +} + + + + +void KPPPWidget::beginConnect() { + // make sure to connect to the account that is selected in the combo box + // (exeption: an account given by a command line argument) + // if(!m_bCmdlAccount) { +// gpppdata.setAccount(connectto_c->currentText()); +// gpppdata.setPassword(PW_Edit->text()); +// } else { + gpppdata.setPassword(gpppdata.storedPassword()); +// } + + QFileInfo info(pppdPath()); + + if(!info.exists()){ + QMessageBox::warning(this, "error", i18n("Cannot find the PPP daemon!\n" + "Make sure that pppd is installed and " + "that you have entered the correct path.")); + return; + } +#if 0 + if(!info.isExecutable()){ + + QString string; + string = i18n("kppp cannot execute:\n %1\n" + "Please make sure that you have given kppp " + "setuid permission and that " + "pppd is executable.").arg(gpppdata.pppdPath()); + KMessageBox::error(this, string); + return; + + } +#endif + + QFileInfo info2(gpppdata.modemDevice()); + + if(!info2.exists()){ + QString string; + string = i18n("kppp can not find:\n %1\nPlease make sure you have setup " + "your modem device properly " + "and/or adjust the location of the modem device on " + "the modem tab of " + "the setup dialog.").arg(gpppdata.modemDevice()); + QMessageBox::warning(this, "error", string); + return; + } + + // if this is a PAP or CHAP account, ensure that username is + // supplied + if(gpppdata.authMethod() == AUTH_PAP || + gpppdata.authMethod() == AUTH_CHAP || + gpppdata.authMethod() == AUTH_PAPCHAP ) { + if(ID_Edit->text().isEmpty()) { + QMessageBox::warning(this,"error", + i18n( + "You have selected the authentication " + "method PAP or CHAP. This requires that you " + "supply a username and a password!")); + return; + } else { + if(!Modem::modem->setSecret(gpppdata.authMethod(), + encodeWord(gpppdata.storedUsername()), + encodeWord(gpppdata.password()))) { + QString s; + s = i18n("Cannot create PAP/CHAP authentication\n" + "file \"%1\"").arg(PAP_AUTH_FILE); + QMessageBox::warning(this, "error", s); + return; + } + } + } + + if (gpppdata.phonenumber().isEmpty()) { + QString s = i18n("You must specify a telephone number!"); + QMessageBox::warning(this, "error", s); + return; + } + + this->hide(); + + QString tit = i18n("Connecting to: %1").arg(gpppdata.accname()); +// con->setCaption(tit); + +// con->show(); + + bool show_debug = gpppdata.get_show_log_window(); +// con->debug->setOn(show_debug); // toggle button + debugwindow->clear(); + if (!show_debug) + debugwindow->hide(); + else { + debugwindow->show(); +// con->raise(); + } + + emit begin_connect(); +} + + +void KPPPWidget::disconnect() { + if (!gpppdata.command_before_disconnect().isEmpty()) { +// con_win->hide(); +// con->show(); +// con->setCaption(i18n("Disconnecting...")); +// con->setMsg(i18n("Executing command before disconnection.")); + + qApp->processEvents(); + QApplication::flushX(); +// pid_t id = + execute_command(gpppdata.command_before_disconnect()); +// int i, status; + +// do { +// kapp->processEvents(); +// i = waitpid(id, &status, WNOHANG); +// usleep(500000); +// } while (i == 0 && errno == 0); + +// con->hide(); + } + + qApp->processEvents(); + +// statdlg->stop_stats(); + Modem::modem->killPPPDaemon(); + + QApplication::flushX(); + execute_command(gpppdata.command_on_disconnect()); + + Modem::modem->removeSecret(AUTH_PAP); + Modem::modem->removeSecret(AUTH_CHAP); + + removedns(); + Modem::modem->unlockdevice(); + +// con_win->stopClock(); +// p_kppp->stopAccounting(); +// con_win->hide(); + +// DockWidget::dock_widget->stop_stats(); +// DockWidget::dock_widget->hide(); + +// if(m_bQuitOnDisconnect) +// kapp->exit(0); +// else { + this->quit_b->setFocus(); + this->show(); +// } +} + + +// void KPPPWidget::helpbutton() { +// kapp->invokeHelp(); +// } + + +void KPPPWidget::quitbutton() { + if(gpppdata.pppdRunning()) { + int ok = QMessageBox::warning(this, + i18n("Exiting kPPP will close your PPP Session."), + i18n("Quit kPPP?")); + if(ok == QMessageBox::Yes) { + Modem::modem->killPPPDaemon(); + QApplication::flushX(); + execute_command(gpppdata.command_on_disconnect()); + removedns(); + Modem::modem->unlockdevice(); + } + } else { + if (!gpppdata.accname().isEmpty() && !gpppdata.storePassword()) + gpppdata.setStoredPassword(""); + } + gpppdata.save(); + qApp->quit(); +} + + +// void KPPPWidget::rulesetLoadError() { +// QMessageBox::warning(this,"error", ruleset_load_errmsg); +// } + + +// void KPPPWidget::startAccounting() { +// // volume accounting +// stats->totalbytes = 0; + +// kdDebug() << "AcctEnabled: " << gpppdata.AcctEnabled() << endl; + +// // load the ruleset +// if(!gpppdata.AcctEnabled()) +// return; + +// QString d = AccountingBase::getAccountingFile(gpppdata.accountingFile()); +// // if(::access(d.data(), X_OK) != 0) +// acct = new Accounting(this, stats); +// // else +// // acct = new ExecutableAccounting(this); + +// // connect to the accounting object +// connect(acct, SIGNAL(changed(QString, QString)), +// con_win, SLOT(slotAccounting(QString, QString))); + +// // if(!acct->loadRuleSet(gpppdata.accountingFile())) { +// // QString s= i18n("Can not load the accounting " +// // "ruleset \"%1\"!").arg(gpppdata.accountingFile()); + +// // starting the messagebox with a timer will prevent us +// // from blocking the calling function ConnectWidget::timerEvent +// ruleset_load_errmsg = s; +// QTimer::singleShot(0, this, SLOT(rulesetLoadError())); +// return; +// } +// //else +// // acct->slotStart(); +// } + +// void KPPPWidget::stopAccounting() { +// // store volume accounting +// // if(stats->totalbytes != 0) +// // gpppdata.setTotalBytes(stats->totalbytes); + +// if(!gpppdata.AcctEnabled()) +// return; + +// // if(acct != 0) { +// // acct->slotStop(); +// // delete acct; +// // acct = 0; +// // } +// } + + +// void KPPPWidget::showStats() { +// if(statdlg) { +// statdlg->show(); +// statdlg->raise(); +// } +// } + + +void KPPPWidget::usernameChanged(const QString &) { + // store username for later use + gpppdata.setStoredUsername(ID_Edit->text()); +} + + +void KPPPWidget::passwordChanged(const QString &) { + // store the password if so requested + if(gpppdata.storePassword()) + gpppdata.setStoredPassword(PW_Edit->text()); + else + gpppdata.setStoredPassword(""); +} + + +void KPPPWidget::setPW_Edit(const QString &pw) { + PW_Edit->setText(pw); +} + + +// void KPPPWidget::resetCosts(const QString &s) { +// AccountingBase::resetCosts(s); +// } + + +// void KPPPWidget::resetVolume(const QString &s) { +// AccountingBase::resetVolume(s); +// } + +/** + * pppd's getword() function knows about escape characters. + * If we write the username and password to the secrets file + * we'll therefore have to escape back slashes. + */ +QString KPPPWidget::encodeWord(const QString &s) { + QString r = s; + r.replace(QRegExp("\\"), "\\\\"); + return r; +} + +// void KPPPWidget::setQuitOnDisconnect (bool b) +// { +// m_bQuitOnDisconnect = b; +// } + +void KPPPWidget::showNews() { +#ifdef KPPP_SHOW_NEWS + /* + * Introduce the QuickHelp feature to new users of this version + */ + #define QUICKHELP_HINT "Hint_QuickHelp" + if(gpppdata.readNumConfig(GENERAL_GRP, QUICKHELP_HINT, 0) == 0) { + QDialog dlg(0, 0, true); + dlg.setCaption(i18n("Recent Changes in KPPP")); + + QVBoxLayout *tl = new QVBoxLayout(&dlg, 10, 10); + QHBoxLayout *l1 = new QHBoxLayout(10); + QVBoxLayout *l2 = new QVBoxLayout(10); + tl->addLayout(l1); + + QLabel *icon = new QLabel(&dlg); + icon->setPixmap(BarIcon("exclamation")); + icon->setFixedSize(icon->sizeHint()); + l1->addWidget(icon); + l1->addLayout(l2); + + QLabel *l = new QLabel(i18n("From version 1.4.8 on, kppp has a new feature\n" + "called \"Quickhelp\". It's similar to a tooltip,\n" + "but you can activate it whenever you want.\n" + "\n" + "To activate it, simply click on a control like\n" + "a button or a label with the right mouse button.\n" + "If the item supports Quickhelp, a popup menu\n" + "will appear leading to Quickhelp.\n" + "\n" + "To test it, right-click somewhere in this text."), + &dlg); + + QCheckBox *cb = new QCheckBox(i18n("Don't show this hint again"), &dlg); + cb->setFixedSize(cb->sizeHint()); + + KButtonBox *bbox = new KButtonBox(&dlg); + bbox->addStretch(1); + QPushButton *ok = bbox->addButton(i18n("OK")); + ok->setDefault(true); + dlg.connect(ok, SIGNAL(clicked()), + &dlg, SLOT(accept())); + bbox->addStretch(1); + bbox->layout(); + + l2->addWidget(l); + l2->addWidget(cb); + tl->addWidget(bbox); + + QString tmp = i18n("This is an example of <b>QuickHelp</b>.\n" + "This window will stay open until you\n" + "click a mouse button or a press a key.\n"); + + QWhatsThis::add(cb,tmp); + QWhatsThis::add(l, tmp); + + dlg.exec(); + if(cb->isChecked()) { + gpppdata.writeConfig(GENERAL_GRP, QUICKHELP_HINT, 1); + gpppdata.save(); + } + } +#endif +} + + +//#include "kpppwidget.moc" + diff --git a/noncore/settings/networksettings/ppp/kpppwidget.h b/noncore/settings/networksettings/ppp/kpppwidget.h new file mode 100644 index 0000000..266d829 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/kpppwidget.h @@ -0,0 +1,157 @@ +/* + * + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * Copyright (C) 1998-2002 Harri Porten <porten@kde.org> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef __KPPPWIDGET_H__ +#define __KPPPWIDGET_H__ + +#include <qstring.h> + +//#include "accounting.h" +#include "conwindow.h" +#include "accounts.h" +#include "connect.h" +#include "debug.h" +//#include "pppstatdlg.h" + +//class GraphSetup; +//class AboutWidget; +//class PPPStats; +class QDialog; +class QPushButton; + +/* class SignalEvent : public QEvent { */ +/* public: */ +/* SignalEvent(int s) : QEvent(User), sig(s) { } */ +/* int sigType() const { return sig; } */ +/* private: */ +/* int sig; */ +/* }; */ + + +class KPPPWidget : public QDialog { + Q_OBJECT +public: + + KPPPWidget( QWidget *parent=0, const char *name=0, bool modal = false, WFlags fl = 0 ); + ~KPPPWidget(); + + void setPW_Edit(const QString &); + // virtual bool eventFilter(QObject *, QEvent *); + + void setQuitOnDisconnect (bool b); + // bool quitOnDisconnect () {return m_bQuitOnDisconnect;}; + +private slots: + void newdefaultaccount(int); +// void expandbutton(); + void beginConnect(); + void quitbutton(); + // void helpbutton(); + // void setup(); + // void rulesetLoadError(); + void usernameChanged(const QString &); + void passwordChanged(const QString &); + void enterPressedInID(); + void enterPressedInPW(); + void saveMyself(); + void shutDown(); + +/* protected slots: */ +/* virtual void accept(); */ +/* virtual void reject(); */ + +public slots: + // void resetaccounts(); +/* void resetCosts(const QString &); */ +/* void resetVolume(const QString &); */ + void disconnect(); + void log_window_toggled(bool on); +/* void startAccounting(); */ +/* void stopAccounting(); */ +/* void showStats(); */ + +signals: + void begin_connect(); + void cmdl_start(); + +public: + QCheckBox *log; + bool connected; + DebugWidget *debugwindow; + QString con_speed; + // ConnectWidget *con; + // ConWindow *con_win; + // PPPStatsDlg *statdlg; + // AccountingBase *acct; + QPushButton *quit_b; + //PPPStats *stats; + +private: + // void prepareSetupDialog(); + void interruptConnection(); + void sigChld(); + void sigPPPDDied(); + QString encodeWord(const QString &s); + void showNews (); + + QString ruleset_load_errmsg; + + // QPushButton *help_b; + QPushButton *setup_b; + QFrame *fline; + QFrame *fline1; + QPushButton *connect_b; + QComboBox *connectto_c; + QLabel *ID_Label; + QLabel *PW_Label; + QLineEdit *ID_Edit; + QLineEdit *PW_Edit; + QLabel *label1; + QLabel *label2; + QLabel *label3; + QLabel *label4; + QLabel *label5; + QLabel *label6; + QLabel *radio_label; + + + // QTabWidget *tabWindow; + // AccountWidget *accounts; + // GeneralWidget *general; + // ModemWidget *modem1; + // ModemWidget2 *modem2; + // GraphSetup *graph; + // AboutWidget *about; + + +/* QString m_strCmdlAccount; */ +/* bool m_bQuitOnDisconnect; */ +/* bool m_bCmdlAccount; */ +}; + + +#endif + diff --git a/noncore/settings/networksettings/ppp/modem.cpp b/noncore/settings/networksettings/ppp/modem.cpp index e9e3f06..a2f77c5 100644 --- a/noncore/settings/networksettings/ppp/modem.cpp +++ b/noncore/settings/networksettings/ppp/modem.cpp @@ -30,12 +30,13 @@ #include <signal.h> #include <sys/ioctl.h> #include <setjmp.h> +#include <regex.h> #include <qregexp.h> #include <assert.h> +#include "auth.h" #include "modem.h" #include "pppdata.h" -//#include "requester.h" //#include <klocale.h> #define i18n QObject::tr #define qError qDebug @@ -51,15 +52,42 @@ static sigjmp_buf jmp_buffer; Modem *Modem::modem = 0; -Modem::Modem() : - modemfd(-1), - sn(0L), - data_mode(false), - modem_is_locked(false) + +const char* pppdPath() { + // wasting a few bytes + static char buffer[sizeof(PPPDSEARCHPATH)+sizeof(PPPDNAME)]; + static char *pppdPath = 0L; + char *p; + + if(pppdPath == 0L) { + const char *c = PPPDSEARCHPATH; + while(*c != '\0') { + while(*c == ':') + c++; + p = buffer; + while(*c != '\0' && *c != ':') + *p++ = *c++; + *p = '\0'; + strcat(p, "/"); + strcat(p, PPPDNAME); + if(access(buffer, F_OK) == 0) + return (pppdPath = buffer); + } + } + + return pppdPath; +} + + +Modem::Modem() { + if (Modem::modem != 0) return; //CORRECT? + modemfd = -1; + sn = 0L; + data_mode = false; + modem_is_locked = false; lockfile[0] = '\0'; device = "/dev/modem"; - assert(modem==0); modem = this; } @@ -644,28 +672,138 @@ void alarm_handler(int) { } +const char* Modem::authFile(Auth method, int version) { + switch(method|version) { + case PAP|Original: + return PAP_AUTH_FILE; + break; + case PAP|New: + return PAP_AUTH_FILE".new"; + break; + case PAP|Old: + return PAP_AUTH_FILE".old"; + break; + case CHAP|Original: + return CHAP_AUTH_FILE; + break; + case CHAP|New: + return CHAP_AUTH_FILE".new"; + break; + case CHAP|Old: + return CHAP_AUTH_FILE".old"; + break; + default: + return 0L; + } +} -const char* pppdPath() { - // wasting a few bytes - static char buffer[sizeof(PPPDSEARCHPATH)+sizeof(PPPDNAME)]; - static char *pppdPath = 0L; - char *p; - if(pppdPath == 0L) { - const char *c = PPPDSEARCHPATH; - while(*c != '\0') { - while(*c == ':') - c++; - p = buffer; - while(*c != '\0' && *c != ':') - *p++ = *c++; - *p = '\0'; - strcat(p, "/"); - strcat(p, PPPDNAME); - if(access(buffer, F_OK) == 0) - return (pppdPath = buffer); +bool Modem::createAuthFile(Auth method, const char *username, const char *password) { + const char *authfile, *oldName, *newName; + char line[100]; + char regexp[2*MaxStrLen+30]; + regex_t preg; + + if(!(authfile = authFile(method))) + return false; + + if(!(newName = authFile(method, New))) + return false; + + // look for username, "username" or 'username' + // if you modify this RE you have to adapt regexp's size above + snprintf(regexp, sizeof(regexp), "^[ \t]*%s[ \t]\\|^[ \t]*[\"\']%s[\"\']", + username,username); + MY_ASSERT(regcomp(&preg, regexp, 0) == 0); + + // copy to new file pap- or chap-secrets + int old_umask = umask(0077); + FILE *fout = fopen(newName, "w"); + if(fout) { + // copy old file + FILE *fin = fopen(authfile, "r"); + if(fin) { + while(fgets(line, sizeof(line), fin)) { + if(regexec(&preg, line, 0, 0L, 0) == 0) + continue; + fputs(line, fout); } + fclose(fin); } - return pppdPath; + // append user/pass pair + fprintf(fout, "\"%s\"\t*\t\"%s\"\n", username, password); + fclose(fout); + } + + // restore umask + umask(old_umask); + + // free memory allocated by regcomp + regfree(&preg); + + if(!(oldName = authFile(method, Old))) + return false; + + // delete old file if any + unlink(oldName); + + rename(authfile, oldName); + rename(newName, authfile); + + return true; +} + + +bool Modem::setSecret(int method, const char* name, const char* password) +{ + + Auth auth; + if(method == AUTH_PAPCHAP) + return setSecret(AUTH_PAP, name, password) && + setSecret(AUTH_CHAP, name, password); + + switch(method) { + case AUTH_PAP: + auth = Modem::PAP; + break; + case AUTH_CHAP: + auth = Modem::CHAP; + break; + default: + return false; } + + return createAuthFile(auth, name, password); + +} + +bool Modem::removeSecret(int) +{ + return true; +} + +void Modem::killPPPDaemon() +{ +} + +int Modem::pppdExitStatus() +{ + return -1; +} + +bool Modem::execPPPDaemon(const QString & arguments) +{ + return true; +} + +int Modem::openResolv(int flags) +{ + return -1; +} + +bool Modem::setHostname(const QString & name) +{ + return true; +} + diff --git a/noncore/settings/networksettings/ppp/modem.h b/noncore/settings/networksettings/ppp/modem.h index c23524a..052be4a 100644 --- a/noncore/settings/networksettings/ppp/modem.h +++ b/noncore/settings/networksettings/ppp/modem.h @@ -66,8 +66,18 @@ public: int lockdevice(); void unlockdevice(); + bool setSecret(int,const char*,const char*); + bool removeSecret(int); + void killPPPDaemon(); + int pppdExitStatus(); + bool execPPPDaemon(const QString & arguments); + int openResolv(int flags); + bool setHostname(const QString & name); + public: + enum Auth { PAP = 1, CHAP }; static Modem *modem; + int lastStatus; signals: void charWaiting(unsigned char); @@ -78,6 +88,11 @@ private slots: void readtty(int); private: + enum { MaxPathLen = 30, MaxStrLen = 40, MaxArgs = 100 }; + enum { Original=0x100, New=0x200, Old=0x400 } Version; + + const char* authFile(Auth method, int version = Original ); + bool createAuthFile(Auth method,const char *username,const char *password); void escape_to_command_mode(); int openLockfile(QString,int); diff --git a/noncore/settings/networksettings/ppp/modemcmds.cpp b/noncore/settings/networksettings/ppp/modemcmds.cpp new file mode 100644 index 0000000..766ba0f --- a/dev/null +++ b/noncore/settings/networksettings/ppp/modemcmds.cpp @@ -0,0 +1,321 @@ +/* + * kPPP: A front end for pppd for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with dummyWidget program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <qlayout.h> +#include <qslider.h> +#include <qbuttongroup.h> +#include <stdlib.h> +//#include <kapplication.h> // for getMiniIcon() +//#include <klocale.h> +#define i18n QObject::tr +#include "modemcmds.h" +#include "pppdata.h" +//#include <kwin.h> + +#define ADJUSTEDIT(e) //e->setText("XXXXXXXXqy"); e->setMinimumSize(e->sizeHint()); /*e->setFixedHeight(e->sizeHint().height());*/ e->setText(""); e->setMaxLength(MODEMSTR_SIZE); + +// a little trick to make the label look like a disabled lineedit +#define FORMATSLIDERLABEL(l) //l->setFixedWidth(l->sizeHint().width()); l->setFixedHeight(QLineEdit(dummyWidget).sizeHint().height()); l->setAlignment(AlignCenter); l->setFrameStyle(QFrame::WinPanel|QFrame::Sunken); l->setLineWidth(2); + +ModemCommands::ModemCommands(QWidget *parent, const char *name) + : QDialog(parent, name, true ) //, i18n("Edit Modem Commands") , Ok|Cancel) +{ + setCaption(i18n("Edit Modem Commands")); +// KWin::setIcons(winId(), kapp->icon(), kapp->miniIcon()); + QWidget *dummyWidget = new QWidget(this); +// setMainWidget(dummyWidget); + + const int GRIDROWS = 22; + int row = 0; + + // toplevel layout + QVBoxLayout *tl = new QVBoxLayout(this, 10, 4); + + // add grid + frame + QGridLayout *l1 = new QGridLayout(GRIDROWS, 4); + tl->addLayout(l1); + box = new QGroupBox(this, "box"); + l1->addMultiCellWidget(box, row++, GRIDROWS, 0, 3); + + // put slider and label into a separate H-Box + QHBoxLayout *l2 = new QHBoxLayout; + l1->addLayout(l2, row, 2); + lpreinitslider = new QLabel("MMMM", this); + FORMATSLIDERLABEL(lpreinitslider); + + QSlider *preinitslider = new QSlider(0, 300, 1, 0, + QSlider::Horizontal, this); +// preinitslider->setFixedHeight(preinitslider->sizeHint().height()); + connect(preinitslider, SIGNAL(valueChanged(int)), + lpreinitslider, SLOT(setNum(int))); + l2->addWidget(lpreinitslider, 0); + l2->addWidget(preinitslider, 1); + + lpreinit = new QLabel(i18n("Pre-init delay (sec/100):"), this); + l1->addWidget(lpreinit, row++, 1); + + for(int i = 0; i < PPPData::NumInitStrings; i++) { + initstr[i] = new QLineEdit(this); + QLabel *initLabel = new QLabel(i18n("Initialization string %1:").arg(i + 1), + this); + ADJUSTEDIT(initstr[i]); + l1->addWidget(initLabel, row, 1); + l1->addWidget(initstr[i], row++, 2); + } + + QHBoxLayout *l3 = new QHBoxLayout; + l1->addLayout(l3, row, 2); + linitslider = new QLabel("MMMM", this); + FORMATSLIDERLABEL(linitslider); + QSlider *initslider = new QSlider(1, 300, 1, 0, + QSlider::Horizontal, this); +// initslider->setFixedHeight(initslider->sizeHint().height()); + connect(initslider, SIGNAL(valueChanged(int)), + linitslider, SLOT(setNum(int))); + l3->addWidget(linitslider, 0); + l3->addWidget(initslider, 1); + + label3 = new QLabel(i18n("Post-init delay (sec/100):"), this); + l1->addWidget(label3, row++, 1); + + /* Set ATS11 (Dial tone duration) between 0-255 (Default ~ 70) */ + QHBoxLayout *l4 = new QHBoxLayout; + l1->addLayout(l4, row, 2); + ldurationslider = new QLabel("MMMM", this); + FORMATSLIDERLABEL(ldurationslider); + QSlider *durationslider = new QSlider(1, 255, 1, 0, + QSlider::Horizontal, this); +// durationslider->setFixedHeight(durationslider->sizeHint().height()); + connect(durationslider, SIGNAL(valueChanged(int)), + ldurationslider, SLOT(setNum(int))); + l4->addWidget(ldurationslider, 0); + l4->addWidget(durationslider, 1); + + lduration = new QLabel(i18n("Dialing speed (sec/100):"), this); + l1->addWidget(lduration, row++, 1); + + + initresp = new QLineEdit(this); + label2 = new QLabel(i18n("Init response:"), this); + ADJUSTEDIT(initresp); + l1->addWidget(label2, row, 1); + l1->addWidget(initresp, row++, 2); + + nodetectdialtone = new QLineEdit(this); + lnodetectdialtone = new QLabel(i18n("No dial tone detection:"), this); + ADJUSTEDIT(nodetectdialtone); + l1->addWidget(lnodetectdialtone, row, 1); + l1->addWidget(nodetectdialtone, row++, 2); + + dialstr = new QLineEdit(this); + label4 = new QLabel(i18n("Dial string:"),this); + ADJUSTEDIT(dialstr); + l1->addWidget(label4, row, 1); + l1->addWidget(dialstr, row++, 2); + + connectresp = new QLineEdit(this); + label5 = new QLabel(i18n("Connect response:"), this); + ADJUSTEDIT(connectresp); + l1->addWidget(label5, row, 1); + l1->addWidget(connectresp, row++, 2); + + busyresp = new QLineEdit(this); + label6 = new QLabel(i18n("Busy response:"), this); + ADJUSTEDIT(busyresp); + l1->addWidget(label6, row, 1); + l1->addWidget(busyresp, row++, 2); + + nocarrierresp = new QLineEdit(this); + label7 = new QLabel(i18n("No carrier response:"), this); + ADJUSTEDIT(nocarrierresp); + l1->addWidget(label7, row, 1); + l1->addWidget(nocarrierresp, row++, 2); + + nodialtoneresp = new QLineEdit(this); + label8 = new QLabel(i18n("No dial tone response:"), this); + ADJUSTEDIT(nodialtoneresp); + l1->addWidget(label8, row, 1); + l1->addWidget(nodialtoneresp, row++, 2); + + hangupstr = new QLineEdit(this); + label9 = new QLabel(i18n("Hangup string:"), this); + ADJUSTEDIT(hangupstr); + l1->addWidget(label9, row, 1); + l1->addWidget(hangupstr, row++, 2); + + hangupresp = new QLineEdit(this); + label10 = new QLabel(i18n("Hangup response:"), this); + ADJUSTEDIT(hangupresp); + l1->addWidget(label10, row, 1); + l1->addWidget(hangupresp, row++, 2); + + answerstr = new QLineEdit(this); + label11 = new QLabel(i18n("Answer string:"), this); + ADJUSTEDIT(answerstr); + l1->addWidget(label11, row, 1); + l1->addWidget(answerstr, row++, 2); + + ringresp = new QLineEdit(this); + label12 = new QLabel(i18n("Ring response:"), this); + ADJUSTEDIT(ringresp); + l1->addWidget(label12, row, 1); + l1->addWidget(ringresp, row++, 2); + + answerresp = new QLineEdit(this); + label13 = new QLabel(i18n("Answer response:"), this); + ADJUSTEDIT(answerresp); + l1->addWidget(label13, row, 1); + l1->addWidget(answerresp, row++, 2); + + escapestr = new QLineEdit(this); + label14 = new QLabel(i18n("Escape string:"), this); + ADJUSTEDIT(escapestr); + l1->addWidget(label14, row, 1); + l1->addWidget(escapestr, row++, 2); + + escaperesp = new QLineEdit(this); + label15 = new QLabel(i18n("Escape response:"), this); + ADJUSTEDIT(escaperesp); + l1->addWidget(label15, row, 1); + l1->addWidget(escaperesp, row++, 2); + + QHBoxLayout *l5 = new QHBoxLayout; + l1->addLayout(l5, row, 2); + lslider = new QLabel("MMMM", this); + FORMATSLIDERLABEL(lslider); + + QSlider *slider = new QSlider(0, 255, 1, 0, + QSlider::Horizontal, this); +// slider->setFixedHeight(slider->sizeHint().height()); + connect(slider, SIGNAL(valueChanged(int)), + lslider, SLOT(setNum(int))); + l5->addWidget(lslider, 0); + l5->addWidget(slider, 1); + + label16 = new QLabel(i18n("Guard time (sec/50):"), this); + l1->addWidget(label16, row++, 1); + + QLabel *l = new QLabel(i18n("Volume off/low/high:"), this); + l1->addWidget(l, row, 1); + QHBoxLayout *l6 = new QHBoxLayout; + l1->addLayout(l6, row++, 2); + volume_off = new QLineEdit(this); +// volume_off->setFixedHeight(volume_off->sizeHint().height()); + // volume_off->setMinimumWidth((int)(volume_off->sizeHint().width() / 2)); + volume_medium = new QLineEdit(this); +// volume_medium->setFixedHeight(volume_medium->sizeHint().height()); + // volume_medium->setMinimumWidth((int)(volume_medium->sizeHint().width() / 2)); + volume_high = new QLineEdit(this); + // volume_high->setFixedHeight(volume_high->sizeHint().height()); + // volume_high->setMinimumWidth((int)(volume_high->sizeHint().width() / 2)); + l6->addWidget(volume_off); + l6->addWidget(volume_medium); + l6->addWidget(volume_high); + + initstr[0]->setFocus(); + + l1->addColSpacing(0, 10); + l1->addColSpacing(3, 10); + l1->addRowSpacing(0, 5); + l1->addRowSpacing(GRIDROWS, 5); + + //set stuff from gpppdata + preinitslider->setValue(gpppdata.modemPreInitDelay()); + lpreinitslider->setNum(gpppdata.modemPreInitDelay()); + for(int i = 0; i < PPPData::NumInitStrings; i++) + initstr[i]->setText(gpppdata.modemInitStr(i)); + initslider->setValue(gpppdata.modemInitDelay()); + linitslider->setNum(gpppdata.modemInitDelay()); + initresp->setText(gpppdata.modemInitResp()); + + durationslider->setValue(gpppdata.modemToneDuration()); + ldurationslider->setNum(gpppdata.modemToneDuration()); + + nodetectdialtone->setText(gpppdata.modemNoDialToneDetectionStr()); + dialstr->setText(gpppdata.modemDialStr()); + connectresp->setText(gpppdata.modemConnectResp()); + busyresp->setText(gpppdata.modemBusyResp()); + nocarrierresp->setText(gpppdata.modemNoCarrierResp()); + nodialtoneresp->setText(gpppdata.modemNoDialtoneResp()); + + escapestr->setText(gpppdata.modemEscapeStr()); + escaperesp->setText(gpppdata.modemEscapeResp()); + + hangupstr->setText(gpppdata.modemHangupStr()); + hangupresp->setText(gpppdata.modemHangupResp()); + + answerstr->setText(gpppdata.modemAnswerStr()); + ringresp->setText(gpppdata.modemRingResp()); + answerresp->setText(gpppdata.modemAnswerResp()); + + slider->setValue(gpppdata.modemEscapeGuardTime()); + lslider->setNum(gpppdata.modemEscapeGuardTime()); + + volume_off->setText(gpppdata.volumeOff()); + volume_medium->setText(gpppdata.volumeMedium()); + volume_high->setText(gpppdata.volumeHigh()); +} + + +void ModemCommands::slotOk() { + gpppdata.setModemPreInitDelay(lpreinitslider->text().toInt()); + for(int i = 0; i < PPPData::NumInitStrings; i++) + gpppdata.setModemInitStr(i, initstr[i]->text()); + gpppdata.setModemInitResp(initresp->text()); + gpppdata.setModemInitDelay(linitslider->text().toInt()); + + gpppdata.setModemToneDuration(ldurationslider->text().toInt()); + gpppdata.setModemNoDialToneDetectionStr(nodetectdialtone->text()); + gpppdata.setModemDialStr(dialstr->text()); + gpppdata.setModemConnectResp(connectresp->text()); + gpppdata.setModemBusyResp(busyresp->text()); + gpppdata.setModemNoCarrierResp(nocarrierresp->text()); + gpppdata.setModemNoDialtoneResp(nodialtoneresp->text()); + + gpppdata.setModemEscapeStr(escapestr->text()); + gpppdata.setModemEscapeResp(escaperesp->text()); + gpppdata.setModemEscapeGuardTime(lslider->text().toInt()); + gpppdata.setModemHangupStr(hangupstr->text()); + gpppdata.setModemHangupResp(hangupresp->text()); + + gpppdata.setModemAnswerStr(answerstr->text()); + gpppdata.setModemRingResp(ringresp->text()); + gpppdata.setModemAnswerResp(answerresp->text()); + + gpppdata.setVolumeHigh(volume_high->text()); + gpppdata.setVolumeMedium(volume_medium->text()); + gpppdata.setVolumeOff(volume_off->text()); + + gpppdata.save(); + accept(); +} + + +void ModemCommands::slotCancel() { + reject(); +} + +//#include "modemcmds.moc" diff --git a/noncore/settings/networksettings/ppp/modemcmds.h b/noncore/settings/networksettings/ppp/modemcmds.h new file mode 100644 index 0000000..9d078ec --- a/dev/null +++ b/noncore/settings/networksettings/ppp/modemcmds.h @@ -0,0 +1,119 @@ + +/* + * + * kPPP: A front end for pppd for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + + +#ifndef _MODEMCMDS_H_ +#define _MODEMCMDS_H_ + +#include <qgroupbox.h> +#include <qdialog.h> +#include <qlineedit.h> +#include <qpushbutton.h> +#include <qlabel.h> +#include "pppdata.h" + +class ModemCommands : public QDialog { + +Q_OBJECT + +public: + + ModemCommands(QWidget *parent=0, const char *name=0); + ~ModemCommands() {} + +private slots: + void slotCancel(); + void slotOk(); + +private: + + QGroupBox *box; + + QLineEdit *initstr[int(PPPData::NumInitStrings)]; + + QLineEdit *initresp; + QLabel *label2; + + QLabel *lpreinitslider; + QLabel *lpreinit; + + QLabel *linitslider; + QLabel *label3; + + QLabel *ldurationslider; + QLabel *lduration; + + QLineEdit *nodetectdialtone; + QLabel *lnodetectdialtone; + + QLineEdit *dialstr; + QLabel *label4; + + QLineEdit *connectresp; + QLabel *label5; + + QLineEdit *busyresp; + QLabel *label6; + + QLineEdit *nocarrierresp; + QLabel *label7; + + QLineEdit *nodialtoneresp; + QLabel *label8; + + QLineEdit *hangupstr; + QLabel *label9; + + QLineEdit *hangupresp; + QLabel *label10; + + QLineEdit *answerstr; + QLabel *label11; + + QLineEdit *ringresp; + QLabel *label12; + + QLineEdit *answerresp; + QLabel *label13; + + QLineEdit *escapestr; + QLabel *label14; + + QLineEdit *escaperesp; + QLabel *label15; + + QLabel *lslider; + QLabel *label16; + + QLineEdit *volume_off, *volume_medium, *volume_high; +}; +#endif + + + diff --git a/noncore/settings/networksettings/ppp/modeminfo.cpp b/noncore/settings/networksettings/ppp/modeminfo.cpp index 8c81e67..4dbbcf5 100644 --- a/noncore/settings/networksettings/ppp/modeminfo.cpp +++ b/noncore/settings/networksettings/ppp/modeminfo.cpp @@ -105,6 +105,7 @@ void ModemTransfer::ati_done() { ModemInfo *mi = new ModemInfo(this); for(int i = 0; i < NUM_OF_ATI; i++) mi->setAtiString(i, ati_query_strings[i]); + mi->showMaximized(); mi->exec(); delete mi; diff --git a/noncore/settings/networksettings/ppp/newwidget.cpp b/noncore/settings/networksettings/ppp/newwidget.cpp new file mode 100644 index 0000000..d2182fb --- a/dev/null +++ b/noncore/settings/networksettings/ppp/newwidget.cpp @@ -0,0 +1,17 @@ +///////////////////////////////////////////////////////////////////////////// +// +// functions generating layout-aware widgets +// +///////////////////////////////////////////////////////////////////////////// + +#include "newwidget.h" + +QLineEdit *newLineEdit(int visiblewidth, QWidget *parent) { + QLineEdit *l = new QLineEdit(parent); + if(visiblewidth == 0) + l->setMinimumWidth(l->sizeHint().width()); + else + l->setFixedWidth(l->fontMetrics().width('H') * visiblewidth); + + return l; +} diff --git a/noncore/settings/networksettings/ppp/newwidget.h b/noncore/settings/networksettings/ppp/newwidget.h new file mode 100644 index 0000000..52f2ec7 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/newwidget.h @@ -0,0 +1,19 @@ +///////////////////////////////////////////////////////////////////////////// +// +// functions generating layout-aware widgets +// +///////////////////////////////////////////////////////////////////////////// + +#ifndef __NEWWIDGET__H__ +#define __NEWWIDGET__H__ + +#include <qwidget.h> +#include <qlineedit.h> + +#define L_FIXEDW 1 +#define L_FIXEDH 2 +#define L_FIXED (L_FIXEDW | L_FIXEDH) + +QLineEdit *newLineEdit(int visiblewidth, QWidget *parent); + +#endif diff --git a/noncore/settings/networksettings/ppp/ppp.pro b/noncore/settings/networksettings/ppp/ppp.pro index da32395..a456427 100644 --- a/noncore/settings/networksettings/ppp/ppp.pro +++ b/noncore/settings/networksettings/ppp/ppp.pro @@ -1,14 +1,15 @@ #TEMPLATE = app +# TEMPLATE = lib #CONFIG += qt warn_on release CONFIG += qt warn_on debug DESTDIR = $(OPIEDIR)/plugins/networksettings -HEADERS = pppimp.h pppmodule.h devices.h modem.h modeminfo.h pppdata.h kpppconfig.h pppdata.h runtests.h -SOURCES = pppimp.cpp pppmodule.cpp modem.cpp modeminfo.cpp pppdata.cpp runtests.cpp +HEADERS = pppmodule.h devices.h modem.h modeminfo.h pppdata.h kpppconfig.h pppdata.h runtests.h general.h modemcmds.h knuminput.h knumvalidator.h kpppwidget.h conwindow.h debug.h accounts.h connect.h edit.h scriptedit.h pppdargs.h newwidget.h iplined.h pwentry.h pppconfig.h +SOURCES = pppmodule.cpp modem.cpp modeminfo.cpp pppdata.cpp runtests.cpp general.cpp modemcmds.cpp knuminput.cpp knumvalidator.cpp kpppwidget.cpp conwindow.cpp debug.cpp accounts.cpp connect.cpp edit.cpp scriptedit.cpp pppdargs.cpp newwidget.cpp iplined.cpp pwentry.cpp pppconfig.cpp INCLUDEPATH += $(OPIEDIR)/include ../ ../interfaces/ DEPENDPATH += $(OPIEDIR)/include LIBS += -lqpe -L../interfaces/ -linterfaces -INTERFACES = ppp.ui +INTERFACES = TARGET = pppplugin VERSION = 1.0.0 diff --git a/noncore/settings/networksettings/ppp/pppconfig.cpp b/noncore/settings/networksettings/ppp/pppconfig.cpp new file mode 100644 index 0000000..7b2b21b --- a/dev/null +++ b/noncore/settings/networksettings/ppp/pppconfig.cpp @@ -0,0 +1,62 @@ + +#include <qlayout.h> +#include <qmessagebox.h> +#include <qtabwidget.h> + +#include "accounts.h" +#include "general.h" +#include "pppconfig.h" +#include "pppdata.h" +#include "runtests.h" +#include "modem.h" + +PPPConfigWidget::PPPConfigWidget( QWidget *parent, const char *name, + bool modal, WFlags fl ) + : QDialog(parent, name, modal, fl) +{ + setCaption(tr("Configure Modem")); + int result = runTests(); + if(result == TEST_CRITICAL){ + QMessageBox::critical(0, tr("Modem failure"), tr("A critical failure appeard while testing the modem") ); + return; + } + +// setFixedSize(sizeHint()); + + (void)new Modem; + + QVBoxLayout *layout = new QVBoxLayout( this ); + layout->setSpacing( 0 ); + layout->setMargin( 1 ); + tabWindow = new QTabWidget( this, "tabWidget" ); + layout->addWidget( tabWindow ); + + accounts = new AccountWidget( tabWindow, "accounts" ); + tabWindow->addTab( accounts, tr("&Accounts") ); + modem1 = new ModemWidget( tabWindow, "modem1" ); + tabWindow->addTab( modem1, tr("&Device") ); + modem2 = new ModemWidget2( tabWindow, "modem2" ); + tabWindow->addTab( modem2, tr("&Modem") ); +// graph = new GraphSetup( tabWindow->addPage( tr("&Graph"), tr("Throughput Graph" ) ) ); +// general = new GeneralWidget( tabWindow->addPage( tr("M&isc"), tr("Miscellaneous Settings") ) ); + +} + + +PPPConfigWidget::~PPPConfigWidget() +{ + +} + +void PPPConfigWidget::accept() +{ + gpppdata.save(); + QDialog::accept(); +} + + +void PPPConfigWidget::reject() +{ + gpppdata.cancel(); + QDialog::reject(); +} diff --git a/noncore/settings/networksettings/ppp/pppconfig.h b/noncore/settings/networksettings/ppp/pppconfig.h new file mode 100644 index 0000000..ec64878 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/pppconfig.h @@ -0,0 +1,34 @@ +#ifndef _PPPCONFIG_H_ +#define _PPPCONFIG_H_ + +#include <qdialog.h> + +class QTabWidget; +class AccountWidget; +class GeneralWidget; +class ModemWidget; +class ModemWidget2; + +class PPPConfigWidget : public QDialog { + Q_OBJECT +public: + + PPPConfigWidget( QWidget *parent=0, const char *name=0, + bool modal = false, WFlags fl = 0 ); + ~PPPConfigWidget(); + + +protected slots: + virtual void accept(); + virtual void reject(); + + private: + QTabWidget *tabWindow; + AccountWidget *accounts; + GeneralWidget *general; + ModemWidget *modem1; + ModemWidget2 *modem2; +}; + + +#endif diff --git a/noncore/settings/networksettings/ppp/pppdargs.cpp b/noncore/settings/networksettings/ppp/pppdargs.cpp new file mode 100644 index 0000000..04d0dd0 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/pppdargs.cpp @@ -0,0 +1,166 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <qlayout.h> +#include <qbuttongroup.h> +//#include <kwin.h> +#include <qapplication.h> +#include "pppdargs.h" +#include "pppdata.h" +//#include <klocale.h> +#define i18n QObject::tr + +PPPdArguments::PPPdArguments(QWidget *parent, const char *name) + : QDialog(parent, name, TRUE) +{ + setCaption(i18n("Customize pppd Arguments")); +// KWin::setIcons(winId(), kapp->icon(), kapp->miniIcon()); + QVBoxLayout *l = new QVBoxLayout(this, 10, 10); + QHBoxLayout *tl = new QHBoxLayout(10); + l->addLayout(tl); + QVBoxLayout *l1 = new QVBoxLayout(); + QVBoxLayout *l2 = new QVBoxLayout(); + tl->addLayout(l1, 1); + tl->addLayout(l2, 0); + + QHBoxLayout *l11 = new QHBoxLayout(10); + l1->addLayout(l11); + + argument_label = new QLabel(i18n("Argument:"), this); + l11->addWidget(argument_label); + + argument = new QLineEdit(this); + connect(argument, SIGNAL(returnPressed()), + SLOT(addbutton())); + l11->addWidget(argument); + connect(argument, SIGNAL(textChanged(const QString &)), + this, SLOT(textChanged(const QString &))); + + arguments = new QListBox(this); + arguments->setMinimumSize(1, fontMetrics().lineSpacing()*10); + connect(arguments, SIGNAL(highlighted(int)), + this, SLOT(itemSelected(int))); + l1->addWidget(arguments, 1); + + add = new QPushButton(i18n("Add"), this); + connect(add, SIGNAL(clicked()), SLOT(addbutton())); + l2->addWidget(add); + l2->addStretch(1); + + remove = new QPushButton(i18n("Remove"), this); + connect(remove, SIGNAL(clicked()), SLOT(removebutton())); + l2->addWidget(remove); + + defaults = new QPushButton(i18n("Defaults"), this); + connect(defaults, SIGNAL(clicked()), SLOT(defaultsbutton())); + l2->addWidget(defaults); + + l->addSpacing(5); + + QButtonGroup *bbox = new QButtonGroup(this); +// bbox->addStretch(1); + closebtn = new QPushButton( bbox, i18n("OK")); + bbox->insert(closebtn); + connect(closebtn, SIGNAL(clicked()), SLOT(closebutton())); + QPushButton *cancel = new QPushButton( bbox, i18n("Cancel")); + bbox->insert(cancel); + connect(cancel, SIGNAL(clicked()), + this, SLOT(reject())); + bbox->layout(); + l->addWidget(bbox); + + setFixedSize(sizeHint()); + + //load info from gpppdata + init(); + + add->setEnabled(false); + remove->setEnabled(false); + argument->setFocus(); +} + + +void PPPdArguments::addbutton() { + if(!argument->text().isEmpty() && arguments->count() < MAX_PPPD_ARGUMENTS) { + arguments->insertItem(argument->text()); + argument->setText(""); + } +} + + +void PPPdArguments::removebutton() { + if(arguments->currentItem() >= 0) + arguments->removeItem(arguments->currentItem()); +} + + +void PPPdArguments::defaultsbutton() { + // all of this is a hack + // save current list + QStringList arglist(gpppdata.pppdArgument()); + + // get defaults + gpppdata.setpppdArgumentDefaults(); + init(); + + // restore old list + gpppdata.setpppdArgument(arglist); +} + + +void PPPdArguments::closebutton() { + QStringList arglist; + for(uint i=0; i < arguments->count(); i++) + arglist.append(arguments->text(i)); + gpppdata.setpppdArgument(arglist); + + done(0); +} + + +void PPPdArguments::init() { + while(arguments->count()) + arguments->removeItem(0); + + QStringList &arglist = gpppdata.pppdArgument(); + for ( QStringList::Iterator it = arglist.begin(); + it != arglist.end(); + ++it ) + arguments->insertItem(*it); +} + + +void PPPdArguments::textChanged(const QString &s) { + add->setEnabled(s.length() > 0); +} + + +void PPPdArguments::itemSelected(int idx) { + remove->setEnabled(idx != -1); +} + + diff --git a/noncore/settings/networksettings/ppp/pppdargs.h b/noncore/settings/networksettings/ppp/pppdargs.h new file mode 100644 index 0000000..c1cd28d --- a/dev/null +++ b/noncore/settings/networksettings/ppp/pppdargs.h @@ -0,0 +1,76 @@ +/* + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _PPPDARGS_H_ +#define _PPPDARGS_H_ + +#include <qdialog.h> +#include <qlineedit.h> +#include <qpushbutton.h> +#include <qlistbox.h> +#include <qlabel.h> + +class PPPdArguments : public QDialog { +Q_OBJECT +public: + PPPdArguments(QWidget *parent=0, const char *name=0); + ~PPPdArguments() {} + +private slots: + void addbutton(); + void removebutton(); + void defaultsbutton(); + void closebutton(); + void textChanged(const QString &); + void itemSelected(int); + +private: + void init(); + + QLabel *argument_label; + + QLineEdit *argument; + + QPushButton *add; + QPushButton *remove; + QPushButton *defaults; + + QListBox *arguments; + + QPushButton *closebtn; +}; +#endif + + + + + + + + + + diff --git a/noncore/settings/networksettings/ppp/pppmodule.cpp b/noncore/settings/networksettings/ppp/pppmodule.cpp index 40d2455..d6ca88a 100644 --- a/noncore/settings/networksettings/ppp/pppmodule.cpp +++ b/noncore/settings/networksettings/ppp/pppmodule.cpp @@ -1,5 +1,7 @@ +#include "pppconfig.h" #include "pppmodule.h" -#include "pppimp.h" +//#include "pppimp.h" +#include "kpppwidget.h" #include "interfaceinformationimp.h" //#include "devices.h" @@ -53,7 +55,8 @@ bool PPPModule::isOwner(Interface *i){ * @return QWidget* pointer to this modules configure. */ QWidget *PPPModule::configure(Interface *i){ - PPPConfigureImp *pppconfig = new PPPConfigureImp(0, "PPPConfig", /* i,*/ false, Qt::WDestructiveClose); + qDebug("return ModemWidget"); + PPPConfigWidget *pppconfig = new PPPConfigWidget( 0, "PPPConfig", false, Qt::WDestructiveClose ); // pppconfig->setProfile(profile); return pppconfig; } @@ -65,6 +68,7 @@ QWidget *PPPModule::configure(Interface *i){ QWidget *PPPModule::information(Interface *i){ // We don't have any advanced pppd information widget yet :-D // TODO ^ + qDebug("return PPPModule::information"); InterfaceInformationImp *information = new InterfaceInformationImp(0, "InterfaceSetupImp", i); return information; } @@ -86,9 +90,10 @@ QList<Interface> PPPModule::getInterfaces(){ * @return Interface* NULL if it was unable to be created. */ Interface *PPPModule::addNewInterface(const QString &newInterface){ - // If the + qDebug("try to add iface %s",newInterface.latin1()); - PPPConfigureImp imp(0, "PPPConfigImp"); + + PPPConfigWidget imp(0, "PPPConfigImp", true); imp.showMaximized(); if(imp.exec() == QDialog::Accepted ){ qDebug("ACCEPTED"); diff --git a/noncore/settings/networksettings/ppp/pwentry.cpp b/noncore/settings/networksettings/ppp/pwentry.cpp new file mode 100644 index 0000000..842dc87 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/pwentry.cpp @@ -0,0 +1,116 @@ +/* + * + * Kppp: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + + +#include <stdio.h> +#include <qapplication.h> +#include "pwentry.h" + +PWEntry::PWEntry( QWidget *parent, const char *name ) + : QWidget(NULL, name) { + + if(parent){ + + QPoint point = this->mapToGlobal (QPoint (0,0)); + QRect pos = this->geometry(); + + setGeometry(point.x() + pos.width()/2 - 300/2, + point.y() + pos.height()/2 - 90/2, + 300, + 90); + } +// else{ +// int scnum = QApplication::desktop()->screenNumber(parent); +// QRect desk = QApplication::desktop()->screenGeometry(scnum); +// setGeometry( desk.center().x() - 150, desk.center().y() - 50, 300, 90 ); +// } + + frame = new QGroupBox(name, this ); + + this->setFocusPolicy( QWidget::StrongFocus ); + + pw = new QLineEdit( this, "le" ); + pw->setEchoMode( QLineEdit::Password ); + connect( pw, SIGNAL(returnPressed()), this, SLOT(hide()) ); + + isconsumed = TRUE; +} + +QString PWEntry::text() { return (pw->text()); } + +void PWEntry::focusInEvent( QFocusEvent *){ + + pw->setFocus(); + +} + +void PWEntry::setEchoModeNormal() { + + pw->setEchoMode(QLineEdit::Normal); + +} + +void PWEntry::setEchoModePassword() { + + pw->setEchoMode(QLineEdit::Password); + +} + +void PWEntry::setPrompt(const QString &p) { + + frame->setTitle(p); + +} + +void PWEntry::resizeEvent(QResizeEvent* ){ + + pw->setGeometry( 15,35, this->width() - 30, 25 ); + frame->setGeometry(5,5,this->width() - 10, this->height() - 10 ); + +} + + +void PWEntry::show() { + + pw->setText(""); + isconsumed = FALSE; + QWidget::show(); +} + +bool PWEntry::Consumed() { + return(isconsumed); +} + +void PWEntry::setConsumed() { + isconsumed = TRUE; +} + +void PWEntry::hide() { + QWidget::hide(); + return; +} + +//#include "pwentry.moc" diff --git a/noncore/settings/networksettings/ppp/pwentry.h b/noncore/settings/networksettings/ppp/pwentry.h new file mode 100644 index 0000000..4a5e554 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/pwentry.h @@ -0,0 +1,72 @@ +/* + * + * kPPP: A pppd front end for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef PWENTRY_H +#define PWENTRY_H + +#include <qwidget.h> +#include <qlineedit.h> +#include <qlabel.h> +#include <qgroupbox.h> + +class PWEntry : public QWidget { + + Q_OBJECT + +public: + + PWEntry( QWidget *parent=0, const char *name=0 ); + bool Consumed(); + void setConsumed(); + QString text(); + void setPrompt(const QString &); + +public slots: + + void setEchoModeNormal(); + void setEchoModePassword(); + void hide(); + void show(); + +signals: + + void returnPressed(); + +protected: + + void resizeEvent(QResizeEvent* qre); + void focusInEvent( QFocusEvent *); + +private: + + QGroupBox *frame; + QLineEdit *pw; + QLabel *pl; + bool isconsumed; + +}; + +#endif diff --git a/noncore/settings/networksettings/ppp/scriptedit.cpp b/noncore/settings/networksettings/ppp/scriptedit.cpp new file mode 100644 index 0000000..b8afad5 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/scriptedit.cpp @@ -0,0 +1,174 @@ + +/* + * kPPP: A front end for pppd for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "scriptedit.h" +#include <qlayout.h> +#include <qcombobox.h> +#include <qlineedit.h> + +ScriptEdit::ScriptEdit( QWidget *parent, const char *name ) + : QWidget(parent, name) +{ + QHBoxLayout *tl = new QHBoxLayout(this, 0, 10); + + st = new QComboBox(this, "st"); + st->insertItem("Expect"); + st->insertItem("Send"); + st->insertItem("Pause (sec)"); + st->insertItem("Hangup"); + st->insertItem("Answer"); + st->insertItem("Timeout (sec)"); + st->insertItem("Password"); + st->insertItem("ID"); + st->insertItem("Prompt"); + st->insertItem("PWPrompt"); + st->insertItem("LoopStart"); + st->insertItem("LoopEnd"); + st->insertItem("Scan"); + st->insertItem("Save"); + st->insertItem("SendNoEcho"); + connect(st, SIGNAL(activated(int)), SLOT(setType(int))); + + se = new QLineEdit(this, "se"); + se->setGeometry(120, 5, 140, 25); + se->setMaxLength(50); + connect(se, SIGNAL(returnPressed()), SLOT(seReturnPressed())); + + tl->addWidget(st, 3); + tl->addWidget(se, 7); + + setType(0); + + tl->activate(); +} + + +void ScriptEdit::setEnabled(bool b) { + se->setEnabled(b); + st->setEnabled(b); +} + +void ScriptEdit::seReturnPressed() { + emit returnPressed(); +} + + +QString ScriptEdit::text() { + return se->text(); +} + +void ScriptEdit::setText(const QString &t) { + se->setText(t); +} + + +int ScriptEdit::type() { + return st->currentItem(); +} + +void ScriptEdit::setType(int i) { + switch(i) { + case Expect: + se->setText(""); + se->setEnabled(TRUE); + break; + + case Send: + se->setText(""); + se->setEnabled(TRUE); + break; + + case Pause: + se->setText(""); + se->setEnabled(TRUE); + break; + + case Hangup: + se->setText(""); + se->setEnabled(FALSE); + break; + + case Answer: + se->setText(""); + se->setEnabled(FALSE); + break; + + case Timeout: + se->setText(""); + se->setEnabled(TRUE); + break; + + case Password: + se->setText(""); + se->setEnabled(TRUE); + break; + + case ID: + se->setText(""); + se->setEnabled(TRUE); + break; + + case Prompt: + se->setText(""); + se->setEnabled(TRUE); + break; + + case PWPrompt: + se->setText(""); + se->setEnabled(TRUE); + break; + + case LoopStart: + se->setText(""); + se->setEnabled(TRUE); + break; + + case LoopEnd: + se->setText(""); + se->setEnabled(TRUE); + break; + + case Scan: + se->setText(""); + se->setEnabled(TRUE); + break; + + case Save: + se->setText("password"); + se->setEnabled(FALSE); + break; + + default: break; + } +} + + + + + + + diff --git a/noncore/settings/networksettings/ppp/scriptedit.h b/noncore/settings/networksettings/ppp/scriptedit.h new file mode 100644 index 0000000..47565b8 --- a/dev/null +++ b/noncore/settings/networksettings/ppp/scriptedit.h @@ -0,0 +1,79 @@ + +/* + * kPPP: A front end for pppd for the KDE project + * + * $Id$ + * + * Copyright (C) 1997 Bernd Johannes Wuebben + * wuebben@math.cornell.edu + * + * based on EzPPP: + * Copyright (C) 1997 Jay Painter + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SCRIPTEDIT_H_ +#define _SCRIPTEDIT_H_ + +#include <qwidget.h> + +class QComboBox; +class QLineEdit; + +class ScriptEdit : public QWidget { +Q_OBJECT +public: + ScriptEdit( QWidget *parent=0, const char *name=0 ); + ~ScriptEdit() {} + + QString text(); + void setText(const QString &); + int type(); + + virtual void setEnabled(bool); + +signals: + void returnPressed(); + +private slots: + void setType(int); + void seReturnPressed(); + +private: + QComboBox *st; + QLineEdit *se; + +public: + enum setypes { Expect = 0, + Send = 1, + Pause = 2, + Hangup = 3, + Answer = 4, + Timeout = 5, + Password = 6, + ID = 7, + Prompt = 8, + PWPrompt = 9, + LoopStart = 10, + LoopEnd = 11, + Scan = 12, + Save = 13, + SendNoEcho = 14 + }; +}; + +#endif + |