#include <G4VisCommandsViewerSet.hh>

Inheritance diagram for G4VisCommandsViewerSet:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const

	G4VisCommandsViewerSet ()

G4String	GetCurrentValue (G4UIcommand *command)

G4bool	operator!= (const G4UImessenger &messenger) const

G4bool	operator== (const G4UImessenger &messenger) const

void	SetNewValue (G4UIcommand *command, G4String newValue)

virtual	~G4VisCommandsViewerSet ()

Static Public Member Functions
static const G4Colour &	GetCurrentTextColour ()

static G4VisManager *	GetVisManager ()

static void	SetVisManager (G4VisManager *pVisManager)

Protected Member Functions
void	AddUIcommand (G4UIcommand *newCommand)

G4String	BtoS (G4bool b)

void	CheckSceneAndNotifyHandlers (G4Scene *=nullptr)

G4bool	CheckView ()

void	ConvertToColour (G4Colour &colour, const G4String &redOrString, G4double green, G4double blue, G4double opacity)

const G4String &	ConvertToColourGuidance ()

void	CopyCameraParameters (G4ViewParameters &target, const G4ViewParameters &from)

void	CopyGuidanceFrom (const G4UIcommand fromCmd, G4UIcommand toCmd, G4int startLine=0)

void	CopyMostViewParameters (G4ViewParameters &target, const G4ViewParameters &from)

void	CopyParametersFrom (const G4UIcommand fromCmd, G4UIcommand toCmd)

template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

void	DrawExtent (const G4VisExtent &)

G4String	DtoS (G4double a)

void	G4VisCommandsSceneAddUnsuccessful (G4VisManager::Verbosity verbosity)

void	InterpolateToNewView (G4VViewer *currentViewer, const G4ViewParameters &oldVP, const G4ViewParameters &newVP, const G4int nInterpolationPoints=50, const G4int waitTimePerPointmilliseconds=20, const G4String exportString="")

void	InterpolateViews (G4VViewer *currentViewer, std::vector< G4ViewParameters > viewVector, const G4int nInterpolationPoints=50, const G4int waitTimePerPointmilliseconds=20, const G4String exportString="")

G4String	ItoS (G4int i)

G4bool	ProvideValueOfUnit (const G4String &where, const G4String &unit, const G4String &category, G4double &value)

void	RefreshIfRequired (G4VViewer *viewer)

void	SetViewParameters (G4VViewer *viewer, const G4ViewParameters &viewParams)

G4bool	StoB (G4String s)

G4double	StoD (G4String s)

G4int	StoI (G4String s)

G4long	StoL (G4String s)

Static Protected Member Functions
static G4bool	ConvertToDoublePair (const G4String &paramString, G4double &xval, G4double &yval)

static G4String	ConvertToString (G4double x, G4double y, const char *unitName)

Protected Attributes
G4UIdirectory *	baseDir = nullptr

G4String	baseDirName = ""

G4bool	commandsShouldBeInMaster = false

Static Protected Attributes
static G4int	fCurrentArrow3DLineSegmentsPerCircle = 6

static G4Colour	fCurrentColour = G4Colour::White()

static G4VisExtent	fCurrentExtentForField

static G4double	fCurrentLineWidth = 1.

static G4Colour	fCurrentTextColour = G4Colour::Blue()

static G4Text::Layout	fCurrentTextLayout = G4Text::left

static G4double	fCurrentTextSize = 12.

static G4PhysicalVolumeModel::TouchableProperties	fCurrentTouchableProperties

static std::vector< G4PhysicalVolumesSearchScene::Findings >	fCurrrentPVFindingsForField

static G4VisManager *	fpVisManager = nullptr

static G4bool	fThereWasAViewer = false

static G4ViewParameters	fVPExistingViewer

Private Member Functions
	G4VisCommandsViewerSet (const G4VisCommandsViewerSet &)

G4VisCommandsViewerSet &	operator= (const G4VisCommandsViewerSet &)

Private Attributes
G4ThreeVector	fLightsVector

G4UIcmdWithAString *	fpCommandAll

G4UIcmdWithABool *	fpCommandAutoRefresh

G4UIcmdWithABool *	fpCommandAuxEdge

G4UIcommand *	fpCommandBackground

G4UIcommand *	fpCommandCulling

G4UIcmdWithAString *	fpCommandCutawayMode

G4UIcommand *	fpCommandDefaultColour

G4UIcommand *	fpCommandDefaultTextColour

G4UIcmdWithABool *	fpCommandEdge

G4UIcommand *	fpCommandExplodeFactor

G4UIcmdWithADouble *	fpCommandGlobalLineWidthScale

G4UIcmdWithADouble *	fpCommandGlobalMarkerScale

G4UIcmdWithABool *	fpCommandHiddenEdge

G4UIcmdWithABool *	fpCommandHiddenMarker

G4UIcmdWithAString *	fpCommandLightsMove

G4UIcommand *	fpCommandLightsThetaPhi

G4UIcommand *	fpCommandLightsVector

G4UIcmdWithAnInteger *	fpCommandLineSegments

G4UIcmdWithAnInteger *	fpCommandNumberOfCloudPoints

G4UIcmdWithABool *	fpCommandPicking

G4UIcommand *	fpCommandProjection

G4UIcmdWithAString *	fpCommandRotationStyle

G4UIcommand *	fpCommandSectionPlane

G4UIcmdWithABool *	fpCommandSpecialMeshRendering

G4UIcommand *	fpCommandSpecialMeshVolumes

G4UIcmdWithAString *	fpCommandStyle

G4UIcmdWith3VectorAndUnit *	fpCommandTargetPoint

G4UIcommand *	fpCommandTimeWindowDisplayHeadTime

G4UIcommand *	fpCommandTimeWindowDisplayLightFront

G4UIcommand *	fpCommandTimeWindowEndTime

G4UIcmdWithADouble *	fpCommandTimeWindowFadeFactor

G4UIcommand *	fpCommandTimeWindowStartTime

G4UIcommand *	fpCommandUpThetaPhi

G4UIcommand *	fpCommandUpVector

G4UIcommand *	fpCommandViewpointThetaPhi

G4UIcommand *	fpCommandViewpointVector

G4UIdirectory *	fpTimeWindowDirectory

G4ThreeVector	fUpVector

G4ThreeVector	fViewpointVector

Detailed Description

Definition at line 45 of file G4VisCommandsViewerSet.hh.

Constructor & Destructor Documentation

◆ G4VisCommandsViewerSet() [1/2]

G4VisCommandsViewerSet::G4VisCommandsViewerSet ( )

Definition at line 46 of file G4VisCommandsViewerSet.cc.

                                               :
