- add modem layer so dialer can be used within Connect

4 files changed, 13 insertions, 5 deletions

diff --git a/noncore/apps/opie-console/default.cpp b/noncore/apps/opie-console/default.cpp
index ce5c870..5c1c05a 100644
--- a/noncore/apps/opie-console/default.cpp
+++ b/noncore/apps/opie-console/default.cpp
@@ -1,100 +1,105 @@
 #include "io_serial.h"
 #include "io_irda.h"
 #include "io_bt.h"
+#include "io_modem.h"
 #include "filetransfer.h"
 #include "filereceive.h"
 #include "serialconfigwidget.h"
 #include "irdaconfigwidget.h"
 #include "btconfigwidget.h"
 #include "modemconfigwidget.h"
 #include "terminalwidget.h"
 #include "vt102emulation.h"
 
 #include "default.h"
 
 extern "C" {
     // FILE Transfer Stuff
     FileTransferLayer* newSZTransfer(IOLayer* lay) {
         return new FileTransfer( FileTransfer::SZ, lay );
     }
     FileTransferLayer* newSYTransfer(IOLayer* lay) {
         return new FileTransfer( FileTransfer::SY, lay );
     }
     FileTransferLayer* newSXTransfer(IOLayer* lay) {
         return new FileTransfer(FileTransfer ::SX, lay );
     }
 
     // FILE Transfer Receive Stuff
     ReceiveLayer* newSZReceive(IOLayer* lay) {
         return new FileReceive( FileReceive::SZ, lay );
     }
     ReceiveLayer* newSYReceive(IOLayer* lay) {
         return new FileReceive( FileReceive::SY, lay );
     }
     ReceiveLayer* newSXReceive(IOLayer* lay) {
         return new FileReceive(FileReceive::SX, lay );
     }
 
     // Layer stuff
     IOLayer* newSerialLayer( const Profile& prof) {
         return new IOSerial( prof );
     }
     IOLayer* newBTLayer( const Profile& prof ) {
         return new IOBt( prof );
     }
     IOLayer* newIrDaLayer( const Profile& prof ) {
         return new IOIrda( prof );
     }
+    IOLayer* newModemLayer( const Profile& prof ) {
+        return new IOModem( prof );
+    }
 
     // Connection Widgets
     ProfileDialogWidget* newSerialWidget( const QString& str, QWidget* wid ) {
         return new SerialConfigWidget( str, wid );
     }
     ProfileDialogWidget* newIrDaWidget( const QString& str, QWidget* wid ) {
         return new IrdaConfigWidget( str, wid );
     }
     ProfileDialogWidget* newModemWidget( const QString& str, QWidget* wid ) {
         return new ModemConfigWidget(str, wid );
     }
     ProfileDialogWidget* newBTWidget( const QString& str, QWidget* wid ) {
         return new BTConfigWidget(str, wid );
     }
 
 
     // Terminal Widget(s)
 /*    ProfileDialogWidget* newTerminalWidget(const QString& na, QWidget* wid) {
         return new TerminalWidget(na, wid,0 );
     }
 */
 /*    // VT Emulations
     EmulationLayer* newVT102( WidgetLayer* wid ) {
         return new Vt102Emulation( wid );
     }
 */
 };
 
 Default::Default( MetaFactory* fact ) {
     fact->addFileTransferLayer( "SZ", QObject::tr("Z-Modem"), newSZTransfer );
     fact->addFileTransferLayer( "SY", QObject::tr("Y-Modem"), newSYTransfer );
     fact->addFileTransferLayer( "SX", QObject::tr("X-Modem"), newSXTransfer );
 
     fact->addReceiveLayer( "SZ", QObject::tr("Z-Modem"), newSZReceive );
     fact->addReceiveLayer( "SY", QObject::tr("Y-Modem"), newSYReceive );
     fact->addReceiveLayer( "SX", QObject::tr("X-Modem"), newSXReceive );
 
     fact->addIOLayerFactory( "serial", QObject::tr("Serial"), newSerialLayer );
     fact->addIOLayerFactory( "irda", QObject::tr("Infrared"), newIrDaLayer   );
     fact->addIOLayerFactory( "bt", QObject::tr("Bluetooth"),  newBTLayer     );
+    fact->addIOLayerFactory( "modem", QObject::tr("Modem"),   newModemLayer  );
 
     fact->addConnectionWidgetFactory( "serial", QObject::tr("Serial"), newSerialWidget );
     fact->addConnectionWidgetFactory( "irda", QObject::tr("Infrared"), newIrDaWidget );
     fact->addConnectionWidgetFactory( "modem", QObject::tr("Modem"), newModemWidget );
     fact->addConnectionWidgetFactory( "bt", QObject::tr("Bluetooth"), newBTWidget );
 
 //    fact->addTerminalWidgetFactory( "default", QObject::tr("Default Terminal"),  newTerminalWidget );
 
 //    fact->addEmulationLayer( "default", QObject::tr("Default Terminal"), newVT102 );
 }
 Default::~Default() {
 
 }
