G4XXXStoredSceneHandler Class Reference

#include <G4XXXStoredSceneHandler.hh>

Inheritance diagram for G4XXXStoredSceneHandler:

G4VSceneHandler G4VGraphicsScene

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 G4NURBS &)
void AddPrimitive (const G4Polymarker &polymarker)
void AddPrimitive (const G4Scale &scale)
void BeginPrimitives (const G4Transform3D &objectTransformation)
void EndPrimitives ()
void ClearStore ()
void ClearTransientStore ()

Protected Types

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

Protected Attributes

Store fStore
StoreIterator fCurrentItem
std::vector< StoreIteratorfPermanents
std::vector< StoreIteratorfTransients

Static Protected Attributes

static G4int fSceneIdCount = 0

Friends

class G4XXXStoredViewer

Detailed Description

Definition at line 41 of file G4XXXStoredSceneHandler.hh.


Member Typedef Documentation

typedef std::list<G4String> G4XXXStoredSceneHandler::Store [protected]

Definition at line 123 of file G4XXXStoredSceneHandler.hh.

typedef std::list<G4String>::iterator G4XXXStoredSceneHandler::StoreIterator [protected]

Definition at line 124 of file G4XXXStoredSceneHandler.hh.


Constructor & Destructor Documentation

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

Definition at line 57 of file G4XXXStoredSceneHandler.cc.

00058                                                                   :
00059   G4VSceneHandler(system, fSceneIdCount++, name)
00060 {}

G4XXXStoredSceneHandler::~G4XXXStoredSceneHandler (  )  [virtual]

Definition at line 62 of file G4XXXStoredSceneHandler.cc.

00062 {}


Member Function Documentation

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Scale scale  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 98 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddPrimitive().

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Polymarker polymarker  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 96 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddPrimitive().

00097   {G4VSceneHandler::AddPrimitive (polymarker);}

void G4XXXStoredSceneHandler::AddPrimitive ( const G4NURBS  )  [virtual]

Implements G4VSceneHandler.

Definition at line 370 of file G4XXXStoredSceneHandler.cc.

References G4cout, and G4endl.

