DtRemoteControlCommand

remoteControlCommands.h

/******************************************************************************
** Copyright (c) 2018 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

//\file remoteControlCommands.h

#pragma once

#include <vrvUtil/signalslib.h>
#include <vlpi/simulationAddress.h>
#include <matrix/vlVector.h>

#include <QtCore/QStringList>
#include <boost/signals2.hpp>

namespace makVrv
{
   class DtDe;
}

class QString;
class DtEntityIdentifier;
class DtUUID;
class DtEntityType;

//These classes will represent commands that can be executed by using the
//DtVrossThreadVrfRemoteControl class.

class DtRemoteControlCommand
{
public:
   virtual bool execute(makVrv::DtDe&, const QString& command) = 0;
   virtual DtRemoteControlCommand* clone() const = 0;

   QString help() const
   {
      return myHelp;
   }

   QString command() const
   {
      return myCommand;
   }

   boost::signals2::signal<void (const QString&, DtRemoteControlCommand*)> signal_commandComplete;

protected:
   //Parse out the string.  All tokens are separated by spaces or enclosed in quotes or
   //parens
   virtual QStringList tokenize(const QString&, char delim = ' ') const;

   //Parses a point of the form x,y,z
   bool parsePoint(const QString&, DtVector&) const;

protected:
   DtRemoteControlCommand(const QString& command, const QString& help);
   DtRemoteControlCommand(const DtRemoteControlCommand&);

protected:
   QString myCommand;
   QString myHelp;
};

//This command will create a single point object (entity, waypoint, aggregate) and will notify the user
//when the command has been completed
class DtRemoteControlCreateCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlCreateCommand();

   virtual ~DtRemoteControlCreateCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;

   //Convert string to entity type either by name or by actual type
   DtEntityType entityToCreate(const QString& c, makVrv::DtDe& de) const;

   //Returns the currently selected simulation address
   DtSimulationAddress simulationAddress(makVrv::DtDe&) const;

protected:
   //Called when the object is created, will signal complete with the name and the object id
   void objectCreated(DtString, const DtUUID&, const DtEntityIdentifier&, const DtEntityType&);
};

//Closes the current scenario

class DtRemoteControlCloseScenarioCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlCloseScenarioCommand();
   virtual ~DtRemoteControlCloseScenarioCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;
};

//Loads the specified scenario into the simulation

class DtRemoteControlLoadScenarioCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlLoadScenarioCommand();
   virtual ~DtRemoteControlLoadScenarioCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;
};

//Loads a new scenario into the system

class DtRemoteControlNewScenarioCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlNewScenarioCommand();
   virtual ~DtRemoteControlNewScenarioCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;
};

//Rewinds the current scenario

class DtRemoteControlRewindScenarioCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlRewindScenarioCommand();
   virtual ~DtRemoteControlRewindScenarioCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;
};

//Pauses the current scenario

class DtRemoteControlPauseScenarioCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlPauseScenarioCommand();
   virtual ~DtRemoteControlPauseScenarioCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;
};

//Plays the current scenario

class DtRemoteControlPlayScenarioCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlPlayScenarioCommand();
   virtual ~DtRemoteControlPlayScenarioCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;
};

//Saves the current scenario

class DtRemoteControlSaveScenarioCommand : public DtRemoteControlCommand
{
public:
   DtRemoteControlSaveScenarioCommand();
   virtual ~DtRemoteControlSaveScenarioCommand();

   virtual bool execute(makVrv::DtDe&, const QString& command) override;
   virtual DtRemoteControlCommand* clone() const override;
};

remoteControlCommands.cxx

/******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
//\file remoteControlCommands.cxx

#include "remoteControlCommands.h"
#include <vrfGuiCore/entityCreationData.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrfGuiCore/guiThreadVrfRemoteController.h>
#include <vrfGuiCore/vrfSimBackendManager.h>
#include <vrvUtil/DtCoordinateConverter.h>
#include <vrvUtil/DtCoordinateSystem.h>
#include <vrfGuiCoreQt/createMenu.h>
#include <vrfGuiCommonQt/vrfSaveScenarioHandler.h>

#include <QtCore/QString>
#include <QtCore/QObject>

using namespace makVrf;
using namespace makVrv;

DtRemoteControlCommand::DtRemoteControlCommand(const QString& command, const QString& help)
: myCommand(command)
, myHelp(help)
{
}

DtRemoteControlCommand::DtRemoteControlCommand(const DtRemoteControlCommand& orig)
: myCommand(orig.myCommand)
, myHelp(orig.myHelp)
{
}

bool DtRemoteControlCommand::parsePoint(const QString& c, DtVector& v) const
{
   QStringList vals = c.split(',');

   if (vals.size() != 3)
   {
      return false;
   }

   v.setX(atof(vals[0].trimmed().toLatin1().constData()));
   v.setY(atof(vals[1].trimmed().toLatin1().constData()));
   v.setZ(atof(vals[2].trimmed().toLatin1().constData()));

   return true;
}

QStringList DtRemoteControlCommand::tokenize(const QString& c, char delim) const
{
   int iLimit = c.length();
   int i;
   QString token;
   QStringList tokens;
   bool inQuote = false;
   int inParen = 0;

   for (i = 0; i < iLimit; i++)
   {
      if (c[i] == '"')
      {
         if (inParen == 0)
         {
            if (!inQuote)
            {
               inQuote = true;
            }
            else
            {
               if (token.length())
               {
                  tokens += token;
               }
               token = "";
               inQuote = false;
            }
         }
      }
      else if (c[i] == '(')
      {
         if (!inQuote)
         {
            inParen++;
         }
         else
         {
            token += c[i];
         }
      }
      else if (c[i] == ')')
      {
         if (!inQuote)
         {
            inParen--;

            if (inParen == 0)
            {
               if (token.length())
               {
                  tokens += token;
               }
               token = "";
            }
         }
         else
         {
            token += c[i];
         }
      }
      else if (c[i] == delim)
      {
         if (!inQuote && (inParen == 0))
         {
            if (token.length())
            {
               tokens += token;
            }
            token = "";
         }
         else
         {
            token += c[i];
         }
      }
      else
      {
         token += c[i];
      }
   }

   if (token.length())
   {
      tokens += token;
   }

   return tokens;
}

//************************************** Create command
DtRemoteControlCreateCommand::DtRemoteControlCreateCommand()
: DtRemoteControlCommand("create", QObject::tr("create \"<Menu Item Name>\" (i.e. \"M1A2 Abrams MBT\") OR Entity Type - delimited by comma (i.e. 1,1,225,1,1,3,0)> <force number> <x,y,z> [simulation address]"))
{
}

DtRemoteControlCreateCommand::~DtRemoteControlCreateCommand()
{
}

DtEntityType DtRemoteControlCreateCommand::entityToCreate(const QString& c, DtDe& de) const
{
   QStringList vals = c.split(',');
   DtEntityType type;

   if (vals.size() == 7)
   {
      type = DtEntityType(c.toLatin1().constData());
   }
   else
   {
      type = DtCreateMenu::instance(de).nameToType(c);
   }

   return type;
}

DtSimulationAddress DtRemoteControlCreateCommand::simulationAddress(DtDe& de) const
{
   return DtGuiThreadVrfRemoteController::instance(de).backendManager().selectedBackend();
}

bool DtRemoteControlCreateCommand::execute(makVrv::DtDe& de, const QString& command)
{
   QStringList tokens = tokenize(command);
   int iLimit = tokens.size();

   if (iLimit < 4)
   {
      signal_commandComplete(help(), this);
      return false;
   }

   DtEntityType type = entityToCreate(tokens[1], de);

   if (type == DtEntityType())
   {
      QString error = QObject::tr("Cannot create entity of type ") + tokens[1];
      signal_commandComplete(error, this);

      return false;
   }

   int force = atoi(tokens[2].toLatin1().constData());

   DtVector point;

   if (!parsePoint(tokens[3], point))
   {
      QString error = QObject::tr("Location format is incorrect ") + tokens[2];
      signal_commandComplete(error, this);

      return false;
   }

   DtSimulationAddress simAddress;

   if (iLimit == 5)
   {
      simAddress = DtSimulationAddress(tokens[4].toLatin1().constData());
   }
   else
   {
      simAddress = simulationAddress(de);
   }

   DtVector position;

   de.sharedState().coordinateSystem().localToNetPos( point, position );

   DtEntityCreationData entData(type, force, position);

   //Convert the local position to a geocentric position
   //Create the entity and print out the name and entity id
   //This is where the remote controller is used to create the entity object
   DtGuiThreadVrfRemoteController::instance(de).createEntity(
      boost::bind(&DtRemoteControlCreateCommand::objectCreated, this
         , boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3, boost::placeholders::_4)
         , simAddress, entData);

   return true;
}

void DtRemoteControlCreateCommand::objectCreated(DtString s, const DtUUID&, const DtEntityIdentifier& id, const DtEntityType&)
{
   QString message = QObject::tr("Object ") + s.c_str();

   message += QObject::tr(" with id ") + id.string();
   message += QObject::tr(" has been created.");

   signal_commandComplete(message, this);
}

DtRemoteControlCommand* DtRemoteControlCreateCommand::clone() const
{
   return new DtRemoteControlCreateCommand;
}

//************************ Load Scenario Command

DtRemoteControlLoadScenarioCommand::DtRemoteControlLoadScenarioCommand()
: DtRemoteControlCommand("load", QObject::tr("load \"<scenario name>\""))
{
}

DtRemoteControlLoadScenarioCommand::~DtRemoteControlLoadScenarioCommand()
{
}

bool DtRemoteControlLoadScenarioCommand::execute(makVrv::DtDe& de, const QString& command)
{
   QStringList tokens = tokenize(command);

   if (tokens.size() != 2)
   {
      signal_commandComplete(help(), this);
      return false;
   }

   // If this is not a relative or abs path, then, add the scenarios directory

   DtFilename fn(tokens[1].toUtf8().constData());

   if ((fn.extension() != "scn") && (fn.extension() != "scnx"))
   {
      fn += ".scnx";
   }

   std::vector<std::string> scenarioDirectories = {"scenarios", "scenarios/Sample"};
   if (!fn.exists())
   {
      for(const auto& dir : scenarioDirectories)
      {
         DtFilename source(DtFilename::combine("$(USER_DIR)", dir.c_str()));
         DtFilename combined(DtFilename::combine(
            de.dePathConfiguration().resolvePath(source.c_str()).c_str(), fn));

         if (combined.exists())
         {
            fn = combined;
            break;
         }
      }
   }

   if (!DtGuiThreadVrfRemoteController::instance(de).loadScenario(fn.c_str()))
   {
      signal_commandComplete(QObject::tr("Could not load scenario file ") + tokens[1], this);
      return false;
   }

   signal_commandComplete(QObject::tr("Loading scenario ") + tokens[1], this);

   return true;
}

DtRemoteControlCommand* DtRemoteControlLoadScenarioCommand::clone() const
{
   return new DtRemoteControlLoadScenarioCommand;
}

//************************ Close Scenario Command

DtRemoteControlCloseScenarioCommand::DtRemoteControlCloseScenarioCommand()
: DtRemoteControlCommand("close", QObject::tr("close (closes scenario)"))
{
}

DtRemoteControlCloseScenarioCommand::~DtRemoteControlCloseScenarioCommand()
{
}

bool DtRemoteControlCloseScenarioCommand::execute(makVrv::DtDe& de, const QString& command)
{

   DtGuiThreadVrfRemoteController::instance(de).closeScenario();

   signal_commandComplete(QObject::tr("Closing scenario"), this);

   return true;
}

DtRemoteControlCommand* DtRemoteControlCloseScenarioCommand::clone() const
{
   return new DtRemoteControlCloseScenarioCommand;
}

//************************ New Scenario Command

DtRemoteControlNewScenarioCommand::DtRemoteControlNewScenarioCommand()
: DtRemoteControlCommand("new", QObject::tr("new \"<terrain database>\""))
{
}

DtRemoteControlNewScenarioCommand::~DtRemoteControlNewScenarioCommand()
{
}

bool DtRemoteControlNewScenarioCommand::execute(makVrv::DtDe& de, const QString& command)
{
   QStringList tokens = tokenize(command);

   if (tokens.size() != 2)
   {
      signal_commandComplete(help(), this);
      return false;
   }

   DtFilename terrain(tokens[1].toLatin1().constData());

   if (!terrain.extension().length())
   {
      terrain += ".mtf";
   }

   DtGuiThreadVrfRemoteController::instance(de).newScenario(terrain);

   signal_commandComplete(QObject::tr("Creating new scenario ") + terrain.c_str(), this);

   return true;
}

DtRemoteControlCommand* DtRemoteControlNewScenarioCommand::clone() const
{
   return new DtRemoteControlNewScenarioCommand;
}

//************************ Save Scenario Command

DtRemoteControlSaveScenarioCommand::DtRemoteControlSaveScenarioCommand()
: DtRemoteControlCommand("save", QObject::tr("save \"<scenario name>\""))
{
}

DtRemoteControlSaveScenarioCommand::~DtRemoteControlSaveScenarioCommand()
{
}

bool DtRemoteControlSaveScenarioCommand::execute(makVrv::DtDe& de, const QString& command)
{
   QStringList tokens = tokenize(command);

   if (tokens.size() != 2)
   {
      signal_commandComplete(help(), this);
      return false;
   }

   //The scenario handler will call down to the cross thread remote controller's save scenario method, however,
   //always use this method to save the current scenario as the handler will fill in all the relevant scenario
   //information.
   DtFilename fp(tokens[1].toLatin1().constData());
   DtFilename scenario(fp);

   fp.stripPath();

   if (fp == scenario)
   {
      std::string ud = de.dePathConfiguration().userPath() + "/scenarios/";

      ud += scenario.c_str();

      scenario = ud.c_str();
   }

   DtVrfSaveScenarioHandler::instance(de).saveScenario(scenario, true);

   signal_commandComplete(QObject::tr("Saving scenario ") + tokens[1], this);

   return true;
}

DtRemoteControlCommand* DtRemoteControlSaveScenarioCommand::clone() const
{
   return new DtRemoteControlSaveScenarioCommand;
}

//************************ Rewind Scenario Command

DtRemoteControlRewindScenarioCommand::DtRemoteControlRewindScenarioCommand()
: DtRemoteControlCommand("rewind", QObject::tr("rewind"))
{
}

DtRemoteControlRewindScenarioCommand::~DtRemoteControlRewindScenarioCommand()
{
}

bool DtRemoteControlRewindScenarioCommand::execute(makVrv::DtDe& de, const QString& command)
{
   QStringList tokens = tokenize(command);

   if (tokens.size() != 1)
   {
      signal_commandComplete(help(), this);
      return false;
   }

   DtGuiThreadVrfRemoteController::instance(de).rewindScenario();

   signal_commandComplete(QObject::tr("Scenario Rewound"), this);

   return true;
}

DtRemoteControlCommand* DtRemoteControlRewindScenarioCommand::clone() const
{
   return new DtRemoteControlRewindScenarioCommand;
}

//************************ Play Scenario Command

DtRemoteControlPlayScenarioCommand::DtRemoteControlPlayScenarioCommand()
: DtRemoteControlCommand("run", QObject::tr("run"))
{
}

DtRemoteControlPlayScenarioCommand::~DtRemoteControlPlayScenarioCommand()
{
}

bool DtRemoteControlPlayScenarioCommand::execute(makVrv::DtDe& de, const QString& command)
{
   QStringList tokens = tokenize(command);

   if (tokens.size() != 1)
   {
      signal_commandComplete(help(), this);
      return false;
   }

   DtGuiThreadVrfRemoteController::instance(de).runScenario();

   signal_commandComplete(QObject::tr("Scenario Playing"), this);

   return true;
}

DtRemoteControlCommand* DtRemoteControlPlayScenarioCommand::clone() const
{
   return new DtRemoteControlPlayScenarioCommand;
}

//************************ Pause Scenario Command

DtRemoteControlPauseScenarioCommand::DtRemoteControlPauseScenarioCommand()
: DtRemoteControlCommand("pause", QObject::tr("pause"))
{
}

DtRemoteControlPauseScenarioCommand::~DtRemoteControlPauseScenarioCommand()
{
}

bool DtRemoteControlPauseScenarioCommand::execute(makVrv::DtDe& de, const QString& command)
{
   QStringList tokens = tokenize(command);

   if (tokens.size() != 1)
   {
      signal_commandComplete(help(), this);
      return false;
   }

   DtGuiThreadVrfRemoteController::instance(de).pauseScenario();

   signal_commandComplete(QObject::tr("Scenario Paused"), this);

   return true;
}

DtRemoteControlCommand* DtRemoteControlPauseScenarioCommand::clone() const
{
   return new DtRemoteControlPauseScenarioCommand;
}