fLightsVector    (G4ThreeVector(1.,1.,1.)),
fUpVector        (G4ThreeVector(0.,1.,0.)),
fViewpointVector (G4ThreeVector(0.,0.,1.))
{
  G4bool omitable;
  G4UIparameter* parameter;
 
  fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
  fpCommandAll->SetGuidance
  ("Copies view parameters.");
  fpCommandAll->SetGuidance
  ("Copies ALL view parameters (except the autoRefresh status) from"
   "\nfrom-viewer to current viewer. You may need \"/vis/viewer/rebuild\".");
  fpCommandAll->SetGuidance
  ("Note: to copy only the camera-specific parameters use"
   "\n\"/vis/viewer/copyfrom\".");
  fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
 
  fpCommandAutoRefresh = new G4UIcmdWithABool
  ("/vis/viewer/set/autoRefresh",this);
  fpCommandAutoRefresh->SetGuidance("Sets auto-refresh.");
  fpCommandAutoRefresh->SetGuidance
  ("If true, view is automatically refreshed after a change of"
   "\nview parameters.");
  fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true);
  fpCommandAutoRefresh->SetDefaultValue(true);
 
  fpCommandAuxEdge = new G4UIcmdWithABool
  ("/vis/viewer/set/auxiliaryEdge",this);
  fpCommandAuxEdge->SetGuidance("Sets visibility of auxiliary edges");
  fpCommandAuxEdge->SetGuidance
  ("Auxiliary edges, i.e., those that are part of a curved surface,"
   "\nsometimes called soft edges, become visible/invisible.");
  fpCommandAuxEdge->SetParameterName("edge",omitable = true);
  fpCommandAuxEdge->SetDefaultValue(true);
 
  fpCommandBackground = new G4UIcommand
  ("/vis/viewer/set/background",this);
  fpCommandBackground->SetGuidance
  ("Set background colour and transparency (default black and opaque).");
  fpCommandBackground->SetGuidance(ConvertToColourGuidance());
  parameter = new G4UIparameter("red_or_string", 's', omitable = true);
  parameter -> SetDefaultValue ("0.");
  fpCommandBackground -> SetParameter (parameter);
  parameter = new G4UIparameter("green", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommandBackground -> SetParameter (parameter);
  parameter = new G4UIparameter ("blue", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommandBackground -> SetParameter (parameter);
  parameter = new G4UIparameter ("opacity", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandBackground -> SetParameter (parameter);
 
  fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
  fpCommandCulling->SetGuidance ("Set culling options.");
  fpCommandCulling->SetGuidance
  ("\"global\": enables/disables all other culling options.");
  fpCommandCulling->SetGuidance
  ("\"coveredDaughters\": culls, i.e., eliminates, volumes that would not"
   "\nbe seen because covered by ancestor volumes in surface drawing mode,"
   "\nand then only if the ancestors are visible and opaque, and then only"
   "\nif no sections or cutaways are in operation.  Intended solely to"
   "\nimprove the speed of rendering visible volumes.");
  fpCommandCulling->SetGuidance
  ("\"invisible\": culls objects with the invisible attribute set.");
  fpCommandCulling->SetGuidance
  ("\"density\": culls volumes with density lower than threshold.  Useful"
   "\nfor eliminating \"container volumes\" with no physical correspondence,"
   "\nwhose material is usually air.  If this is selected, provide threshold"
   "\ndensity and unit (e.g., g/cm3, mg/cm3 or kg/m3)."
   );
  parameter = new G4UIparameter("culling-option",'s',omitable = false);
  parameter->SetParameterCandidates
  ("global coveredDaughters invisible density");
  fpCommandCulling->SetParameter(parameter);
  parameter = new G4UIparameter("action",'b',omitable = true);
  parameter->SetDefaultValue(1);
  fpCommandCulling->SetParameter(parameter);
  parameter = new G4UIparameter("density-threshold",'d',omitable = true);
  parameter->SetDefaultValue("0.01");
  fpCommandCulling->SetParameter(parameter);
  parameter = new G4UIparameter("unit",'s',omitable = true);
  // parameter->SetParameterCandidates ("g/cm3 mg/cm3 kg/m3");
  // Instead of the above, SetNewValue accepts *any* density unit.
  parameter->SetDefaultValue("g/cm3");
  fpCommandCulling->SetParameter(parameter);
 
  fpCommandCutawayMode =
  new G4UIcmdWithAString ("/vis/viewer/set/cutawayMode", this);
  fpCommandCutawayMode->SetGuidance
  ("Sets cutaway mode - add (union) or multiply (intersection).");
  fpCommandCutawayMode->SetParameterName ("cutaway-mode",omitable = false);
  fpCommandCutawayMode->SetCandidates ("add union multiply intersection");
  fpCommandCutawayMode->SetDefaultValue("union");
 
  fpCommandDefaultColour = new G4UIcommand
  ("/vis/viewer/set/defaultColour",this);
  fpCommandDefaultColour->SetGuidance
  ("Set defaultColour colour and transparency (default white and opaque).");
  fpCommandDefaultColour->SetGuidance(ConvertToColourGuidance());
  parameter = new G4UIparameter("red_or_string", 's', omitable = true);
  parameter -> SetDefaultValue ("1.");
  fpCommandDefaultColour -> SetParameter (parameter);
  parameter = new G4UIparameter("green", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandDefaultColour -> SetParameter (parameter);
  parameter = new G4UIparameter ("blue", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandDefaultColour -> SetParameter (parameter);
  parameter = new G4UIparameter ("opacity", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandDefaultColour -> SetParameter (parameter);
 
  fpCommandDefaultTextColour = new G4UIcommand
  ("/vis/viewer/set/defaultTextColour",this);
  fpCommandDefaultTextColour->SetGuidance
  ("Set defaultTextColour colour and transparency (default blue and opaque).");
  fpCommandDefaultTextColour->SetGuidance(ConvertToColourGuidance());
  parameter = new G4UIparameter("red_or_string", 's', omitable = true);
  parameter -> SetDefaultValue ("0.");
  fpCommandDefaultTextColour -> SetParameter (parameter);
  parameter = new G4UIparameter("green", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommandDefaultTextColour -> SetParameter (parameter);
  parameter = new G4UIparameter ("blue", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandDefaultTextColour -> SetParameter (parameter);
  parameter = new G4UIparameter ("opacity", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandDefaultTextColour -> SetParameter (parameter);
 
  fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
  fpCommandEdge->SetGuidance
  ("Edges become visible/invisible in surface mode.");
  fpCommandEdge->SetParameterName("edge",omitable = true);
  fpCommandEdge->SetDefaultValue(true);
 
  fpCommandExplodeFactor = new G4UIcommand
  ("/vis/viewer/set/explodeFactor", this);
  fpCommandExplodeFactor->SetGuidance
  ("Moves top-level drawn volumes by this factor from this centre.");
  parameter = new G4UIparameter("explodeFactor", 'd', omitable=true);
  parameter->SetParameterRange("explodeFactor>=1.");
  parameter->SetDefaultValue(1.);
  fpCommandExplodeFactor->SetParameter(parameter);
  parameter = new G4UIparameter("x",'d',omitable = true);
  parameter->SetDefaultValue  (0);
  parameter->SetGuidance      ("Coordinate of explode centre.");
  fpCommandExplodeFactor->SetParameter(parameter);
  parameter = new G4UIparameter("y",'d',omitable = true);
  parameter->SetDefaultValue  (0);
  parameter->SetGuidance      ("Coordinate of explode centre.");
  fpCommandExplodeFactor->SetParameter(parameter);
  parameter = new G4UIparameter("z",'d',omitable = true);
  parameter->SetDefaultValue  (0);
  parameter->SetGuidance      ("Coordinate of explode centre.");
  fpCommandExplodeFactor->SetParameter(parameter);
  parameter = new G4UIparameter("unit",'s',omitable = true);
  parameter->SetDefaultValue  ("m");
  parameter->SetGuidance      ("Unit of explode centre.");
  fpCommandExplodeFactor->SetParameter(parameter);
 
  fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble
  ("/vis/viewer/set/globalLineWidthScale", this);
  fpCommandGlobalLineWidthScale->SetGuidance
  ("Multiplies line widths by this factor.");
  fpCommandGlobalLineWidthScale->
  SetParameterName("scale-factor", omitable=true);
  fpCommandGlobalLineWidthScale->SetDefaultValue(1.);
 
  fpCommandGlobalMarkerScale = new G4UIcmdWithADouble
  ("/vis/viewer/set/globalMarkerScale", this);
  fpCommandGlobalMarkerScale->SetGuidance
  ("Multiplies marker sizes by this factor.");
  fpCommandGlobalMarkerScale->
  SetParameterName("scale-factor", omitable=true);
  fpCommandGlobalMarkerScale->SetDefaultValue(1.);
 
  fpCommandHiddenEdge =
  new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
  fpCommandHiddenEdge->SetGuidance
  ("Edges become hidden/seen in wireframe or surface mode.");
  fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
  fpCommandHiddenEdge->SetDefaultValue(true);
 
  fpCommandHiddenMarker =
  new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
  fpCommandHiddenMarker->SetGuidance
  ("If true, closer objects hide markers. Otherwise, markers always show.");
  fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
  fpCommandHiddenMarker->SetDefaultValue(true);
 
  fpCommandLightsMove = new G4UIcmdWithAString
  ("/vis/viewer/set/lightsMove",this);
  fpCommandLightsMove->SetGuidance
  ("Lights move with camera or with object");
  fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
  fpCommandLightsMove->SetCandidates
  ("cam camera with-camera obj object with-object");
 
  fpCommandLightsThetaPhi = new G4UIcommand
  ("/vis/viewer/set/lightsThetaPhi", this);
  fpCommandLightsThetaPhi->SetGuidance
  ("Set direction from target to lights.");
  parameter = new G4UIparameter("theta", 'd', omitable = true);
  parameter -> SetDefaultValue(60.);
  fpCommandLightsThetaPhi -> SetParameter (parameter);
  parameter = new G4UIparameter("phi", 'd', omitable = true);
  parameter -> SetDefaultValue(45.);
  fpCommandLightsThetaPhi -> SetParameter (parameter);
  parameter = new G4UIparameter ("unit", 's', omitable = true);
  parameter -> SetDefaultValue ("deg");
  fpCommandLightsThetaPhi -> SetParameter (parameter);
 
  fpCommandLightsVector = new G4UIcommand
  ("/vis/viewer/set/lightsVector", this);
  fpCommandLightsVector->SetGuidance
  ("Set direction from target to lights.");
  parameter = new G4UIparameter("x", 'd', omitable = true);
  parameter -> SetDefaultValue (1);
  fpCommandLightsVector -> SetParameter (parameter);
  parameter = new G4UIparameter("y", 'd', omitable = true);
  parameter -> SetDefaultValue (1);
  fpCommandLightsVector -> SetParameter (parameter);
  parameter = new G4UIparameter ("z", 'd', omitable = true);
  parameter -> SetDefaultValue (1);
  fpCommandLightsVector -> SetParameter (parameter);
 
  fpCommandLineSegments = new G4UIcmdWithAnInteger
  ("/vis/viewer/set/lineSegmentsPerCircle",this);
  fpCommandLineSegments->SetGuidance
  ("Set number of sides per circle for polygon/polyhedron drawing.");
  fpCommandLineSegments->SetGuidance
  ("Refers to graphical representation of objects with curved lines/surfaces.");
  fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
  fpCommandLineSegments->SetDefaultValue(24);
 
  fpCommandNumberOfCloudPoints = new G4UIcmdWithAnInteger
  ("/vis/viewer/set/numberOfCloudPoints",this);
  fpCommandNumberOfCloudPoints->SetGuidance
  ("Set number of points to be used for cloud representation of volumes.");
  fpCommandNumberOfCloudPoints->SetParameterName("points",omitable = true);
  fpCommandNumberOfCloudPoints->SetDefaultValue(10000);
 
  fpCommandPicking = new G4UIcmdWithABool
  ("/vis/viewer/set/picking",this);
  fpCommandPicking->SetGuidance("Sets picking, if available.");
  fpCommandPicking->SetGuidance
  ("If true, view is set up for picking, if available.");
  fpCommandPicking->SetGuidance
  ("You may need to issue \"/vis/viewer/update\".");
  fpCommandPicking->SetGuidance
  ("For required actions, watch for instructions for viewer.");
  fpCommandPicking->SetParameterName("picking",omitable = true);
  fpCommandPicking->SetDefaultValue(true);
 
  fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
  fpCommandProjection->SetGuidance
  ("Set projection style - o[rthogonal] or p[erspective]."
   "\nIf p[erspective], also set field half angle.");
  parameter = new G4UIparameter("projection",'s',omitable = true);
  parameter->SetParameterCandidates("o orthogonal p perspective");
  parameter->SetDefaultValue("orthogonal");
  fpCommandProjection->SetParameter(parameter);
  parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
  parameter->SetDefaultValue(30.);
  //parameter->SetCurrentAsDefault(true);
  fpCommandProjection->SetParameter(parameter);
  parameter = new G4UIparameter("unit",'s',omitable = true);
  parameter->SetDefaultValue("deg");
  //parameter->SetCurrentAsDefault(true);
  fpCommandProjection->SetParameter(parameter);
 
  fpCommandRotationStyle = new G4UIcmdWithAString
  ("/vis/viewer/set/rotationStyle",this);
  fpCommandRotationStyle->SetGuidance
  ("Set style of rotation - constrainUpDirection or freeRotation.");
  fpCommandRotationStyle->SetGuidance
  ("constrainUpDirection: conventional HEP view.");
  fpCommandRotationStyle->SetGuidance
  ("freeRotation: Google-like rotation, using mouse-grab.");
  fpCommandRotationStyle->SetParameterName ("style",omitable = false);
  fpCommandRotationStyle->SetCandidates("constrainUpDirection freeRotation");
 
  fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
  fpCommandSectionPlane -> SetGuidance
  ("Set plane for drawing section (DCUT).");
  fpCommandSectionPlane -> SetGuidance
  ("E.g., for a y-z plane at x = 1 cm:"
   "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
   "\nTo turn off: /vis/viewer/set/sectionPlane off");
  parameter  =  new G4UIparameter("Selector",'c',true);
  parameter  -> SetDefaultValue  ("on");
  fpCommandSectionPlane->SetParameter(parameter);
  parameter  =  new G4UIparameter("x",'d',omitable = true);
  parameter  -> SetDefaultValue  (0);
  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
  fpCommandSectionPlane->SetParameter(parameter);
  parameter  =  new G4UIparameter("y",'d',omitable = true);
  parameter  -> SetDefaultValue  (0);
  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
  fpCommandSectionPlane->SetParameter(parameter);
  parameter  =  new G4UIparameter("z",'d',omitable = true);
  parameter  -> SetDefaultValue  (0);
  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
  fpCommandSectionPlane->SetParameter(parameter);
  parameter  =  new G4UIparameter("unit",'s',omitable = true);
  parameter  -> SetDefaultValue  ("m");
  parameter  -> SetGuidance      ("Unit of point on the plane.");
  fpCommandSectionPlane->SetParameter(parameter);
  parameter  =  new G4UIparameter("nx",'d',omitable = true);
  parameter  -> SetDefaultValue  (1);
  parameter  -> SetGuidance      ("Component of plane normal.");
  fpCommandSectionPlane->SetParameter(parameter);
  parameter  =  new G4UIparameter("ny",'d',omitable = true);
  parameter  -> SetDefaultValue  (0);
  parameter  -> SetGuidance      ("Component of plane normal.");
  fpCommandSectionPlane->SetParameter(parameter);
  parameter  =  new G4UIparameter("nz",'d',omitable = true);
  parameter  -> SetDefaultValue  (0);
  parameter  -> SetGuidance      ("Component of plane normal.");
  fpCommandSectionPlane->SetParameter(parameter);
 
  fpCommandSpecialMeshRendering = new G4UIcmdWithABool
  ("/vis/viewer/set/specialMeshRendering",this);
  fpCommandSpecialMeshRendering -> SetGuidance
  ("Request special rendering of volumes (meshes) that use G4VNestedParameterisation.");
  fpCommandSpecialMeshRendering->SetParameterName("render",omitable = true);
  fpCommandSpecialMeshRendering->SetDefaultValue(true);
 
  fpCommandSpecialMeshVolumes = new G4UIcommand
  ("/vis/viewer/set/specialMeshVolumes",this);
  fpCommandSpecialMeshVolumes -> SetGuidance
  ("Specify the volumes for special rendering. No arguments resets the list"
   "\nand is interpreted to mean \"all found meshes\".");
  fpCommandSpecialMeshVolumes->SetGuidance
  ("Please provide a list of space-separated physical volume names and copy"
   "\nnumber pairs. Negative copy number means \"all volumes of that name\".");
  parameter = new G4UIparameter("volumes",'s',omitable = true);
  parameter->SetGuidance
  ("List of physical volume names and copy number pairs");
  fpCommandSpecialMeshVolumes->SetParameter(parameter);
 
  fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
  fpCommandStyle->SetGuidance
  ("Set style of drawing - w[ireframe] or s[urface] or c[loud].");
  fpCommandStyle->SetGuidance
  ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
  fpCommandStyle->SetParameterName ("style",omitable = false);
  fpCommandStyle->SetCandidates("w wireframe s surface c cloud");
 
  fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit
  ("/vis/viewer/set/targetPoint", this);
  fpCommandTargetPoint->SetGuidance
  ("Set target point.");
  fpCommandTargetPoint->SetGuidance
  ("This sets the \"Current Target Point\" relative to the \"Standard");
  fpCommandTargetPoint->SetGuidance
  ("Target Point\" so that the actual target point is as requested.");
  fpCommandTargetPoint->SetGuidance
  ("(See G4ViewParameters.hh for an explanation of target points.)");
  fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false);
  fpCommandTargetPoint->SetUnitCategory("Length");
 
  fpCommandUpThetaPhi = new G4UIcommand
  ("/vis/viewer/set/upThetaPhi", this);
  fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
  fpCommandUpThetaPhi -> SetGuidance
  ("Viewer will attempt always to show this direction upwards.");
  parameter = new G4UIparameter("theta", 'd', omitable = true);
  parameter -> SetDefaultValue (90.);
  fpCommandUpThetaPhi -> SetParameter (parameter);
  parameter = new G4UIparameter("phi", 'd', omitable = true);
  parameter -> SetDefaultValue (90.);
  fpCommandUpThetaPhi -> SetParameter (parameter);
  parameter = new G4UIparameter ("unit", 's', omitable = true);
  parameter -> SetDefaultValue ("deg");
  fpCommandUpThetaPhi -> SetParameter (parameter);
 
  fpCommandUpVector = new G4UIcommand
  ("/vis/viewer/set/upVector", this);
  fpCommandUpVector -> SetGuidance ("Set up vector.");
  fpCommandUpVector -> SetGuidance
  ("Viewer will attempt always to show this direction upwards.");
  parameter = new G4UIparameter("x", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommandUpVector -> SetParameter (parameter);
  parameter = new G4UIparameter("y", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandUpVector -> SetParameter (parameter);
  parameter = new G4UIparameter ("z", 'd', omitable = true);
  parameter -> SetDefaultValue (0.);
  fpCommandUpVector -> SetParameter (parameter);
 
  fpCommandViewpointThetaPhi = new G4UIcommand
  ("/vis/viewer/set/viewpointThetaPhi", this);
  fpCommandViewpointThetaPhi -> SetGuidance
  ("Set direction from target to camera.");
  fpCommandViewpointThetaPhi -> SetGuidance
  ("Also changes lightpoint direction if lights are set to move with camera.");
  parameter = new G4UIparameter("theta", 'd', omitable = true);
  parameter -> SetDefaultValue (60.);
  fpCommandViewpointThetaPhi -> SetParameter (parameter);
  parameter = new G4UIparameter("phi", 'd', omitable = true);
  parameter -> SetDefaultValue (45.);
  fpCommandViewpointThetaPhi -> SetParameter (parameter);
  parameter = new G4UIparameter ("unit", 's', omitable = true);
  parameter -> SetDefaultValue ("deg");
  fpCommandViewpointThetaPhi -> SetParameter (parameter);
 
  fpCommandViewpointVector = new G4UIcommand
  ("/vis/viewer/set/viewpointVector", this);
  fpCommandViewpointVector -> SetGuidance
  ("Set direction from target to camera.");
  fpCommandViewpointVector -> SetGuidance
  ("Also changes lightpoint direction if lights are set to move with camera.");
  parameter = new G4UIparameter("x", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandViewpointVector -> SetParameter (parameter);
  parameter = new G4UIparameter("y", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandViewpointVector -> SetParameter (parameter);
  parameter = new G4UIparameter ("z", 'd', omitable = true);
  parameter -> SetDefaultValue (1.);
  fpCommandViewpointVector -> SetParameter (parameter);
 
  fpTimeWindowDirectory = new G4UIdirectory ("/vis/viewer/set/timeWindow/");
  fpTimeWindowDirectory -> SetGuidance ("Set time window parameters of current viewer.");
  G4String timeWindowGuidance =
  "For these commands use"
  "\n  /vis/scene/add/trajectories rich"
  "\n  /vis/modeling/trajectories/drawByCharge-0/default/setTimeSliceInterval 0.01 ns"
  "\nthen typically"
  "\n  /vis/viewer/set/timeWindow/displayLightFront true 0 0 -50 cm -0.5 ns"
  "\n  /vis/viewer/set/timeWindow/displayHeadTime true"
  "\n  /vis/viewer/set/timeWindow/fadeFactor 1"
  "\n  /run/beamOn # or several until you get a good event or events"
  "\n  /vis/viewer/set/timeWindow/startTime 0 ns 1 ns"
  "\n  /vis/viewer/save"
  "\n  /vis/viewer/set/timeWindow/startTime 1 ns 1 ns"
  "\nthen zoom, pan etc to a view of interest and"
  "\n  /vis/viewer/save"
  "\nthen repeat with next start time, another view and a save, then try"
  "\n  /vis/viewer/interpolate";
 
  fpCommandTimeWindowDisplayHeadTime =
  new G4UIcommand("/vis/viewer/set/timeWindow/displayHeadTime", this);
  fpCommandTimeWindowDisplayHeadTime->SetGuidance
  ("Display head time of range in 2D text.");
  fpCommandTimeWindowDisplayHeadTime->SetGuidance(timeWindowGuidance);
  parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
  parameter->SetDefaultValue(false);
  fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
  parameter = new G4UIparameter ("screenX", 'd', omitable = true);
  parameter->SetGuidance("-1 < screenX < 1");
  parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
  parameter->SetDefaultValue(-0.9);
  fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
  parameter = new G4UIparameter ("screenY", 'd', omitable = true);
  parameter->SetGuidance("-1 < screenY < 1");
  parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
  parameter->SetDefaultValue(-0.9);
  fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
  parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
  parameter->SetDefaultValue(24.);
  fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
  parameter = new G4UIparameter ("red", 'd', omitable = true);
  parameter->SetParameterRange("red >= 0. && red <= 1.");
  parameter->SetDefaultValue(0.);
  fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
  parameter = new G4UIparameter ("green", 'd', omitable = true);
  parameter->SetParameterRange("green >= 0. && green <= 1.");
  parameter->SetDefaultValue(1.);
  fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
  parameter = new G4UIparameter ("blue", 'd', omitable = true);
  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
  parameter->SetDefaultValue(1.);
  fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
 
  fpCommandTimeWindowDisplayLightFront =
  new G4UIcommand("/vis/viewer/set/timeWindow/displayLightFront", this);
  fpCommandTimeWindowDisplayLightFront->SetGuidance
  ("Display the light front at head time.");
  fpCommandTimeWindowDisplayLightFront->SetGuidance
  ("Tip: The trajectories can appear of jump ahead of the light front"
   "\nbecause their time range overlaps the viewer's time range.  To"
   "\naverage out this discrete time effect, advance the light front by"
   "\nhalf the trajectories interval. E.g., if the trajectory time slice"
   "\ninterval is 0.01 ns:"
   "\n  /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.005 ns"
   "\nTo prevent them beating the light front at all:"
   "\n  /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.01 ns");
  fpCommandTimeWindowDisplayLightFront->SetGuidance(timeWindowGuidance);
  parameter = new G4UIparameter ("displayLightFront", 'b', omitable = true);
  parameter->SetDefaultValue(true);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("originX", 'd', omitable = true);
  parameter->SetDefaultValue(0.);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("originY", 'd', omitable = true);
  parameter->SetDefaultValue(0.);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("originZ", 'd', omitable = true);
  parameter->SetDefaultValue(0.);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("space_unit", 's', omitable = true);
  parameter->SetDefaultValue("m");
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("originT", 'd', omitable = true);
  parameter->SetDefaultValue(0.);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("time_unit", 's', omitable = true);
  parameter->SetDefaultValue("s");
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("red", 'd', omitable = true);
  parameter->SetParameterRange("red >= 0. && red <= 1.");
  parameter->SetDefaultValue(0.);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("green", 'd', omitable = true);
  parameter->SetParameterRange("green >= 0. && green <= 1.");
  parameter->SetDefaultValue(1.);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
  parameter = new G4UIparameter ("blue", 'd', omitable = true);
  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
  parameter->SetDefaultValue(0.);
  fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
 
  fpCommandTimeWindowEndTime =
  new G4UIcommand("/vis/viewer/set/timeWindow/endTime", this);
  fpCommandTimeWindowEndTime->SetGuidance("Set end and range of track time.");
  fpCommandTimeWindowEndTime->SetGuidance(timeWindowGuidance);
  parameter = new G4UIparameter ("end-time", 'd', omitable = false);
  parameter->SetDefaultValue(G4VisAttributes::fVeryLongTime);
  fpCommandTimeWindowEndTime->SetParameter(parameter);
  parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
  parameter->SetDefaultValue("ns");
  fpCommandTimeWindowEndTime->SetParameter(parameter);
  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
  parameter->SetDefaultValue(-1.);
  fpCommandTimeWindowEndTime->SetParameter(parameter);
  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
  parameter->SetDefaultValue("ns");
  fpCommandTimeWindowEndTime->SetParameter(parameter);
 
  fpCommandTimeWindowFadeFactor =
  new G4UIcmdWithADouble("/vis/viewer/set/timeWindow/fadeFactor", this);
  fpCommandTimeWindowFadeFactor->SetGuidance
  ("0: no fade; 1: maximum fade with time window.");
  fpCommandTimeWindowFadeFactor->SetGuidance(timeWindowGuidance);
  fpCommandTimeWindowFadeFactor->SetParameterName("fade_factor", omitable = false);
  fpCommandTimeWindowFadeFactor->SetRange("fade_factor>=0.&&fade_factor<=1.");
  fpCommandTimeWindowFadeFactor->SetDefaultValue(0.);
 
  fpCommandTimeWindowStartTime =
  new G4UIcommand("/vis/viewer/set/timeWindow/startTime", this);
  fpCommandTimeWindowStartTime->SetGuidance("Set start and range of track time.");
  fpCommandTimeWindowStartTime->SetGuidance(timeWindowGuidance);
  parameter = new G4UIparameter ("start-time", 'd', omitable = false);
  parameter->SetDefaultValue(-G4VisAttributes::fVeryLongTime);
  fpCommandTimeWindowStartTime->SetParameter(parameter);
  parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
  parameter->SetDefaultValue("ns");
  fpCommandTimeWindowStartTime->SetParameter(parameter);
  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
  parameter->SetDefaultValue(-1.);
  fpCommandTimeWindowStartTime->SetParameter(parameter);
  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
  parameter->SetDefaultValue("ns");
  fpCommandTimeWindowStartTime->SetParameter(parameter);
}

References G4VVisCommand::ConvertToColourGuidance(), fpCommandAll, fpCommandAutoRefresh, fpCommandAuxEdge, fpCommandBackground, fpCommandCulling, fpCommandCutawayMode, fpCommandDefaultColour, fpCommandDefaultTextColour, fpCommandEdge, fpCommandExplodeFactor, fpCommandGlobalLineWidthScale, fpCommandGlobalMarkerScale, fpCommandHiddenEdge, fpCommandHiddenMarker, fpCommandLightsMove, fpCommandLightsThetaPhi, fpCommandLightsVector, fpCommandLineSegments, fpCommandNumberOfCloudPoints, fpCommandPicking, fpCommandProjection, fpCommandRotationStyle, fpCommandSectionPlane, fpCommandSpecialMeshRendering, fpCommandSpecialMeshVolumes, fpCommandStyle, fpCommandTargetPoint, fpCommandTimeWindowDisplayHeadTime, fpCommandTimeWindowDisplayLightFront, fpCommandTimeWindowEndTime, fpCommandTimeWindowFadeFactor, fpCommandTimeWindowStartTime, fpCommandUpThetaPhi, fpCommandUpVector, fpCommandViewpointThetaPhi, fpCommandViewpointVector, fpTimeWindowDirectory, G4VisAttributes::fVeryLongTime, G4UIcmdWithAString::SetCandidates(), G4UIcmdWithAString::SetDefaultValue(), G4UIparameter::SetDefaultValue(), G4UIcmdWithABool::SetDefaultValue(), G4UIcmdWithADouble::SetDefaultValue(), G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIparameter::SetGuidance(), G4UIcommand::SetParameter(), G4UIparameter::SetParameterCandidates(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithADouble::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWith3VectorAndUnit::SetParameterName(), G4UIparameter::SetParameterRange(), G4UIcommand::SetRange(), and G4UIcmdWith3VectorAndUnit::SetUnitCategory().

◆ ~G4VisCommandsViewerSet()

G4VisCommandsViewerSet::~G4VisCommandsViewerSet ( )

virtual

Definition at line 619 of file G4VisCommandsViewerSet.cc.

                                                {
  delete fpCommandTimeWindowStartTime;
  delete fpCommandTimeWindowFadeFactor;
  delete fpCommandTimeWindowEndTime;
  delete fpCommandTimeWindowDisplayLightFront;
  delete fpCommandTimeWindowDisplayHeadTime;
  delete fpTimeWindowDirectory;
  delete fpCommandViewpointVector;
  delete fpCommandViewpointThetaPhi;
  delete fpCommandUpVector;
  delete fpCommandUpThetaPhi;
  delete fpCommandTargetPoint;
  delete fpCommandStyle;
  delete fpCommandSpecialMeshVolumes;
  delete fpCommandSpecialMeshRendering;
  delete fpCommandSectionPlane;
  delete fpCommandRotationStyle;
  delete fpCommandProjection;
  delete fpCommandPicking;
  delete fpCommandNumberOfCloudPoints;
  delete fpCommandLineSegments;
  delete fpCommandLightsVector;
  delete fpCommandLightsThetaPhi;
  delete fpCommandLightsMove;
  delete fpCommandHiddenMarker;
  delete fpCommandHiddenEdge;
  delete fpCommandGlobalMarkerScale;
  delete fpCommandGlobalLineWidthScale;
  delete fpCommandExplodeFactor;
  delete fpCommandEdge;
  delete fpCommandDefaultTextColour;
  delete fpCommandDefaultColour;
  delete fpCommandCutawayMode;
  delete fpCommandCulling;
  delete fpCommandBackground;
  delete fpCommandAuxEdge;
  delete fpCommandAutoRefresh;
  delete fpCommandAll;
}

References fpCommandAll, fpCommandAutoRefresh, fpCommandAuxEdge, fpCommandBackground, fpCommandCulling, fpCommandCutawayMode, fpCommandDefaultColour, fpCommandDefaultTextColour, fpCommandEdge, fpCommandExplodeFactor, fpCommandGlobalLineWidthScale, fpCommandGlobalMarkerScale, fpCommandHiddenEdge, fpCommandHiddenMarker, fpCommandLightsMove, fpCommandLightsThetaPhi, fpCommandLightsVector, fpCommandLineSegments, fpCommandNumberOfCloudPoints, fpCommandPicking, fpCommandProjection, fpCommandRotationStyle, fpCommandSectionPlane, fpCommandSpecialMeshRendering, fpCommandSpecialMeshVolumes, fpCommandStyle, fpCommandTargetPoint, fpCommandTimeWindowDisplayHeadTime, fpCommandTimeWindowDisplayLightFront, fpCommandTimeWindowEndTime, fpCommandTimeWindowFadeFactor, fpCommandTimeWindowStartTime, fpCommandUpThetaPhi, fpCommandUpVector, fpCommandViewpointThetaPhi, fpCommandViewpointVector, and fpTimeWindowDirectory.

◆ G4VisCommandsViewerSet() [2/2]

G4VisCommandsViewerSet::G4VisCommandsViewerSet ( const G4VisCommandsViewerSet & )

private

Member Function Documentation

◆ AddUIcommand()

void G4UImessenger::AddUIcommand ( G4UIcommand * newCommand )

protectedinherited

Definition at line 149 of file G4UImessenger.cc.

{
  G4cerr << "Warning : Old style definition of G4UIcommand <"
         << newCommand->GetCommandPath() << ">." << G4endl;
}

References G4cerr, G4endl, and G4UIcommand::GetCommandPath().

◆ BtoS()

G4String G4UImessenger::BtoS ( G4bool b )

protectedinherited

Definition at line 98 of file G4UImessenger.cc.

{
  G4String vl = "0";
  if(b)
    vl = "true";
  return vl;
}

◆ CheckSceneAndNotifyHandlers()

void G4VVisCommand::CheckSceneAndNotifyHandlers ( G4Scene * pScene = nullptr )

protectedinherited

Definition at line 207 of file G4VVisCommand.cc.

{
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 
  if (!pScene) {
    if (verbosity >= G4VisManager::warnings) {
      G4cout << "WARNING: Scene pointer is null."
      << G4endl;
    }
    return;
  }
 
  G4VSceneHandler* pSceneHandler = fpVisManager -> GetCurrentSceneHandler();
  if (!pSceneHandler) {
    if (verbosity >= G4VisManager::warnings) {
      G4cout << "WARNING: Scene handler not found." << G4endl;
    }
    return;
  }
 
  // Scene has changed.  If it is the scene of the currrent scene handler
  // refresh viewers of all scene handlers using this scene. If not, it may be
  // a scene that the user is building up before attaching to a scene handler,
  // so do nothing.
  if (pScene == pSceneHandler->GetScene()) {
    G4UImanager::GetUIpointer () -> ApplyCommand ("/vis/scene/notifyHandlers");
  }
 
}

References G4VVisCommand::fpVisManager, G4cout, G4endl, G4VSceneHandler::GetScene(), G4UImanager::GetUIpointer(), G4VisManager::GetVerbosity(), and G4VisManager::warnings.

◆ CheckView()

G4bool G4VVisCommand::CheckView ( )

protectedinherited

Definition at line 237 of file G4VVisCommand.cc.

{
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
 
  if (!viewer) {
    if (verbosity >= G4VisManager::errors) {
      G4cerr <<
  "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
       << G4endl;
    }
    return false;
  }
  
  return true;
}

References G4VisManager::errors, G4VVisCommand::fpVisManager, G4cerr, G4endl, and G4VisManager::GetVerbosity().

◆ CommandsShouldBeInMaster()

G4bool G4UImessenger::CommandsShouldBeInMaster ( ) const

inlineinherited

Definition at line 77 of file G4UImessenger.hh.

    {
      return commandsShouldBeInMaster;
    }

References G4UImessenger::commandsShouldBeInMaster.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode().

◆ ConvertToColour()

void G4VVisCommand::ConvertToColour	(	G4Colour &	colour,
		const G4String &	redOrString,
		G4double	green,
		G4double	blue,
		G4double	opacity
	)

protectedinherited

Definition at line 119 of file G4VVisCommand.cc.

{
  // Note: colour is supplied by the caller and some or all of its components
  // may act as default.
  //
  // Note: redOrString is either a number or string.  If a string it must be
  // one of the recognised colours.
  //
  // Thus the arguments can be, for example:
  // (colour,"red",...,...,0.5): will give the colour red with opacity 0.5 (the
  // third and fourth arguments are ignored), or
  // (1.,0.,0.,0.5): this also will be red with opacity 0.5.
 
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 
  const size_t iPos0 = 0;
  if (std::isalpha(redOrString[iPos0])) {
 
    // redOrString is probably alphabetic characters defining the colour
    if (!G4Colour::GetColour(redOrString, colour)) {
      // Not a recognised string
      if (verbosity >= G4VisManager::warnings) {
        G4cout << "WARNING: Colour \"" << redOrString
        << "\" not found.  Defaulting to " << colour
        << G4endl;
      }
      return;
    } else {
      // It was a recognised string.  Now add opacity.
      colour.SetAlpha(opacity);
      return;
    }
 
  } else {
 
    // redOrString is probably numeric defining the red component
    std::istringstream iss(redOrString);
    G4double red;
    iss >> red;
    if (iss.fail()) {
      if (verbosity >= G4VisManager::warnings) {
        G4cout << "WARNING: String \"" << redOrString
        << "\" cannot be parsed.  Defaulting to " << colour
        << G4endl;
      }
      return;
    } else {
      colour = G4Colour(red,green,blue,opacity);
      return;
    }
    
  }
}

References G4VVisCommand::fpVisManager, G4cout, G4endl, G4Colour::GetColour(), G4VisManager::GetVerbosity(), G4Colour::SetAlpha(), and G4VisManager::warnings.

Referenced by G4VisCommandGeometrySetColour::SetNewValue(), G4VisCommandSceneAddGPS::SetNewValue(), G4VisCommandSetColour::SetNewValue(), G4VisCommandSetTextColour::SetNewValue(), G4VisCommandsTouchableSet::SetNewValue(), and SetNewValue().

◆ ConvertToColourGuidance()

const G4String & G4VVisCommand::ConvertToColourGuidance ( )

protectedinherited

Definition at line 109 of file G4VVisCommand.cc.

{
  static G4String guidance
  ("Accepts (a) RGB triplet. e.g., \".3 .4 .5\", or"
   "\n (b) string such as \"white\", \"black\", \"grey\", \"red\"...or"
   "\n (c) an additional number for opacity, e.g., \".3 .4 .5 .6\""
   "\n     or \"grey ! ! .6\" (note \"!\"'s for unused parameters).");
  return guidance;
}

Referenced by G4VisCommandSceneAddGPS::G4VisCommandSceneAddGPS(), G4VisCommandSetColour::G4VisCommandSetColour(), G4VisCommandSetTextColour::G4VisCommandSetTextColour(), G4VisCommandsTouchableSet::G4VisCommandsTouchableSet(), and G4VisCommandsViewerSet().

◆ ConvertToDoublePair()

G4bool G4VVisCommand::ConvertToDoublePair	(	const G4String &	paramString,
		G4double &	xval,
		G4double &	yval
	)

staticprotectedinherited

Definition at line 85 of file G4VVisCommand.cc.

{
  G4double x, y;
  G4String unit;
  
  std::istringstream is(paramString);
  is >> x >> y >> unit;
 
  if (G4UnitDefinition::IsUnitDefined(unit)) {
    xval = x*G4UIcommand::ValueOf(unit);
    yval = y*G4UIcommand::ValueOf(unit);
  } else {
    G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
    if (verbosity >= G4VisManager::errors) {
      G4cout << "ERROR: Unrecognised unit" << G4endl;
    }
    return false;
  }
 
  return true;
}

References G4VisManager::errors, G4VVisCommand::fpVisManager, G4cout, G4endl, G4VisManager::GetVerbosity(), G4UnitDefinition::IsUnitDefined(), and G4UIcommand::ValueOf().

Referenced by G4VisCommandViewerPan::SetNewValue(), and SetNewValue().

◆ ConvertToString()

G4String G4VVisCommand::ConvertToString	(	G4double	x,
		G4double	y,
		const char *	unitName
	)

staticprotectedinherited

Definition at line 75 of file G4VVisCommand.cc.

{
  G4double uv = G4UIcommand::ValueOf(unitName);
  
  std::ostringstream oss;
  oss << x/uv << " " << y/uv << " " << unitName;
  return oss.str();
}

References G4UIcommand::ValueOf().

Referenced by G4VisCommandViewerPan::GetCurrentValue().

◆ CopyCameraParameters()

void G4VVisCommand::CopyCameraParameters	(	G4ViewParameters &	target,
		const G4ViewParameters &	from
	)

protectedinherited

Definition at line 385 of file G4VVisCommand.cc.

{
  // Copy view parameters pertaining only to camera
  target.SetViewpointDirection  (from.GetViewpointDirection());
  target.SetLightpointDirection (from.GetLightpointDirection());
  target.SetLightsMoveWithCamera(from.GetLightsMoveWithCamera());
  target.SetUpVector            (from.GetUpVector());
  target.SetFieldHalfAngle      (from.GetFieldHalfAngle());
  target.SetZoomFactor          (from.GetZoomFactor());
  target.SetScaleFactor         (from.GetScaleFactor());
  target.SetCurrentTargetPoint  (from.GetCurrentTargetPoint());
  target.SetDolly               (from.GetDolly());
}

Referenced by G4VisCommandViewerCopyViewFrom::SetNewValue().

◆ CopyGuidanceFrom()

void G4VVisCommand::CopyGuidanceFrom	(	const G4UIcommand *	fromCmd,
		G4UIcommand *	toCmd,
		G4int	startLine = `0`
	)

protectedinherited

Definition at line 335 of file G4VVisCommand.cc.

{
  if (fromCmd && toCmd) {
    const G4int nGuideEntries = fromCmd->GetGuidanceEntries();
    for (G4int i = startLine; i < nGuideEntries; ++i) {
      const G4String& guidance = fromCmd->GetGuidanceLine(i);
      toCmd->SetGuidance(guidance);
    }
  }
}

References G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), and G4UIcommand::SetGuidance().

Referenced by G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume(), G4VisCommandDrawVolume::G4VisCommandDrawVolume(), G4VisCommandSceneAddMagneticField::G4VisCommandSceneAddMagneticField(), G4VisCommandsTouchable::G4VisCommandsTouchable(), and G4VisCommandViewerCentreOn::G4VisCommandViewerCentreOn().

◆ CopyMostViewParameters()

void G4VVisCommand::CopyMostViewParameters	(	G4ViewParameters &	target,
		const G4ViewParameters &	from
	)

protectedinherited

Definition at line 374 of file G4VVisCommand.cc.

{
  // Copy view parameters except for autoRefresh and background...
  auto targetAutoRefresh = target.IsAutoRefresh();
  auto targetBackground  = target.GetBackgroundColour();
  target = from;
  target.SetAutoRefresh(targetAutoRefresh);
  target.SetBackgroundColour(targetBackground);
}

References G4ViewParameters::GetBackgroundColour(), G4ViewParameters::IsAutoRefresh(), G4ViewParameters::SetAutoRefresh(), and G4ViewParameters::SetBackgroundColour().

Referenced by G4VisCommandViewerCreate::SetNewValue(), and SetNewValue().

◆ CopyParametersFrom()

void G4VVisCommand::CopyParametersFrom	(	const G4UIcommand *	fromCmd,
		G4UIcommand *	toCmd
	)

protectedinherited

Definition at line 347 of file G4VVisCommand.cc.

{
  if (fromCmd && toCmd) {
    const G4int nParEntries = fromCmd->GetParameterEntries();
    for (G4int i = 0; i < nParEntries; ++i) {
      G4UIparameter* parameter = new G4UIparameter(*(fromCmd->GetParameter(i)));
      toCmd->SetParameter(parameter);
    }
  }
}

References G4UIcommand::GetParameter(), G4UIcommand::GetParameterEntries(), and G4UIcommand::SetParameter().

Referenced by G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume(), G4VisCommandDrawVolume::G4VisCommandDrawVolume(), G4VisCommandSceneAddMagneticField::G4VisCommandSceneAddMagneticField(), and G4VisCommandViewerCentreOn::G4VisCommandViewerCentreOn().

◆ CreateCommand()

template<typename T >

T * G4UImessenger::CreateCommand	(	const G4String &	cname,
		const G4String &	dsc
	)

protectedinherited

Definition at line 110 of file G4UImessenger.hh.

{
  G4String path;
  if(cname[0] != '/')
  {
    path = baseDirName + cname;
    if(path[0] != '/')
      path = "/" + path;
  }
 
  T* command = new T(path.c_str(), this);
  command->SetGuidance(dsc.c_str());
 
  return command;
}

References G4UImessenger::baseDirName.

◆ CreateDirectory()

void G4UImessenger::CreateDirectory	(	const G4String &	path,
		const G4String &	dsc,
		G4bool	commandsToBeBroadcasted = `true`
	)

protectedinherited

Definition at line 156 of file G4UImessenger.cc.

{
  G4UImanager* ui = G4UImanager::GetUIpointer();
 
  G4String fullpath = path;
  if(fullpath.back() != '/')
    fullpath.append("/");
 
  G4UIcommandTree* tree = ui->GetTree()->FindCommandTree(fullpath.c_str());
  if(tree != nullptr)
  {
    baseDirName = tree->GetPathName();
  }
  else
  {
    baseDir     = new G4UIdirectory(fullpath.c_str(), commandsToBeBroadcasted);
    baseDirName = fullpath;
    baseDir->SetGuidance(dsc.c_str());
  }
}

References G4UImessenger::baseDir, G4UImessenger::baseDirName, G4UIcommandTree::FindCommandTree(), G4UIcommandTree::GetPathName(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), and G4UIcommand::SetGuidance().

Referenced by G4MoleculeShootMessenger::G4MoleculeShootMessenger(), and G4UImessenger::G4UImessenger().

◆ DrawExtent()

void G4VVisCommand::DrawExtent ( const G4VisExtent & extent )

protectedinherited

Definition at line 359 of file G4VVisCommand.cc.

{
  if (fpVisManager) {
    const G4double halfX = (extent.GetXmax() - extent.GetXmin()) / 2.;
    const G4double halfY = (extent.GetYmax() - extent.GetYmin()) / 2.;
    const G4double halfZ = (extent.GetZmax() - extent.GetZmin()) / 2.;
    if (halfX > 0. && halfY > 0. && halfZ > 0.) {
      const G4Box box("vis_extent",halfX,halfY,halfZ);
      const G4VisAttributes visAtts(G4Color::Red());
      const G4Point3D& centre = extent.GetExtentCenter();
      fpVisManager->Draw(box,visAtts,G4Translate3D(centre));
    }
  }
}

References G4VisManager::Draw(), G4VVisCommand::fpVisManager, G4VisExtent::GetExtentCenter(), G4VisExtent::GetXmax(), G4VisExtent::GetXmin(), G4VisExtent::GetYmax(), G4VisExtent::GetYmin(), G4VisExtent::GetZmax(), G4VisExtent::GetZmin(), and G4Colour::Red().

Referenced by G4VisCommandSceneShowExtents::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

◆ DtoS()

G4String G4UImessenger::DtoS ( G4double a )

protectedinherited

Definition at line 90 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << a;
  return G4String(os.str());
}

Referenced by G4ScoreQuantityMessenger::FilterCommands(), and G4UIcontrolMessenger::SetNewValue().

◆ G4VisCommandsSceneAddUnsuccessful()

void G4VVisCommand::G4VisCommandsSceneAddUnsuccessful ( G4VisManager::Verbosity verbosity )

protectedinherited

Definition at line 254 of file G4VVisCommand.cc.

                                  {
  // Some frequently used error printing...
  if (verbosity >= G4VisManager::warnings) {
    G4cout <<
    "WARNING: For some reason, possibly mentioned above, it has not been"
    "\n  possible to add to the scene."
    << G4endl;
  }
}

References G4cout, G4endl, and G4VisManager::warnings.

◆ GetCurrentTextColour()

const G4Colour & G4VVisCommand::GetCurrentTextColour ( )

staticinherited

Definition at line 70 of file G4VVisCommand.cc.

{
  return fCurrentTextColour;
}

References G4VVisCommand::fCurrentTextColour.

◆ GetCurrentValue()

G4String G4VisCommandsViewerSet::GetCurrentValue ( G4UIcommand * command )

virtual

Reimplemented from G4UImessenger.

Definition at line 659 of file G4VisCommandsViewerSet.cc.

                                                             {
  return "";
}

◆ GetVisManager()

G4VisManager * G4VVisCommand::GetVisManager ( )

staticinherited

Definition at line 60 of file G4VVisCommand.cc.

{
  return fpVisManager;
}

References G4VVisCommand::fpVisManager.

◆ InterpolateToNewView()

void G4VVisCommand::InterpolateToNewView	(	G4VViewer *	currentViewer,
		const G4ViewParameters &	oldVP,
		const G4ViewParameters &	newVP,
		const G4int	nInterpolationPoints = `50`,
		const G4int	waitTimePerPointmilliseconds = `20`,
		const G4String	exportString = `""`
	)

protectedinherited

Definition at line 313 of file G4VVisCommand.cc.

{
  std::vector<G4ViewParameters> viewVector;
  viewVector.push_back(oldVP);
  viewVector.push_back(oldVP);
  viewVector.push_back(newVP);
  viewVector.push_back(newVP);
  
  InterpolateViews
  (currentViewer,
   viewVector,
   nInterpolationPoints,
   waitTimePerPointmilliseconds,
   exportString);
}

References G4VVisCommand::InterpolateViews().

Referenced by G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

◆ InterpolateViews()

void G4VVisCommand::InterpolateViews	(	G4VViewer *	currentViewer,
		std::vector< G4ViewParameters >	viewVector,
		const G4int	nInterpolationPoints = `50`,
		const G4int	waitTimePerPointmilliseconds = `20`,
		const G4String	exportString = `""`
	)

protectedinherited

Definition at line 288 of file G4VVisCommand.cc.

{
  const G4int safety = viewVector.size()*nInterpolationPoints;
  G4int safetyCount = 0;
  do {
    G4ViewParameters* vp =
    G4ViewParameters::CatmullRomCubicSplineInterpolation(viewVector,nInterpolationPoints);
    if (!vp) break;  // Finished.
    currentViewer->SetViewParameters(*vp);
    currentViewer->RefreshView();
    if (exportString == "export" &&
        G4StrUtil::contains(currentViewer->GetName(), "OpenGL")) {
      G4UImanager::GetUIpointer()->ApplyCommand("/vis/ogl/export");
    }
    currentViewer->ShowView();
    if (waitTimePerPointmilliseconds > 0)
      std::this_thread::sleep_for(std::chrono::milliseconds(waitTimePerPointmilliseconds));
  } while (safetyCount++ < safety);  // Loop checking, 16.02.2016, J.Allison
}

References G4UImanager::ApplyCommand(), G4ViewParameters::CatmullRomCubicSplineInterpolation(), G4StrUtil::contains(), G4VViewer::GetName(), G4UImanager::GetUIpointer(), G4VViewer::RefreshView(), G4VViewer::SetViewParameters(), and G4VViewer::ShowView().

Referenced by G4VVisCommand::InterpolateToNewView(), and G4VisCommandViewerInterpolate::SetNewValue().

◆ ItoS()

G4String G4UImessenger::ItoS ( G4int i )

protectedinherited

Definition at line 82 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << i;
  return G4String(os.str());
}

Referenced by G4GenericMessenger::DeclareMethod(), and G4ParticleGunMessenger::GetCurrentValue().

◆ operator!=()

G4bool G4UImessenger::operator!= ( const G4UImessenger & messenger ) const

inherited

Definition at line 76 of file G4UImessenger.cc.

{
  return this != &messenger;
}

◆ operator=()

G4VisCommandsViewerSet & G4VisCommandsViewerSet::operator= ( const G4VisCommandsViewerSet & )

private

◆ operator==()

G4bool G4UImessenger::operator== ( const G4UImessenger & messenger ) const

inherited

Definition at line 70 of file G4UImessenger.cc.

{
  return this == &messenger;
}

◆ ProvideValueOfUnit()

G4bool G4VVisCommand::ProvideValueOfUnit	(	const G4String &	where,
		const G4String &	unit,
		const G4String &	category,
		G4double &	value
	)

protectedinherited

Definition at line 175 of file G4VVisCommand.cc.

{
  // Return false if there's a problem
 
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 
  G4bool success = true;
  if (!G4UnitDefinition::IsUnitDefined(unit)) {
    if (verbosity >= G4VisManager::warnings) {
      G4cerr << where
      << "\n  Unit \"" << unit << "\" not defined"
      << G4endl;
    }
    success = false;
  } else if (G4UnitDefinition::GetCategory(unit) != category) {
    if (verbosity >= G4VisManager::warnings) {
      G4cerr << where
      << "\n  Unit \"" << unit << "\" not a unit of " << category;
      if (category == "Volumic Mass") G4cerr << " (density)";
      G4cerr << G4endl;
    }
    success = false;
  } else {
    value = G4UnitDefinition::GetValueOf(unit);
  }
  return success;
}

References G4VVisCommand::fpVisManager, G4cerr, G4endl, G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4VisManager::GetVerbosity(), G4UnitDefinition::IsUnitDefined(), and G4VisManager::warnings.

Referenced by G4VisCommandViewerColourByDensity::SetNewValue(), and SetNewValue().

◆ RefreshIfRequired()

void G4VVisCommand::RefreshIfRequired ( G4VViewer * viewer )

protectedinherited

Definition at line 271 of file G4VVisCommand.cc.

                                                       {
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
  G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
  const G4ViewParameters& viewParams = viewer->GetViewParameters();
  if (sceneHandler && sceneHandler->GetScene()) {
    if (viewParams.IsAutoRefresh()) {
      G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
    }
    else {
      if (verbosity >= G4VisManager::warnings) {
        G4cout << "Issue /vis/viewer/refresh or flush to see effect."
        << G4endl;
      }
    }
  }
}

References G4UImanager::ApplyCommand(), G4VVisCommand::fpVisManager, G4cout, G4endl, G4VSceneHandler::GetScene(), G4VViewer::GetSceneHandler(), G4UImanager::GetUIpointer(), G4VisManager::GetVerbosity(), G4VViewer::GetViewParameters(), G4ViewParameters::IsAutoRefresh(), and G4VisManager::warnings.

Referenced by G4VisCommandViewerReset::SetNewValue(), G4VisCommandViewerRebuild::SetNewValue(), G4VisCommandViewerSelect::SetNewValue(), and G4VVisCommand::SetViewParameters().

◆ SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 663 of file G4VisCommandsViewerSet.cc.

                                         {
 
  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 
  G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
  if (!currentViewer) {
    if (verbosity >= G4VisManager::errors) {
      G4cerr <<
      "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
      << G4endl;
    }
    return;
  }
 
  G4ViewParameters vp = currentViewer->GetViewParameters();
 
  if (command == fpCommandAll) {
    G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
    if (!fromViewer) {
      if (verbosity >= G4VisManager::errors) {
        G4cerr <<
        "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
        "\n  unrecognised from-viewer."
        << G4endl;
      }
      return;
    }
    if (fromViewer == currentViewer) {
      if (verbosity >= G4VisManager::warnings) {
        G4cout <<
        "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
        "\n  from-viewer and current viewer are identical."
        << G4endl;
      }
      return;
    }
    // Copy view parameters except for autoRefresh and background...
    CopyMostViewParameters(vp, fromViewer->GetViewParameters());
    // Concatenate any private vis attributes modifiers...
    const std::vector<G4ModelingParameters::VisAttributesModifier>*
    privateVAMs = fromViewer->GetPrivateVisAttributesModifiers();
    if (privateVAMs) {
      std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator i;
      for (i = privateVAMs->begin(); i != privateVAMs->end(); ++i) {
        vp.AddVisAttributesModifier(*i);
      }
    }
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "View parameters of viewer \"" << currentViewer->GetName()
      << "\"\n  set to those of viewer \"" << fromViewer->GetName()
      << "\"."
      << G4endl;
    }
    if (verbosity >= G4VisManager::warnings) {
      G4cout << "You may need \"/vis/viewer/rebuild\"."
      << G4endl;
    }
  }
 
  else if (command == fpCommandAutoRefresh) {
    G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue);
    const G4ViewParameters& defaultVP =
    currentViewer->GetDefaultViewParameters();
    if (autoRefresh && !defaultVP.IsAutoRefresh()) {
      if (verbosity >= G4VisManager::warnings) {
        G4cout
        << "WARNING: "
        << currentViewer->GetName() << " is NOT auto-refesh by default"
        << "\n  so cannot be set to auto-refresh."
        << G4endl;
      }
      return;
    }
    vp.SetAutoRefresh(autoRefresh);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Views will ";
      if (!vp.IsAutoRefresh()) G4cout << "not ";
      G4cout << "be automatically refreshed after a change of view parameters."
      << G4endl;
    }
    if (!vp.IsAutoRefresh()) {
      currentViewer->SetViewParameters(vp);
      return;  // Avoid a refresh if auto-refresh has been set to off...
    }  // ...otherwise take normal action.
  }
 
  else if (command == fpCommandAuxEdge) {
    vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Auxiliary edges will ";
      if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
      G4cout << "be visible." << G4endl;
    }
  }
 
  else if (command == fpCommandBackground) {
    G4String redOrString;
    G4double green, blue, opacity;
    std::istringstream iss(newValue);
    iss >> redOrString >> green >> blue >> opacity;
    G4Colour colour(0.,0.,0.);  // Default black and opaque.
    ConvertToColour(colour, redOrString, green, blue, opacity);
    vp.SetBackgroundColour(colour);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Background colour "
      << vp.GetBackgroundColour()
      << " requested."
      << G4endl;
    }
  }
 
  else if (command == fpCommandCulling) {
    G4String cullingOption, stringFlag, unit;
    G4double density;
    std::istringstream is (newValue);
    is >> cullingOption >> stringFlag >> density >> unit;
    G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
    if (cullingOption == "global") {
      vp.SetCulling(boolFlag);
      if (verbosity >= G4VisManager::confirmations) {
        G4cout <<
        "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
        " set to " << G4UIcommand::ConvertToString(boolFlag) <<
        ".\n  Does not change specific culling flags."
        << G4endl;
      }
    }
    else if (cullingOption == "coveredDaughters") {
      vp.SetCullingCovered(boolFlag);
      if (verbosity >= G4VisManager::confirmations) {
        G4cout <<
        "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
        "\n  daughters flag set to "
        << G4UIcommand::ConvertToString(boolFlag) <<
        ".  Daughters covered by opaque mothers"
        "\n  will be culled, i.e., not drawn, if this flag is true."
        "\n  Note: this is only effective in surface drawing style,"
        "\n  and then only if the volumes are visible and opaque, and then"
        "\n  only if no sections or cutaways are in operation."
        << G4endl;
      }
    }
    else if (cullingOption == "invisible") {
      vp.SetCullingInvisible(boolFlag);
      if (verbosity >= G4VisManager::confirmations) {
        G4cout <<
        "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
        "\n  flag set to "
        << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
        ".  Volumes marked invisible will be culled,"
        "\n  i.e., not drawn, if this flag is true."
        << G4endl;
      }
    }
    else if (cullingOption == "density") {
      const G4String where =
      "G4VisCommandsViewerSet::SetNewValue: culling: culling by density";
      if (boolFlag) {
        G4double valueOfUnit;
        // "Volumic Mass" is Michel's phrase for "Density"
        if (ProvideValueOfUnit(where,unit,"Volumic Mass",valueOfUnit)) {
          // Successful outcome of unit search
          vp.SetDensityCulling(boolFlag);
          density *= valueOfUnit;
          vp.SetVisibleDensity(density);
        } else {
          // Unsuccessful outcome of unit search. Flag and density unchanged.
          density = vp.GetVisibleDensity();
        }
      } else {  // Reset flag but density unchanged.
        vp.SetDensityCulling(boolFlag);
      }
      if (verbosity >= G4VisManager::confirmations) {
        G4cout
        << where
        << "\n  flag set to "
        << std::boolalpha << vp.IsDensityCulling()
        << ".  Volumes with density less than "
        << G4BestUnit(density,"Volumic Mass")
        << "\n  will be culled, i.e., not drawn, if this flag is true."
        << G4endl;
      }
    }
    else {
      if (verbosity >= G4VisManager::errors) {
        G4cerr <<
        "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
        "\n  option not recognised."
        << G4endl;
      }
    }
  }
 
  else if (command == fpCommandCutawayMode) {
    if (newValue == "add" || newValue == "union")
      vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
    if (newValue == "multiply" || newValue == "intersection")
      vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
 
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Cutaway mode set to ";
      if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
        G4cout << "cutawayUnion";
      if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
        G4cout << "cutawayIntersection";
      G4cout << G4endl;
    }
  }
 
  else if (command == fpCommandDefaultColour) {
    G4String redOrString;
    G4double green, blue, opacity;
    std::istringstream iss(newValue);
    iss >> redOrString >> green >> blue >> opacity;
    G4Colour colour(1.,1.,1.);  // Default white and opaque.
    ConvertToColour(colour, redOrString, green, blue, opacity);
    G4VisAttributes va = vp.GetDefaultVisAttributes();
    va.SetColour(colour);
    vp.SetDefaultVisAttributes(va);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Default colour "
      << vp.GetDefaultVisAttributes()->GetColour()
      << " requested."
      << G4endl;
    }
  }
 
  else if (command == fpCommandDefaultTextColour) {
    G4String redOrString;
    G4double green, blue, opacity;
    std::istringstream iss(newValue);
    iss >> redOrString >> green >> blue >> opacity;
    G4Colour colour(1.,1.,1.);  // Default white and opaque.
    ConvertToColour(colour, redOrString, green, blue, opacity);
    G4VisAttributes va = vp.GetDefaultTextVisAttributes();
    va.SetColour(colour);
    vp.SetDefaultTextVisAttributes(va);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Default colour "
      << vp.GetDefaultTextVisAttributes()->GetColour()
      << " requested."
      << G4endl;
    }
  }
 
  else if (command == fpCommandEdge) {
    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
    if (G4UIcommand::ConvertToBool(newValue)) {  // true
      switch (existingStyle) {
        case G4ViewParameters::wireframe:
          break;
        case G4ViewParameters::hlr:
          break;
        case G4ViewParameters::hsr:
          vp.SetDrawingStyle(G4ViewParameters::hlhsr);
          break;
        case G4ViewParameters::hlhsr:
          break;
        case G4ViewParameters::cloud:
          break;
      }
    }
    else {  // false
      switch (existingStyle) {
        case G4ViewParameters::wireframe:
          break;
        case G4ViewParameters::hlr:
          break;
        case G4ViewParameters::hsr:
          break;
        case G4ViewParameters::hlhsr:
          vp.SetDrawingStyle(G4ViewParameters::hsr);
          break;
        case G4ViewParameters::cloud:
          break;
      }
    }
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
      << "\" set to " << vp.GetDrawingStyle()
      << G4endl;
    }
  }
 
  else if (command == fpCommandExplodeFactor) {
    G4double explodeFactor, x, y, z;
    G4String unitString;
    std::istringstream is (newValue);
    is >> explodeFactor >> x >> y >> z >> unitString;
    G4double unit = G4UIcommand::ValueOf(unitString);
    vp.SetExplodeFactor(explodeFactor);
    vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
      << " from centre " << vp.GetExplodeCentre()
      << G4endl;
    }
  }
 
  else if (command == fpCommandGlobalLineWidthScale) {
    G4double globalLineWidthScale
    = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
    vp.SetGlobalLineWidthScale(globalLineWidthScale);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Global Line Width Scale changed to "
      << vp.GetGlobalLineWidthScale() << G4endl;
    }
  }
 
  else if (command == fpCommandGlobalMarkerScale) {
    G4double globalMarkerScale
    = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
    vp.SetGlobalMarkerScale(globalMarkerScale);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Global Marker Scale changed to "
      << vp.GetGlobalMarkerScale() << G4endl;
    }
  }
 
  else if (command == fpCommandHiddenEdge) {
    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
    if (G4UIcommand::ConvertToBool(newValue)) {
      switch (existingStyle) {
        case G4ViewParameters::wireframe:
          vp.SetDrawingStyle(G4ViewParameters::hlr);
          break;
        case G4ViewParameters::hlr:
          break;
        case G4ViewParameters::hsr:
          vp.SetDrawingStyle(G4ViewParameters::hlhsr);
          break;
        case G4ViewParameters::hlhsr:
          break;
        case G4ViewParameters::cloud:
          break;
      }
    }
    else {
      switch (existingStyle) {
        case G4ViewParameters::wireframe:
          break;
        case G4ViewParameters::hlr:
          vp.SetDrawingStyle(G4ViewParameters::wireframe);
          break;
        case G4ViewParameters::hsr:
          break;
        case G4ViewParameters::hlhsr:
          vp.SetDrawingStyle(G4ViewParameters::hsr);
          break;
        case G4ViewParameters::cloud:
          break;
      }
    }
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
      << "\" set to " << vp.GetDrawingStyle()
      << G4endl;
    }
  }
 
  else if (command == fpCommandHiddenMarker) {
    G4bool hidden = G4UIcommand::ConvertToBool(newValue);
    if (hidden) vp.SetMarkerHidden();
    else vp.SetMarkerNotHidden();
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Markers will ";
      if (vp.IsMarkerNotHidden()) G4cout << "not ";
      G4cout << "be hidden under solid objects." << G4endl;
    }
  }
 
  else if (command == fpCommandLightsMove) {
    if (newValue.find("cam") != G4String::npos)
      vp.SetLightsMoveWithCamera(true);
    else if(newValue.find("obj") != G4String::npos)
      vp.SetLightsMoveWithCamera(false);
    else {
      if (verbosity >= G4VisManager::errors) {
        G4cerr << "ERROR: \"" << newValue << "\" not recognised."
        "  Looking for \"cam\" or \"obj\" in string." << G4endl;
      }
    }
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Lights move with ";
      if (vp.GetLightsMoveWithCamera())
        G4cout << "camera (object appears to rotate).";
      else G4cout << "object (the viewer appears to be moving).";
      G4cout << G4endl;
    }
  }
 
  else if (command == fpCommandLightsThetaPhi) {
    G4double theta, phi;
    if (ConvertToDoublePair(newValue, theta, phi)) {
      G4double x = std::sin (theta) * std::cos (phi);
      G4double y = std::sin (theta) * std::sin (phi);
      G4double z = std::cos (theta);
      fLightsVector = G4ThreeVector (x, y, z);
      vp.SetLightpointDirection(fLightsVector);
      if (verbosity >= G4VisManager::confirmations) {
        G4cout << "Lights direction set to "
        << vp.GetLightpointDirection() << G4endl;
      }
    }
  }
 
  else if (command == fpCommandLightsVector) {
    fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
    vp.SetLightpointDirection(fLightsVector);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Lights direction set to "
      << vp.GetLightpointDirection() << G4endl;
    }
  }
 
  else if (command == fpCommandLineSegments) {
    G4int nSides = G4UIcommand::ConvertToInt(newValue);
    nSides = vp.SetNoOfSides(nSides);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout <<
      "Number of line segments per circle in polygon approximation is "
      << nSides << G4endl;
    }
  }
 
  else if (command == fpCommandNumberOfCloudPoints) {
    G4int nPoints = G4UIcommand::ConvertToInt(newValue);
    nPoints = vp.SetNumberOfCloudPoints(nPoints);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout <<
      "Number of points to be used in cloud representation of volumes is "
      << nPoints << G4endl;
    }
  }
 
  else if (command == fpCommandPicking) {
    vp.SetPicking(G4UIcommand::ConvertToBool(newValue));
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Picking ";
      if (vp.IsPicking()) G4cout << "requested.";
      else G4cout << "inhibited.";
      G4cout << G4endl;
    }
    if (verbosity >= G4VisManager::warnings) {
      G4cout << "You may need to issue \"/vis/viewer/update\"."
      << G4endl;
    }
  }
 
  else if (command == fpCommandProjection) {
    G4double fieldHalfAngle;
    const size_t iPos0 = 0;
    if (newValue[iPos0] == 'o') {  // "orthogonal"
      fieldHalfAngle = 0.;
    }
    else if (newValue[iPos0] == 'p') {  // "perspective"
      G4String dummy;
      G4String unit;
      std::istringstream is (newValue);
      is >> dummy >> fieldHalfAngle >> unit;
      fieldHalfAngle *= G4UIcommand::ValueOf(unit);
      if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
        if (verbosity >= G4VisManager::errors) {
          G4cerr <<
          "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
          G4cout << G4endl;
        }
        return;
      }
    }
    else {
      if (verbosity >= G4VisManager::errors) {
        G4cerr << "ERROR: \"" << newValue << "\" not recognised."
        "  Looking for 'o' or 'p' first character." << G4endl;
      }
      return;
    }
    vp.SetFieldHalfAngle(fieldHalfAngle);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Projection style of viewer \"" << currentViewer->GetName()
      << "\" set to ";
      if (fieldHalfAngle == 0.) {
        G4cout << "orthogonal.";
      }
      else {
        G4cout << "perspective\n  with half angle " << fieldHalfAngle / deg
        << " degrees.";
      }
      G4cout << G4endl;
    }
  }
 
  else if (command == fpCommandRotationStyle) {
    G4ViewParameters::RotationStyle style;
    if (newValue == "constrainUpDirection")
      style = G4ViewParameters::constrainUpDirection;
    else if (newValue == "freeRotation")
      style = G4ViewParameters::freeRotation;
    else {
      if (verbosity >= G4VisManager::errors) {
    G4cerr << "ERROR: \"" << newValue << "\" not recognised." << G4endl;
      }
      return;
    }
    vp.SetRotationStyle(style);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Rotation style of viewer \"" << currentViewer->GetName()
      << "\" set to " << vp.GetRotationStyle()
      << G4endl;
    }
  }
 
  else if (command == fpCommandSectionPlane) {
    G4String choice, unit;
    G4double x, y, z, nx, ny, nz, F = 1.;
    std::istringstream is (newValue);
    is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
    G4int iSelector = -1;
    if (G4StrUtil::icompare(choice, "off") == 0 ||
        !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
    if (G4StrUtil::icompare(choice, "on") == 0 ||
        G4UIcommand::ConvertToBool(choice)) iSelector = 1;
    if (iSelector < 0) {
      if (verbosity >= G4VisManager::errors) {
        G4cout << "Choice not recognised (on/true or off/false)." << G4endl;
      }
      goto write_result;
    }
    // iSelector can only be 0 or 1
    switch (iSelector) {
      case 0:
        vp.UnsetSectionPlane();
        break;
      case 1:
        F = G4UIcommand::ValueOf(unit);
        x *= F; y *= F; z *= F;
        if (nx == 0. && ny == 0. && nz == 0.) {
          if (verbosity >= G4VisManager::errors) {
            G4cout << "Null normal." << G4endl;
          }
          break;;
        }
        const G4Normal3D& normal = G4Normal3D(nx,ny,nz).unit();
        vp.SetSectionPlane(G4Plane3D(normal, G4Point3D(x,y,z)));
        vp.SetViewpointDirection(normal);
        break;
    }
  write_result:
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Section drawing is: ";
      if (vp.IsSection ()) G4cout << "on";
      else                 G4cout << "off";
      G4cout << ".\nSection plane is now: "
      << vp.GetSectionPlane ();
      G4cout << G4endl;
    }
  }
 
  else if (command == fpCommandSpecialMeshRendering) {
    vp.SetSpecialMeshRendering(G4UIcommand::ConvertToBool(newValue));
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Special mesh rendering ";
      if (vp.IsSpecialMeshRendering()) G4cout << "requested.";
      else G4cout << "inhibited.";
      G4cout << G4endl;
    }
  }
 
  else if (command == fpCommandSpecialMeshVolumes) {
    std::vector<G4ModelingParameters::PVNameCopyNo> requestedMeshes;
    if (newValue.empty()) {
      vp.SetSpecialMeshVolumes(requestedMeshes);  // Empty list
    } else {
      // Algorithm from Josuttis p.476.
      G4String::size_type iBegin, iEnd;
      iBegin = newValue.find_first_not_of(' ');
      while (iBegin != G4String::npos) {
    iEnd = newValue.find_first_of(' ',iBegin);
    if (iEnd == G4String::npos) {
      iEnd = newValue.length();
    }
    G4String name(newValue.substr(iBegin,iEnd-iBegin));
    iBegin = newValue.find_first_not_of(' ',iEnd);
    if (iBegin == G4String::npos) {
      if (verbosity >= G4VisManager::warnings) {
        G4cout <<
        "WARNING: G4VisCommandsViewerSet::SetNewValue: /vis/viewer/set/specialMeshVolumes"
        "\n  A pair not found.  (There should be an even number of parameters.)"
        "\n  Command ignored."
        << G4endl;
        return;
      }
    }
    iEnd = newValue.find_first_of(' ',iBegin);
    if (iEnd == G4String::npos) {
      iEnd = newValue.length();
    }
    G4int copyNo;
    std::istringstream iss(newValue.substr(iBegin,iEnd-iBegin));
    if (!(iss >> copyNo)) {
      if (verbosity >= G4VisManager::warnings) {
        G4cout <<
        "WARNING: G4VisCommandsViewerSet::SetNewValue: /vis/viewer/set/specialMeshVolumes"
        "\n  Error reading copy number - it was not numeric?"
        "\n  Command ignored."
        << G4endl;
        return;
      }
    }
    requestedMeshes.push_back(G4ModelingParameters::PVNameCopyNo(name,copyNo));
    iBegin = newValue.find_first_not_of(' ',iEnd);
      }
      vp.SetSpecialMeshVolumes(requestedMeshes);
    }
    if (verbosity >= G4VisManager::confirmations) {
      if (vp.GetSpecialMeshVolumes().empty()) {
    G4cout <<
    "Special mesh list empty, which means \"all meshes\"."
    << G4endl;
      } else {
    G4cout << "Selected special mesh volumes are:";
    for (const auto& pvNameCopyNo: vp.GetSpecialMeshVolumes()) {
      G4cout << "\n  " << pvNameCopyNo.GetName();
      if (pvNameCopyNo.GetCopyNo() >= 0) G4cout << ':' << pvNameCopyNo.GetCopyNo();
    }
    G4cout << G4endl;
      }
    }
  }
 
  else if (command == fpCommandStyle) {
    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
    const size_t iPos0 = 0;
    if (newValue[iPos0] == 'w') {  // "wireframe"
      switch (existingStyle) {
        case G4ViewParameters::wireframe:
          break;
        case G4ViewParameters::hlr:
          break;
        case G4ViewParameters::hsr:
          vp.SetDrawingStyle(G4ViewParameters::wireframe);
          break;
        case G4ViewParameters::hlhsr:
          vp.SetDrawingStyle(G4ViewParameters::hlr);
          break;
        case G4ViewParameters::cloud:
          vp.SetDrawingStyle(G4ViewParameters::wireframe);
          break;
      }
    }
    else if (newValue[iPos0] == 's') {  // "surface"
      switch (existingStyle) {
        case G4ViewParameters::wireframe:
          vp.SetDrawingStyle(G4ViewParameters::hsr);
          break;
        case G4ViewParameters::hlr:
          vp.SetDrawingStyle(G4ViewParameters::hlhsr);
          break;
        case G4ViewParameters::hsr:
          break;
        case G4ViewParameters::hlhsr:
          break;
        case G4ViewParameters::cloud:
          vp.SetDrawingStyle(G4ViewParameters::hsr);
          break;
     }
    }
    else if (newValue[iPos0] == 'c') {  // "cloud"
      switch (existingStyle) {
        case G4ViewParameters::wireframe:
          vp.SetDrawingStyle(G4ViewParameters::cloud);
          break;
        case G4ViewParameters::hlr:
          vp.SetDrawingStyle(G4ViewParameters::cloud);
          break;
        case G4ViewParameters::hsr:
          vp.SetDrawingStyle(G4ViewParameters::cloud);
          break;
        case G4ViewParameters::hlhsr:
          vp.SetDrawingStyle(G4ViewParameters::cloud);
          break;
        case G4ViewParameters::cloud:
          break;
      }
    }
    else {
      if (verbosity >= G4VisManager::errors) {
        G4cerr << "ERROR: \"" << newValue << "\" not recognised."
        "  Looking for 'w' or 's' or 'c' first character." << G4endl;
      }
      return;
    }
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
      << "\" set to " << vp.GetDrawingStyle()
      << G4endl;
    }
  }
 
  else if (command == fpCommandTargetPoint) {
    G4ThreeVector targetPoint =
    fpCommandTargetPoint->GetNew3VectorValue(newValue);
    const G4Point3D& standardTargetPoint =
    currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint();
    vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Target point set to "
      << fpCommandTargetPoint->ConvertToStringWithBestUnit
      (targetPoint)
      << "\n\"Current Target Point\" set to  "
      << fpCommandTargetPoint->ConvertToStringWithBestUnit
      (vp.GetCurrentTargetPoint())
      << "\n\"Standard Target Point\" is "
      << fpCommandTargetPoint->ConvertToStringWithBestUnit
      (standardTargetPoint)
      << G4endl;
    }
  }
 
  else if (command == fpCommandUpThetaPhi) {
    G4double theta, phi;
    if (ConvertToDoublePair(newValue, theta, phi)) {
      G4double x = std::sin (theta) * std::cos (phi);
      G4double y = std::sin (theta) * std::sin (phi);
      G4double z = std::cos (theta);
      fUpVector = G4ThreeVector (x, y, z);
      vp.SetUpVector(fUpVector);
      if (verbosity >= G4VisManager::confirmations) {
        G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
      }
    }
  }
 
  else if (command == fpCommandUpVector) {
    fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
    vp.SetUpVector(fUpVector);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
    }
  }
 
  else if (command == fpCommandViewpointThetaPhi) {
    G4double theta, phi;
    if (ConvertToDoublePair(newValue, theta, phi)) {
      G4double x = std::sin (theta) * std::cos (phi);
      G4double y = std::sin (theta) * std::sin (phi);
      G4double z = std::cos (theta);
      fViewpointVector = G4ThreeVector (x, y, z);
      vp.SetViewAndLights(fViewpointVector);
      if (verbosity >= G4VisManager::confirmations) {
        G4cout << "Viewpoint direction set to "
        << vp.GetViewpointDirection() << G4endl;
        if (vp.GetLightsMoveWithCamera ()) {
          G4cout << "Lightpoint direction set to "
          << vp.GetActualLightpointDirection () << G4endl;
        }
      }
    }
  }
 
  else if (command == fpCommandViewpointVector) {
    G4ThreeVector viewpointVector = G4UIcommand::ConvertTo3Vector(newValue);
    if (viewpointVector.mag2() <= 0.) {
      if (verbosity >= G4VisManager::errors) {
        G4cerr << "ERROR: Null viewpoint vector. No action taken." << G4endl;
      }
    } else {
      fViewpointVector = viewpointVector.unit();
      vp.SetViewAndLights(fViewpointVector);
      if (verbosity >= G4VisManager::confirmations) {
        G4cout << "Viewpoint direction set to "
        << vp.GetViewpointDirection() << G4endl;
        if (vp.GetLightsMoveWithCamera ()) {
          G4cout << "Lightpoint direction set to "
          << vp.GetActualLightpointDirection () << G4endl;
        }
      }
    }
  }
 
  else if (command == fpCommandTimeWindowDisplayHeadTime)
  {
    G4String display;
    G4double screenX, screenY, screenSize, red, green, blue;
    std::istringstream iss(newValue);
    iss >> display >> screenX >> screenY
    >> screenSize >> red >> green >> blue;
    vp.SetDisplayHeadTime(command->ConvertToBool(display));
    vp.SetDisplayHeadTimeX(screenX);
    vp.SetDisplayHeadTimeY(screenY);
    vp.SetDisplayHeadTimeSize(screenSize);
    vp.SetDisplayHeadTimeRed(red);
    vp.SetDisplayHeadTimeGreen(green);
    vp.SetDisplayHeadTimeBlue(blue);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Display head time flag set: "
      << vp
      << G4endl;
    }
  }
 
  else if (command == fpCommandTimeWindowDisplayLightFront)
  {
    G4String display, originX, originY, originZ, unitS, originT, unitT;
    G4double red, green, blue;
    std::istringstream iss(newValue);
    iss >> display
    >> originX >> originY >> originZ >> unitS
    >> originT >> unitT
    >> red >> green >> blue;
    vp.SetDisplayLightFront(command->ConvertToBool(display));
    vp.SetDisplayLightFrontX
    (command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS)));
    vp.SetDisplayLightFrontY
    (command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS)));
    vp.SetDisplayLightFrontZ
    (command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS)));
    vp.SetDisplayLightFrontT
    (command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT)));
    vp.SetDisplayLightFrontRed(red);
    vp.SetDisplayLightFrontGreen(green);
    vp.SetDisplayLightFrontBlue(blue);
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Display light front flag set: "
      << vp
      << G4endl;
    }
  }
 
  else if (command == fpCommandTimeWindowEndTime)
  {
    G4String end_time_string, end_time_unit,
    time_range_string, time_range_unit;
    std::istringstream iss(newValue);
    iss >> end_time_string >> end_time_unit
    >> time_range_string >> time_range_unit;
    vp.SetEndTime
    (command->ConvertToDimensionedDouble
     (G4String(end_time_string + ' ' + end_time_unit)));
    G4double timeRange = command->ConvertToDimensionedDouble
    (G4String(time_range_string + ' ' + time_range_unit));
    if (timeRange > 0.) {
      vp.SetStartTime
      (vp.GetEndTime() - timeRange);
    }
    if (verbosity >= G4VisManager::confirmations) {
      G4cout
      << "Time window start time: " << vp.GetStartTime()/ns << " ns"
      << ", time window end time: " << vp.GetEndTime()/ns << " ns";
      if (timeRange > 0.) {
        G4cout << "\n  (time range: " << timeRange/ns << " ns)";
      }
      G4cout << G4endl;
    }
  }
 
  else if (command == fpCommandTimeWindowFadeFactor) {
    vp.SetFadeFactor(command->ConvertToDouble(newValue));
    if (verbosity >= G4VisManager::confirmations) {
      G4cout << "Time window fade factor changed to " << vp.GetFadeFactor()
      << G4endl;
    }
  }
 
  else if (command == fpCommandTimeWindowStartTime)
  {
    G4String start_time_string, start_time_unit,
    time_range_string, time_range_unit;
    std::istringstream iss(newValue);
    iss >> start_time_string >> start_time_unit
    >> time_range_string >> time_range_unit;
    vp.SetStartTime
    (command->ConvertToDimensionedDouble
     (G4String(start_time_string + ' ' + start_time_unit)));
    G4double timeRange = command->ConvertToDimensionedDouble
    (G4String(time_range_string + ' ' + time_range_unit));
    if (timeRange > 0.) {
      vp.SetEndTime
      (vp.GetStartTime() + timeRange);
    }
    if (verbosity >= G4VisManager::confirmations) {
      G4cout
      << "Time window start time: " << vp.GetStartTime()/ns << " ns"
      << ", time window end time: " << vp.GetEndTime()/ns << " ns";
      if (timeRange > 0.) {
        G4cout << "\n  (time range: " << timeRange/ns << " ns)";
      }
      G4cout << G4endl;
    }
  }
 
  else {
    if (verbosity >= G4VisManager::errors) {
      G4cerr <<
      "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
      << G4endl;
    }
    return;
  }
 
  SetViewParameters(currentViewer,vp);
}

