document statemachine/factorial example

4 files changed, 141 insertions, 26 deletions

diff --git a/doc/src/examples.qdoc b/doc/src/examples.qdoc
index 6fb903c..6603390 100644
--- a/doc/src/examples.qdoc
+++ b/doc/src/examples.qdoc
@@ -312,6 +312,7 @@
 
     \list
     \o \l{statemachine/eventtransitions}{Event Transitions}\raisedaster
+    \o \l{statemachine/factorial}{Factorial States}\raisedaster
     \o \l{statemachine/pingpong}{Ping Pong States}\raisedaster
     \o \l{statemachine/trafficlight}{Traffic Light}\raisedaster
     \o \l{statemachine/twowaybutton}{Two-way Button}\raisedaster
diff --git a/doc/src/examples/factorial.qdoc b/doc/src/examples/factorial.qdoc
new file mode 100644
index 0000000..2a72e0a
--- /dev/null
+++ b/doc/src/examples/factorial.qdoc
@@ -0,0 +1,102 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/factorial
+    \title Factorial States Example
+
+    The Factorial States example shows how to use \l{The State Machine
+    Framework} to calculate the factorial of an integer.
+
+    The statechart for calculating the factorial looks as follows:
+
+    \img factorial-example.png
+    \omit
+    \caption This is a caption
+    \endomit
+
+    In other words, the state machine calculates the factorial of 6 and prints
+    the result.
+
+    \snippet examples/statemachine/factorial/main.cpp 0
+
+    The Factorial class is used to hold the data of the computation, \c x and
+    \c fac. It also provides a signal that's emitted whenever the value of \c
+    x changes.
+
+    \snippet examples/statemachine/factorial/main.cpp 1
+
+    The FactorialLoopTransition class implements the guard (\c x > 1) and
+    calculations (\c fac = \c x * \c fac; \c x = \c x - 1) of the factorial
+    loop.
+
+    \snippet examples/statemachine/factorial/main.cpp 2
+
+    The FactorialDoneTransition class implements the guard (\c x <= 1) that
+    terminates the factorial computation. It also prints the final result to
+    standard output.
+
+    \snippet examples/statemachine/factorial/main.cpp 3
+
+    The application's main() function first creates the application object, a
+    Factorial object and a state machine.
+
+    \snippet examples/statemachine/factorial/main.cpp 4
+
+    The \c compute state is created, and the initial values of \c x and \c fac
+    are defined. A FactorialLoopTransition object is created and added to the
+    state.
+
+    \snippet examples/statemachine/factorial/main.cpp 5
+
+    A final state, \c done, is created, and a FactorialDoneTransition object
+    is created with \c done as its target state. The transition is then added
+    to the \c compute state.
+
+    \snippet examples/statemachine/factorial/main.cpp 6
+
+    The machine's initial state is set to be the \c compute state. We connect
+    the QStateMachine::finished() signal to the QCoreApplication::quit() slot,
+    so the application will quit when the state machine's work is
+    done. Finally, the state machine is started, and the application's event
+    loop is entered.
+
+ */
diff --git a/doc/src/images/factorial-example.png b/doc/src/images/factorial-example.png
new file mode 100644
index 0000000..8fb1cc6
--- /dev/null
+++ b/doc/src/images/factorial-example.png
diff --git a/examples/statemachine/factorial/main.cpp b/examples/statemachine/factorial/main.cpp
index 2b63690..ae5928f 100644
--- a/examples/statemachine/factorial/main.cpp
+++ b/examples/statemachine/factorial/main.cpp
@@ -48,6 +48,7 @@
 #include <qfinalstate.h>
 #endif
 
+//! [0]
 class Factorial : public QObject
 {
     Q_OBJECT
@@ -55,10 +56,8 @@ class Factorial : public QObject
     Q_PROPERTY(int fac READ fac WRITE setFac)
 public:
     Factorial(QObject *parent = 0)
-        : QObject(parent)
+        : QObject(parent), m_x(-1), m_fac(1)
     {
-        m_fac = 1;
-        m_x = -1;
     }
 
     int x() const
@@ -71,7 +70,7 @@ public:
         if (x == m_x)
             return;
         m_x = x;
-        emit xChanged();
+        emit xChanged(x);
     }
 
     int fac() const
