exampleSymbolFacade

Table of Contents

• Overview
• Expected Result
• Example details
• DtSymbolDriverToolbar.h
• DtSymbolDriverToolbar.cxx
• DtRotateSymbolDialog.h
• DtRotateSymbolDialog.cxx
• DtSymbolFacade.h
• DtSymbolFacade.cxx
• DtExampleSymbolDriver.h
• DtExampleSymbolDriver.cxx
• exampleSymbolFacade.cxx
• exampleSymbolFacade.h

Overview

This example builds on the symbol facade and driver from the previous examples in this tutorial series, and shows additional steps that are necessary for deleting symbols using an item on the symbol's context menu.

Expected Result

Symbol Facade Result

Example details

A menu item for deleting the selected symbols was first created and registered with the menu assembler. The menu item should only be enabled if a symbol is selected, so the menu item's on_aboutToShow method performs this check.

      void DtDeleteSymbolItem::on_aboutToShow()
      {
         // Get the symbol driver for determining if symbols are selected.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );

         // Only enable the MenuItem if symbols are selected.
         myAction->setEnabled( ! symbolDriver->selectedSymbols().empty() );
      }

When the user clicks on the menu item, it tells the driver to delete the selected symbols.

         // Tell the driver to delete the selected symbols.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );
         symbolDriver->deleteSelectedSymbols();

The driver's deleteSelectedSymbols method was created to iterate over all selected objects and delete the symbols.

      void DtExampleSymbolDriver::deleteSelectedSymbols()
      {
         SymbolList::iterator i = myCurrentlySelectedSymbols.begin();
         SymbolList::iterator e = myCurrentlySelectedSymbols.end();
         DtSelectionManager::IdSet idsToRemove;
         DtElementID symbolId;
         for ( ; i != e; ++i )
         {
            symbolId = (*i)->elementId();

            idsToRemove.insert(symbolId);

            delete *i;
            mySymbolFacades.erase( symbolId );
            reportElementDestroyed( symbolId );
         }

         DtSelectionManager::instance( myAgentManager.de() ).removeFromCurrentSelection(idsToRemove);
         myCurrentlySelectedSymbols.clear();
      }

• DtSymbolDriverToolbar.h
• DtSymbolDriverToolbar.cxx
• DtRotateSymbolDialog.h
• DtRotateSymbolDialog.cxx
• DtSymbolFacade.h
• DtSymbolFacade.cxx
• DtExampleSymbolDriver.h
• DtExampleSymbolDriver.cxx
• exampleSymbolFacade.cxx
• exampleSymbolFacade.h

---

DtSymbolDriverToolbar.h

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


#pragma once

#include <exampleSymbolFacade.h>

#include <vrvCoreQt/DtToolbar.h>
#include <vrvCoreQt/DtMenuItem.h>
#include <vrvCoreQt/DtMenu.h>

#include <vrvUtil/DtSignalConnectionManager.h>

namespace makVrv
{
   class DtDe;
   class DtDriver;
}

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      class DT_DLL_exampleSymbolFacade DtSymbolDriverToolbar
         : public makVrv::DtToolbar
      {
      public:

         DtSymbolDriverToolbar( makVrv::DtDe& );

         virtual ~DtSymbolDriverToolbar();

         virtual QToolBar* createToolbar( makVrv::DtDe&, QWidget* parent );

      };


      class DT_DLL_exampleSymbolFacade DtAddSymbolItem : public makVrv::DtMenuItem
      {
      public:

         DtAddSymbolItem( makVrv::DtDe& de );

         virtual ~DtAddSymbolItem();

         virtual QAction* createAction( makVrv::DtDe&, QWidget* parent );

         virtual void slot_driverStopped(DtDriver&);
         virtual void slot_driverStarted(DtDriver&);

         virtual void slot_listenForDriverManagerSignals();

         virtual void on_triggered();

      protected:

         QAction* myAction;

         makVrv::DtDe& myDe;

         DtSignalConnectionManager        myConnectionManager;

      };


      class DT_DLL_exampleSymbolFacade DtRotateSymbolItem : public makVrv::DtMenuItem
      {
      public:

         DtRotateSymbolItem( makVrv::DtDe& de );

         virtual ~DtRotateSymbolItem();

         virtual QAction* createAction( makVrv::DtDe&, QWidget* parent );

         virtual void on_aboutToShow();

         virtual void on_triggered();

      protected:

         QAction* myAction;

         makVrv::DtDe& myDe;

      };


      class DT_DLL_exampleSymbolFacade DtHideSymbolItem : public makVrv::DtMenuItem
      {
      public:

         DtHideSymbolItem( makVrv::DtDe& de );

         virtual ~DtHideSymbolItem();

         virtual QAction* createAction( makVrv::DtDe&, QWidget* parent );

         virtual void on_aboutToShow();

         virtual void on_triggered();

      protected:

         QAction* myAction;

         makVrv::DtDe& myDe;

      };


      class DT_DLL_exampleSymbolFacade DtDeleteSymbolItem : public makVrv::DtMenuItem
      {
      public:

         DtDeleteSymbolItem( makVrv::DtDe& de );

         virtual ~DtDeleteSymbolItem();

         virtual QAction* createAction( makVrv::DtDe&, QWidget* parent );

         virtual void on_aboutToShow();

         virtual void on_triggered();

      protected:

         QAction* myAction;

         makVrv::DtDe& myDe;

      };

      class DT_DLL_exampleSymbolFacade DtSymbolFacadeExampleMenu : public DtMenu
      {
      public:
         DtSymbolFacadeExampleMenu(DtDe& de);

         virtual ~DtSymbolFacadeExampleMenu();

         virtual QMenu* createMenu( DtDe& de, QWidget* parent );
      };

   }
}

