Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommandsScene.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/management/src/G4VisCommandsScene.cc (Version 11.3.0) and /visualization/management/src/G4VisCommandsScene.cc (Version 8.2.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
                                                   >>  27 // $Id: G4VisCommandsScene.cc,v 1.65 2006/11/26 19:37:54 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-02-patch-01 $
 27                                                    29 
 28 // /vis/scene commands - John Allison  9th Aug     30 // /vis/scene commands - John Allison  9th August 1998
 29                                                    31 
 30 #include "G4VisCommandsScene.hh"                   32 #include "G4VisCommandsScene.hh"
 31                                                    33 
 32 #include "G4VisManager.hh"                         34 #include "G4VisManager.hh"
 33 #include "G4TransportationManager.hh"              35 #include "G4TransportationManager.hh"
 34 #include "G4RunManager.hh"                     << 
 35 #include "G4RunManagerFactory.hh"              << 
 36 #include "G4Run.hh"                            << 
 37 #include "G4PhysicalVolumeModel.hh"                36 #include "G4PhysicalVolumeModel.hh"
 38 #include "G4ApplicationState.hh"                   37 #include "G4ApplicationState.hh"
 39 #include "G4UImanager.hh"                          38 #include "G4UImanager.hh"
 40 #include "G4UIcommand.hh"                          39 #include "G4UIcommand.hh"
 41 #include "G4UIcmdWithAString.hh"                   40 #include "G4UIcmdWithAString.hh"
 42 #include "G4UIcmdWithoutParameter.hh"          << 
 43 #include "G4ios.hh"                                41 #include "G4ios.hh"
 44 #include <sstream>                                 42 #include <sstream>
 45                                                    43 
 46 #define G4warn G4cout                          << 
 47                                                << 
 48 G4VVisCommandScene::G4VVisCommandScene () {}       44 G4VVisCommandScene::G4VVisCommandScene () {}
 49                                                    45 
 50 G4VVisCommandScene::~G4VVisCommandScene () {}      46 G4VVisCommandScene::~G4VVisCommandScene () {}
 51                                                    47 
 52 G4String G4VVisCommandScene::CurrentSceneName      48 G4String G4VVisCommandScene::CurrentSceneName () {
 53   const G4Scene* pScene = fpVisManager -> GetC     49   const G4Scene* pScene = fpVisManager -> GetCurrentScene ();
 54   G4String currentSceneName = "none";          <<  50   G4String currentSceneName;
 55   if (pScene) currentSceneName = pScene -> Get     51   if (pScene) currentSceneName = pScene -> GetName ();
 56   return currentSceneName;                         52   return currentSceneName;
 57 }                                                  53 }
 58                                                    54 
 59 ////////////// /vis/scene/activateModel ////// << 
 60                                                << 
 61 G4VisCommandSceneActivateModel::G4VisCommandSc << 
 62   G4bool omitable;                             << 
 63   fpCommand = new G4UIcommand ("/vis/scene/act << 
 64   fpCommand -> SetGuidance                     << 
 65     ("Activate or de-activate model.");        << 
 66   fpCommand -> SetGuidance                     << 
 67     ("Attempts to match search string to name  << 
 68   fpCommand -> SetGuidance                     << 
 69     ("Use \"/vis/scene/list\" to see model nam << 
 70   fpCommand -> SetGuidance                     << 
 71     ("If name == \"all\" (default), all models << 
 72   G4UIparameter* parameter;                    << 
 73   parameter = new G4UIparameter ("search-strin << 
 74   parameter -> SetDefaultValue ("all");        << 
 75   fpCommand -> SetParameter (parameter);       << 
 76   parameter = new G4UIparameter ("activate", ' << 
 77   parameter -> SetDefaultValue (true);         << 
 78   fpCommand -> SetParameter (parameter);       << 
 79 }                                              << 
 80                                                << 
 81 G4VisCommandSceneActivateModel::~G4VisCommandS << 
 82   delete fpCommand;                            << 
 83 }                                              << 
 84                                                << 
 85 G4String G4VisCommandSceneActivateModel::GetCu << 
 86   return "";                                   << 
 87 }                                              << 
 88                                                << 
 89 void G4VisCommandSceneActivateModel::SetNewVal << 
 90                  G4String newValue) {          << 
 91                                                << 
 92   G4VisManager::Verbosity verbosity = fpVisMan << 
 93                                                << 
 94   G4String searchString, activateString;       << 
 95   std::istringstream is (newValue);            << 
 96   // Need to handle the possibility that the s << 
 97   // contains embedded blanks within quotation << 
 98   // (This arises if the search string is auto << 
 99   // global description, as in G4UIQt, clickin << 
100   auto lastQuotationMark = newValue.find_last_ << 
101   if (lastQuotationMark != std::string::npos)  << 
102     auto firstQuotationMark = newValue.find_fi << 
103     if (lastQuotationMark != firstQuotationMar << 
104       // Note: there must not be more quotatio << 
105       searchString = newValue.substr           << 
106       (firstQuotationMark + 1, lastQuotationMa << 
107       activateString = newValue.substr(lastQuo << 
108       // Perhaps we ought to check number of q << 
109       G4int nQuotes = 0;                       << 
110       for (auto c : newValue) {                << 
111         if (c == '"') nQuotes++;               << 
112       }                                        << 
113       if (nQuotes > 2) {                       << 
114         G4ExceptionDescription ed;             << 
115         ed << "More than 2 quotation marks in  << 
116         G4Exception("G4VisCommandSceneActivate << 
117       }                                        << 
118     }                                          << 
119   }                                            << 
120   else {                                       << 
121     // None or one quotation marks - just inpu << 
122     is >> searchString >> activateString;      << 
123   }                                            << 
124   G4bool activate = G4UIcommand::ConvertToBool << 
125                                                << 
126   G4Scene* pScene = fpVisManager->GetCurrentSc << 
127   if (!pScene) {                               << 
128     if (verbosity >= G4VisManager::errors) {   << 
129       G4warn << "ERROR: No current scene.  Ple << 
130     }                                          << 
131     return;                                    << 
132   }                                            << 
133                                                << 
134   G4VSceneHandler* pSceneHandler = fpVisManage << 
135   if (!pSceneHandler) {                        << 
136     if (verbosity >= G4VisManager::errors) {   << 
137       G4warn << "ERROR: No current sceneHandle << 
138     }                                          << 
139     return;                                    << 
140   }                                            << 
141                                                << 
142   if (searchString == "all" && !activate) {    << 
143     if (verbosity >= G4VisManager::warnings) { << 
144       G4warn <<                                << 
145   "WARNING: You are not allowed to de-activate << 
146   "\n  Command ignored."                       << 
147        << G4endl;                              << 
148     }                                          << 
149     return;                                    << 
150   }                                            << 
151                                                << 
152   G4bool any = false;                          << 
153                                                << 
154   std::vector<G4Scene::Model>& runDurationMode << 
155     pScene->SetRunDurationModelList();         << 
156   for (size_t i = 0; i < runDurationModelList. << 
157     const G4String& modelName = runDurationMod << 
158     if (searchString == "all" || modelName.fin << 
159       any = true;                              << 
160       runDurationModelList[i].fActive = activa << 
161       if (verbosity >= G4VisManager::warnings) << 
162   G4warn << "Model \"" << modelName;           << 
163   if (activate) G4warn << "\" activated.";     << 
164   else  G4warn << "\" de-activated.";          << 
165   G4warn << G4endl;                            << 
166       }                                        << 
167     }                                          << 
168   }                                            << 
169                                                << 
170   std::vector<G4Scene::Model>& endOfEventModel << 
171     pScene->SetEndOfEventModelList();          << 
172   for (size_t i = 0; i < endOfEventModelList.s << 
173     const G4String& modelName = endOfEventMode << 
174     if (searchString == "all" || modelName.fin << 
175       any = true;                              << 
176       endOfEventModelList[i].fActive = activat << 
177       if (verbosity >= G4VisManager::warnings) << 
178   G4warn << "Model \"" << modelName;           << 
179   if (activate) G4warn << "\" activated.";     << 
180   else  G4warn << "\" de-activated.";          << 
181   G4warn << G4endl;                            << 
182       }                                        << 
183     }                                          << 
184   }                                            << 
185                                                << 
186   std::vector<G4Scene::Model>& endOfRunModelLi << 
187     pScene->SetEndOfRunModelList();            << 
188   for (size_t i = 0; i < endOfRunModelList.siz << 
189     const G4String& modelName = endOfRunModelL << 
190     if (searchString == "all" || modelName.fin << 
191       any = true;                              << 
192       endOfRunModelList[i].fActive = activate; << 
193       if (verbosity >= G4VisManager::warnings) << 
194   G4warn << "Model \"" << modelName;           << 
195   if (activate) G4warn << "\" activated.";     << 
196   else  G4warn << "\" de-activated.";          << 
197   G4warn << G4endl;                            << 
198       }                                        << 
199     }                                          << 
200   }                                            << 
201                                                << 
202   if (!any) {                                  << 
203     if (verbosity >= G4VisManager::warnings) { << 
204       G4warn << "WARNING: No match found." <<  << 
205     }                                          << 
206     return;                                    << 
207   }                                            << 
208                                                << 
209   CheckSceneAndNotifyHandlers (pScene);        << 
210 }                                              << 
211                                                << 
212 ////////////// /vis/scene/create /////////////     55 ////////////// /vis/scene/create ///////////////////////////////////////
213                                                    56 
214 G4VisCommandSceneCreate::G4VisCommandSceneCrea     57 G4VisCommandSceneCreate::G4VisCommandSceneCreate (): fId (0) {
215   G4bool omitable;                                 58   G4bool omitable;
216   fpCommand = new G4UIcmdWithAString ("/vis/sc     59   fpCommand = new G4UIcmdWithAString ("/vis/scene/create", this);
217   fpCommand -> SetGuidance                         60   fpCommand -> SetGuidance
218     ("Creates an empty scene.");                   61     ("Creates an empty scene.");
219   fpCommand -> SetGuidance                         62   fpCommand -> SetGuidance
220     ("Invents a name if not supplied.  This sc     63     ("Invents a name if not supplied.  This scene becomes current.");
221   fpCommand -> SetParameterName ("scene-name",     64   fpCommand -> SetParameterName ("scene-name", omitable = true);
222 }                                                  65 }
223                                                    66 
224 G4VisCommandSceneCreate::~G4VisCommandSceneCre     67 G4VisCommandSceneCreate::~G4VisCommandSceneCreate () {
225   delete fpCommand;                                68   delete fpCommand;
226 }                                                  69 }
227                                                    70 
228 G4String G4VisCommandSceneCreate::NextName ()      71 G4String G4VisCommandSceneCreate::NextName () {
229   std::ostringstream oss;                          72   std::ostringstream oss;
230   oss << "scene-" << fId;                          73   oss << "scene-" << fId;
231   return oss.str();                                74   return oss.str();
232 }                                                  75 }
233                                                    76 
234 G4String G4VisCommandSceneCreate::GetCurrentVa     77 G4String G4VisCommandSceneCreate::GetCurrentValue (G4UIcommand*) {
235   return "";                                       78   return "";
236 }                                                  79 }
237                                                    80 
238 void G4VisCommandSceneCreate::SetNewValue (G4U     81 void G4VisCommandSceneCreate::SetNewValue (G4UIcommand*, G4String newValue) {
239                                                    82 
240   G4VisManager::Verbosity verbosity = fpVisMan     83   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
241                                                    84 
242   G4String& newName = newValue;                    85   G4String& newName = newValue;
243   G4String nextName = NextName ();                 86   G4String nextName = NextName ();
244                                                    87 
245   if (newName == "") {                             88   if (newName == "") {
246     newName = nextName;                            89     newName = nextName;
247   }                                                90   }
248   if (newName == nextName) fId++;                  91   if (newName == nextName) fId++;
249                                                    92 
250   G4SceneList& sceneList = fpVisManager -> Set     93   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
251   std::size_t iScene, nScenes = sceneList.size <<  94   G4int iScene, nScenes = sceneList.size ();
252   for (iScene = 0; iScene < nScenes; ++iScene) <<  95   for (iScene = 0; iScene < nScenes; iScene++) {
253     if (sceneList [iScene] -> GetName () == ne     96     if (sceneList [iScene] -> GetName () == newName) break;
254   }                                                97   }
255   if (iScene < nScenes) {                          98   if (iScene < nScenes) {
256     if (verbosity >= G4VisManager::warnings) {     99     if (verbosity >= G4VisManager::warnings) {
257       G4warn << "WARNING: Scene \"" << newName << 100       G4cout << "WARNING: Scene \"" << newName << "\" already exists."
258        << "\n  New scene not created."            101        << "\n  New scene not created."
259        << G4endl;                                 102        << G4endl;
260     }                                             103     }
261   } else {                                        104   } else {
262                                                   105 
263     // Add empty scene data object to list...     106     // Add empty scene data object to list...
264     G4Scene* pScene = new G4Scene (newName);      107     G4Scene* pScene = new G4Scene (newName);
265     sceneList.push_back (pScene);                 108     sceneList.push_back (pScene);
266     fpVisManager -> SetCurrentScene (pScene);     109     fpVisManager -> SetCurrentScene (pScene);
267                                                   110 
268     if (verbosity >= G4VisManager::confirmatio    111     if (verbosity >= G4VisManager::confirmations) {
269       G4cout << "New empty scene \"" << newNam    112       G4cout << "New empty scene \"" << newName << "\" created." << G4endl;
270     }                                             113     }
271   }                                               114   }
272 }                                                 115 }
273                                                   116 
274 ////////////// /vis/scene/endOfEventAction ///    117 ////////////// /vis/scene/endOfEventAction ////////////////////////////
275                                                   118 
276 G4VisCommandSceneEndOfEventAction::G4VisComman    119 G4VisCommandSceneEndOfEventAction::G4VisCommandSceneEndOfEventAction () {
277   G4bool omitable;                                120   G4bool omitable;
278   fpCommand = new G4UIcommand ("/vis/scene/end    121   fpCommand = new G4UIcommand ("/vis/scene/endOfEventAction", this);
279   fpCommand -> SetGuidance                        122   fpCommand -> SetGuidance
280     ("Accumulate or refresh the viewer for eac    123     ("Accumulate or refresh the viewer for each new event.");
281   fpCommand -> SetGuidance                        124   fpCommand -> SetGuidance
282     ("\"accumulate\": viewer accumulates hits,    125     ("\"accumulate\": viewer accumulates hits, etc., event by event, or");
283   fpCommand -> SetGuidance                        126   fpCommand -> SetGuidance
284     ("\"refresh\": viewer shows them at end of    127     ("\"refresh\": viewer shows them at end of event or, for direct-screen"
285      "\n  viewers, refreshes the screen just b    128      "\n  viewers, refreshes the screen just before drawing the next event.");
286   G4UIparameter* parameter;                       129   G4UIparameter* parameter;
287   parameter = new G4UIparameter ("action", 's'    130   parameter = new G4UIparameter ("action", 's', omitable = true);
288   parameter -> SetParameterCandidates ("accumu    131   parameter -> SetParameterCandidates ("accumulate refresh");
289   parameter -> SetDefaultValue ("refresh");       132   parameter -> SetDefaultValue ("refresh");
290   fpCommand -> SetParameter (parameter);          133   fpCommand -> SetParameter (parameter);
291   parameter = new G4UIparameter ("maxNumber",     134   parameter = new G4UIparameter ("maxNumber", 'i', omitable = true);
292   parameter -> SetDefaultValue (100);             135   parameter -> SetDefaultValue (100);
293   parameter -> SetGuidance                        136   parameter -> SetGuidance
294   ("Maximum number of events kept.  Unlimited     137   ("Maximum number of events kept.  Unlimited if negative.");
295   fpCommand -> SetParameter (parameter);          138   fpCommand -> SetParameter (parameter);
296 }                                                 139 }
297                                                   140 
298 G4VisCommandSceneEndOfEventAction::~G4VisComma    141 G4VisCommandSceneEndOfEventAction::~G4VisCommandSceneEndOfEventAction () {
299   delete fpCommand;                               142   delete fpCommand;
300 }                                                 143 }
301                                                   144 
302 G4String G4VisCommandSceneEndOfEventAction::Ge    145 G4String G4VisCommandSceneEndOfEventAction::GetCurrentValue(G4UIcommand*) {
303   return "";                                      146   return "";
304 }                                                 147 }
305                                                   148 
306 void G4VisCommandSceneEndOfEventAction::SetNew    149 void G4VisCommandSceneEndOfEventAction::SetNewValue (G4UIcommand*,
307                  G4String newValue) {             150                  G4String newValue) {
308                                                   151 
309   G4VisManager::Verbosity verbosity = fpVisMan    152   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
310                                                   153 
311   G4String action;                                154   G4String action;
312   G4int maxNumberOfKeptEvents;                    155   G4int maxNumberOfKeptEvents;
313   std::istringstream is (newValue);               156   std::istringstream is (newValue);
314   is >> action >> maxNumberOfKeptEvents;          157   is >> action >> maxNumberOfKeptEvents;
315                                                   158 
316   G4Scene* pScene = fpVisManager->GetCurrentSc    159   G4Scene* pScene = fpVisManager->GetCurrentScene();
317   if (!pScene) {                                  160   if (!pScene) {
318     if (verbosity >= G4VisManager::errors) {      161     if (verbosity >= G4VisManager::errors) {
319       G4warn << "ERROR: No current scene.  Ple << 162       G4cout << "ERROR: No current scene.  Please create one." << G4endl;
320     }                                             163     }
321     return;                                       164     return;
322   }                                               165   }
323                                                   166 
324   G4VSceneHandler* pSceneHandler = fpVisManage    167   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
325   if (!pSceneHandler) {                           168   if (!pSceneHandler) {
326     if (verbosity >= G4VisManager::errors) {      169     if (verbosity >= G4VisManager::errors) {
327       G4warn << "ERROR: No current sceneHandle << 170       G4cout << "ERROR: No current sceneHandler.  Please create one." << G4endl;
328     }                                             171     }
329     return;                                       172     return;
330   }                                               173   }
331                                                   174 
332   if (action == "accumulate") {                   175   if (action == "accumulate") {
333     pScene->SetRefreshAtEndOfEvent(false);        176     pScene->SetRefreshAtEndOfEvent(false);
334     pScene->SetMaxNumberOfKeptEvents(maxNumber    177     pScene->SetMaxNumberOfKeptEvents(maxNumberOfKeptEvents);
335   }                                               178   }
336   else if (action == "refresh") {                 179   else if (action == "refresh") {
337     if (!pScene->GetRefreshAtEndOfRun()) {        180     if (!pScene->GetRefreshAtEndOfRun()) {
338       if (verbosity >= G4VisManager::errors) {    181       if (verbosity >= G4VisManager::errors) {
339   G4warn <<                                    << 182   G4cout <<
340     "ERROR: Cannot refresh events unless runs     183     "ERROR: Cannot refresh events unless runs refresh too."
341     "\n  Use \"/vis/scene/endOfRun refresh\"."    184     "\n  Use \"/vis/scene/endOfRun refresh\"."
342          << G4endl;                               185          << G4endl;
343       }                                           186       }
344     } else {                                      187     } else {
345       pScene->SetRefreshAtEndOfEvent(true);       188       pScene->SetRefreshAtEndOfEvent(true);
346       pScene->SetMaxNumberOfKeptEvents(maxNumb << 
347       pSceneHandler->SetMarkForClearingTransie    189       pSceneHandler->SetMarkForClearingTransientStore(true);
348     }                                             190     }
349   }                                               191   }
350   else {                                          192   else {
351     if (verbosity >= G4VisManager::errors) {      193     if (verbosity >= G4VisManager::errors) {
352       G4warn <<                                << 194       G4cout <<
353   "ERROR: unrecognised parameter \"" << action    195   "ERROR: unrecognised parameter \"" << action << "\"."
354              << G4endl;                           196              << G4endl;
355     }                                             197     }
356     return;                                       198     return;
357   }                                               199   }
358                                                   200 
359   // Change of transients behaviour, so...        201   // Change of transients behaviour, so...
360   fpVisManager->ResetTransientsDrawnFlags();      202   fpVisManager->ResetTransientsDrawnFlags();
361                                                   203 
362   // Are there any events currently kept...    << 
363   size_t nCurrentlyKept    = 0;                << 
364   G4RunManager* runManager = G4RunManagerFacto << 
365   if(runManager)                               << 
366   {                                            << 
367     const G4Run* currentRun = runManager->GetC << 
368     if(currentRun)                             << 
369     {                                          << 
370       const std::vector<const G4Event*>* event << 
371       if(events)                               << 
372         nCurrentlyKept = events->size();       << 
373     }                                          << 
374   }                                            << 
375                                                << 
376   if (verbosity >= G4VisManager::confirmations    204   if (verbosity >= G4VisManager::confirmations) {
377     G4cout << "End of event action set to ";      205     G4cout << "End of event action set to ";
378     if (pScene->GetRefreshAtEndOfEvent()) G4co    206     if (pScene->GetRefreshAtEndOfEvent()) G4cout << "\"refresh\".";
379     else {                                        207     else {
380       G4cout << "\"accumulate\"."                 208       G4cout << "\"accumulate\"."
381   "\n  Maximum number of events to be kept: "     209   "\n  Maximum number of events to be kept: "
382        << maxNumberOfKeptEvents                   210        << maxNumberOfKeptEvents
383        << " (unlimited if negative)."             211        << " (unlimited if negative)."
384   "\n  This may be changed with, e.g., "          212   "\n  This may be changed with, e.g., "
385   "\"/vis/scene/endOfEventAction accumulate 10 << 213   "\"/vis/scene/endOfEventAction accumulate 100\"."
                                                   >> 214        << G4endl;
386     }                                             215     }
387     G4cout << G4endl;                          << 
388   }                                               216   }
389                                                << 
390   if (!pScene->GetRefreshAtEndOfEvent() &&        217   if (!pScene->GetRefreshAtEndOfEvent() &&
391       maxNumberOfKeptEvents != 0 &&               218       maxNumberOfKeptEvents != 0 &&
392       verbosity >= G4VisManager::warnings) {      219       verbosity >= G4VisManager::warnings) {
393     G4warn << "WARNING: ";                     << 220     G4cout << "WARNING: The vis manager will keep ";
394     if (nCurrentlyKept) {                      << 221     if (maxNumberOfKeptEvents < 0) G4cout << "an unlimited number of";
395       G4warn <<                                << 222     else G4cout << "up to " << maxNumberOfKeptEvents;
396   "\n  There are currently " << nCurrentlyKept << 223     G4cout << " events.";
397        << " events kept for refreshing and/or  << 224     if (maxNumberOfKeptEvents > 1 || maxNumberOfKeptEvents < 0)
398     } else {                                   << 225       G4cout << "\n  This may use a lot of memory.";
399       G4warn << "The vis manager will keep ";  << 226     G4cout << G4endl;
400       if (maxNumberOfKeptEvents < 0) G4warn << << 
401       else G4warn << "up to " << maxNumberOfKe << 
402       G4warn << " events.";                    << 
403       if (maxNumberOfKeptEvents > 1 || maxNumb << 
404   G4warn <<                                    << 
405     "\n  This may use a lot of memory."        << 
406     "\n  It may be changed with, e.g., "       << 
407     "\"/vis/scene/endOfEventAction accumulate  << 
408     }                                          << 
409     G4warn << G4endl;                          << 
410   }                                               227   }
                                                   >> 228   UpdateVisManagerScene (pScene->GetName());
411 }                                                 229 }
412                                                   230 
413 ////////////// /vis/scene/endOfRunAction /////    231 ////////////// /vis/scene/endOfRunAction ////////////////////////////
414                                                   232 
415 G4VisCommandSceneEndOfRunAction::G4VisCommandS    233 G4VisCommandSceneEndOfRunAction::G4VisCommandSceneEndOfRunAction () {
416   G4bool omitable;                                234   G4bool omitable;
417   fpCommand = new G4UIcmdWithAString ("/vis/sc    235   fpCommand = new G4UIcmdWithAString ("/vis/scene/endOfRunAction", this);
418   fpCommand -> SetGuidance                        236   fpCommand -> SetGuidance
419     ("Accumulate or refresh the viewer for eac    237     ("Accumulate or refresh the viewer for each new run.");
420   fpCommand -> SetGuidance                        238   fpCommand -> SetGuidance
421     ("\"accumulate\": viewer accumulates hits,    239     ("\"accumulate\": viewer accumulates hits, etc., run by run, or");
422   fpCommand -> SetGuidance                        240   fpCommand -> SetGuidance
423     ("\"refresh\": viewer shows them at end of    241     ("\"refresh\": viewer shows them at end of run or, for direct-screen"
424      "\n  viewers, refreshes the screen just b    242      "\n  viewers, refreshes the screen just before drawing the first"
425      "\n  event of the next run.");               243      "\n  event of the next run.");
426   fpCommand -> SetGuidance ("The detector rema    244   fpCommand -> SetGuidance ("The detector remains or is redrawn.");
427   fpCommand -> SetParameterName ("action", omi    245   fpCommand -> SetParameterName ("action", omitable = true);
428   fpCommand -> SetCandidates ("accumulate refr    246   fpCommand -> SetCandidates ("accumulate refresh");
429   fpCommand -> SetDefaultValue ("refresh");       247   fpCommand -> SetDefaultValue ("refresh");
430 }                                                 248 }
431                                                   249 
432 G4VisCommandSceneEndOfRunAction::~G4VisCommand    250 G4VisCommandSceneEndOfRunAction::~G4VisCommandSceneEndOfRunAction () {
433   delete fpCommand;                               251   delete fpCommand;
434 }                                                 252 }
435                                                   253 
436 G4String G4VisCommandSceneEndOfRunAction::GetC    254 G4String G4VisCommandSceneEndOfRunAction::GetCurrentValue(G4UIcommand*) {
437   return "";                                      255   return "";
438 }                                                 256 }
439                                                   257 
440 void G4VisCommandSceneEndOfRunAction::SetNewVa    258 void G4VisCommandSceneEndOfRunAction::SetNewValue (G4UIcommand*,
441                  G4String newValue) {             259                  G4String newValue) {
442                                                   260 
443   G4VisManager::Verbosity verbosity = fpVisMan    261   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
444                                                   262 
445   G4String action;                                263   G4String action;
446   std::istringstream is (newValue);               264   std::istringstream is (newValue);
447   is >> action;                                   265   is >> action;
448                                                   266 
449   G4Scene* pScene = fpVisManager->GetCurrentSc    267   G4Scene* pScene = fpVisManager->GetCurrentScene();
450   if (!pScene) {                                  268   if (!pScene) {
451     if (verbosity >= G4VisManager::errors) {      269     if (verbosity >= G4VisManager::errors) {
452       G4warn << "ERROR: No current scene.  Ple << 270       G4cout << "ERROR: No current scene.  Please create one." << G4endl;
453     }                                             271     }
454     return;                                       272     return;
455   }                                               273   }
456                                                   274 
457   G4VSceneHandler* pSceneHandler = fpVisManage    275   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
458   if (!pSceneHandler) {                           276   if (!pSceneHandler) {
459     if (verbosity >= G4VisManager::errors) {      277     if (verbosity >= G4VisManager::errors) {
460       G4warn << "ERROR: No current sceneHandle << 278       G4cout << "ERROR: No current sceneHandler.  Please create one." << G4endl;
461     }                                             279     }
462     return;                                       280     return;
463   }                                               281   }
464                                                   282 
465   if (action == "accumulate") {                   283   if (action == "accumulate") {
466     if (pScene->GetRefreshAtEndOfEvent()) {       284     if (pScene->GetRefreshAtEndOfEvent()) {
467       if (verbosity >= G4VisManager::errors) {    285       if (verbosity >= G4VisManager::errors) {
468   G4warn <<                                    << 286   G4cout <<
469     "ERROR: Cannot accumulate runs unless even    287     "ERROR: Cannot accumulate runs unless events accumulate too."
470     "\n  Use \"/vis/scene/endOfEventAction acc    288     "\n  Use \"/vis/scene/endOfEventAction accumulate\"."
471          << G4endl;                               289          << G4endl;
472       }                                           290       }
473     }                                             291     }
474     else {                                        292     else {
475       pScene->SetRefreshAtEndOfRun(false);        293       pScene->SetRefreshAtEndOfRun(false);
476     }                                             294     }
477   }                                               295   }
478   else if (action == "refresh") {                 296   else if (action == "refresh") {
479     pScene->SetRefreshAtEndOfRun(true);           297     pScene->SetRefreshAtEndOfRun(true);
480     pSceneHandler->SetMarkForClearingTransient    298     pSceneHandler->SetMarkForClearingTransientStore(true);
481   }                                               299   }
482   else {                                          300   else {
483     if (verbosity >= G4VisManager::errors) {      301     if (verbosity >= G4VisManager::errors) {
484       G4warn <<                                << 302       G4cout <<
485   "ERROR: unrecognised parameter \"" << action    303   "ERROR: unrecognised parameter \"" << action << "\"."
486              << G4endl;                           304              << G4endl;
487     }                                             305     }
488     return;                                       306     return;
489   }                                               307   }
490                                                   308 
491   // Change of transients behaviour, so...        309   // Change of transients behaviour, so...
492   fpVisManager->ResetTransientsDrawnFlags();      310   fpVisManager->ResetTransientsDrawnFlags();
493                                                   311 
494   if (verbosity >= G4VisManager::confirmations    312   if (verbosity >= G4VisManager::confirmations) {
495     G4cout << "End of run action set to \"";      313     G4cout << "End of run action set to \"";
496     if (pScene->GetRefreshAtEndOfRun()) G4cout    314     if (pScene->GetRefreshAtEndOfRun()) G4cout << "refresh";
497     else G4cout << "accumulate";                  315     else G4cout << "accumulate";
498     G4cout << "\"" << G4endl;                     316     G4cout << "\"" << G4endl;
499   }                                               317   }
                                                   >> 318   UpdateVisManagerScene (pScene->GetName());
500 }                                                 319 }
501                                                   320 
502 ////////////// /vis/scene/list ///////////////    321 ////////////// /vis/scene/list ///////////////////////////////////////
503                                                   322 
504 G4VisCommandSceneList::G4VisCommandSceneList (    323 G4VisCommandSceneList::G4VisCommandSceneList () {
505   G4bool omitable;                                324   G4bool omitable;
506   fpCommand = new G4UIcommand ("/vis/scene/lis    325   fpCommand = new G4UIcommand ("/vis/scene/list", this);
507   fpCommand -> SetGuidance ("Lists scene(s).")    326   fpCommand -> SetGuidance ("Lists scene(s).");
508   fpCommand -> SetGuidance                        327   fpCommand -> SetGuidance
509     ("\"help /vis/verbose\" for definition of     328     ("\"help /vis/verbose\" for definition of verbosity.");
510   G4UIparameter* parameter;                       329   G4UIparameter* parameter;
511   parameter = new G4UIparameter ("scene-name",    330   parameter = new G4UIparameter ("scene-name", 's', omitable = true);
512   parameter -> SetDefaultValue ("all");           331   parameter -> SetDefaultValue ("all");
513   fpCommand -> SetParameter (parameter);          332   fpCommand -> SetParameter (parameter);
514   parameter = new G4UIparameter ("verbosity",     333   parameter = new G4UIparameter ("verbosity", 's', omitable = true);
515   parameter -> SetDefaultValue ("warnings");      334   parameter -> SetDefaultValue ("warnings");
516   fpCommand -> SetParameter (parameter);          335   fpCommand -> SetParameter (parameter);
517 }                                                 336 }
518                                                   337 
519 G4VisCommandSceneList::~G4VisCommandSceneList     338 G4VisCommandSceneList::~G4VisCommandSceneList () {
520   delete fpCommand;                               339   delete fpCommand;
521 }                                                 340 }
522                                                   341 
523 G4String G4VisCommandSceneList::GetCurrentValu    342 G4String G4VisCommandSceneList::GetCurrentValue (G4UIcommand*) {
524   return "";                                      343   return "";
525 }                                                 344 }
526                                                   345 
527 void G4VisCommandSceneList::SetNewValue (G4UIc    346 void G4VisCommandSceneList::SetNewValue (G4UIcommand*, G4String newValue) {
528   G4String name, verbosityString;                 347   G4String name, verbosityString;
529   std::istringstream is (newValue);               348   std::istringstream is (newValue);
530   is >> name >> verbosityString;                  349   is >> name >> verbosityString;
531   G4VisManager::Verbosity verbosity =             350   G4VisManager::Verbosity verbosity =
532     fpVisManager->GetVerbosityValue(verbosityS    351     fpVisManager->GetVerbosityValue(verbosityString);
533   const G4Scene* currentScene = fpVisManager -    352   const G4Scene* currentScene = fpVisManager -> GetCurrentScene ();
534   G4String currentName;                           353   G4String currentName;
535   if (currentScene) currentName = currentScene    354   if (currentScene) currentName = currentScene->GetName();
536                                                   355 
537   G4SceneList& sceneList = fpVisManager -> Set    356   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
538   std::size_t iScene, nScenes = sceneList.size << 357   G4int iScene, nScenes = sceneList.size ();
539   G4bool found = false;                           358   G4bool found = false;
540   for (iScene = 0; iScene < nScenes; ++iScene) << 359   for (iScene = 0; iScene < nScenes; iScene++) {
541     G4Scene* pScene = sceneList [iScene];         360     G4Scene* pScene = sceneList [iScene];
542     const G4String& iName = pScene -> GetName     361     const G4String& iName = pScene -> GetName ();
543     if (name != "all") {                          362     if (name != "all") {
544       if (name != iName) continue;                363       if (name != iName) continue;
545     }                                             364     }
546     found = true;                                 365     found = true;
547     if (iName == currentName) {                   366     if (iName == currentName) {
548       G4cout << "  (current)";                    367       G4cout << "  (current)";
549     }                                             368     }
550     else {                                        369     else {
551       G4cout << "           ";                    370       G4cout << "           ";
552     }                                             371     }
553     G4cout << " scene \"" << iName << "\"";       372     G4cout << " scene \"" << iName << "\"";
554     if (verbosity >= G4VisManager::warnings) { << 373     if (verbosity >= G4VisManager::confirmations) {
555       std::size_t i;                           << 374       G4int i;
556       G4cout << "\n  Run-duration models:";       375       G4cout << "\n  Run-duration models:";
557       std::size_t nRunModels = pScene -> GetRu << 376       G4int nRunModels = pScene -> GetRunDurationModelList ().size ();
558       if (nRunModels == 0) {                      377       if (nRunModels == 0) {
559   G4cout << " none.";                             378   G4cout << " none.";
560       }                                           379       }
561       for (i = 0; i < nRunModels; ++i) {       << 380       for (i = 0; i < nRunModels; i++) {
562   if (pScene -> GetRunDurationModelList()[i].f << 381   G4VModel* pModel = pScene -> GetRunDurationModelList () [i];
563     G4cout << "\n   Active:   ";               << 382   G4cout << "\n    " << pModel -> GetGlobalDescription ();
564   else G4cout << "\n   Inactive: ";            << 
565   G4VModel* pModel = pScene -> GetRunDurationM << 
566   G4cout << pModel -> GetGlobalDescription (); << 
567       }                                           383       }
568       G4cout << "\n  End-of-event models:";       384       G4cout << "\n  End-of-event models:";
569       std::size_t nEOEModels = pScene -> GetEn << 385       G4int nEOEModels = pScene -> GetEndOfEventModelList ().size ();
570       if (nEOEModels == 0) {                      386       if (nEOEModels == 0) {
571   G4cout << " none.";                             387   G4cout << " none.";
572       }                                           388       }
573       for (i = 0; i < nEOEModels; ++i) {       << 389       for (i = 0; i < nEOEModels; i++) {
574   if (pScene -> GetEndOfEventModelList()[i].fA << 390   G4VModel* pModel = pScene -> GetEndOfEventModelList () [i];
575     G4cout << "\n   Active:   ";               << 391   G4cout << "\n    " << pModel -> GetGlobalDescription ();
576   else G4cout << "\n   Inactive: ";            << 
577   G4VModel* pModel = pScene -> GetEndOfEventMo << 
578   G4cout << pModel -> GetGlobalDescription (); << 
579       }                                        << 
580       G4cout << "\n  End-of-run models:";      << 
581       std::size_t nEORModels = pScene -> GetEn << 
582       if (nEORModels == 0) {                   << 
583   G4cout << " none.";                          << 
584       }                                        << 
585       for (i = 0; i < nEORModels; ++i) {       << 
586   if (pScene -> GetEndOfRunModelList()[i].fAct << 
587     G4cout << "\n   Active:   ";               << 
588   else G4cout << "\n   Inactive: ";            << 
589   G4VModel* pModel = pScene -> GetEndOfRunMode << 
590   G4cout << pModel -> GetGlobalDescription (); << 
591       }                                           392       }
592     }                                             393     }
593     if (verbosity >= G4VisManager::parameters)    394     if (verbosity >= G4VisManager::parameters) {
594       G4cout << "\n  " << *sceneList [iScene];    395       G4cout << "\n  " << *sceneList [iScene];
595     }                                             396     }
596     G4cout << G4endl;                             397     G4cout << G4endl;
597   }                                               398   }
598   if (!found) {                                   399   if (!found) {
599     G4warn << "No scenes found";               << 400     G4cout << "No scenes found";
600     if (name != "all") {                          401     if (name != "all") {
601       G4warn << " of name \"" << name << "\""; << 402       G4cout << " of name \"" << name << "\"";
602     }                                             403     }
603     G4warn << "." << G4endl;                   << 404     G4cout << "." << G4endl;
604   }                                               405   }
605 }                                                 406 }
606                                                   407 
607 ////////////// /vis/scene/notifyHandlers /////    408 ////////////// /vis/scene/notifyHandlers /////////////////////////
608                                                   409 
609 G4VisCommandSceneNotifyHandlers::G4VisCommandS    410 G4VisCommandSceneNotifyHandlers::G4VisCommandSceneNotifyHandlers () {
610   G4bool omitable;                                411   G4bool omitable;
611   fpCommand = new G4UIcommand ("/vis/scene/not    412   fpCommand = new G4UIcommand ("/vis/scene/notifyHandlers", this);
612   fpCommand -> SetGuidance                        413   fpCommand -> SetGuidance
613     ("Notifies scene handlers and forces re-re    414     ("Notifies scene handlers and forces re-rendering.");
614   fpCommand -> SetGuidance                        415   fpCommand -> SetGuidance
615     ("Notifies the handler(s) of the specified    416     ("Notifies the handler(s) of the specified scene and forces a"
616      "\nreconstruction of any graphical databa    417      "\nreconstruction of any graphical databases."
617      "\nClears and refreshes all viewers of cu    418      "\nClears and refreshes all viewers of current scene."
618      "\n  The default action \"refresh\" does     419      "\n  The default action \"refresh\" does not issue \"update\" (see"
619      "\n    /vis/viewer/update)."                 420      "\n    /vis/viewer/update)."
620      "\nIf \"flush\" is specified, it issues a    421      "\nIf \"flush\" is specified, it issues an \"update\" as well as"
621      "\n  \"refresh\" - \"update\" and initiat    422      "\n  \"refresh\" - \"update\" and initiates post-processing"
622      "\n  for graphics systems which need it."    423      "\n  for graphics systems which need it.");
623   fpCommand -> SetGuidance                        424   fpCommand -> SetGuidance 
624     ("The default for <scene-name> is the curr    425     ("The default for <scene-name> is the current scene name.");
625   fpCommand -> SetGuidance                        426   fpCommand -> SetGuidance
626     ("This command does not change current sce    427     ("This command does not change current scene, scene handler or viewer.");
627   G4UIparameter* parameter;                       428   G4UIparameter* parameter;
628   parameter = new G4UIparameter ("scene-name",    429   parameter = new G4UIparameter ("scene-name", 's',
629          omitable = true);                        430          omitable = true);
630   parameter -> SetCurrentAsDefault(true);         431   parameter -> SetCurrentAsDefault(true);
631   fpCommand -> SetParameter (parameter);          432   fpCommand -> SetParameter (parameter);
632   parameter = new G4UIparameter ("refresh-flus    433   parameter = new G4UIparameter ("refresh-flush", 's',
633          omitable = true);                        434          omitable = true);
634   parameter -> SetDefaultValue("refresh");        435   parameter -> SetDefaultValue("refresh");
635   parameter -> SetParameterCandidates("r refre    436   parameter -> SetParameterCandidates("r refresh f flush");
636   fpCommand -> SetParameter (parameter);          437   fpCommand -> SetParameter (parameter);
637 }                                                 438 }
638                                                   439 
639 G4VisCommandSceneNotifyHandlers::~G4VisCommand    440 G4VisCommandSceneNotifyHandlers::~G4VisCommandSceneNotifyHandlers () {
640   delete fpCommand;                               441   delete fpCommand;
641 }                                                 442 }
642                                                   443 
643 G4String G4VisCommandSceneNotifyHandlers::GetC    444 G4String G4VisCommandSceneNotifyHandlers::GetCurrentValue(G4UIcommand*) {
644   return CurrentSceneName ();                     445   return CurrentSceneName ();
645 }                                                 446 }
646                                                   447 
647 void G4VisCommandSceneNotifyHandlers::SetNewVa    448 void G4VisCommandSceneNotifyHandlers::SetNewValue (G4UIcommand*,
648                G4String newValue) {               449                G4String newValue) {
649                                                   450 
650   G4VisManager::Verbosity verbosity = fpVisMan    451   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
651                                                   452 
652   G4String sceneName, refresh_flush;              453   G4String sceneName, refresh_flush;
653   std::istringstream is (newValue);               454   std::istringstream is (newValue);
654   is >> sceneName >> refresh_flush;               455   is >> sceneName >> refresh_flush;
655   G4bool flush = false;                           456   G4bool flush = false;
656   if (refresh_flush[0] == 'f') flush = true;   << 457   if (refresh_flush(0) == 'f') flush = true;
657                                                   458 
658   const G4SceneList& sceneList = fpVisManager     459   const G4SceneList& sceneList = fpVisManager -> GetSceneList ();
659   G4SceneHandlerList& sceneHandlerList =          460   G4SceneHandlerList& sceneHandlerList =
660     fpVisManager -> SetAvailableSceneHandlers     461     fpVisManager -> SetAvailableSceneHandlers ();
661                                                   462 
662   // Check scene name.                            463   // Check scene name.
663   const std::size_t nScenes = sceneList.size ( << 464   const G4int nScenes = sceneList.size ();
664   std::size_t iScene;                          << 465   G4int iScene;
665   for (iScene = 0; iScene < nScenes; ++iScene) << 466   for (iScene = 0; iScene < nScenes; iScene++) {
666     G4Scene* scene = sceneList [iScene];          467     G4Scene* scene = sceneList [iScene];
667     if (sceneName == scene -> GetName ()) brea    468     if (sceneName == scene -> GetName ()) break;
668   }                                               469   }
669   if (iScene >= nScenes ) {                       470   if (iScene >= nScenes ) {
670     if (verbosity >= G4VisManager::warnings) {    471     if (verbosity >= G4VisManager::warnings) {
671       G4warn << "WARNING: Scene \"" << sceneNa << 472       G4cout << "WARNING: Scene \"" << sceneName << "\" not found."
672   "\n  /vis/scene/list to see scenes."            473   "\n  /vis/scene/list to see scenes."
673        << G4endl;                                 474        << G4endl;
674     }                                             475     }
675     return;                                       476     return;
676   }                                               477   }
677                                                   478 
678   // Store current context...                     479   // Store current context...
679   G4VSceneHandler* pCurrentSceneHandler =         480   G4VSceneHandler* pCurrentSceneHandler =
680     fpVisManager -> GetCurrentSceneHandler();     481     fpVisManager -> GetCurrentSceneHandler();
681   if (!pCurrentSceneHandler) {                 << 
682     if (verbosity >= G4VisManager::warnings) { << 
683       G4warn << "WARNING: No current scene han << 
684        << G4endl;                              << 
685     }                                          << 
686     return;                                    << 
687   }                                            << 
688   G4VViewer* pCurrentViewer = fpVisManager ->     482   G4VViewer* pCurrentViewer = fpVisManager -> GetCurrentViewer();
689   if (!pCurrentViewer) {                       << 
690     if (verbosity >= G4VisManager::warnings) { << 
691       G4warn << "WARNING: No current viewer."  << 
692        << G4endl;                              << 
693     }                                          << 
694     return;                                    << 
695   }                                            << 
696   G4Scene* pCurrentScene = fpVisManager -> Get    483   G4Scene* pCurrentScene = fpVisManager -> GetCurrentScene();
697   if (!pCurrentScene) {                        << 
698     if (verbosity >= G4VisManager::warnings) { << 
699       G4warn << "WARNING: No current scene."   << 
700        << G4endl;                              << 
701     }                                          << 
702     return;                                    << 
703   }                                            << 
704                                                << 
705   G4VisManager::Verbosity currentVerbosity = f    484   G4VisManager::Verbosity currentVerbosity = fpVisManager -> GetVerbosity();
706                                                   485 
707   // Suppress messages during this process (on    486   // Suppress messages during this process (only print errors)...
708   //fpVisManager -> SetVerboseLevel(G4VisManag    487   //fpVisManager -> SetVerboseLevel(G4VisManager::errors);
709                                                   488 
710   // For each scene handler, if it contains th    489   // For each scene handler, if it contains the scene, clear and
711   // rebuild the graphical database, then for     490   // rebuild the graphical database, then for each viewer set (make
712   // current), clear, (re)draw, and show.         491   // current), clear, (re)draw, and show.
713   const std::size_t nSceneHandlers = sceneHand << 492   const G4int nSceneHandlers = sceneHandlerList.size ();
714   for (std::size_t iSH = 0; iSH < nSceneHandle << 493   for (G4int iSH = 0; iSH < nSceneHandlers; iSH++) {
715     G4VSceneHandler* aSceneHandler = sceneHand    494     G4VSceneHandler* aSceneHandler = sceneHandlerList [iSH];
716     G4Scene* aScene = aSceneHandler -> GetScen    495     G4Scene* aScene = aSceneHandler -> GetScene ();
717     if (aScene) {                                 496     if (aScene) {
718       const G4String& aSceneName = aScene -> G    497       const G4String& aSceneName = aScene -> GetName ();
719       if (sceneName == aSceneName) {              498       if (sceneName == aSceneName) {
720   aScene->CalculateExtent();  // Check and rec << 499   // Clear store and force a rebuild of graphical database...
                                                   >> 500   //aSceneHandler -> ClearStore (); // Not nec??  Done below
                                                   >> 501   //with NeedKernelVisit and DrawView.  JA.
721   G4ViewerList& viewerList = aSceneHandler ->     502   G4ViewerList& viewerList = aSceneHandler -> SetViewerList ();
722   const std::size_t nViewers = viewerList.size << 503   const G4int nViewers = viewerList.size ();
723   for (std::size_t iV = 0; iV < nViewers; ++iV << 504   for (G4int iV = 0; iV < nViewers; iV++) {
724     G4VViewer* aViewer = viewerList [iV];         505     G4VViewer* aViewer = viewerList [iV];
725     // Force rebuild of graphical database, if << 
726     aViewer -> NeedKernelVisit();              << 
727     if (aViewer->GetViewParameters().IsAutoRef    506     if (aViewer->GetViewParameters().IsAutoRefresh()) {
728       aSceneHandler -> SetCurrentViewer (aView    507       aSceneHandler -> SetCurrentViewer (aViewer);
729       // Ensure consistency of vis manager...     508       // Ensure consistency of vis manager...
730       fpVisManager -> SetCurrentViewer(aViewer    509       fpVisManager -> SetCurrentViewer(aViewer);
731       fpVisManager -> SetCurrentSceneHandler(a    510       fpVisManager -> SetCurrentSceneHandler(aSceneHandler);
732       fpVisManager -> SetCurrentScene(aScene);    511       fpVisManager -> SetCurrentScene(aScene);
                                                   >> 512       // Re-draw, forcing rebuild of graphics database, if any...
                                                   >> 513       aViewer -> NeedKernelVisit();
733       aViewer -> SetView ();                      514       aViewer -> SetView ();
734       aViewer -> ClearView ();                    515       aViewer -> ClearView ();
735       aViewer -> DrawView ();                     516       aViewer -> DrawView ();
736       if (flush) aViewer -> ShowView ();          517       if (flush) aViewer -> ShowView ();
737       if (verbosity >= G4VisManager::confirmat    518       if (verbosity >= G4VisManager::confirmations) {
738         G4cout << "Viewer \"" << aViewer -> Ge    519         G4cout << "Viewer \"" << aViewer -> GetName ()
739          << "\" of scene handler \"" << aScene    520          << "\" of scene handler \"" << aSceneHandler -> GetName ()
740          << "\"\n  ";                             521          << "\"\n  ";
741         if (flush) G4cout << "flushed";           522         if (flush) G4cout << "flushed";
742         else G4cout << "refreshed";               523         else G4cout << "refreshed";
743         G4cout << " at request of scene \"" <<    524         G4cout << " at request of scene \"" << sceneName
744          << "\"." << G4endl;                      525          << "\"." << G4endl;
745       }                                           526       }
746     } else {                                      527     } else {
747       if (verbosity >= G4VisManager::confirmat << 528       if (verbosity >= G4VisManager::warnings) {
748         G4cout << "NOTE: The scene, \""        << 529         G4cout << "WARNING: The scene, \""
749          << sceneName                             530          << sceneName
750          << "\", of viewer \""                    531          << "\", of viewer \""
751          << aViewer -> GetName ()                 532          << aViewer -> GetName ()
752          << "\"\n  of scene handler \""           533          << "\"\n  of scene handler \""
753          << aSceneHandler -> GetName ()           534          << aSceneHandler -> GetName ()
754          << "\"  has changed.  To see effect,"    535          << "\"  has changed.  To see effect,"
755          << "\n  \"/vis/viewer/select "           536          << "\n  \"/vis/viewer/select "
756          << aViewer -> GetShortName ()            537          << aViewer -> GetShortName ()
757          << "\" and \"/vis/viewer/rebuild\"."     538          << "\" and \"/vis/viewer/rebuild\"."
758          << G4endl;                               539          << G4endl;
759       }                                           540       }
760     }                                             541     }
761   }                                               542   }
762       }                                           543       }
763     }                                             544     }
764     else {                                        545     else {
765       if (verbosity >= G4VisManager::warnings)    546       if (verbosity >= G4VisManager::warnings) {
766   G4warn << "WARNING: G4VisCommandSceneNotifyH << 547   G4cout << "WARNING: G4VisCommandSceneNotifyHandlers: scene handler \""
767          << aSceneHandler->GetName()              548          << aSceneHandler->GetName()
768          << "\" has a null scene."                549          << "\" has a null scene."
769          << G4endl;                               550          << G4endl;
770       }                                           551       }
771     }                                             552     }
772   }                                               553   }
773                                                   554 
774   // Reclaim original context - but set viewer    555   // Reclaim original context - but set viewer first, then scene
775   // handler, because the latter might have be    556   // handler, because the latter might have been created very recently
776   // and, not yet having a viewer, the current    557   // and, not yet having a viewer, the current viewer will,
777   // temporarily, refer to another scene handl    558   // temporarily, refer to another scene handler.  SetCurrentViewer
778   // actually resets the scene handler, which     559   // actually resets the scene handler, which is what we don't want,
779   // so we set it again on the next line...       560   // so we set it again on the next line...
780   fpVisManager -> SetCurrentViewer(pCurrentVie    561   fpVisManager -> SetCurrentViewer(pCurrentViewer);
781   fpVisManager -> SetCurrentSceneHandler(pCurr    562   fpVisManager -> SetCurrentSceneHandler(pCurrentSceneHandler);
782   fpVisManager -> SetCurrentScene(pCurrentScen    563   fpVisManager -> SetCurrentScene(pCurrentScene);
783   fpVisManager -> SetVerboseLevel(currentVerbo    564   fpVisManager -> SetVerboseLevel(currentVerbosity);
784   // Take care of special case of scene handle    565   // Take care of special case of scene handler with no viewer yet.  
785   if (pCurrentSceneHandler) {                     566   if (pCurrentSceneHandler) {
786     G4ViewerList& viewerList = pCurrentSceneHa    567     G4ViewerList& viewerList = pCurrentSceneHandler -> SetViewerList ();
787     const std::size_t nViewers = viewerList.si << 568     const G4int nViewers = viewerList.size ();
788     if (nViewers) {                               569     if (nViewers) {
789       pCurrentSceneHandler -> SetCurrentViewer    570       pCurrentSceneHandler -> SetCurrentViewer (pCurrentViewer);
790       // JA: I don't think we need this. SetVi << 571       if (pCurrentViewer && pCurrentSceneHandler->GetScene()) {
791       // if (pCurrentViewer && pCurrentSceneHa << 572   pCurrentViewer -> SetView ();
792       //   pCurrentViewer -> SetView ();       << 
793       // }                                     << 
794     }                                          << 
795   }                                            << 
796 }                                              << 
797                                                << 
798 ////////////// /vis/scene/removeModel //////// << 
799                                                << 
800 G4VisCommandSceneRemoveModel::G4VisCommandScen << 
801   G4bool omitable;                             << 
802   fpCommand = new G4UIcommand ("/vis/scene/rem << 
803   fpCommand -> SetGuidance("Remove model.");   << 
804   fpCommand -> SetGuidance                     << 
805   ("Attempts to match search string to name of << 
806   fpCommand -> SetGuidance                     << 
807   ("Use \"/vis/scene/list\" to see model names << 
808   G4UIparameter* parameter;                    << 
809   parameter = new G4UIparameter ("search-strin << 
810   fpCommand -> SetParameter (parameter);       << 
811 }                                              << 
812                                                << 
813 G4VisCommandSceneRemoveModel::~G4VisCommandSce << 
814   delete fpCommand;                            << 
815 }                                              << 
816                                                << 
817 G4String G4VisCommandSceneRemoveModel::GetCurr << 
818   return "";                                   << 
819 }                                              << 
820                                                << 
821 void G4VisCommandSceneRemoveModel::SetNewValue << 
822               G4String newValue) {             << 
823                                                << 
824   G4VisManager::Verbosity verbosity = fpVisMan << 
825                                                << 
826   G4String searchString;                       << 
827   std::istringstream is (newValue);            << 
828   is >> searchString;                          << 
829                                                << 
830   G4Scene* pScene = fpVisManager->GetCurrentSc << 
831   if (!pScene) {                               << 
832     if (verbosity >= G4VisManager::errors) {   << 
833       G4warn << "ERROR: No current scene.  Ple << 
834     }                                          << 
835     return;                                    << 
836   }                                            << 
837                                                << 
838   G4VSceneHandler* pSceneHandler = fpVisManage << 
839   if (!pSceneHandler) {                        << 
840     if (verbosity >= G4VisManager::errors) {   << 
841       G4warn << "ERROR: No current sceneHandle << 
842     }                                          << 
843     return;                                    << 
844   }                                            << 
845                                                << 
846   G4bool any = false;                          << 
847                                                << 
848   std::vector<G4Scene::Model>& runDurationMode << 
849   pScene->SetRunDurationModelList();           << 
850   for (size_t i = 0; i < runDurationModelList. << 
851     const G4String& modelName =                << 
852     runDurationModelList[i].fpModel->GetGlobal << 
853     if (modelName.find(searchString) != std::s << 
854       runDurationModelList.erase(runDurationMo << 
855       any = true;                              << 
856       if (verbosity >= G4VisManager::warnings) << 
857   G4warn << "Model \"" << modelName << "\" rem << 
858       }                                           573       }
859       break;  // Allow only one model at a tim << 
860     }                                             574     }
861   }                                               575   }
862                                                << 
863   std::vector<G4Scene::Model>& endOfEventModel << 
864   pScene->SetEndOfEventModelList();            << 
865   for (size_t i = 0; i < endOfEventModelList.s << 
866     const G4String& modelName =                << 
867     endOfEventModelList[i].fpModel->GetGlobalD << 
868     if (modelName.find(searchString) != std::s << 
869       endOfEventModelList.erase(endOfEventMode << 
870       any = true;                              << 
871       if (verbosity >= G4VisManager::warnings) << 
872   G4warn << "Model \"" << modelName << "\" rem << 
873       }                                        << 
874       break;  // Allow only one model at a tim << 
875     }                                          << 
876   }                                            << 
877                                                << 
878   std::vector<G4Scene::Model>& endOfRunModelLi << 
879   pScene->SetEndOfRunModelList();              << 
880   for (size_t i = 0; i < endOfRunModelList.siz << 
881     const G4String& modelName =                << 
882     endOfRunModelList[i].fpModel->GetGlobalDes << 
883     if (modelName.find(searchString) != std::s << 
884       endOfRunModelList.erase(endOfRunModelLis << 
885       any = true;                              << 
886       if (verbosity >= G4VisManager::warnings) << 
887   G4warn << "Model \"" << modelName << "\" rem << 
888       }                                        << 
889       break;  // Allow only one model at a tim << 
890     }                                          << 
891   }                                            << 
892                                                << 
893   if (!any) {                                  << 
894     if (verbosity >= G4VisManager::warnings) { << 
895       G4warn << "WARNING: No match found." <<  << 
896     }                                          << 
897     return;                                    << 
898   }                                            << 
899                                                << 
900   CheckSceneAndNotifyHandlers (pScene);        << 
901 }                                                 576 }
902                                                   577 
903 ////////////// /vis/scene/select /////////////    578 ////////////// /vis/scene/select ///////////////////////////////////////
904                                                   579 
905 G4VisCommandSceneSelect::G4VisCommandSceneSele    580 G4VisCommandSceneSelect::G4VisCommandSceneSelect () {
906   G4bool omitable;                                581   G4bool omitable;
907   fpCommand = new G4UIcmdWithAString ("/vis/sc    582   fpCommand = new G4UIcmdWithAString ("/vis/scene/select", this);
908   fpCommand -> SetGuidance ("Selects a scene")    583   fpCommand -> SetGuidance ("Selects a scene");
909   fpCommand -> SetGuidance                     << 584   fpCommand -> SetGuidance 
910   ("Makes the scene current.  \"/vis/scene/lis << 585     ("Makes the scene current.  \"/vis/scene/list\" to see"
911    "\n possible scene names.");                << 586      "\n possible scene names.");
912   fpCommand -> SetParameterName ("scene-name",    587   fpCommand -> SetParameterName ("scene-name", omitable = false);
913 }                                                 588 }
914                                                   589 
915 G4VisCommandSceneSelect::~G4VisCommandSceneSel    590 G4VisCommandSceneSelect::~G4VisCommandSceneSelect () {
916   delete fpCommand;                               591   delete fpCommand;
917 }                                                 592 }
918                                                   593 
919 G4String G4VisCommandSceneSelect::GetCurrentVa    594 G4String G4VisCommandSceneSelect::GetCurrentValue (G4UIcommand*) {
920   return "";                                      595   return "";
921 }                                                 596 }
922                                                   597 
923 void G4VisCommandSceneSelect::SetNewValue (G4U    598 void G4VisCommandSceneSelect::SetNewValue (G4UIcommand*, G4String newValue) {
924                                                   599 
925   G4VisManager::Verbosity verbosity = fpVisMan    600   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
926                                                   601 
927   G4String& selectName = newValue;                602   G4String& selectName = newValue;
928   G4SceneList& sceneList = fpVisManager -> Set    603   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
929   std::size_t iScene, nScenes = sceneList.size << 604   G4int iScene, nScenes = sceneList.size ();
930   for (iScene = 0; iScene < nScenes; ++iScene) << 605   for (iScene = 0; iScene < nScenes; iScene++) {
931     if (sceneList [iScene] -> GetName () == se    606     if (sceneList [iScene] -> GetName () == selectName) break;
932   }                                               607   }
933   if (iScene >= nScenes) {                        608   if (iScene >= nScenes) {
934     if (verbosity >= G4VisManager::warnings) {    609     if (verbosity >= G4VisManager::warnings) {
935       G4warn << "WARNING: Scene \"" << selectN << 610       G4cout << "WARNING: Scene \"" << selectName
936       << "\" not found - \"/vis/scene/list\" t << 611        << "\" not found - \"/vis/scene/list\" to see possibilities."
937       << G4endl;                               << 612        << G4endl;
938     }                                             613     }
939     return;                                       614     return;
940   }                                               615   }
941                                                   616 
942   if (verbosity >= G4VisManager::confirmations    617   if (verbosity >= G4VisManager::confirmations) {
943     G4cout << "Scene \"" << selectName            618     G4cout << "Scene \"" << selectName
944     << "\" selected." << G4endl;               << 619      << "\" selected." << G4endl;
945   }                                            << 
946                                                << 
947   CheckSceneAndNotifyHandlers (sceneList [iSce << 
948 }                                              << 
949                                                << 
950 ////////////// /vis/scene/showExtents //////// << 
951                                                << 
952 G4VisCommandSceneShowExtents::G4VisCommandScen << 
953   fpCommand = new G4UIcmdWithoutParameter ("/v << 
954   fpCommand -> SetGuidance ("Prints and draws  << 
955 }                                              << 
956                                                << 
957 G4VisCommandSceneShowExtents::~G4VisCommandSce << 
958   delete fpCommand;                            << 
959 }                                              << 
960                                                << 
961 G4String G4VisCommandSceneShowExtents::GetCurr << 
962   return "";                                   << 
963 }                                              << 
964                                                << 
965 void G4VisCommandSceneShowExtents::SetNewValue << 
966                                                << 
967   G4VisManager::Verbosity verbosity = fpVisMan << 
968                                                << 
969   G4VSceneHandler* pCurrentSceneHandler =      << 
970   fpVisManager -> GetCurrentSceneHandler();    << 
971   if (!pCurrentSceneHandler) {                 << 
972     if (verbosity >= G4VisManager::warnings) { << 
973       G4warn << "WARNING: No current scene han << 
974       << G4endl;                               << 
975     }                                          << 
976     return;                                    << 
977   }                                            << 
978   G4VViewer* pCurrentViewer = fpVisManager ->  << 
979   if (!pCurrentViewer) {                       << 
980     if (verbosity >= G4VisManager::warnings) { << 
981       G4warn << "WARNING: No current viewer."  << 
982       << G4endl;                               << 
983     }                                          << 
984     return;                                    << 
985   }                                               620   }
986   G4Scene* pCurrentScene = fpVisManager -> Get << 621   UpdateVisManagerScene (selectName);
987   if (!pCurrentScene) {                        << 
988     if (verbosity >= G4VisManager::warnings) { << 
989       G4warn << "WARNING: No current scene."   << 
990       << G4endl;                               << 
991     }                                          << 
992     return;                                    << 
993   }                                            << 
994                                                << 
995   G4cout << "\n  Run-duration models:";        << 
996   std::size_t nRunModels = pCurrentScene -> Ge << 
997   if (nRunModels == 0) {                       << 
998     G4cout << " none.";                        << 
999   }                                            << 
1000   for (std::size_t i = 0; i < nRunModels; ++i << 
1001     if (pCurrentScene -> GetRunDurationModelL << 
1002       G4cout << "\n   Active:   ";            << 
1003     else G4cout << "\n   Inactive: ";         << 
1004     G4VModel* pModel = pCurrentScene -> GetRu << 
1005     const G4VisExtent& transformedExtent = pM << 
1006     G4cout << pModel -> GetGlobalDescription  << 
1007     << "\n" << transformedExtent;             << 
1008     DrawExtent(transformedExtent);            << 
1009   }                                           << 
1010   G4cout << "\n  End-of-event models:";       << 
1011   std::size_t nEOEModels = pCurrentScene -> G << 
1012   if (nEOEModels == 0) {                      << 
1013     G4cout << " none.";                       << 
1014   }                                           << 
1015   for (std::size_t i = 0; i < nEOEModels; ++i << 
1016     if (pCurrentScene -> GetEndOfEventModelLi << 
1017       G4cout << "\n   Active:   ";            << 
1018     else G4cout << "\n   Inactive: ";         << 
1019     G4VModel* pModel = pCurrentScene -> GetEn << 
1020     const G4VisExtent& transformedExtent = pM << 
1021     G4cout << pModel -> GetGlobalDescription  << 
1022     << "\n" << transformedExtent;             << 
1023     DrawExtent(transformedExtent);            << 
1024   }                                           << 
1025   G4cout << "\n  End-of-run models:";         << 
1026   std::size_t nEORModels = pCurrentScene -> G << 
1027   if (nEORModels == 0) {                      << 
1028     G4cout << " none.";                       << 
1029   }                                           << 
1030   for (std::size_t i = 0; i < nEORModels; ++i << 
1031     if (pCurrentScene -> GetEndOfRunModelList << 
1032       G4cout << "\n   Active:   ";            << 
1033     else G4cout << "\n   Inactive: ";         << 
1034     G4VModel* pModel = pCurrentScene -> GetEn << 
1035     const G4VisExtent& transformedExtent = pM << 
1036     G4cout << pModel -> GetGlobalDescription  << 
1037     << "\n" << transformedExtent;             << 
1038     DrawExtent(transformedExtent);            << 
1039   }                                           << 
1040   G4cout << "\n  Overall extent:\n";          << 
1041   DrawExtent(pCurrentScene->GetExtent());     << 
1042   G4cout << G4endl;                           << 
1043 }                                                622 }
1044                                                  623