GUI Thread VRF Remote Controller (guiThreadVrfRemoteController)

Table of Contents

• Adding Remote Control
• How to Run the Example
  • Usage
• Classes
• Plugin Entry Points

The GUI Thread VRF Remote Controller example demonstrates the following:

• Create a plugin to the GUI
• Use the GUI remote controller to communicate with a sim engine
• Add callbacks for objects created through the remote controller
• How to be notified when the user clicks on the terrain

Adding Remote Control

The Gui Thread VRF Remote Controller example adds a new menu and menu item to the gui that will allow the user to bring up a console and type in simple commands to manipulate the simulation. More commands may be added to extend this example

How to Run the Example

Usage

In the Launcher, click the Plug-ins button to bring up the Plug-ins Selection dialog. Enable the plugin.

1. Start VR-Forces GUI and SIM.
2. Load an existing scenario - e.g. HawaiiGround.scnx.
3. Choose the new 'Remote Control' menu item.
4. Select the 'Remote Control Console...' sub-menu item.
5. The remote control console is displayed. Type help in the Command field - to retrieve available commands.
6. Then type a command to perform a remote control operation - e.g. run - to play the scenario.

Classes

DtRemoteControlMenuItem	The menu item to display the console.
DtRemoteControlConsole	The console used to enter in remote control commands.
DtRemoteControlCommand	Remote control command classes used to communicate with the GUI remote controller.

Plugin Entry Points

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

//\file guiThreadVrfRemoteController.cxx

//This file defines the generic DT_DLL_VRF_PLUGIN_EXPORT_MACRO.  Use that macro when
//you want to export symbols.  Also, in your CMakeLists.txt file, make sure to
//define the VRFPLUGIN_EXPORTS define to tell the compiler to define the macro as an
//export
#include <vrfGuiCore/vrfGuiExportPlugin.h>
#include <vrfGuiCore/vrfSimBackendManager.h>
#include <vrfGuiCore/vrfGuiApplication.h>
#include "remoteControlConsole.h"

#include <vrfGuiCore/entityMapperKey.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtVrvApplication.h>
#include <vrvUtil/DtDeInitializer.h>
#include <vrvCore/DtUserInterfaceAssembler.h>
#include <vrvCoreQt/DtMenuItem.h>
#include <vrvCoreQt/DtQtMenuAssembler.h>
#include <vrvCoreQt/DtMenu.h>

#include <vrvCore/DtToolbarConfiguration.h>
#include <vrvCore/DtToolbarPath.h>
#include <vrvCoreQt/DtToolbar.h>
#include <vrvCoreQt/DtWidgetBuilder.h>
#include <vrvCoreQt/DtQApplicationProvider.h>
#include <vrvCoreQt/DtQtToolbarAssembler.h>

#include <QtWidgets/QMenu>
#include <QtWidgets/QToolBar>
#include <QtWidgets/QLabel>
#include <QtWidgets/QMessageBox>
#include <QtWidgets/QLineEdit>
#include <QApplication>

#include <boost/bind.hpp>

using namespace makVrv;
using namespace makVrf;

// Toolbar for displaying the current simulation status
class DtSimulationStatusToolbar : public DtToolbar
{
public:
   DtSimulationStatusToolbar (DtDe& de);
   virtual ~DtSimulationStatusToolbar() override;
   virtual QToolBar* createToolbar(DtDe&, QWidget* parent) override;
};

DtSimulationStatusToolbar::DtSimulationStatusToolbar(DtDe& de)
   : DtToolbar(de, std::string("SimulationStatusToolbar") )
{
}

DtSimulationStatusToolbar::~DtSimulationStatusToolbar()
{
}

QToolBar* DtSimulationStatusToolbar::createToolbar(DtDe&, QWidget* parent)
{
   QToolBar* tb = new QToolBar("Simulation Status", parent);
   tb->setWindowTitle("Simulation Status Toolbar");
   return tb;
}

