- implement better state machine, with explanation

- command order as used in kppp's connect.cpp

2 files changed, 109 insertions, 19 deletions

diff --git a/noncore/apps/opie-console/dialer.cpp b/noncore/apps/opie-console/dialer.cpp
index f6758ed..8589d14 100644
--- a/noncore/apps/opie-console/dialer.cpp
+++ b/noncore/apps/opie-console/dialer.cpp
@@ -1,106 +1,189 @@
 #include "dialer.h"
 
 #include <qlayout.h>
 #include <qprogressbar.h>
 #include <qlabel.h>
 #include <qpushbutton.h>
 #include <qapp.h>
+#include <qtimer.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                     |
 
 Dialer::Dialer(const QString& number, QWidget *parent, const char *name)
 : QDialog(parent, name, true)
 {
         QVBoxLayout *vbox;
         QLabel *desc;
 
+        usercancel = 0;
+        m_number = number;
+
         desc = new QLabel(QObject::tr("Dialing number: %1").arg(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);
 
-        reset();
-
         connect(cancel, SIGNAL(clicked()), SLOT(slotCancel()));
 
         show();
 
-        dial(number);
+        QTimer::singleShot(500, this, SLOT(slotAutostart()));
 }
 
 Dialer::~Dialer()
 {
 }
 
 void Dialer::slotCancel()
 {
         if(state != state_online) reset();
-        close();
+        else accept();
 }
 
 void Dialer::reset()
 {
-        switchState(state_init);
+        switchState(state_cancel);
+        usercancel = 1;
+}
+
+void Dialer::slotAutostart()
+{
+        state = state_preinit;
+        dial(m_number);
 }
 
 void Dialer::dial(const QString& number)
 {
-        send("ATZ");
-        QString response = receive();
+        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();
+        }
 
-        switchState(state_options);
+        if(state != state_cancel)
+        {
+                switchState(state_options);
 
-        send("ATM0L0");
-        QString response2 = receive();
+                send("ATM0L0");
+                QString response3 = receive();
+        }
 
-        switchState(state_dialing);
+        if(state != state_cancel)
+        {
+                switchState(state_dialtone);
 
-        send(QString("ATDT %1").arg(number));
-        QString response3 = receive();
+                send("ATX1");
+                QString response4 = receive();
+        }
 
-        switchState(state_online);
+        if(state != state_cancel)
+        {
+                switchState(state_dialing);
+
+                send(QString("ATDT %1").arg(number));
+                QString response5 = receive();
+        }
+        
+        if(state != state_cancel)
+        {
+                switchState(state_online);
+        }
 }
 
 void Dialer::send(const QString& msg)
 {
 
 }
 
 QString Dialer::receive()
 {
-        for(int i = 0; i < 200000; i++)
+        for(int i = 0; i < 200000;i++)
                 qApp->processEvents();
         return QString::null;
 }
 
 void Dialer::switchState(int newstate)
 {
+        int oldstate = state;
         state = newstate;
 
         switch(state)
         {
+                case state_cancel:
+                        status->setText(QObject::tr("Cancelling..."));
+                        progress->setProgress(0);
+                        break;
+                case state_preinit:
+                        status->setText(QObject::tr("Searching modem"));
+                        progress->setProgress(10);
+                        break;
                 case state_init:
                         status->setText(QObject::tr("Initializing..."));
-                        progress->setProgress(10);
+                        progress->setProgress(20);
                         break;
                 case state_options:
                         status->setText(QObject::tr("Reset speakers"));
-                        progress->setProgress(20);
+                        progress->setProgress(30);
+                        break;
+                case state_dialtone:
+                        status->setText(QObject::tr("Turning off dialtone"));
+                        progress->setProgress(40);
                         break;
                 case state_dialing:
-                        status->setText(QObject::tr("Dial number"));
-                        progress->setProgress(30);
+                        if(oldstate != state_dialing) status->setText(QObject::tr("Dial number"));
+                        else status->setText(QObject::tr("Line busy, redialing number"));
+                        progress->setProgress(50);
                         break;
                 case state_online:
                         status->setText(QObject::tr("Connection established"));
                         progress->setProgress(100);
                         cancel->setText(QObject::tr("Dismiss"));
                         break;
         }
 }
 
diff --git a/noncore/apps/opie-console/dialer.h b/noncore/apps/opie-console/dialer.h
index f07f110..20fb3c3 100644
--- a/noncore/apps/opie-console/dialer.h
+++ b/noncore/apps/opie-console/dialer.h
@@ -1,42 +1,49 @@
 #ifndef DIALER_H
 #define DIALER_H
 
 #include <qdialog.h>
 
 class QLabel;
 class QProgressBar;
 
 class Dialer : public QDialog
 {
         Q_OBJECT
         public:
                 Dialer(const QString& number, 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;
+                QString m_number;
 };
 
 #endif