◆ SetViewParameters()

void G4VVisCommand::SetViewParameters	(	G4VViewer *	viewer,
		const G4ViewParameters &	viewParams
	)

protectedinherited

Definition at line 265 of file G4VVisCommand.cc.

                                                        {
  viewer->SetViewParameters(viewParams);
  RefreshIfRequired(viewer);
}

References G4VVisCommand::RefreshIfRequired(), and G4VViewer::SetViewParameters().

◆ SetVisManager()

void G4VVisCommand::SetVisManager ( G4VisManager * pVisManager )

staticinherited

Definition at line 65 of file G4VVisCommand.cc.

{
  fpVisManager = pVisManager;
}

References G4VVisCommand::fpVisManager.

Referenced by G4VisManager::G4VisManager().

◆ StoB()

G4bool G4UImessenger::StoB ( G4String s )

protectedinherited

Definition at line 137 of file G4UImessenger.cc.

{
  G4String v = G4StrUtil::to_upper_copy(str);
  G4bool vl = false;
  if(v == "Y" || v == "YES" || v == "1" || v == "T" || v == "TRUE")
  {
    vl = true;
  }
  return vl;
}

References G4StrUtil::to_upper_copy().

Referenced by G4LocalThreadCoutMessenger::SetNewValue(), G4CascadeParamMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoD()

