#include <G4XXXStoredSceneHandler.hh>

Inheritance diagram for G4XXXStoredSceneHandler:

Public Member Functions
	G4XXXStoredSceneHandler (G4VGraphicsSystem &system, const G4String &name)

virtual	~G4XXXStoredSceneHandler ()

void	AddSolid (const G4Box &)

void	AddSolid (const G4Cons &cons)

void	AddSolid (const G4Tubs &tubs)

void	AddSolid (const G4Trd &trd)

void	AddSolid (const G4Trap &trap)

void	AddSolid (const G4Sphere &sphere)

void	AddSolid (const G4Para &para)

void	AddSolid (const G4Torus &torus)

void	AddSolid (const G4Polycone &polycone)

void	AddSolid (const G4Polyhedra &polyhedra)

void	AddSolid (const G4VSolid &solid)

void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)

void	PostAddSolid ()

void	AddPrimitive (const G4Polyline &)

void	AddPrimitive (const G4Text &)

void	AddPrimitive (const G4Circle &)

void	AddPrimitive (const G4Square &)

void	AddPrimitive (const G4Polyhedron &)

void	AddPrimitive (const G4Polymarker &polymarker)

void	AddPrimitive (const G4Scale &scale)

void	BeginPrimitives (const G4Transform3D &objectTransformation)

void	EndPrimitives ()

void	ClearStore ()

void	ClearTransientStore ()

Public Member Functions inherited from G4VSceneHandler
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")

virtual	~G4VSceneHandler ()

virtual void	AddCompound (const G4VTrajectory &)

virtual void	AddCompound (const G4VHit &)

virtual void	AddCompound (const G4VDigi &)

virtual void	AddCompound (const G4THitsMap< G4double > &)

virtual void	BeginModeling ()

virtual void	EndModeling ()

virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation)

virtual void	EndPrimitives2D ()

virtual const G4VisExtent &	GetExtent () const

const G4String &	GetName () const

G4int	GetSceneHandlerId () const

G4int	GetViewCount () const

G4VGraphicsSystem *	GetGraphicsSystem () const

G4Scene *	GetScene () const

const G4ViewerList &	GetViewerList () const

G4VModel *	GetModel () const

G4VViewer *	GetCurrentViewer () const

G4bool	GetMarkForClearingTransientStore () const

G4bool	IsReadyForTransients () const

G4bool	GetTransientsDrawnThisEvent () const

G4bool	GetTransientsDrawnThisRun () const

const G4Transform3D &	GetObjectTransformation () const

void	SetName (const G4String &)

void	SetCurrentViewer (G4VViewer *)

virtual void	SetScene (G4Scene *)

G4ViewerList &	SetViewerList ()

void	SetModel (G4VModel *)

void	SetMarkForClearingTransientStore (G4bool)

void	SetTransientsDrawnThisEvent (G4bool)

void	SetTransientsDrawnThisRun (G4bool)

void	SetObjectTransformation (const G4Transform3D &)

const G4Colour &	GetColour (const G4Visible &)

const G4Colour &	GetColor (const G4Visible &)

const G4Colour &	GetTextColour (const G4Text &)

const G4Colour &	GetTextColor (const G4Text &)

G4double	GetLineWidth (const G4VisAttributes *)

G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)

G4bool	GetAuxEdgeVisible (const G4VisAttributes *)

G4int	GetNoOfSides (const G4VisAttributes *)

G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)

G4ModelingParameters *	CreateModelingParameters ()

void	DrawEvent (const G4Event *)

void	DrawEndOfRunModels ()

G4int	IncrementViewCount ()

void	AddViewerToList (G4VViewer *pView)

void	RemoveViewerFromList (G4VViewer *pView)

Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()

virtual	~G4VGraphicsScene ()

Protected Types
typedef std::list< G4String >	Store

typedef std::list< G4String > ::iterator	StoreIterator

Protected Attributes
Store	fStore

StoreIterator	fCurrentItem

std::vector< StoreIterator >	fPermanents

std::vector< StoreIterator >	fTransients

Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystem &	fSystem

const G4int	fSceneHandlerId

G4String	fName

G4int	fViewCount

G4ViewerList	fViewerList

G4VViewer *	fpViewer

G4Scene *	fpScene

G4bool	fMarkForClearingTransientStore

G4bool	fReadyForTransients

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

G4bool	fProcessingSolid

G4bool	fProcessing2D

G4VModel *	fpModel

G4Transform3D	fObjectTransformation

G4int	fNestingDepth

const G4VisAttributes *	fpVisAttribs

const G4Transform3D	fIdentityTransformation

Static Protected Attributes
static G4int	fSceneIdCount = 0

Friends
class	G4XXXStoredViewer

Additional Inherited Members
Public Types inherited from G4VSceneHandler
enum	MarkerSizeType { world, screen }