DtSymbolDriverToolbar.cxx

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


#include <DtSymbolDriverToolbar.h>

#include <DtExampleSymbolDriver.h>
#include <DtRotateSymbolDialog.h>
#include <DtSymbolFacade.h>

#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtDe.h>

#include <QtWidgets/QToolBar>
#include <QtWidgets/QAction>
#include <QtWidgets/QMenu>

#include <matrix/vlVector.h>

#include <time.h>
#include <math.h>

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      DtSymbolDriverToolbar::DtSymbolDriverToolbar( DtDe& de )
         : DtToolbar( de, "DtSymbolDriverToolbar" )
      {
      }

      DtSymbolDriverToolbar::~DtSymbolDriverToolbar()
      {
      }

      QToolBar* DtSymbolDriverToolbar::createToolbar( DtDe&, QWidget* parent )
      {
         QToolBar* bar = new QToolBar( parent );
         bar->setWindowTitle( QObject::tr("Symbol Driver Toolbar") );
         bar->setObjectName( QObject::tr("Symbol Driver Toolbar") );
         return bar;
      }


      DtAddSymbolItem::DtAddSymbolItem( DtDe& de )
         : DtMenuItem( "DtAddSymbolItem" )
         , myAction(0)
         , myDe( de )
         , myConnectionManager()
      {
         // Seed the random number generator.
         srand( time(NULL ) );

         // when de is initialized, listen to driver manager signals
         de.signal_postInitialize.connect(boost::bind(
            &DtAddSymbolItem::slot_listenForDriverManagerSignals, this));
      }

      DtAddSymbolItem::~DtAddSymbolItem()
      {
      }

      void DtAddSymbolItem::slot_listenForDriverManagerSignals()
      {
         myDe.signal_postInitialize.disconnect(boost::bind(
            &DtAddSymbolItem::slot_listenForDriverManagerSignals, this));

         myConnectionManager.manageConnection(myDe.driverManager().signal_driverStopped.connect(boost::bind(&DtAddSymbolItem::slot_driverStopped, this, _1)));
         myConnectionManager.manageConnection(myDe.driverManager().signal_driverStarted.connect(boost::bind(&DtAddSymbolItem::slot_driverStarted, this, _1)));
      }

      void DtAddSymbolItem::slot_driverStarted(DtDriver& d)
      {
         // A driver has been stopped - is it the one we care about?
         if (d.className() == "DtExampleSymbolDriver")
         {
            myAction->setEnabled(true);
         }
      }

      void DtAddSymbolItem::slot_driverStopped(DtDriver& d)
      {
         // A driver has been stopped - is it the one we care about?
         if (d.className() == "DtExampleSymbolDriver")
         {
            myAction->setEnabled(false);
         }
      }

      QAction* DtAddSymbolItem::createAction( DtDe&, QWidget* parent )
      {
         if (myAction)
         {
            return myAction;
         }

         myAction = new QAction(parent);
         myAction->setText(DtMenuItem::tr("&Add new symbol..."));
         myAction->setToolTip(DtMenuItem::tr("Create a new symbol..."));
         myAction->setIcon(QIcon(QObject::tr("../data/Icons/UtilityAdd.svg")));
         return myAction;
      }

      void DtAddSymbolItem::on_triggered()
      {
         // Keep track of how many symbols have been created.
         static int numSymbolsCreated = 0;

         // Give the symbol a unique name.
         DtString symbolName( "Symbol #" );
         symbolName += DtString(numSymbolsCreated);

         // Put the symbol somewhere random on the makland terrain.
         double rand_x = 4000.0*((double)rand())/RAND_MAX;
         double rand_y = 4000.0*((double)rand())/RAND_MAX;
         double rand_z = 4000.0*((double)rand())/RAND_MAX;
         DtVector location( rand_x, rand_y, rand_z );

         // Get the driver and create the symbol
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );
         symbolDriver->createSymbol( symbolName.string(), location );
         ++numSymbolsCreated;
      }


      DtRotateSymbolItem::DtRotateSymbolItem( DtDe& de )
         : DtMenuItem( "DtRotateSymbolItem" )
         , myAction( 0 )
         , myDe( de )
      {
      }

      DtRotateSymbolItem::~DtRotateSymbolItem()
      {
      }

      QAction* DtRotateSymbolItem::createAction( DtDe&, QWidget* parent )
      {
         if (myAction)
         {
            return myAction;
         }

         myAction = new QAction( parent );
         myAction->setText( DtMenuItem::tr("&Rotate symbol...") );
         myAction->setToolTip( DtMenuItem::tr("Rotate symbol...") );
         myAction->setIcon( QIcon(QObject::tr("../data/Icons/SetRestore.svg")) );
         return myAction;
      }

      void DtRotateSymbolItem::on_aboutToShow()
      {
         // Get the symbol driver for determining if symbols are selected.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );

         // Only enable the MenuItem if symbols are selected.
         myAction->setEnabled( ! symbolDriver->selectedSymbols().empty() );
      }

      void DtRotateSymbolItem::on_triggered()
      {
         // Prompt the user for the amount to rotate by.
         DtRotateSymbolDialog rotateDialog( myDe );
         int retCode = rotateDialog.exec();
         if ( retCode == QDialog::Rejected )
         {
            return;
         }

         // Get the list of selected symbols from the driver.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );
         DtExampleSymbolDriver::SymbolList selectedSymbols =
            symbolDriver->selectedSymbols();

         // Apply the rotation to selected symbols.
         DtExampleSymbolDriver::SymbolList::iterator i = selectedSymbols.begin();
         DtExampleSymbolDriver::SymbolList::iterator e = selectedSymbols.end();
         float angle = rotateDialog.selectedRotationAmount();
         for ( ; i != e; ++i )
         {
            (*i)->setRotation( angle );
         }
      }


      DtHideSymbolItem::DtHideSymbolItem( DtDe& de )
         : DtMenuItem( "DtHideSymbolItem" )
         , myAction( 0 )
         , myDe( de )
      {
      }

      DtHideSymbolItem::~DtHideSymbolItem()
      {
      }

      QAction* DtHideSymbolItem::createAction( DtDe&, QWidget* parent )
      {
         if (myAction)
         {
            return myAction;
         }

         myAction = new QAction( parent );
         myAction->setText( DtMenuItem::tr("&Hide symbol...") );
         myAction->setToolTip( DtMenuItem::tr("Hide symbol...") );
         myAction->setIcon( QIcon(QObject::tr("../data/Icons/ObserverViewsDelete.svg")) );
         return myAction;
      }

      void DtHideSymbolItem::on_aboutToShow()
      {
         // Get the symbol driver for determining if symbols are selected.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );

         // If no symbols are selected, disable the MenuItem.
         if ( symbolDriver->selectedSymbols().empty() )
         {
            myAction->setEnabled( false );
            return;
         }

         // Symbols are selected, enable the MenuItem.
         myAction->setEnabled( true );

         // Determine if any of the symbols are hidden.
         DtExampleSymbolDriver::SymbolList::iterator i, e;
         DtExampleSymbolDriver::SymbolList curSelSymbols =
            symbolDriver->selectedSymbols();
         bool hiddenSelected = false;
         i = curSelSymbols.begin();
         e = curSelSymbols.end();
         for ( ; i != e; ++i )
         {
            if ( ! (*i)->visible() )
            {
               hiddenSelected = true;
            }
         }

         // Update the MenuItem icon/text and store whether the
         // item should show or hide the symbol(s) when triggered.
         if ( hiddenSelected )
         {
            myAction->setText( DtMenuItem::tr("&Show symbol...") );
            myAction->setToolTip( DtMenuItem::tr("Show symbol...") );
            myAction->setIcon( QIcon(QObject::tr("../data/Icons/ObserverView.svg")) );
            myAction->setData( qVariantFromValue(hiddenSelected) );
         }
         else
         {
            myAction->setText( DtMenuItem::tr("&Hide symbol...") );
            myAction->setToolTip( DtMenuItem::tr("Hide symbol...") );
            myAction->setIcon( QIcon(QObject::tr("../data/Icons/ObserverViewsDelete.svg")) );
            myAction->setData( qVariantFromValue(hiddenSelected) );
         }
      }

      void DtHideSymbolItem::on_triggered()
      {
         // Get the list of selected symbols from the driver.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );
         DtExampleSymbolDriver::SymbolList selectedSymbols =
            symbolDriver->selectedSymbols();

         // Apply the rotation to selected symbols.
         DtExampleSymbolDriver::SymbolList::iterator i = selectedSymbols.begin();
         DtExampleSymbolDriver::SymbolList::iterator e = selectedSymbols.end();
         for ( ; i != e; ++i )
         {
            (*i)->setVisible( myAction->data().toBool() );
         }
      }


      DtDeleteSymbolItem::DtDeleteSymbolItem( DtDe& de )
         : DtMenuItem( "DtDeleteSymbolItem" )
         , myAction( 0 )
         , myDe( de )
      {
      }

      DtDeleteSymbolItem::~DtDeleteSymbolItem()
      {
      }

      QAction* DtDeleteSymbolItem::createAction( DtDe&, QWidget* parent )
      {
         if (myAction)
         {
            return myAction;
         }

         myAction = new QAction( parent );
         myAction->setText( DtMenuItem::tr("&Delete symbol...") );
         myAction->setToolTip( DtMenuItem::tr("Delete symbol...") );
         myAction->setIcon( QIcon(QObject::tr("../data/Icons/UtilityClose.svg")) );
         return myAction;
      }

      void DtDeleteSymbolItem::on_aboutToShow()
      {
         // Get the symbol driver for determining if symbols are selected.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );

         // Only enable the MenuItem if symbols are selected.
         myAction->setEnabled( ! symbolDriver->selectedSymbols().empty() );
      }

      void DtDeleteSymbolItem::on_triggered()
      {
         // Tell the driver to delete the selected symbols.
         DtExampleSymbolDriver* symbolDriver = (DtExampleSymbolDriver*)
            myDe.driverManager().findDriver( "DtExampleSymbolDriver" );
         symbolDriver->deleteSelectedSymbols();
      }

      DtSymbolFacadeExampleMenu::DtSymbolFacadeExampleMenu(DtDe& de)
      : DtMenu(de, "DtSymbolFacadeExampleMenu")
      {
      }

      DtSymbolFacadeExampleMenu::~DtSymbolFacadeExampleMenu()
      {
      }

      QMenu* DtSymbolFacadeExampleMenu::createMenu( DtDe& de, QWidget* parent )
      {
         QMenu* menu = new QMenu(QObject::tr("Example"), parent);

         return menu;
      }
   }
}

