Commands.h

Go to the documentation of this file.

#ifndef _MOVECMDS_HEADER
#define _MOVECMDS_HEADER


#include "Command.h"
#include "SpeechControlSource.h"
#include <assert.h>


namespace ot
{


// class *CmdUpMovement*
// *******************************************************************************************

class CmdUpMovement : public Command
{
public:
        CmdUpMovement(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("up movement", 3), parentSrc_, true, true), step(step_), range(step_)        {}

        bool extend()   { getEvent().getPosition()[1] += step * scale; range += step; return true; };
        bool redo()             { getEvent().getPosition()[1] += range * scale; return true; }
        bool undo()             { getEvent().getPosition()[1] -= range * scale; return true; }
        bool combine(Command &cmd)
        {
                if (isCombinable(cmd))
                        range += ((CmdUpMovement*)&cmd)->range;
                return isCombinable(cmd);
        }

protected:
        int step;
        int range;
};


// class *CmdUp*

class CmdUp : public CmdUpMovement
{
public:
        CmdUp(SpeechControlSource &parentSrc_)
        : CmdUpMovement(TtsString("up", 1), 1, parentSrc_)      {}
};


// class *CmdMoveUp*

class CmdMoveUp : public CmdUpMovement
{
public:
        CmdMoveUp(SpeechControlSource &parentSrc_)
        : CmdUpMovement(TtsString("move up", 2), 5, parentSrc_) {}
};


// class *CmdDownMovement*
// *******************************************************************************************

class CmdDownMovement : public Command
{
public:
        CmdDownMovement(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("down movement", 3), parentSrc_, true, true), step(step_), range(step_)      {}

        bool extend()   { getEvent().getPosition()[1] -= step * scale; range += step; return true; };
        bool redo()             { getEvent().getPosition()[1] -= range * scale; return true; }
        bool undo()             { getEvent().getPosition()[1] += range * scale; return true; }
        bool combine(Command &cmd)
        {
                if (isCombinable(cmd))
                        range += ((CmdDownMovement*)&cmd)->range;
                return isCombinable(cmd);
        }

protected:
        int step;
        int range;
};


// class *CmdDown*

class CmdDown : public CmdDownMovement
{
public:
        CmdDown(SpeechControlSource &parentSrc_)
        : CmdDownMovement(TtsString("down", 1), 1, parentSrc_)  {}
};


// class *CmdMoveDown*

class CmdMoveDown : public CmdDownMovement
{
public:
        CmdMoveDown(SpeechControlSource &parentSrc_)
        : CmdDownMovement(TtsString("move down", 2), 5, parentSrc_)     {}
};


// class *CmdRightMovement*
// *******************************************************************************************

class CmdRightMovement : public Command
{
public:
        CmdRightMovement(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("right movement", 3), parentSrc_, true, true), step(step_), range(step_)     {}

        bool extend()   { getEvent().getPosition()[0] += step * scale; range += step; return true; };
        bool redo()             { getEvent().getPosition()[0] += range * scale; return true; }
        bool undo()             { getEvent().getPosition()[0] -= range * scale; return true; }
        bool combine(Command &cmd)
        {
                if (isCombinable(cmd))
                        range += ((CmdRightMovement*)&cmd)->range;
                return isCombinable(cmd);
        }

protected:
        int step;
        int range;
};


// class *CmdRight*

class CmdRight : public CmdRightMovement
{
public:
        CmdRight(SpeechControlSource &parentSrc_)
        : CmdRightMovement(TtsString("right", 1), 1, parentSrc_)        {}
};


// class *CmdMoveRight*

class CmdMoveRight : public CmdRightMovement
{
public:
        CmdMoveRight(SpeechControlSource &parentSrc_)
        : CmdRightMovement(TtsString("move right", 2), 5, parentSrc_)   {}
};


// class *CmdLeftMovement*
// *******************************************************************************************

class CmdLeftMovement : public Command
{
public:
        CmdLeftMovement(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("left movement", 3), parentSrc_, true, true), step(step_), range(step_)      {}