G4double G4UImessenger::StoD ( G4String s )

protectedinherited

Definition at line 127 of file G4UImessenger.cc.

{
  G4double vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), G4ScoringMessenger::SetNewValue(), and G4PolarizationMessenger::SetNewValue().

◆ StoI()

G4int G4UImessenger::StoI ( G4String s )

protectedinherited

Definition at line 107 of file G4UImessenger.cc.

{
  G4int vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoringMessenger::Fill1D(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4ParticleGunMessenger::IonLevelCommand(), G4GeneralParticleSourceMessenger::IonLvlCommand(), G4ScoringMessenger::MeshBinCommand(), G4LocalThreadCoutMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4GMocrenMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoL()

G4long G4UImessenger::StoL ( G4String s )

protectedinherited

Definition at line 117 of file G4UImessenger.cc.

{
  G4long vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4RunMessenger::SetNewValue().

Field Documentation

◆ baseDir

G4UIdirectory* G4UImessenger::baseDir = nullptr

protectedinherited

Definition at line 102 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateDirectory(), and G4UImessenger::~G4UImessenger().

◆ baseDirName

G4String G4UImessenger::baseDirName = ""

protectedinherited

Definition at line 103 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateCommand(), and G4UImessenger::CreateDirectory().

◆ commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

Referenced by G4UImessenger::CommandsShouldBeInMaster(), and G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger().

◆ fCurrentArrow3DLineSegmentsPerCircle

G4int G4VVisCommand::fCurrentArrow3DLineSegmentsPerCircle = 6

staticprotectedinherited

Definition at line 146 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneAddElectricField::SetNewValue(), G4VisCommandSceneAddMagneticField::SetNewValue(), and G4VisCommandSetArrow3DLineSegmentsPerCircle::SetNewValue().

◆ fCurrentColour

G4Colour G4VVisCommand::fCurrentColour = G4Colour::White()

staticprotectedinherited

Definition at line 147 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), and G4VisCommandSetColour::SetNewValue().

◆ fCurrentExtentForField

G4VisExtent G4VVisCommand::fCurrentExtentForField

staticprotectedinherited

Definition at line 156 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddElectricField::SetNewValue(), G4VisCommandSceneAddMagneticField::SetNewValue(), G4VisCommandSetExtentForField::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

◆ fCurrentLineWidth

G4double G4VVisCommand::fCurrentLineWidth = 1.

staticprotectedinherited

Definition at line 148 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddAxes::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), and G4VisCommandSetLineWidth::SetNewValue().

◆ fCurrentTextColour

G4Colour G4VVisCommand::fCurrentTextColour = G4Colour::Blue()

staticprotectedinherited

Definition at line 152 of file G4VVisCommand.hh.

Referenced by G4VVisCommand::GetCurrentTextColour(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), and G4VisCommandSetTextColour::SetNewValue().

◆ fCurrentTextLayout

G4Text::Layout G4VVisCommand::fCurrentTextLayout = G4Text::left

staticprotectedinherited

Definition at line 153 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), and G4VisCommandSetTextLayout::SetNewValue().

