DtDestroyedFilter

objectFilter.cxx

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

//\file objectFilter.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/DtVrfSelectionFilters.h>
#include <vrfGuiConstants/vrfMenuIds.h>
#include <vrvCore/DtVrvApplication.h>
#include <vrvCoreQt/DtMenu.h>
#include <vrvCoreQt/DtCheckedItem.h>
#include <vrvCoreQt/DtQtMenuAssembler.h>
#include <vrvCore/DtSubjectAnnouncer.h>
#include <vlpi/appearance.h>

#include <boost/bind.hpp>
#include <QMenu>
#include <QString>
#include <QtCore/QCoreApplication>

#include "objectFilterManager.h"

using namespace makVrv;

// This menu will be a submenu off of the Entities menu that will hold items that will
// allow the user to filter the display of objects
class DtObjectVisibilityMenu : public DtMenu
{
public:
   DtObjectVisibilityMenu(DtDe& de)
   : DtMenu(de, "DtObjectVisibilityMenu")
   {
   }

   ~DtObjectVisibilityMenu()
   {
   }

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

      return menu;
   }
};

template <typename _Filter>
class DtObjectVisibilityMenuItem : public makVrv::DtCheckedItem
{
public:
   DtObjectVisibilityMenuItem(makVrv::DtDe& de)
   : DtCheckedItem(de, _Filter().className())
   {
   }

   ~DtObjectVisibilityMenuItem()
   {
   }

   QAction* createAction(DtDe& de, QWidget* parent)
   {
      makVrv::DtUnicode text = makVrv::DtUnicode::tr("Hide ") + myFilter.filterName();
      makVrv::DtUnicode toolTip = makVrv::DtUnicode::tr("Show/Hide ") + myFilter.filterName();

      myOffText = text.translate<QString, QCoreApplication>();
      myToolTip = toolTip.translate<QString, QCoreApplication>();

      QAction* retVal = DtCheckedItem::createAction(de,parent);
      updateValue();
      return retVal;
   }

   void setValue( bool value )
   {
      DtObjectFilterManager::instance(myDe).activateFilter(value, myFilter);
   }

   bool getValue() const
   {
      return DtObjectFilterManager::instance(myDe).filterActive(myFilter);
   }

protected:
   _Filter myFilter;
};

class DtHideEntitiesFilter : public makVrf::DtVrfKindLessThanFilter
{
public:
   DtHideEntitiesFilter()
   : DtVrfKindLessThanFilter("DtHideEntitiesFilterId", makVrv::DtUnicode::tr("Entities"), DtEntityType(11, -1, -1, -1, -1, -1, -1))
   {
   }

   virtual DtVrfSelectionFilter* clone() const { return new DtHideEntitiesFilter(*this); };
};

class DtHideEntitiesByForceFilter : public makVrf::DtVrfKindLessThanFilter
{
public:
   DtHideEntitiesByForceFilter(int force, const makVrv::DtUnicode& forceName)
   : DtVrfKindLessThanFilter(("DtHideEntitiesByForceFilterId" + forceName.toAscii()), 
      (forceName + makVrv::DtUnicode::tr(" Entities")), DtEntityType(11, -1, -1, -1, -1, -1, -1), force)
   {
   }
};

class DtHideEntitiesByForceFriendlyFilter : public DtHideEntitiesByForceFilter
{
public:
   DtHideEntitiesByForceFriendlyFilter()
   : DtHideEntitiesByForceFilter(1, makVrv::DtUnicode::tr("Friendly")) 
   {
   }

   virtual DtVrfSelectionFilter* clone() const { return new DtHideEntitiesByForceFriendlyFilter(*this); };
};

class DtHideEntitiesByForceOpposingFilter : public DtHideEntitiesByForceFilter
{
public:
   DtHideEntitiesByForceOpposingFilter()
   : DtHideEntitiesByForceFilter(2, makVrv::DtUnicode::tr("Opposing")) 
   {
   }

   virtual DtVrfSelectionFilter* clone() const { return new DtHideEntitiesByForceOpposingFilter(*this); };
};

class DtHideEntitiesByForceNeutralFilter : public DtHideEntitiesByForceFilter
{
public:
   DtHideEntitiesByForceNeutralFilter()
   : DtHideEntitiesByForceFilter(3, makVrv::DtUnicode::tr("Neutral")) 
   {
   }