        bool extend()   { getEvent().getPosition()[0] -= step * scale; range += step; return true; };
        bool redo()             { getEvent().getPosition()[0] -= range * scale; return true; }
        bool undo()             { getEvent().getPosition()[0] += range * scale; return true; }
        bool combine(Command &cmd)
        {
                if (isCombinable(cmd))
                        range += ((CmdLeftMovement*)&cmd)->range;
                return isCombinable(cmd);
        }

protected:
        int step;
        int range;
};


// class *CmdLeft*

class CmdLeft : public CmdLeftMovement
{
public:
        CmdLeft(SpeechControlSource &parentSrc_)
        : CmdLeftMovement(TtsString("left", 1), 1, parentSrc_)  {}
};


// class *CmdMoveLeft*

class CmdMoveLeft : public CmdLeftMovement
{
public:
        CmdMoveLeft(SpeechControlSource &parentSrc_)
        : CmdLeftMovement(TtsString("move left", 2), 5, parentSrc_)     {}
};


// class *CmdForwardMovement*
// *******************************************************************************************

class CmdForwardMovement : public Command
{
public:
        CmdForwardMovement(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("forward movement", 4), parentSrc_, true, true), step(step_), range(step_)   {}

        bool extend()   { getEvent().getPosition()[2] += step * scale; range += step; return true; };
        bool redo()             { getEvent().getPosition()[2] += range * scale; return true; }
        bool undo()             { getEvent().getPosition()[2] -= range * scale; return true; }
        bool combine(Command &cmd)
        {
                if (isCombinable(cmd))
                        range += ((CmdForwardMovement*)&cmd)->range;
                return isCombinable(cmd);
        }

protected:
        int step;
        int range;
};


// class *CmdForward*

class CmdForward : public CmdForwardMovement
{
public:
        CmdForward(SpeechControlSource &parentSrc_)
        : CmdForwardMovement(TtsString("forward", 2), 1, parentSrc_)    {}
};


// class *CmdMoveForward*

class CmdMoveForward : public CmdForwardMovement
{
public:
        CmdMoveForward(SpeechControlSource &parentSrc_)
        : CmdForwardMovement(TtsString("move forward", 3), 5, parentSrc_)       {}
};


// class *CmdBackwardMovement*
// *******************************************************************************************

class CmdBackwardMovement : public Command
{
public:
        CmdBackwardMovement(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("backward movement", 4), parentSrc_, true, true), step(step_), range(step_)  {}

        bool extend()   { getEvent().getPosition()[2] -= step * scale; range += step; return true; };
        bool redo()             { getEvent().getPosition()[2] -= range * scale; return true; }
        bool undo()             { getEvent().getPosition()[2] += range * scale; return true; }
        bool combine(Command &cmd)
        {
                if (isCombinable(cmd))
                        range += ((CmdBackwardMovement*)&cmd)->range;
                return isCombinable(cmd);
        }

protected:
        int step;
        int range;
};


// class *CmdBackward*

class CmdBackward : public CmdBackwardMovement
{
public:
        CmdBackward(SpeechControlSource &parentSrc_)
        : CmdBackwardMovement(TtsString("backward", 2), 1, parentSrc_)  {}
};


// class *CmdMoveBackward*

class CmdMoveBackward : public CmdBackwardMovement
{
public:
        CmdMoveBackward(SpeechControlSource &parentSrc_)
        : CmdBackwardMovement(TtsString("move backward", 3), 5, parentSrc_)     {}
};


// class *CmdAxial*
// *******************************************************************************************

class CmdAxial : public Command
{
public:
        CmdAxial(SpeechControlSource &parentSrc_)
        : Command(TtsString("axial", 3), TtsString("axial", 3), parentSrc_, true)       {}