00370                                                          {
00371 #ifdef G4XXXStoredDEBUG
00372   G4cout <<
00373     "G4XXXStoredSceneHandler::AddPrimitive(const G4NURBS& nurbs) called."
00374          << G4endl;
00375 #endif
00376   //?? Don't bother implementing this.  NURBS are not functional.
00377 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Polyhedron  )  [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.

00312                                                                          {
00313 #ifdef G4XXXStoredDEBUG
00314   G4cout <<
00315     "G4XXXStoredSceneHandler::AddPrimitive(const G4Polyhedron&) called.\n"
00316          << polyhedron
00317          << G4endl;
00318 #endif
00319   //?? Process polyhedron.
00320   std::ostringstream oss;
00321   oss << polyhedron;
00322   *fCurrentItem += oss.str();
00323 
00324   //?? Or... here are some ideas for decomposing into polygons...
00325   //Assume all facets are convex quadrilaterals.
00326   //Draw each G4Facet individually
00327   
00328   //Get colour, etc..
00329   if (polyhedron.GetNoFacets() == 0) return;
00330 
00331   // Get vis attributes - pick up defaults if none.
00332   const G4VisAttributes* pVA =
00333     fpViewer -> GetApplicableVisAttributes (polyhedron.GetVisAttributes ());
00334 
00335   // Get view parameters that the user can force through the vis
00336   // attributes, thereby over-riding the current view parameter.
00337   G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
00338   //G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
00339   
00340   //Get colour, etc..
00341   //const G4Colour& c = pVA -> GetColour ();
00342   
00343   // Initial action depending on drawing style.
00344   switch (drawing_style) {
00345   case (G4ViewParameters::hsr):
00346     {
00347       break;
00348     }
00349   case (G4ViewParameters::hlr):
00350     {
00351       break;
00352     }
00353   case (G4ViewParameters::wireframe):
00354     {
00355       break;
00356     }
00357   default:
00358     {
00359       break;
00360     }     
00361   }
00362 
00363   // Loop through all the facets...
00364 
00365   // Look at G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&)
00366   // for an example of how to get facets out of a G4Polyhedron,
00367   // including how to cope with triangles if that's a problem.
00368 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Square  )  [virtual]

Implements G4VSceneHandler.

Definition at line 282 of file G4XXXStoredSceneHandler.cc.

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

00282                                                                  {
00283 #ifdef G4XXXStoredDEBUG
00284   G4cout <<
00285     "G4XXXStoredSceneHandler::AddPrimitive(const G4Square& square) called.\n"
00286          << square
00287          << G4endl;
00288   MarkerSizeType sizeType;
00289   G4double size = GetMarkerSize (square, sizeType);
00290   switch (sizeType) {
00291   default:
00292   case screen:
00293     // Draw in screen coordinates.
00294     G4cout << "screen";
00295     break;
00296   case world:
00297     // Draw in world coordinates.
00298     G4cout << "world";
00299     break;
00300   }
00301   G4cout << " size: " << size << G4endl;
00302 #endif
00303   // Get vis attributes - pick up defaults if none.
00304   //const G4VisAttributes* pVA =
00305   //  fpViewer -> GetApplicableVisAttributes (square.GetVisAttributes ());
00306   //?? Process square.
00307   std::ostringstream oss;
00308   oss << square;
00309   *fCurrentItem += oss.str();
00310 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Circle  )  [virtual]

Implements G4VSceneHandler.

Definition at line 252 of file G4XXXStoredSceneHandler.cc.

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

00252                                                                  {
00253 #ifdef G4XXXStoredDEBUG
00254   G4cout <<
00255     "G4XXXStoredSceneHandler::AddPrimitive(const G4Circle& circle) called.\n"
00256          << circle
00257          << G4endl;
00258   MarkerSizeType sizeType;
00259   G4double size = GetMarkerSize (circle, sizeType);
00260   switch (sizeType) {
00261   default:
00262   case screen:
00263     // Draw in screen coordinates.
00264     G4cout << "screen";
00265     break;
00266   case world:
00267     // Draw in world coordinates.
00268     G4cout << "world";
00269     break;
00270   }
00271   G4cout << " size: " << size << G4endl;
00272 #endif
00273   // Get vis attributes - pick up defaults if none.
00274   //const G4VisAttributes* pVA =
00275   //  fpViewer -> GetApplicableVisAttributes (circle.GetVisAttributes ());
00276   //?? Process circle.
00277   std::ostringstream oss;
00278   oss << circle;
00279   *fCurrentItem += oss.str();
00280 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Text  )  [virtual]

Implements G4VSceneHandler.

Definition at line 234 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4cout, and G4endl.

00234                                                              {
00235 #ifdef G4XXXStoredDEBUG
00236   G4cout <<
00237     "G4XXXStoredSceneHandler::AddPrimitive(const G4Text& text) called.|n"
00238          << text
00239          << G4endl;
00240 #endif
00241   // Get text colour - special method since default text colour is
00242   // determined by the default text vis attributes, which may be
00243   // specified independent of default vis attributes of other types of
00244   // visible objects.
00245   //const G4Colour& c = GetTextColour (text);  // Picks up default if none.
00246   //?? Process text.
00247   std::ostringstream oss;
00248   oss << text;
00249   *fCurrentItem += oss.str();
00250 }

void G4XXXStoredSceneHandler::AddPrimitive ( const G4Polyline  )  [virtual]

Implements G4VSceneHandler.

Definition at line 218 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, G4cout, and G4endl.

00218                                                                      {
00219 #ifdef G4XXXStoredDEBUG
00220   G4cout <<
00221  "G4XXXStoredSceneHandler::AddPrimitive(const G4Polyline& polyline) called.\n"
00222          << polyline
00223          << G4endl;
00224 #endif
00225   // Get vis attributes - pick up defaults if none.
00226   //const G4VisAttributes* pVA =
00227   //  fpViewer -> GetApplicableVisAttributes (polyline.GetVisAttributes ());
00228   //?? Process polyline.
00229   std::ostringstream oss;
00230   oss << polyline;
00231   *fCurrentItem += oss.str();
00232 }

void G4XXXStoredSceneHandler::AddSolid ( const G4VSolid solid  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 74 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00075   {G4VSceneHandler::AddSolid(solid);}

void G4XXXStoredSceneHandler::AddSolid ( const G4Polyhedra polyhedra  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 72 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00073   {G4VSceneHandler::AddSolid(polyhedra);}

void G4XXXStoredSceneHandler::AddSolid ( const G4Polycone polycone  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 70 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00071   {G4VSceneHandler::AddSolid(polycone);}

void G4XXXStoredSceneHandler::AddSolid ( const G4Torus torus  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 68 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00069   {G4VSceneHandler::AddSolid(torus);}

void G4XXXStoredSceneHandler::AddSolid ( const G4Para para  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 66 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

void G4XXXStoredSceneHandler::AddSolid ( const G4Sphere sphere  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 64 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00065   {G4VSceneHandler::AddSolid(sphere);}

void G4XXXStoredSceneHandler::AddSolid ( const G4Trap trap  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 62 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

void G4XXXStoredSceneHandler::AddSolid ( const G4Trd trd  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 60 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

void G4XXXStoredSceneHandler::AddSolid ( const G4Tubs tubs  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 58 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

void G4XXXStoredSceneHandler::AddSolid ( const G4Cons cons  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 56 of file G4XXXStoredSceneHandler.hh.

References G4VSceneHandler::AddSolid().

void G4XXXStoredSceneHandler::AddSolid ( const G4Box  )  [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().

00200                                                        {
00201 #ifdef G4XXXStoredDEBUG
00202   G4cout <<
00203     "G4XXXStoredSceneHandler::AddSolid(const G4Box& box) called for "
00204          << box.GetName()
00205          << G4endl;
00206 #endif
00207   //?? Process your box...
00208   std::ostringstream oss;
00209   oss << "G4Box(" <<
00210     G4String
00211     (G4BestUnit
00212      (G4ThreeVector
00213       (box.GetXHalfLength(), box.GetYHalfLength(), box.GetZHalfLength()),
00214       "Length")).strip() << ')';
00215   *fCurrentItem += oss.str();
00216 }

void G4XXXStoredSceneHandler::BeginPrimitives ( const G4Transform3D objectTransformation  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 165 of file G4XXXStoredSceneHandler.cc.

References G4VSceneHandler::BeginPrimitives().

00166 {
00167   G4VSceneHandler::BeginPrimitives(objectTransformation);
00168 
00169   // If thread of control has already passed through PreAddSolid,
00170   // avoid opening a graphical data base component again.
00171   if (!fProcessingSolid) {
00172     // Create a place for current primitive...
00173     fCurrentItem = fStore.insert(fStore.end(),
00174                                  G4String("\nBeginPrimitives:\n"));
00175     if (fReadyForTransients) {
00176       fTransients.push_back(fCurrentItem);
00177     } else {
00178       fPermanents.push_back(fCurrentItem);
00179     }
00180   }
00181 }

void G4XXXStoredSceneHandler::ClearStore (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 379 of file G4XXXStoredSceneHandler.cc.

References fPermanents, fStore, and fTransients.

00380 {
00381   fStore.clear();
00382   fPermanents.clear();
00383   fTransients.clear();
00384 }

void G4XXXStoredSceneHandler::ClearTransientStore (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 386 of file G4XXXStoredSceneHandler.cc.

References G4VSceneHandler::fpViewer, fStore, and fTransients.

00387 {
00388   typedef std::vector<StoreIterator>::iterator StoreIteratorIterator;
00389   for (StoreIteratorIterator i = fTransients.begin();
00390        i != fTransients.end(); ++i) {
00391     fStore.erase(*i);
00392   }
00393   fTransients.clear();
00394 
00395   // Make sure screen corresponds to graphical database...
00396   if (fpViewer) {
00397     fpViewer -> SetView ();
00398     fpViewer -> ClearView ();
00399     fpViewer -> DrawView ();
00400   }
00401 }

void G4XXXStoredSceneHandler::EndPrimitives (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 183 of file G4XXXStoredSceneHandler.cc.

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

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

void G4XXXStoredSceneHandler::PostAddSolid (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 158 of file G4XXXStoredSceneHandler.cc.

References fCurrentItem, and G4VSceneHandler::PostAddSolid().

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

void G4XXXStoredSceneHandler::PreAddSolid ( const G4Transform3D objectTransformation,
const G4VisAttributes  
) [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 94 of file G4XXXStoredSceneHandler.cc.

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

00096 {
00097   G4VSceneHandler::PreAddSolid(objectTransformation, visAttribs);
00098 
00099   // Get user G4Atts...
00100   const std::map<G4String,G4AttDef>* userAttDefs = visAttribs.GetAttDefs();
00101   if (userAttDefs) {
00102 #ifdef G4XXXStoredDEBUG
00103     const std::vector<G4AttValue>* userAttValues =
00104       visAttribs.CreateAttValues();
00105     G4cout << "\nProvided G4Atts:\n"
00106            << G4AttCheck(userAttValues, userAttDefs);
00107     // Extra checks...
00108     G4AttCheck attCheck(userAttValues, userAttDefs);
00109     if (attCheck.Check()) G4cout << "Error" << G4endl;
00110     else {
00111       std::vector<G4AttValue> standardValues;
00112       std::map<G4String,G4AttDef> standardDefinitions;
00113       attCheck.Standard(&standardValues, &standardDefinitions);
00114       G4cout << "\nStandard G4Atts:\n"
00115              << G4AttCheck(&standardValues, &standardDefinitions);
00116     }
00117     // End of extra checks.
00118     delete userAttValues;  // (Must be deleted after use.)
00119 #endif
00120   }
00121 
00122   // Get solid's G4Atts created by G4PhysicalVolumeModel...
00123   G4PhysicalVolumeModel* pPVModel =
00124     dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
00125   if (pPVModel) {
00126     const std::map<G4String,G4AttDef>* solidAttDefs = pPVModel->GetAttDefs();
00127     if (solidAttDefs) {
00128 #ifdef G4XXXStoredDEBUG
00129       std::vector<G4AttValue>* solidAttValues =
00130         pPVModel->CreateCurrentAttValues();
00131       G4cout << "\nProvided G4Atts:\n"
00132              << G4AttCheck(solidAttValues, solidAttDefs);
00133       // Extra checks...
00134       G4AttCheck attCheck(solidAttValues,solidAttDefs);
00135       if (attCheck.Check()) G4cout << "Error" << G4endl;
00136       else {
00137         std::vector<G4AttValue> standardValues;
00138         std::map<G4String,G4AttDef> standardDefinitions;
00139         attCheck.Standard(&standardValues, &standardDefinitions);
00140         G4cout << "\nStandard G4Atts:\n"
00141                << G4AttCheck(&standardValues, &standardDefinitions);
00142       }
00143       // End of extra checks.
00144       delete solidAttValues;  // (Must be deleted after use.)
00145 #endif
00146     }
00147   }
00148 
00149   // Create a place for current solid...
00150   fCurrentItem = fStore.insert(fStore.end(), G4String("\nPreAddSolid:\n"));
00151   if (fReadyForTransients) {
00152     fTransients.push_back(fCurrentItem);
00153   } else {
00154     fPermanents.push_back(fCurrentItem);
00155   }
00156 }


Friends And Related Function Documentation

friend class G4XXXStoredViewer [friend]

Definition at line 43 of file G4XXXStoredSceneHandler.hh.


Field Documentation

StoreIterator G4XXXStoredSceneHandler::fCurrentItem [protected]

Definition at line 126 of file G4XXXStoredSceneHandler.hh.

Referenced by AddPrimitive(), AddSolid(), EndPrimitives(), and PostAddSolid().

std::vector<StoreIterator> G4XXXStoredSceneHandler::fPermanents [protected]

Definition at line 129 of file G4XXXStoredSceneHandler.hh.

Referenced by ClearStore().

G4int G4XXXStoredSceneHandler::fSceneIdCount = 0 [static, protected]

Definition at line 118 of file G4XXXStoredSceneHandler.hh.

Store G4XXXStoredSceneHandler::fStore [protected]

Definition at line 125 of file G4XXXStoredSceneHandler.hh.

Referenced by ClearStore(), and ClearTransientStore().

std::vector<StoreIterator> G4XXXStoredSceneHandler::fTransients [protected]

Definition at line 130 of file G4XXXStoredSceneHandler.hh.

Referenced by ClearStore(), and ClearTransientStore().


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:54:01 2013 for Geant4 by  doxygen 1.4.7