class DtSimulationStatusDisplay : public QLabel
{
public:
   DtSimulationStatusDisplay(DtDe& de, QWidget* parent)
   : QLabel(parent)
   , myDe(de)
   , mySimulationStatus(DtSimulationStatusReady)
   {
      simulationStatusChanged(DtVrfSimBackendManager::instance(myDe).simulationStatus());
      DtVrfSimBackendManager::instance(myDe).signal_simulationStatusChanged.connect(
         boost::bind(&DtSimulationStatusDisplay::simulationStatusChanged, this, boost::placeholders::_1));
   }

   virtual ~DtSimulationStatusDisplay() override
   {
      if (!DtVrfGuiApplication::applicationIsTerminating(myDe))
      {
         DtVrfSimBackendManager::instance(myDe).signal_simulationStatusChanged.disconnect(
            boost::bind(&DtSimulationStatusDisplay::simulationStatusChanged, this, boost::placeholders::_1));
      }
   }

   void simulationStatusChanged(DtSimulationStatus s)
   {
      if (s != mySimulationStatus)
      {
         mySimulationStatus = s;

         QString status = "Simulation Status: ";

         switch (s)
         {
         case DtSimulationStatusUnknown:
            status += "Unknown";
            break;
         case DtSimulationStatusNotReady:
            status += "Not Ready to Simulate";
            break;
         case DtSimulationStatusNotLoaded:
            status += "No Simulation Loaded";
            break;
         case DtSimulationStatusReady:
            status += "Ready to Simulate";
            break;
         case DtSimulationStatusPlaying:
            status += "Scenario Playing";
            break;
         case DtSimulationStatusPaused:
            status += "Scenario Paused";
            break;
         case DtSimulationStatusLoading:
            status += "Scenario Loading";
            break;
         case DtSimulationStatusLoaded:
            status += "Scenario Loaded";
            break;
         case DtSimulationStatusClosing:
            status += "Scenario Closing";
            break;
         case DtSimulationStatusClosed:
            status += "Scenario Closed";
            break;
         case DtSimulationStatusSaving:
            status += "Scenario Saving";
            break;
         case DtSimulationStatusSaved:
            status += "Scenario Saved";
            break;
         case DtSimulationStatusRollingBackScenario:
            status += "Rolling Back Scenario";
            break;
         case DtSimulationStatusRolledBackScenario:
            status += "Rolled Back Scenario";
            break;
         case DtSimulationStatusImportingScenario:
            status += "Importing Scenario";
            break;
         case DtSimulationStatusImportedScenario:
            status += "Imported Scenario";
            break;
         }

         setText(status);
      }
   }

protected:
   DtDe& myDe;
   DtSimulationStatus mySimulationStatus;
};

class DtSimulationStatusDisplayBuilder : public DtWidgetBuilder
{
public:
   DtSimulationStatusDisplayBuilder(DtDe& de);
   virtual ~DtSimulationStatusDisplayBuilder() override;
   virtual QWidget* create(DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0) override;
};
//......................................................................
DtSimulationStatusDisplayBuilder::DtSimulationStatusDisplayBuilder(DtDe& de)
   : DtWidgetBuilder()
{
}

DtSimulationStatusDisplayBuilder::~DtSimulationStatusDisplayBuilder()
{
}

QWidget* DtSimulationStatusDisplayBuilder::create( DtDe& de, QWidget* parent, 
   const Qt::WindowFlags& flags)
{
   return new DtSimulationStatusDisplay(de, parent);
}

//New main menu. This menu will be used to hold the Remote Control Console menu item
class DtRemoteControlMenu : public DtMenu
{
public:
   DtRemoteControlMenu(DtDe& de)
      : DtMenu(de, "DtRemoteControlMenu")
   {
   }

   virtual ~DtRemoteControlMenu() override {}

   virtual QMenu* createMenu(DtDe& de, QWidget* parent) override
   {
      QMenu* menu = new QMenu(QObject::tr("Remote Control"), parent);

      return menu;
   }
};