Protected Member Functions inherited from G4VSceneHandler
virtual void	ProcessScene ()

virtual void	RequestPrimitives (const G4VSolid &solid)

virtual G4VSolid *	CreateSectionSolid ()

virtual G4VSolid *	CreateCutawaySolid ()

void	LoadAtts (const G4Visible &, G4AttHolder *)

Detailed Description

Definition at line 41 of file G4XXXStoredSceneHandler.hh.

Member Typedef Documentation

typedef std::list<G4String> G4XXXStoredSceneHandler::Store

protected

Definition at line 122 of file G4XXXStoredSceneHandler.hh.

typedef std::list<G4String>::iterator G4XXXStoredSceneHandler::StoreIterator

protected

Definition at line 123 of file G4XXXStoredSceneHandler.hh.

Constructor & Destructor Documentation

G4XXXStoredSceneHandler::G4XXXStoredSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name
	)

Definition at line 57 of file G4XXXStoredSceneHandler.cc.

                                               :
   G4VSceneHandler(system, fSceneIdCount++, name)
 {}

G4XXXStoredSceneHandler::~G4XXXStoredSceneHandler ( )

virtual

Definition at line 62 of file G4XXXStoredSceneHandler.cc.

62 {}

Member Function Documentation

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Polyline & polyline )

virtual

Implements G4VSceneHandler.

Definition at line 218 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4cout, and G4endl.

                                                                      {
 #ifdef G4XXXStoredDEBUG
   G4cout <<
  "G4XXXStoredSceneHandler::AddPrimitive(const G4Polyline& polyline) called.\n"
      << polyline
      << G4endl;
 #endif
   // Get vis attributes - pick up defaults if none.
   //const G4VisAttributes* pVA =
   //  fpViewer -> GetApplicableVisAttributes (polyline.GetVisAttributes ());
   //?? Process polyline.
   std::ostringstream oss;
   oss << polyline;
   *fCurrentItem += oss.str();
 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Text & text )

virtual

Implements G4VSceneHandler.

Definition at line 234 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4cout, and G4endl.

                                                              {
 #ifdef G4XXXStoredDEBUG
   G4cout <<
     "G4XXXStoredSceneHandler::AddPrimitive(const G4Text& text) called.|n"
      << text
      << G4endl;
 #endif
   // Get text colour - special method since default text colour is
   // determined by the default text vis attributes, which may be
   // specified independent of default vis attributes of other types of
   // visible objects.
   //const G4Colour& c = GetTextColour (text);  // Picks up default if none.
   //?? Process text.
   std::ostringstream oss;
   oss << text;
   *fCurrentItem += oss.str();
 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Circle & circle )

virtual

Implements G4VSceneHandler.

Definition at line 252 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4cout, G4endl, G4VSceneHandler::GetMarkerSize(), G4VSceneHandler::screen, and G4VSceneHandler::world.

                                                                  {
 #ifdef G4XXXStoredDEBUG
   G4cout <<
     "G4XXXStoredSceneHandler::AddPrimitive(const G4Circle& circle) called.\n"
      << circle
      << G4endl;
   MarkerSizeType sizeType;
   G4double size = GetMarkerSize (circle, sizeType);
   switch (sizeType) {
   default:
   case screen:
     // Draw in screen coordinates.
     G4cout << "screen";
     break;
   case world:
     // Draw in world coordinates.
     G4cout << "world";
     break;
   }
   G4cout << " size: " << size << G4endl;
 #endif
   // Get vis attributes - pick up defaults if none.
   //const G4VisAttributes* pVA =
   //  fpViewer -> GetApplicableVisAttributes (circle.GetVisAttributes ());
   //?? Process circle.
   std::ostringstream oss;
   oss << circle;
   *fCurrentItem += oss.str();
 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Square & square )

virtual

Implements G4VSceneHandler.