DtRotateSymbolDialog.h

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


#pragma once

#include <exampleSymbolFacade.h>

#include <QtWidgets/QDialog>

class QDoubleSpinBox;

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      class DT_DLL_exampleSymbolFacade DtRotateSymbolDialog : public QDialog
      {  Q_OBJECT;
      public:

         DtRotateSymbolDialog( makVrv::DtDe& de, QWidget* parent = 0,
            Qt::WindowFlags f = 0 );

         virtual ~DtRotateSymbolDialog();

         float selectedRotationAmount() const;

      private:

         DtRotateSymbolDialog( const DtRotateSymbolDialog& orig );

         DtRotateSymbolDialog& operator = ( const DtRotateSymbolDialog& orig );

      protected:

         void setupGui();

      protected:

         QDoubleSpinBox* myRotationSpinner;

      };

   }
}

DtRotateSymbolDialog.cxx

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


#include <DtRotateSymbolDialog.h>

#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QLabel>

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      DtRotateSymbolDialog::DtRotateSymbolDialog( DtDe& de,
            QWidget* parent /*= 0*/, Qt::WindowFlags f /*= 0 */ )
         : QDialog( parent, f )
         , myRotationSpinner( 0 )
      {
         setupGui();
         setWindowTitle(tr("Rotate Symbol"));
      }

      DtRotateSymbolDialog::~DtRotateSymbolDialog()
      {
      }

      void DtRotateSymbolDialog::setupGui()
      {
         QVBoxLayout* dialogLayout = new QVBoxLayout();

         QHBoxLayout* fieldLayout = new QHBoxLayout();
         {
            QLabel* fieldLabel = new QLabel();
            fieldLabel->setText( "Rotation (deg):" );
            fieldLayout->addWidget( fieldLabel );

            myRotationSpinner = new QDoubleSpinBox();
            myRotationSpinner->setMinimum( 0 );
            myRotationSpinner->setDecimals( 1 );
            myRotationSpinner->setMaximum( 360 );
            fieldLayout->addWidget( myRotationSpinner );
         }
         dialogLayout->addLayout( fieldLayout );

         QHBoxLayout* okCancelLayout = new QHBoxLayout();
         {
            okCancelLayout->addStretch( 1 );

            QPushButton* okButton = new QPushButton();
            okButton->setText( "OK" );
            okButton->setDefault( true );
            okCancelLayout->addWidget( okButton );
            connect( okButton, SIGNAL(clicked()), this, SLOT(accept()) );

            QPushButton* cancelButton = new QPushButton();
            cancelButton->setText( "Cancel" );
            cancelButton->setDefault( false );
            okCancelLayout->addWidget( cancelButton );
            connect( cancelButton, SIGNAL(clicked()), this, SLOT(reject()) );

            okCancelLayout->addStretch( 1 );
         }
         dialogLayout->addLayout( okCancelLayout );

         setLayout( dialogLayout );
      }

      float DtRotateSymbolDialog::selectedRotationAmount() const
      {
         return myRotationSpinner->value();
      }

   }
}