◆ fCurrentTextSize

G4double G4VVisCommand::fCurrentTextSize = 12.

staticprotectedinherited

Definition at line 154 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddAxes::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4VisCommandSetTextSize::SetNewValue().

◆ fCurrentTouchableProperties

G4PhysicalVolumeModel::TouchableProperties G4VVisCommand::fCurrentTouchableProperties

staticprotectedinherited

Definition at line 155 of file G4VVisCommand.hh.

Referenced by G4VisCommandSetTouchable::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandsTouchableSet::SetNewValue().

◆ fCurrrentPVFindingsForField

std::vector< G4PhysicalVolumesSearchScene::Findings > G4VVisCommand::fCurrrentPVFindingsForField

staticprotectedinherited

Definition at line 157 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneAddElectricField::SetNewValue(), G4VisCommandSceneAddMagneticField::SetNewValue(), G4VisCommandSetExtentForField::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

◆ fLightsVector

G4ThreeVector G4VisCommandsViewerSet::fLightsVector

private

Definition at line 71 of file G4VisCommandsViewerSet.hh.

Referenced by SetNewValue().

◆ fpCommandAll

G4UIcmdWithAString* G4VisCommandsViewerSet::fpCommandAll

private

Definition at line 54 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandAutoRefresh

G4UIcmdWithABool* G4VisCommandsViewerSet::fpCommandAutoRefresh

