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 9.1.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.67 2007/11/10 15:03:56 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-01-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"                         36 #include "G4RunManager.hh"
 35 #include "G4RunManagerFactory.hh"              << 
 36 #include "G4Run.hh"                                37 #include "G4Run.hh"
 37 #include "G4PhysicalVolumeModel.hh"                38 #include "G4PhysicalVolumeModel.hh"
 38 #include "G4ApplicationState.hh"                   39 #include "G4ApplicationState.hh"
 39 #include "G4UImanager.hh"                          40 #include "G4UImanager.hh"
 40 #include "G4UIcommand.hh"                          41 #include "G4UIcommand.hh"
 41 #include "G4UIcmdWithAString.hh"                   42 #include "G4UIcmdWithAString.hh"
 42 #include "G4UIcmdWithoutParameter.hh"          << 
 43 #include "G4ios.hh"                                43 #include "G4ios.hh"
 44 #include <sstream>                                 44 #include <sstream>
 45                                                    45 
 46 #define G4warn G4cout                          << 
 47                                                << 
 48 G4VVisCommandScene::G4VVisCommandScene () {}       46 G4VVisCommandScene::G4VVisCommandScene () {}
 49                                                    47 
 50 G4VVisCommandScene::~G4VVisCommandScene () {}      48 G4VVisCommandScene::~G4VVisCommandScene () {}
 51                                                    49 
 52 G4String G4VVisCommandScene::CurrentSceneName      50 G4String G4VVisCommandScene::CurrentSceneName () {
 53   const G4Scene* pScene = fpVisManager -> GetC     51   const G4Scene* pScene = fpVisManager -> GetCurrentScene ();
 54   G4String currentSceneName = "none";          <<  52   G4String currentSceneName;
 55   if (pScene) currentSceneName = pScene -> Get     53   if (pScene) currentSceneName = pScene -> GetName ();
 56   return currentSceneName;                         54   return currentSceneName;
 57 }                                                  55 }
 58                                                    56 
 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 /////////////     57 ////////////// /vis/scene/create ///////////////////////////////////////