DtSymbolFacade.h

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


#pragma once

#include <exampleSymbolFacade.h>

#include <vrvCore/DtElementEntry.h>
#include <vrvCore/DtUniqueID.h>

#include <matrix/vlVector.h>

namespace makVrv
{
   class DtSceneObjectAgent;
   class DtWidgetLabelAgent;
   class DtAgentManagerInterface;
   class DtProjectedWidgetModelAgent;
}

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      class DT_DLL_exampleSymbolFacade DtSymbolFacade
      {
      public:

         DtSymbolFacade( makVrv::DtAgentManagerInterface& sceneInterface,
            makVrv::DtElementID id );

         virtual ~DtSymbolFacade();



         virtual makVrv::DtElementID elementId() const;

         virtual makVrv::DtWidgetLabelAgent& widgetLabelAgent();

         virtual void setVisible( bool visible );

         virtual bool visible() const;

         virtual void setPosition( const DtVector& pos );

         virtual void setRotation( float angleInDegrees );



         static makVrv::DtElementEntry::ElementType elementType();

      protected:

         // Sets up the sceneobject and widget agents.
         // Non-virtual (Called from CTOR).
         void initialize();

      protected:

         makVrv::DtElementID myElementId;

         makVrv::DtSceneObjectAgent* mySceneObjectAgent;
         makVrv::DtProjectedWidgetModelAgent* myProjectedWidgetModelAgent;
         makVrv::DtWidgetLabelAgent* myWidgetLabelAgent;

      };

   }
}