Definition at line 282 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4cout, G4endl, G4VSceneHandler::GetMarkerSize(), G4VSceneHandler::screen, and G4VSceneHandler::world.

                                                                  {
 #ifdef G4XXXStoredDEBUG
   G4cout <<
     "G4XXXStoredSceneHandler::AddPrimitive(const G4Square& square) called.\n"
      << square
      << G4endl;
   MarkerSizeType sizeType;
   G4double size = GetMarkerSize (square, sizeType);
   switch (sizeType) {
   default:
   case screen:
     // Draw in screen coordinates.
     G4cout << "screen";
     break;
   case world:
     // Draw in world coordinates.
     G4cout << "world";
     break;
   }
   G4cout << " size: " << size << G4endl;
 #endif
   // Get vis attributes - pick up defaults if none.
   //const G4VisAttributes* pVA =
   //  fpViewer -> GetApplicableVisAttributes (square.GetVisAttributes ());
   //?? Process square.
   std::ostringstream oss;
   oss << square;
   *fCurrentItem += oss.str();
 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Polyhedron & polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 312 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4VSceneHandler::fpViewer, G4cout, G4endl, G4VSceneHandler::GetDrawingStyle(), G4ViewParameters::hlr, G4ViewParameters::hsr, and G4ViewParameters::wireframe.

                                                                          {
 #ifdef G4XXXStoredDEBUG
   G4cout <<
     "G4XXXStoredSceneHandler::AddPrimitive(const G4Polyhedron&) called.\n"
      << polyhedron
      << G4endl;
 #endif
   //?? Process polyhedron.
   std::ostringstream oss;
   oss << polyhedron;
   *fCurrentItem += oss.str();
 
   //?? Or... here are some ideas for decomposing into polygons...
   //Assume all facets are convex quadrilaterals.
   //Draw each G4Facet individually
   
   //Get colour, etc..
   if (polyhedron.GetNoFacets() == 0) return;
 
   // Get vis attributes - pick up defaults if none.
   const G4VisAttributes* pVA =
     fpViewer -> GetApplicableVisAttributes (polyhedron.GetVisAttributes ());
 
   // Get view parameters that the user can force through the vis
   // attributes, thereby over-riding the current view parameter.
   G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
   //G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
   
   //Get colour, etc..
   //const G4Colour& c = pVA -> GetColour ();
   
   // Initial action depending on drawing style.
   switch (drawing_style) {
   case (G4ViewParameters::hsr):
     {
       break;
     }
   case (G4ViewParameters::hlr):
     {
       break;
     }
   case (G4ViewParameters::wireframe):
     {
       break;
     }
   default:
     {
       break;
     }     
   }
 
   // Loop through all the facets...
 
   // Look at G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&)
   // for an example of how to get facets out of a G4Polyhedron,
   // including how to cope with triangles if that's a problem.
 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Polymarker & polymarker )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 95 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddPrimitive().

96 {G4VSceneHandler::AddPrimitive (polymarker);}

G4VSceneHandler::AddPrimitive

virtual void AddPrimitive(const G4Polyline &)=0

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Scale & scale )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 97 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddPrimitive().

98 {G4VSceneHandler::AddPrimitive (scale);}

G4VSceneHandler::AddPrimitive

virtual void AddPrimitive(const G4Polyline &)=0

