/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of SCXML on Qt labs

**

** $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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QSCXML_H

#define QSCXML_H

#ifndef QT_NO_STATEMACHINE

#include <QStateMachine>

#include <QAbstractTransition>

#include <QVariant>

#include <QEvent>

#include <QStringList>

#include <QScriptValue>

#include <QUrl>

#include <QScriptProgram>

class QScriptEngine;

class QScxml;

class QScxmlEvent : public QEvent

{

    public:

        static QEvent::Type eventType();

        QString eventName() const;

        QStringList paramNames () const;

        QVariantList paramValues () const;

        QScriptValue content () const;

        QVariant param (const QString & name) const;

        QScxmlEvent (

                const QString & name,

                const QStringList & paramNames = QStringList(),

                const QVariantList & paramValues = QVariantList(),

                const QScriptValue & content = QScriptValue());

        struct MetaData

        {

            QUrl origin,target;

            QString originType, targetType;

            QString invokeID;

            enum Kind { Platform, Internal, External } kind;

        };

        MetaData metaData;

    private:

        QString ename;

        QStringList pnames;

        QVariantList pvals;

        QScriptValue cnt;

};

class   QScxmlTransition : public QAbstractTransition

{

    Q_OBJECT

    Q_PROPERTY(QString conditionExpression READ conditionExpression WRITE setConditionExpression)

    Q_PROPERTY(QStringList eventPrefixes READ eventPrefixes WRITE setEventPrefixes)

    public:

        QScxmlTransition (QState* state, QScxml* machine);

        QString conditionExpression () const;

        void setConditionExpression (const QString & c);

        QStringList eventPrefixes () const { return ev; }

        void setEventPrefixes (const QStringList & e) { ev = e; }

    protected:

        bool eventTest(QEvent*);

        void onTransition (QEvent*);

    private:

        QScxml* scxml;

        QStringList ev;

        QScriptProgram prog;

};

class QScxmlInvoker : public QObject

{

    Q_OBJECT

    Q_PROPERTY (QString id READ id WRITE setID)

    protected:

        QScxmlInvoker(QScxmlEvent* ievent, QStateMachine* p) : QObject(p), initEvent(ievent),cancelled(false) {}

    public:

        virtual ~QScxmlInvoker();

        QString id () const;

        void setID(const QString &);

    public Q_SLOTS:

        virtual void activate() = 0;

        virtual void cancel() { deleteLater(); }

    protected Q_SLOTS:

        void postParentEvent (const QString & event);

    protected:

        QScxml* parentStateMachine() { return (QScxml*)parent(); }

        void postParentEvent (QScxmlEvent* ev);

        QScxmlEvent* initEvent;

        bool cancelled;

    friend struct QScxmlFunctions;

};

struct QScxmlInvokerFactory

{

    virtual QScxmlInvoker* createInvoker (QScxmlEvent* event, QScxml* stateMachine) = 0;

    virtual bool isTypeSupported (const QString & type) const = 0;

    virtual void init (QScxml*) = 0;

};

template <class T>

class QScxmlAutoInvokerFactory : public QScxmlInvokerFactory

{

    QScxmlInvoker* createInvoker (QScxmlEvent* _e, QScxml* _sm) { return new T(_e,_sm); }

    bool isTypeSupported(const QString & _s) const { return T::isTypeSupported(_s); }

    void init (QScxml* sm) { T::initInvokerFactory(sm); }

};

class QScxml : public QStateMachine

{

    Q_OBJECT

    Q_PROPERTY(QUrl baseUrl READ baseUrl WRITE setBaseUrl)

    public:

        QScxml(QScriptEngine* engine, QObject* o = NULL);

        QScxml(QObject* o = NULL);

        virtual ~QScxml();

    protected:

        // overloaded to store the event for the script environment's use (_event), and to convert

        // StateFinished events to "done." named events

        virtual void beginSelectTransitions(QEvent*);

        virtual void endMicrostep(QEvent*);

    public:

        QScriptEngine* scriptEngine () const;

        void registerObject (QObject* object, const QString & name = QString(), bool recursive = false);

        void registerInvokerFactory (QScxmlInvokerFactory* f);

        void setBaseUrl (const QUrl &);

        QUrl baseUrl () const;

        static QScxml* load (const QString & filename, QObject* o = NULL);

        QMap<QString,QVariant> data() const;

        QStringList knownEventNames() const;

    public Q_SLOTS:

        void postNamedEvent(const QString &);

        void executeScript (const QString &);

        void executeScript (const QScriptProgram &);

        void setData(const QString & id, const QVariant & value);

    private Q_SLOTS:

        void registerSession();

        void unregisterSession();

        void handleStateFinished();

    Q_SIGNALS:

        void eventTriggered(const QString &);

        void dataChanged (const QString &, const QVariant &);

        void configurationChanged();

    private:

        class QScxmlPrivate* pvt;

        friend class QScxmlLoader;

        friend struct QScxmlFunctions;

        void init();

};

#endif

#endif // QSCXML_H