DtSymbolFacade.cxx

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


#include <DtSymbolFacade.h>

#include <vrvCore/DtProjectedWidgetModelAgent.hpp>
#include <vrvCore/DtObserverMode.h>
#include <vrvCore/DtObserverModeManager.h>
#include <vrvCore/DtWidgetLabelAgent.hpp>
#include <vrvCore/DtSceneObjectAgent.hpp>

#include <vrvCore/DtStateVisualizer.h>
#include <vrvCore/DtOverlayManager.h>
#include <vrvCore/DtWidgetSignaler.h>
#include <vrvCore/DtSceneObject.h>

#include <vlutil/vlUtil.h>
#include <matrix/vlMath.h>

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      DtSymbolFacade::DtSymbolFacade(
            DtAgentManagerInterface& sceneInterface, DtElementID id )
         : myElementId( id )
         , mySceneObjectAgent( DtSceneObjectAgent::create(sceneInterface) )
         , myProjectedWidgetModelAgent( DtProjectedWidgetModelAgent::create(sceneInterface) )
         , myWidgetLabelAgent( DtWidgetLabelAgent::create(sceneInterface) )
      {
         initialize();
      }

      DtSymbolFacade::~DtSymbolFacade()
      {
         // Remove the widget label agent from the PWMA and delete it.
         myProjectedWidgetModelAgent->removeWidget( myWidgetLabelAgent );
         DtDELETE( myWidgetLabelAgent );

         // Remove the PWMA from the scene object and delete it.
         mySceneObjectAgent->removeModel( myProjectedWidgetModelAgent );
         DtDELETE( myProjectedWidgetModelAgent );

         // Delete the scene object now that everything's been removed from it.
         DtDELETE( mySceneObjectAgent );
      }

      void DtSymbolFacade::initialize()
      {
         // Make sure the agents were fully created.
         if ( ! mySceneObjectAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create scene object agent." );
         if ( ! myProjectedWidgetModelAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create projected widget model agent." );
         if ( ! myWidgetLabelAgent ) DtTHROW_NEW( DtCorruptedState, "Unable to create widget label agent." );

         // Initialize the scene object
         mySceneObjectAgent->setModelSet( DtObserverMode::ModelSet2dIcons );  // PVD
         mySceneObjectAgent->setElementID( myElementId );
         mySceneObjectAgent->addModel( myProjectedWidgetModelAgent, DtStateVisualizer::EntityVisualizerType );

         // Initialize the label
         myWidgetLabelAgent->setOverlay( DtOverlayManager::ModelSet_2D_Icons_Overlay );
         myWidgetLabelAgent->setBackgroundImage( "$(DATA_DIR)/images/ArrowCircle.png" );
         myWidgetLabelAgent->setColor( 0.8f, 0.8f, 0.8f, 1.0f );
         myWidgetLabelAgent->setSize( 32, 32 );

         // Add the label to the projected widget model.
         myProjectedWidgetModelAgent->addWidget( myWidgetLabelAgent );

         // Enable events processing so symbols accept mouse input.
         // Enabling events for the widget label agent allows mouse click
         // events on the symbol to select them, as well as allowing for
         // the context menu to be shown on right-click.
         myWidgetLabelAgent->setEventsEnabled( true );
      }

      void DtSymbolFacade::setVisible( bool visible )
      {
         mySceneObjectAgent->setVisible( visible );
      }

      bool DtSymbolFacade::visible() const
      {
         DtSceneObject* obj =
            mySceneObjectAgent->findObject();
         if ( obj )
         {
            return obj->isVisible();
         }

         return false;
      }

      DtUniqueID DtSymbolFacade::elementId() const
      {
         return myElementId;
      }

      DtWidgetLabelAgent& DtSymbolFacade::widgetLabelAgent()
      {
         return *myWidgetLabelAgent;
      }

      void DtSymbolFacade::setPosition( const DtVector& pos )
      {
         mySceneObjectAgent->setPosition( 0, pos );
      }

      void DtSymbolFacade::setRotation( float angleInDegrees )
      {
         myWidgetLabelAgent->setRotation( DtDeg2Rad(angleInDegrees) );
      }

      // This is a static method that can be used to query what type of element
      // DtSymbolFacades are. The returned value indicates whether the symbol
      // is an entity, a prop, or a terrain (among other things).
      // For this example we'll consider the symbol to be an entity.
      DtElementEntry::ElementType DtSymbolFacade::elementType()
      {
         return DtElementEntry::Entity;
      }

   }
}

DtExampleSymbolDriver.h

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


#pragma once

#include <exampleSymbolFacade.h>

#include <vrvCore/DtDriver.h>

#include <vrvCore/DtSelectionManager.h>

#include <boost/unordered_set.hpp>