213                                                    58 
214 G4VisCommandSceneCreate::G4VisCommandSceneCrea     59 G4VisCommandSceneCreate::G4VisCommandSceneCreate (): fId (0) {
215   G4bool omitable;                                 60   G4bool omitable;
216   fpCommand = new G4UIcmdWithAString ("/vis/sc     61   fpCommand = new G4UIcmdWithAString ("/vis/scene/create", this);
217   fpCommand -> SetGuidance                         62   fpCommand -> SetGuidance
218     ("Creates an empty scene.");                   63     ("Creates an empty scene.");
219   fpCommand -> SetGuidance                         64   fpCommand -> SetGuidance
220     ("Invents a name if not supplied.  This sc     65     ("Invents a name if not supplied.  This scene becomes current.");
221   fpCommand -> SetParameterName ("scene-name",     66   fpCommand -> SetParameterName ("scene-name", omitable = true);
222 }                                                  67 }
223                                                    68 
224 G4VisCommandSceneCreate::~G4VisCommandSceneCre     69 G4VisCommandSceneCreate::~G4VisCommandSceneCreate () {
225   delete fpCommand;                                70   delete fpCommand;
226 }                                                  71 }
227                                                    72 
228 G4String G4VisCommandSceneCreate::NextName ()      73 G4String G4VisCommandSceneCreate::NextName () {
229   std::ostringstream oss;                          74   std::ostringstream oss;
230   oss << "scene-" << fId;                          75   oss << "scene-" << fId;
231   return oss.str();                                76   return oss.str();
232 }                                                  77 }
233                                                    78 
234 G4String G4VisCommandSceneCreate::GetCurrentVa     79 G4String G4VisCommandSceneCreate::GetCurrentValue (G4UIcommand*) {
235   return "";                                       80   return "";
236 }                                                  81 }
237                                                    82 
238 void G4VisCommandSceneCreate::SetNewValue (G4U     83 void G4VisCommandSceneCreate::SetNewValue (G4UIcommand*, G4String newValue) {
239                                                    84 
240   G4VisManager::Verbosity verbosity = fpVisMan     85   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
241                                                    86 
242   G4String& newName = newValue;                    87   G4String& newName = newValue;
243   G4String nextName = NextName ();                 88   G4String nextName = NextName ();
244                                                    89 
245   if (newName == "") {                             90   if (newName == "") {
246     newName = nextName;                            91     newName = nextName;
247   }                                                92   }
248   if (newName == nextName) fId++;                  93   if (newName == nextName) fId++;
249                                                    94 
250   G4SceneList& sceneList = fpVisManager -> Set     95   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
251   std::size_t iScene, nScenes = sceneList.size <<  96   G4int iScene, nScenes = sceneList.size ();
252   for (iScene = 0; iScene < nScenes; ++iScene) <<  97   for (iScene = 0; iScene < nScenes; iScene++) {
253     if (sceneList [iScene] -> GetName () == ne     98     if (sceneList [iScene] -> GetName () == newName) break;
254   }                                                99   }
255   if (iScene < nScenes) {                         100   if (iScene < nScenes) {
256     if (verbosity >= G4VisManager::warnings) {    101     if (verbosity >= G4VisManager::warnings) {
257       G4warn << "WARNING: Scene \"" << newName << 102       G4cout << "WARNING: Scene \"" << newName << "\" already exists."
258        << "\n  New scene not created."            103        << "\n  New scene not created."
259        << G4endl;                                 104        << G4endl;
260     }                                             105     }
261   } else {                                        106   } else {
262                                                   107 
263     // Add empty scene data object to list...     108     // Add empty scene data object to list...
264     G4Scene* pScene = new G4Scene (newName);      109     G4Scene* pScene = new G4Scene (newName);
265     sceneList.push_back (pScene);                 110     sceneList.push_back (pScene);
266     fpVisManager -> SetCurrentScene (pScene);     111     fpVisManager -> SetCurrentScene (pScene);
267                                                   112 
268     if (verbosity >= G4VisManager::confirmatio    113     if (verbosity >= G4VisManager::confirmations) {
269       G4cout << "New empty scene \"" << newNam    114       G4cout << "New empty scene \"" << newName << "\" created." << G4endl;
270     }                                             115     }
271   }                                               116   }
272 }                                                 117 }
273                                                   118 
274 ////////////// /vis/scene/endOfEventAction ///    119 ////////////// /vis/scene/endOfEventAction ////////////////////////////
275                                                   120 
276 G4VisCommandSceneEndOfEventAction::G4VisComman    121 G4VisCommandSceneEndOfEventAction::G4VisCommandSceneEndOfEventAction () {
277   G4bool omitable;                                122   G4bool omitable;
278   fpCommand = new G4UIcommand ("/vis/scene/end    123   fpCommand = new G4UIcommand ("/vis/scene/endOfEventAction", this);
279   fpCommand -> SetGuidance                        124   fpCommand -> SetGuidance
280     ("Accumulate or refresh the viewer for eac    125     ("Accumulate or refresh the viewer for each new event.");
281   fpCommand -> SetGuidance                        126   fpCommand -> SetGuidance
282     ("\"accumulate\": viewer accumulates hits,    127     ("\"accumulate\": viewer accumulates hits, etc., event by event, or");
283   fpCommand -> SetGuidance                        128   fpCommand -> SetGuidance
284     ("\"refresh\": viewer shows them at end of    129     ("\"refresh\": viewer shows them at end of event or, for direct-screen"
285      "\n  viewers, refreshes the screen just b    130      "\n  viewers, refreshes the screen just before drawing the next event.");
286   G4UIparameter* parameter;                       131   G4UIparameter* parameter;
287   parameter = new G4UIparameter ("action", 's'    132   parameter = new G4UIparameter ("action", 's', omitable = true);
288   parameter -> SetParameterCandidates ("accumu    133   parameter -> SetParameterCandidates ("accumulate refresh");
289   parameter -> SetDefaultValue ("refresh");       134   parameter -> SetDefaultValue ("refresh");
290   fpCommand -> SetParameter (parameter);          135   fpCommand -> SetParameter (parameter);
291   parameter = new G4UIparameter ("maxNumber",     136   parameter = new G4UIparameter ("maxNumber", 'i', omitable = true);
292   parameter -> SetDefaultValue (100);             137   parameter -> SetDefaultValue (100);
293   parameter -> SetGuidance                        138   parameter -> SetGuidance
294   ("Maximum number of events kept.  Unlimited     139   ("Maximum number of events kept.  Unlimited if negative.");
295   fpCommand -> SetParameter (parameter);          140   fpCommand -> SetParameter (parameter);
296 }                                                 141 }
297                                                   142 
298 G4VisCommandSceneEndOfEventAction::~G4VisComma    143 G4VisCommandSceneEndOfEventAction::~G4VisCommandSceneEndOfEventAction () {
299   delete fpCommand;                               144   delete fpCommand;
300 }                                                 145 }
301                                                   146 
302 G4String G4VisCommandSceneEndOfEventAction::Ge    147 G4String G4VisCommandSceneEndOfEventAction::GetCurrentValue(G4UIcommand*) {
303   return "";                                      148   return "";
304 }                                                 149 }
305                                                   150 
306 void G4VisCommandSceneEndOfEventAction::SetNew    151 void G4VisCommandSceneEndOfEventAction::SetNewValue (G4UIcommand*,
307                  G4String newValue) {             152                  G4String newValue) {
308                                                   153 
309   G4VisManager::Verbosity verbosity = fpVisMan    154   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
310                                                   155 
311   G4String action;                                156   G4String action;
312   G4int maxNumberOfKeptEvents;                    157   G4int maxNumberOfKeptEvents;
313   std::istringstream is (newValue);               158   std::istringstream is (newValue);
314   is >> action >> maxNumberOfKeptEvents;          159   is >> action >> maxNumberOfKeptEvents;
315                                                   160 
316   G4Scene* pScene = fpVisManager->GetCurrentSc    161   G4Scene* pScene = fpVisManager->GetCurrentScene();
317   if (!pScene) {                                  162   if (!pScene) {
318     if (verbosity >= G4VisManager::errors) {      163     if (verbosity >= G4VisManager::errors) {
319       G4warn << "ERROR: No current scene.  Ple << 164       G4cout << "ERROR: No current scene.  Please create one." << G4endl;
320     }                                             165     }
321     return;                                       166     return;
322   }                                               167   }
323                                                   168 
324   G4VSceneHandler* pSceneHandler = fpVisManage    169   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
325   if (!pSceneHandler) {                           170   if (!pSceneHandler) {
326     if (verbosity >= G4VisManager::errors) {      171     if (verbosity >= G4VisManager::errors) {
327       G4warn << "ERROR: No current sceneHandle << 172       G4cout << "ERROR: No current sceneHandler.  Please create one." << G4endl;
328     }                                             173     }
329     return;                                       174     return;
330   }                                               175   }
331                                                   176 
332   if (action == "accumulate") {                   177   if (action == "accumulate") {
333     pScene->SetRefreshAtEndOfEvent(false);        178     pScene->SetRefreshAtEndOfEvent(false);
334     pScene->SetMaxNumberOfKeptEvents(maxNumber    179     pScene->SetMaxNumberOfKeptEvents(maxNumberOfKeptEvents);
335   }                                               180   }
336   else if (action == "refresh") {                 181   else if (action == "refresh") {
337     if (!pScene->GetRefreshAtEndOfRun()) {        182     if (!pScene->GetRefreshAtEndOfRun()) {
338       if (verbosity >= G4VisManager::errors) {    183       if (verbosity >= G4VisManager::errors) {
339   G4warn <<                                    << 184   G4cout <<
340     "ERROR: Cannot refresh events unless runs     185     "ERROR: Cannot refresh events unless runs refresh too."
341     "\n  Use \"/vis/scene/endOfRun refresh\"."    186     "\n  Use \"/vis/scene/endOfRun refresh\"."
342          << G4endl;                               187          << G4endl;
343       }                                           188       }
344     } else {                                      189     } else {
345       pScene->SetRefreshAtEndOfEvent(true);       190       pScene->SetRefreshAtEndOfEvent(true);
346       pScene->SetMaxNumberOfKeptEvents(maxNumb << 
347       pSceneHandler->SetMarkForClearingTransie    191       pSceneHandler->SetMarkForClearingTransientStore(true);
348     }                                             192     }
349   }                                               193   }
350   else {                                          194   else {
351     if (verbosity >= G4VisManager::errors) {      195     if (verbosity >= G4VisManager::errors) {
352       G4warn <<                                << 196       G4cout <<
353   "ERROR: unrecognised parameter \"" << action    197   "ERROR: unrecognised parameter \"" << action << "\"."
354              << G4endl;                           198              << G4endl;
355     }                                             199     }
356     return;                                       200     return;
357   }                                               201   }
358                                                   202 
359   // Change of transients behaviour, so...        203   // Change of transients behaviour, so...
360   fpVisManager->ResetTransientsDrawnFlags();      204   fpVisManager->ResetTransientsDrawnFlags();
361                                                   205 
362   // Are there any events currently kept...       206   // Are there any events currently kept...
363   size_t nCurrentlyKept    = 0;                << 207   size_t nCurrentlyKept = 0;
364   G4RunManager* runManager = G4RunManagerFacto << 208   G4RunManager* runManager = G4RunManager::GetRunManager();
365   if(runManager)                               << 209   if (runManager) {
366   {                                            << 
367     const G4Run* currentRun = runManager->GetC    210     const G4Run* currentRun = runManager->GetCurrentRun();
368     if(currentRun)                             << 211     if (currentRun) {
369     {                                          << 212       const std::vector<const G4Event*>* events =
370       const std::vector<const G4Event*>* event << 213   currentRun->GetEventVector();
371       if(events)                               << 214       if (events) nCurrentlyKept = events->size();
372         nCurrentlyKept = events->size();       << 
373     }                                             215     }
374   }                                               216   }
375                                                   217 
376   if (verbosity >= G4VisManager::confirmations    218   if (verbosity >= G4VisManager::confirmations) {
377     G4cout << "End of event action set to ";      219     G4cout << "End of event action set to ";
378     if (pScene->GetRefreshAtEndOfEvent()) G4co    220     if (pScene->GetRefreshAtEndOfEvent()) G4cout << "\"refresh\".";
379     else {                                        221     else {
380       G4cout << "\"accumulate\"."                 222       G4cout << "\"accumulate\"."
381   "\n  Maximum number of events to be kept: "     223   "\n  Maximum number of events to be kept: "
382        << maxNumberOfKeptEvents                   224        << maxNumberOfKeptEvents
383        << " (unlimited if negative)."             225        << " (unlimited if negative)."
384   "\n  This may be changed with, e.g., "          226   "\n  This may be changed with, e.g., "
385   "\"/vis/scene/endOfEventAction accumulate 10    227   "\"/vis/scene/endOfEventAction accumulate 1000\".";
386     }                                             228     }
387     G4cout << G4endl;                             229     G4cout << G4endl;
388   }                                               230   }
389                                                   231 
390   if (!pScene->GetRefreshAtEndOfEvent() &&        232   if (!pScene->GetRefreshAtEndOfEvent() &&
391       maxNumberOfKeptEvents != 0 &&               233       maxNumberOfKeptEvents != 0 &&
392       verbosity >= G4VisManager::warnings) {      234       verbosity >= G4VisManager::warnings) {
393     G4warn << "WARNING: ";                     << 235     G4cout << "WARNING: ";
394     if (nCurrentlyKept) {                         236     if (nCurrentlyKept) {
395       G4warn <<                                << 237       G4cout <<
396   "\n  There are currently " << nCurrentlyKept    238   "\n  There are currently " << nCurrentlyKept
397        << " events kept for refreshing and/or     239        << " events kept for refreshing and/or reviewing.";
398     } else {                                      240     } else {
399       G4warn << "The vis manager will keep ";  << 241       G4cout << "The vis manager will keep ";
400       if (maxNumberOfKeptEvents < 0) G4warn << << 242       if (maxNumberOfKeptEvents < 0) G4cout << "an unlimited number of";
401       else G4warn << "up to " << maxNumberOfKe << 243       else G4cout << "up to " << maxNumberOfKeptEvents;
402       G4warn << " events.";                    << 244       G4cout << " events.";
403       if (maxNumberOfKeptEvents > 1 || maxNumb    245       if (maxNumberOfKeptEvents > 1 || maxNumberOfKeptEvents < 0)
404   G4warn <<                                    << 246   G4cout << "\n  This may use a lot of memory.";
405     "\n  This may use a lot of memory."        << 
406     "\n  It may be changed with, e.g., "       << 
407     "\"/vis/scene/endOfEventAction accumulate  << 
408     }                                             247     }
409     G4warn << G4endl;                          << 248     G4cout << G4endl;
410   }                                               249   }
411 }                                                 250 }
412                                                   251 
413 ////////////// /vis/scene/endOfRunAction /////    252 ////////////// /vis/scene/endOfRunAction ////////////////////////////
414                                                   253 
415 G4VisCommandSceneEndOfRunAction::G4VisCommandS    254 G4VisCommandSceneEndOfRunAction::G4VisCommandSceneEndOfRunAction () {
416   G4bool omitable;                                255   G4bool omitable;
417   fpCommand = new G4UIcmdWithAString ("/vis/sc    256   fpCommand = new G4UIcmdWithAString ("/vis/scene/endOfRunAction", this);
418   fpCommand -> SetGuidance                        257   fpCommand -> SetGuidance
419     ("Accumulate or refresh the viewer for eac    258     ("Accumulate or refresh the viewer for each new run.");
420   fpCommand -> SetGuidance                        259   fpCommand -> SetGuidance
421     ("\"accumulate\": viewer accumulates hits,    260     ("\"accumulate\": viewer accumulates hits, etc., run by run, or");
422   fpCommand -> SetGuidance                        261   fpCommand -> SetGuidance
423     ("\"refresh\": viewer shows them at end of    262     ("\"refresh\": viewer shows them at end of run or, for direct-screen"
424      "\n  viewers, refreshes the screen just b    263      "\n  viewers, refreshes the screen just before drawing the first"
425      "\n  event of the next run.");               264      "\n  event of the next run.");
426   fpCommand -> SetGuidance ("The detector rema    265   fpCommand -> SetGuidance ("The detector remains or is redrawn.");
427   fpCommand -> SetParameterName ("action", omi    266   fpCommand -> SetParameterName ("action", omitable = true);
428   fpCommand -> SetCandidates ("accumulate refr    267   fpCommand -> SetCandidates ("accumulate refresh");
429   fpCommand -> SetDefaultValue ("refresh");       268   fpCommand -> SetDefaultValue ("refresh");
430 }                                                 269 }
431                                                   270 
432 G4VisCommandSceneEndOfRunAction::~G4VisCommand    271 G4VisCommandSceneEndOfRunAction::~G4VisCommandSceneEndOfRunAction () {
433   delete fpCommand;                               272   delete fpCommand;
434 }                                                 273 }
435                                                   274 
436 G4String G4VisCommandSceneEndOfRunAction::GetC    275 G4String G4VisCommandSceneEndOfRunAction::GetCurrentValue(G4UIcommand*) {
437   return "";                                      276   return "";
438 }                                                 277 }
439                                                   278 
440 void G4VisCommandSceneEndOfRunAction::SetNewVa    279 void G4VisCommandSceneEndOfRunAction::SetNewValue (G4UIcommand*,
441                  G4String newValue) {             280                  G4String newValue) {
442                                                   281 
443   G4VisManager::Verbosity verbosity = fpVisMan    282   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
444                                                   283 
445   G4String action;                                284   G4String action;
446   std::istringstream is (newValue);               285   std::istringstream is (newValue);
447   is >> action;                                   286   is >> action;
448                                                   287 
449   G4Scene* pScene = fpVisManager->GetCurrentSc    288   G4Scene* pScene = fpVisManager->GetCurrentScene();
450   if (!pScene) {                                  289   if (!pScene) {
451     if (verbosity >= G4VisManager::errors) {      290     if (verbosity >= G4VisManager::errors) {
452       G4warn << "ERROR: No current scene.  Ple << 291       G4cout << "ERROR: No current scene.  Please create one." << G4endl;
453     }                                             292     }
454     return;                                       293     return;
455   }                                               294   }
456                                                   295 
457   G4VSceneHandler* pSceneHandler = fpVisManage    296   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
458   if (!pSceneHandler) {                           297   if (!pSceneHandler) {
459     if (verbosity >= G4VisManager::errors) {      298     if (verbosity >= G4VisManager::errors) {
460       G4warn << "ERROR: No current sceneHandle << 299       G4cout << "ERROR: No current sceneHandler.  Please create one." << G4endl;
461     }                                             300     }
462     return;                                       301     return;
463   }                                               302   }
464                                                   303 
465   if (action == "accumulate") {                   304   if (action == "accumulate") {
466     if (pScene->GetRefreshAtEndOfEvent()) {       305     if (pScene->GetRefreshAtEndOfEvent()) {
467       if (verbosity >= G4VisManager::errors) {    306       if (verbosity >= G4VisManager::errors) {
468   G4warn <<                                    << 307   G4cout <<
469     "ERROR: Cannot accumulate runs unless even    308     "ERROR: Cannot accumulate runs unless events accumulate too."
470     "\n  Use \"/vis/scene/endOfEventAction acc    309     "\n  Use \"/vis/scene/endOfEventAction accumulate\"."
471          << G4endl;                               310          << G4endl;
472       }                                           311       }
473     }                                             312     }
474     else {                                        313     else {
475       pScene->SetRefreshAtEndOfRun(false);        314       pScene->SetRefreshAtEndOfRun(false);
476     }                                             315     }
477   }                                               316   }
478   else if (action == "refresh") {                 317   else if (action == "refresh") {
479     pScene->SetRefreshAtEndOfRun(true);           318     pScene->SetRefreshAtEndOfRun(true);
480     pSceneHandler->SetMarkForClearingTransient    319     pSceneHandler->SetMarkForClearingTransientStore(true);
481   }                                               320   }
482   else {                                          321   else {
483     if (verbosity >= G4VisManager::errors) {      322     if (verbosity >= G4VisManager::errors) {
484       G4warn <<                                << 323       G4cout <<
485   "ERROR: unrecognised parameter \"" << action    324   "ERROR: unrecognised parameter \"" << action << "\"."
486              << G4endl;                           325              << G4endl;
487     }                                             326     }
488     return;                                       327     return;
489   }                                               328   }
490                                                   329 
491   // Change of transients behaviour, so...        330   // Change of transients behaviour, so...
492   fpVisManager->ResetTransientsDrawnFlags();      331   fpVisManager->ResetTransientsDrawnFlags();
493                                                   332 
494   if (verbosity >= G4VisManager::confirmations    333   if (verbosity >= G4VisManager::confirmations) {
495     G4cout << "End of run action set to \"";      334     G4cout << "End of run action set to \"";
496     if (pScene->GetRefreshAtEndOfRun()) G4cout    335     if (pScene->GetRefreshAtEndOfRun()) G4cout << "refresh";
497     else G4cout << "accumulate";                  336     else G4cout << "accumulate";
498     G4cout << "\"" << G4endl;                     337     G4cout << "\"" << G4endl;
499   }                                               338   }
500 }                                                 339 }
501                                                   340 
502 ////////////// /vis/scene/list ///////////////    341 ////////////// /vis/scene/list ///////////////////////////////////////
503                                                   342 
504 G4VisCommandSceneList::G4VisCommandSceneList (    343 G4VisCommandSceneList::G4VisCommandSceneList () {
505   G4bool omitable;                                344   G4bool omitable;
506   fpCommand = new G4UIcommand ("/vis/scene/lis    345   fpCommand = new G4UIcommand ("/vis/scene/list", this);
507   fpCommand -> SetGuidance ("Lists scene(s).")    346   fpCommand -> SetGuidance ("Lists scene(s).");
508   fpCommand -> SetGuidance                        347   fpCommand -> SetGuidance
509     ("\"help /vis/verbose\" for definition of     348     ("\"help /vis/verbose\" for definition of verbosity.");
510   G4UIparameter* parameter;                       349   G4UIparameter* parameter;
511   parameter = new G4UIparameter ("scene-name",    350   parameter = new G4UIparameter ("scene-name", 's', omitable = true);
512   parameter -> SetDefaultValue ("all");           351   parameter -> SetDefaultValue ("all");
513   fpCommand -> SetParameter (parameter);          352   fpCommand -> SetParameter (parameter);
514   parameter = new G4UIparameter ("verbosity",     353   parameter = new G4UIparameter ("verbosity", 's', omitable = true);
515   parameter -> SetDefaultValue ("warnings");      354   parameter -> SetDefaultValue ("warnings");
516   fpCommand -> SetParameter (parameter);          355   fpCommand -> SetParameter (parameter);
517 }                                                 356 }
518                                                   357 
519 G4VisCommandSceneList::~G4VisCommandSceneList     358 G4VisCommandSceneList::~G4VisCommandSceneList () {
520   delete fpCommand;                               359   delete fpCommand;
521 }                                                 360 }
522                                                   361 
523 G4String G4VisCommandSceneList::GetCurrentValu    362 G4String G4VisCommandSceneList::GetCurrentValue (G4UIcommand*) {
524   return "";                                      363   return "";
525 }                                                 364 }
526                                                   365 
527 void G4VisCommandSceneList::SetNewValue (G4UIc    366 void G4VisCommandSceneList::SetNewValue (G4UIcommand*, G4String newValue) {
528   G4String name, verbosityString;                 367   G4String name, verbosityString;
529   std::istringstream is (newValue);               368   std::istringstream is (newValue);
530   is >> name >> verbosityString;                  369   is >> name >> verbosityString;
531   G4VisManager::Verbosity verbosity =             370   G4VisManager::Verbosity verbosity =
532     fpVisManager->GetVerbosityValue(verbosityS    371     fpVisManager->GetVerbosityValue(verbosityString);
533   const G4Scene* currentScene = fpVisManager -    372   const G4Scene* currentScene = fpVisManager -> GetCurrentScene ();
534   G4String currentName;                           373   G4String currentName;
535   if (currentScene) currentName = currentScene    374   if (currentScene) currentName = currentScene->GetName();
536                                                   375 
537   G4SceneList& sceneList = fpVisManager -> Set    376   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
538   std::size_t iScene, nScenes = sceneList.size << 377   G4int iScene, nScenes = sceneList.size ();
539   G4bool found = false;                           378   G4bool found = false;
540   for (iScene = 0; iScene < nScenes; ++iScene) << 379   for (iScene = 0; iScene < nScenes; iScene++) {
541     G4Scene* pScene = sceneList [iScene];         380     G4Scene* pScene = sceneList [iScene];
542     const G4String& iName = pScene -> GetName     381     const G4String& iName = pScene -> GetName ();
543     if (name != "all") {                          382     if (name != "all") {
544       if (name != iName) continue;                383       if (name != iName) continue;
545     }                                             384     }
546     found = true;                                 385     found = true;
547     if (iName == currentName) {                   386     if (iName == currentName) {
548       G4cout << "  (current)";                    387       G4cout << "  (current)";
549     }                                             388     }
550     else {                                        389     else {
551       G4cout << "           ";                    390       G4cout << "           ";
552     }                                             391     }
553     G4cout << " scene \"" << iName << "\"";       392     G4cout << " scene \"" << iName << "\"";
554     if (verbosity >= G4VisManager::warnings) { << 393     if (verbosity >= G4VisManager::confirmations) {
555       std::size_t i;                           << 394       G4int i;
556       G4cout << "\n  Run-duration models:";       395       G4cout << "\n  Run-duration models:";
557       std::size_t nRunModels = pScene -> GetRu << 396       G4int nRunModels = pScene -> GetRunDurationModelList ().size ();
558       if (nRunModels == 0) {                      397       if (nRunModels == 0) {
559   G4cout << " none.";                             398   G4cout << " none.";
560       }                                           399       }
561       for (i = 0; i < nRunModels; ++i) {       << 400       for (i = 0; i < nRunModels; i++) {
562   if (pScene -> GetRunDurationModelList()[i].f << 401   G4VModel* pModel = pScene -> GetRunDurationModelList () [i];
563     G4cout << "\n   Active:   ";               << 402   G4cout << "\n    " << pModel -> GetGlobalDescription ();
564   else G4cout << "\n   Inactive: ";            << 
565   G4VModel* pModel = pScene -> GetRunDurationM << 
566   G4cout << pModel -> GetGlobalDescription (); << 
567       }                                           403       }
568       G4cout << "\n  End-of-event models:";       404       G4cout << "\n  End-of-event models:";
569       std::size_t nEOEModels = pScene -> GetEn << 405       G4int nEOEModels = pScene -> GetEndOfEventModelList ().size ();
570       if (nEOEModels == 0) {                      406       if (nEOEModels == 0) {
571   G4cout << " none.";                             407   G4cout << " none.";
572       }                                           408       }
573       for (i = 0; i < nEOEModels; ++i) {       << 409       for (i = 0; i < nEOEModels; i++) {
574   if (pScene -> GetEndOfEventModelList()[i].fA << 410   G4VModel* pModel = pScene -> GetEndOfEventModelList () [i];
575     G4cout << "\n   Active:   ";               << 411   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       }                                           412       }
592     }                                             413     }
593     if (verbosity >= G4VisManager::parameters)    414     if (verbosity >= G4VisManager::parameters) {
594       G4cout << "\n  " << *sceneList [iScene];    415       G4cout << "\n  " << *sceneList [iScene];
595     }                                             416     }
596     G4cout << G4endl;                             417     G4cout << G4endl;
597   }                                               418   }
598   if (!found) {                                   419   if (!found) {
599     G4warn << "No scenes found";               << 420     G4cout << "No scenes found";
600     if (name != "all") {                          421     if (name != "all") {
601       G4warn << " of name \"" << name << "\""; << 422       G4cout << " of name \"" << name << "\"";
602     }                                             423     }
603     G4warn << "." << G4endl;                   << 424     G4cout << "." << G4endl;
604   }                                               425   }
605 }                                                 426 }
606                                                   427 
607 ////////////// /vis/scene/notifyHandlers /////    428 ////////////// /vis/scene/notifyHandlers /////////////////////////
608                                                   429 
609 G4VisCommandSceneNotifyHandlers::G4VisCommandS    430 G4VisCommandSceneNotifyHandlers::G4VisCommandSceneNotifyHandlers () {
610   G4bool omitable;                                431   G4bool omitable;
611   fpCommand = new G4UIcommand ("/vis/scene/not    432   fpCommand = new G4UIcommand ("/vis/scene/notifyHandlers", this);
612   fpCommand -> SetGuidance                        433   fpCommand -> SetGuidance
613     ("Notifies scene handlers and forces re-re    434     ("Notifies scene handlers and forces re-rendering.");
614   fpCommand -> SetGuidance                        435   fpCommand -> SetGuidance
615     ("Notifies the handler(s) of the specified    436     ("Notifies the handler(s) of the specified scene and forces a"
616      "\nreconstruction of any graphical databa    437      "\nreconstruction of any graphical databases."
617      "\nClears and refreshes all viewers of cu    438      "\nClears and refreshes all viewers of current scene."
618      "\n  The default action \"refresh\" does     439      "\n  The default action \"refresh\" does not issue \"update\" (see"
619      "\n    /vis/viewer/update)."                 440      "\n    /vis/viewer/update)."
620      "\nIf \"flush\" is specified, it issues a    441      "\nIf \"flush\" is specified, it issues an \"update\" as well as"
621      "\n  \"refresh\" - \"update\" and initiat    442      "\n  \"refresh\" - \"update\" and initiates post-processing"
622      "\n  for graphics systems which need it."    443      "\n  for graphics systems which need it.");
623   fpCommand -> SetGuidance                        444   fpCommand -> SetGuidance 
624     ("The default for <scene-name> is the curr    445     ("The default for <scene-name> is the current scene name.");
625   fpCommand -> SetGuidance                        446   fpCommand -> SetGuidance
626     ("This command does not change current sce    447     ("This command does not change current scene, scene handler or viewer.");
627   G4UIparameter* parameter;                       448   G4UIparameter* parameter;
628   parameter = new G4UIparameter ("scene-name",    449   parameter = new G4UIparameter ("scene-name", 's',
629          omitable = true);                        450          omitable = true);
630   parameter -> SetCurrentAsDefault(true);         451   parameter -> SetCurrentAsDefault(true);
631   fpCommand -> SetParameter (parameter);          452   fpCommand -> SetParameter (parameter);
632   parameter = new G4UIparameter ("refresh-flus    453   parameter = new G4UIparameter ("refresh-flush", 's',
633          omitable = true);                        454          omitable = true);
634   parameter -> SetDefaultValue("refresh");        455   parameter -> SetDefaultValue("refresh");
635   parameter -> SetParameterCandidates("r refre    456   parameter -> SetParameterCandidates("r refresh f flush");
636   fpCommand -> SetParameter (parameter);          457   fpCommand -> SetParameter (parameter);
637 }                                                 458 }
638                                                   459 
639 G4VisCommandSceneNotifyHandlers::~G4VisCommand    460 G4VisCommandSceneNotifyHandlers::~G4VisCommandSceneNotifyHandlers () {
640   delete fpCommand;                               461   delete fpCommand;
641 }                                                 462 }
642                                                   463 
643 G4String G4VisCommandSceneNotifyHandlers::GetC    464 G4String G4VisCommandSceneNotifyHandlers::GetCurrentValue(G4UIcommand*) {
644   return CurrentSceneName ();                     465   return CurrentSceneName ();
645 }                                                 466 }
646                                                   467 
647 void G4VisCommandSceneNotifyHandlers::SetNewVa    468 void G4VisCommandSceneNotifyHandlers::SetNewValue (G4UIcommand*,
648                G4String newValue) {               469                G4String newValue) {
649                                                   470 
650   G4VisManager::Verbosity verbosity = fpVisMan    471   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
651                                                   472 
652   G4String sceneName, refresh_flush;              473   G4String sceneName, refresh_flush;
653   std::istringstream is (newValue);               474   std::istringstream is (newValue);
654   is >> sceneName >> refresh_flush;               475   is >> sceneName >> refresh_flush;
655   G4bool flush = false;                           476   G4bool flush = false;
656   if (refresh_flush[0] == 'f') flush = true;   << 477   if (refresh_flush(0) == 'f') flush = true;
657                                                   478 
658   const G4SceneList& sceneList = fpVisManager     479   const G4SceneList& sceneList = fpVisManager -> GetSceneList ();
659   G4SceneHandlerList& sceneHandlerList =          480   G4SceneHandlerList& sceneHandlerList =
660     fpVisManager -> SetAvailableSceneHandlers     481     fpVisManager -> SetAvailableSceneHandlers ();
661                                                   482 
662   // Check scene name.                            483   // Check scene name.
663   const std::size_t nScenes = sceneList.size ( << 484   const G4int nScenes = sceneList.size ();
664   std::size_t iScene;                          << 485   G4int iScene;
665   for (iScene = 0; iScene < nScenes; ++iScene) << 486   for (iScene = 0; iScene < nScenes; iScene++) {
666     G4Scene* scene = sceneList [iScene];          487     G4Scene* scene = sceneList [iScene];
667     if (sceneName == scene -> GetName ()) brea    488     if (sceneName == scene -> GetName ()) break;
668   }                                               489   }
669   if (iScene >= nScenes ) {                       490   if (iScene >= nScenes ) {
670     if (verbosity >= G4VisManager::warnings) {    491     if (verbosity >= G4VisManager::warnings) {
671       G4warn << "WARNING: Scene \"" << sceneNa << 492       G4cout << "WARNING: Scene \"" << sceneName << "\" not found."
672   "\n  /vis/scene/list to see scenes."            493   "\n  /vis/scene/list to see scenes."
673        << G4endl;                                 494        << G4endl;
674     }                                             495     }
675     return;                                       496     return;
676   }                                               497   }
677                                                   498 
678   // Store current context...                     499   // Store current context...
679   G4VSceneHandler* pCurrentSceneHandler =         500   G4VSceneHandler* pCurrentSceneHandler =
680     fpVisManager -> GetCurrentSceneHandler();     501     fpVisManager -> GetCurrentSceneHandler();
681   if (!pCurrentSceneHandler) {                    502   if (!pCurrentSceneHandler) {
682     if (verbosity >= G4VisManager::warnings) {    503     if (verbosity >= G4VisManager::warnings) {
683       G4warn << "WARNING: No current scene han << 504       G4cout << "WARNING: No current scene handler."
684        << G4endl;                                 505        << G4endl;
685     }                                             506     }
686     return;                                       507     return;
687   }                                               508   }
688   G4VViewer* pCurrentViewer = fpVisManager ->     509   G4VViewer* pCurrentViewer = fpVisManager -> GetCurrentViewer();
689   if (!pCurrentViewer) {                          510   if (!pCurrentViewer) {
690     if (verbosity >= G4VisManager::warnings) {    511     if (verbosity >= G4VisManager::warnings) {
691       G4warn << "WARNING: No current viewer."  << 512       G4cout << "WARNING: No current viewer."
692        << G4endl;                                 513        << G4endl;
693     }                                             514     }
694     return;                                       515     return;
695   }                                               516   }
696   G4Scene* pCurrentScene = fpVisManager -> Get    517   G4Scene* pCurrentScene = fpVisManager -> GetCurrentScene();
697   if (!pCurrentScene) {                           518   if (!pCurrentScene) {
698     if (verbosity >= G4VisManager::warnings) {    519     if (verbosity >= G4VisManager::warnings) {
699       G4warn << "WARNING: No current scene."   << 520       G4cout << "WARNING: No current scene."
700        << G4endl;                                 521        << G4endl;
701     }                                             522     }
702     return;                                       523     return;
703   }                                               524   }
704                                                << 
705   G4VisManager::Verbosity currentVerbosity = f    525   G4VisManager::Verbosity currentVerbosity = fpVisManager -> GetVerbosity();
706                                                   526 
707   // Suppress messages during this process (on    527   // Suppress messages during this process (only print errors)...
708   //fpVisManager -> SetVerboseLevel(G4VisManag    528   //fpVisManager -> SetVerboseLevel(G4VisManager::errors);
709                                                   529 
710   // For each scene handler, if it contains th    530   // For each scene handler, if it contains the scene, clear and
711   // rebuild the graphical database, then for     531   // rebuild the graphical database, then for each viewer set (make
712   // current), clear, (re)draw, and show.         532   // current), clear, (re)draw, and show.
713   const std::size_t nSceneHandlers = sceneHand << 533   const G4int nSceneHandlers = sceneHandlerList.size ();
714   for (std::size_t iSH = 0; iSH < nSceneHandle << 534   for (G4int iSH = 0; iSH < nSceneHandlers; iSH++) {
715     G4VSceneHandler* aSceneHandler = sceneHand    535     G4VSceneHandler* aSceneHandler = sceneHandlerList [iSH];
716     G4Scene* aScene = aSceneHandler -> GetScen    536     G4Scene* aScene = aSceneHandler -> GetScene ();
717     if (aScene) {                                 537     if (aScene) {
718       const G4String& aSceneName = aScene -> G    538       const G4String& aSceneName = aScene -> GetName ();
719       if (sceneName == aSceneName) {              539       if (sceneName == aSceneName) {
720   aScene->CalculateExtent();  // Check and rec << 540   // Clear store and force a rebuild of graphical database...
                                                   >> 541   //aSceneHandler -> ClearStore (); // Not nec??  Done below
                                                   >> 542   //with NeedKernelVisit and DrawView.  JA.
721   G4ViewerList& viewerList = aSceneHandler ->     543   G4ViewerList& viewerList = aSceneHandler -> SetViewerList ();
722   const std::size_t nViewers = viewerList.size << 544   const G4int nViewers = viewerList.size ();
723   for (std::size_t iV = 0; iV < nViewers; ++iV << 545   for (G4int iV = 0; iV < nViewers; iV++) {
724     G4VViewer* aViewer = viewerList [iV];         546     G4VViewer* aViewer = viewerList [iV];
725     // Force rebuild of graphical database, if << 
726     aViewer -> NeedKernelVisit();              << 
727     if (aViewer->GetViewParameters().IsAutoRef    547     if (aViewer->GetViewParameters().IsAutoRefresh()) {
728       aSceneHandler -> SetCurrentViewer (aView    548       aSceneHandler -> SetCurrentViewer (aViewer);
729       // Ensure consistency of vis manager...     549       // Ensure consistency of vis manager...
730       fpVisManager -> SetCurrentViewer(aViewer    550       fpVisManager -> SetCurrentViewer(aViewer);
731       fpVisManager -> SetCurrentSceneHandler(a    551       fpVisManager -> SetCurrentSceneHandler(aSceneHandler);
732       fpVisManager -> SetCurrentScene(aScene);    552       fpVisManager -> SetCurrentScene(aScene);
                                                   >> 553       // Re-draw, forcing rebuild of graphics database, if any...
                                                   >> 554       aViewer -> NeedKernelVisit();
733       aViewer -> SetView ();                      555       aViewer -> SetView ();
734       aViewer -> ClearView ();                    556       aViewer -> ClearView ();
735       aViewer -> DrawView ();                     557       aViewer -> DrawView ();
736       if (flush) aViewer -> ShowView ();          558       if (flush) aViewer -> ShowView ();
737       if (verbosity >= G4VisManager::confirmat    559       if (verbosity >= G4VisManager::confirmations) {
738         G4cout << "Viewer \"" << aViewer -> Ge    560         G4cout << "Viewer \"" << aViewer -> GetName ()
739          << "\" of scene handler \"" << aScene    561          << "\" of scene handler \"" << aSceneHandler -> GetName ()
740          << "\"\n  ";                             562          << "\"\n  ";
741         if (flush) G4cout << "flushed";           563         if (flush) G4cout << "flushed";
742         else G4cout << "refreshed";               564         else G4cout << "refreshed";
743         G4cout << " at request of scene \"" <<    565         G4cout << " at request of scene \"" << sceneName
744          << "\"." << G4endl;                      566          << "\"." << G4endl;
745       }                                           567       }
746     } else {                                      568     } else {
747       if (verbosity >= G4VisManager::confirmat << 569       if (verbosity >= G4VisManager::warnings) {
748         G4cout << "NOTE: The scene, \""        << 570         G4cout << "WARNING: The scene, \""
749          << sceneName                             571          << sceneName
750          << "\", of viewer \""                    572          << "\", of viewer \""
751          << aViewer -> GetName ()                 573          << aViewer -> GetName ()
752          << "\"\n  of scene handler \""           574          << "\"\n  of scene handler \""
753          << aSceneHandler -> GetName ()           575          << aSceneHandler -> GetName ()
754          << "\"  has changed.  To see effect,"    576          << "\"  has changed.  To see effect,"
755          << "\n  \"/vis/viewer/select "           577          << "\n  \"/vis/viewer/select "
756          << aViewer -> GetShortName ()            578          << aViewer -> GetShortName ()
757          << "\" and \"/vis/viewer/rebuild\"."     579          << "\" and \"/vis/viewer/rebuild\"."
758          << G4endl;                               580          << G4endl;
759       }                                           581       }
760     }                                             582     }
761   }                                               583   }
762       }                                           584       }
763     }                                             585     }
764     else {                                        586     else {
765       if (verbosity >= G4VisManager::warnings)    587       if (verbosity >= G4VisManager::warnings) {
766   G4warn << "WARNING: G4VisCommandSceneNotifyH << 588   G4cout << "WARNING: G4VisCommandSceneNotifyHandlers: scene handler \""
767          << aSceneHandler->GetName()              589          << aSceneHandler->GetName()
768          << "\" has a null scene."                590          << "\" has a null scene."
769          << G4endl;                               591          << G4endl;
770       }                                           592       }
771     }                                             593     }
772   }                                               594   }
773                                                   595 
774   // Reclaim original context - but set viewer    596   // Reclaim original context - but set viewer first, then scene
775   // handler, because the latter might have be    597   // handler, because the latter might have been created very recently
776   // and, not yet having a viewer, the current    598   // and, not yet having a viewer, the current viewer will,
777   // temporarily, refer to another scene handl    599   // temporarily, refer to another scene handler.  SetCurrentViewer
778   // actually resets the scene handler, which     600   // actually resets the scene handler, which is what we don't want,
779   // so we set it again on the next line...       601   // so we set it again on the next line...
780   fpVisManager -> SetCurrentViewer(pCurrentVie    602   fpVisManager -> SetCurrentViewer(pCurrentViewer);
781   fpVisManager -> SetCurrentSceneHandler(pCurr    603   fpVisManager -> SetCurrentSceneHandler(pCurrentSceneHandler);
782   fpVisManager -> SetCurrentScene(pCurrentScen    604   fpVisManager -> SetCurrentScene(pCurrentScene);
783   fpVisManager -> SetVerboseLevel(currentVerbo    605   fpVisManager -> SetVerboseLevel(currentVerbosity);
784   // Take care of special case of scene handle    606   // Take care of special case of scene handler with no viewer yet.  
785   if (pCurrentSceneHandler) {                     607   if (pCurrentSceneHandler) {
786     G4ViewerList& viewerList = pCurrentSceneHa    608     G4ViewerList& viewerList = pCurrentSceneHandler -> SetViewerList ();
787     const std::size_t nViewers = viewerList.si << 609     const G4int nViewers = viewerList.size ();
788     if (nViewers) {                               610     if (nViewers) {
789       pCurrentSceneHandler -> SetCurrentViewer    611       pCurrentSceneHandler -> SetCurrentViewer (pCurrentViewer);
790       // JA: I don't think we need this. SetVi << 612       if (pCurrentViewer && pCurrentSceneHandler->GetScene()) {
791       // if (pCurrentViewer && pCurrentSceneHa << 613   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       }                                        << 
859       break;  // Allow only one model at a tim << 
860     }                                          << 
861   }                                            << 
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       }                                           614       }
889       break;  // Allow only one model at a tim << 
890     }                                             615     }
891   }                                               616   }
892                                                << 
893   if (!any) {                                  << 
894     if (verbosity >= G4VisManager::warnings) { << 
895       G4warn << "WARNING: No match found." <<  << 
896     }                                          << 
897     return;                                    << 
898   }                                            << 
899                                                << 
900   CheckSceneAndNotifyHandlers (pScene);        << 
901 }                                                 617 }
902                                                   618 
903 ////////////// /vis/scene/select /////////////    619 ////////////// /vis/scene/select ///////////////////////////////////////
904                                                   620 
905 G4VisCommandSceneSelect::G4VisCommandSceneSele    621 G4VisCommandSceneSelect::G4VisCommandSceneSelect () {
906   G4bool omitable;                                622   G4bool omitable;
907   fpCommand = new G4UIcmdWithAString ("/vis/sc    623   fpCommand = new G4UIcmdWithAString ("/vis/scene/select", this);
908   fpCommand -> SetGuidance ("Selects a scene")    624   fpCommand -> SetGuidance ("Selects a scene");
909   fpCommand -> SetGuidance                     << 625   fpCommand -> SetGuidance 
910   ("Makes the scene current.  \"/vis/scene/lis << 626     ("Makes the scene current.  \"/vis/scene/list\" to see"
911    "\n possible scene names.");                << 627      "\n possible scene names.");
912   fpCommand -> SetParameterName ("scene-name",    628   fpCommand -> SetParameterName ("scene-name", omitable = false);
913 }                                                 629 }
914                                                   630 
915 G4VisCommandSceneSelect::~G4VisCommandSceneSel    631 G4VisCommandSceneSelect::~G4VisCommandSceneSelect () {
916   delete fpCommand;                               632   delete fpCommand;
917 }                                                 633 }
918                                                   634 
919 G4String G4VisCommandSceneSelect::GetCurrentVa    635 G4String G4VisCommandSceneSelect::GetCurrentValue (G4UIcommand*) {
920   return "";                                      636   return "";
921 }                                                 637 }
922                                                   638 
923 void G4VisCommandSceneSelect::SetNewValue (G4U    639 void G4VisCommandSceneSelect::SetNewValue (G4UIcommand*, G4String newValue) {
924                                                   640 
925   G4VisManager::Verbosity verbosity = fpVisMan    641   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
926                                                   642 
927   G4String& selectName = newValue;                643   G4String& selectName = newValue;
928   G4SceneList& sceneList = fpVisManager -> Set    644   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
929   std::size_t iScene, nScenes = sceneList.size << 645   G4int iScene, nScenes = sceneList.size ();
930   for (iScene = 0; iScene < nScenes; ++iScene) << 646   for (iScene = 0; iScene < nScenes; iScene++) {
931     if (sceneList [iScene] -> GetName () == se    647     if (sceneList [iScene] -> GetName () == selectName) break;
932   }                                               648   }
933   if (iScene >= nScenes) {                        649   if (iScene >= nScenes) {
934     if (verbosity >= G4VisManager::warnings) {    650     if (verbosity >= G4VisManager::warnings) {
935       G4warn << "WARNING: Scene \"" << selectN << 651       G4cout << "WARNING: Scene \"" << selectName
936       << "\" not found - \"/vis/scene/list\" t << 652        << "\" not found - \"/vis/scene/list\" to see possibilities."
937       << G4endl;                               << 653        << G4endl;
938     }                                             654     }
939     return;                                       655     return;
940   }                                               656   }
941                                                   657 
942   if (verbosity >= G4VisManager::confirmations    658   if (verbosity >= G4VisManager::confirmations) {
943     G4cout << "Scene \"" << selectName            659     G4cout << "Scene \"" << selectName
944     << "\" selected." << G4endl;               << 660      << "\" selected." << G4endl;
945   }                                               661   }
946                                                << 662   UpdateVisManagerScene (selectName);
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   }                                            << 
986   G4Scene* pCurrentScene = fpVisManager -> Get << 
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 }                                                663 }
1044                                                  664