Geant4: G4VisManager Class Reference

Enumerator:

quiet
startup
errors
warnings
confirmations
parameters
all

Definition at line 147 of file G4VisManager.hh.

00147                  {
00148     quiet,         // Nothing is printed.
00149     startup,       // Startup and endup messages are printed...
00150     errors,        // ...and errors...
00151     warnings,      // ...and warnings...
00152     confirmations, // ...and confirming messages...
00153     parameters,    // ...and parameters of scenes and views...
00154     all            // ...and everything available.
00155   };

G4VisManager::G4VisManager ( const G4String & verbosityString = "warnings" ) [protected]

Definition at line 84 of file G4VisManager.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4VisStateDependent, GetVerbosityValue(), RegisterMessenger(), G4VVisManager::SetConcreteInstance(), G4VVisCommand::SetVisManager(), startup, VerbosityGuidanceStrings, and VerbosityString().

00084                                                           :
00085   fVerbose         (1),
00086   fInitialised     (false),
00087   fpGraphicsSystem (0),
00088   fpScene          (0),
00089   fpSceneHandler   (0),
00090   fpViewer         (0),
00091   fpStateDependent (0),
00092   fEventRefreshing          (false),
00093   fTransientsDrawnThisRun   (false),
00094   fTransientsDrawnThisEvent (false),
00095   fEventKeepingSuspended    (false),
00096   fKeptLastEvent            (false),
00097   fpRequestedEvent (0),
00098   fAbortReviewKeptEvents    (false),
00099   fIsDrawGroup              (false),
00100   fDrawGroupNestingDepth    (0)
00101   // All other objects use default constructors.
00102 {
00103   fpTrajDrawModelMgr = new G4VisModelManager<G4VTrajectoryModel>("/vis/modeling/trajectories");
00104   fpTrajFilterMgr = new G4VisFilterManager<G4VTrajectory>("/vis/filtering/trajectories");
00105   fpHitFilterMgr = new G4VisFilterManager<G4VHit>("/vis/filtering/hits");
00106   fpDigiFilterMgr = new G4VisFilterManager<G4VDigi>("/vis/filtering/digi");
00107 
00108   VerbosityGuidanceStrings.push_back
00109     ("Simple graded message scheme - digit or string (1st character defines):");
00110   VerbosityGuidanceStrings.push_back
00111     ("  0) quiet,         // Nothing is printed.");
00112   VerbosityGuidanceStrings.push_back
00113     ("  1) startup,       // Startup and endup messages are printed...");
00114   VerbosityGuidanceStrings.push_back
00115     ("  2) errors,        // ...and errors...");
00116   VerbosityGuidanceStrings.push_back
00117     ("  3) warnings,      // ...and warnings...");
00118   VerbosityGuidanceStrings.push_back
00119     ("  4) confirmations, // ...and confirming messages...");
00120   VerbosityGuidanceStrings.push_back
00121     ("  5) parameters,    // ...and parameters of scenes and views...");
00122   VerbosityGuidanceStrings.push_back
00123     ("  6) all            // ...and everything available.");
00124 
00125   if (fpInstance) {
00126     G4Exception
00127       ("G4VisManager::G4VisManager",
00128        "visman0001", FatalException,
00129        "Attempt to Construct more than one VisManager");
00130   }
00131 
00132   fpInstance = this;
00133   SetConcreteInstance(this);
00134 
00135   fpStateDependent = new G4VisStateDependent (this);
00136   // No need to delete this; G4StateManager does this.
00137 
00138   fVerbosity = GetVerbosityValue(verbosityString);
00139   if (fVerbosity >= startup) {
00140       G4cout
00141         << "Visualization Manager instantiating with verbosity \""
00142         << VerbosityString(fVerbosity)
00143         << "\"..." << G4endl;
00144   }
00145 
00146   // Note: The specific graphics systems must be instantiated in a
00147   // higher level library to avoid circular dependencies.  Also,
00148   // some specifically need additional external libararies that the
00149   // user must supply.  Therefore we ask the user to implement
00150   // RegisterGraphicsSystems() and RegisterModelFactories()
00151   // in a subclass.  We have to wait for the subclass to instantiate
00152   // so RegisterGraphicsSystems() cannot be called from this
00153   // constructor; it is called from Initialise().  So we ask the
00154   // user:
00155   //   (a) to write a subclass and implement  RegisterGraphicsSystems()
00156   //       and RegisterModelFactories().  See
00157   //       visualization/include/G4VisExecutive.hh/icc as an example.
00158   //   (b) instantiate the subclass.
00159   //   (c) invoke the Initialise() method of the subclass.
00160   // For example:
00161   //   ...
00162   // #ifdef G4VIS_USE
00163   //   // Instantiate and initialise Visualization Manager.
00164   //   G4VisManager* visManager = new G4VisExecutive;
00165   //   visManager -> SetVerboseLevel (Verbose);
00166   //   visManager -> Initialise ();
00167   // #endif
00168   //   // (Don't forget to delete visManager;)
00169   //   ...
00170 
00171   // Make top level command directory...
00172   G4UIcommand* directory;
00173   directory = new G4UIdirectory ("/vis/");
00174   directory -> SetGuidance ("Visualization commands.");
00175   fDirectoryList.push_back (directory);
00176 
00177   // Instantiate *basic* top level commands so that they can be used
00178   // immediately after instantiation of the vis manager.  Other top
00179   // level and lower level commands are instantiated later in
00180   // RegisterMessengers.
00181   G4VVisCommand::SetVisManager (this);  // Sets shared pointer
00182   RegisterMessenger(new G4VisCommandVerbose);
00183   RegisterMessenger(new G4VisCommandInitialize);
00184 }

G4VisManager::~G4VisManager ( ) [virtual]

Definition at line 186 of file G4VisManager.cc.

References G4cout, G4endl, and startup.

00186                              {
00187   fpInstance = 0;
00188   size_t i;
00189   for (i = 0; i < fSceneList.size (); ++i) {
00190     delete fSceneList[i];
00191   }
00192   for (i = 0; i < fAvailableSceneHandlers.size (); ++i) {
00193   if (fAvailableSceneHandlers[i] != NULL) {
00194     delete fAvailableSceneHandlers[i];
00195   }
00196   }
00197   for (i = 0; i < fAvailableGraphicsSystems.size (); ++i) {
00198     if (fAvailableGraphicsSystems[i]) {
00199       delete fAvailableGraphicsSystems[i];
00200     }
00201   }
00202   if (fVerbosity >= startup) {
00203     G4cout << "Graphics systems deleted." << G4endl;
00204     G4cout << "Visualization Manager deleting..." << G4endl;
00205   }
00206   for (i = 0; i < fMessengerList.size (); ++i) {
00207     delete fMessengerList[i];
00208   }
00209   for (i = 0; i < fDirectoryList.size (); ++i) {
00210     delete fDirectoryList[i];
00211   }
00212 
00213   delete fpDigiFilterMgr;
00214   delete fpHitFilterMgr;
00215   delete fpTrajFilterMgr;
00216   delete fpTrajDrawModelMgr;
00217 }

void G4VisManager::BeginDraw ( const G4Transform3D & objectTransformation = G4Transform3D() ) [virtual]

Implements G4VVisManager.

Definition at line 648 of file G4VisManager.cc.

References G4Exception(), and JustWarning.

00649 {
00650   fDrawGroupNestingDepth++;
00651   if (fDrawGroupNestingDepth > 1) {
00652     G4Exception
00653       ("G4VSceneHandler::BeginDraw",
00654        "visman0008", JustWarning,
00655        "Nesting detected. It is illegal to nest Begin/EndDraw."
00656        "\n Ignored");
00657     return;
00658   }
00659   if (IsValidView ()) {
00660     ClearTransientStoreIfMarked();
00661     fpSceneHandler -> BeginPrimitives (objectTransform);
00662     fIsDrawGroup = true;
00663   }
00664 }

void G4VisManager::BeginDraw2D ( const G4Transform3D & objectTransformation = G4Transform3D() ) [virtual]

Implements G4VVisManager.

Definition at line 679 of file G4VisManager.cc.

References G4Exception(), and JustWarning.

00680 {
00681   fDrawGroupNestingDepth++;
00682   if (fDrawGroupNestingDepth > 1) {
00683     G4Exception
00684       ("G4VSceneHandler::BeginDraw2D",
00685        "visman0009", JustWarning,
00686        "Nesting detected. It is illegal to nest Begin/EndDraw2D."
00687        "\n Ignored");
00688     return;
00689   }
00690   if (IsValidView ()) {
00691     ClearTransientStoreIfMarked();
00692     fpSceneHandler -> BeginPrimitives2D (objectTransform);
00693     fIsDrawGroup = true;
00694   }
00695 }

void G4VisManager::CreateSceneHandler ( G4String name = "" )

Definition at line 912 of file G4VisManager.cc.

References errors, G4cout, G4endl, and Initialise().

00912                                                     {
00913   if (!fInitialised) Initialise ();
00914   if (fpGraphicsSystem) {
00915     G4VSceneHandler* pSceneHandler =
00916       fpGraphicsSystem -> CreateSceneHandler (name);
00917     if (pSceneHandler) {
00918       fAvailableSceneHandlers.push_back (pSceneHandler);
00919       fpSceneHandler = pSceneHandler;                         // Make current.
00920     }
00921     else {
00922       if(fVerbosity >= errors) {
00923         G4cout << "ERROR in G4VisManager::CreateSceneHandler during "
00924                << fpGraphicsSystem -> GetName ()
00925                << " scene handler creation.\n  No action taken."
00926                << G4endl;
00927       }
00928     }
00929   }
00930   else PrintInvalidPointers ();
00931 }

void G4VisManager::CreateViewer	(	G4String	name = `""`,
		G4String	XGeometry = `""`
	)

Definition at line 933 of file G4VisManager.cc.

References confirmations, errors, G4cout, G4endl, G4VViewer::GetViewParameters(), Initialise(), G4ViewParameters::IsCulling(), G4ViewParameters::IsCullingCovered(), G4ViewParameters::IsCullingInvisible(), parameters, SetCurrentViewer(), G4ViewParameters::SetXGeometryString(), and warnings.