#include <matrix/vlVector.h>

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      class DtSymbolFacade;

      class DT_DLL_exampleSymbolFacade DtExampleSymbolDriver
         : public makVrv::DtDriver
      {
      public:

         typedef boost::unordered_set<DtSymbolFacade*> SymbolList;

      public:

         DtExampleSymbolDriver( makVrv::DtAgentManager& am );

         virtual ~DtExampleSymbolDriver();



         virtual const std::string& className() const;

         virtual bool onStart();

         virtual bool onStop();

         virtual bool onTick();




         virtual DtSymbolFacade* createSymbol( const std::string& name,
            const DtVector& pos );

         virtual DtSymbolFacade* findSymbol( makVrv::DtElementID id );

         virtual SymbolList selectedSymbols() const;

         virtual void deleteSelectedSymbols();


      protected:

         virtual void positionSymbol( DtSymbolFacade* symbol, const DtVector& pos );

         virtual void slot_currentSelectionChanged(
            const makVrv::DtSelectionManager::IdSet& selected,
            const makVrv::DtSelectionManager::IdSet& deselected,
            makVrv::DtSelectionManager::SelectionType newType,
            makVrv::DtSelectionManager::SelectionType oldType );

         virtual void slot_displayEngineAdded( const makVrv::DtDeRecord& igRecord );

      protected:

         typedef boost::unordered_map<makVrv::DtElementID,DtSymbolFacade*> SymbolFacadeMap;

         SymbolFacadeMap mySymbolFacades;

         SymbolList myCurrentlySelectedSymbols;

      };

   }
}

DtExampleSymbolDriver.cxx

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


#include <DtExampleSymbolDriver.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtScene.h>
#include <vrvCore/DtAgentManager.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtElementAttributes.h>

#include <vrvCore/DtWidgetAgent.hpp>
#include <vrvCore/DtWidgetLabelAgent.hpp>
#include <vrvCore/DtSceneObjectAgent.hpp>
#include <vrvCore/DtProjectedWidgetModelAgent.hpp>
#include <vrvCore/DtDataBank.h>

#include <vrvUtil/DtCoordinateConverter.h>
#include <vrvUtil/DtCoordinateSystem.h>

#include <matrix/vlVector.h>

#include <DtSymbolFacade.h>

namespace makVrv
{

   namespace exampleSymbolFacade
   {

      DtExampleSymbolDriver::DtExampleSymbolDriver( DtAgentManager& am )
         : makVrv::DtDriver( am, "DtExampleSymbolDriver" )
      {
      }

      DtExampleSymbolDriver::~DtExampleSymbolDriver()
      {
         DtExampleSymbolDriver::onStop();
      }

      const std::string& DtExampleSymbolDriver::className() const
      {
         static std::string name = "DtExampleSymbolDriver";
         return name;
      }

      bool DtExampleSymbolDriver::onStart()
      {
         // Load the Makland programatically.
         DtScene& sceneDriver = myAgentManager.de().scene();
         std::string maklandPath = myAgentManager.de().dePathConfiguration().userPath();
         maklandPath += "/terrains/Makland.mtf";
         sceneDriver.loadTerrain( maklandPath );

         // Listen for selection changes.
         DtSelectionManager& selectionManager =
            DtSelectionManager::instance( myAgentManager.de() );
         selectionManager.signal_currentSelectionChanged.connect( boost::bind(
            &DtExampleSymbolDriver::slot_currentSelectionChanged,
            this, _1, _2, _3, _4 ) );

         return true;
      }

      bool DtExampleSymbolDriver::onStop()
      {
         // Stop listening for selection changes.
         DtSelectionManager& selectionManager =
            DtSelectionManager::instance( myAgentManager.de() );
         selectionManager.signal_currentSelectionChanged.disconnect(
            boost::bind( &DtExampleSymbolDriver::slot_currentSelectionChanged,
            this, _1, _2, _3, _4 ) );

         // Delete all created facades.
         SymbolFacadeMap::iterator i = mySymbolFacades.begin();
         SymbolFacadeMap::iterator e = mySymbolFacades.end();
         for ( ; i != e; ++i )
         {
            reportElementDestroyed(i->first);
            delete i->second;
         }

         // Clear the list of facades.
         mySymbolFacades.clear();

         // Apply changes manually since we're stopping the driver
         if (myChanges.hasChanges())
         {
            myAgentManager.de().dataBank().elementData().applyChanges(myChanges);
            myChanges.clear();
         }
         return true;
      }

      bool DtExampleSymbolDriver::onTick()
      {
         return true;
      }

      DtSymbolFacade* DtExampleSymbolDriver::createSymbol(
         const std::string& name, const DtVector& pos )
      {
         // Create symbol.
         DtElementID elementId = myAgentManager.createNewUniqueId();
         DtSymbolFacade* symbol = new DtSymbolFacade( myAgentManager, elementId );
         symbol->widgetLabelAgent().setColor( 0.8f, 0.8f, 0.8f, 1.0f );
         symbol->widgetLabelAgent().setSize( 32, 32 );

         // Store the symbol in the driver's symbol map.
         mySymbolFacades.insert( std::make_pair(elementId,symbol) );

         // Report that the symbol was created and report its name.
         // These commands report to VR-Vantage that a new object has been created
         // and that it should be managed as an object that may be visualized in various ways.
         reportElementCreated( elementId, 0, DtSymbolFacade::elementType() );
         reportElementAttribute( elementId, new DtElementAttributeDisplayName(name) );
         reportElementAttribute( elementId, new DtElementAttributeDriverType( "Symbol Driver" ) );

         // Position the symbol.
         positionSymbol( symbol, pos );
         return symbol;
      }