@@ -85,28 +84,34 @@ public:
     }
 
 Q_SIGNALS:
-    void xChanged();
+    void xChanged(int value);
     
 private:
     int m_x;
     int m_fac;
 };
+//! [0]
 
+//! [1]
 class FactorialLoopTransition : public QSignalTransition
 {
 public:
     FactorialLoopTransition(Factorial *fact)
-        : QSignalTransition(fact, SIGNAL(xChanged())), m_fact(fact)
+        : QSignalTransition(fact, SIGNAL(xChanged(int))), m_fact(fact)
     {}
 
-    virtual bool eventTest(QEvent *) const
+    virtual bool eventTest(QEvent *e) const
     {
-        return m_fact->property("x").toInt() > 1;
+        if (!QSignalTransition::eventTest(e))
+            return false;
+        QSignalEvent *se = static_cast<QSignalEvent*>(e);
+        return se->arguments().at(0).toInt() > 1;
     }
 
-    virtual void onTransition(QEvent *)
+    virtual void onTransition(QEvent *e)
     {
-        int x = m_fact->property("x").toInt();
+        QSignalEvent *se = static_cast<QSignalEvent*>(e);
+        int x = se->arguments().at(0).toInt();
         int fac = m_fact->property("fac").toInt();
         m_fact->setProperty("fac",  x * fac);
         m_fact->setProperty("x",  x - 1);
@@ -115,17 +120,22 @@ public:
 private:
     Factorial *m_fact;
 };
+//! [1]
 
+//! [2]
 class FactorialDoneTransition : public QSignalTransition
 {
 public:
     FactorialDoneTransition(Factorial *fact)
-        : QSignalTransition(fact, SIGNAL(xChanged())), m_fact(fact)
+        : QSignalTransition(fact, SIGNAL(xChanged(int))), m_fact(fact)
     {}
 
-    virtual bool eventTest(QEvent *) const
+    virtual bool eventTest(QEvent *e) const
     {
-        return m_fact->property("x").toInt() <= 1;
+        if (!QSignalTransition::eventTest(e))
+            return false;
+        QSignalEvent *se = static_cast<QSignalEvent*>(e);
+        return se->arguments().at(0).toInt() <= 1;
     }
 
     virtual void onTransition(QEvent *)
@@ -136,35 +146,37 @@ public:
 private:
     Factorial *m_fact;
 };
+//! [2]
 
+//! [3]
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
-
     Factorial factorial;
-
     QStateMachine machine;
+//! [3]
 
-    QState *computing = new QState(machine.rootState());
-    computing->addTransition(new FactorialLoopTransition(&factorial));
+//! [4]
+    QState *compute = new QState(machine.rootState());
+    compute->assignProperty(&factorial, "fac", 1);
+    compute->assignProperty(&factorial, "x", 6);
+    compute->addTransition(new FactorialLoopTransition(&factorial));
+//! [4]
 
+//! [5]
     QFinalState *done = new QFinalState(machine.rootState());
     FactorialDoneTransition *doneTransition = new FactorialDoneTransition(&factorial);
     doneTransition->setTargetState(done);
-    computing->addTransition(doneTransition);
-
-    QState *initialize = new QState(machine.rootState());
-    initialize->assignProperty(&factorial, "x", 6);
-    FactorialLoopTransition *enterLoopTransition = new FactorialLoopTransition(&factorial);
-    enterLoopTransition->setTargetState(computing);
-    initialize->addTransition(enterLoopTransition);
+    compute->addTransition(doneTransition);
+//! [5]
 
+//! [6]
+    machine.setInitialState(compute);
     QObject::connect(&machine, SIGNAL(finished()), &app, SLOT(quit()));
-
-    machine.setInitialState(initialize);
     machine.start();
 
     return app.exec();
 }
+//! [6]
 
 #include "main.moc"