G4OpenGLViewerMessenger Class Reference

#include <G4OpenGLViewerMessenger.hh>

Inheritance diagram for G4OpenGLViewerMessenger:

Public Member Functions
	~G4OpenGLViewerMessenger ()
void	SetNewValue (G4UIcommand *, G4String)
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
virtual void	SetNewValue (G4UIcommand *command, G4String newValue)
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const

Static Public Member Functions
static G4OpenGLViewerMessenger *	GetInstance ()

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (const G4String &s)
G4long	StoL (const G4String &s)
G4double	StoD (const G4String &s)
G4bool	StoB (G4String s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false

Detailed Description

Definition at line 43 of file G4OpenGLViewerMessenger.hh.

Constructor & Destructor Documentation

~G4OpenGLViewerMessenger()

G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger

(

)

Definition at line 178 of file G4OpenGLViewerMessenger.cc.

{
  delete fpCommandTransparency;
  delete fpCommandPrintSize;
  delete fpCommandPrintMode;
  delete fpCommandPrintFilename;
  delete fpCommandExportFormat;
  delete fpCommandDisplayListLimit;
  delete fpDirectorySet;
  delete fpCommandFlushAt;
  delete fpCommandExport;
  delete fpDirectory;
 
  delete fpInstance;
}

Member Function Documentation

GetInstance()

G4OpenGLViewerMessenger * G4OpenGLViewerMessenger::GetInstance ( )

static

Definition at line 48 of file G4OpenGLViewerMessenger.cc.

{
  if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
  return fpInstance;
}

Referenced by G4OpenGLImmediateQt::G4OpenGLImmediateQt(), G4OpenGLImmediateWin32::G4OpenGLImmediateWin32(), G4OpenGLImmediateX::G4OpenGLImmediateX(), G4OpenGLImmediateXm::G4OpenGLImmediateXm(), G4OpenGLStoredQt::G4OpenGLStoredQt(), G4OpenGLStoredWin32::G4OpenGLStoredWin32(), G4OpenGLStoredX::G4OpenGLStoredX(), and G4OpenGLStoredXm::G4OpenGLStoredXm().

SetNewValue()

void G4OpenGLViewerMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValue  )

virtual

Reimplemented from G4UImessenger.

Definition at line 194 of file G4OpenGLViewerMessenger.cc.

{
  G4VisManager* pVisManager = G4VisManager::GetInstance();
 
  G4VViewer* pViewer = pVisManager->GetCurrentViewer();
  if (!pViewer) {
    G4cout <<
      "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
      "\n  \"/vis/open\", or similar, to get one."
           << G4endl;
    return;
  }
 
  G4VSceneHandler* pSceneHandler = pViewer->GetSceneHandler();
  if (!pSceneHandler) {
    G4cout <<
    "G4OpenGLViewerMessenger::SetNewValue: This viewer has no scene handler."
    "\n  Shouldn't happen - please report circumstances."
    "\n  (Viewer is \"" << pViewer->GetName() << "\".)"
    "\n  Try \"/vis/open\", or similar, to get one."
    << G4endl;
    return;
  }
  
  G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
  if (!pOGLViewer) {
    G4cout <<
      "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
      "\n  OGL.  (It is \""
       << pViewer->GetName() <<
      "\".)\n  Use \"/vis/viewer/select\" or \"/vis/open\"."
           << G4endl;
    return;
  }
 
  G4OpenGLSceneHandler* pOGLSceneHandler =
  dynamic_cast<G4OpenGLSceneHandler*>(pSceneHandler);
  if (!pOGLSceneHandler) {
    G4cout <<
    "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
    "\n  OGL.  (Viewer is \"" << pViewer->GetName() << "\".)"
    "\n  (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
    "\n  Use \"/vis/sceneHandler/list\" and \"/vis/sceneHandler/select\""
    "\n  or \"/vis/open\"."
    << G4endl;
    return;
  }
 
  if (command == fpCommandExport)
  {
    G4String name;
    G4int width,height;
    std::istringstream iss(newValue);
    iss >> name >> width >> height;
    pOGLViewer->exportImage(name, width, height);
    
    if (pOGLViewer->fVP.IsAutoRefresh())
      G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
    return;
  }
  
  if (command == fpCommandExportFormat)
  {
    G4String name;
    std::istringstream iss(newValue);
    iss >> name;
    pOGLViewer->setExportImageFormat(name);
 
    return;
  }
 
  if (command == fpCommandFlushAt)
  {
    static G4bool firstTime = true;
    static std::map<G4String,G4OpenGLSceneHandler::FlushAction> actionMap;
    if (firstTime) {
      actionMap["endOfEvent"]    = G4OpenGLSceneHandler::endOfEvent;
      actionMap["endOfRun"]      = G4OpenGLSceneHandler::endOfRun;
      actionMap["eachPrimitive"] = G4OpenGLSceneHandler::eachPrimitive;
      actionMap["NthPrimitive"]  = G4OpenGLSceneHandler::NthPrimitive;
      actionMap["NthEvent"]      = G4OpenGLSceneHandler::NthEvent;
      actionMap["never"]         = G4OpenGLSceneHandler::never;
      firstTime = false;
    }
    G4String action;
    G4int entitiesFlushInterval;
    std::istringstream iss(newValue);
    iss >> action >> entitiesFlushInterval;
    pOGLSceneHandler->SetFlushAction(actionMap[action]);
    pOGLSceneHandler->SetEntitiesFlushInterval(entitiesFlushInterval);
    return;
  }
 
  if (command == fpCommandPrintFilename)
    {
      G4String name;
      G4bool inc;
      std::istringstream iss(newValue);
      iss >> name
    >> inc;
      pOGLViewer->setExportFilename(name,inc);
      return;
    }
 
  if (command == fpCommandPrintMode)
    {
      if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
 
      if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
      return;
    }
 
  if (command == fpCommandPrintSize)
    {
      G4int width,height;
      std::istringstream iss(newValue);
      iss >> width
    >> height;
      pOGLViewer->setExportSize(width,height);
      return;
    }
 
  if (command == fpCommandTransparency)
    {
      pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
      if (pOGLViewer->fVP.IsAutoRefresh())
  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
      return;
    }
 
  // Stored viewer commands
  G4OpenGLStoredViewer* pOGLSViewer =
    dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
 
  if (!pOGLSViewer)
    {
      G4cout <<
  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
  "\n  (It is \"" << pViewer->GetName() << "\".)"
  "\n  This feature is only implemented for OGL Stored viewers."
  "\n  Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
         << G4endl;
      return;
    }
 
  // Scene handler commands
  G4OpenGLStoredSceneHandler* pOGLSSceneHandler =
    dynamic_cast<G4OpenGLStoredSceneHandler*>(pViewer->GetSceneHandler());
 
  if (!pOGLSSceneHandler) {
    G4cout <<
  "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
  "\n  OGLS (Stored).  (Viewer is \"" << pViewer->GetName() << "\".)"
  "\n  (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
  "\n  This feature is only implemented for OGL Stored"
  "\n  scene handlers.  Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
           << G4endl;
    return;
  }
 
  if (command == fpCommandDisplayListLimit)
    {
      G4cerr << command->GetGuidanceLine(0) << G4endl;
      return;
    }
}

---

The documentation for this class was generated from the following files:

• G4OpenGLViewerMessenger.hh
• G4OpenGLViewerMessenger.cc