//This menu item will create and display the remote control console dialog which will be an example of
//how to use the DtCrossThreadVrfRemoteControl (the GUI version of the DtVrfRemoteController)
class DtRemoteControlMenuItem : public DtMenuItem
{
public:
   DtRemoteControlMenuItem(DtDe& de)
   : DtMenuItem("DtRemoteControlMenuItem")
   , myConsole(0)
   , myDe(de)
   {
   }

   virtual ~DtRemoteControlMenuItem() override {
      delete myConsole;
   }

     //Build a menu item (via an action).
   virtual QAction* createAction(DtDe&, QWidget* parent) override
   {
      return new QAction(tr("Remote Control Console..."), parent);
   }

protected:
   virtual void on_triggered() override
   {
      QAction* action = dynamic_cast<QAction*>(sender());
      QWidget* parent = 0;
      if(action)
      {
         parent = action->parentWidget();
      }

      if (!myConsole)
      {
         myConsole = new DtRemoteControlConsole(myDe, parent);
      }

      myConsole->show();
      myConsole->raise();
      qApp->setActiveWindow(myConsole);
      myConsole->myCommand->setFocus();
   }

protected:
   DtRemoteControlConsole* myConsole;
   DtDe& myDe;
};

void initPluginMenus(DtVrvApplication& app, DtDe& de)
{
   //First, register the creators with the menu assember
   DtQtMenuAssembler::instance(de).registerMenu(new DtRemoteControlMenu(de));
   DtQtMenuAssembler::instance(de).registerMenu(new DtRemoteControlMenuItem(de));

   //Now, add the menu to the master mode configuration.  mainMenu indicates that
   //the example menu is going to be used as a top-level main menu rather than a
   //sub-menu.  Add it before the Task menu.  To leave off the path will
   //put the menu at the end of the menu bar
   app.masterModeMenuConfiguration().addMenuPathBefore(DtMenuPath::mainMenu("DtRemoteControlMenu"),
      DtMenuPath::mainMenu("DtTaskMenu"));

   //Now, register the DtRemoteControlMenuItem as an item of DtRemoteControlMenu
   app.masterModeMenuConfiguration().addMenuPath(
      DtMenuPath::mainMenu("DtRemoteControlMenu").item("DtRemoteControlMenuItem"));
}


void setupNewToolbar(DtVrvApplication& app, DtDe& de)
{
   DtToolbar * tb = new DtSimulationStatusToolbar(de);
   DtQtToolbarAssembler::instance(de).registerToolbar(tb);

   DtSimulationStatusDisplayBuilder* bwb = new DtSimulationStatusDisplayBuilder(de);
   DtQtToolbarAssembler::instance(de).registerWidgetBuilder(
      "SimulationStatusDisplay", bwb);
   app.masterModeToolbarConfiguration().addToolbarPath(
      DtToolbarPath::toolbar("SimulationStatusToolbar").widget("SimulationStatusDisplay"));
}

bool initDeModule(DtDe* de)
{
   DtVrvApplication* igApp = DtVrvApplication::findFromDe(*de);
   if(igApp)
   {
      initPluginMenus(*igApp, *de);
      setupNewToolbar(*igApp, *de);
      return true;
   }
   else
   {
      return false;
   }
}

void DtPluginInformation(DtVrfPluginInformation& info)
{
   info.pluginName = "Cross Thread Vrf Remote Control";
   info.pluginDescription = "This example shows how to use the DtCrossThreadVrfRemoteControl class to control the simulation back-ends.";
   info.pluginVersion = "1.00";
   info.pluginCreator = "MAK Technologies";
   info.pluginCreatorEmail = "sales@mak.com";
   info.pluginContactWebPage = "www.mak.com";
   info.pluginContactMailingAddress = "10 Fawcett Street, Suite 204, Cambridge, MA 02138 USA";
   info.pluginContactPhone = "(617) 876 8085";
}