00933                                                                  {
00934 
00935   if (!fInitialised) Initialise ();
00936 
00937   if (!fpSceneHandler) {
00938     PrintInvalidPointers ();
00939     return;
00940   }
00941 
00942   G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);
00943 
00944   if (!p) {
00945     if (fVerbosity >= errors) {
00946       G4cout << "ERROR in G4VisManager::CreateViewer during "
00947              << fpGraphicsSystem -> GetName ()
00948              << " viewer creation.\n  No action taken."
00949              << G4endl;
00950     }
00951     return;
00952   }
00953 
00954   if (p -> GetViewId() < 0) {
00955     if (fVerbosity >= errors) {
00956       G4cout << "ERROR in G4VisManager::CreateViewer during "
00957              << fpGraphicsSystem -> GetName ()
00958              << " viewer initialisation.\n  No action taken."
00959              << G4endl;
00960     }
00961     return;
00962   }
00963 
00964   // Viewer is created, now we can set geometry parameters
00965   // Before 12/2008, it was done in G4VViewer.cc but it did not have to be there!
00966     
00967   G4ViewParameters initialvp = p -> GetViewParameters();
00968   initialvp.SetXGeometryString(XGeometry); //parse string and store parameters
00969   p -> SetViewParameters(initialvp);
00970   p -> Initialise ();  // (Viewer itself may change view parameters further.)
00971 
00972   fpViewer = p;                             // Make current.
00973   fpSceneHandler -> AddViewerToList (fpViewer);
00974   fpSceneHandler -> SetCurrentViewer (fpViewer);
00975   if (fVerbosity >= confirmations) {
00976     G4cout << "G4VisManager::CreateViewer: new viewer created."
00977            << G4endl;
00978   }
00979 
00980   const G4ViewParameters& vp = fpViewer->GetViewParameters();
00981   if (fVerbosity >= parameters) {
00982     G4cout << " view parameters are:\n  " << vp << G4endl;
00983   }
00984 
00985   if (vp.IsCulling () && vp.IsCullingInvisible ()) {
00986     static G4bool warned = false;
00987     if (fVerbosity >= confirmations) {
00988       if (!warned) {
00989         G4cout <<
00990   "NOTE: objects with visibility flag set to \"false\""
00991   " will not be drawn!"
00992   "\n  \"/vis/viewer/set/culling global false\" to Draw such objects."
00993   "\n  Also see other \"/vis/viewer/set\" commands."
00994                << G4endl;
00995         warned = true;
00996       }
00997     }
00998   }
00999   if (vp.IsCullingCovered ()) {
01000     static G4bool warned = false;
01001     if (fVerbosity >= warnings) {
01002       if (!warned) {
01003         G4cout <<
01004   "WARNING: covered objects in solid mode will not be rendered!"
01005   "\n  \"/vis/viewer/set/culling coveredDaughters false\" to reverse this."
01006   "\n  Also see other \"/vis/viewer/set\" commands."
01007                << G4endl;
01008         warned = true;
01009       }
01010     }
01011   }
01012 }

const G4VTrajectoryModel * G4VisManager::CurrentTrajDrawModel ( ) const

Definition at line 576 of file G4VisManager.cc.

References G4VisModelManager< Model >::Current(), G4cout, G4endl, G4VisModelManager< Model >::Register(), and warnings.

Referenced by G4HepRepFileSceneHandler::BeginModeling(), and DispatchToModel().

00577 {
00578   assert (0 != fpTrajDrawModelMgr);
00579 
00580   const G4VTrajectoryModel* model = fpTrajDrawModelMgr->Current();
00581 
00582   if (0 == model) {
00583     // No model was registered with the trajectory model manager.
00584     // Use G4TrajectoryDrawByCharge as a default.
00585     fpTrajDrawModelMgr->Register(new G4TrajectoryDrawByCharge("AutoGenerated"));
00586 
00587     if (fVerbosity >= warnings) {
00588       G4cout<<"G4VisManager: Using G4TrajectoryDrawByCharge as default trajectory model."<<G4endl;
00589       G4cout<<"See commands in /vis/modeling/trajectories/ for other options."<<G4endl;
00590     }
00591   }
00592 
00593   model = fpTrajDrawModelMgr->Current();
00594   assert (0 != model); // Should definitely exist now
00595 
00596   return model;
00597 }

void G4VisManager::Disable ( )

Definition at line 521 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, and G4VVisManager::SetConcreteInstance().

Referenced by G4VisCommandEnable::SetNewValue().

00521                            {
00522   SetConcreteInstance(0);
00523   if (fVerbosity >= confirmations) {
00524     G4cout <<
00525       "G4VisManager::Disable: visualization disabled."
00526       "\n  The pointer returned by GetConcreteInstance will be zero."
00527       "\n  Note that it will become enabled after some valid vis commands."
00528            << G4endl;
00529   }
00530 }

