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 11.0)


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