Statement.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU 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 General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#include "Rotation.h"
#include "Vector.h"

#include <string>

class Parser;


namespace Script {


    class BadStatementException: public std::runtime_error {
        public:
            BadStatementException(const std::string &what):
                std::runtime_error(what) { }
    };



    class Statement {

        public:
            Statement(const Parser *parser, const std::string &arg):
                _arg(arg), _parser(parser) { }
            virtual bool execute();

        protected:
            const std::string &arg() { return _arg; }
            const Parser *parser() { return _parser; }

        private:
            std::string _arg;       
            const Parser *_parser;  
    };


    class BoolStatement: public Statement {
        public:
            BoolStatement (const Parser *p, const std::string &_arg);
            virtual bool execute() = 0;

        protected:
            bool getValue() { return _bool; }

        private:
            bool _bool;         
    };


    class SizeStmt: public Statement {
        public:
            SizeStmt(const Parser *p, const std::string &_arg);
            virtual bool execute();
        private:
            unsigned _width;    
            unsigned _height;   
    };


    class ObjectStmt: public Statement {
        public:
            ObjectStmt(const Parser *p, const std::string &_arg):
                    Statement(p, _arg) { }
            virtual bool execute();
    };


    template <typename T = unsigned> class ParmStmt: public Statement {
        public:
            ParmStmt(const Parser *p, const std::string &_arg):
                Statement(p, _arg) { }
            virtual bool execute();
    };


    class XformStmt: public Statement {
        public:
            XformStmt(const Parser *p, const std::string &_arg);
            virtual bool execute();

        protected:
            VecMath::Rotation<4> &r() { return _r; }

        private:
            VecMath::Rotation<4> _r;    
    };


    class RotStmt: public XformStmt {
        public:
            RotStmt(const Parser *p, const std::string &_arg):
                XformStmt(p, _arg) { }
            virtual bool execute();
    };


    class DeltaStmt: public XformStmt {
        public:
            DeltaStmt(const Parser *p, const std::string &_arg):
                XformStmt(p, _arg) { }
            virtual bool execute();
    };


    class RotDeltaStmt: public DeltaStmt {
        public:
            RotDeltaStmt(const Parser *p, const std::string &_arg):
                DeltaStmt(p, _arg) { }
            virtual bool execute();
    };


    class FramesStmt: public Statement {
        public:
            FramesStmt(const Parser *p, const std::string &_arg);
            virtual bool execute();
        private:
            unsigned _frames;   
    };


    class LoopStmt: public Statement {
        public:
            LoopStmt(const Parser *p, const std::string &_arg);
            virtual bool execute();
        private:
            unsigned _loops;    
    };


    class ColorStmt: public BoolStatement {
        public:
            ColorStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class ShadingStmt: public BoolStatement {
        public:
            ShadingStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class LightStmt: public BoolStatement {
        public:
            LightStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class TransStmt: public BoolStatement {
        public:
            TransStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class WireStmt: public BoolStatement {
        public:
            WireStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class SolidStmt: public BoolStatement {
        public:
            SolidStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class FogStmt: public BoolStatement {
        public:
            FogStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class Fog4DStmt: public BoolStatement {
        public:
            Fog4DStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class CoordsStmt: public BoolStatement {
        public:
            CoordsStmt(const Parser *p, const std::string &_arg):
                BoolStatement(p, _arg) { }
            virtual bool execute();
    };


    class AnimateStmt: public Statement {
        public:
            AnimateStmt(const Parser *p): Statement(p, "") { }
            virtual bool execute();
    };


    class SleepStmt: public Statement {
        public:
            SleepStmt(const Parser *p, const std::string &_arg);
            virtual bool execute();
        private:
            unsigned _msec;     
    };


    class ImgDirStmt: public Statement {
        public:
            ImgDirStmt(const Parser *p, const std::string &_arg):
                Statement(p, _arg) { }
            virtual bool execute();
    };


    class ImgPrefixStmt: public Statement {
        public:
            ImgPrefixStmt(const Parser *p, const std::string &_arg):
                Statement(p, _arg) { }
            virtual bool execute();
    };


    class StatementFactory {
        public:
            static Statement *createStatement(const Parser *,
                                              const std::string &);
    };
}