void G4VisManager::DispatchToModel	(	const G4VTrajectory &	,
		G4int	i_mode
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 1158 of file G4VisManager.cc.

References CurrentTrajDrawModel(), G4VTrajectoryModel::Draw(), FilterTrajectory(), G4VisFilterManager< T >::GetMode(), G4VSceneHandler::GetModel(), G4TrajectoriesModel::IsDrawingModeSet(), and FilterMode::Soft.

01159 {
01160   G4bool visible(true);
01161 
01162   // See if trajectory passes filter
01163   G4bool passed = FilterTrajectory(trajectory);
01164 
01165   if (!passed) {
01166     // Draw invisible trajectory if trajectory failed filter and
01167     // are filtering in soft mode
01168     if (fpTrajFilterMgr->GetMode() == FilterMode::Soft) visible = false;
01169     else {return;}
01170   }
01171 
01172   // Go on to draw trajectory
01173   assert (0 != fpTrajDrawModelMgr);
01174 
01175   const G4VTrajectoryModel* trajectoryModel = CurrentTrajDrawModel();
01176 
01177   assert (0 != trajectoryModel); // Should exist
01178 
01179   if (IsValidView()) {
01180     G4TrajectoriesModel* trajectoriesModel =
01181       dynamic_cast<G4TrajectoriesModel*>(fpSceneHandler->GetModel());
01182     if (trajectoriesModel) {
01183       if (trajectoriesModel->IsDrawingModeSet()) {
01184         trajectoryModel->Draw(trajectory, i_mode, visible);
01185       } else {
01186         trajectoryModel->Draw(trajectory, visible);
01187       }
01188     } else {
01189       // Just draw at user's request
01190       trajectoryModel->Draw(trajectory, i_mode, visible);
01191     }
01192   }
01193 }

void G4VisManager::DispatchToModel ( const G4VTrajectory & ) [virtual]

Implements G4VVisManager.

Definition at line 1134 of file G4VisManager.cc.

References CurrentTrajDrawModel(), G4VTrajectoryModel::Draw(), FilterTrajectory(), G4VisFilterManager< T >::GetMode(), and FilterMode::Soft.

01135 {
01136   G4bool visible(true);
01137 
01138   // See if trajectory passes filter
01139   G4bool passed = FilterTrajectory(trajectory);
01140 
01141   if (!passed) {
01142     // Draw invisible trajectory if trajectory failed filter and
01143     // are filtering in soft mode
01144     if (fpTrajFilterMgr->GetMode() == FilterMode::Soft) visible = false;
01145     else {return;}
01146   }
01147 
01148   // Go on to draw trajectory
01149   assert (0 != fpTrajDrawModelMgr);
01150 
01151   const G4VTrajectoryModel* trajectoryModel = CurrentTrajDrawModel();
01152 
01153   assert (0 != trajectoryModel); // Should exist
01154 
01155   trajectoryModel->Draw(trajectory, visible);
01156 }

void G4VisManager::Draw	(	const G4VSolid &	,
		const G4VisAttributes &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 886 of file G4VisManager.cc.

References G4VSolid::DescribeYourselfTo().

00888                                                                {
00889   if (fIsDrawGroup) {
00890     fpSceneHandler -> PreAddSolid (objectTransform, attribs);
00891     solid.DescribeYourselfTo (*fpSceneHandler);
00892     fpSceneHandler -> PostAddSolid ();
00893   } else {
00894     if (IsValidView ()) {
00895       ClearTransientStoreIfMarked();
00896       fpSceneHandler -> PreAddSolid (objectTransform, attribs);
00897       solid.DescribeYourselfTo (*fpSceneHandler);
00898       fpSceneHandler -> PostAddSolid ();
00899     }
00900   }
00901 }

void G4VisManager::Draw	(	const G4VPhysicalVolume &	,
		const G4VisAttributes &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 903 of file G4VisManager.cc.

References Draw(), and G4VPhysicalVolume::GetLogicalVolume().

00905                                                                {
00906   // Find corresponding logical volume and solid.
00907   G4LogicalVolume* pLV  = physicalVol.GetLogicalVolume ();
00908   G4VSolid*        pSol = pLV -> GetSolid ();
00909   Draw (*pSol, attribs, objectTransform);
00910 }

void G4VisManager::Draw	(	const G4LogicalVolume &	,
		const G4VisAttributes &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 878 of file G4VisManager.cc.

References Draw(), and G4LogicalVolume::GetSolid().

00880                                                                {
00881   // Find corresponding solid.
00882   G4VSolid* pSol = logicalVol.GetSolid ();
00883   Draw (*pSol, attribs, objectTransform);
00884 }

void G4VisManager::Draw	(	const G4VTrajectory &	,
		G4int	i_mode
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 862 of file G4VisManager.cc.

References G4TrajectoriesModel::SetDrawingMode().

00863                                        {
00864   if (fIsDrawGroup) {
00865     fpSceneHandler -> SetModel (&dummyTrajectoriesModel);
00866     dummyTrajectoriesModel.SetDrawingMode(i_mode);
00867     fpSceneHandler -> AddCompound (traj);
00868   } else {
00869     if (IsValidView ()) {
00870       ClearTransientStoreIfMarked();
00871       fpSceneHandler -> SetModel (&dummyTrajectoriesModel);
00872       dummyTrajectoriesModel.SetDrawingMode(i_mode);
00873       fpSceneHandler -> AddCompound (traj);
00874     }
00875   }
00876 }

void G4VisManager::Draw ( const G4VDigi & ) [virtual]

Implements G4VVisManager.

Definition at line 851 of file G4VisManager.cc.

00851                                             {
00852   if (fIsDrawGroup) {
00853     fpSceneHandler -> AddCompound (digi);
00854   } else {
00855     if (IsValidView ()) {
00856       ClearTransientStoreIfMarked();
00857       fpSceneHandler -> AddCompound (digi);
00858     }
00859   }
00860 }

void G4VisManager::Draw ( const G4VHit & ) [virtual]

Implements G4VVisManager.

Definition at line 840 of file G4VisManager.cc.

00840                                           {
00841   if (fIsDrawGroup) {
00842     fpSceneHandler -> AddCompound (hit);
00843   } else {
00844     if (IsValidView ()) {
00845       ClearTransientStoreIfMarked();
00846       fpSceneHandler -> AddCompound (hit);
00847     }
00848   }
00849 }

void G4VisManager::Draw	(	const G4Text &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 792 of file G4VisManager.cc.

00794 {
00795   DrawT (text, objectTransform);
00796 }

void G4VisManager::Draw	(	const G4Square &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 786 of file G4VisManager.cc.

00788 {
00789   DrawT (square, objectTransform);
00790 }

void G4VisManager::Draw	(	const G4Scale &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 780 of file G4VisManager.cc.

00782 {
00783   DrawT (scale, objectTransform);
00784 }

void G4VisManager::Draw	(	const G4Polymarker &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 774 of file G4VisManager.cc.

00776 {
00777   DrawT (polymarker, objectTransform);
00778 }

void G4VisManager::Draw	(	const G4Polyline &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 768 of file G4VisManager.cc.

00770 {
00771   DrawT (line, objectTransform);
00772 }

void G4VisManager::Draw	(	const G4Polyhedron &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 762 of file G4VisManager.cc.

00764 {
00765   DrawT (polyhedron, objectTransform);
00766 }

void G4VisManager::Draw	(	const G4NURBS &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 756 of file G4VisManager.cc.

00758 {
00759   DrawT (nurbs, objectTransform);
00760 }

void G4VisManager::Draw	(	const G4Circle &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 750 of file G4VisManager.cc.

Referenced by Draw().

00752 {
00753   DrawT (circle, objectTransform);
00754 }

void G4VisManager::Draw2D	(	const G4Text &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 834 of file G4VisManager.cc.

00836 {
00837   DrawT2D (text, objectTransform);
00838 }

void G4VisManager::Draw2D	(	const G4Square &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 828 of file G4VisManager.cc.

00830 {
00831   DrawT2D (square, objectTransform);
00832 }

void G4VisManager::Draw2D	(	const G4Polymarker &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 822 of file G4VisManager.cc.

00824 {
00825   DrawT2D (polymarker, objectTransform);
00826 }

void G4VisManager::Draw2D	(	const G4Polyline &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 816 of file G4VisManager.cc.

00818 {
00819   DrawT2D (line, objectTransform);
00820 }

void G4VisManager::Draw2D	(	const G4Polyhedron &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 810 of file G4VisManager.cc.

00812 {
00813   DrawT2D (polyhedron, objectTransform);
00814 }

void G4VisManager::Draw2D	(	const G4NURBS &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 804 of file G4VisManager.cc.

00806 {
00807   DrawT2D (nurbs, objectTransform);
00808 }

void G4VisManager::Draw2D	(	const G4Circle &	,
		const G4Transform3D &	objectTransformation = `G4Transform3D()`
	)			`[virtual]`

Implements G4VVisManager.

Definition at line 798 of file G4VisManager.cc.

00800 {
00801   DrawT2D (circle, objectTransform);
00802 }

void G4VisManager::Enable ( )

Definition at line 504 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, and warnings.

Referenced by G4VisCommandEnable::SetNewValue().

00504                           {
00505   if (IsValidView ()) {
00506     if (fVerbosity >= confirmations) {
00507       G4cout << "G4VisManager::Enable: visualization enabled." << G4endl;
00508     }
00509   }
00510   else {
00511     if (fVerbosity >= warnings) {
00512       G4cout <<
00513         "G4VisManager::Enable: WARNING: visualization remains disabled for"
00514         "\n  above reasons.  Rectifying with valid vis commands will"
00515         "\n  automatically enable."
00516              << G4endl;
00517     }
00518   }
00519 }

void G4VisManager::EndDraw ( ) [virtual]

Implements G4VVisManager.

Definition at line 666 of file G4VisManager.cc.

00667 {
00668   fDrawGroupNestingDepth--;
00669   if (fDrawGroupNestingDepth != 0) {
00670     if (fDrawGroupNestingDepth < 0) fDrawGroupNestingDepth = 0;
00671     return;
00672   }
00673   if (IsValidView ()) {
00674     fpSceneHandler -> EndPrimitives ();
00675   }
00676   fIsDrawGroup = false;
00677 }

void G4VisManager::EndDraw2D ( ) [virtual]

Implements G4VVisManager.

Definition at line 697 of file G4VisManager.cc.

00698 {
00699   fDrawGroupNestingDepth--;
00700   if (fDrawGroupNestingDepth != 0) {
00701     if (fDrawGroupNestingDepth < 0) fDrawGroupNestingDepth = 0;
00702     return;
00703   }
00704   if (IsValidView ()) {
00705     fpSceneHandler -> EndPrimitives2D ();
00706   }
00707   fIsDrawGroup = false;
00708 }

G4bool G4VisManager::FilterDigi ( const G4VDigi & ) [virtual]

Implements G4VVisManager.

Definition at line 1129 of file G4VisManager.cc.

References G4VisFilterManager< T >::Accept().

01130 {
01131   return fpDigiFilterMgr->Accept(digi);
01132 }

G4bool G4VisManager::FilterHit ( const G4VHit & ) [virtual]

Implements G4VVisManager.

Definition at line 1124 of file G4VisManager.cc.

References G4VisFilterManager< T >::Accept().

01125 {
01126   return fpHitFilterMgr->Accept(hit);
01127 }

G4bool G4VisManager::FilterTrajectory ( const G4VTrajectory & ) [virtual]

Implements G4VVisManager.

Definition at line 1119 of file G4VisManager.cc.

References G4VisFilterManager< T >::Accept().

Referenced by DispatchToModel().

01120 {
01121   return fpTrajFilterMgr->Accept(trajectory);
01122 }

void G4VisManager::GeometryHasChanged ( ) [virtual]

Implements G4VVisManager.

Definition at line 1014 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, G4TransportationManager::GetTransportationManager(), G4UImanager::GetUIpointer(), and warnings.

01014                                        {
01015   if (fVerbosity >= confirmations) {
01016     G4cout << "G4VisManager::GeometryHasChanged() called." << G4endl;
01017   }
01018 
01019   // Change the world...
01020   G4VPhysicalVolume* pWorld =
01021     G4TransportationManager::GetTransportationManager ()
01022     -> GetNavigatorForTracking () -> GetWorldVolume ();
01023   if (!pWorld) {
01024     if (fVerbosity >= warnings) {
01025       G4cout << "WARNING: There is no world volume!" << G4endl;
01026     }
01027   }
01028 
01029   // Check scenes.
01030   G4SceneList& sceneList = fSceneList;
01031   G4int iScene, nScenes = sceneList.size ();
01032   for (iScene = 0; iScene < nScenes; iScene++) {
01033     G4Scene* pScene = sceneList [iScene];
01034     std::vector<G4Scene::Model>& modelList = pScene -> SetRunDurationModelList ();
01035     if (modelList.size ()) {
01036       G4bool modelInvalid;
01037       do {  // Remove, if required, one at a time.
01038         modelInvalid = false;
01039         std::vector<G4Scene::Model>::iterator iterModel;
01040         for (iterModel = modelList.begin();
01041              iterModel != modelList.end();
01042              ++iterModel) {
01043           modelInvalid = !(iterModel->fpModel->Validate(fVerbosity>=warnings));
01044           if (modelInvalid) {
01045             // Model invalid - remove and break.
01046             if (fVerbosity >= warnings) {
01047               G4cout << "WARNING: Model \""
01048                      << iterModel->fpModel->GetGlobalDescription ()
01049                      <<
01050                 "\" is no longer valid - being removed\n  from scene \""
01051                      << pScene -> GetName () << "\""
01052                      << G4endl;
01053             }
01054             modelList.erase (iterModel);
01055             break;
01056           }
01057         }
01058       } while (modelInvalid);
01059 
01060       if (modelList.size () == 0) {
01061         if (fVerbosity >= warnings) {
01062           G4cout << "WARNING: No models left in this scene \""
01063                  << pScene -> GetName ()
01064                  << "\"."
01065                  << G4endl;
01066         }
01067       }
01068       else {
01069         pScene->CalculateExtent();
01070         G4UImanager::GetUIpointer () ->
01071           ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
01072       }
01073     }
01074   }
01075 
01076   // Check the manager's current scene...
01077   if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
01078     if (fVerbosity >= warnings) {
01079       G4cout << "WARNING: The current scene \""
01080              << fpScene -> GetName ()
01081              << "\" has no models."
01082              << G4endl;
01083     }
01084   }
01085 
01086 }

G4bool G4VisManager::GetAbortReviewKeptEvents ( ) const [inline]

Definition at line 94 of file G4VisManager.icc.

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

00094                                                            {
00095   return fAbortReviewKeptEvents;
00096 }

const G4GraphicsSystemList & G4VisManager::GetAvailableGraphicsSystems ( )

Definition at line 532 of file G4VisManager.cc.

References G4cout, G4endl, and warnings.

Referenced by G4VisCommandOpen::G4VisCommandOpen().

00532                                                                        {
00533   G4int nSystems = fAvailableGraphicsSystems.size ();
00534   if (nSystems == 0) {
00535     if (fVerbosity >= warnings) {
00536       G4cout << "G4VisManager::GetAvailableGraphicsSystems: WARNING: no"
00537         "\n graphics system available!"
00538         "\n  1) Did you have environment variables G4VIS_BUILD_xxxx_DRIVER set"
00539         "\n     when you compiled/built the visualization code?"
00540         "\n  2) Did you instantiate your own Visualization Manager and forget"
00541         "\n     to implement RegisterGraphicsSystems correctly?"
00542         "\n  3) You can register your own graphics system, e.g.,"
00543         "\n     visManager->RegisterGraphicsSystem(new MyGraphicsSystem);)"
00544         "\n     after instantiating your vis manager and before"
00545         "\n     visManager->Initialize()."
00546              << G4endl;
00547     }
00548   }
00549   return fAvailableGraphicsSystems;
00550 }

const G4SceneHandlerList & G4VisManager::GetAvailableSceneHandlers ( ) const [inline]

Definition at line 69 of file G4VisManager.icc.

00069                                                {
00070   return fAvailableSceneHandlers;
00071 }

G4VGraphicsSystem * G4VisManager::GetCurrentGraphicsSystem ( ) const [inline]

Definition at line 78 of file G4VisManager.icc.

Referenced by G4VisCommandDrawTree::SetNewValue().

00078                                               {
00079   return fpGraphicsSystem;
00080 }

G4Scene * G4VisManager::GetCurrentScene ( ) const [inline]

Definition at line 64 of file G4VisManager.icc.

00064                                                      {
00065   return fpScene;
00066 }

G4VSceneHandler * G4VisManager::GetCurrentSceneHandler ( ) const [inline]

Definition at line 56 of file G4VisManager.icc.

Referenced by G4VisCommandSceneEndOfRunAction::SetNewValue(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneActivateModel::SetNewValue(), and G4VisCommandDrawTree::SetNewValue().

00056                                                                     {
00057   return fpSceneHandler;
00058 }

G4VViewer * G4VisManager::GetCurrentViewer ( ) const [inline]

const G4ViewParameters & G4VisManager::GetDefaultViewParameters ( ) const [inline]

Definition at line 98 of file G4VisManager.icc.

Referenced by G4VViewer::G4VViewer(), G4VisCommandViewerDefaultStyle::SetNewValue(), and G4VisCommandViewerDefaultHiddenEdge::SetNewValue().

00098                                                                             {
00099   return fDefaultViewParameters;
00100 }

const std::vector< G4VisManager::UserVisAction > & G4VisManager::GetEndOfEventUserVisActions ( ) const [inline]

Definition at line 42 of file G4VisManager.icc.

00042                                                  {
00043   return fEndOfEventUserVisActions;
00044 }

const std::vector< G4VisManager::UserVisAction > & G4VisManager::GetEndOfRunUserVisActions ( ) const [inline]

Definition at line 47 of file G4VisManager.icc.

00047                                                {
00048   return fEndOfRunUserVisActions;
00049 }

const G4Event * G4VisManager::GetRequestedEvent ( ) const [inline]

Definition at line 90 of file G4VisManager.icc.

Referenced by G4VSceneHandler::ProcessScene().

00090                                                             {
00091   return fpRequestedEvent;
00092 }

const std::vector< G4VisManager::UserVisAction > & G4VisManager::GetRunDurationUserVisActions ( ) const [inline]

Definition at line 37 of file G4VisManager.icc.

00037                                                   {
00038   return fRunDurationUserVisActions;
00039 }

const G4SceneList & G4VisManager::GetSceneList ( ) const [inline]

Definition at line 73 of file G4VisManager.icc.

00073                                                             {
00074   return fSceneList;
00075 }

G4bool G4VisManager::GetTransientsDrawnThisEvent ( ) const [inline]

Definition at line 82 of file G4VisManager.icc.

Referenced by G4VSceneHandler::G4VSceneHandler().

00082                                                               {
00083   return fTransientsDrawnThisEvent;
00084 }

G4bool G4VisManager::GetTransientsDrawnThisRun ( ) const [inline]

Definition at line 86 of file G4VisManager.icc.

Referenced by G4VSceneHandler::G4VSceneHandler().

00086                                                             {
00087   return fTransientsDrawnThisRun;
00088 }

const std::map< G4VUserVisAction *, G4VisExtent > & G4VisManager::GetUserVisActionExtents ( ) const [inline]

Definition at line 52 of file G4VisManager.icc.

00052                                              {
00053   return fUserVisActionExtents;
00054 }

G4VisManager::Verbosity G4VisManager::GetVerbosity ( ) [static]

Definition at line 1816 of file G4VisManager.cc.

01816                                                   {
01817   return fVerbosity;
01818 }

G4VisManager::Verbosity G4VisManager::GetVerbosityValue ( G4int ) [static]

Definition at line 1808 of file G4VisManager.cc.

References all, and quiet.

01808                                                                         {
01809   Verbosity verbosity;
01810   if      (intVerbosity < quiet) verbosity = quiet;
01811   else if (intVerbosity > all)   verbosity = all;
01812   else                           verbosity = Verbosity(intVerbosity);
01813   return verbosity;
01814 }

G4VisManager::Verbosity G4VisManager::GetVerbosityValue ( const G4String & ) [static]

Definition at line 1777 of file G4VisManager.cc.

References all, confirmations, errors, G4cout, parameters, quiet, startup, G4String::toLower(), VerbosityGuidanceStrings, VerbosityString(), and warnings.

Referenced by G4VisManager(), G4VisCommandViewerList::SetNewValue(), G4VisCommandSceneHandlerList::SetNewValue(), G4VisCommandSceneList::SetNewValue(), G4VisCommandVerbose::SetNewValue(), G4VisCommandList::SetNewValue(), and SetVerboseLevel().

01777                                                                {
01778   G4String ss(verbosityString); ss.toLower();
01779   Verbosity verbosity;
01780   if      (ss(0) == 'q') verbosity = quiet;
01781   else if (ss(0) == 's') verbosity = startup;
01782   else if (ss(0) == 'e') verbosity = errors;
01783   else if (ss(0) == 'w') verbosity = warnings;
01784   else if (ss(0) == 'c') verbosity = confirmations;
01785   else if (ss(0) == 'p') verbosity = parameters;
01786   else if (ss(0) == 'a') verbosity = all;
01787   else {
01788     G4int intVerbosity;
01789     std::istringstream is(ss);
01790     is >> intVerbosity;
01791     if (!is) {
01792       G4cout << "ERROR: G4VisManager::GetVerbosityValue: invalid verbosity \""
01793              << verbosityString << "\"";
01794       for (size_t i = 0; i < VerbosityGuidanceStrings.size(); ++i) {
01795         G4cout << '\n' << VerbosityGuidanceStrings[i];
01796       }
01797       verbosity = warnings;
01798       G4cout << "\n  Returning " << VerbosityString(verbosity)
01799              << G4endl;
01800     }
01801     else {
01802       verbosity = GetVerbosityValue(intVerbosity);
01803     }
01804   }
01805   return verbosity;
01806 }

G4VViewer * G4VisManager::GetViewer ( const G4String & viewerName ) const

Definition at line 1738 of file G4VisManager.cc.

References ViewerShortName().

01738                                                                     {
01739   G4String viewerShortName = ViewerShortName (viewerName);
01740   size_t nHandlers = fAvailableSceneHandlers.size ();
01741   size_t iHandler, iViewer;
01742   G4VViewer* viewer = 0;
01743   G4bool found = false;
01744   for (iHandler = 0; iHandler < nHandlers; iHandler++) {
01745     G4VSceneHandler* sceneHandler = fAvailableSceneHandlers [iHandler];
01746     const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
01747     for (iViewer = 0; iViewer < viewerList.size (); iViewer++) {
01748       viewer = viewerList [iViewer];
01749       if (viewerShortName == viewer -> GetShortName ()) {
01750         found = true;
01751         break;
01752       }
01753     }
01754     if (found) break;
01755   }
01756   if (found) return viewer;
01757   else return 0;
01758 }

void G4VisManager::Initialise ( )

Definition at line 228 of file G4VisManager.cc.

References G4cout, G4endl, parameters, PrintAvailableGraphicsSystems(), RegisterGraphicsSystems(), RegisterMessengers(), RegisterModelFactories(), startup, and warnings.

Referenced by CreateSceneHandler(), CreateViewer(), and Initialize().

00228                                {
00229 
00230   if (fInitialised && fVerbosity >= warnings) {
00231     G4cout << "WARNING: G4VisManager::Initialise: already initialised."
00232            << G4endl;
00233     return;
00234   }
00235 
00236   if (fVerbosity >= startup) {
00237     G4cout << "Visualization Manager initialising..." << G4endl;
00238   }
00239 
00240   if (fVerbosity >= parameters) {
00241     G4cout <<
00242       "\nYou have instantiated your own Visualization Manager, inheriting"
00243       "\n  G4VisManager and implementing RegisterGraphicsSystems(), in which"
00244       "\n  you should, normally, instantiate drivers which do not need"
00245       "\n  external packages or libraries, and, optionally, drivers under"
00246       "\n  control of environment variables."
00247       "\n  Also you should implement RegisterModelFactories()."
00248       "\n  See visualization/include/G4VisExecutive.hh/icc, for example."
00249       "\n  In your main() you will have something like:"
00250       "\n  #ifdef G4VIS_USE"
00251       "\n    G4VisManager* visManager = new G4VisExecutive;"
00252       "\n    visManager -> SetVerboseLevel (Verbose);"
00253       "\n    visManager -> Initialize ();"
00254       "\n  #endif"
00255       "\n  (Don't forget to delete visManager;)"
00256       "\n"
00257          << G4endl;
00258   }
00259 
00260   if (fVerbosity >= startup) {
00261     G4cout << "Registering graphics systems..." << G4endl;
00262   }
00263 
00264   RegisterGraphicsSystems ();
00265 
00266   if (fVerbosity >= startup) {
00267     G4cout <<
00268       "\nYou have successfully registered the following graphics systems."
00269          << G4endl;
00270     PrintAvailableGraphicsSystems ();
00271     G4cout << G4endl;
00272   }
00273 
00274   // Make command directories for commands instantiated in the
00275   // modeling subcategory...
00276   G4UIcommand* directory;
00277   directory = new G4UIdirectory ("/vis/modeling/");
00278   directory -> SetGuidance ("Modeling commands.");
00279   fDirectoryList.push_back (directory);
00280   directory = new G4UIdirectory ("/vis/modeling/trajectories/");
00281   directory -> SetGuidance ("Trajectory model commands.");
00282   fDirectoryList.push_back (directory);
00283   directory = new G4UIdirectory ("/vis/modeling/trajectories/create/");
00284   directory -> SetGuidance ("Create trajectory models and messengers.");
00285   fDirectoryList.push_back (directory);
00286 
00287   // Filtering command directory
00288   directory = new G4UIdirectory ("/vis/filtering/");
00289   directory -> SetGuidance ("Filtering commands.");
00290   fDirectoryList.push_back (directory);
00291   directory = new G4UIdirectory ("/vis/filtering/trajectories/");
00292   directory -> SetGuidance ("Trajectory filtering commands.");
00293   fDirectoryList.push_back (directory);
00294   directory = new G4UIdirectory ("/vis/filtering/trajectories/create/");
00295   directory -> SetGuidance ("Create trajectory filters and messengers.");
00296   fDirectoryList.push_back (directory);
00297   directory = new G4UIdirectory ("/vis/filtering/hits/");
00298   directory -> SetGuidance ("Hit filtering commands.");
00299   fDirectoryList.push_back (directory);
00300   directory = new G4UIdirectory ("/vis/filtering/hits/create/");
00301   directory -> SetGuidance ("Create hit filters and messengers.");
00302   fDirectoryList.push_back (directory);
00303   directory = new G4UIdirectory ("/vis/filtering/digi/");
00304   directory -> SetGuidance ("Digi filtering commands.");
00305   fDirectoryList.push_back (directory);
00306   directory = new G4UIdirectory ("/vis/filtering/digi/create/");
00307   directory -> SetGuidance ("Create digi filters and messengers.");
00308   fDirectoryList.push_back (directory);
00309 
00310   RegisterMessengers ();
00311 
00312   if (fVerbosity >= startup) {
00313     G4cout << "Registering model factories..." << G4endl;
00314   }
00315 
00316   RegisterModelFactories();
00317 
00318   if (fVerbosity >= startup) {
00319     G4cout <<
00320       "\nYou have successfully registered the following model factories."
00321            << G4endl;
00322     PrintAvailableModels (fVerbosity);
00323     G4cout << G4endl;
00324   }
00325 
00326   if (fVerbosity >= startup) {
00327     PrintAvailableUserVisActions (fVerbosity);
00328     G4cout << G4endl;
00329   }
00330 
00331   if (fVerbosity >= startup) {
00332     PrintAvailableColours (fVerbosity);
00333     G4cout << G4endl;
00334   }
00335 
00336   fInitialised = true;
00337 }

void G4VisManager::Initialize ( ) [inline]

Definition at line 32 of file G4VisManager.icc.

References Initialise().

Referenced by G4VisCommandInitialize::SetNewValue().

00032                                       {
00033   Initialise ();
00034 }

void G4VisManager::NotifyHandlers ( ) [virtual]

Reimplemented from G4VVisManager.

Definition at line 1087 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, G4UImanager::GetUIpointer(), and warnings.

01087                                    {
01088 
01089   if (fVerbosity >= confirmations) {
01090     G4cout << "G4VisManager::NotifyHandler() called." << G4endl;
01091   }
01092 
01093   // Check scenes.
01094   G4SceneList& sceneList = fSceneList;
01095   G4int iScene, nScenes = sceneList.size ();
01096   for (iScene = 0; iScene < nScenes; iScene++) {
01097     G4Scene* pScene = sceneList [iScene];
01098     std::vector<G4Scene::Model>& modelList = pScene -> SetRunDurationModelList ();
01099     
01100     if (modelList.size ()) {
01101       pScene->CalculateExtent();
01102       G4UImanager::GetUIpointer () ->
01103         ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
01104     }
01105   }
01106 
01107   // Check the manager's current scene...
01108   if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
01109     if (fVerbosity >= warnings) {
01110       G4cout << "WARNING: The current scene \""
01111              << fpScene -> GetName ()
01112              << "\" has no models."
01113              << G4endl;
01114     }
01115   }
01116 
01117 }

void G4VisManager::PrintAvailableGraphicsSystems ( ) const [protected]

Definition at line 1377 of file G4VisManager.cc.

References G4cout, and G4endl.

Referenced by Initialise(), and G4VisCommandList::SetNewValue().

01377                                                         {
01378   G4int nSystems = fAvailableGraphicsSystems.size ();
01379   G4cout << "Current available graphics systems are:";
01380   if (nSystems) {
01381     // Make a map of graphics systems names (there may be repeated systems)
01382     // and for each name a set of nicknames.  The nicknames are ordered
01383     // by length - see struct NicknameComparison above.
01384     std::map<G4String,std::set<G4String,NicknameComparison> > systemMap;
01385     for (G4int i = 0; i < nSystems; i++) {
01386       const G4VGraphicsSystem* pSystem = fAvailableGraphicsSystems[i];
01387       systemMap[pSystem->GetName()].insert(pSystem->GetNickname());
01388     }
01389     // Print the map.
01390     std::map<G4String,std::set<G4String,NicknameComparison> >::const_iterator i;
01391     for (i = systemMap.begin(); i != systemMap.end(); ++i) {
01392       G4cout << "\n  " << i->first << " (";
01393       const std::set<G4String,NicknameComparison>& nicknames = i->second;
01394       std::set<G4String,NicknameComparison>::const_iterator j;
01395       for (j = nicknames.begin(); j != nicknames.end(); ++j) {
01396         if (j != nicknames.begin()) G4cout << ", ";
01397         G4cout << *j;
01398       }
01399       G4cout << ')';
01400     }
01401   }
01402   else {
01403     G4cout << "\n  NONE!!!  None registered - yet!  Mmmmm!";
01404   }
01405   G4cout << G4endl;
01406 }

void G4VisManager::RegisterEndOfEventUserVisAction	(	const G4String &	name,
		G4VUserVisAction *	,
		const G4VisExtent &	= `G4VisExtent::NullExtent`
	)

Definition at line 1212 of file G4VisManager.cc.

References G4cout, G4endl, and G4VisExtent::GetExtentRadius().

01214                             {
01215   fEndOfEventUserVisActions.push_back(UserVisAction(name,pVisAction));
01216   if (extent.GetExtentRadius() > 0.) {
01217     fUserVisActionExtents[pVisAction] = extent;
01218   } else {
01219     if (fVerbosity >= warnings) {
01220       G4cout << 
01221         "WARNING: No extent set for user vis action \"" << name << "\"."
01222              << G4endl;
01223     }
01224   }
01225 }

void G4VisManager::RegisterEndOfRunUserVisAction	(	const G4String &	name,
		G4VUserVisAction *	,
		const G4VisExtent &	= `G4VisExtent::NullExtent`
	)

Definition at line 1228 of file G4VisManager.cc.

References G4cout, G4endl, and G4VisExtent::GetExtentRadius().

01230                             {
01231   fEndOfRunUserVisActions.push_back(UserVisAction(name,pVisAction));
01232   fUserVisActionExtents[pVisAction] = extent;
01233   if (extent.GetExtentRadius() <= 0.) {
01234     if (fVerbosity >= warnings) {
01235       G4cout << 
01236         "WARNING: No extent set for user vis action \"" << name << "\"."
01237              << G4endl;
01238     }
01239   }
01240 }

G4bool G4VisManager::RegisterGraphicsSystem ( G4VGraphicsSystem * )

Definition at line 552 of file G4VisManager.cc.

References confirmations, errors, G4cout, and G4endl.

00552                                                                        {
00553   G4bool happy = true;
00554   if (pSystem) {
00555     fAvailableGraphicsSystems.push_back (pSystem);
00556     if (fVerbosity >= confirmations) {
00557       G4cout << "G4VisManager::RegisterGraphicsSystem: "
00558              << pSystem -> GetName ();
00559       if (pSystem -> GetNickname () != "") {
00560         G4cout << " (" << pSystem -> GetNickname () << ")";
00561       }
00562       G4cout << " registered." << G4endl;
00563     }
00564   }
00565   else {
00566     if (fVerbosity >= errors) {
00567       G4cout << "G4VisManager::RegisterGraphicsSystem: null pointer!"
00568              << G4endl;
00569     }
00570     happy=false;
00571   }
00572   return happy;
00573 }

virtual void G4VisManager::RegisterGraphicsSystems ( ) [protected, pure virtual]

Referenced by Initialise().

void G4VisManager::RegisterMessenger ( G4UImessenger * messenger ) [inline]

Definition at line 124 of file G4VisManager.icc.

Referenced by G4VisManager(), RegisterMessengers(), and G4VisCommandModelCreate< Factory >::SetNewValue().

00125 {
00126   fMessengerList.push_back(msgr);
00127 }

void G4VisManager::RegisterMessengers ( ) [protected]

Definition at line 339 of file G4VisManager.cc.

References G4VisFilterManager< T >::Placement(), G4VisModelManager< Model >::Placement(), and RegisterMessenger().

Referenced by Initialise().

00339                                        {
00340   
00341   // Instantiate individual messengers/commands (often - but not
00342   // always - one command per messenger).
00343   
00344   G4UIcommand* directory;
00345   
00346   // *Basic* top level commands were instantiated in the constructor
00347   // so that they can be used immediately after instantiation of the
00348   // vis manager.  Other top level and lower level commands are
00349   // instantiated here.
00350   
00351   // Other top level commands...
00352   RegisterMessenger(new G4VisCommandAbortReviewKeptEvents);
00353   RegisterMessenger(new G4VisCommandEnable);
00354   RegisterMessenger(new G4VisCommandList);
00355   RegisterMessenger(new G4VisCommandReviewKeptEvents);
00356   
00357   // Compound commands...
00358   RegisterMessenger(new G4VisCommandDrawTree);
00359   RegisterMessenger(new G4VisCommandDrawView);
00360   RegisterMessenger(new G4VisCommandDrawVolume);
00361   RegisterMessenger(new G4VisCommandOpen);
00362   RegisterMessenger(new G4VisCommandSpecify);
00363   
00364   directory = new G4UIdirectory ("/vis/geometry/");
00365   directory -> SetGuidance("Operations on vis attributes of Geant4 geometry.");
00366   fDirectoryList.push_back (directory);
00367   RegisterMessenger(new G4VisCommandGeometryList);
00368   RegisterMessenger(new G4VisCommandGeometryRestore);
00369   
00370   directory = new G4UIdirectory ("/vis/geometry/set/");
00371   directory -> SetGuidance("Set vis attributes of Geant4 geometry.");
00372   fDirectoryList.push_back (directory);
00373   RegisterMessenger(new G4VisCommandGeometrySetColour);
00374   RegisterMessenger(new G4VisCommandGeometrySetDaughtersInvisible);
00375   RegisterMessenger(new G4VisCommandGeometrySetLineStyle);
00376   RegisterMessenger(new G4VisCommandGeometrySetLineWidth);
00377   RegisterMessenger(new G4VisCommandGeometrySetForceAuxEdgeVisible);
00378   RegisterMessenger(new G4VisCommandGeometrySetForceLineSegmentsPerCircle);
00379   RegisterMessenger(new G4VisCommandGeometrySetForceSolid);
00380   RegisterMessenger(new G4VisCommandGeometrySetForceWireframe);
00381   RegisterMessenger(new G4VisCommandGeometrySetVisibility);
00382   
00383   directory = new G4UIdirectory ("/vis/set/");
00384   directory -> SetGuidance
00385     ("Set quantities for use in future commands where appropriate.");
00386   fDirectoryList.push_back (directory);
00387   RegisterMessenger(new G4VisCommandSetColour);
00388   RegisterMessenger(new G4VisCommandSetLineWidth);
00389   RegisterMessenger(new G4VisCommandSetTextColour);
00390   RegisterMessenger(new G4VisCommandSetTextLayout);
00391   RegisterMessenger(new G4VisCommandSetTouchable);
00392   
00393   directory = new G4UIdirectory ("/vis/scene/");
00394   directory -> SetGuidance ("Operations on Geant4 scenes.");
00395   fDirectoryList.push_back (directory);
00396   RegisterMessenger(new G4VisCommandSceneActivateModel);
00397   RegisterMessenger(new G4VisCommandSceneCreate);
00398   RegisterMessenger(new G4VisCommandSceneEndOfEventAction);
00399   RegisterMessenger(new G4VisCommandSceneEndOfRunAction);
00400   RegisterMessenger(new G4VisCommandSceneList);
00401   RegisterMessenger(new G4VisCommandSceneNotifyHandlers);
00402   RegisterMessenger(new G4VisCommandSceneSelect);
00403   
00404   directory = new G4UIdirectory ("/vis/scene/add/");
00405   directory -> SetGuidance ("Add model to current scene.");
00406   fDirectoryList.push_back (directory);
00407   RegisterMessenger(new G4VisCommandSceneAddArrow);
00408   RegisterMessenger(new G4VisCommandSceneAddArrow2D);
00409   RegisterMessenger(new G4VisCommandSceneAddAxes);
00410   RegisterMessenger(new G4VisCommandSceneAddDate);
00411   RegisterMessenger(new G4VisCommandSceneAddDigis);
00412   RegisterMessenger(new G4VisCommandSceneAddEventID);
00413   RegisterMessenger(new G4VisCommandSceneAddFrame);
00414   RegisterMessenger(new G4VisCommandSceneAddGhosts);
00415   RegisterMessenger(new G4VisCommandSceneAddHits);
00416   RegisterMessenger(new G4VisCommandSceneAddLine);
00417   RegisterMessenger(new G4VisCommandSceneAddLine2D);
00418   RegisterMessenger(new G4VisCommandSceneAddLogicalVolume);
00419   RegisterMessenger(new G4VisCommandSceneAddLogo);
00420   RegisterMessenger(new G4VisCommandSceneAddLogo2D);
00421   RegisterMessenger(new G4VisCommandSceneAddPSHits);
00422   RegisterMessenger(new G4VisCommandSceneAddScale);
00423   RegisterMessenger(new G4VisCommandSceneAddText);
00424   RegisterMessenger(new G4VisCommandSceneAddText2D);
00425   RegisterMessenger(new G4VisCommandSceneAddTrajectories);
00426   RegisterMessenger(new G4VisCommandSceneAddUserAction);
00427   RegisterMessenger(new G4VisCommandSceneAddVolume);
00428   
00429   directory = new G4UIdirectory ("/vis/sceneHandler/");
00430   directory -> SetGuidance ("Operations on Geant4 scene handlers.");
00431   fDirectoryList.push_back (directory);
00432   RegisterMessenger(new G4VisCommandSceneHandlerAttach);
00433   RegisterMessenger(new G4VisCommandSceneHandlerCreate);
00434   RegisterMessenger(new G4VisCommandSceneHandlerList);
00435   RegisterMessenger(new G4VisCommandSceneHandlerSelect);
00436   
00437   directory = new G4UIdirectory ("/vis/touchable/");
00438   directory -> SetGuidance ("Operations on touchables.");
00439   directory = new G4UIdirectory ("/vis/touchable/set/");
00440   directory -> SetGuidance ("Set vis attributes of current touchable.");
00441   fDirectoryList.push_back (directory);
00442   RegisterMessenger(new G4VisCommandsTouchableSet);
00443 
00444   directory = new G4UIdirectory ("/vis/viewer/");
00445   directory -> SetGuidance ("Operations on Geant4 viewers.");
00446   fDirectoryList.push_back (directory);
00447   RegisterMessenger(new G4VisCommandViewerAddCutawayPlane);
00448   RegisterMessenger(new G4VisCommandViewerChangeCutawayPlane);
00449   RegisterMessenger(new G4VisCommandViewerClear);
00450   RegisterMessenger(new G4VisCommandViewerClearCutawayPlanes);
00451   RegisterMessenger(new G4VisCommandViewerClearTransients);
00452   RegisterMessenger(new G4VisCommandViewerClone);
00453   RegisterMessenger(new G4VisCommandViewerCopyViewFrom);
00454   RegisterMessenger(new G4VisCommandViewerCreate);
00455   RegisterMessenger(new G4VisCommandViewerDolly);
00456   RegisterMessenger(new G4VisCommandViewerFlush);
00457   RegisterMessenger(new G4VisCommandViewerList);
00458   RegisterMessenger(new G4VisCommandViewerPan);
00459   RegisterMessenger(new G4VisCommandViewerRebuild);
00460   RegisterMessenger(new G4VisCommandViewerRefresh);
00461   RegisterMessenger(new G4VisCommandViewerReset);
00462   RegisterMessenger(new G4VisCommandViewerSave);
00463   RegisterMessenger(new G4VisCommandViewerScale);
00464   RegisterMessenger(new G4VisCommandViewerSelect);
00465   RegisterMessenger(new G4VisCommandViewerUpdate);
00466   RegisterMessenger(new G4VisCommandViewerZoom);
00467   
00468   directory = new G4UIdirectory ("/vis/viewer/default/");
00469   directory -> SetGuidance("Set default values for future viewers.");
00470   fDirectoryList.push_back (directory);
00471   RegisterMessenger(new G4VisCommandViewerDefaultHiddenEdge);
00472   RegisterMessenger(new G4VisCommandViewerDefaultStyle);
00473   
00474   directory = new G4UIdirectory ("/vis/viewer/set/");
00475   directory -> SetGuidance ("Set view parameters of current viewer.");
00476   fDirectoryList.push_back (directory);
00477   RegisterMessenger(new G4VisCommandsViewerSet);
00478   
00479   // List manager commands
00480   RegisterMessenger(new G4VisCommandListManagerList< G4VisModelManager<G4VTrajectoryModel> >
00481                     (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
00482   RegisterMessenger(new G4VisCommandListManagerSelect< G4VisModelManager<G4VTrajectoryModel> >
00483                     (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
00484   
00485   // Trajectory filter manager commands
00486   RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VTrajectory> >
00487                     (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
00488   RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VTrajectory> >
00489                     (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
00490   
00491   // Hit filter manager commands
00492   RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VHit> >
00493                     (fpHitFilterMgr, fpHitFilterMgr->Placement()));
00494   RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VHit> >
00495                     (fpHitFilterMgr, fpHitFilterMgr->Placement()));
00496   
00497   // Digi filter manager commands
00498   RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VDigi> >
00499                     (fpDigiFilterMgr, fpDigiFilterMgr->Placement()));
00500   RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VDigi> >
00501                     (fpDigiFilterMgr, fpDigiFilterMgr->Placement()));
00502 }

void G4VisManager::RegisterModel ( G4VFilter< G4VDigi > * filter )

Definition at line 632 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

00633 {
00634   fpDigiFilterMgr->Register(model);
00635 }

void G4VisManager::RegisterModel ( G4VFilter< G4VHit > * filter )

Definition at line 621 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

00622 {
00623   fpHitFilterMgr->Register(model);
00624 }

void G4VisManager::RegisterModel ( G4VFilter< G4VTrajectory > * filter )

Definition at line 610 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

00611 {
00612   fpTrajFilterMgr->Register(model);
00613 }

void G4VisManager::RegisterModel ( G4VTrajectoryModel * model )

Definition at line 599 of file G4VisManager.cc.

References G4VisModelManager< Model >::Register().

Referenced by G4VisCommandModelCreate< Factory >::SetNewValue().

00600 {
00601   fpTrajDrawModelMgr->Register(model);
00602 }

void G4VisManager::RegisterModelFactories ( ) [protected, virtual]

Definition at line 1939 of file G4VisManager.cc.

References G4cout, and warnings.

Referenced by Initialise().

01940 {
01941   if (fVerbosity >= warnings) {
01942     G4cout<<"G4VisManager: No model factories registered with G4VisManager."<<G4endl;
01943     G4cout<<"G4VisManager::RegisterModelFactories() should be overridden in derived"<<G4endl;
01944     G4cout<<"class. See G4VisExecutive for an example."<<G4endl;
01945   }
01946 }

void G4VisManager::RegisterModelFactory ( G4DigiFilterFactory * factory )

Definition at line 638 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

00639 {
00640   fpDigiFilterMgr->Register(factory);
00641 }

void G4VisManager::RegisterModelFactory ( G4HitFilterFactory * factory )

Definition at line 627 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

00628 {
00629   fpHitFilterMgr->Register(factory);
00630 }

void G4VisManager::RegisterModelFactory ( G4TrajFilterFactory * factory )

Definition at line 616 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

00617 {
00618   fpTrajFilterMgr->Register(factory);
00619 }

void G4VisManager::RegisterModelFactory ( G4TrajDrawModelFactory * factory )

Definition at line 605 of file G4VisManager.cc.

References G4VisModelManager< Model >::Register().

00606 {
00607   fpTrajDrawModelMgr->Register(factory);
00608 }

void G4VisManager::RegisterRunDurationUserVisAction	(	const G4String &	name,
		G4VUserVisAction *	,
		const G4VisExtent &	= `G4VisExtent::NullExtent`
	)

Definition at line 1196 of file G4VisManager.cc.

References G4cout, G4endl, and G4VisExtent::GetExtentRadius().

01198                             {
01199   fRunDurationUserVisActions.push_back(UserVisAction(name,pVisAction));
01200   if (extent.GetExtentRadius() > 0.) {
01201     fUserVisActionExtents[pVisAction] = extent;
01202   } else {
01203     if (fVerbosity >= warnings) {
01204       G4cout << 
01205         "WARNING: No extent set for user vis action \"" << name << "\"."
01206              << G4endl;
01207     }
01208   }
01209 }

void G4VisManager::ResetTransientsDrawnFlags ( )

Definition at line 1720 of file G4VisManager.cc.

Referenced by SetCurrentScene(), G4VisCommandViewerClearTransients::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), and G4VisCommandSceneEndOfEventAction::SetNewValue().

01721 {
01722   fTransientsDrawnThisRun = false;
01723   fTransientsDrawnThisEvent = false;
01724   G4SceneHandlerListConstIterator i;
01725   for (i = fAvailableSceneHandlers.begin();
01726        i != fAvailableSceneHandlers.end(); ++i) {
01727     (*i)->SetTransientsDrawnThisEvent(false);
01728     (*i)->SetTransientsDrawnThisRun(false);
01729   }
01730 }

void G4VisManager::SelectTrajectoryModel ( const G4String & model )

Definition at line 643 of file G4VisManager.cc.

References G4VisModelManager< Model >::SetCurrent().

00644 {
00645    fpTrajDrawModelMgr->SetCurrent(model);
00646 }

void G4VisManager::SetAbortReviewKeptEvents ( G4bool ) [inline]

Definition at line 133 of file G4VisManager.icc.

Referenced by G4VisCommandReviewKeptEvents::SetNewValue(), and G4VisCommandAbortReviewKeptEvents::SetNewValue().

00133                                                                 {
00134   fAbortReviewKeptEvents = abort;
00135 }

G4SceneHandlerList & G4VisManager::SetAvailableSceneHandlers ( ) [inline]

Definition at line 112 of file G4VisManager.icc.

00112                                                                     {
00113   return fAvailableSceneHandlers;
00114 }

void G4VisManager::SetCurrentGraphicsSystem ( G4VGraphicsSystem * )

Definition at line 1251 of file G4VisManager.cc.

References confirmations, G4cout, and G4endl.

Referenced by G4VisCommandDrawTree::SetNewValue().

01251                                                                        {
01252   fpGraphicsSystem = pSystem;
01253   if (fVerbosity >= confirmations) {
01254     G4cout << "G4VisManager::SetCurrentGraphicsSystem: system now "
01255            << pSystem -> GetName () << G4endl;
01256   }
01257   // If current scene handler is of same graphics system, leave unchanged.
01258   // Else find the most recent scene handler of same graphics system.
01259   // Or clear pointers.
01260   if (!(fpSceneHandler && fpSceneHandler -> GetGraphicsSystem () == pSystem)) {
01261     const G4SceneHandlerList& sceneHandlerList = fAvailableSceneHandlers;
01262     G4int nSH = sceneHandlerList.size ();  // No. of scene handlers.
01263     G4int iSH;
01264     for (iSH = nSH - 1; iSH >= 0; iSH--) {
01265       if (sceneHandlerList [iSH] -> GetGraphicsSystem () == pSystem) break;
01266     }
01267     if (iSH >= 0) {
01268       fpSceneHandler = sceneHandlerList [iSH];
01269       if (fVerbosity >= confirmations) {
01270         G4cout << "  Scene Handler now "
01271                << fpSceneHandler -> GetName () << G4endl;
01272       }
01273       if (fpScene != fpSceneHandler -> GetScene ()) {
01274         fpScene = fpSceneHandler -> GetScene ();
01275         if (fVerbosity >= confirmations) {
01276           G4cout << "  Scene now \""
01277                  << fpScene -> GetName () << "\"" << G4endl;
01278         }
01279       }
01280       const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
01281       if (viewerList.size ()) {
01282         fpViewer = viewerList [0];
01283         if (fVerbosity >= confirmations) {
01284           G4cout << "  Viewer now " << fpViewer -> GetName () << G4endl;
01285         }
01286       }
01287       else {
01288         fpViewer = 0;
01289       }
01290     }
01291     else {
01292       fpSceneHandler = 0;
01293       fpViewer = 0;
01294     }
01295   }
01296 }

void G4VisManager::SetCurrentScene ( G4Scene * )

Definition at line 1242 of file G4VisManager.cc.

References ResetTransientsDrawnFlags().

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler(), and G4VisCommandDrawTree::SetNewValue().

01242                                                    {
01243   if (pScene != fpScene) {
01244     // A change of scene.  Therefore reset transients drawn flags.  All
01245     // memory of previous transient proceessing thereby erased...
01246     ResetTransientsDrawnFlags();
01247   }
01248   fpScene = pScene;
01249 }

void G4VisManager::SetCurrentSceneHandler ( G4VSceneHandler * )

Definition at line 1298 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, and warnings.

Referenced by G4VisCommandDrawTree::SetNewValue().

01298                                                                          {
01299   fpSceneHandler = pSceneHandler;
01300   if (fVerbosity >= confirmations) {
01301     G4cout << "G4VisManager::SetCurrentSceneHandler: scene handler now \""
01302            << pSceneHandler -> GetName () << "\"" << G4endl;
01303   }
01304   if (fpScene != fpSceneHandler -> GetScene ()) {
01305     fpScene = fpSceneHandler -> GetScene ();
01306     if (fVerbosity >= confirmations) {
01307       G4cout << "  Scene now \""
01308              << fpScene -> GetName () << "\"" << G4endl;
01309     }
01310   }
01311   if (fpGraphicsSystem != pSceneHandler -> GetGraphicsSystem ()) {
01312     fpGraphicsSystem = pSceneHandler -> GetGraphicsSystem ();
01313     if (fVerbosity >= confirmations) {
01314       G4cout << "  Graphics system now \""
01315              << fpGraphicsSystem -> GetName () << "\"" << G4endl;
01316     }
01317   }
01318   const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
01319   G4int nViewers = viewerList.size ();
01320   if (nViewers) {
01321     G4int iViewer;
01322     for (iViewer = 0; iViewer < nViewers; iViewer++) {
01323       if (fpViewer == viewerList [iViewer]) break;
01324     }
01325     if (iViewer >= nViewers) {
01326       fpViewer = viewerList [0];
01327       if (fVerbosity >= confirmations) {
01328         G4cout << "  Viewer now \"" << fpViewer -> GetName () << "\""
01329                << G4endl;
01330       }
01331     }
01332     if (!IsValidView ()) {
01333       if (fVerbosity >= warnings) {
01334         G4cout <<
01335   "WARNING: Problem setting scene handler - please report circumstances."
01336                << G4endl;
01337       }
01338     }
01339   }
01340   else {
01341     fpViewer = 0;
01342     if (fVerbosity >= warnings) {
01343       G4cout <<
01344         "WARNING: No viewers for this scene handler - please create one."
01345              << G4endl;
01346     }
01347   }
01348 }

void G4VisManager::SetCurrentViewer ( G4VViewer * )

Definition at line 1350 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, and warnings.

Referenced by CreateViewer(), and G4VisCommandDrawTree::SetNewValue().

01350                                                        {
01351   fpViewer  = pViewer;
01352   if (fVerbosity >= confirmations) {
01353     G4cout << "G4VisManager::SetCurrentViewer: viewer now "
01354            << pViewer -> GetName ()
01355            << G4endl;
01356   }
01357   fpSceneHandler = fpViewer -> GetSceneHandler ();
01358   fpSceneHandler -> SetCurrentViewer (pViewer);
01359   fpScene = fpSceneHandler -> GetScene ();
01360   fpGraphicsSystem = fpSceneHandler -> GetGraphicsSystem ();
01361   if (!IsValidView ()) {
01362     if (fVerbosity >= warnings) {
01363       G4cout <<
01364         "WARNING: Problem setting viewer - please report circumstances."
01365              << G4endl;
01366     }
01367   }
01368 }

void G4VisManager::SetDefaultViewParameters ( const G4ViewParameters & ) [inline]

Definition at line 138 of file G4VisManager.icc.

Referenced by G4VisCommandViewerDefaultStyle::SetNewValue(), and G4VisCommandViewerDefaultHiddenEdge::SetNewValue().

00138                              {
00139   fDefaultViewParameters = vp;
00140 }

void G4VisManager::SetEventRefreshing ( G4bool ) [inline]

Definition at line 120 of file G4VisManager.icc.

Referenced by G4VSceneHandler::ProcessScene().

00120                                                                     {
00121   fEventRefreshing = eventRefreshing;
00122 }

void G4VisManager::SetRequestedEvent ( const G4Event * ) [inline]

Definition at line 129 of file G4VisManager.icc.

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

00129                                                                  {
00130   fpRequestedEvent = event;
00131 }

G4SceneList & G4VisManager::SetSceneList ( ) [inline]

Definition at line 108 of file G4VisManager.icc.

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler().

00108                                                 {
00109   return fSceneList;
00110 }

void G4VisManager::SetUserAction	(	G4VUserVisAction *	pVisAction,
		const G4VisExtent &	= `G4VisExtent::NullExtent`
	)			`[inline]`

Definition at line 103 of file G4VisManager.icc.

00104                             {
00105   RegisterRunDurationUserVisAction("SetUserAction",pVisAction,extent);
00106 }

void G4VisManager::SetUserActionExtent ( const G4VisExtent & )

void G4VisManager::SetVerboseLevel ( Verbosity ) [inline]

Definition at line 116 of file G4VisManager.icc.

00116                                                                           {
00117   fVerbosity = verbosity;
00118 }

void G4VisManager::SetVerboseLevel ( const G4String & )

Definition at line 1824 of file G4VisManager.cc.

References GetVerbosityValue().

01824                                                                    {
01825   fVerbosity = GetVerbosityValue(verbosityString);
01826 }

void G4VisManager::SetVerboseLevel ( G4int )

Definition at line 1820 of file G4VisManager.cc.

References GetVerbosityValue().

Referenced by G4VisCommandVerbose::SetNewValue().

01820                                                       {
01821   fVerbosity = GetVerbosityValue(intVerbosity);
01822 }

G4String G4VisManager::VerbosityString ( Verbosity ) [static]

Definition at line 1762 of file G4VisManager.cc.

References all, confirmations, errors, parameters, quiet, startup, and warnings.

Referenced by G4VisManager(), GetVerbosityValue(), and G4VisCommandVerbose::SetNewValue().

01762                                                           {
01763   G4String rs;
01764   switch (verbosity) {
01765   case         quiet: rs = "quiet (0)"; break;
01766   case       startup: rs = "startup (1)"; break;
01767   case        errors: rs = "errors (2)"; break;
01768   case      warnings: rs = "warnings (3)"; break;
01769   case confirmations: rs = "confirmations (4)"; break;
01770   case    parameters: rs = "parameters (5)"; break;
01771   case           all: rs = "all (6)"; break;
01772   }
01773   return rs;
01774 }

G4String G4VisManager::ViewerShortName ( const G4String & viewerName ) const

Definition at line 1732 of file G4VisManager.cc.

References G4String::strip().

Referenced by GetViewer().

01732                                                                         {
01733   G4String viewerShortName (viewerName);
01734   viewerShortName = viewerShortName (0, viewerShortName.find (' '));
01735   return viewerShortName.strip ();
01736 }

friend class G4HepRepFileSceneHandler [friend]

Definition at line 133 of file G4VisManager.hh.

friend class G4OpenGLViewerMessenger [friend]

Definition at line 131 of file G4VisManager.hh.

friend class G4OpenGLXmViewerMessenger [friend]

Definition at line 132 of file G4VisManager.hh.

friend class G4RayTracerSceneHandler [friend]

Definition at line 129 of file G4VisManager.hh.

friend class G4RayTrajectory [friend]

Definition at line 128 of file G4VisManager.hh.

friend class G4RTMessenger [friend]

Definition at line 130 of file G4VisManager.hh.

friend class G4RTSteppingAction [friend]

Definition at line 127 of file G4VisManager.hh.

friend class G4VisCommandList [friend]

Definition at line 139 of file G4VisManager.hh.

friend class G4VisStateDependent [friend]

Definition at line 138 of file G4VisManager.hh.

Referenced by G4VisManager().

friend class G4VSceneHandler [friend]

Definition at line 136 of file G4VisManager.hh.

friend class G4VViewer [friend]

Definition at line 137 of file G4VisManager.hh.

std::ostream& operator<<	(	std::ostream &	os,
		const G4VSceneHandler &	sh
	)			`[friend]`

Definition at line 963 of file G4VSceneHandler.cc.

00963                                                                     {
00964 
00965   os << "Scene handler " << sh.fName << " has "
00966      << sh.fViewerList.size () << " viewer(s):";
00967   for (size_t i = 0; i < sh.fViewerList.size (); i++) {
00968     os << "\n  " << *(sh.fViewerList [i]);
00969   }
00970 
00971   if (sh.fpScene) {
00972     os << "\n  " << *sh.fpScene;
00973   }
00974   else {
00975     os << "\n  This scene handler currently has no scene.";
00976   }
00977 
00978   return os;
00979 }

std::ostream& operator<<	(	std::ostream &	os,
		const G4VGraphicsSystem &	gs
	)			`[friend]`

Definition at line 68 of file G4VGraphicsSystem.cc.

00068                                                                       {
00069   G4VisManager* pVMan = G4VisManager::GetInstance ();
00070   const G4SceneHandlerList& scenes = pVMan -> GetAvailableSceneHandlers ();
00071   os << "Graphics System: " << gs.GetName ();
00072   if (gs.GetNickname () != "") {
00073     os << ", nickname: " << gs.GetNickname ();
00074   }
00075   if (gs.GetDescription () != "") {
00076     os << "\n  Description: " << gs.GetDescription ();
00077   }
00078   os << "\n  Functionality: " << G4int(gs.GetFunctionality());
00079   if (pVMan -> GetVerbosity() >= G4VisManager::parameters) {
00080     size_t nScenes = scenes.size ();
00081     if (nScenes) {
00082       G4int nScenesOfThisSystem = 0;
00083       for (size_t i = 0; i < nScenes; i++) {
00084         if (scenes [i] -> GetGraphicsSystem () == &gs) {
00085           nScenesOfThisSystem++;
00086         }
00087       }
00088       if (nScenesOfThisSystem) {
00089         os << "\n  Its scenes are: ";
00090         for (size_t i = 0; i < nScenes; i++) {
00091           if (scenes [i] -> GetGraphicsSystem () == &gs) {
00092             os << "\n  " << *(scenes [i]);
00093           }
00094         }
00095       }
00096       else {
00097         os << "\n  It has no scenes at present.";
00098       }
00099     }
00100     else {
00101       os << "\n  There are no scenes instantiated at present.";
00102     }
00103   }
00104   return os;
00105 }

const G4int G4VisManager::fVerbose [protected]

Definition at line 461 of file G4VisManager.hh.

std::vector< G4String > G4VisManager::VerbosityGuidanceStrings [static]

Definition at line 447 of file G4VisManager.hh.

Referenced by G4VisCommandVerbose::G4VisCommandVerbose(), G4VisManager(), and GetVerbosityValue().

G4VisManager Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Data Structures

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation


Public Types
	quiet
	startup
	errors
	warnings
	confirmations
	parameters
	all
enum	Verbosity { quiet, startup, errors, warnings, confirmations, parameters, all }
Public Member Functions
virtual	~G4VisManager ()
void	Initialise ()
void	Initialize ()
void	RegisterRunDurationUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent::NullExtent)
void	RegisterEndOfEventUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent::NullExtent)
void	RegisterEndOfRunUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent::NullExtent)
G4bool	RegisterGraphicsSystem (G4VGraphicsSystem *)
void	RegisterModelFactory (G4TrajDrawModelFactory *factory)
void	RegisterModel (G4VTrajectoryModel *model)
void	RegisterModelFactory (G4TrajFilterFactory *factory)
void	RegisterModel (G4VFilter< G4VTrajectory > *filter)
void	RegisterModelFactory (G4HitFilterFactory *factory)
void	RegisterModel (G4VFilter< G4VHit > *filter)
void	RegisterModelFactory (G4DigiFilterFactory *factory)
void	RegisterModel (G4VFilter< G4VDigi > *filter)
void	SelectTrajectoryModel (const G4String &model)
void	RegisterMessenger (G4UImessenger *messenger)
void	Draw (const G4Circle &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4NURBS &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Polyhedron &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Polyline &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Polymarker &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Scale &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Square &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Text &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Circle &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4NURBS &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Polyhedron &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Polyline &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Polymarker &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Square &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Text &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4VHit &)
void	Draw (const G4VDigi &)
void	Draw (const G4VTrajectory &, G4int i_mode)
void	Draw (const G4LogicalVolume &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4VPhysicalVolume &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4VSolid &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())
void	BeginDraw (const G4Transform3D &objectTransformation=G4Transform3D())
void	EndDraw ()
void	BeginDraw2D (const G4Transform3D &objectTransformation=G4Transform3D())
void	EndDraw2D ()
void	GeometryHasChanged ()
void	NotifyHandlers ()
void	DispatchToModel (const G4VTrajectory &)
void	DispatchToModel (const G4VTrajectory &, G4int i_mode)
G4bool	FilterTrajectory (const G4VTrajectory &)
G4bool	FilterHit (const G4VHit &)
G4bool	FilterDigi (const G4VDigi &)
void	CreateSceneHandler (G4String name="")
void	CreateViewer (G4String name="", G4String XGeometry="")
void	Enable ()
void	Disable ()
const G4VTrajectoryModel *	CurrentTrajDrawModel () const
const std::vector< UserVisAction > &	GetRunDurationUserVisActions () const
const std::vector< UserVisAction > &	GetEndOfEventUserVisActions () const
const std::vector< UserVisAction > &	GetEndOfRunUserVisActions () const
const std::map< G4VUserVisAction *, G4VisExtent > &	GetUserVisActionExtents () const
G4VGraphicsSystem *	GetCurrentGraphicsSystem () const
G4Scene *	GetCurrentScene () const
G4VSceneHandler *	GetCurrentSceneHandler () const
G4VViewer *	GetCurrentViewer () const
const G4GraphicsSystemList &	GetAvailableGraphicsSystems ()
const G4SceneHandlerList &	GetAvailableSceneHandlers () const
const G4SceneList &	GetSceneList () const
G4bool	GetTransientsDrawnThisRun () const
G4bool	GetTransientsDrawnThisEvent () const
const G4Event *	GetRequestedEvent () const
G4bool	GetAbortReviewKeptEvents () const
const G4ViewParameters &	GetDefaultViewParameters () const
void	SetUserAction (G4VUserVisAction *pVisAction, const G4VisExtent &=G4VisExtent::NullExtent)
void	SetUserActionExtent (const G4VisExtent &)
void	SetCurrentGraphicsSystem (G4VGraphicsSystem *)
void	SetCurrentScene (G4Scene *)
void	SetCurrentSceneHandler (G4VSceneHandler *)
void	SetCurrentViewer (G4VViewer *)
G4SceneHandlerList &	SetAvailableSceneHandlers ()
G4SceneList &	SetSceneList ()
void	SetVerboseLevel (G4int)
void	SetVerboseLevel (const G4String &)
void	SetVerboseLevel (Verbosity)
void	SetEventRefreshing (G4bool)
void	ResetTransientsDrawnFlags ()
void	SetRequestedEvent (const G4Event *)
void	SetAbortReviewKeptEvents (G4bool)
void	SetDefaultViewParameters (const G4ViewParameters &)
G4String	ViewerShortName (const G4String &viewerName) const
G4VViewer *	GetViewer (const G4String &viewerName) const
Static Public Member Functions
static Verbosity	GetVerbosity ()
static Verbosity	GetVerbosityValue (const G4String &)
static Verbosity	GetVerbosityValue (G4int)
static G4String	VerbosityString (Verbosity)
Static Public Attributes
static std::vector< G4String >	VerbosityGuidanceStrings
Protected Member Functions
	G4VisManager (const G4String &verbosityString="warnings")
virtual void	RegisterGraphicsSystems ()=0
virtual void	RegisterModelFactories ()
void	RegisterMessengers ()
void	PrintAvailableGraphicsSystems () const
Protected Attributes
const G4int	fVerbose
Friends
class	G4RTSteppingAction
class	G4RayTrajectory
class	G4RayTracerSceneHandler
class	G4RTMessenger
class	G4OpenGLViewerMessenger
class	G4OpenGLXmViewerMessenger
class	G4HepRepFileSceneHandler
class	G4VSceneHandler
class	G4VViewer
class	G4VisStateDependent
class	G4VisCommandList
std::ostream &	operator<< (std::ostream &, const G4VGraphicsSystem &)
std::ostream &	operator<< (std::ostream &, const G4VSceneHandler &)
Data Structures
struct	UserVisAction