G4OpenGLXmViewerMessenger Class Reference

#include <G4OpenGLXmViewerMessenger.hh>

Inheritance diagram for G4OpenGLXmViewerMessenger:

Public Member Functions
	~G4OpenGLXmViewerMessenger ()
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 G4OpenGLXmViewerMessenger *	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 (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 40 of file G4OpenGLXmViewerMessenger.hh.

Constructor & Destructor Documentation

~G4OpenGLXmViewerMessenger()

G4OpenGLXmViewerMessenger::~G4OpenGLXmViewerMessenger

(

)

Definition at line 91 of file G4OpenGLXmViewerMessenger.cc.

{
  delete fpCommandSetZoomLow;
  delete fpCommandSetZoomHigh;
  delete fpCommandSetRotationHigh;
  delete fpCommandSetPanHigh;
  delete fpCommandSetDollyLow;
  delete fpCommandSetDollyHigh;
  delete fpDirectorySet;
  delete fpDirectory;
}

Member Function Documentation

GetInstance()

G4OpenGLXmViewerMessenger * G4OpenGLXmViewerMessenger::GetInstance ( )

static

Definition at line 44 of file G4OpenGLXmViewerMessenger.cc.

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

Referenced by G4OpenGLImmediateXm::G4OpenGLImmediateXm(), and G4OpenGLStoredXm::G4OpenGLStoredXm().

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 103 of file G4OpenGLXmViewerMessenger.cc.

{
  G4VisManager* pVisManager = G4VisManager::GetInstance();
 
  G4VViewer* pVViewer = pVisManager->GetCurrentViewer();
 
  if (!pVViewer) {
    G4cout <<
      "G4OpenGLXmViewerMessenger::SetNewValue: No current viewer."
      "\n  \"/vis/open\", or similar, to get one."
           << G4endl;
    return;
  }
 
  G4OpenGLXmViewer* pViewer = dynamic_cast<G4OpenGLXmViewer*>(pVViewer);
 
  if (!pViewer) {
    G4cout <<
      "G4OpenGLXmViewerMessenger::SetNewValue: Current viewer is not of type"
      "\n  OGLIXm or OGLSXm.  Use \"/vis/viewer/select\" or \"/vis/open\"."
           << G4endl;
    return;
  }
 
  G4bool panningControlPanel = true;
  G4bool rotationControlPanel = true;
 
  if (command == fpCommandSetDollyHigh)
    {
      if (pViewer->fpdolly_slider)
    {
      pViewer->dolly_high =
        fpCommandSetDollyHigh->GetNewDoubleValue(newValue);
      pViewer->fpdolly_slider->SetMaxValue (pViewer->dolly_high);
      if (pViewer->fVP.GetDolly() > pViewer->dolly_high)
        {
          pViewer->fpdolly_slider->SetInitialValue (pViewer->dolly_high);
          pViewer->fVP.SetDolly(pViewer->dolly_high);
        }
      else
        {
          pViewer->fpdolly_slider->SetInitialValue (pViewer->fVP.GetDolly());
        }
    }
      else
    {
      panningControlPanel = false;
    }
    }
 
  else if (command == fpCommandSetDollyLow)
    {
      if (pViewer->fpdolly_slider)
    {
      pViewer->dolly_low =
        fpCommandSetDollyLow->GetNewDoubleValue(newValue);
      pViewer->fpdolly_slider->SetMinValue (pViewer->dolly_low);
      if (pViewer->fVP.GetDolly() < pViewer->dolly_low)
        {
          pViewer->fpdolly_slider->SetInitialValue (pViewer->dolly_low);
          pViewer->fVP.SetDolly(pViewer->dolly_low);
        }
      else
        {
          pViewer->fpdolly_slider->SetInitialValue (pViewer->fVP.GetDolly());
        }
    }
      else
    {
      panningControlPanel = false;
    }
    }
 
  else if (command == fpCommandSetPanHigh)
    {
      if (pViewer->fppanning_slider)
    {
      pViewer->pan_sens_limit =
        fpCommandSetPanHigh->GetNewDoubleValue(newValue);
      pViewer->fppanning_slider->SetMaxValue (pViewer->pan_sens_limit);
      pViewer->fppanning_slider->SetInitialValue (pViewer->pan_sens_limit / 2.);
    }
      else
    {
      panningControlPanel = false;
    }
    }
 
  else if (command == fpCommandSetRotationHigh)
    {
      if (pViewer->fprotation_slider)
    {
      // Internally in OpenGLXm, it's in degrees...
      pViewer->rot_sens_limit =
        fpCommandSetRotationHigh->GetNewDoubleValue(newValue) / deg;
      pViewer->fprotation_slider->SetMaxValue (pViewer->rot_sens_limit);
      pViewer->fprotation_slider->SetInitialValue (pViewer->rot_sens_limit / 2.);
    }
      else
    {
      rotationControlPanel = false;
    }
    }
 
  else if (command == fpCommandSetZoomHigh)
    {
      if (pViewer->fpzoom_slider)
    {
      pViewer->zoom_high =
        fpCommandSetZoomHigh->GetNewDoubleValue(newValue);
      pViewer->fpzoom_slider->SetMaxValue (pViewer->zoom_high);
      pViewer->fpzoom_slider->SetInitialValue (pViewer->fVP.GetZoomFactor());
      if (pViewer->fVP.GetZoomFactor() > pViewer->zoom_high)
        {
          pViewer->fpzoom_slider->SetInitialValue (pViewer->zoom_high);
          pViewer->fVP.SetZoomFactor(pViewer->zoom_high);
        }
      else
        {
          pViewer->fpzoom_slider->SetInitialValue (pViewer->fVP.GetZoomFactor());
        }
    }
      else
    {
      panningControlPanel = false;
    }
    }
 
  else if (command == fpCommandSetZoomLow)
    {
      if (pViewer->fpzoom_slider)
    {
      pViewer->zoom_low =
        fpCommandSetZoomLow->GetNewDoubleValue(newValue);
      pViewer->fpzoom_slider->SetMinValue (pViewer->zoom_low);
      pViewer->fpzoom_slider->SetInitialValue (pViewer->fVP.GetZoomFactor());
      if (pViewer->fVP.GetZoomFactor() < pViewer->zoom_low)
        {
          pViewer->fpzoom_slider->SetInitialValue (pViewer->zoom_low);
          pViewer->fVP.SetZoomFactor(pViewer->zoom_low);
        }
      else
        {
          pViewer->fpzoom_slider->SetInitialValue (pViewer->fVP.GetZoomFactor());
        }
    }
      else
    {
      panningControlPanel = false;
    }
    }
 
  if (!panningControlPanel)
    {
      G4cout << 
        "G4OpenGLXmViewerMessenger::SetNewValue: pull down panning"
        "\n  control panel and re-issue command."
         << G4endl;
      return;
    }
 
  if (!rotationControlPanel)
    {
      G4cout << 
        "G4OpenGLXmViewerMessenger::SetNewValue: pull down rotation"
        "\n  control panel and re-issue command."
         << G4endl;
      return;
    }
 
  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/rebuild");
}

---

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

• G4OpenGLXmViewerMessenger.hh
• G4OpenGLXmViewerMessenger.cc