      DtSymbolFacade* DtExampleSymbolDriver::findSymbol( DtElementID symbolId )
      {
         SymbolFacadeMap::iterator itr = mySymbolFacades.find( symbolId );
         if ( itr != mySymbolFacades.end() )
            return itr->second;
         return NULL;
      }

      DtExampleSymbolDriver::SymbolList
         DtExampleSymbolDriver::selectedSymbols() const
      {
         return myCurrentlySelectedSymbols;
      }

      void DtExampleSymbolDriver::deleteSelectedSymbols()
      {
         SymbolList::iterator i = myCurrentlySelectedSymbols.begin();
         SymbolList::iterator e = myCurrentlySelectedSymbols.end();
         DtSelectionManager::IdSet idsToRemove;
         DtElementID symbolId;
         for ( ; i != e; ++i )
         {
            symbolId = (*i)->elementId();

            idsToRemove.insert(symbolId);

            delete *i;
            mySymbolFacades.erase( symbolId );
            reportElementDestroyed( symbolId );
         }

         DtSelectionManager::instance( myAgentManager.de() ).removeFromCurrentSelection(idsToRemove);
         myCurrentlySelectedSymbols.clear();
      }

      void DtExampleSymbolDriver::positionSymbol(
         DtSymbolFacade* symbol, const DtVector& pos )
      {
         // Initialize the coordinate converter with the position.
         DtCoordinateConverter* coordConverter =
            myAgentManager.de().sharedState().coordinateSystem().converter();
         coordConverter->setupTopoFrame( pos );

         // Convert the position (from ENU) to our local database (CIG) coordinate system.
         DtVector position;
         coordConverter->enuToCig_coordTrans( pos, position );
         symbol->setPosition( position );
      }

      void DtExampleSymbolDriver::slot_currentSelectionChanged(
         const DtSelectionManager::IdSet& selected,
         const DtSelectionManager::IdSet& deselected,
         DtSelectionManager::SelectionType newType,
         DtSelectionManager::SelectionType oldType )
      {
         DtSelectionManager::IdSet::const_iterator i, e;

         // Update selected symbols to indicate they're selected.
         e = selected.end();
         i = selected.begin();
         for ( ; i != e; ++i )
         {
            SymbolFacadeMap::iterator itr = mySymbolFacades.find( *i );
            if ( itr != mySymbolFacades.end() )
            {
               DtWidgetLabelAgent& label = itr->second->widgetLabelAgent();
               label.setColor( 1.0f, 1.0f, 1.0f, 1.0f );
               label.setSize( 36, 36 );
            }
         }

         // Revert deselected symbols to the default (unselected) look.
         e = deselected.end();
         i = deselected.begin();
         for ( ; i != e; ++i )
         {
            SymbolFacadeMap::iterator itr = mySymbolFacades.find( *i );
            if ( itr != mySymbolFacades.end() )
            {
               DtWidgetLabelAgent& label = itr->second->widgetLabelAgent();
               label.setColor( 0.8f, 0.8f, 0.8f, 1.0f );
               label.setSize( 32, 32 );
            }
         }

         // Don't try to maintain set of selected entities using the selected
         // and deselected lists passed in, just update using selection manager.
         DtSelectionManager& selMgr =
            DtSelectionManager::instance( myAgentManager.de() );
         const DtSelectionManager::IdSet& curSel = selMgr.currentSelections();
         DtSelectionManager::IdSet::const_iterator selItr = curSel.begin();
         DtSelectionManager::IdSet::const_iterator selEnd = curSel.end();
         myCurrentlySelectedSymbols.clear();
         for ( ; selItr != selEnd; ++selItr )
         {
            DtSymbolFacade* symbol = findSymbol(*selItr);
            if ( symbol )
            {
               myCurrentlySelectedSymbols.insert( symbol );
            }
         }
      }

      void DtExampleSymbolDriver::slot_displayEngineAdded( const DtDeRecord& igRecord )
      {
         // When a new display engine is connected to our driver, the driver
         // must be re-started in order to ensure the terrain and all symbols
         // are properly loaded on all connected De's.
         stop();
         start();
      }

   }
}

exampleSymbolFacade.cxx

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


#include <exampleSymbolFacade.h>

#include <vrvCoreQt/DtQtToolbarAssembler.h>
#include <vrvCoreQt/vrvCoreQt.h>
#include <vrvCoreQt/DtQtDeMainWindow.h>

#include <vrvCore/DtVrvApplication.h>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtToolbarPath.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeMainWindow.h>

#include <DtExampleSymbolDriver.h>
#include <DtSymbolDriverToolbar.h>

// Use the VR-Vantage namespace.
// All classes in VR-Vantage are in this namespace.
using namespace makVrv;