   virtual DtVrfSelectionFilter* clone() const { return new DtHideEntitiesByForceNeutralFilter(*this); };
};

class DtDestroyedFilter : public makVrf::DtVrfSelectionFilter
{
public:
   DtDestroyedFilter()
   : DtVrfSelectionFilter("DtDestroyedFilterId", makVrv::DtUnicode::tr("Destroyed"))
   {
   }

   DtDestroyedFilter(const DtDestroyedFilter& orig)
   : DtVrfSelectionFilter(orig)
   {
   }

   virtual bool isValid(const makVrv::DtVrlinkSimulatedBaseState* s) const
   {
      const makVrv::DtVrlinkSimulatedEntityState* ent = dynamic_cast<const makVrv::DtVrlinkSimulatedEntityState*>(s);

      if (ent)
      {
         DtEntityType t(ent->myEntityType.c_str());
         DtAppearance app(t);

         app.setAppearance(ent->myAppearance);
         return (app.damageState() == DtDamageDestroyed);
      }

      return false;
   }

   virtual void setForce(int)
   {
   }

   virtual DtVrfSelectionFilter* clone() const { return new DtDestroyedFilter(*this); };
};

void initPluginMenus(DtVrvApplication& app, DtDe& de)
{
   //First, register the creators with the menu assember
   DtQtMenuAssembler::instance(de).registerMenu(new DtObjectVisibilityMenu(de));
   DtQtMenuAssembler::instance(de).registerMenu(new DtObjectVisibilityMenuItem<DtHideEntitiesFilter>(de));
   DtQtMenuAssembler::instance(de).registerMenu(new DtObjectVisibilityMenuItem<DtDestroyedFilter>(de));
   DtQtMenuAssembler::instance(de).registerMenu(new DtObjectVisibilityMenuItem<DtHideEntitiesByForceFriendlyFilter>(de));
   DtQtMenuAssembler::instance(de).registerMenu(new DtObjectVisibilityMenuItem<DtHideEntitiesByForceOpposingFilter>(de));
   DtQtMenuAssembler::instance(de).registerMenu(new DtObjectVisibilityMenuItem<DtHideEntitiesByForceNeutralFilter>(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().addMenuPath(DtMenuPath::mainMenu(DtEntityMenuId).menu("DtObjectVisibilityMenu"));
   app.masterModeMenuConfiguration().addMenuPath(DtMenuPath::menu("DtObjectVisibilityMenu").item(DtHideEntitiesFilter().className()));
   app.masterModeMenuConfiguration().addMenuPath(DtMenuPath::menu("DtObjectVisibilityMenu").
      item(DtHideEntitiesByForceFriendlyFilter().className()));
   app.masterModeMenuConfiguration().addMenuPath(DtMenuPath::menu("DtObjectVisibilityMenu").
      item(DtHideEntitiesByForceOpposingFilter().className()));
   app.masterModeMenuConfiguration().addMenuPath(DtMenuPath::menu("DtObjectVisibilityMenu").
      item(DtHideEntitiesByForceNeutralFilter().className()));
   app.masterModeMenuConfiguration().addMenuPath(DtMenuPath::menu("DtObjectVisibilityMenu").item(DtDestroyedFilter().className()));
}

static void slot_activated(makVrv::DtDe* de)
{
   DtObjectFilterManager::instance(*de);
}

bool initDeModule(DtDe* de)
{
   DtVrvApplication* igApp = DtVrvApplication::findFromDe(*de);
   if(igApp)
   {
      initPluginMenus(*igApp, *de);

      makVrv::DtDeAnnouncer* announcer = makVrv::DtDeAnnouncer::findInstance(*de);

      if (announcer)
      {
         announcer->signal_deactivate.connect(boost::bind(&slot_activated, de));
      }
      return true;
   }
   else
   {
      return false;
   }
}

void DtPluginInformation(DtVrfPluginInformation& info)
{
   info.pluginName = "Object Filter";
   info.pluginDescription = "This example shows how to filter objects for visibility on the front-end.";
   info.pluginVersion = "1.00";
   info.pluginCreator = "MAK Technologies";
   info.pluginCreatorEmail = "sales@mak.com";
   info.pluginContactWebPage = "www.mak.com";
   info.pluginContactMailingAddress = "150 Cambridge Park Drive 3rd Floor - Cambridge, MA 02140 USA";
   info.pluginContactPhone = "(617) 876 8085";
}