private

Definition at line 55 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandAuxEdge

G4UIcmdWithABool* G4VisCommandsViewerSet::fpCommandAuxEdge

private

Definition at line 56 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandBackground

G4UIcommand* G4VisCommandsViewerSet::fpCommandBackground

private

Definition at line 57 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandCulling

G4UIcommand* G4VisCommandsViewerSet::fpCommandCulling

private

Definition at line 58 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandCutawayMode

G4UIcmdWithAString* G4VisCommandsViewerSet::fpCommandCutawayMode

private

Definition at line 59 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandDefaultColour

G4UIcommand* G4VisCommandsViewerSet::fpCommandDefaultColour

private

Definition at line 60 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandDefaultTextColour

G4UIcommand* G4VisCommandsViewerSet::fpCommandDefaultTextColour

private

Definition at line 61 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandEdge

G4UIcmdWithABool* G4VisCommandsViewerSet::fpCommandEdge

private

Definition at line 62 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandExplodeFactor

G4UIcommand* G4VisCommandsViewerSet::fpCommandExplodeFactor

private

Definition at line 63 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandGlobalLineWidthScale

G4UIcmdWithADouble* G4VisCommandsViewerSet::fpCommandGlobalLineWidthScale

private

Definition at line 65 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandGlobalMarkerScale

G4UIcmdWithADouble* G4VisCommandsViewerSet::fpCommandGlobalMarkerScale

private

Definition at line 64 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandHiddenEdge

G4UIcmdWithABool* G4VisCommandsViewerSet::fpCommandHiddenEdge

private

Definition at line 66 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandHiddenMarker

G4UIcmdWithABool* G4VisCommandsViewerSet::fpCommandHiddenMarker

private

Definition at line 67 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandLightsMove

G4UIcmdWithAString* G4VisCommandsViewerSet::fpCommandLightsMove

private

Definition at line 68 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandLightsThetaPhi

G4UIcommand* G4VisCommandsViewerSet::fpCommandLightsThetaPhi

private

Definition at line 69 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandLightsVector

G4UIcommand* G4VisCommandsViewerSet::fpCommandLightsVector

private

Definition at line 70 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandLineSegments

G4UIcmdWithAnInteger* G4VisCommandsViewerSet::fpCommandLineSegments

private

Definition at line 72 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandNumberOfCloudPoints

G4UIcmdWithAnInteger* G4VisCommandsViewerSet::fpCommandNumberOfCloudPoints

private

Definition at line 73 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandPicking

G4UIcmdWithABool* G4VisCommandsViewerSet::fpCommandPicking

private

Definition at line 74 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandProjection

G4UIcommand* G4VisCommandsViewerSet::fpCommandProjection

private

Definition at line 75 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandRotationStyle

G4UIcmdWithAString* G4VisCommandsViewerSet::fpCommandRotationStyle

private

Definition at line 76 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandSectionPlane

G4UIcommand* G4VisCommandsViewerSet::fpCommandSectionPlane

private

Definition at line 77 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandSpecialMeshRendering

G4UIcmdWithABool* G4VisCommandsViewerSet::fpCommandSpecialMeshRendering

private

Definition at line 78 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandSpecialMeshVolumes

G4UIcommand* G4VisCommandsViewerSet::fpCommandSpecialMeshVolumes

private

Definition at line 79 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandStyle

G4UIcmdWithAString* G4VisCommandsViewerSet::fpCommandStyle

private

Definition at line 80 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandTargetPoint

G4UIcmdWith3VectorAndUnit* G4VisCommandsViewerSet::fpCommandTargetPoint

private

Definition at line 81 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandTimeWindowDisplayHeadTime

G4UIcommand* G4VisCommandsViewerSet::fpCommandTimeWindowDisplayHeadTime

private

Definition at line 89 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandTimeWindowDisplayLightFront

G4UIcommand* G4VisCommandsViewerSet::fpCommandTimeWindowDisplayLightFront

private

Definition at line 90 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandTimeWindowEndTime

G4UIcommand* G4VisCommandsViewerSet::fpCommandTimeWindowEndTime

private

Definition at line 91 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandTimeWindowFadeFactor

G4UIcmdWithADouble* G4VisCommandsViewerSet::fpCommandTimeWindowFadeFactor

private

Definition at line 92 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandTimeWindowStartTime

G4UIcommand* G4VisCommandsViewerSet::fpCommandTimeWindowStartTime

private

Definition at line 93 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandUpThetaPhi

G4UIcommand* G4VisCommandsViewerSet::fpCommandUpThetaPhi

private

Definition at line 82 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandUpVector

G4UIcommand* G4VisCommandsViewerSet::fpCommandUpVector

private

Definition at line 83 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandViewpointThetaPhi

G4UIcommand* G4VisCommandsViewerSet::fpCommandViewpointThetaPhi

private

Definition at line 85 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpCommandViewpointVector

G4UIcommand* G4VisCommandsViewerSet::fpCommandViewpointVector

private

Definition at line 86 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), SetNewValue(), and ~G4VisCommandsViewerSet().

◆ fpTimeWindowDirectory

G4UIdirectory* G4VisCommandsViewerSet::fpTimeWindowDirectory

private

Definition at line 88 of file G4VisCommandsViewerSet.hh.

Referenced by G4VisCommandsViewerSet(), and ~G4VisCommandsViewerSet().

◆ fpVisManager

G4VisManager * G4VVisCommand::fpVisManager = nullptr

staticprotectedinherited

Definition at line 143 of file G4VVisCommand.hh.

◆ fThereWasAViewer

G4bool G4VVisCommand::fThereWasAViewer = false

staticprotectedinherited

Definition at line 163 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneHandlerCreate::SetNewValue(), and G4VisCommandViewerCreate::SetNewValue().

◆ fUpVector

G4ThreeVector G4VisCommandsViewerSet::fUpVector

private

Definition at line 84 of file G4VisCommandsViewerSet.hh.

Referenced by SetNewValue().

◆ fViewpointVector

G4ThreeVector G4VisCommandsViewerSet::fViewpointVector

private

Definition at line 87 of file G4VisCommandsViewerSet.hh.

Referenced by SetNewValue().

◆ fVPExistingViewer

G4ViewParameters G4VVisCommand::fVPExistingViewer

staticprotectedinherited

Definition at line 164 of file G4VVisCommand.hh.

Referenced by G4VisCommandSceneHandlerCreate::SetNewValue(), and G4VisCommandViewerCreate::SetNewValue().

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

source/visualization/management/include/G4VisCommandsViewerSet.hh
source/visualization/management/src/G4VisCommandsViewerSet.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4VisCommandsViewerSet() [1/2]

◆ ~G4VisCommandsViewerSet()

◆ G4VisCommandsViewerSet() [2/2]

Member Function Documentation

◆ AddUIcommand()

◆ BtoS()

◆ CheckSceneAndNotifyHandlers()

◆ CheckView()

◆ CommandsShouldBeInMaster()

◆ ConvertToColour()

◆ ConvertToColourGuidance()

◆ ConvertToDoublePair()

◆ ConvertToString()

◆ CopyCameraParameters()

◆ CopyGuidanceFrom()

◆ CopyMostViewParameters()

◆ CopyParametersFrom()

◆ CreateCommand()

◆ CreateDirectory()

◆ DrawExtent()

◆ DtoS()

◆ G4VisCommandsSceneAddUnsuccessful()

◆ GetCurrentTextColour()

◆ GetCurrentValue()

◆ GetVisManager()

◆ InterpolateToNewView()

◆ InterpolateViews()

◆ ItoS()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ ProvideValueOfUnit()

◆ RefreshIfRequired()

◆ SetNewValue()

◆ SetViewParameters()

◆ SetVisManager()

◆ StoB()

◆ StoD()

◆ StoI()

◆ StoL()

Field Documentation

◆ baseDir

◆ baseDirName

◆ commandsShouldBeInMaster

◆ fCurrentArrow3DLineSegmentsPerCircle

◆ fCurrentColour

◆ fCurrentExtentForField

◆ fCurrentLineWidth

◆ fCurrentTextColour

◆ fCurrentTextLayout

◆ fCurrentTextSize

◆ fCurrentTouchableProperties

◆ fCurrrentPVFindingsForField

◆ fLightsVector

◆ fpCommandAll

◆ fpCommandAutoRefresh

◆ fpCommandAuxEdge

◆ fpCommandBackground

◆ fpCommandCulling

◆ fpCommandCutawayMode

◆ fpCommandDefaultColour

◆ fpCommandDefaultTextColour

◆ fpCommandEdge

◆ fpCommandExplodeFactor

◆ fpCommandGlobalLineWidthScale

◆ fpCommandGlobalMarkerScale

◆ fpCommandHiddenEdge

◆ fpCommandHiddenMarker

◆ fpCommandLightsMove

◆ fpCommandLightsThetaPhi