        bool redo()
        {
                originalEvent = getEvent();
                getEvent().getOrientation()[0] = (float)0;
                getEvent().getOrientation()[1] = (float)0;
                getEvent().getOrientation()[2] = (float)0;
                getEvent().getOrientation()[3] = (float)1;
                return true;
        };
        bool undo()     { getEvent() = originalEvent; return true; };

protected:
        Event   originalEvent;
};


// class *CmdSagittal*
// *******************************************************************************************

class CmdSagittal : public Command
{
public:
        CmdSagittal(SpeechControlSource &parentSrc_)
        : Command(TtsString("sagittal", 3), TtsString("sagittal", 3), parentSrc_, true) {}

        bool redo()
        {
                originalEvent = getEvent();
                getEvent().getOrientation()[0] = (float)0.5;
                getEvent().getOrientation()[1] = (float)0.5;
                getEvent().getOrientation()[2] = (float)0.5;
                getEvent().getOrientation()[3] = (float)0.5;
                return true;
        };
        bool undo()     { getEvent() = originalEvent; return true; };

protected:
        Event   originalEvent;
};


// class *CmdCoronal*
// *******************************************************************************************

class CmdCoronal : public Command
{
public:
        CmdCoronal(SpeechControlSource &parentSrc_)
        : Command(TtsString("coronal", 3), TtsString("coronal", 3), parentSrc_, true)   {}

        bool redo()
        {
                originalEvent = getEvent();
                getEvent().getOrientation()[0] = (float)0.7;
                getEvent().getOrientation()[1] = (float)0;
                getEvent().getOrientation()[2] = (float)0;
                getEvent().getOrientation()[3] = (float)0.7;
                return true;
        };
        bool undo()     { getEvent() = originalEvent; return true; };

protected:
        Event   originalEvent;
};


// class *CmdReset*
// *******************************************************************************************

class CmdReset : public Command
{
public:
        CmdReset(SpeechControlSource &parentSrc_)
        : Command(TtsString("reset", 2), TtsString("reset", 2), parentSrc_, true)       {}

        bool redo()
        {
                originalEvent = getEvent();
                getEvent().getPosition()[0] = (float)0;
                getEvent().getPosition()[1] = (float)0;
                getEvent().getPosition()[2] = (float)0;
                getEvent().getOrientation()[0] = (float)0;
                getEvent().getOrientation()[1] = (float)0;
                getEvent().getOrientation()[2] = (float)0;
                getEvent().getOrientation()[3] = (float)1;
                getEvent().getButton() = 0;
                getEvent().getConfidence() = 0;
                return true;
        };
        bool undo()     { getEvent() = originalEvent; return true; };

protected:
        Event   originalEvent;
};


// class *CmdRotation*
// *******************************************************************************************

class CmdRotation : public Command
{
public:
        CmdRotation(TtsString name_, TtsString class_, SpeechControlSource &parentSrc_, int step_)
        : Command(name_, class_, parentSrc_, true, true), step(step_), range(step_)     {}