void G4XXXStoredSceneHandler::AddSolid ( const G4Box & box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 200 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4cout, G4endl, G4VSolid::GetName(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), and G4Box::GetZHalfLength().

                                                        {
 #ifdef G4XXXStoredDEBUG
   G4cout <<
     "G4XXXStoredSceneHandler::AddSolid(const G4Box& box) called for "
      << box.GetName()
      << G4endl;
 #endif
   //?? Process your box...
   std::ostringstream oss;
   oss << "G4Box(" <<
     G4String
     (G4BestUnit
      (G4ThreeVector
       (box.GetXHalfLength(), box.GetYHalfLength(), box.GetZHalfLength()),
       "Length")).strip() << ')';
   *fCurrentItem += oss.str();
 }

void G4XXXStoredSceneHandler::AddSolid ( const G4Cons & cons )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 56 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

57 {G4VSceneHandler::AddSolid(cons);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Tubs & tubs )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 58 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

59 {G4VSceneHandler::AddSolid(tubs);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Trd & trd )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 60 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

61 {G4VSceneHandler::AddSolid(trd);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Trap & trap )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 62 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

63 {G4VSceneHandler::AddSolid(trap);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Sphere & sphere )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 64 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

65 {G4VSceneHandler::AddSolid(sphere);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Para & para )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 66 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

67 {G4VSceneHandler::AddSolid(para);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Torus & torus )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 68 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

69 {G4VSceneHandler::AddSolid(torus);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Polycone & polycone )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 70 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

71 {G4VSceneHandler::AddSolid(polycone);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4Polyhedra & polyhedra )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 72 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

73 {G4VSceneHandler::AddSolid(polyhedra);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::AddSolid ( const G4VSolid & solid )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 74 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

75 {G4VSceneHandler::AddSolid(solid);}

G4VSceneHandler::AddSolid

virtual void AddSolid(const G4Box &)

Definition: G4VSceneHandler.cc:212

void G4XXXStoredSceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 165 of file G4XXXStoredSceneHandler.cc.

References G4VSceneHandler::BeginPrimitives().

 {
   G4VSceneHandler::BeginPrimitives(objectTransformation);
 
   // If thread of control has already passed through PreAddSolid,
   // avoid opening a graphical data base component again.
   if (!fProcessingSolid) {
     // Create a place for current primitive...
     fCurrentItem = fStore.insert(fStore.end(),
                  G4String("\nBeginPrimitives:\n"));
     if (fReadyForTransients) {
       fTransients.push_back(fCurrentItem);
     } else {
       fPermanents.push_back(fCurrentItem);
     }
   }
 }

void G4XXXStoredSceneHandler::ClearStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 370 of file G4XXXStoredSceneHandler.cc.

References fPermanents, fStore, and fTransients.

 {
   fStore.clear();
   fPermanents.clear();
   fTransients.clear();
 }

void G4XXXStoredSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 377 of file G4XXXStoredSceneHandler.cc.

References G4VSceneHandler::fpViewer, fStore, and fTransients.

 {
   typedef std::vector<StoreIterator>::iterator StoreIteratorIterator;
   for (StoreIteratorIterator i = fTransients.begin();
        i != fTransients.end(); ++i) {
     fStore.erase(*i);
   }
   fTransients.clear();
 
   // Make sure screen corresponds to graphical database...
   if (fpViewer) {
     fpViewer -> SetView ();
     fpViewer -> ClearView ();
     fpViewer -> DrawView ();
   }
 }

void G4XXXStoredSceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 183 of file G4XXXStoredSceneHandler.cc.

References G4VSceneHandler::EndPrimitives(), fCurrentItem, and G4VSceneHandler::fProcessingSolid.

 {
   if (!fProcessingSolid) {  // Already done if so.
     *fCurrentItem += "\nEndPrimitives\n";
   }
   G4VSceneHandler::EndPrimitives ();
 }

void G4XXXStoredSceneHandler::PostAddSolid ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 158 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, and G4VSceneHandler::PostAddSolid().

 {
   *fCurrentItem += "\nEndSolid\n";
   G4VSceneHandler::PostAddSolid();
 }

void G4XXXStoredSceneHandler::PreAddSolid	(	const G4Transform3D &	objectTransformation,
		const G4VisAttributes &	visAttribs
	)

virtual

Reimplemented from G4VSceneHandler.

Definition at line 94 of file G4XXXStoredSceneHandler.cc.

References G4AttCheck::Check(), G4VisAttributes::CreateAttValues(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4cout, G4endl, G4VisAttributes::GetAttDefs(), G4PhysicalVolumeModel::GetAttDefs(), G4VSceneHandler::PreAddSolid(), and G4AttCheck::Standard().

 {
   G4VSceneHandler::PreAddSolid(objectTransformation, visAttribs);
 
   // Get user G4Atts...
   const std::map<G4String,G4AttDef>* userAttDefs = visAttribs.GetAttDefs();
   if (userAttDefs) {
 #ifdef G4XXXStoredDEBUG
     const std::vector<G4AttValue>* userAttValues =
       visAttribs.CreateAttValues();
     G4cout << "\nProvided G4Atts:\n"
        << G4AttCheck(userAttValues, userAttDefs);
     // Extra checks...
     G4AttCheck attCheck(userAttValues, userAttDefs);
     if (attCheck.Check()) G4cout << "Error" << G4endl;
     else {
       std::vector<G4AttValue> standardValues;
       std::map<G4String,G4AttDef> standardDefinitions;
       attCheck.Standard(&standardValues, &standardDefinitions);
       G4cout << "\nStandard G4Atts:\n"
              << G4AttCheck(&standardValues, &standardDefinitions);
     }
     // End of extra checks.
     delete userAttValues;  // (Must be deleted after use.)
 #endif
   }
 
   // Get solid's G4Atts created by G4PhysicalVolumeModel...
   G4PhysicalVolumeModel* pPVModel =
     dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
   if (pPVModel) {
     const std::map<G4String,G4AttDef>* solidAttDefs = pPVModel->GetAttDefs();
     if (solidAttDefs) {
 #ifdef G4XXXStoredDEBUG
       std::vector<G4AttValue>* solidAttValues =
     pPVModel->CreateCurrentAttValues();
       G4cout << "\nProvided G4Atts:\n"
          << G4AttCheck(solidAttValues, solidAttDefs);
       // Extra checks...
       G4AttCheck attCheck(solidAttValues,solidAttDefs);
       if (attCheck.Check()) G4cout << "Error" << G4endl;
       else {
     std::vector<G4AttValue> standardValues;
     std::map<G4String,G4AttDef> standardDefinitions;
     attCheck.Standard(&standardValues, &standardDefinitions);
     G4cout << "\nStandard G4Atts:\n"
            << G4AttCheck(&standardValues, &standardDefinitions);
       }
       // End of extra checks.
       delete solidAttValues;  // (Must be deleted after use.)
 #endif
     }
   }
 
   // Create a place for current solid...
   fCurrentItem = fStore.insert(fStore.end(), G4String("\nPreAddSolid:\n"));
   if (fReadyForTransients) {
     fTransients.push_back(fCurrentItem);
   } else {
     fPermanents.push_back(fCurrentItem);
   }
 }