diff --git a/noncore/apps/opie-console/dialer.cpp b/noncore/apps/opie-console/dialer.cpp
index d20965a..90e2b6c 100644
--- a/noncore/apps/opie-console/dialer.cpp
+++ b/noncore/apps/opie-console/dialer.cpp
@@ -1,150 +1,149 @@
 #include "dialer.h"
 
 #include <qlayout.h>
 #include <qprogressbar.h>
 #include <qlabel.h>
 #include <qpushbutton.h>
 #include <qapp.h>
 #include <qtimer.h>
 
 #include <unistd.h>
 #include <string.h>
 
 // State machine:          | When an error occurs, we don't have to
 //                         | reset everything.
 // (init) <------+         | But if the user wants to reset,
 //   |           |         | we stop dialing immediately.
 //   v           |         |
 // (options) ----+         | Following the state machine is necessary
 //   |       \             | to get determinable results.
 //   v        ^            |
 // (dial) ----+            |
 //   |        ^            |
 //   v        |            |
 // (online) --+            |
 //   |                     |
 //   v                     |
 
 
 // from atconfigdialog
 //initStringLine->setText( config.readEntry("InitString", MODEM_DEFAULT_INIT_STRING ) );
 //resetStringLine->setText( config.readEntry("ResetString", MODEM_DEFAULT_RESET_STRING ) );
 //dialPref1Line->setText( config.readEntry("DialPrefix1", MODEM_DEFAULT_DIAL_PREFIX1 ) );
 //dialSuf1Line->setText( config.readEntry("DialSuffix1", MODEM_DEFAULT_DIAL_SUFFIX1 ) );
 //dialPref2Line->setText( config.readEntry("DialPrefix2", MODEM_DEFAULT_DIAL_PREFIX1 ) );
 //dialSuf2Line->setText( config.readEntry("DialSuffix2", MODEM_DEFAULT_DIAL_SUFFIX1 ) );
 //dialPref3Line->setText( config.readEntry("DialPrefix3", MODEM_DEFAULT_DIAL_PREFIX1 ) );
 //dialSuf3Line->setText( config.readEntry("DialSuffix3", MODEM_DEFAULT_DIAL_SUFFIX1 ) );
 //connectLine->setText( config.readEntry("DefaultConnect" MODEM_DEFAULT_CONNECT_STRING ) );
 //hangupLine->setText( config.readEntry("HangupString", MODEM_DEFAULT_HANGUP_STRING ) );
 
 // from modemconfigwidget
 //int rad_flow = prof.readNumEntry("Flow");
 //int rad_parity = prof.readNumEntry("Parity");
 //int speed = prof.readNumEntry("Speed");
 //QString number = prof.readEntry("Number");
 
 Dialer::Dialer(const Profile& profile, QWidget *parent, const char *name)