        bool rotate(int axis, bool up, int step)
        {
                assert(axis >= 0 && axis <= 2);

                // set variables
                float axisAngle[] = { 0, 0, 0, 0 };
                std::vector<float> oldOrientation = getEvent().getOrientation();
                std::vector<float> rotationQuaternion;
                float angle = step * scale;
                if (!up)
                        angle *= -1;
                angle *= MathUtils::GradToRad;

                // set axisAngle
                axisAngle[3] = angle;
                axisAngle[axis] = 1;

                // rotate
                MathUtils::axisAngleToQuaternion(copyA2V(axisAngle, 4), rotationQuaternion);
                MathUtils::multiplyQuaternion(oldOrientation, rotationQuaternion, getEvent().getOrientation());
                return true;
        };
        bool combine(Command &cmd)
        {
                if (isCombinable(cmd))
                        range += ((CmdRotation*)&cmd)->range;
                return isCombinable(cmd);
        };

protected:
        int range;
        int step;
};


// class *CmdRightRotation*
// *******************************************************************************************

class CmdRightRotation : public CmdRotation
{
public:
        CmdRightRotation(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : CmdRotation(name_, TtsString("right rotation", 4), parentSrc_, step_) {}

        bool extend()   { range += step; return rotate(0, true, step); };
        bool redo()             { return rotate(0, true, range); };
        bool undo()             { return rotate(0, false, range); };
};


// class *CmdRotateRight*

class CmdRotateRight : public CmdRightRotation
{
public:
        CmdRotateRight(SpeechControlSource &parentSrc_)
        : CmdRightRotation(TtsString("rotate right", 3), 1, parentSrc_) {}
};


// class *CmdRotateRightFast*

class CmdRotateRightFast : public CmdRightRotation
{
public:
        CmdRotateRightFast(SpeechControlSource &parentSrc_)
        : CmdRightRotation(TtsString("rotate right fast", 4), 5, parentSrc_)    {}
};


// class *CmdLeftRotation*
// *******************************************************************************************

class CmdLeftRotation : public CmdRotation
{
public:
        CmdLeftRotation(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : CmdRotation(name_, TtsString("left rotation", 4), parentSrc_, step_) {}

        bool extend()   { range += step; return rotate(0, false, step); };
        bool redo()             { return rotate(0, false, range); };
        bool undo()             { return rotate(0, true, range); };
};


// class *CmdRotateLeft*

class CmdRotateLeft : public CmdLeftRotation
{
public:
        CmdRotateLeft(SpeechControlSource &parentSrc_)
        : CmdLeftRotation(TtsString("rotate left", 3), 1, parentSrc_)   {}
};


// class *CmdRotateLeftFast*

class CmdRotateLeftFast : public CmdLeftRotation
{
public:
        CmdRotateLeftFast(SpeechControlSource &parentSrc_)
        : CmdLeftRotation(TtsString("rotate left fast", 4), 5, parentSrc_)      {}
};


// class *CmdClockwiseRolling*
// *******************************************************************************************

class CmdClockwiseRolling : public CmdRotation
{
public:
        CmdClockwiseRolling(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : CmdRotation(name_, TtsString("clockwise rolling", 4), parentSrc_, step_) {}

        bool extend()   { range += step; return rotate(1, true, step); };
        bool redo()             { return rotate(1, true, range); };
        bool undo()             { return rotate(1, false, range); };
};


// class *CmdRollClockwise*

class CmdRollClockwise : public CmdClockwiseRolling
{
public:
        CmdRollClockwise(SpeechControlSource &parentSrc_)
        : CmdClockwiseRolling(TtsString("roll clockwise", 3), 1, parentSrc_)    {}
};


// class *CmdRollClockwiseFast*

class CmdRollClockwiseFast : public CmdClockwiseRolling
{
public:
        CmdRollClockwiseFast(SpeechControlSource &parentSrc_)
        : CmdClockwiseRolling(TtsString("roll clockwise fast", 4), 5, parentSrc_)       {}
};


// class *CmdCounterClockwiseRolling*
// *******************************************************************************************

class CmdCounterClockwiseRolling : public CmdRotation
{
public:
        CmdCounterClockwiseRolling(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : CmdRotation(name_, TtsString("counterclockwise rolling", 6), parentSrc_, step_) {}

        bool extend()   { range += step; return rotate(1, false, step); };
        bool redo()             { return rotate(1, false, range); };
        bool undo()             { return rotate(1, true, range); };
};


// class *CmdRollCounterClockwise*

class CmdRollCounterClockwise : public CmdCounterClockwiseRolling
{
public:
        CmdRollCounterClockwise(SpeechControlSource &parentSrc_)
        : CmdCounterClockwiseRolling(TtsString("roll counterclockwise", 5), 1, parentSrc_)      {}
};


// class *CmdRollCounterClockwiseFast*

class CmdRollCounterClockwiseFast : public CmdCounterClockwiseRolling
{
public:
        CmdRollCounterClockwiseFast(SpeechControlSource &parentSrc_)
        : CmdCounterClockwiseRolling(TtsString("roll counterclockwise fast", 6), 5, parentSrc_) {}
};


// class *CmdTildingUp*
// *******************************************************************************************

class CmdTildingUp : public CmdRotation
{
public:
        CmdTildingUp(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : CmdRotation(name_, TtsString("tilding up", 3), parentSrc_, 1) {}

        bool extend()   { range += step; return rotate(2, true, step); };
        bool redo()             { return rotate(2, true, range); };
        bool undo()             { return rotate(2, false, range); };
};


// class *CmdTildUp*

class CmdTildUp : public CmdTildingUp
{
public:
        CmdTildUp(SpeechControlSource &parentSrc_)
        : CmdTildingUp(TtsString("tild up", 2), 1, parentSrc_)  {}
};


// class *CmdTildUpFast*

class CmdTildUpFast : public CmdTildingUp
{
public:
        CmdTildUpFast(SpeechControlSource &parentSrc_)
        : CmdTildingUp(TtsString("tild up fast", 3), 5, parentSrc_)     {}
};


// class *CmdTildingDown*
// *******************************************************************************************

class CmdTildingDown : public CmdRotation
{
public:
        CmdTildingDown(TtsString name_, int step_, SpeechControlSource &parentSrc_)
        : CmdRotation(name_, TtsString("tilding down", 3), parentSrc_, 1) {}