using namespace makVrv::exampleSymbolFacade;

bool initDeModule( DtDe* de )
{
   // Setup the plug-in.
   init( *de );
   return true;
}

void init( DtDe& de )
{
   // Ensure that init only gets called once
   // (not strictly necessary here, but this is good practice in general)
   DT_DE_INIT_ONCE( de );

   // Make sure that the vrvCoreQt and vrvOsgEarthQt module are init'ed.
   vrvCoreQt::init(de);

   // Don't show the startup dialog for selecting a terrain.
   DtDeMainWindow& mw = DtDeMainWindowProvider::instance(de).igMainWindow();
   DtQtDeMainWindow& mainWindow = dynamic_cast<DtQtDeMainWindow&>(mw);
   mainWindow.hideStartupDialog();

   //Add example menu and example page item.
   DtVrvApplication* igApp = DtVrvApplication::findFromDe(de);
   if ( igApp )
   {

      // Register the toolbar and MenuItems so they can be created where they're placed.
      DtQtToolbarAssembler::instance(de).registerToolbar( new DtSymbolDriverToolbar(de) );
      DtQtMenuAssembler::instance(de).registerMenu( new DtDeleteSymbolItem(de) );
      DtQtMenuAssembler::instance(de).registerMenu( new DtRotateSymbolItem(de) );
      DtQtMenuAssembler::instance(de).registerMenu( new DtHideSymbolItem(de) );
      DtQtMenuAssembler::instance(de).registerMenu( new DtAddSymbolItem(de) );
      
      // Add a new main menu to place example menu items that are also placed on the right click
      // context menu.  The new menu will be placed before the help menu
      DtQtMenuAssembler::instance(de).registerMenu( new DtSymbolFacadeExampleMenu(de) );
      igApp->masterModeMenuConfiguration().addMenuPathBefore(
         DtMenuPath::mainMenu("DtSymbolFacadeExampleMenu"), DtMenuPath::mainMenu("DtHelpMenu"));
      igApp->masterModeMenuConfiguration().addMenuPath(
         DtMenuPath::mainMenu("DtSymbolFacadeExampleMenu").item("DtAddSymbolItem") );
      igApp->masterModeMenuConfiguration().addMenuPath(
         DtMenuPath::mainMenu("DtSymbolFacadeExampleMenu").item("DtRotateSymbolItem") );
      igApp->masterModeMenuConfiguration().addMenuPath(
         DtMenuPath::mainMenu("DtSymbolFacadeExampleMenu").item("DtHideSymbolItem") );
      igApp->masterModeMenuConfiguration().addMenuPath(
         DtMenuPath::mainMenu("DtSymbolFacadeExampleMenu").item("DtDeleteSymbolItem") );

      // Add the buttons to the toolbar and context menu.
      igApp->masterModeToolbarConfiguration().addToolbarPath(
         DtToolbarPath::toolbar("DtSymbolDriverToolbar").item("DtAddSymbolItem") );
      igApp->masterModeMenuConfiguration().addMenuPath(
         DtMenuPath::popupMenu("DtObjectContextMenu").item("DtRotateSymbolItem") );
      igApp->masterModeMenuConfiguration().addMenuPath(
         DtMenuPath::popupMenu("DtObjectContextMenu").item("DtHideSymbolItem") );
      igApp->masterModeMenuConfiguration().addMenuPath(
         DtMenuPath::popupMenu("DtObjectContextMenu").item("DtDeleteSymbolItem") );
   }

   // We only want to create the driver if we are running in master mode.
   if ( de.isInMasterMode() )
   {
      // The accessory must be created after the DE's initialization is
      // finished, to make sure all the objects it uses exist.
      de.signal_postInitialize.connect( boost::bind(
         &installDriver, boost::ref(de) ) );
   }
}

void installDriver( DtDe& de )
{
   // Create DtExampleDriver.
   DtExampleSymbolDriver* driver = new DtExampleSymbolDriver( de.agentManager() );

   // The driver is now owned by the display engine. Do not delete it.
   de.driverManager().addDriver( driver );

   // Start the driver, creating the agent.
   de.driverManager().startDriver( driver );
}

exampleSymbolFacade.h

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


#pragma once

// Plugin export macro.
#ifdef _WIN32
#  ifdef exampleSymbolFacade_EXPORTS
#     define DT_DLL_exampleSymbolFacade __declspec ( dllexport )
#  else
#     define DT_DLL_exampleSymbolFacade __declspec ( dllimport )
#  endif
#else
#  define DT_DLL_exampleSymbolFacade
#endif

// Declare & export the plugin initialization function (bool initDeModule(DtDe* de))
#define DT_DE_PLUGIN_EXPORT_MACRO DT_DLL_exampleSymbolFacade
#include <vrvCore/exportPlugin.h>

// Plugin initialization methods.
DT_DLL_exampleSymbolFacade bool initDeModule( makVrv::DtDe* de );
DT_DLL_exampleSymbolFacade void init( makVrv::DtDe& de );
DT_DLL_exampleSymbolFacade void installDriver( makVrv::DtDe& de );

[<< Examples] [Home] [Top of Page]