-: QDialog(parent, name, true)
+: QDialog(parent, name, true), m_profile(profile)
 {
 	QVBoxLayout *vbox;
 	QLabel *desc;
 
 	usercancel = 0;
-	m_profile = profile;
 
 	desc = new QLabel(QObject::tr("Dialing number: %1").arg(m_profile.readEntry("Number")), this);
 	progress = new QProgressBar(this);
 	status = new QLabel("", this);
 	status->setFrameStyle(QFrame::Panel | QFrame::Sunken);
 	cancel = new QPushButton(QObject::tr("Cancel"), this);
 
 	vbox = new QVBoxLayout(this, 2);
 	vbox->add(desc);
 	vbox->add(progress);
 	vbox->add(status);
 	vbox->add(cancel);
 
 	connect(cancel, SIGNAL(clicked()), SLOT(slotCancel()));
 
 	show();
 
 	QTimer::singleShot(500, this, SLOT(slotAutostart()));
 }
 
 Dialer::~Dialer()
 {
 }
 
 void Dialer::slotCancel()
 {
 	if(state != state_online)
 	{
 		usercancel = 1;
 		reset();
 	}
 	else accept();
 }
 
 void Dialer::reset()
 {
 	switchState(state_cancel);
 }
 
 void Dialer::slotAutostart()
 {
 	state = state_preinit;
 	dial(m_profile.readEntry("Number"));
 }
 
 void Dialer::dial(const QString& number)
 {
 	while(state != state_online)
 	{
 		if(!usercancel)
 		{
 			trydial(number);
 		}
 		else break;
 	}
 
 	if(usercancel)
 	{
 		reject();
 	}
 }
 
 void Dialer::trydial(const QString& number)
 {
 	if(state != state_cancel)
 	{
 		switchState(state_preinit);
 		// ...
 		QString response = receive();
 	}
 
 	if(state != state_cancel)
 	{
 		switchState(state_init);
 		send("ATZ");
 		QString response2 = receive();
 	}
 
 	if(state != state_cancel)
 	{
 		switchState(state_options);
 
 		send("ATM0L0");
 		QString response3 = receive();
 	}
 
 	if(state != state_cancel)
 	{
 		switchState(state_dialtone);
 
 		send("ATX1");
 		QString response4 = receive();
 	}
 
 	if(state != state_cancel)
 	{
diff --git a/noncore/apps/opie-console/dialer.h b/noncore/apps/opie-console/dialer.h
index 8c83bb6..09cc5ca 100644
--- a/noncore/apps/opie-console/dialer.h
+++ b/noncore/apps/opie-console/dialer.h
@@ -1,51 +1,51 @@
 #ifndef DIALER_H
 #define DIALER_H
 
 #include <qdialog.h>
 
 #include "profile.h"
 
 class QLabel;
 class QProgressBar;
 
 class Dialer : public QDialog
 {
 	Q_OBJECT
 	public:
 		Dialer(const Profile& profile, QWidget *parent = NULL, const char *name = NULL);
 		~Dialer();
 
 	public slots:
 		void slotCancel();
 		void slotAutostart();
 
 	private:
 		void switchState(int newstate);
 		void reset();
 		void dial(const QString& number);
 		void trydial(const QString& number);
 
 		void send(const QString& msg);
 		QString receive();
 
 		enum States
 		{
 			state_cancel,
 			state_preinit,
 			state_init,
 			state_options,
 			state_dialtone,
 			state_dialing,
 			state_online
 		};
 
 		QLabel *status;
 		QProgressBar *progress;
 		QPushButton *cancel;
 		int state;
 		int usercancel;
-		Profile m_profile;
+		const Profile& m_profile;
 };
 
 #endif
 
diff --git a/noncore/apps/opie-console/io_modem.cpp b/noncore/apps/opie-console/io_modem.cpp
index 56147d8..28d1722 100644
--- a/noncore/apps/opie-console/io_modem.cpp
+++ b/noncore/apps/opie-console/io_modem.cpp
@@ -1,75 +1,79 @@
 
 #include "io_modem.h"
 
 #include "dialer.h"
 
 IOModem::IOModem( const Profile &profile )
 	: IOSerial( profile ),  m_profile( profile ) {
 }
 
 
 IOModem::~IOModem() {
 
 }
 
 
 void IOModem::close() {
 
     IOSerial::close();
 
 }
 
 bool IOModem::open() {
-	qWarning("IOModem::open");
-    IOSerial::open();
+    bool ret = IOSerial::open();
+	if(!ret) return false;
+
+	qWarning("IOModem::open continues...");
 
 	Dialer d(m_profile);
+	qWarning("dialer created");
+
 	int result = d.exec();
 	if(result == QDialog::Accepted)
 	{
 		return true;
 	}
 	else return false;
 }
 
 void IOModem::reload( const Profile &config ) {
     m_device = config.readEntry("Device", MODEM_DEFAULT_DEVICE);
     m_baud = config.readNumEntry("Baud", MODEM_DEFAULT_BAUD);
     m_parity = config.readNumEntry("Parity", MODEM_DEFAULT_PARITY);
     m_dbits = config.readNumEntry("DataBits", MODEM_DEFAULT_DBITS);
     m_sbits = config.readNumEntry("StopBits", MODEM_DEFAULT_SBITS);
     m_flow = config.readNumEntry("Flow", MODEM_DEFAULT_FLOW);
 
     m_initString = config.readEntry("InitString", MODEM_DEFAULT_INIT_STRING );
     m_resetString = config.readEntry("ResetString", MODEM_DEFAULT_RESET_STRING );
     m_dialPref1 = config.readEntry("DialPrefix1", MODEM_DEFAULT_DIAL_PREFIX1 );
     m_dialSuf1 = config.readEntry("DialSuffix1", MODEM_DEFAULT_DIAL_SUFFIX1 );
     m_dialPref2 = config.readEntry("DialPrefix2", MODEM_DEFAULT_DIAL_PREFIX1 );
     m_dialSuf2 = config.readEntry("DialSuffix2", MODEM_DEFAULT_DIAL_SUFFIX1 );
     m_dialPref3 = config.readEntry("DialPrefix3", MODEM_DEFAULT_DIAL_PREFIX1 );
     m_dialSuf3 = config.readEntry("DialSuffix3", MODEM_DEFAULT_DIAL_SUFFIX1 );
     m_connect = config.readEntry("DefaultConnect" MODEM_DEFAULT_CONNECT_STRING );
     m_hangup = config.readEntry("HangupString", MODEM_DEFAULT_HANGUP_STRING );
     m_cancel = config.readEntry("CancelString", MODEM_DEFAULT_CANCEL_STRING );
     m_dialTime = config.readNumEntry("DialTime", MODEM_DEFAULT_DIAL_TIME );
     m_delayRedial = config.readNumEntry("DelayRedial", MODEM_DEFAULT_DELAY_REDIAL );
     m_numberTries = config.readNumEntry("NumberTries", MODEM_DEFAULT_NUMBER_TRIES );
     m_dtrDropTime = config.readNumEntry("DTRDRopTime", MODEM_DEFAULT_DTR_DROP_TIME );
     m_bpsDetect = config.readBoolEntry("BPSDetect", MODEM_DEFAULT_BPS_DETECT );
     m_dcdLines = config.readBoolEntry("DCDLines", MODEM_DEFAULT_DCD_LINES );
     m_multiLineUntag = config.readBoolEntry("MultiLineUntag", MODEM_DEFAULT_MULTI_LINE_UNTAG );
 }
 
 
 QString IOModem::identifier() const {
     return "modem";
 }
 
 QString IOModem::name() const {
     return "Modem IO Layer";
 }
 
 void IOModem::slotExited(OProcess* proc ){
     close();
 }