        bool extend()   { range += step; return rotate(2, false, step); };
        bool redo()             { return rotate(2, false, range); };
        bool undo()             { return rotate(2, true, range); };
};


// class *CmdTildDown*

class CmdTildDown : public CmdTildingDown
{
public:
        CmdTildDown(SpeechControlSource &parentSrc_)
        : CmdTildingDown(TtsString("tild down", 2), 1, parentSrc_)      {}
};


// class *CmdTildDownFast*

class CmdTildDownFast : public CmdTildingDown
{
public:
        CmdTildDownFast(SpeechControlSource &parentSrc_)
        : CmdTildingDown(TtsString("tild down fast", 3), 5, parentSrc_) {}
};


// class *CmdSaveEvent*
// *******************************************************************************************


class CmdSaveEvent : public Command
{
public:
        CmdSaveEvent(TtsString name_, int index_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("save event", 2), parentSrc_), index(index_) { assert(index >= 0 && index <= 4); };

        bool redo() { parentSrc.setSavedEvent(index, getEvent()); return true; };

protected:
        int     index;
};


// class *CmdSaveOne*

class CmdSaveOne : public CmdSaveEvent
{
public:
        CmdSaveOne(SpeechControlSource &parentSrc_)
        : CmdSaveEvent(TtsString("save one", 2), 0, parentSrc_) {};
};


// class *CmdSaveTwo*

class CmdSaveTwo : public CmdSaveEvent
{
public:
        CmdSaveTwo(SpeechControlSource &parentSrc_)
        : CmdSaveEvent(TtsString("save two", 2), 1, parentSrc_) {};
};


// class *CmdSaveThree*

class CmdSaveThree : public CmdSaveEvent
{
public:
        CmdSaveThree(SpeechControlSource &parentSrc_)
        : CmdSaveEvent(TtsString("save three", 2), 2, parentSrc_) {};
};


// class *CmdSaveFour*

class CmdSaveFour : public CmdSaveEvent
{
public:
        CmdSaveFour(SpeechControlSource &parentSrc_)
        : CmdSaveEvent(TtsString("save four", 2), 3, parentSrc_) {};
};


// class *CmdSaveFive*

class CmdSaveFive : public CmdSaveEvent
{
public:
        CmdSaveFive(SpeechControlSource &parentSrc_)
        : CmdSaveEvent(TtsString("save five", 2), 4, parentSrc_) {};
};


// class *CmdRestoreEvent*
// *******************************************************************************************


class CmdRestoreEvent : public Command
{
public:
        CmdRestoreEvent(TtsString name_, int index_, SpeechControlSource &parentSrc_)
        : Command(name_, TtsString("restore event", 3), parentSrc_, true), index(index_)
        {
                assert(index >= 0 && index <= 4);
                failureMsg.str = failureMsg.str + ", since no event was saved yet";
                failureMsg.syl = failureMsg.syl + 6;
        };

