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)
G4bool	CommandsShouldBeInMaster () const

Static Public Member Functions
static G4OpenGLViewerMessenger *	GetInstance ()

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	LtoS (G4long l)
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 (const 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