DtRemoteControlMenuItem

guiThreadVrfRemoteController.cxx

/*******************************************************************************
** 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();
   virtual QToolBar* createToolbar(DtDe&, QWidget* parent);
};

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, _1));
   }

   virtual ~DtSimulationStatusDisplay()
   {
      if (!DtVrfGuiApplication::applicationIsTerminating(myDe))
      {
         DtVrfSimBackendManager::instance(myDe).signal_simulationStatusChanged.disconnect(
            boost::bind(&DtSimulationStatusDisplay::simulationStatusChanged, this, _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();
   virtual QWidget* create(DtDe& de, QWidget* parent,
      const Qt::WindowFlags& flags = 0);
};
//......................................................................
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")
   {
   }

   ~DtRemoteControlMenu()
   {
   }

   QMenu* createMenu( DtDe& de, QWidget* parent )
   {
      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()
   {
      delete myConsole;
   }

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

protected:
   void on_triggered()
   {
      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";
}