        bool redo()
        {
                if (!parentSrc.isSavedEventAvailable(index))
                        return false;
                originalEvent = getEvent();
                setEvent(parentSrc.getSavedEvent(index));
                return true;
        };
        bool undo()     { setEvent(originalEvent); return true; };

protected:
        int             index;
        Event   originalEvent;
};


// class *CmdRestoreOne*

class CmdRestoreOne : public CmdRestoreEvent
{
public:
        CmdRestoreOne(SpeechControlSource &parentSrc_)
        : CmdRestoreEvent(TtsString("restore one", 3), 0, parentSrc_) {};
};


// class *CmdRestoreTwo*

class CmdRestoreTwo : public CmdRestoreEvent
{
public:
        CmdRestoreTwo(SpeechControlSource &parentSrc_)
        : CmdRestoreEvent(TtsString("restore two", 3), 1, parentSrc_) {};
};


// class *CmdRestoreThree*

class CmdRestoreThree : public CmdRestoreEvent
{
public:
        CmdRestoreThree(SpeechControlSource &parentSrc_)
        : CmdRestoreEvent(TtsString("restore three", 3), 2, parentSrc_) {};
};


// class *CmdRestoreFour*

class CmdRestoreFour : public CmdRestoreEvent
{
public:
        CmdRestoreFour(SpeechControlSource &parentSrc_)
        : CmdRestoreEvent(TtsString("restore four", 3), 3, parentSrc_) {};
};


// class *CmdRestoreFive*

class CmdRestoreFive : public CmdRestoreEvent
{
public:
        CmdRestoreFive(SpeechControlSource &parentSrc_)
        : CmdRestoreEvent(TtsString("restore five", 3), 4, parentSrc_) {};
};


// class *CmdScaleUp*
// *******************************************************************************************

class CmdScaleUp : public Command
{
public:
        CmdScaleUp(SpeechControlSource &parentSrc_)
        : Command(TtsString("scale up", 3), TtsString("scale up", 3), parentSrc_, true) {}

        bool redo()
        {
                char chars[10];
                std::string sentence;

                scale *= 2;
                sprintf(chars, "%8.4f", scale);
                sentence = std::string(chars);
                sentence = sentence.substr(0, sentence.find_last_not_of("0.") + 1);
                if (scale >= 1.0)
                        sentence += ".0";

                successMsg.str = "scale factor is now " + sentence;
                successMsg.syl = 9 + sentence.length();
                return true;
        };
        bool undo()
        {
                char chars[10];
                std::string sentence;

                scale /= 2;
                sprintf(chars, "%8.4f", scale);
                sentence = std::string(chars);
                sentence = sentence.substr(0, sentence.find_last_not_of("0.") + 1);
                if (scale >= 1.0)
                        sentence += ".0";

                successMsg.str = "scale factor is now " + sentence;
                successMsg.syl = 9 + sentence.length();
                return true;
        };
};


// class *CmdScaleDown*
// *******************************************************************************************

class CmdScaleDown : public Command
{
public:
        CmdScaleDown(SpeechControlSource &parentSrc_)
        : Command(TtsString("scale down", 3), TtsString("scale down", 3), parentSrc_, true)     {}

        bool redo()
        {
                char chars[10];
                std::string sentence;

                scale /= 2;
                sprintf(chars, "%8.4f", scale);
                sentence = std::string(chars);
                sentence = sentence.substr(0, sentence.find_last_not_of("0.") + 1);
                if (scale >= 1.0)
                        sentence += ".0";

                successMsg.str = "scale factor is now " + sentence;
                successMsg.syl = 9 + sentence.length();
                return true;
        }
        bool undo()
        {
                char chars[10];
                std::string sentence;

                scale *= 2;
                sprintf(chars, "%8.4f", scale);
                sentence = std::string(chars);
                sentence = sentence.substr(0, sentence.find_last_not_of("0.") + 1);
                if (scale >= 1.0)
                        sentence += ".0";

                successMsg.str = "scale factor is now " + sentence;
                successMsg.syl = 9 + sentence.length();
                return true;
        }
};


// class *CmdGoOn*
// *******************************************************************************************

class CmdGoOn : public Command
{
public:
        CmdGoOn(SpeechControlSource &parentSrc_)
        : Command(TtsString("go on", 2), TtsString("go on", 2), parentSrc_, false, false)
        {
                successMsg = TtsString("going on", 3);
                failureMsg = TtsString("no command to go on", 6);
        };

        bool redo()
        {
                if (getLastCmd() && getLastCmd()->isExtendable())
                {
                        parentSrc.setMoving(true);
                        getLastCmd()->extend();
                        return true;
                }
                else
                        return false;
        };
};


// class *CmdStop*
// *******************************************************************************************

class CmdStop : public Command
{
public:
        CmdStop(SpeechControlSource &parentSrc_)
        : Command(TtsString("stop", 1), TtsString("stop", 1), parentSrc_, false, false)
        {
                successMsg = TtsString("stopped", 2.8);
                failureMsg = TtsString("no continuous movement", 7);
        };

        bool redo()
        {
                parentSrc.setMoving(false);
                return parentSrc.isWasMoving();;
        };
};


// class *CmdAgain*
// *******************************************************************************************

class CmdAgain : public Command
{
public:
        CmdAgain(SpeechControlSource &parentSrc_)
        : Command(TtsString("again", 2), TtsString("again", 2), parentSrc_, false, false)
        {
                successMsg = getLastCmd() ? getLastCmd()->getSuccessMsg() : TtsString();
                failureMsg = TtsString("no command do be done again", 8);
        };

        bool redo()     { return parentSrc.getCmdStack().again(); };
};


// class *CmdQuit*
// *******************************************************************************************

class CmdQuit : public Command
{
public:
        CmdQuit(SpeechControlSource &parentSrc_)
        : Command(TtsString("quit", 1), TtsString("quit", 1), parentSrc_, false, false)
        {
                successMsg = TtsString("quit system", 3);
        };

        bool redo()
        {
                parentSrc.setListening(false);
                return true;
        };
};


// class *CmdUndo*
// *******************************************************************************************

class CmdUndo : public Command
{
public:
        CmdUndo(SpeechControlSource &parentSrc_)
        : Command(TtsString("undo", 2), TtsString("undo", 2), parentSrc_, false, false)
        {
                successMsg = getUndoCmd() ? getUndoCmd()->getName() + TtsString(" was undone", 3) : TtsString();
                failureMsg = TtsString("no command to be undone", 7);
        };

        bool redo()
        {
                return parentSrc.getCmdStack().undo();
        };
};


// class *CmdRedo*
// *******************************************************************************************

class CmdRedo : public Command
{
public:
        CmdRedo(SpeechControlSource &parentSrc_)
        : Command(TtsString("redo", 2), TtsString("redo", 2), parentSrc_, false, false)
        {
                successMsg = getRedoCmd() ? getRedoCmd()->getName() + TtsString(" was redone", 3) : TtsString();
                failureMsg = TtsString("no command to be redone", 7);
        };

        bool redo()
        {
                return parentSrc.getCmdStack().redo();
        };
};


} // namespace ot


#endif

---