Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommandsViewer.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/G4VisCommandsViewer.cc (Version 11.3.0) and /visualization/management/src/G4VisCommandsViewer.cc (Version 10.1.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
                                                   >>  27 // $Id: G4VisCommandsViewer.cc 83403 2014-08-21 15:07:30Z gcosmo $
 27                                                    28 
 28 // /vis/viewer commands - John Allison  25th O     29 // /vis/viewer commands - John Allison  25th October 1998
 29                                                    30 
 30 #include "G4VisCommandsViewer.hh"                  31 #include "G4VisCommandsViewer.hh"
 31                                                    32 
 32 #include "G4VisManager.hh"                         33 #include "G4VisManager.hh"
 33 #include "G4GraphicsSystemList.hh"                 34 #include "G4GraphicsSystemList.hh"
 34 #include "G4VisCommandsScene.hh"                   35 #include "G4VisCommandsScene.hh"
 35 #include "G4UImanager.hh"                          36 #include "G4UImanager.hh"
 36 #include "G4UIcommand.hh"                          37 #include "G4UIcommand.hh"
 37 #include "G4UIcmdWithoutParameter.hh"              38 #include "G4UIcmdWithoutParameter.hh"
 38 #include "G4UIcmdWithAString.hh"                   39 #include "G4UIcmdWithAString.hh"
 39 #include "G4UIcmdWithADouble.hh"                   40 #include "G4UIcmdWithADouble.hh"
 40 #include "G4UIcmdWithADoubleAndUnit.hh"            41 #include "G4UIcmdWithADoubleAndUnit.hh"
 41 #include "G4UIcmdWith3Vector.hh"                   42 #include "G4UIcmdWith3Vector.hh"
 42 #include "G4PhysicalVolumesSearchScene.hh"     << 
 43 #include "G4TransportationManager.hh"          << 
 44 #include "G4Point3D.hh"                            43 #include "G4Point3D.hh"
 45 #include "G4SystemOfUnits.hh"                  << 
 46 #include "G4UnitsTable.hh"                         44 #include "G4UnitsTable.hh"
 47 #include "G4Filesystem.hh"                     <<  45 #include "G4ios.hh"
 48 #include <chrono>                              << 
 49 #include <thread>                              << 
 50 #include <sstream>                                 46 #include <sstream>
 51 #include <fstream>                                 47 #include <fstream>
 52 #include <iomanip>                             << 
 53 #include <cstdio>                              << 
 54 #include <regex>                               << 
 55 #include <set>                                 << 
 56                                                    48 
 57 #define G4warn G4cout                          <<  49 G4VVisCommandViewer::G4VVisCommandViewer () {}
                                                   >>  50 
                                                   >>  51 G4VVisCommandViewer::~G4VVisCommandViewer () {}
                                                   >>  52 
                                                   >>  53 void G4VVisCommandViewer::SetViewParameters
                                                   >>  54 (G4VViewer* viewer, const G4ViewParameters& viewParams) {
                                                   >>  55   viewer->SetViewParameters(viewParams);
                                                   >>  56   RefreshIfRequired(viewer);
                                                   >>  57 }
                                                   >>  58 
                                                   >>  59 void G4VVisCommandViewer::RefreshIfRequired(G4VViewer* viewer) {
                                                   >>  60   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
                                                   >>  61   G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
                                                   >>  62   const G4ViewParameters& viewParams = viewer->GetViewParameters();
                                                   >>  63   if (sceneHandler && sceneHandler->GetScene()) {
                                                   >>  64     if (viewParams.IsAutoRefresh()) {
                                                   >>  65       G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
                                                   >>  66     }
                                                   >>  67     else {
                                                   >>  68       if (verbosity >= G4VisManager::warnings) {
                                                   >>  69   G4cout << "Issue /vis/viewer/refresh or flush to see effect."
                                                   >>  70          << G4endl;
                                                   >>  71       }
                                                   >>  72     }
                                                   >>  73   }
                                                   >>  74 }
 58                                                    75 
 59 ////////////// /vis/viewer/addCutawayPlane ///     76 ////////////// /vis/viewer/addCutawayPlane ///////////////////////////////////////
 60                                                    77 
 61 G4VisCommandViewerAddCutawayPlane::G4VisComman     78 G4VisCommandViewerAddCutawayPlane::G4VisCommandViewerAddCutawayPlane () {
 62   G4bool omitable;                                 79   G4bool omitable;
 63   fpCommand = new G4UIcommand ("/vis/viewer/ad     80   fpCommand = new G4UIcommand ("/vis/viewer/addCutawayPlane", this);
 64   fpCommand -> SetGuidance                         81   fpCommand -> SetGuidance
 65     ("Add cutaway plane to current viewer.");      82     ("Add cutaway plane to current viewer.");
 66   G4UIparameter* parameter;                        83   G4UIparameter* parameter;
 67   parameter  =  new G4UIparameter("x",'d',omit     84   parameter  =  new G4UIparameter("x",'d',omitable = true);
 68   parameter  -> SetDefaultValue  (0);              85   parameter  -> SetDefaultValue  (0);
 69   parameter  -> SetGuidance      ("Coordinate      86   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
 70   fpCommand->SetParameter(parameter);              87   fpCommand->SetParameter(parameter);
 71   parameter  =  new G4UIparameter("y",'d',omit     88   parameter  =  new G4UIparameter("y",'d',omitable = true);
 72   parameter  -> SetDefaultValue  (0);              89   parameter  -> SetDefaultValue  (0);
 73   parameter  -> SetGuidance      ("Coordinate      90   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
 74   fpCommand->SetParameter(parameter);              91   fpCommand->SetParameter(parameter);
 75   parameter  =  new G4UIparameter("z",'d',omit     92   parameter  =  new G4UIparameter("z",'d',omitable = true);
 76   parameter  -> SetDefaultValue  (0);              93   parameter  -> SetDefaultValue  (0);
 77   parameter  -> SetGuidance      ("Coordinate      94   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
 78   fpCommand->SetParameter(parameter);              95   fpCommand->SetParameter(parameter);
 79   parameter  =  new G4UIparameter("unit",'s',o     96   parameter  =  new G4UIparameter("unit",'s',omitable = true);
 80   parameter  -> SetDefaultValue  ("m");            97   parameter  -> SetDefaultValue  ("m");
 81   parameter  -> SetGuidance      ("Unit of poi     98   parameter  -> SetGuidance      ("Unit of point on the plane.");
 82   fpCommand->SetParameter(parameter);              99   fpCommand->SetParameter(parameter);
 83   parameter  =  new G4UIparameter("nx",'d',omi    100   parameter  =  new G4UIparameter("nx",'d',omitable = true);
 84   parameter  -> SetDefaultValue  (1);             101   parameter  -> SetDefaultValue  (1);
 85   parameter  -> SetGuidance      ("Component o    102   parameter  -> SetGuidance      ("Component of plane normal.");
 86   fpCommand->SetParameter(parameter);             103   fpCommand->SetParameter(parameter);
 87   parameter  =  new G4UIparameter("ny",'d',omi    104   parameter  =  new G4UIparameter("ny",'d',omitable = true);
 88   parameter  -> SetDefaultValue  (0);             105   parameter  -> SetDefaultValue  (0);
 89   parameter  -> SetGuidance      ("Component o    106   parameter  -> SetGuidance      ("Component of plane normal.");
 90   fpCommand->SetParameter(parameter);             107   fpCommand->SetParameter(parameter);
 91   parameter  =  new G4UIparameter("nz",'d',omi    108   parameter  =  new G4UIparameter("nz",'d',omitable = true);
 92   parameter  -> SetDefaultValue  (0);             109   parameter  -> SetDefaultValue  (0);
 93   parameter  -> SetGuidance      ("Component o    110   parameter  -> SetGuidance      ("Component of plane normal.");
 94   fpCommand->SetParameter(parameter);             111   fpCommand->SetParameter(parameter);
 95 }                                                 112 }
 96                                                   113 
 97 G4VisCommandViewerAddCutawayPlane::~G4VisComma    114 G4VisCommandViewerAddCutawayPlane::~G4VisCommandViewerAddCutawayPlane () {
 98   delete fpCommand;                               115   delete fpCommand;
 99 }                                                 116 }
100                                                   117 
101 G4String G4VisCommandViewerAddCutawayPlane::Ge    118 G4String G4VisCommandViewerAddCutawayPlane::GetCurrentValue (G4UIcommand*) {
102   return "";                                      119   return "";
103 }                                                 120 }
104                                                   121 
105 void G4VisCommandViewerAddCutawayPlane::SetNew    122 void G4VisCommandViewerAddCutawayPlane::SetNewValue (G4UIcommand*, G4String newValue) {
106                                                   123 
107   G4VisManager::Verbosity verbosity = fpVisMan    124   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
108                                                   125 
109   G4VViewer* viewer = fpVisManager -> GetCurre    126   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
110   if (!viewer) {                                  127   if (!viewer) {
111     if (verbosity >= G4VisManager::errors) {      128     if (verbosity >= G4VisManager::errors) {
112       G4warn <<                                << 129       G4cerr <<
113   "ERROR: No current viewer - \"/vis/viewer/li    130   "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
114        << G4endl;                                 131        << G4endl;
115     }                                             132     }
116     return;                                       133     return;
117   }                                               134   }
118                                                   135 
119   G4double x, y, z, nx, ny, nz;                   136   G4double x, y, z, nx, ny, nz;
120   G4String unit;                                  137   G4String unit;
121   std::istringstream is (newValue);               138   std::istringstream is (newValue);
122   is >> x >> y >> z >> unit >> nx >> ny >> nz;    139   is >> x >> y >> z >> unit >> nx >> ny >> nz;
123   G4double F = G4UIcommand::ValueOf(unit);        140   G4double F = G4UIcommand::ValueOf(unit);
124   x *= F; y *= F; z *= F;                         141   x *= F; y *= F; z *= F;
125                                                   142 
126   G4ViewParameters vp = viewer->GetViewParamet    143   G4ViewParameters vp = viewer->GetViewParameters();
127   // Make sure normal is normalised.           << 144   vp.AddCutawayPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
128   vp.AddCutawayPlane(G4Plane3D(G4Normal3D(nx,n << 
129   if (verbosity >= G4VisManager::confirmations    145   if (verbosity >= G4VisManager::confirmations) {
130     G4cout << "Cutaway planes for viewer \"" <    146     G4cout << "Cutaway planes for viewer \"" << viewer->GetName() << "\" now:";
131     const G4Planes& cutaways = vp.GetCutawayPl    147     const G4Planes& cutaways = vp.GetCutawayPlanes();
132     for (std::size_t i = 0; i < cutaways.size( << 148     for (size_t i = 0; i < cutaways.size(); ++i)
133       G4cout << "\n  " << i << ": " << cutaway    149       G4cout << "\n  " << i << ": " << cutaways[i];
134     G4cout << G4endl;                             150     G4cout << G4endl;
135   }                                               151   }
136                                                   152 
137   SetViewParameters(viewer, vp);                  153   SetViewParameters(viewer, vp);
138 }                                                 154 }
139                                                   155 
140 ////////////// /vis/viewer/centreOn ////////// << 
141                                                << 
142 G4VisCommandViewerCentreOn::G4VisCommandViewer << 
143   G4bool omitable;                             << 
144   fpCommandCentreAndZoomInOn = new G4UIcommand << 
145   fpCommandCentreAndZoomInOn->SetGuidance      << 
146   ("Centre and zoom in on the given physical v << 
147   fpCommandCentreAndZoomInOn->SetGuidance      << 
148   ("The names of all volumes in all worlds are << 
149    "\ncopy-no is supplied, it matches the copy << 
150    "\nform \"/regexp/\", where regexp is a reg << 
151    "\nthe match uses the usual rules of regula << 
152    "\nOtherwise an exact match is required."   << 
153    "\nFor example, \"/Shap/\" matches \"Shape1 << 
154   fpCommandCentreAndZoomInOn->SetGuidance      << 
155   ("It may help to see a textual representatio << 
156    "\nthe worlds. Try \"/vis/drawTree [worlds] << 
157    "\ncombinations that have the required func << 
158   fpCommandCentreAndZoomInOn->SetGuidance      << 
159    ("If there are more than one matching physi << 
160     "\nincluded. If this is not what you want, << 
161     "\nparticular touchable, then select the t << 
162     "\nuse \"/vis/touchable/centreOn\". (You m << 
163   G4UIparameter* parameter;                    << 
164   parameter =  new G4UIparameter("pv-name",'s' << 
165   parameter->SetGuidance      ("Physical volum << 
166   fpCommandCentreAndZoomInOn->SetParameter(par << 
167   parameter =  new G4UIparameter("copy-no",'i' << 
168   parameter->SetDefaultValue  (-1);            << 
169   parameter->SetGuidance      ("Copy number. - << 
170   fpCommandCentreAndZoomInOn->SetParameter(par << 
171                                                << 
172   fpCommandCentreOn = new G4UIcommand ("/vis/v << 
173   fpCommandCentreOn->SetGuidance ("Centre the  << 
174   // Pick up additional guidance from /vis/vie << 
175   CopyGuidanceFrom(fpCommandCentreAndZoomInOn, << 
176   // Pick up parameters from /vis/viewer/centr << 
177   CopyParametersFrom(fpCommandCentreAndZoomInO << 
178 }                                              << 
179                                                << 
180 G4VisCommandViewerCentreOn::~G4VisCommandViewe << 
181   delete fpCommandCentreAndZoomInOn;           << 
182   delete fpCommandCentreOn;                    << 
183 }                                              << 
184                                                << 
185 G4String G4VisCommandViewerCentreOn::GetCurren << 
186   return "";                                   << 
187 }                                              << 
188                                                << 
189 void G4VisCommandViewerCentreOn::SetNewValue ( << 
190                                                << 
191   G4VisManager::Verbosity verbosity = fpVisMan << 
192   G4bool warn = verbosity >= G4VisManager::war << 
193                                                << 
194   G4VViewer* currentViewer = fpVisManager -> G << 
195   if (!currentViewer) {                        << 
196     if (verbosity >= G4VisManager::errors) {   << 
197       G4warn <<                                << 
198       "ERROR: No current viewer - \"/vis/viewe << 
199       << G4endl;                               << 
200     }                                          << 
201     return;                                    << 
202   }                                            << 
203                                                << 
204   G4String pvName;                             << 
205   G4int copyNo;                                << 
206   std::istringstream is (newValue);            << 
207   is >> pvName >> copyNo;                      << 
208                                                << 
209   // Find physical volumes                     << 
210   G4TransportationManager* transportationManag << 
211   G4TransportationManager::GetTransportationMa << 
212   std::size_t nWorlds = transportationManager- << 
213   std::vector<G4PhysicalVolumesSearchScene::Fi << 
214   std::vector<G4VPhysicalVolume*>::iterator it << 
215   transportationManager->GetWorldsIterator();  << 
216   for (std::size_t i = 0; i < nWorlds; ++i, ++ << 
217     G4PhysicalVolumeModel searchModel (*iterWo << 
218     G4ModelingParameters mp;  // Default - no  << 
219     searchModel.SetModelingParameters (&mp);   << 
220     // Find all instances at any position in t << 
221     G4PhysicalVolumesSearchScene searchScene ( << 
222     searchModel.DescribeYourselfTo (searchScen << 
223     for (const auto& findings: searchScene.Get << 
224       findingsVector.push_back(findings);      << 
225     }                                          << 
226   }                                            << 
227                                                << 
228   if (findingsVector.empty()) {                << 
229     if (verbosity >= G4VisManager::warnings) { << 
230       G4warn                                   << 
231       << "WARNING: Volume \"" << pvName << "\" << 
232       if (copyNo > 0) {                        << 
233         G4warn << "copy number " << copyNo;    << 
234       }                                        << 
235       G4warn << " not found." << G4endl;       << 
236     }                                          << 
237     return;                                    << 
238   }                                            << 
239                                                << 
240   // A vector of found paths so that we can hi << 
241   std::vector<std::vector<G4PhysicalVolumeMode << 
242                                                << 
243   // Use a temporary scene in order to find vi << 
244   G4Scene tempScene("Centre Scene");           << 
245   G4bool successfullyAdded = true;             << 
246   for (const auto& findings: findingsVector) { << 
247     // To handle paramaterisations we have to  << 
248     findings.fpFoundPV->SetCopyNo(findings.fFo << 
249     // Create a temporary physical volume mode << 
250     // They have to be created on the heap bec << 
251     // to hang about long enough to be conflat << 
252     G4PhysicalVolumeModel* tempPVModel = new G << 
253     (findings.fpFoundPV,                       << 
254      0, // Only interested in top volume       << 
255      findings.fFoundObjectTransformation,      << 
256      0, // No modelling parameters (these are  << 
257      true,  // Use full extent                 << 
258      findings.fFoundBasePVPath);               << 
259     // ...and add it to the scene.             << 
260     auto successful = tempScene.AddRunDuration << 
261     if (!successful) {                         << 
262       successfullyAdded = false;               << 
263       continue;                                << 
264     }                                          << 
265     if (verbosity >= G4VisManager::parameters) << 
266       G4cout << "\"" << findings.fpFoundPV->Ge << 
267       << "\", copy no. " << findings.fFoundPVC << 
268       << ",\n  found in searched volume \""    << 
269       << findings.fpSearchPV->GetName()        << 
270       << "\" at depth " << findings.fFoundDept << 
271       << ",\n  base path: \"" << findings.fFou << 
272       << ",\n  has been added to temporary sce << 
273       << G4endl;                               << 
274     }                                          << 
275     foundPaths.push_back(findings.fFoundFullPV << 
276   }                                            << 
277   // Delete temporary physical volume models   << 
278   for (const auto& sceneModel: tempScene.GetRu << 
279     delete sceneModel.fpModel;                 << 
280   }                                            << 
281   if (!successfullyAdded) return;              << 
282                                                << 
283   // Relevant results                          << 
284   const G4VisExtent& newExtent = tempScene.Get << 
285   const G4ThreeVector& newTargetPoint = newExt << 
286                                                << 
287   G4Scene* currentScene = currentViewer->GetSc << 
288   G4ViewParameters saveVP = currentViewer->Get << 
289   G4ViewParameters newVP = saveVP;             << 
290   if (command == fpCommandCentreAndZoomInOn) { << 
291     // Calculate the new zoom factor           << 
292     const G4double zoomFactor                  << 
293     = currentScene->GetExtent().GetExtentRadiu << 
294     newVP.SetZoomFactor(zoomFactor);           << 
295   }                                            << 
296   // Change the target point                   << 
297   const G4Point3D& standardTargetPoint = curre << 
298   newVP.SetCurrentTargetPoint(newTargetPoint - << 
299                                                << 
300   // If this particular view is simple enough  << 
301   if (currentViewer->GetKernelVisitElapsedTime << 
302     // Interpolate                             << 
303     auto keepVisVerbosity = fpVisManager->GetV << 
304     fpVisManager->SetVerboseLevel(G4VisManager << 
305     if (newVP != saveVP) InterpolateToNewView( << 
306     // ...and twinkle                          << 
307     Twinkle(currentViewer,newVP,foundPaths);   << 
308     fpVisManager->SetVerboseLevel(keepVisVerbo << 
309   }                                            << 
310                                                << 
311   if (verbosity >= G4VisManager::confirmations << 
312     G4cout                                     << 
313     << "Viewer \"" << currentViewer->GetName() << 
314     << "\" centred ";                          << 
315     if (fpCommandCentreAndZoomInOn) {          << 
316       G4cout << "and zoomed in";               << 
317     }                                          << 
318     G4cout << " on physical volume(s) \"" << p << 
319     << G4endl;                                 << 
320   }                                            << 
321                                                << 
322   SetViewParameters(currentViewer, newVP);     << 
323 }                                              << 
324                                                << 
325 ////////////// /vis/viewer/changeCutawayPlane     156 ////////////// /vis/viewer/changeCutawayPlane ///////////////////////////////////////
326                                                   157 
327 G4VisCommandViewerChangeCutawayPlane::G4VisCom    158 G4VisCommandViewerChangeCutawayPlane::G4VisCommandViewerChangeCutawayPlane () {
328   G4bool omitable;                                159   G4bool omitable;
329   fpCommand = new G4UIcommand ("/vis/viewer/ch    160   fpCommand = new G4UIcommand ("/vis/viewer/changeCutawayPlane", this);
330   fpCommand -> SetGuidance("Change cutaway pla    161   fpCommand -> SetGuidance("Change cutaway plane.");
331   G4UIparameter* parameter;                       162   G4UIparameter* parameter;
332   parameter  =  new G4UIparameter("index",'i',    163   parameter  =  new G4UIparameter("index",'i',omitable = false);
333   parameter  -> SetGuidance      ("Index of pl    164   parameter  -> SetGuidance      ("Index of plane: 0, 1, 2.");
334   fpCommand->SetParameter(parameter);             165   fpCommand->SetParameter(parameter);
335   parameter  =  new G4UIparameter("x",'d',omit    166   parameter  =  new G4UIparameter("x",'d',omitable = true);
336   parameter  -> SetDefaultValue  (0);             167   parameter  -> SetDefaultValue  (0);
337   parameter  -> SetGuidance      ("Coordinate     168   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
338   fpCommand->SetParameter(parameter);             169   fpCommand->SetParameter(parameter);
339   parameter  =  new G4UIparameter("y",'d',omit    170   parameter  =  new G4UIparameter("y",'d',omitable = true);
340   parameter  -> SetDefaultValue  (0);             171   parameter  -> SetDefaultValue  (0);
341   parameter  -> SetGuidance      ("Coordinate     172   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
342   fpCommand->SetParameter(parameter);             173   fpCommand->SetParameter(parameter);
343   parameter  =  new G4UIparameter("z",'d',omit    174   parameter  =  new G4UIparameter("z",'d',omitable = true);
344   parameter  -> SetDefaultValue  (0);             175   parameter  -> SetDefaultValue  (0);
345   parameter  -> SetGuidance      ("Coordinate     176   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
346   fpCommand->SetParameter(parameter);             177   fpCommand->SetParameter(parameter);
347   parameter  =  new G4UIparameter("unit",'s',o    178   parameter  =  new G4UIparameter("unit",'s',omitable = true);
348   parameter  -> SetDefaultValue  ("m");           179   parameter  -> SetDefaultValue  ("m");
349   parameter  -> SetGuidance      ("Unit of poi    180   parameter  -> SetGuidance      ("Unit of point on the plane.");
350   fpCommand->SetParameter(parameter);             181   fpCommand->SetParameter(parameter);
351   parameter  =  new G4UIparameter("nx",'d',omi    182   parameter  =  new G4UIparameter("nx",'d',omitable = true);
352   parameter  -> SetDefaultValue  (1);             183   parameter  -> SetDefaultValue  (1);
353   parameter  -> SetGuidance      ("Component o    184   parameter  -> SetGuidance      ("Component of plane normal.");
354   fpCommand->SetParameter(parameter);             185   fpCommand->SetParameter(parameter);
355   parameter  =  new G4UIparameter("ny",'d',omi    186   parameter  =  new G4UIparameter("ny",'d',omitable = true);
356   parameter  -> SetDefaultValue  (0);             187   parameter  -> SetDefaultValue  (0);
357   parameter  -> SetGuidance      ("Component o    188   parameter  -> SetGuidance      ("Component of plane normal.");
358   fpCommand->SetParameter(parameter);             189   fpCommand->SetParameter(parameter);
359   parameter  =  new G4UIparameter("nz",'d',omi    190   parameter  =  new G4UIparameter("nz",'d',omitable = true);
360   parameter  -> SetDefaultValue  (0);             191   parameter  -> SetDefaultValue  (0);
361   parameter  -> SetGuidance      ("Component o    192   parameter  -> SetGuidance      ("Component of plane normal.");
362   fpCommand->SetParameter(parameter);             193   fpCommand->SetParameter(parameter);
363 }                                                 194 }
364                                                   195 
365 G4VisCommandViewerChangeCutawayPlane::~G4VisCo    196 G4VisCommandViewerChangeCutawayPlane::~G4VisCommandViewerChangeCutawayPlane () {
366   delete fpCommand;                               197   delete fpCommand;
367 }                                                 198 }
368                                                   199 
369 G4String G4VisCommandViewerChangeCutawayPlane:    200 G4String G4VisCommandViewerChangeCutawayPlane::GetCurrentValue (G4UIcommand*) {
370   return "";                                      201   return "";
371 }                                                 202 }
372                                                   203 
373 void G4VisCommandViewerChangeCutawayPlane::Set    204 void G4VisCommandViewerChangeCutawayPlane::SetNewValue (G4UIcommand*, G4String newValue) {
374                                                   205 
375   G4VisManager::Verbosity verbosity = fpVisMan    206   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
376                                                   207 
377   G4VViewer* viewer = fpVisManager -> GetCurre    208   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
378   if (!viewer) {                                  209   if (!viewer) {
379     if (verbosity >= G4VisManager::errors) {      210     if (verbosity >= G4VisManager::errors) {
380       G4warn <<                                << 211       G4cerr <<
381   "ERROR: No current viewer - \"/vis/viewer/li    212   "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
382        << G4endl;                                 213        << G4endl;
383     }                                             214     }
384     return;                                       215     return;
385   }                                               216   }
386                                                   217 
387   std::size_t index;                           << 218   size_t index;
388   G4double x, y, z, nx, ny, nz;                   219   G4double x, y, z, nx, ny, nz;
389   G4String unit;                                  220   G4String unit;
390   std::istringstream is (newValue);               221   std::istringstream is (newValue);
391   is >> index >> x >> y >> z >> unit >> nx >>     222   is >> index >> x >> y >> z >> unit >> nx >> ny >> nz;
392   G4double F = G4UIcommand::ValueOf(unit);        223   G4double F = G4UIcommand::ValueOf(unit);
393   x *= F; y *= F; z *= F;                         224   x *= F; y *= F; z *= F;
394                                                   225 
395   G4ViewParameters vp = viewer->GetViewParamet    226   G4ViewParameters vp = viewer->GetViewParameters();
396   // Make sure normal is normalised.           << 
397   vp.ChangeCutawayPlane(index,                    227   vp.ChangeCutawayPlane(index,
398       G4Plane3D(G4Normal3D(nx,ny,nz).unit(), G << 228       G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
399   if (verbosity >= G4VisManager::confirmations    229   if (verbosity >= G4VisManager::confirmations) {
400     G4cout << "Cutaway planes for viewer \"" <    230     G4cout << "Cutaway planes for viewer \"" << viewer->GetName() << "\" now:";
401     const G4Planes& cutaways = vp.GetCutawayPl    231     const G4Planes& cutaways = vp.GetCutawayPlanes();
402     for (std::size_t i = 0; i < cutaways.size( << 232     for (size_t i = 0; i < cutaways.size(); ++i)
403       G4cout << "\n  " << i << ": " << cutaway    233       G4cout << "\n  " << i << ": " << cutaways[i];
404     G4cout << G4endl;                             234     G4cout << G4endl;
405   }                                               235   }
406                                                   236 
407   SetViewParameters(viewer, vp);                  237   SetViewParameters(viewer, vp);
408 }                                                 238 }
409                                                   239 
410 ////////////// /vis/viewer/clear /////////////    240 ////////////// /vis/viewer/clear ///////////////////////////////////////
411                                                   241 
412 G4VisCommandViewerClear::G4VisCommandViewerCle    242 G4VisCommandViewerClear::G4VisCommandViewerClear () {
413   G4bool omitable, currentAsDefault;              243   G4bool omitable, currentAsDefault;
414   fpCommand = new G4UIcmdWithAString ("/vis/vi    244   fpCommand = new G4UIcmdWithAString ("/vis/viewer/clear", this);
415   fpCommand -> SetGuidance ("Clears viewer.");    245   fpCommand -> SetGuidance ("Clears viewer.");
416   fpCommand -> SetGuidance                        246   fpCommand -> SetGuidance 
417     ("By default, clears current viewer.  Spec    247     ("By default, clears current viewer.  Specified viewer becomes current."
418      "\n\"/vis/viewer/list\" to see  possible     248      "\n\"/vis/viewer/list\" to see  possible viewer names.");
419   fpCommand -> SetParameterName ("viewer-name"    249   fpCommand -> SetParameterName ("viewer-name",
420          omitable = true,                         250          omitable = true,
421          currentAsDefault = true);                251          currentAsDefault = true);
422 }                                                 252 }
423                                                   253 
424 G4VisCommandViewerClear::~G4VisCommandViewerCl    254 G4VisCommandViewerClear::~G4VisCommandViewerClear () {
425   delete fpCommand;                               255   delete fpCommand;
426 }                                                 256 }
427                                                   257 
428 G4String G4VisCommandViewerClear::GetCurrentVa    258 G4String G4VisCommandViewerClear::GetCurrentValue (G4UIcommand*) {
429   G4VViewer* viewer = fpVisManager -> GetCurre    259   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
430   return viewer ? viewer -> GetName () : G4Str    260   return viewer ? viewer -> GetName () : G4String("none");
431 }                                                 261 }
432                                                   262 
433 void G4VisCommandViewerClear::SetNewValue (G4U    263 void G4VisCommandViewerClear::SetNewValue (G4UIcommand*, G4String newValue) {
434                                                   264 
435   G4VisManager::Verbosity verbosity = fpVisMan    265   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
436                                                   266 
437   G4String& clearName = newValue;                 267   G4String& clearName = newValue;
438   G4VViewer* viewer = fpVisManager -> GetViewe    268   G4VViewer* viewer = fpVisManager -> GetViewer (clearName);
439   if (!viewer) {                                  269   if (!viewer) {
440     if (verbosity >= G4VisManager::errors) {      270     if (verbosity >= G4VisManager::errors) {
441       G4warn << "ERROR: Viewer \"" << clearNam << 271       G4cerr << "ERROR: Viewer \"" << clearName
442        << "\" not found - \"/vis/viewer/list\"    272        << "\" not found - \"/vis/viewer/list\" to see possibilities."
443        << G4endl;                                 273        << G4endl;
444     }                                             274     }
445     return;                                       275     return;
446   }                                               276   }
447                                                   277 
448   viewer->SetView();                           << 
449   viewer->ClearView();                            278   viewer->ClearView();
450   viewer->FinishView();                           279   viewer->FinishView();
451   if (verbosity >= G4VisManager::confirmations    280   if (verbosity >= G4VisManager::confirmations) {
452     G4cout << "Viewer \"" << clearName << "\"     281     G4cout << "Viewer \"" << clearName << "\" cleared." << G4endl;
453   }                                               282   }
454                                                   283 
455 }                                                 284 }
456                                                   285 
457 ////////////// /vis/viewer/clearCutawayPlanes     286 ////////////// /vis/viewer/clearCutawayPlanes ///////////////////////////////////////
458                                                   287 
459 G4VisCommandViewerClearCutawayPlanes::G4VisCom    288 G4VisCommandViewerClearCutawayPlanes::G4VisCommandViewerClearCutawayPlanes () {
460   fpCommand = new G4UIcmdWithoutParameter         289   fpCommand = new G4UIcmdWithoutParameter
461     ("/vis/viewer/clearCutawayPlanes", this);     290     ("/vis/viewer/clearCutawayPlanes", this);
462   fpCommand -> SetGuidance ("Clear cutaway pla    291   fpCommand -> SetGuidance ("Clear cutaway planes of current viewer.");
463 }                                                 292 }
464                                                   293 
465 G4VisCommandViewerClearCutawayPlanes::~G4VisCo    294 G4VisCommandViewerClearCutawayPlanes::~G4VisCommandViewerClearCutawayPlanes () {
466   delete fpCommand;                               295   delete fpCommand;
467 }                                                 296 }
468                                                   297 
469 G4String G4VisCommandViewerClearCutawayPlanes:    298 G4String G4VisCommandViewerClearCutawayPlanes::GetCurrentValue (G4UIcommand*) {
470   return "";                                      299   return "";
471 }                                                 300 }
472                                                   301 
473 void G4VisCommandViewerClearCutawayPlanes::Set    302 void G4VisCommandViewerClearCutawayPlanes::SetNewValue (G4UIcommand*, G4String) {
474                                                   303 
475   G4VisManager::Verbosity verbosity = fpVisMan    304   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
476                                                   305 
477   G4VViewer* viewer = fpVisManager -> GetCurre    306   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
478   if (!viewer) {                                  307   if (!viewer) {
479     if (verbosity >= G4VisManager::errors) {      308     if (verbosity >= G4VisManager::errors) {
480       G4warn <<                                << 309       G4cerr <<
481   "ERROR: No current viewer - \"/vis/viewer/li    310   "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
482        << G4endl;                                 311        << G4endl;
483     }                                             312     }
484     return;                                       313     return;
485   }                                               314   }
486                                                   315 
487   G4ViewParameters vp = viewer->GetViewParamet    316   G4ViewParameters vp = viewer->GetViewParameters();
488   vp.ClearCutawayPlanes();                        317   vp.ClearCutawayPlanes();
489   if (verbosity >= G4VisManager::confirmations    318   if (verbosity >= G4VisManager::confirmations) {
490     G4cout << "Cutaway planes for viewer \"" <    319     G4cout << "Cutaway planes for viewer \"" << viewer->GetName()
491      << "\" now cleared." << G4endl;              320      << "\" now cleared." << G4endl;
492   }                                               321   }
493                                                   322 
494   SetViewParameters(viewer, vp);                  323   SetViewParameters(viewer, vp);
495 }                                                 324 }
496                                                   325 
497 ////////////// /vis/viewer/clearTransients ///    326 ////////////// /vis/viewer/clearTransients //////////////////////////
498                                                   327 
499 G4VisCommandViewerClearTransients::G4VisComman    328 G4VisCommandViewerClearTransients::G4VisCommandViewerClearTransients () {
500   G4bool omitable, currentAsDefault;              329   G4bool omitable, currentAsDefault;
501   fpCommand = new G4UIcmdWithAString ("/vis/vi    330   fpCommand = new G4UIcmdWithAString ("/vis/viewer/clearTransients", this);
502   fpCommand -> SetGuidance ("Clears transients    331   fpCommand -> SetGuidance ("Clears transients from viewer.");
503   fpCommand -> SetGuidance                        332   fpCommand -> SetGuidance 
504   ("By default, operates on current viewer.  S    333   ("By default, operates on current viewer.  Specified viewer becomes current."
505      "\n\"/vis/viewer/list\" to see  possible     334      "\n\"/vis/viewer/list\" to see  possible viewer names.");
506   fpCommand -> SetParameterName ("viewer-name"    335   fpCommand -> SetParameterName ("viewer-name",
507          omitable = true,                         336          omitable = true,
508          currentAsDefault = true);                337          currentAsDefault = true);
509 }                                                 338 }
510                                                   339 
511 G4VisCommandViewerClearTransients::~G4VisComma    340 G4VisCommandViewerClearTransients::~G4VisCommandViewerClearTransients () {
512   delete fpCommand;                               341   delete fpCommand;
513 }                                                 342 }
514                                                   343 
515 G4String G4VisCommandViewerClearTransients::Ge    344 G4String G4VisCommandViewerClearTransients::GetCurrentValue (G4UIcommand*) {
516   G4VViewer* viewer = fpVisManager -> GetCurre    345   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
517   return viewer ? viewer -> GetName () : G4Str    346   return viewer ? viewer -> GetName () : G4String("none");
518 }                                                 347 }
519                                                   348 
520 void G4VisCommandViewerClearTransients::SetNew    349 void G4VisCommandViewerClearTransients::SetNewValue (G4UIcommand*, G4String newValue) {
521                                                   350 
522   G4VisManager::Verbosity verbosity = fpVisMan    351   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
523                                                   352 
524   G4String& clearName = newValue;                 353   G4String& clearName = newValue;
525   G4VViewer* viewer = fpVisManager -> GetViewe    354   G4VViewer* viewer = fpVisManager -> GetViewer (clearName);
526   if (!viewer) {                                  355   if (!viewer) {
527     if (verbosity >= G4VisManager::errors) {      356     if (verbosity >= G4VisManager::errors) {
528       G4warn << "ERROR: Viewer \"" << clearNam << 357       G4cerr << "ERROR: Viewer \"" << clearName
529        << "\" not found - \"/vis/viewer/list\"    358        << "\" not found - \"/vis/viewer/list\" to see possibilities."
530        << G4endl;                                 359        << G4endl;
531     }                                             360     }
532     return;                                       361     return;
533   }                                               362   }
534                                                   363 
535   G4VSceneHandler* sceneHandler = viewer->GetS    364   G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
536   sceneHandler->SetMarkForClearingTransientSto    365   sceneHandler->SetMarkForClearingTransientStore(false);
537   fpVisManager->ResetTransientsDrawnFlags();      366   fpVisManager->ResetTransientsDrawnFlags();
538   sceneHandler->ClearTransientStore();            367   sceneHandler->ClearTransientStore();
539   if (verbosity >= G4VisManager::confirmations    368   if (verbosity >= G4VisManager::confirmations) {
540     G4cout << "Viewer \"" << clearName << "\"     369     G4cout << "Viewer \"" << clearName << "\" cleared of transients."
541      << G4endl;                                   370      << G4endl;
542   }                                               371   }
543                                                   372 
544 }                                                 373 }
545                                                   374 
546 ////////////// /vis/viewer/clearVisAttributesM << 
547                                                << 
548 G4VisCommandViewerClearVisAttributesModifiers: << 
549   fpCommand = new G4UIcmdWithoutParameter      << 
550   ("/vis/viewer/clearVisAttributesModifiers",  << 
551   fpCommand -> SetGuidance ("Clear vis attribu << 
552   fpCommand -> SetGuidance ("(These are used f << 
553 }                                              << 
554                                                << 
555 G4VisCommandViewerClearVisAttributesModifiers: << 
556   delete fpCommand;                            << 
557 }                                              << 
558                                                << 
559 G4String G4VisCommandViewerClearVisAttributesM << 
560   return "";                                   << 
561 }                                              << 
562                                                << 
563 void G4VisCommandViewerClearVisAttributesModif << 
564                                                << 
565   G4VisManager::Verbosity verbosity = fpVisMan << 
566                                                << 
567   G4VViewer* viewer = fpVisManager -> GetCurre << 
568   if (!viewer) {                               << 
569     if (verbosity >= G4VisManager::errors) {   << 
570       G4warn <<                                << 
571       "ERROR: No current viewer - \"/vis/viewe << 
572        << G4endl;                              << 
573     }                                          << 
574     return;                                    << 
575   }                                            << 
576                                                << 
577   G4ViewParameters vp = viewer->GetViewParamet << 
578   vp.ClearVisAttributesModifiers();            << 
579   if (verbosity >= G4VisManager::confirmations << 
580     G4cout << "Vis attributes modifiers for vi << 
581      << "\" now cleared." << G4endl;           << 
582   }                                            << 
583                                                << 
584   SetViewParameters(viewer, vp);               << 
585 }                                              << 
586                                                << 
587 ////////////// /vis/viewer/clone /////////////    375 ////////////// /vis/viewer/clone ///////////////////////////////////////
588                                                   376 
589 G4VisCommandViewerClone::G4VisCommandViewerClo    377 G4VisCommandViewerClone::G4VisCommandViewerClone () {
590   G4bool omitable;                                378   G4bool omitable;
591   fpCommand = new G4UIcommand ("/vis/viewer/cl    379   fpCommand = new G4UIcommand ("/vis/viewer/clone", this);
592   fpCommand -> SetGuidance ("Clones viewer.");    380   fpCommand -> SetGuidance ("Clones viewer.");
593   fpCommand -> SetGuidance                        381   fpCommand -> SetGuidance 
594     ("By default, clones current viewer.  Clon    382     ("By default, clones current viewer.  Clone becomes current."
595      "\nClone name, if not provided, is derive    383      "\nClone name, if not provided, is derived from the original name."
596      "\n\"/vis/viewer/list\" to see  possible     384      "\n\"/vis/viewer/list\" to see  possible viewer names.");
597   G4UIparameter* parameter;                       385   G4UIparameter* parameter;
598   parameter = new G4UIparameter ("original-vie    386   parameter = new G4UIparameter ("original-viewer-name", 's', omitable = true);
599   parameter -> SetCurrentAsDefault (true);        387   parameter -> SetCurrentAsDefault (true);
600   fpCommand -> SetParameter (parameter);          388   fpCommand -> SetParameter (parameter);
601   parameter = new G4UIparameter ("clone-name",    389   parameter = new G4UIparameter ("clone-name", 's', omitable = true);
602   parameter -> SetDefaultValue ("none");          390   parameter -> SetDefaultValue ("none");
603   fpCommand -> SetParameter (parameter);          391   fpCommand -> SetParameter (parameter);
604 }                                                 392 }
605                                                   393 
606 G4VisCommandViewerClone::~G4VisCommandViewerCl    394 G4VisCommandViewerClone::~G4VisCommandViewerClone () {
607   delete fpCommand;                               395   delete fpCommand;
608 }                                                 396 }
609                                                   397 
610 G4String G4VisCommandViewerClone::GetCurrentVa    398 G4String G4VisCommandViewerClone::GetCurrentValue (G4UIcommand*) {
611   G4VViewer* viewer = fpVisManager -> GetCurre    399   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
612   G4String originalName = viewer ? viewer -> G    400   G4String originalName = viewer ? viewer -> GetName () : G4String("none");
613   return "\"" + originalName + "\"";              401   return "\"" + originalName + "\"";
614 }                                                 402 }
615                                                   403 
616 void G4VisCommandViewerClone::SetNewValue (G4U    404 void G4VisCommandViewerClone::SetNewValue (G4UIcommand*, G4String newValue) {
617                                                   405 
618   G4VisManager::Verbosity verbosity = fpVisMan    406   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
619                                                   407 
620   G4String originalName, cloneName;               408   G4String originalName, cloneName;
621   std::istringstream is (newValue);               409   std::istringstream is (newValue);
622                                                   410 
623   // Need to handle the possibility that the n    411   // Need to handle the possibility that the names contain embedded
624   // blanks within quotation marks...             412   // blanks within quotation marks...
625   char c = ' ';                                << 413   char c;
626   while (is.get(c) && c == ' '){}                 414   while (is.get(c) && c == ' '){}
627   if (c == '"') {                                 415   if (c == '"') {
628     while (is.get(c) && c != '"') {originalNam    416     while (is.get(c) && c != '"') {originalName += c;}
629   }                                               417   }
630   else {                                          418   else {
631     originalName += c;                            419     originalName += c;
632     while (is.get(c) && c != ' ') {originalNam    420     while (is.get(c) && c != ' ') {originalName += c;}
633   }                                               421   }
634   G4StrUtil::strip(originalName, ' ');         << 422   originalName = originalName.strip (G4String::both, ' ');
635   G4StrUtil::strip(originalName, '"');         << 423   originalName = originalName.strip (G4String::both, '"');
636                                                   424 
637   G4VViewer* originalViewer = fpVisManager ->     425   G4VViewer* originalViewer = fpVisManager -> GetViewer (originalName);
638   if (!originalViewer) {                          426   if (!originalViewer) {
639     if (verbosity >= G4VisManager::errors) {      427     if (verbosity >= G4VisManager::errors) {
640       G4warn << "ERROR: Viewer \"" << original << 428       G4cerr << "ERROR: Viewer \"" << originalName
641        << "\" not found - \"/vis/viewer/list\"    429        << "\" not found - \"/vis/viewer/list\" to see possibilities."
642        << G4endl;                                 430        << G4endl;
643     }                                             431     }
644     return;                                       432     return;
645   }                                               433   }
646   originalName = originalViewer->GetName();  /    434   originalName = originalViewer->GetName();  // Ensures long name.
647                                                   435 
648   while (is.get(c) && c == ' '){}                 436   while (is.get(c) && c == ' '){}
649   if (c == '"') {                                 437   if (c == '"') {
650     while (is.get(c) && c != '"') {cloneName +    438     while (is.get(c) && c != '"') {cloneName += c;}
651   }                                               439   }
652   else {                                          440   else {
653     cloneName += c;                               441     cloneName += c;
654     while (is.get(c) && c != ' ') {cloneName +    442     while (is.get(c) && c != ' ') {cloneName += c;}
655   }                                               443   }
656   G4StrUtil::strip(cloneName, ' ');            << 444   cloneName = cloneName.strip (G4String::both, ' ');
657   G4StrUtil::strip(cloneName, '"');            << 445   cloneName = cloneName.strip (G4String::both, '"');
658                                                   446 
659   G4bool errorWhileNaming = false;                447   G4bool errorWhileNaming = false;
660   if (cloneName == "none") {                      448   if (cloneName == "none") {
661     G4int subID = 0;                              449     G4int subID = 0;
662     do {                                          450     do {
663       cloneName = originalName;                   451       cloneName = originalName;
664       std::ostringstream oss;                     452       std::ostringstream oss;
665       oss << '-' << subID++;                      453       oss << '-' << subID++;
666       G4String::size_type lastDashPosition, ne    454       G4String::size_type lastDashPosition, nextSpacePosition;
667       if ((lastDashPosition = cloneName.rfind(    455       if ((lastDashPosition = cloneName.rfind('-')) !=  G4String::npos &&
668     (nextSpacePosition = cloneName.find(" ", l    456     (nextSpacePosition = cloneName.find(" ", lastDashPosition)) !=
669     G4String::npos) {                             457     G4String::npos) {
670   cloneName.insert(nextSpacePosition, oss.str(    458   cloneName.insert(nextSpacePosition, oss.str());
671       } else {                                    459       } else {
672   G4String::size_type spacePosition = cloneNam    460   G4String::size_type spacePosition = cloneName.find(' ');
673   if (spacePosition != G4String::npos)            461   if (spacePosition != G4String::npos)
674     cloneName.insert(spacePosition, oss.str())    462     cloneName.insert(spacePosition, oss.str());
675   else                                            463   else
676     errorWhileNaming = true;                      464     errorWhileNaming = true;
677       }                                           465       }
678     } while (!errorWhileNaming && fpVisManager    466     } while (!errorWhileNaming && fpVisManager -> GetViewer (cloneName));
679   }                                               467   }
680                                                   468 
681   if (errorWhileNaming) {                         469   if (errorWhileNaming) {
682     if (verbosity >= G4VisManager::errors) {      470     if (verbosity >= G4VisManager::errors) {
683       G4warn << "ERROR: While naming clone vie << 471       G4cerr << "ERROR: While naming clone viewer \"" << cloneName
684        << "\"."                                   472        << "\"."
685        << G4endl;                                 473        << G4endl;
686     }                                             474     }
687     return;                                       475     return;
688   }                                               476   }
689                                                   477 
690   if (fpVisManager -> GetViewer (cloneName)) {    478   if (fpVisManager -> GetViewer (cloneName)) {
691     if (verbosity >= G4VisManager::errors) {      479     if (verbosity >= G4VisManager::errors) {
692       G4warn << "ERROR: Putative clone viewer  << 480       G4cerr << "ERROR: Putative clone viewer \"" << cloneName
693        << "\" already exists."                    481        << "\" already exists."
694        << G4endl;                                 482        << G4endl;
695     }                                             483     }
696     return;                                       484     return;
697   }                                               485   }
698                                                   486 
699   G4String windowSizeHint =                       487   G4String windowSizeHint =
700     originalViewer->GetViewParameters().GetXGe    488     originalViewer->GetViewParameters().GetXGeometryString();
701                                                   489 
702   G4UImanager* UImanager = G4UImanager::GetUIp    490   G4UImanager* UImanager = G4UImanager::GetUIpointer();
                                                   >> 491   G4int keepVerbose = UImanager->GetVerboseLevel();
                                                   >> 492   G4int newVerbose(0);
                                                   >> 493   if (keepVerbose >= 2 ||
                                                   >> 494       fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
                                                   >> 495     newVerbose = 2;
                                                   >> 496   UImanager->SetVerboseLevel(newVerbose);
703   UImanager->ApplyCommand(G4String("/vis/viewe    497   UImanager->ApplyCommand(G4String("/vis/viewer/select " + originalName));
704   UImanager->ApplyCommand                         498   UImanager->ApplyCommand
705     (G4String("/vis/viewer/create ! \"" + clon    499     (G4String("/vis/viewer/create ! \"" + cloneName + "\" " + windowSizeHint));
706   UImanager->ApplyCommand(G4String("/vis/viewe    500   UImanager->ApplyCommand(G4String("/vis/viewer/set/all " + originalName));
                                                   >> 501   UImanager->SetVerboseLevel(keepVerbose);
707                                                   502 
708   if (verbosity >= G4VisManager::confirmations    503   if (verbosity >= G4VisManager::confirmations) {
709     G4cout << "Viewer \"" << originalName << "    504     G4cout << "Viewer \"" << originalName << "\" cloned." << G4endl;
710     G4cout << "Clone \"" << cloneName << "\" n    505     G4cout << "Clone \"" << cloneName << "\" now current." << G4endl;
711   }                                               506   }
712 }                                                 507 }
713                                                   508 
714 ////////////// /vis/viewer/colourByDensity /// << 
715                                                << 
716 G4VisCommandViewerColourByDensity::G4VisComman << 
717   G4bool omitable;                             << 
718   fpCommand = new G4UIcommand ("/vis/viewer/co << 
719   fpCommand -> SetGuidance                     << 
720   ("If a volume has no vis attributes, colour  << 
721   fpCommand -> SetGuidance                     << 
722   ("Provide algorithm number, e.g., \"1\" (or  << 
723    "\nThen a unit of density, e.g., \"g/cm3\". << 
724    "\nThen parameters for the algorithm assume << 
725   fpCommand -> SetGuidance                     << 
726   ("Algorithm 1: Simple algorithm takes 3 para << 
727    "\n  Volumes with density < d0 are invisibl << 
728    "\n  Volumes with d0 <= density < d1 have c << 
729    "\n  Volumes with d1 <= density < d2 have c << 
730    "\n  Volumes with density > d2 are blue."); << 
731   G4UIparameter* parameter;                    << 
732   parameter  =  new G4UIparameter("n",'i',omit << 
733   parameter  -> SetGuidance      ("Algorithm n << 
734   parameter  -> SetDefaultValue  (1);          << 
735   fpCommand->SetParameter(parameter);          << 
736   parameter  =  new G4UIparameter("unit",'s',o << 
737   parameter  -> SetGuidance      ("Unit of fol << 
738   parameter  -> SetDefaultValue  ("g/cm3");    << 
739   fpCommand->SetParameter(parameter);          << 
740   parameter  =  new G4UIparameter("d0",'d',omi << 
741   parameter  -> SetGuidance      ("Density par << 
742   parameter  -> SetDefaultValue  (0.5);        << 
743   fpCommand->SetParameter(parameter);          << 
744   parameter  =  new G4UIparameter("d1",'d',omi << 
745   parameter  -> SetGuidance      ("Density par << 
746   parameter  -> SetDefaultValue  (3.0);        << 
747   fpCommand->SetParameter(parameter);          << 
748   parameter  =  new G4UIparameter("d2",'d',omi << 
749   parameter  -> SetGuidance      ("Density par << 
750   parameter  -> SetDefaultValue  (10.0);       << 
751   fpCommand->SetParameter(parameter);          << 
752 }                                              << 
753                                                << 
754 G4VisCommandViewerColourByDensity::~G4VisComma << 
755   delete fpCommand;                            << 
756 }                                              << 
757                                                << 
758 G4String G4VisCommandViewerColourByDensity::Ge << 
759   return "";                                   << 
760 }                                              << 
761                                                << 
762 void G4VisCommandViewerColourByDensity::SetNew << 
763                                                << 
764   G4VisManager::Verbosity verbosity = fpVisMan << 
765                                                << 
766   G4VViewer* viewer = fpVisManager -> GetCurre << 
767   if (!viewer) {                               << 
768     if (verbosity >= G4VisManager::errors) {   << 
769       G4warn <<                                << 
770       "ERROR: No current viewer - \"/vis/viewe << 
771       << G4endl;                               << 
772     }                                          << 
773     return;                                    << 
774   }                                            << 
775   G4ViewParameters vp = viewer->GetViewParamet << 
776                                                << 
777   G4int algorithmNumber;                       << 
778   G4double d0, d1, d2;                         << 
779   G4String unit;                               << 
780   std::istringstream is (newValue);            << 
781   is >> algorithmNumber >> unit >> d0 >> d1 >> << 
782                                                << 
783   if (algorithmNumber < 0 || algorithmNumber > << 
784     if (verbosity >= G4VisManager::errors) {   << 
785       G4warn <<                                << 
786       "ERROR: Unrecognised algorithm number: " << 
787       << G4endl;                               << 
788     }                                          << 
789     return;                                    << 
790   }                                            << 
791                                                << 
792   std::vector<G4double> parameters;            << 
793   if (algorithmNumber > 0) {                   << 
794     const G4String where = "G4VisCommandViewer << 
795     G4double valueOfUnit;                      << 
796     // "Volumic Mass" is Michel's phrase for " << 
797     if (ProvideValueOfUnit(where,unit,"Volumic << 
798       // Successful outcome of unit search     << 
799       d0 *= valueOfUnit; d1 *= valueOfUnit; d2 << 
800     } else {                                   << 
801       if (verbosity >= G4VisManager::errors) { << 
802         G4warn <<                              << 
803         "ERROR: Unrecognised or inappropriate  << 
804         << G4endl;                             << 
805       }                                        << 
806       return;                                  << 
807     }                                          << 
808     parameters.push_back(d0);                  << 
809     parameters.push_back(d1);                  << 
810     parameters.push_back(d2);                  << 
811   }                                            << 
812   vp.SetCBDAlgorithmNumber(algorithmNumber);   << 
813   vp.SetCBDParameters(parameters);             << 
814                                                << 
815   if (verbosity >= G4VisManager::confirmations << 
816     if (vp.GetCBDAlgorithmNumber() == 0) {     << 
817       G4cout << "Colour by density deactivated << 
818     } else {                                   << 
819       G4cout << "Colour by density algorithm " << 
820       << " selected for viewer \"" << viewer-> << 
821       << "\n  Parameters:";                    << 
822       for (auto p: vp.GetCBDParameters()) {    << 
823         G4cout << ' ' << G4BestUnit(p,"Volumic << 
824       }                                        << 
825       G4cout << G4endl;                        << 
826     }                                          << 
827   }                                            << 
828                                                << 
829   SetViewParameters(viewer, vp);               << 
830 }                                              << 
831                                                << 
832 ////////////// /vis/viewer/copyViewFrom //////    509 ////////////// /vis/viewer/copyViewFrom //////////////////////////
833                                                   510 
834 G4VisCommandViewerCopyViewFrom::G4VisCommandVi    511 G4VisCommandViewerCopyViewFrom::G4VisCommandViewerCopyViewFrom () {
835   G4bool omitable;                                512   G4bool omitable;
836   fpCommand = new G4UIcmdWithAString ("/vis/vi    513   fpCommand = new G4UIcmdWithAString ("/vis/viewer/copyViewFrom", this);
837   fpCommand -> SetGuidance                        514   fpCommand -> SetGuidance
838   ("Copy the camera-specific parameters from t    515   ("Copy the camera-specific parameters from the specified viewer.");
839   fpCommand -> SetGuidance                        516   fpCommand -> SetGuidance
840   ("Note: To copy ALL view parameters, includi << 517   ("Note: To copy scene modifications - style, etc. - please use"
841    "\nuse \"/vis/viewer/set/all\"");           << 518    "\n\"/vis/viewer/set/all\"");
842   fpCommand -> SetParameterName ("from-viewer-    519   fpCommand -> SetParameterName ("from-viewer-name", omitable = false);
843 }                                                 520 }
844                                                   521 
845 G4VisCommandViewerCopyViewFrom::~G4VisCommandV    522 G4VisCommandViewerCopyViewFrom::~G4VisCommandViewerCopyViewFrom () {
846   delete fpCommand;                               523   delete fpCommand;
847 }                                                 524 }
848                                                   525 
849 G4String G4VisCommandViewerCopyViewFrom::GetCu    526 G4String G4VisCommandViewerCopyViewFrom::GetCurrentValue (G4UIcommand*) {
850   return "";                                      527   return "";
851 }                                                 528 }
852                                                   529 
853 void G4VisCommandViewerCopyViewFrom::SetNewVal    530 void G4VisCommandViewerCopyViewFrom::SetNewValue (G4UIcommand*, G4String newValue) {
854                                                   531 
855   G4VisManager::Verbosity verbosity = fpVisMan    532   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
856                                                   533 
857   G4VViewer* currentViewer = fpVisManager->Get    534   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
858   if (!currentViewer) {                           535   if (!currentViewer) {
859     if (verbosity >= G4VisManager::errors) {      536     if (verbosity >= G4VisManager::errors) {
860       G4warn <<                                << 537       G4cerr <<
861   "ERROR: G4VisCommandsViewerCopyViewFrom::Set    538   "ERROR: G4VisCommandsViewerCopyViewFrom::SetNewValue: no current viewer."
862              << G4endl;                           539              << G4endl;
863     }                                             540     }
864     return;                                       541     return;
865   }                                               542   }
866                                                   543 
867   const G4String& fromViewerName = newValue;      544   const G4String& fromViewerName = newValue;
868   G4VViewer* fromViewer = fpVisManager -> GetV    545   G4VViewer* fromViewer = fpVisManager -> GetViewer (fromViewerName);
869   if (!fromViewer) {                              546   if (!fromViewer) {
870     if (verbosity >= G4VisManager::errors) {      547     if (verbosity >= G4VisManager::errors) {
871       G4warn << "ERROR: Viewer \"" << fromView << 548       G4cerr << "ERROR: Viewer \"" << fromViewerName
872        << "\" not found - \"/vis/viewer/list\"    549        << "\" not found - \"/vis/viewer/list\" to see possibilities."
873        << G4endl;                                 550        << G4endl;
874     }                                             551     }
875     return;                                       552     return;
876   }                                               553   }
877                                                   554 
878   if (fromViewer == currentViewer) {              555   if (fromViewer == currentViewer) {
879     if (verbosity >= G4VisManager::warnings) {    556     if (verbosity >= G4VisManager::warnings) {
880       G4warn <<                                << 557       G4cout <<
881         "WARNING: G4VisCommandsViewerSet::SetN    558         "WARNING: G4VisCommandsViewerSet::SetNewValue:"
882         "\n  from-viewer and current viewer ar    559         "\n  from-viewer and current viewer are identical."
883              << G4endl;                           560              << G4endl;
884     }                                             561     }
885     return;                                       562     return;
886   }                                               563   }
887                                                   564 
888   // Copy camera-specific view parameters         565   // Copy camera-specific view parameters
889   G4ViewParameters vp = currentViewer->GetView    566   G4ViewParameters vp = currentViewer->GetViewParameters();
890   CopyCameraParameters(vp, fromViewer->GetView << 567   const G4ViewParameters& fromVP = fromViewer->GetViewParameters();
                                                   >> 568   vp.SetViewpointDirection  (fromVP.GetViewpointDirection());
                                                   >> 569   vp.SetLightpointDirection (fromVP.GetLightpointDirection());
                                                   >> 570   vp.SetLightsMoveWithCamera(fromVP.GetLightsMoveWithCamera());
                                                   >> 571   vp.SetUpVector            (fromVP.GetUpVector());
                                                   >> 572   vp.SetFieldHalfAngle      (fromVP.GetFieldHalfAngle());
                                                   >> 573   vp.SetZoomFactor          (fromVP.GetZoomFactor());
                                                   >> 574   vp.SetScaleFactor         (fromVP.GetScaleFactor());
                                                   >> 575   vp.SetCurrentTargetPoint  (fromVP.GetCurrentTargetPoint());
                                                   >> 576   vp.SetDolly               (fromVP.GetDolly());
891   SetViewParameters(currentViewer, vp);           577   SetViewParameters(currentViewer, vp);
892                                                   578   
893   if (verbosity >= G4VisManager::confirmations    579   if (verbosity >= G4VisManager::confirmations) {
894     G4cout << "Camera parameters of viewer \""    580     G4cout << "Camera parameters of viewer \"" << currentViewer->GetName()
895      << "\"\n  set to those of viewer \"" << f    581      << "\"\n  set to those of viewer \"" << fromViewer->GetName()
896      << "\"."                                     582      << "\"."
897      << G4endl;                                   583      << G4endl;
898   }                                               584   }
899 }                                                 585 }
900                                                   586 
901 ////////////// /vis/viewer/create ////////////    587 ////////////// /vis/viewer/create ///////////////////////////////////////
902                                                   588 
903 G4VisCommandViewerCreate::G4VisCommandViewerCr    589 G4VisCommandViewerCreate::G4VisCommandViewerCreate (): fId (0) {
904   G4bool omitable;                                590   G4bool omitable;
905   fpCommand = new G4UIcommand ("/vis/viewer/cr    591   fpCommand = new G4UIcommand ("/vis/viewer/create", this);
906   fpCommand -> SetGuidance                        592   fpCommand -> SetGuidance
907     ("Creates a viewer. If the scene handler n << 593     ("Creates a viewer for the specified scene handler.");
908      "\nviewer of that scene handler is create << 
909      "\nof the current scene handler is create << 
910   fpCommand -> SetGuidance                     << 
911     ("If the viewer name is not specified a na << 
912      "\nof the scene handler and a serial numb << 
913   fpCommand -> SetGuidance("The scene handler  << 
914   fpCommand -> SetGuidance                     << 
915     ("(Note: the system adds the graphics syst << 
916      "\nfor identification, but for selecting, << 
917      "\nup to the first blank are used. For ex << 
918      "\n\"viewer-0 (G4OpenGLStoredQt)\", it ma << 
919      "\nfor example in \"/vis/viewer/select vi << 
920   fpCommand -> SetGuidance                     << 
921   ("Window size and placement hints, e.g. 600x << 
922   fpCommand -> SetGuidance                     << 
923   ("- single number, e.g., \"600\": square win << 
924   fpCommand -> SetGuidance                     << 
925   ("- two numbers, e.g., \"800x600\": rectangl << 
926   fpCommand -> SetGuidance                        594   fpCommand -> SetGuidance
927   ("- two numbers plus placement hint, e.g., \ << 595     ("Default scene handler is the current scene handler.  Invents a name"
928    "\n  600x600 100 pixels left and 100 pixels << 596      "\nif not supplied.  (Note: the system adds information to the name"
929   fpCommand -> SetGuidance                     << 597      "\nfor identification - only the characters up to the first blank are"
930   ("- If not specified, the default is \"600\" << 598      "\nused for removing, selecting, etc.)  This scene handler and viewer"
931    "\n  at the window manager's discretion...o << 599      "\nbecome current.");
932   fpCommand -> SetGuidance                     << 
933   ("- This is an X-Windows-type geometry strin << 
934    "\n  https://en.wikibooks.org/wiki/Guide_to << 
935    "\n  \"Specifying window geometry\".");     << 
936   G4UIparameter* parameter;                       600   G4UIparameter* parameter;
937   parameter = new G4UIparameter ("scene-handle    601   parameter = new G4UIparameter ("scene-handler", 's', omitable = true);
938   parameter -> SetCurrentAsDefault (true);        602   parameter -> SetCurrentAsDefault (true);
939   fpCommand -> SetParameter (parameter);          603   fpCommand -> SetParameter (parameter);
940   parameter = new G4UIparameter ("viewer-name"    604   parameter = new G4UIparameter ("viewer-name", 's', omitable = true);
941   parameter -> SetCurrentAsDefault (true);        605   parameter -> SetCurrentAsDefault (true);
942   fpCommand -> SetParameter (parameter);          606   fpCommand -> SetParameter (parameter);
943   parameter = new G4UIparameter ("window-size-    607   parameter = new G4UIparameter ("window-size-hint", 's', omitable = true);
944   parameter -> SetCurrentAsDefault (true);     << 608   parameter->SetGuidance
                                                   >> 609     ("integer (pixels) for square window placed by window manager or"
                                                   >> 610      " X-Windows-type geometry string, e.g. 600x600-100+100");
                                                   >> 611   parameter->SetDefaultValue("600");
945   fpCommand -> SetParameter (parameter);          612   fpCommand -> SetParameter (parameter);
946 }                                                 613 }
947                                                   614 
948 G4VisCommandViewerCreate::~G4VisCommandViewerC    615 G4VisCommandViewerCreate::~G4VisCommandViewerCreate () {
949   delete fpCommand;                               616   delete fpCommand;
950 }                                                 617 }
951                                                   618 
952 G4String G4VisCommandViewerCreate::NextName ()    619 G4String G4VisCommandViewerCreate::NextName () {
953   std::ostringstream oss;                         620   std::ostringstream oss;
954   G4VSceneHandler* sceneHandler = fpVisManager    621   G4VSceneHandler* sceneHandler = fpVisManager -> GetCurrentSceneHandler ();
955   oss << "viewer-" << fId << " (";                622   oss << "viewer-" << fId << " (";
956   if (sceneHandler) {                             623   if (sceneHandler) {
957     oss << sceneHandler -> GetGraphicsSystem (    624     oss << sceneHandler -> GetGraphicsSystem () -> GetName ();
958   }                                               625   }
959   else {                                          626   else {
960     oss << "no_scene_handlers";                   627     oss << "no_scene_handlers";
961   }                                               628   }
962   oss << ")";                                     629   oss << ")";
963   return oss.str();                               630   return oss.str();
964 }                                                 631 }
965                                                   632 
966 G4String G4VisCommandViewerCreate::GetCurrentV << 633 G4String G4VisCommandViewerCreate::GetCurrentValue (G4UIcommand*) {
967 {                                              << 634   G4String currentValue;
968   G4String sceneHandlerName;                   << 635   G4VSceneHandler* currentSceneHandler =
969   auto currentSceneHandler = fpVisManager->Get << 636     fpVisManager -> GetCurrentSceneHandler ();
970   if (currentSceneHandler) {  // Get name of l << 637   if (currentSceneHandler) {
971     sceneHandlerName = currentSceneHandler->Ge << 638     currentValue = currentSceneHandler -> GetName ();
972   }                                               639   }
973   else {  // No scene handler - ensure a warni << 640   else {
974     sceneHandlerName = "none";                 << 641     currentValue = "none";
975   }                                               642   }
                                                   >> 643   currentValue += ' ';
                                                   >> 644   currentValue += '"';
                                                   >> 645   currentValue += NextName ();
                                                   >> 646   currentValue += '"';
976                                                   647 
977   // Default name                              << 648   currentValue += " 600";  // Default number of pixels for window size hint.
978   const auto& viewerName = NextName();         << 
979                                                   649 
980   // Size hint                                 << 650   return currentValue;
981   G4String windowSizeHint;                     << 
982   auto currentViewer = fpVisManager->GetCurren << 
983   if (currentViewer) {  // Get hint from last  << 
984     windowSizeHint = currentViewer->GetViewPar << 
985   }                                            << 
986   else {  // No viewer - must be first time    << 
987     windowSizeHint = fpVisManager->GetDefaultX << 
988   }                                            << 
989                                                << 
990   // Add quotes around viewer name             << 
991   return sceneHandlerName + " \"" + viewerName << 
992 }                                                 651 }
993                                                   652 
994 void G4VisCommandViewerCreate::SetNewValue (G4 << 653 void G4VisCommandViewerCreate::SetNewValue (G4UIcommand*, G4String newValue) {
995                                                   654 
996   G4VisManager::Verbosity verbosity = fpVisMan    655   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
997                                                   656 
998   G4String sceneHandlerName, newName;             657   G4String sceneHandlerName, newName;
999   G4String windowSizeHintString;                  658   G4String windowSizeHintString;
1000   std::istringstream is (newValue);              659   std::istringstream is (newValue);
1001   is >> sceneHandlerName;                        660   is >> sceneHandlerName;
1002                                                  661 
1003   // Now need to handle the possibility that     662   // Now need to handle the possibility that the second string
1004   // contains embedded blanks within quotatio    663   // contains embedded blanks within quotation marks...
1005   char c = ' ';                                  664   char c = ' ';
1006   while (is.get(c) && c == ' '){}                665   while (is.get(c) && c == ' '){}
1007   if (c == '"') {                                666   if (c == '"') {
1008     while (is.get(c) && c != '"') {newName +=    667     while (is.get(c) && c != '"') {newName += c;}
1009   }                                              668   }
1010   else {                                         669   else {
1011     newName += c;                                670     newName += c;
1012     while (is.get(c) && c != ' ') {newName +=    671     while (is.get(c) && c != ' ') {newName += c;}
1013   }                                              672   }
1014   G4StrUtil::strip(newName, ' ');             << 673   newName = newName.strip (G4String::both, ' ');
1015   G4StrUtil::strip(newName, '"');             << 674   newName = newName.strip (G4String::both, '"');
1016                                                  675 
1017   // Now get window size hint...                 676   // Now get window size hint...
1018   is >> windowSizeHintString;                    677   is >> windowSizeHintString;
1019                                                  678 
1020   const G4SceneHandlerList& sceneHandlerList     679   const G4SceneHandlerList& sceneHandlerList =
1021     fpVisManager -> GetAvailableSceneHandlers    680     fpVisManager -> GetAvailableSceneHandlers ();
1022   std::size_t nHandlers = sceneHandlerList.si << 681   G4int nHandlers = sceneHandlerList.size ();
1023   if (nHandlers == 0) {                       << 682   if (nHandlers <= 0) {
1024     G4ExceptionDescription ed;                << 683     if (verbosity >= G4VisManager::errors) {
1025     ed <<                                     << 684       G4cerr <<
1026     "ERROR: G4VisCommandViewerCreate::SetNewV << 685   "ERROR: G4VisCommandViewerCreate::SetNewValue: no scene handlers."
1027     "\n  Create a scene handler with \"/vis/s << 686   "\n  Create a scene handler with \"/vis/sceneHandler/create\""
1028     command->CommandFailed(ed);               << 687        << G4endl;
                                                   >> 688     }
1029     return;                                      689     return;
1030   }                                              690   }
1031                                                  691 
1032   std::size_t iHandler;                       << 692   G4int iHandler;
1033   for (iHandler = 0; iHandler < nHandlers; ++ << 693   for (iHandler = 0; iHandler < nHandlers; iHandler++) {
1034     if (sceneHandlerList [iHandler] -> GetNam    694     if (sceneHandlerList [iHandler] -> GetName () == sceneHandlerName) break;
1035   }                                              695   }
1036                                                  696 
1037   if (iHandler >= nHandlers) {                << 697   if (iHandler < 0 || iHandler >= nHandlers) {
1038     // Invalid command line argument or none.    698     // Invalid command line argument or none.
1039     // This shouldn't happen!!!!!!               699     // This shouldn't happen!!!!!!
1040     G4ExceptionDescription ed;                << 700     if (verbosity >= G4VisManager::errors) {
1041     ed <<                                     << 701       G4cout << "G4VisCommandViewerCreate::SetNewValue:"
1042     "G4VisCommandViewerCreate::SetNewValue: i << 702   " invalid scene handler specified."
1043     command->CommandFailed(ed);               << 703       << G4endl;
                                                   >> 704     }
1044     return;                                      705     return;
1045   }                                              706   }
1046                                                  707 
1047   // Valid index.  Set current scene handler     708   // Valid index.  Set current scene handler and graphics system in
1048   // preparation for creating viewer.            709   // preparation for creating viewer.
1049   G4VSceneHandler* sceneHandler = sceneHandle    710   G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
1050   if (sceneHandler != fpVisManager -> GetCurr    711   if (sceneHandler != fpVisManager -> GetCurrentSceneHandler ()) {
1051     fpVisManager -> SetCurrentSceneHandler (s    712     fpVisManager -> SetCurrentSceneHandler (sceneHandler);
1052   }                                              713   }
1053                                                  714 
1054   // Now deal with name of viewer.               715   // Now deal with name of viewer.
1055   G4String nextName = NextName ();               716   G4String nextName = NextName ();
1056   if (newName == "") {                           717   if (newName == "") {
1057     newName = nextName;                          718     newName = nextName;
1058   }                                              719   }
1059   if (newName == nextName) fId++;                720   if (newName == nextName) fId++;
1060   G4String newShortName = fpVisManager -> Vie    721   G4String newShortName = fpVisManager -> ViewerShortName (newName);
1061                                                  722 
1062   for (std::size_t ih = 0; ih < nHandlers; ++ << 723   for (G4int ih = 0; ih < nHandlers; ih++) {
1063     G4VSceneHandler* sh = sceneHandlerList [i    724     G4VSceneHandler* sh = sceneHandlerList [ih];
1064     const G4ViewerList& viewerList = sh -> Ge    725     const G4ViewerList& viewerList = sh -> GetViewerList ();
1065     for (std::size_t iViewer = 0; iViewer < v << 726     for (size_t iViewer = 0; iViewer < viewerList.size (); iViewer++) {
1066       if (viewerList [iViewer] -> GetShortNam    727       if (viewerList [iViewer] -> GetShortName () == newShortName ) {
1067   G4ExceptionDescription ed;                  << 728   if (verbosity >= G4VisManager::errors) {
1068   ed <<                                       << 729     G4cerr << "ERROR: Viewer \"" << newShortName << "\" already exists."
1069   "ERROR: Viewer \"" << newShortName << "\" a << 730      << G4endl;
1070   command->CommandFailed(ed);                 << 731   }
1071   return;                                        732   return;
1072       }                                          733       }
1073     }                                            734     }
1074   }                                              735   }
1075                                                  736 
1076   if (fThereWasAViewer && windowSizeHintStrin << 737   // WindowSizeHint and XGeometryString are picked up from the vis
1077     // The user did not specify a window size << 738   // manager in the G4VViewer constructor. In G4VisManager, after Viewer
1078     windowSizeHintString = fExistingVP.GetXGe << 739   // creation, we will store theses parameters in G4ViewParameters.
1079   }                                           << 
1080                                                  740 
1081   fpVisManager -> CreateViewer (newName,windo    741   fpVisManager -> CreateViewer (newName,windowSizeHintString);
1082                                                  742 
1083   // Now we have a new viewer                 << 
1084   G4VViewer* newViewer = fpVisManager -> GetC    743   G4VViewer* newViewer = fpVisManager -> GetCurrentViewer ();
1085                                               << 
1086   if (newViewer && newViewer -> GetName () ==    744   if (newViewer && newViewer -> GetName () == newName) {
1087     if (fThereWasAViewer) {                   << 
1088       G4ViewParameters vp = newViewer->GetVie << 
1089       // Copy view parameters from existing v << 
1090       fExistingVP.SetAutoRefresh(vp.IsAutoRef << 
1091       fExistingVP.SetBackgroundColour(vp.GetB << 
1092       fExistingVP.SetGlobalMarkerScale(vp.Get << 
1093       // ...including window hint paramaters  << 
1094       fExistingVP.SetXGeometryString(vp.GetXG << 
1095       vp = fExistingVP;                       << 
1096       newViewer->SetViewParameters(vp);       << 
1097       newViewer->AccessSceneTree() = fExistin << 
1098     }                                         << 
1099     if (verbosity >= G4VisManager::confirmati    745     if (verbosity >= G4VisManager::confirmations) {
1100       G4cout << "New viewer \"" << newName <<    746       G4cout << "New viewer \"" << newName << "\" created." << G4endl;
1101     }                                            747     }
1102     // Keep for next time...                  << 748   }
1103     fThereWasAViewer = true;                  << 749   else {
1104     auto viewer = fpVisManager->GetCurrentVie << 750     if (verbosity >= G4VisManager::errors) {
1105     fExistingVP = viewer->GetViewParameters() << 751       if (newViewer) {
1106     fExistingSceneTree = viewer->GetSceneTree << 752   G4cerr << "ERROR: New viewer doesn\'t match!!!  Curious!!" << G4endl;
1107   } else {                                    << 753       } else {
1108     G4ExceptionDescription ed;                << 754   G4cout << "WARNING: No viewer created." << G4endl;
1109     if (newViewer) {                          << 755       }
1110       ed << "ERROR: New viewer doesn\'t match << 
1111     } else {                                  << 
1112       ed << "WARNING: No viewer created.";    << 
1113     }                                            756     }
1114     command->CommandFailed(ed);               << 
1115     return;                                   << 
1116   }                                              757   }
1117   // Refresh if appropriate...                   758   // Refresh if appropriate...
1118   if (newViewer) {                               759   if (newViewer) {
1119     if (newViewer->GetViewParameters().IsAuto    760     if (newViewer->GetViewParameters().IsAutoRefresh()) {
1120       G4UImanager::GetUIpointer()->ApplyComma    761       G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
1121     }                                            762     }
1122     else {                                       763     else {
1123       if (verbosity >= G4VisManager::warnings    764       if (verbosity >= G4VisManager::warnings) {
1124   G4warn << "Issue /vis/viewer/refresh or flu << 765   G4cout << "Issue /vis/viewer/refresh or flush to see effect."
1125          << G4endl;                              766          << G4endl;
1126       }                                          767       }
1127     }                                            768     }
1128   }                                              769   }
1129 }                                                770 }
1130                                                  771 
1131 ////////////// /vis/viewer/dolly and dollyTo     772 ////////////// /vis/viewer/dolly and dollyTo ////////////////////////////
1132                                                  773 
1133 G4VisCommandViewerDolly::G4VisCommandViewerDo    774 G4VisCommandViewerDolly::G4VisCommandViewerDolly ():
1134   fDollyIncrement  (0.),                         775   fDollyIncrement  (0.),
1135   fDollyTo (0.)                                  776   fDollyTo (0.)
1136 {                                                777 {
1137   G4bool omitable, currentAsDefault;             778   G4bool omitable, currentAsDefault;
1138                                                  779 
1139   fpCommandDolly = new G4UIcmdWithADoubleAndU    780   fpCommandDolly = new G4UIcmdWithADoubleAndUnit
1140     ("/vis/viewer/dolly", this);                 781     ("/vis/viewer/dolly", this);
1141   fpCommandDolly -> SetGuidance                  782   fpCommandDolly -> SetGuidance
1142     ("Incremental dolly.");                      783     ("Incremental dolly.");
1143   fpCommandDolly -> SetGuidance                  784   fpCommandDolly -> SetGuidance
1144     ("Moves the camera incrementally towards     785     ("Moves the camera incrementally towards target point.");
1145   fpCommandDolly -> SetParameterName("increme    786   fpCommandDolly -> SetParameterName("increment",
1146              omitable=true,                      787              omitable=true,
1147              currentAsDefault=true);             788              currentAsDefault=true);
1148   fpCommandDolly -> SetDefaultUnit("m");         789   fpCommandDolly -> SetDefaultUnit("m");
1149                                                  790 
1150   fpCommandDollyTo = new G4UIcmdWithADoubleAn    791   fpCommandDollyTo = new G4UIcmdWithADoubleAndUnit
1151     ("/vis/viewer/dollyTo", this);               792     ("/vis/viewer/dollyTo", this);
1152   fpCommandDollyTo -> SetGuidance                793   fpCommandDollyTo -> SetGuidance
1153     ("Dolly to specific coordinate.");           794     ("Dolly to specific coordinate.");
1154   fpCommandDollyTo -> SetGuidance                795   fpCommandDollyTo -> SetGuidance
1155  ("Places the camera towards target point rel    796  ("Places the camera towards target point relative to standard camera point.");
1156   fpCommandDollyTo -> SetParameterName("dista    797   fpCommandDollyTo -> SetParameterName("distance",
1157                omitable=true,                    798                omitable=true,
1158                currentAsDefault=true);           799                currentAsDefault=true);
1159   fpCommandDollyTo -> SetDefaultUnit("m");       800   fpCommandDollyTo -> SetDefaultUnit("m");
1160 }                                                801 }
1161                                                  802 
1162 G4VisCommandViewerDolly::~G4VisCommandViewerD    803 G4VisCommandViewerDolly::~G4VisCommandViewerDolly () {
1163   delete fpCommandDolly;                         804   delete fpCommandDolly;
1164   delete fpCommandDollyTo;                       805   delete fpCommandDollyTo;
1165 }                                                806 }
1166                                                  807 
1167 G4String G4VisCommandViewerDolly::GetCurrentV    808 G4String G4VisCommandViewerDolly::GetCurrentValue (G4UIcommand* command) {
1168   G4String currentValue;                         809   G4String currentValue;
1169   if (command == fpCommandDolly) {               810   if (command == fpCommandDolly) {
1170     currentValue = fpCommandDolly->ConvertToS    811     currentValue = fpCommandDolly->ConvertToString(fDollyIncrement, "m");
1171   }                                              812   }
1172   else if (command == fpCommandDollyTo) {        813   else if (command == fpCommandDollyTo) {
1173     currentValue = fpCommandDollyTo->ConvertT    814     currentValue = fpCommandDollyTo->ConvertToString(fDollyTo, "m");
1174   }                                              815   }
1175   return currentValue;                           816   return currentValue;
1176 }                                                817 }
1177                                                  818 
1178 void G4VisCommandViewerDolly::SetNewValue (G4    819 void G4VisCommandViewerDolly::SetNewValue (G4UIcommand* command,
1179              G4String newValue) {                820              G4String newValue) {
1180                                                  821 
1181                                                  822 
1182   G4VisManager::Verbosity verbosity = fpVisMa    823   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1183                                                  824 
1184   G4VViewer* currentViewer = fpVisManager->Ge    825   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1185   if (!currentViewer) {                          826   if (!currentViewer) {
1186     if (verbosity >= G4VisManager::errors) {     827     if (verbosity >= G4VisManager::errors) {
1187       G4warn <<                               << 828       G4cerr <<
1188   "ERROR: G4VisCommandsViewerDolly::SetNewVal    829   "ERROR: G4VisCommandsViewerDolly::SetNewValue: no current viewer."
1189        << G4endl;                                830        << G4endl;
1190     }                                            831     }
1191     return;                                      832     return;
1192   }                                              833   }
1193                                                  834 
1194   G4ViewParameters vp = currentViewer->GetVie    835   G4ViewParameters vp = currentViewer->GetViewParameters();
1195                                                  836 
1196   if (command == fpCommandDolly) {               837   if (command == fpCommandDolly) {
1197     fDollyIncrement = fpCommandDolly->GetNewD    838     fDollyIncrement = fpCommandDolly->GetNewDoubleValue(newValue);
1198     vp.IncrementDolly(fDollyIncrement);          839     vp.IncrementDolly(fDollyIncrement);
1199   }                                              840   }
1200   else if (command == fpCommandDollyTo) {        841   else if (command == fpCommandDollyTo) {
1201     fDollyTo = fpCommandDolly->GetNewDoubleVa    842     fDollyTo = fpCommandDolly->GetNewDoubleValue(newValue);
1202     vp.SetDolly(fDollyTo);                       843     vp.SetDolly(fDollyTo);
1203   }                                              844   }
1204                                                  845 
1205   if (verbosity >= G4VisManager::confirmation    846   if (verbosity >= G4VisManager::confirmations) {
1206     G4cout << "Dolly distance changed to " <<    847     G4cout << "Dolly distance changed to " << vp.GetDolly() << G4endl;
1207   }                                              848   }
1208                                                  849 
1209   SetViewParameters(currentViewer, vp);          850   SetViewParameters(currentViewer, vp);
1210 }                                                851 }
1211                                                  852 
1212 ////////////// /vis/viewer/flush ////////////    853 ////////////// /vis/viewer/flush ///////////////////////////////////////
1213                                                  854 
1214 G4VisCommandViewerFlush::G4VisCommandViewerFl    855 G4VisCommandViewerFlush::G4VisCommandViewerFlush () {
1215   G4bool omitable, currentAsDefault;             856   G4bool omitable, currentAsDefault;
1216   fpCommand = new G4UIcmdWithAString ("/vis/v    857   fpCommand = new G4UIcmdWithAString ("/vis/viewer/flush", this);
1217   fpCommand -> SetGuidance                       858   fpCommand -> SetGuidance
1218     ("Compound command: \"/vis/viewer/refresh    859     ("Compound command: \"/vis/viewer/refresh\" + \"/vis/viewer/update\".");
1219   fpCommand -> SetGuidance                       860   fpCommand -> SetGuidance
1220     ("Useful for refreshing and initiating po    861     ("Useful for refreshing and initiating post-processing for graphics"
1221      "\nsystems which need post-processing.      862      "\nsystems which need post-processing.  By default, acts on current"
1222      "\nviewer.  \"/vis/viewer/list\" to see     863      "\nviewer.  \"/vis/viewer/list\" to see possible viewers.  Viewer"
1223      "\nbecomes current.");                      864      "\nbecomes current.");
1224   fpCommand -> SetParameterName ("viewer-name    865   fpCommand -> SetParameterName ("viewer-name",
1225          omitable = true,                        866          omitable = true,
1226          currentAsDefault = true);               867          currentAsDefault = true);
1227 }                                                868 }
1228                                                  869 
1229 G4VisCommandViewerFlush::~G4VisCommandViewerF    870 G4VisCommandViewerFlush::~G4VisCommandViewerFlush () {
1230   delete fpCommand;                              871   delete fpCommand;
1231 }                                                872 }
1232                                                  873 
1233 G4String G4VisCommandViewerFlush::GetCurrentV    874 G4String G4VisCommandViewerFlush::GetCurrentValue 
1234 (G4UIcommand*) {                                 875 (G4UIcommand*) {
1235   G4VViewer* viewer = fpVisManager -> GetCurr    876   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1236   return viewer ? viewer -> GetName () : G4St    877   return viewer ? viewer -> GetName () : G4String("none");
1237 }                                                878 }
1238                                                  879 
1239 void G4VisCommandViewerFlush::SetNewValue (G4    880 void G4VisCommandViewerFlush::SetNewValue (G4UIcommand*, G4String newValue) {
1240                                                  881 
1241   G4VisManager::Verbosity verbosity = fpVisMa    882   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1242                                                  883 
1243   G4String& flushName = newValue;                884   G4String& flushName = newValue;
1244   G4VViewer* viewer = fpVisManager -> GetView    885   G4VViewer* viewer = fpVisManager -> GetViewer (flushName);
1245   if (!viewer) {                                 886   if (!viewer) {
1246     if (verbosity >= G4VisManager::errors) {     887     if (verbosity >= G4VisManager::errors) {
1247       G4warn << "ERROR: Viewer \"" << flushNa << 888       G4cerr << "ERROR: Viewer \"" << flushName << "\"" <<
1248   " not found - \"/vis/viewer/list\"\n  to se    889   " not found - \"/vis/viewer/list\"\n  to see possibilities."
1249        << G4endl;                                890        << G4endl;
1250     }                                            891     }
1251     return;                                      892     return;
1252   }                                              893   }
1253                                                  894 
1254   G4UImanager* ui = G4UImanager::GetUIpointer    895   G4UImanager* ui = G4UImanager::GetUIpointer();
                                                   >> 896   G4int keepVerbose = ui->GetVerboseLevel();
                                                   >> 897   G4int newVerbose(0);
                                                   >> 898   if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
                                                   >> 899     newVerbose = 2;
                                                   >> 900   ui->SetVerboseLevel(newVerbose);
1255   ui->ApplyCommand(G4String("/vis/viewer/refr    901   ui->ApplyCommand(G4String("/vis/viewer/refresh " + flushName));
1256   ui->ApplyCommand(G4String("/vis/viewer/upda    902   ui->ApplyCommand(G4String("/vis/viewer/update " + flushName));
                                                   >> 903   ui->SetVerboseLevel(keepVerbose);
1257   if (verbosity >= G4VisManager::confirmation    904   if (verbosity >= G4VisManager::confirmations) {
1258     G4cout << "Viewer \"" << viewer -> GetNam    905     G4cout << "Viewer \"" << viewer -> GetName () << "\""
1259      << " flushed." << G4endl;                   906      << " flushed." << G4endl;
1260   }                                              907   }
1261 }                                                908 }
1262                                                  909 
1263 ////////////// /vis/viewer/interpolate ////// << 
1264                                               << 
1265 G4VisCommandViewerInterpolate::G4VisCommandVi << 
1266   G4bool omitable;                            << 
1267   fpCommand = new G4UIcommand ("/vis/viewer/i << 
1268   fpCommand -> SetGuidance                    << 
1269   ("Interpolate views defined by the first ar << 
1270    "Unix-shell-style pattern matching charact << 
1271    "- see \"man sh\" and look for \"Pattern M << 
1272    "of each file are assumed to be \"/vis/vie << 
1273    "that specify a particular view. The files << 
1274    "order of filename. The files may be writt << 
1275    "\"/vis/viewer/save\" command.");          << 
1276   fpCommand -> SetGuidance                    << 
1277   ("The default is to search the working dire << 
1278    "extension. Another procedure is to assemb << 
1279    "e.g., \"myviews\"; then they can be inter << 
1280    "\"/vis/viewer/interpolate myviews\".");   << 
1281   fpCommand -> SetGuidance                    << 
1282   ("To export interpolated views to file for  << 
1283    "write \"export\" as 5th parameter (OpenGL << 
1284   G4UIparameter* parameter;                   << 
1285   parameter = new G4UIparameter("pattern", 's << 
1286   parameter -> SetGuidance("Pattern that defi << 
1287   parameter -> SetDefaultValue("*.g4view");   << 
1288   fpCommand -> SetParameter(parameter);       << 
1289   parameter = new G4UIparameter("no-of-points << 
1290   parameter -> SetGuidance ("Number of interp << 
1291   parameter -> SetDefaultValue(50);           << 
1292   fpCommand -> SetParameter(parameter);       << 
1293   parameter = new G4UIparameter("wait-time",  << 
1294   parameter -> SetGuidance("Wait time per int << 
1295   parameter -> SetDefaultValue("20.");        << 
1296   fpCommand -> SetParameter(parameter);       << 
1297   parameter = new G4UIparameter("time-unit",  << 
1298   parameter -> SetDefaultValue("millisecond") << 
1299   fpCommand -> SetParameter (parameter);      << 
1300   parameter = new G4UIparameter("export", 's' << 
1301   parameter -> SetDefaultValue("no");         << 
1302   fpCommand -> SetParameter (parameter);      << 
1303 }                                             << 
1304                                               << 
1305 G4VisCommandViewerInterpolate::~G4VisCommandV << 
1306   delete fpCommand;                           << 
1307 }                                             << 
1308                                               << 
1309 G4String G4VisCommandViewerInterpolate::GetCu << 
1310   return "";                                  << 
1311 }                                             << 
1312                                               << 
1313 void G4VisCommandViewerInterpolate::SetNewVal << 
1314                                               << 
1315   G4VisManager::Verbosity verbosity = fpVisMa << 
1316                                               << 
1317   G4VViewer* currentViewer = fpVisManager->Ge << 
1318   if (!currentViewer) {                       << 
1319     if (verbosity >= G4VisManager::errors) {  << 
1320       G4warn <<                               << 
1321       "ERROR: G4VisCommandViewerInterpolate:: << 
1322        << G4endl;                             << 
1323     }                                         << 
1324     return;                                   << 
1325   }                                           << 
1326                                               << 
1327   G4String pattern;                           << 
1328   G4int nInterpolationPoints;                 << 
1329   G4String waitTimePerPointString;            << 
1330   G4String timeUnit;                          << 
1331   G4String exportString;                      << 
1332                                               << 
1333   std::istringstream iss (newValue);          << 
1334   iss                                         << 
1335   >> pattern                                  << 
1336   >> nInterpolationPoints                     << 
1337   >> waitTimePerPointString                   << 
1338   >> timeUnit                                 << 
1339   >> exportString;                            << 
1340   G4String waitTimePerPointDimString(waitTime << 
1341   const G4double waitTimePerPoint =           << 
1342   G4UIcommand::ConvertToDimensionedDouble(wai << 
1343   G4int waitTimePerPointmilliseconds = waitTi << 
1344   if (waitTimePerPointmilliseconds < 0) waitT << 
1345                                               << 
1346   G4UImanager* uiManager = G4UImanager::GetUI << 
1347                                               << 
1348   // Save current view parameters             << 
1349   G4ViewParameters saveVP = currentViewer->Ge << 
1350                                               << 
1351   // Save current verbosities                 << 
1352   G4VisManager::Verbosity keepVisVerbosity =  << 
1353   G4int keepUIVerbosity = uiManager->GetVerbo << 
1354                                               << 
1355   // Set verbosities for this operation       << 
1356   fpVisManager->SetVerboseLevel(G4VisManager: << 
1357   uiManager->SetVerboseLevel(0);              << 
1358                                               << 
1359   // Switch off auto-refresh while we read in << 
1360   // restored later).  Note: the view files d << 
1361   G4ViewParameters non_auto = saveVP;         << 
1362   non_auto.SetAutoRefresh(false);             << 
1363   currentViewer->SetViewParameters(non_auto); << 
1364                                               << 
1365   const G4int safety = 99;                    << 
1366   G4int safetyCount = 0;                      << 
1367   G4fs::path pathPattern = pattern.c_str();   << 
1368                                               << 
1369   // Parent path - add "./" for empty directo << 
1370   G4String parentPathString                   << 
1371   (pathPattern.parent_path().string().length( << 
1372    pathPattern.parent_path().string() :       << 
1373    std::string("./"));                        << 
1374   G4fs::path parentPath = parentPathString.c_ << 
1375                                               << 
1376   // Fill selected paths                      << 
1377   std::set<G4fs::path> paths;  // Use std::se << 
1378                                               << 
1379   if (G4fs::is_directory(pathPattern)) {      << 
1380                                               << 
1381     // The user has specified a directory. Fi << 
1382     for (const auto& path: G4fs::directory_it << 
1383       if (safetyCount++ >= safety) break;     << 
1384       paths.insert(path);                     << 
1385     }                                         << 
1386                                               << 
1387   } else {                                    << 
1388                                               << 
1389     // Assume user has specified a Unix "glob << 
1390     // Default pattern is *.g4view, which tra << 
1391     // Convert pattern into a regexp          << 
1392     G4String regexp_pattern("^");             << 
1393     for (G4int i = 0; i < (G4int)pattern.leng << 
1394       if (pattern[i] == '.') {                << 
1395   regexp_pattern += "\\.";                    << 
1396       } else if (pattern[i] == '*') {         << 
1397   regexp_pattern += ".*";                     << 
1398       } else if (pattern[i] == '?') {         << 
1399   regexp_pattern += "(.{1,1})";               << 
1400       } else {                                << 
1401   regexp_pattern += pattern[i];               << 
1402       }                                       << 
1403     }                                         << 
1404     std::regex regexp(regexp_pattern, std::re << 
1405                                               << 
1406     for (const auto& path: G4fs::directory_it << 
1407       const auto& pathname = path.path().rela << 
1408       if (std::regex_match(pathname, regexp)) << 
1409   if (safetyCount++ >= safety) break;         << 
1410   paths.insert(path);                         << 
1411       }                                       << 
1412     }                                         << 
1413   }                                           << 
1414                                               << 
1415   if (safetyCount > safety) {                 << 
1416     if (verbosity >= G4VisManager::errors) {  << 
1417       G4warn <<                               << 
1418       "/vis/viewer/interpolate:"              << 
1419       "\n  the number of way points has been  << 
1420       << safety << G4endl;                    << 
1421     }                                         << 
1422   }                                           << 
1423                                               << 
1424   // Fill view vector of way points           << 
1425   std::vector<G4ViewParameters> viewVector;   << 
1426   for (const auto& path: paths) {             << 
1427     uiManager->ApplyCommand("/control/execute << 
1428     G4ViewParameters vp = currentViewer->GetV << 
1429     // Set original auto-refresh status.      << 
1430     vp.SetAutoRefresh(saveVP.IsAutoRefresh()) << 
1431     viewVector.push_back(vp);                 << 
1432   }                                           << 
1433                                               << 
1434   InterpolateViews                            << 
1435   (currentViewer,viewVector,                  << 
1436    nInterpolationPoints,waitTimePerPointmilli << 
1437                                               << 
1438   // Restore original verbosities             << 
1439   uiManager->SetVerboseLevel(keepUIVerbosity) << 
1440   fpVisManager->SetVerboseLevel(keepVisVerbos << 
1441                                               << 
1442   // Restore original view parameters         << 
1443   currentViewer->SetViewParameters(saveVP);   << 
1444   currentViewer->RefreshView();               << 
1445   if (verbosity >= G4VisManager::confirmation << 
1446     G4cout << "Viewer \"" << currentViewer -> << 
1447     << " restored." << G4endl;                << 
1448   }                                           << 
1449 }                                             << 
1450                                               << 
1451 ////////////// /vis/viewer/list /////////////    910 ////////////// /vis/viewer/list ///////////////////////////////////////
1452                                                  911 
1453 G4VisCommandViewerList::G4VisCommandViewerLis    912 G4VisCommandViewerList::G4VisCommandViewerList () {
1454   G4bool omitable;                               913   G4bool omitable;
1455   fpCommand = new G4UIcommand ("/vis/viewer/l    914   fpCommand = new G4UIcommand ("/vis/viewer/list", this);
1456   fpCommand -> SetGuidance ("Lists viewers(s)    915   fpCommand -> SetGuidance ("Lists viewers(s).");
1457   fpCommand -> SetGuidance                       916   fpCommand -> SetGuidance
1458     ("See \"/vis/verbose\" for definition of     917     ("See \"/vis/verbose\" for definition of verbosity.");
1459   G4UIparameter* parameter;                      918   G4UIparameter* parameter;
1460   parameter = new G4UIparameter("viewer-name"    919   parameter = new G4UIparameter("viewer-name", 's',
1461         omitable = true);                        920         omitable = true);
1462   parameter -> SetDefaultValue ("all");          921   parameter -> SetDefaultValue ("all");
1463   fpCommand -> SetParameter (parameter);         922   fpCommand -> SetParameter (parameter);
1464   parameter = new G4UIparameter ("verbosity",    923   parameter = new G4UIparameter ("verbosity", 's',
1465          omitable = true);                       924          omitable = true);
1466   parameter -> SetDefaultValue ("warnings");     925   parameter -> SetDefaultValue ("warnings");
1467   fpCommand -> SetParameter (parameter);         926   fpCommand -> SetParameter (parameter);
1468 }                                                927 }
1469                                                  928 
1470 G4VisCommandViewerList::~G4VisCommandViewerLi    929 G4VisCommandViewerList::~G4VisCommandViewerList () {
1471   delete fpCommand;                              930   delete fpCommand;
1472 }                                                931 }
1473                                                  932 
1474 G4String G4VisCommandViewerList::GetCurrentVa    933 G4String G4VisCommandViewerList::GetCurrentValue (G4UIcommand*) {
1475   return "";                                     934   return "";
1476 }                                                935 }
1477                                                  936 
1478 void G4VisCommandViewerList::SetNewValue (G4U    937 void G4VisCommandViewerList::SetNewValue (G4UIcommand*, G4String newValue) {
1479   G4String name, verbosityString;                938   G4String name, verbosityString;
1480   std::istringstream is (newValue);              939   std::istringstream is (newValue);
1481   is >> name >> verbosityString;                 940   is >> name >> verbosityString;
1482   G4String shortName = fpVisManager -> Viewer    941   G4String shortName = fpVisManager -> ViewerShortName (name);
1483   G4VisManager::Verbosity verbosity =            942   G4VisManager::Verbosity verbosity =
1484     fpVisManager->GetVerbosityValue(verbosity    943     fpVisManager->GetVerbosityValue(verbosityString);
1485                                                  944 
1486   const G4VViewer* currentViewer = fpVisManag    945   const G4VViewer* currentViewer = fpVisManager -> GetCurrentViewer ();
1487   G4String currentViewerShortName;               946   G4String currentViewerShortName;
1488   if (currentViewer) {                           947   if (currentViewer) {
1489     currentViewerShortName = currentViewer ->    948     currentViewerShortName = currentViewer -> GetShortName ();
1490   }                                              949   }
1491   else {                                         950   else {
1492     currentViewerShortName = "none";             951     currentViewerShortName = "none";
1493   }                                              952   }
1494                                                  953 
1495   const G4SceneHandlerList& sceneHandlerList     954   const G4SceneHandlerList& sceneHandlerList =
1496     fpVisManager -> GetAvailableSceneHandlers    955     fpVisManager -> GetAvailableSceneHandlers ();
1497   std::size_t nHandlers = sceneHandlerList.si << 956   G4int nHandlers = sceneHandlerList.size ();
1498   G4bool found = false;                          957   G4bool found = false;
1499   G4bool foundCurrent = false;                   958   G4bool foundCurrent = false;
1500   for (std::size_t iHandler = 0; iHandler < n << 959   for (int iHandler = 0; iHandler < nHandlers; iHandler++) {
1501     G4VSceneHandler* sceneHandler = sceneHand    960     G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
1502     const G4ViewerList& viewerList = sceneHan    961     const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
1503     G4cout                                    << 962     G4cout << "Scene handler \"" << sceneHandler -> GetName ();
1504     << "Scene handler \"" << sceneHandler ->  << 
1505     << sceneHandler->GetGraphicsSystem()->Get << 
1506     const G4Scene* pScene = sceneHandler -> G    963     const G4Scene* pScene = sceneHandler -> GetScene ();
1507     if (pScene) {                                964     if (pScene) {
1508       G4cout << ", scene \"" << pScene -> Get << 965       G4cout << "\", scene \"" << pScene -> GetName () << "\":";
1509     }                                            966     }
1510     G4cout << ':';                            << 967     G4int nViewers = viewerList.size ();
1511     std::size_t nViewers = viewerList.size () << 
1512     if (nViewers == 0) {                         968     if (nViewers == 0) {
1513       G4cout << "\n            No viewers for    969       G4cout << "\n            No viewers for this scene handler." << G4endl;
1514     }                                            970     }
1515     else {                                       971     else {
1516       for (std::size_t iViewer = 0; iViewer < << 972       for (int iViewer = 0; iViewer < nViewers; iViewer++) {
1517   const G4VViewer* thisViewer = viewerList [i    973   const G4VViewer* thisViewer = viewerList [iViewer];
1518   G4String thisName = thisViewer -> GetName (    974   G4String thisName = thisViewer -> GetName ();
1519   G4String thisShortName = thisViewer -> GetS    975   G4String thisShortName = thisViewer -> GetShortName ();
1520   if (name != "all") {                           976   if (name != "all") {
1521     if (thisShortName != shortName) continue;    977     if (thisShortName != shortName) continue;
1522   }                                              978   }
1523   found = true;                                  979   found = true;
1524   G4cout << "\n  ";                              980   G4cout << "\n  ";
1525   if (thisShortName == currentViewerShortName    981   if (thisShortName == currentViewerShortName) {
1526     foundCurrent = true;                         982     foundCurrent = true;
1527     G4cout << "(current)";                       983     G4cout << "(current)";
1528   }                                              984   }
1529   else {                                         985   else {
1530     G4cout << "         ";                       986     G4cout << "         ";
1531   }                                              987   }
1532   G4cout << " viewer \"" << thisName << "\"";    988   G4cout << " viewer \"" << thisName << "\"";
1533   if (verbosity >= G4VisManager::parameters)     989   if (verbosity >= G4VisManager::parameters) {
1534     G4cout << "\n  " << *thisViewer;             990     G4cout << "\n  " << *thisViewer;
1535   }                                              991   }
1536       }                                          992       }
1537     }                                            993     }
1538     G4cout << G4endl;                            994     G4cout << G4endl;
1539   }                                              995   }
1540                                                  996 
1541   if (!foundCurrent) {                           997   if (!foundCurrent) {
1542     G4cout << "No valid current viewer - plea    998     G4cout << "No valid current viewer - please create or select one."
1543      << G4endl;                                  999      << G4endl;
1544   }                                              1000   }
1545                                                  1001 
1546   if (!found) {                                  1002   if (!found) {
1547     G4cout << "No viewers";                      1003     G4cout << "No viewers";
1548     if (name != "all") {                         1004     if (name != "all") {
1549       G4cout << " of name \"" << name << "\""    1005       G4cout << " of name \"" << name << "\"";
1550     }                                            1006     }
1551     G4cout << " found." << G4endl;               1007     G4cout << " found." << G4endl;
1552   }                                              1008   }
1553 }                                                1009 }
1554                                                  1010 
1555 ////////////// /vis/viewer/pan and panTo ////    1011 ////////////// /vis/viewer/pan and panTo ////////////////////////////
1556                                                  1012 
1557 G4VisCommandViewerPan::G4VisCommandViewerPan     1013 G4VisCommandViewerPan::G4VisCommandViewerPan ():
1558   fPanIncrementRight  (0.),                      1014   fPanIncrementRight  (0.),
1559   fPanIncrementUp  (0.),                         1015   fPanIncrementUp  (0.),
1560   fPanToRight (0.),                              1016   fPanToRight (0.),
1561   fPanToUp (0.)                                  1017   fPanToUp (0.)
1562 {                                                1018 {
1563   G4bool omitable;                               1019   G4bool omitable;
1564                                                  1020 
1565   fpCommandPan = new G4UIcommand                 1021   fpCommandPan = new G4UIcommand
1566     ("/vis/viewer/pan", this);                   1022     ("/vis/viewer/pan", this);
1567   fpCommandPan -> SetGuidance                    1023   fpCommandPan -> SetGuidance
1568     ("Incremental pan.");                        1024     ("Incremental pan.");
1569   fpCommandPan -> SetGuidance                    1025   fpCommandPan -> SetGuidance
1570     ("Moves the camera incrementally right an    1026     ("Moves the camera incrementally right and up by these amounts (as seen"
1571      "\nfrom viewpoint direction).");            1027      "\nfrom viewpoint direction).");
1572   G4UIparameter* parameter;                      1028   G4UIparameter* parameter;
1573   parameter = new G4UIparameter("right-increm    1029   parameter = new G4UIparameter("right-increment", 'd', omitable = true);
1574   parameter -> SetCurrentAsDefault (true);       1030   parameter -> SetCurrentAsDefault (true);
1575   fpCommandPan -> SetParameter (parameter);      1031   fpCommandPan -> SetParameter (parameter);
1576   parameter = new G4UIparameter("up-increment    1032   parameter = new G4UIparameter("up-increment", 'd', omitable = true);
1577   parameter -> SetCurrentAsDefault (true);       1033   parameter -> SetCurrentAsDefault (true);
1578   fpCommandPan -> SetParameter (parameter);      1034   fpCommandPan -> SetParameter (parameter);
1579   parameter = new G4UIparameter ("unit", 's',    1035   parameter = new G4UIparameter ("unit", 's', omitable = true);
1580   parameter -> SetDefaultValue ("m");            1036   parameter -> SetDefaultValue ("m");
1581   fpCommandPan -> SetParameter (parameter);      1037   fpCommandPan -> SetParameter (parameter);
1582                                                  1038 
1583   fpCommandPanTo = new G4UIcommand               1039   fpCommandPanTo = new G4UIcommand
1584     ("/vis/viewer/panTo", this);                 1040     ("/vis/viewer/panTo", this);
1585   fpCommandPanTo -> SetGuidance                  1041   fpCommandPanTo -> SetGuidance
1586     ("Pan to specific coordinate.");             1042     ("Pan to specific coordinate.");
1587   fpCommandPanTo -> SetGuidance                  1043   fpCommandPanTo -> SetGuidance
1588     ("Places the camera in this position righ    1044     ("Places the camera in this position right and up relative to standard"
1589      "\ntarget point (as seen from viewpoint     1045      "\ntarget point (as seen from viewpoint direction).");
1590   parameter = new G4UIparameter("right", 'd',    1046   parameter = new G4UIparameter("right", 'd', omitable = true);
1591   parameter -> SetCurrentAsDefault (true);       1047   parameter -> SetCurrentAsDefault (true);
1592   fpCommandPanTo -> SetParameter (parameter);    1048   fpCommandPanTo -> SetParameter (parameter);
1593   parameter = new G4UIparameter("up", 'd', om    1049   parameter = new G4UIparameter("up", 'd', omitable = true);
1594   parameter -> SetCurrentAsDefault (true);       1050   parameter -> SetCurrentAsDefault (true);
1595   fpCommandPanTo -> SetParameter (parameter);    1051   fpCommandPanTo -> SetParameter (parameter);
1596   parameter = new G4UIparameter ("unit", 's',    1052   parameter = new G4UIparameter ("unit", 's', omitable = true);
1597   parameter -> SetDefaultValue ("m");            1053   parameter -> SetDefaultValue ("m");
1598   fpCommandPanTo -> SetParameter (parameter);    1054   fpCommandPanTo -> SetParameter (parameter);
1599 }                                                1055 }
1600                                                  1056 
1601 G4VisCommandViewerPan::~G4VisCommandViewerPan    1057 G4VisCommandViewerPan::~G4VisCommandViewerPan () {
1602   delete fpCommandPan;                           1058   delete fpCommandPan;
1603   delete fpCommandPanTo;                         1059   delete fpCommandPanTo;
1604 }                                                1060 }
1605                                                  1061 
1606 G4String G4VisCommandViewerPan::GetCurrentVal    1062 G4String G4VisCommandViewerPan::GetCurrentValue (G4UIcommand* command) {
1607   G4String currentValue;                         1063   G4String currentValue;
1608   if (command == fpCommandPan) {                 1064   if (command == fpCommandPan) {
1609     currentValue = ConvertToString(fPanIncrem    1065     currentValue = ConvertToString(fPanIncrementRight, fPanIncrementUp, "m");
1610   }                                              1066   }
1611   else if (command == fpCommandPanTo) {          1067   else if (command == fpCommandPanTo) {
1612     currentValue = ConvertToString(fPanToRigh    1068     currentValue = ConvertToString(fPanToRight, fPanToUp, "m");
1613   }                                              1069   }
1614   return currentValue;                           1070   return currentValue;
1615 }                                                1071 }
1616                                                  1072 
1617 void G4VisCommandViewerPan::SetNewValue (G4UI    1073 void G4VisCommandViewerPan::SetNewValue (G4UIcommand* command,
1618            G4String newValue) {                  1074            G4String newValue) {
1619                                                  1075 
1620                                                  1076 
1621   G4VisManager::Verbosity verbosity = fpVisMa    1077   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1622                                                  1078 
1623   G4VViewer* currentViewer = fpVisManager->Ge    1079   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1624   if (!currentViewer) {                          1080   if (!currentViewer) {
1625     if (verbosity >= G4VisManager::errors) {     1081     if (verbosity >= G4VisManager::errors) {
1626       G4warn <<                               << 1082       G4cerr <<
1627   "ERROR: G4VisCommandsViewerPan::SetNewValue    1083   "ERROR: G4VisCommandsViewerPan::SetNewValue: no current viewer."
1628        << G4endl;                                1084        << G4endl;
1629     }                                            1085     }
1630     return;                                      1086     return;
1631   }                                              1087   }
1632                                                  1088 
1633   G4ViewParameters vp = currentViewer->GetVie    1089   G4ViewParameters vp = currentViewer->GetViewParameters();
1634                                                  1090 
1635   if (command == fpCommandPan) {                 1091   if (command == fpCommandPan) {
1636     ConvertToDoublePair(newValue, fPanIncreme    1092     ConvertToDoublePair(newValue, fPanIncrementRight, fPanIncrementUp);
1637     vp.IncrementPan(fPanIncrementRight, fPanI    1093     vp.IncrementPan(fPanIncrementRight, fPanIncrementUp);
1638   }                                              1094   }
1639   else if (command == fpCommandPanTo) {          1095   else if (command == fpCommandPanTo) {
1640     ConvertToDoublePair(newValue, fPanToRight    1096     ConvertToDoublePair(newValue, fPanToRight, fPanToUp);
1641     vp.SetPan(fPanToRight, fPanToUp);            1097     vp.SetPan(fPanToRight, fPanToUp);
1642   }                                              1098   }
1643                                                  1099 
1644   if (verbosity >= G4VisManager::confirmation    1100   if (verbosity >= G4VisManager::confirmations) {
1645     G4cout << "Current target point now " <<     1101     G4cout << "Current target point now " << vp.GetCurrentTargetPoint()
1646      << G4endl;                                  1102      << G4endl;
1647   }                                              1103   }
1648                                                  1104 
1649   SetViewParameters(currentViewer, vp);          1105   SetViewParameters(currentViewer, vp);
1650 }                                                1106 }
1651                                                  1107 
1652 ////////////// /vis/viewer/rebuild //////////    1108 ////////////// /vis/viewer/rebuild ///////////////////////////////////////
1653                                                  1109 
1654 G4VisCommandViewerRebuild::G4VisCommandViewer    1110 G4VisCommandViewerRebuild::G4VisCommandViewerRebuild () {
1655   G4bool omitable, currentAsDefault;             1111   G4bool omitable, currentAsDefault;
1656   fpCommand = new G4UIcmdWithAString ("/vis/v    1112   fpCommand = new G4UIcmdWithAString ("/vis/viewer/rebuild", this);
1657   fpCommand -> SetGuidance ("Forces rebuild o    1113   fpCommand -> SetGuidance ("Forces rebuild of graphical database.");
1658   fpCommand -> SetGuidance                       1114   fpCommand -> SetGuidance 
1659     ("By default, acts on current viewer.  \"    1115     ("By default, acts on current viewer.  \"/vis/viewer/list\""
1660      "\nto see possible viewers.  Viewer beco    1116      "\nto see possible viewers.  Viewer becomes current.");
1661   fpCommand -> SetParameterName ("viewer-name    1117   fpCommand -> SetParameterName ("viewer-name",
1662          omitable = true,                        1118          omitable = true,
1663          currentAsDefault = true);               1119          currentAsDefault = true);
1664 }                                                1120 }
1665                                                  1121 
1666 G4VisCommandViewerRebuild::~G4VisCommandViewe    1122 G4VisCommandViewerRebuild::~G4VisCommandViewerRebuild () {
1667   delete fpCommand;                              1123   delete fpCommand;
1668 }                                                1124 }
1669                                                  1125 
1670 G4String G4VisCommandViewerRebuild::GetCurren    1126 G4String G4VisCommandViewerRebuild::GetCurrentValue (G4UIcommand*) {
1671   G4VViewer* viewer = fpVisManager -> GetCurr    1127   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1672   if (viewer) {                                  1128   if (viewer) {
1673     return viewer -> GetName ();                 1129     return viewer -> GetName ();
1674   }                                              1130   }
1675   else {                                         1131   else {
1676     return "none";                               1132     return "none";
1677   }                                              1133   }
1678 }                                                1134 }
1679                                                  1135 
1680 void G4VisCommandViewerRebuild::SetNewValue (    1136 void G4VisCommandViewerRebuild::SetNewValue (G4UIcommand*, G4String newValue) {
1681                                                  1137 
1682   G4VisManager::Verbosity verbosity = fpVisMa    1138   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1683                                                  1139 
1684   G4String& rebuildName = newValue;              1140   G4String& rebuildName = newValue;
1685                                                  1141 
1686   G4VViewer* viewer = fpVisManager -> GetView    1142   G4VViewer* viewer = fpVisManager -> GetViewer (rebuildName);
1687   if (!viewer) {                                 1143   if (!viewer) {
1688     if (verbosity >= G4VisManager::errors) {     1144     if (verbosity >= G4VisManager::errors) {
1689       G4warn << "ERROR: Viewer \"" << rebuild << 1145       G4cerr << "ERROR: Viewer \"" << rebuildName
1690        << "\" not found - \"/vis/viewer/list\    1146        << "\" not found - \"/vis/viewer/list\" to see possibilities."
1691        << G4endl;                                1147        << G4endl;
1692     }                                            1148     }
1693     return;                                      1149     return;
1694   }                                              1150   }
1695                                                  1151 
1696   G4VSceneHandler* sceneHandler = viewer->Get    1152   G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1697   if (!sceneHandler) {                           1153   if (!sceneHandler) {
1698     if (verbosity >= G4VisManager::errors) {     1154     if (verbosity >= G4VisManager::errors) {
1699       G4warn << "ERROR: Viewer \"" << viewer- << 1155       G4cerr << "ERROR: Viewer \"" << viewer->GetName() << "\"" <<
1700   " has no scene handler - report serious bug    1156   " has no scene handler - report serious bug."
1701        << G4endl;                                1157        << G4endl;
1702     }                                            1158     }
1703     return;                                      1159     return;
1704   }                                              1160   }
1705                                                  1161 
1706   sceneHandler->ClearTransientStore();           1162   sceneHandler->ClearTransientStore();
1707   viewer->NeedKernelVisit();                     1163   viewer->NeedKernelVisit();
1708   viewer->SetView();                             1164   viewer->SetView();
1709   viewer->ClearView();                           1165   viewer->ClearView();
1710   viewer->DrawView();                            1166   viewer->DrawView();
1711                                                  1167 
1712   // Check auto-refresh and print confirmatio    1168   // Check auto-refresh and print confirmations.
1713   RefreshIfRequired(viewer);                     1169   RefreshIfRequired(viewer);
1714 }                                                1170 }
1715                                                  1171 
1716 ////////////// /vis/viewer/refresh //////////    1172 ////////////// /vis/viewer/refresh ///////////////////////////////////////
1717                                                  1173 
1718 G4VisCommandViewerRefresh::G4VisCommandViewer    1174 G4VisCommandViewerRefresh::G4VisCommandViewerRefresh () {
1719   G4bool omitable, currentAsDefault;             1175   G4bool omitable, currentAsDefault;
1720   fpCommand = new G4UIcmdWithAString ("/vis/v    1176   fpCommand = new G4UIcmdWithAString ("/vis/viewer/refresh", this);
1721   fpCommand -> SetGuidance                       1177   fpCommand -> SetGuidance
1722     ("Refreshes viewer.");                       1178     ("Refreshes viewer.");
1723   fpCommand -> SetGuidance                       1179   fpCommand -> SetGuidance 
1724     ("By default, acts on current viewer.  \"    1180     ("By default, acts on current viewer.  \"/vis/viewer/list\""
1725      "\nto see possible viewers.  Viewer beco    1181      "\nto see possible viewers.  Viewer becomes current.");
1726   fpCommand -> SetParameterName ("viewer-name    1182   fpCommand -> SetParameterName ("viewer-name",
1727          omitable = true,                        1183          omitable = true,
1728          currentAsDefault = true);               1184          currentAsDefault = true);
1729 }                                                1185 }
1730                                                  1186 
1731 G4VisCommandViewerRefresh::~G4VisCommandViewe    1187 G4VisCommandViewerRefresh::~G4VisCommandViewerRefresh () {
1732   delete fpCommand;                              1188   delete fpCommand;
1733 }                                                1189 }
1734                                                  1190 
1735 G4String G4VisCommandViewerRefresh::GetCurren    1191 G4String G4VisCommandViewerRefresh::GetCurrentValue (G4UIcommand*) {
1736   G4VViewer* viewer = fpVisManager -> GetCurr    1192   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1737   return viewer ? viewer -> GetName () : G4St    1193   return viewer ? viewer -> GetName () : G4String("none");
1738 }                                                1194 }
1739                                                  1195 
1740 void G4VisCommandViewerRefresh::SetNewValue (    1196 void G4VisCommandViewerRefresh::SetNewValue (G4UIcommand*, G4String newValue) {
1741                                                  1197 
1742   G4VisManager::Verbosity verbosity = fpVisMa    1198   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1743   G4bool warn(verbosity >= G4VisManager::warn    1199   G4bool warn(verbosity >= G4VisManager::warnings);
1744                                                  1200 
1745   G4String& refreshName = newValue;              1201   G4String& refreshName = newValue;
1746   G4VViewer* viewer = fpVisManager -> GetView    1202   G4VViewer* viewer = fpVisManager -> GetViewer (refreshName);
1747   if (!viewer) {                                 1203   if (!viewer) {
1748     if (verbosity >= G4VisManager::errors) {     1204     if (verbosity >= G4VisManager::errors) {
1749       G4warn << "ERROR: Viewer \"" << refresh << 1205       G4cerr << "ERROR: Viewer \"" << refreshName << "\"" <<
1750   " not found - \"/vis/viewer/list\"\n  to se    1206   " not found - \"/vis/viewer/list\"\n  to see possibilities."
1751        << G4endl;                                1207        << G4endl;
1752     }                                            1208     }
1753     return;                                      1209     return;
1754   }                                              1210   }
1755                                                  1211 
1756   G4VSceneHandler* sceneHandler = viewer->Get    1212   G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1757   if (!sceneHandler) {                           1213   if (!sceneHandler) {
1758     if (verbosity >= G4VisManager::errors) {     1214     if (verbosity >= G4VisManager::errors) {
1759       G4warn << "ERROR: Viewer \"" << refresh << 1215       G4cerr << "ERROR: Viewer \"" << refreshName << "\"" <<
1760   " has no scene handler - report serious bug    1216   " has no scene handler - report serious bug."
1761        << G4endl;                                1217        << G4endl;
1762     }                                            1218     }
1763     return;                                      1219     return;
1764   }                                              1220   }
1765                                                  1221 
1766   G4Scene* scene = sceneHandler->GetScene();     1222   G4Scene* scene = sceneHandler->GetScene();
1767   if (!scene) {                                  1223   if (!scene) {
1768     if (verbosity >= G4VisManager::confirmati    1224     if (verbosity >= G4VisManager::confirmations) {
1769       G4cout << "NOTE: SceneHandler \"" << sc    1225       G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
1770        << "\", to which viewer \"" << refresh    1226        << "\", to which viewer \"" << refreshName << "\"" <<
1771   "\n  is attached, has no scene - \"/vis/sce    1227   "\n  is attached, has no scene - \"/vis/scene/create\" and"
1772   " \"/vis/sceneHandler/attach\""                1228   " \"/vis/sceneHandler/attach\""
1773   "\n  (or use compound command \"/vis/drawVo    1229   "\n  (or use compound command \"/vis/drawVolume\")."
1774        << G4endl;                                1230        << G4endl;
1775     }                                            1231     }
1776     return;                                      1232     return;
1777   }                                              1233   }
1778   if (scene->GetRunDurationModelList().empty(    1234   if (scene->GetRunDurationModelList().empty()) {
1779     G4bool successful = scene -> AddWorldIfEm    1235     G4bool successful = scene -> AddWorldIfEmpty (warn);
1780     if (!successful) {                           1236     if (!successful) {
1781       if (verbosity >= G4VisManager::warnings    1237       if (verbosity >= G4VisManager::warnings) {
1782   G4warn <<                                   << 1238   G4cout <<
1783     "WARNING: Scene is empty.  Perhaps no geo    1239     "WARNING: Scene is empty.  Perhaps no geometry exists."
1784     "\n  Try /run/initialize."                   1240     "\n  Try /run/initialize."
1785          << G4endl;                              1241          << G4endl;
1786       }                                          1242       }
1787       return;                                    1243       return;
1788     }                                            1244     }
1789     // Scene has changed.  CheckSceneAndNotif << 1245     // Scene has changed.  UpdateVisManagerScene issues
1790     // /vis/scene/notifyHandlers, which does     1246     // /vis/scene/notifyHandlers, which does a refresh anyway, so the
1791     // ordinary refresh becomes part of the e    1247     // ordinary refresh becomes part of the else phrase...
1792     CheckSceneAndNotifyHandlers(scene);       << 1248     UpdateVisManagerScene(scene->GetName());
1793   } else {                                       1249   } else {
1794     if (verbosity >= G4VisManager::confirmati    1250     if (verbosity >= G4VisManager::confirmations) {
1795       G4cout << "Refreshing viewer \"" << vie    1251       G4cout << "Refreshing viewer \"" << viewer -> GetName () << "\"..."
1796        << G4endl;                                1252        << G4endl;
1797     }                                            1253     }
1798     viewer -> SetView ();                        1254     viewer -> SetView ();
1799     viewer -> ClearView ();                      1255     viewer -> ClearView ();
1800     viewer -> DrawView ();                       1256     viewer -> DrawView ();
1801     if (verbosity >= G4VisManager::confirmati    1257     if (verbosity >= G4VisManager::confirmations) {
1802       G4cout << "Viewer \"" << viewer -> GetN    1258       G4cout << "Viewer \"" << viewer -> GetName () << "\"" << " refreshed."
1803   "\n  (You might also need \"/vis/viewer/upd    1259   "\n  (You might also need \"/vis/viewer/update\".)" << G4endl;
1804     }                                            1260     }
1805   }                                              1261   }
1806 }                                                1262 }
1807                                                  1263 
1808 ////////////// /vis/viewer/reset ////////////    1264 ////////////// /vis/viewer/reset ///////////////////////////////////////
1809                                                  1265 
1810 G4VisCommandViewerReset::G4VisCommandViewerRe    1266 G4VisCommandViewerReset::G4VisCommandViewerReset () {
1811   G4bool omitable, currentAsDefault;             1267   G4bool omitable, currentAsDefault;
1812   fpCommand = new G4UIcmdWithAString ("/vis/v    1268   fpCommand = new G4UIcmdWithAString ("/vis/viewer/reset", this);
1813   fpCommand -> SetGuidance ("Resets viewer.")    1269   fpCommand -> SetGuidance ("Resets viewer.");
1814   fpCommand -> SetGuidance                       1270   fpCommand -> SetGuidance 
1815     ("By default, acts on current viewer.  \"    1271     ("By default, acts on current viewer.  \"/vis/viewer/list\""
1816      "\nto see possible viewers.  Viewer beco    1272      "\nto see possible viewers.  Viewer becomes current.");
1817   fpCommand -> SetParameterName ("viewer-name    1273   fpCommand -> SetParameterName ("viewer-name",
1818          omitable = true,                        1274          omitable = true,
1819          currentAsDefault = true);               1275          currentAsDefault = true);
1820 }                                                1276 }
1821                                                  1277 
1822 G4VisCommandViewerReset::~G4VisCommandViewerR    1278 G4VisCommandViewerReset::~G4VisCommandViewerReset () {
1823   delete fpCommand;                              1279   delete fpCommand;
1824 }                                                1280 }
1825                                                  1281 
1826 G4String G4VisCommandViewerReset::GetCurrentV    1282 G4String G4VisCommandViewerReset::GetCurrentValue (G4UIcommand*) {
1827   G4VViewer* viewer = fpVisManager -> GetCurr    1283   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1828   if (viewer) {                                  1284   if (viewer) {
1829     return viewer -> GetName ();                 1285     return viewer -> GetName ();
1830   }                                              1286   }
1831   else {                                         1287   else {
1832     return "none";                               1288     return "none";
1833   }                                              1289   }
1834 }                                                1290 }
1835                                                  1291 
1836 void G4VisCommandViewerReset::SetNewValue (G4    1292 void G4VisCommandViewerReset::SetNewValue (G4UIcommand*, G4String newValue) {
1837                                                  1293 
1838   G4VisManager::Verbosity verbosity = fpVisMa    1294   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1839                                                  1295 
1840   G4String& resetName = newValue;                1296   G4String& resetName = newValue;
1841   G4VViewer* viewer = fpVisManager -> GetView    1297   G4VViewer* viewer = fpVisManager -> GetViewer (resetName);
1842   if (!viewer) {                                 1298   if (!viewer) {
1843     if (verbosity >= G4VisManager::errors) {     1299     if (verbosity >= G4VisManager::errors) {
1844       G4warn << "ERROR: Viewer \"" << resetNa << 1300       G4cerr << "ERROR: Viewer \"" << resetName
1845        << "\" not found - \"/vis/viewer/list\    1301        << "\" not found - \"/vis/viewer/list\" to see possibilities."
1846        << G4endl;                                1302        << G4endl;
1847     }                                            1303     }
1848     return;                                      1304     return;
1849   }                                              1305   }
1850                                                  1306 
1851   viewer->ResetView();                           1307   viewer->ResetView();
1852   RefreshIfRequired(viewer);                     1308   RefreshIfRequired(viewer);
1853 }                                                1309 }
1854                                                  1310 
1855 ////////////// /vis/viewer/resetCameraParamet << 
1856                                               << 
1857 G4VisCommandViewerResetCameraParameters::G4Vi << 
1858   G4bool omitable, currentAsDefault;          << 
1859   fpCommand = new G4UIcmdWithAString ("/vis/v << 
1860   fpCommand -> SetGuidance ("Resets only the  << 
1861   fpCommand -> SetGuidance                    << 
1862   ("By default, acts on current viewer.  \"/v << 
1863    "\nto see possible viewers.  Viewer become << 
1864   fpCommand -> SetParameterName ("viewer-name << 
1865                                  omitable = t << 
1866                                  currentAsDef << 
1867 }                                             << 
1868                                               << 
1869 G4VisCommandViewerResetCameraParameters::~G4V << 
1870   delete fpCommand;                           << 
1871 }                                             << 
1872                                               << 
1873 G4String G4VisCommandViewerResetCameraParamet << 
1874   G4VViewer* viewer = fpVisManager -> GetCurr << 
1875   if (viewer) {                               << 
1876     return viewer -> GetName ();              << 
1877   }                                           << 
1878   else {                                      << 
1879     return "none";                            << 
1880   }                                           << 
1881 }                                             << 
1882                                               << 
1883 void G4VisCommandViewerResetCameraParameters: << 
1884                                               << 
1885   G4VisManager::Verbosity verbosity = fpVisMa << 
1886                                               << 
1887   G4String& resetName = newValue;             << 
1888   G4VViewer* viewer = fpVisManager -> GetView << 
1889   if (!viewer) {                              << 
1890     if (verbosity >= G4VisManager::errors) {  << 
1891       G4warn << "ERROR: Viewer \"" << resetNa << 
1892       << "\" not found - \"/vis/viewer/list\" << 
1893       << G4endl;                              << 
1894     }                                         << 
1895     return;                                   << 
1896   }                                           << 
1897                                               << 
1898   G4ViewParameters newVP = viewer->GetViewPar << 
1899   CopyCameraParameters(newVP,viewer->GetDefau << 
1900   viewer->SetViewParameters(newVP);           << 
1901   RefreshIfRequired(viewer);                  << 
1902 }                                             << 
1903                                               << 
1904 ////////////// /vis/viewer/save /////////////    1311 ////////////// /vis/viewer/save ///////////////////////////////////////
1905                                                  1312 
1906 G4VisCommandViewerSave::G4VisCommandViewerSav    1313 G4VisCommandViewerSave::G4VisCommandViewerSave () {
1907   G4bool omitable;                               1314   G4bool omitable;
1908   fpCommand = new G4UIcmdWithAString ("/vis/v    1315   fpCommand = new G4UIcmdWithAString ("/vis/viewer/save", this);
1909   fpCommand -> SetGuidance                       1316   fpCommand -> SetGuidance
1910   ("Write commands that define the current vi    1317   ("Write commands that define the current view to file.");
1911   fpCommand -> SetGuidance                    << 1318   fpCommand -> SetParameterName ("file-name", omitable = true);
1912   ("Read them back into the same or any viewe << 1319   fpCommand -> SetDefaultValue ("G4cout");
1913   fpCommand -> SetGuidance                    << 
1914   ("If the filename is omitted the view is sa << 
1915    "\"g4_nn.g4view\", where nn is a sequentia << 
1916   fpCommand -> SetGuidance                    << 
1917   ("If the filename is \"-\", the data are wr << 
1918   fpCommand -> SetGuidance                    << 
1919   ("If you are wanting to save views for futu << 
1920    "procedure is: save views to \"g4_nn.g4vie << 
1921    "into a sub-directory, say, \"views\", the << 
1922    "\"/vis/viewer/interpolate views\"");      << 
1923   fpCommand -> SetParameterName ("filename",  << 
1924   fpCommand -> SetDefaultValue ("");          << 
1925 }                                                1320 }
1926                                                  1321 
1927 G4VisCommandViewerSave::~G4VisCommandViewerSa    1322 G4VisCommandViewerSave::~G4VisCommandViewerSave () {
1928   delete fpCommand;                              1323   delete fpCommand;
1929 }                                                1324 }
1930                                                  1325 
1931 G4String G4VisCommandViewerSave::GetCurrentVa    1326 G4String G4VisCommandViewerSave::GetCurrentValue
1932 (G4UIcommand*) {                                 1327 (G4UIcommand*) {
1933   return "";                                     1328   return "";
1934 }                                                1329 }
1935                                                  1330 
1936 namespace {                                      1331 namespace {
1937   void WriteCommands                             1332   void WriteCommands
1938   (std::ostream& os,                             1333   (std::ostream& os,
1939    const G4ViewParameters& vp,                   1334    const G4ViewParameters& vp,
1940    const G4Point3D& stp)  // Standard Target  << 1335    const G4Point3D& stp)
1941   {                                              1336   {
1942     os                                           1337     os
1943     << vp.CameraAndLightingCommands(stp)         1338     << vp.CameraAndLightingCommands(stp)
1944     << vp.DrawingStyleCommands()                 1339     << vp.DrawingStyleCommands()
1945     << vp.SceneModifyingCommands()               1340     << vp.SceneModifyingCommands()
1946     << vp.TouchableCommands()                    1341     << vp.TouchableCommands()
1947     << vp.TimeWindowCommands()                << 
1948     << std::endl;                                1342     << std::endl;
1949   }                                              1343   }
1950 }                                                1344 }
1951                                                  1345 
1952 void G4VisCommandViewerSave::SetNewValue (G4U    1346 void G4VisCommandViewerSave::SetNewValue (G4UIcommand*, G4String newValue) {
1953                                                  1347   
1954   G4VisManager::Verbosity verbosity = fpVisMa    1348   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1955                                                  1349   
1956   const G4VViewer* currentViewer = fpVisManag    1350   const G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1957   if (!currentViewer) {                          1351   if (!currentViewer) {
1958     if (verbosity >= G4VisManager::errors) {     1352     if (verbosity >= G4VisManager::errors) {
1959       G4warn <<                               << 1353       G4cerr <<
1960       "ERROR: G4VisCommandsViewerSave::SetNew    1354       "ERROR: G4VisCommandsViewerSave::SetNewValue: no current viewer."
1961       << G4endl;                                 1355       << G4endl;
1962     }                                            1356     }
1963     return;                                      1357     return;
1964   }                                              1358   }
1965                                                  1359   
1966   const G4Scene* currentScene = currentViewer    1360   const G4Scene* currentScene = currentViewer->GetSceneHandler()->GetScene();
1967   if (!currentScene) {                           1361   if (!currentScene) {
1968     if (verbosity >= G4VisManager::errors) {     1362     if (verbosity >= G4VisManager::errors) {
1969       G4warn <<                               << 1363       G4cerr <<
1970       "ERROR: G4VisCommandsViewerSave::SetNew    1364       "ERROR: G4VisCommandsViewerSave::SetNewValue: no current scene."
1971       << G4endl;                                 1365       << G4endl;
1972     }                                            1366     }
1973     return;                                      1367     return;
1974   }                                              1368   }
1975                                               << 1369   
1976   // Get view parameters and ther relevant in << 1370   std::ofstream ofs;
1977   G4ViewParameters vp = currentViewer->GetVie << 1371   if (newValue != "G4cout") {
1978   // Concatenate any private vis attributes m << 1372     // Check if file exists
1979   const std::vector<G4ModelingParameters::Vis << 1373     std::ifstream ifs(newValue);
1980   privateVAMs = currentViewer->GetPrivateVisA << 1374     if (ifs) {
1981   if (privateVAMs) {                          << 
1982     std::vector<G4ModelingParameters::VisAttr << 
1983     for (i = privateVAMs->begin(); i != priva << 
1984       vp.AddVisAttributesModifier(*i);        << 
1985     }                                         << 
1986   }                                           << 
1987   const G4Point3D& stp = currentScene->GetSta << 
1988                                               << 
1989   G4String filename = newValue;               << 
1990                                               << 
1991   if (newValue.length() == 0) {               << 
1992     // Null filename - generate a filename    << 
1993     const G4int maxNoOfFiles = 100;           << 
1994     static G4int sequenceNumber = 0;          << 
1995     if (sequenceNumber >= maxNoOfFiles) {     << 
1996       if (verbosity >= G4VisManager::errors)     1375       if (verbosity >= G4VisManager::errors) {
1997         G4warn                                << 1376         G4cerr <<
1998         << "ERROR: G4VisCommandsViewerSave::S << 1377         "ERROR: G4VisCommandsViewerSave::SetNewValue: File \""
1999         << maxNoOfFiles                       << 1378         << newValue << "\" already exists."
2000         << ", of files exceeded."             << 
2001         << G4endl;                               1379         << G4endl;
2002       }                                          1380       }
                                                   >> 1381       ifs.close();
2003       return;                                    1382       return;
2004     }                                            1383     }
2005     std::ostringstream oss;                   << 1384     ofs.open(newValue);
2006     oss << std::setw(2) << std::setfill('0')  << 
2007     filename = "g4_" + oss.str() + ".g4view"; << 
2008   }                                           << 
2009                                               << 
2010   if (filename == "-") {                      << 
2011     // Write to standard output               << 
2012     WriteCommands(G4cout,vp,stp);             << 
2013   } else {                                    << 
2014     // Write to file - but add extension if n << 
2015     if (!G4StrUtil::contains(filename, '.'))  << 
2016       // No extension supplied - add .g4view  << 
2017       filename += ".g4view";                  << 
2018     }                                         << 
2019     std::ofstream ofs(filename);              << 
2020     if (!ofs) {                                  1385     if (!ofs) {
2021       if (verbosity >= G4VisManager::errors)     1386       if (verbosity >= G4VisManager::errors) {
2022         G4warn <<                             << 1387         G4cerr <<
2023         "ERROR: G4VisCommandsViewerSave::SetN    1388         "ERROR: G4VisCommandsViewerSave::SetNewValue: Trouble opening file \""
2024         << filename << "\"."                  << 1389         << newValue << "\"."
2025         << G4endl;                               1390         << G4endl;
2026       }                                          1391       }
2027       ofs.close();                               1392       ofs.close();
2028       return;                                    1393       return;
2029     }                                            1394     }
                                                   >> 1395   }
                                                   >> 1396   
                                                   >> 1397   G4ViewParameters vp = currentViewer->GetViewParameters();
                                                   >> 1398   // Concatenate any private vis attributes modifiers...
                                                   >> 1399   const std::vector<G4ModelingParameters::VisAttributesModifier>*
                                                   >> 1400     privateVAMs = currentViewer->GetPrivateVisAttributesModifiers();
                                                   >> 1401   if (privateVAMs) {
                                                   >> 1402     std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator i;
                                                   >> 1403     for (i = privateVAMs->begin(); i != privateVAMs->end(); ++i) {
                                                   >> 1404       vp.AddVisAttributesModifier(*i);
                                                   >> 1405     }
                                                   >> 1406   }
                                                   >> 1407   const G4Point3D& stp = currentScene->GetStandardTargetPoint();
                                                   >> 1408   
                                                   >> 1409   if (newValue == "G4cout") {
                                                   >> 1410     WriteCommands(G4cout,vp,stp);
                                                   >> 1411   } else {
2030     WriteCommands(ofs,vp,stp);                   1412     WriteCommands(ofs,vp,stp);
2031     ofs.close();                                 1413     ofs.close();
2032   }                                              1414   }
2033                                               << 1415 
2034   if (verbosity >= G4VisManager::warnings) {  << 1416   if (verbosity >= G4VisManager::confirmations) {
2035     G4warn << "Viewer \"" << currentViewer -> << 1417     G4cout << "Viewer \"" << currentViewer -> GetName ()
2036     << "\"" << " saved to ";                     1418     << "\"" << " saved to ";
2037     if (filename == "-") {                    << 1419     if (newValue == "G4cout") {
2038       G4warn << "G4cout.";                    << 1420       G4cout << "G4cout.";
2039     } else {                                     1421     } else {
2040       G4warn << "file \'" << filename << "\". << 1422       G4cout << "file \'" << newValue << "\".";
2041       "\n  Read the view back into this or an << 
2042       "\n  \"/control/execute " << filename < << 
2043       "\n  \"/vis/viewer/interpolate\" if you << 
2044       "\n  see \"help /vis/viewer/interpolate << 
2045     }                                            1423     }
2046     G4warn << G4endl;                         << 1424     G4cout << G4endl;
2047   }                                              1425   }
2048 }                                                1426 }
2049                                                  1427 
2050 ////////////// /vis/viewer/scale and scaleTo     1428 ////////////// /vis/viewer/scale and scaleTo ////////////////////////////
2051                                                  1429 
2052 G4VisCommandViewerScale::G4VisCommandViewerSc    1430 G4VisCommandViewerScale::G4VisCommandViewerScale ():
2053   fScaleMultiplier (G4Vector3D (1., 1., 1.)),    1431   fScaleMultiplier (G4Vector3D (1., 1., 1.)),
2054   fScaleTo         (G4Vector3D (1., 1., 1.))     1432   fScaleTo         (G4Vector3D (1., 1., 1.))
2055 {                                                1433 {
2056   G4bool omitable, currentAsDefault;             1434   G4bool omitable, currentAsDefault;
2057                                                  1435 
2058   fpCommandScale = new G4UIcmdWith3Vector        1436   fpCommandScale = new G4UIcmdWith3Vector
2059     ("/vis/viewer/scale", this);                 1437     ("/vis/viewer/scale", this);
2060   fpCommandScale -> SetGuidance ("Incremental    1438   fpCommandScale -> SetGuidance ("Incremental (non-uniform) scaling.");
2061   fpCommandScale -> SetGuidance                  1439   fpCommandScale -> SetGuidance
2062     ("Multiplies components of current scalin    1440     ("Multiplies components of current scaling by components of this factor."
2063      "\n Scales (x,y,z) by corresponding comp    1441      "\n Scales (x,y,z) by corresponding components of the resulting factor.");
2064   fpCommandScale -> SetGuidance                  1442   fpCommandScale -> SetGuidance
2065     ("");                                        1443     ("");
2066   fpCommandScale -> SetParameterName             1444   fpCommandScale -> SetParameterName
2067     ("x-scale-multiplier","y-scale-multiplier    1445     ("x-scale-multiplier","y-scale-multiplier","z-scale-multiplier",
2068      omitable=true, currentAsDefault=true);      1446      omitable=true, currentAsDefault=true);
2069                                                  1447 
2070   fpCommandScaleTo = new G4UIcmdWith3Vector      1448   fpCommandScaleTo = new G4UIcmdWith3Vector
2071     ("/vis/viewer/scaleTo", this);               1449     ("/vis/viewer/scaleTo", this);
2072   fpCommandScaleTo -> SetGuidance ("Absolute     1450   fpCommandScaleTo -> SetGuidance ("Absolute (non-uniform) scaling.");
2073   fpCommandScaleTo -> SetGuidance                1451   fpCommandScaleTo -> SetGuidance
2074     ("Scales (x,y,z) by corresponding compone    1452     ("Scales (x,y,z) by corresponding components of this factor.");
2075   fpCommandScaleTo -> SetParameterName           1453   fpCommandScaleTo -> SetParameterName
2076     ("x-scale-factor","y-scale-factor","z-sca    1454     ("x-scale-factor","y-scale-factor","z-scale-factor",
2077      omitable=true, currentAsDefault=true);      1455      omitable=true, currentAsDefault=true);
2078 }                                                1456 }
2079                                                  1457 
2080 G4VisCommandViewerScale::~G4VisCommandViewerS    1458 G4VisCommandViewerScale::~G4VisCommandViewerScale () {
2081   delete fpCommandScale;                         1459   delete fpCommandScale;
2082   delete fpCommandScaleTo;                       1460   delete fpCommandScaleTo;
2083 }                                                1461 }
2084                                                  1462 
2085 G4String G4VisCommandViewerScale::GetCurrentV    1463 G4String G4VisCommandViewerScale::GetCurrentValue (G4UIcommand* command) {
2086   G4String currentValue;                         1464   G4String currentValue;
2087   if (command == fpCommandScale) {               1465   if (command == fpCommandScale) {
2088     currentValue = fpCommandScale->ConvertToS    1466     currentValue = fpCommandScale->ConvertToString(G4ThreeVector(fScaleMultiplier));
2089   }                                              1467   }
2090   else if (command == fpCommandScaleTo) {        1468   else if (command == fpCommandScaleTo) {
2091     currentValue = fpCommandScaleTo->ConvertT    1469     currentValue = fpCommandScaleTo->ConvertToString(G4ThreeVector(fScaleTo));
2092   }                                              1470   }
2093   return currentValue;                           1471   return currentValue;
2094 }                                                1472 }
2095                                                  1473 
2096 void G4VisCommandViewerScale::SetNewValue (G4    1474 void G4VisCommandViewerScale::SetNewValue (G4UIcommand* command,
2097              G4String newValue) {                1475              G4String newValue) {
2098                                                  1476 
2099                                                  1477 
2100   G4VisManager::Verbosity verbosity = fpVisMa    1478   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2101                                                  1479 
2102   G4VViewer* currentViewer = fpVisManager->Ge    1480   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
2103   if (!currentViewer) {                          1481   if (!currentViewer) {
2104     if (verbosity >= G4VisManager::errors) {     1482     if (verbosity >= G4VisManager::errors) {
2105       G4warn <<                               << 1483       G4cerr <<
2106   "ERROR: G4VisCommandsViewerScale::SetNewVal    1484   "ERROR: G4VisCommandsViewerScale::SetNewValue: no current viewer."
2107        << G4endl;                                1485        << G4endl;
2108     }                                            1486     }
2109     return;                                      1487     return;
2110   }                                              1488   }
2111                                                  1489 
2112   G4ViewParameters vp = currentViewer->GetVie    1490   G4ViewParameters vp = currentViewer->GetViewParameters();
2113                                                  1491 
2114   if (command == fpCommandScale) {               1492   if (command == fpCommandScale) {
2115     fScaleMultiplier = fpCommandScale->GetNew    1493     fScaleMultiplier = fpCommandScale->GetNew3VectorValue(newValue);
2116     vp.MultiplyScaleFactor(fScaleMultiplier);    1494     vp.MultiplyScaleFactor(fScaleMultiplier);
2117   }                                              1495   }
2118   else if (command == fpCommandScaleTo) {        1496   else if (command == fpCommandScaleTo) {
2119     fScaleTo = fpCommandScale->GetNew3VectorV    1497     fScaleTo = fpCommandScale->GetNew3VectorValue(newValue);
2120     vp.SetScaleFactor(fScaleTo);                 1498     vp.SetScaleFactor(fScaleTo);
2121   }                                              1499   }
2122                                                  1500 
2123   if (verbosity >= G4VisManager::confirmation    1501   if (verbosity >= G4VisManager::confirmations) {
2124     G4cout << "Scale factor changed to " << v    1502     G4cout << "Scale factor changed to " << vp.GetScaleFactor() << G4endl;
2125   }                                              1503   }
2126                                                  1504 
2127   SetViewParameters(currentViewer, vp);          1505   SetViewParameters(currentViewer, vp);
2128 }                                                1506 }
2129                                                  1507 
2130 ////////////// /vis/viewer/select ///////////    1508 ////////////// /vis/viewer/select ///////////////////////////////////////
2131                                                  1509 
2132 G4VisCommandViewerSelect::G4VisCommandViewerS    1510 G4VisCommandViewerSelect::G4VisCommandViewerSelect () {
2133   G4bool omitable;                               1511   G4bool omitable;
2134   fpCommand = new G4UIcmdWithAString ("/vis/v    1512   fpCommand = new G4UIcmdWithAString ("/vis/viewer/select", this);
2135   fpCommand -> SetGuidance ("Selects viewer."    1513   fpCommand -> SetGuidance ("Selects viewer.");
2136   fpCommand -> SetGuidance                       1514   fpCommand -> SetGuidance
2137     ("Specify viewer by name.  \"/vis/viewer/    1515     ("Specify viewer by name.  \"/vis/viewer/list\" to see possible viewers.");
2138   fpCommand -> SetParameterName ("viewer-name    1516   fpCommand -> SetParameterName ("viewer-name", omitable = false);
2139 }                                                1517 }
2140                                                  1518 
2141 G4VisCommandViewerSelect::~G4VisCommandViewer    1519 G4VisCommandViewerSelect::~G4VisCommandViewerSelect () {
2142   delete fpCommand;                              1520   delete fpCommand;
2143 }                                                1521 }
2144                                                  1522 
2145 G4String G4VisCommandViewerSelect::GetCurrent    1523 G4String G4VisCommandViewerSelect::GetCurrentValue (G4UIcommand*) {
2146   return "";                                     1524   return "";
2147 }                                                1525 }
2148                                                  1526 
2149 void G4VisCommandViewerSelect::SetNewValue (G    1527 void G4VisCommandViewerSelect::SetNewValue (G4UIcommand*, G4String newValue) {
2150                                                  1528 
2151   G4VisManager::Verbosity verbosity = fpVisMa    1529   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2152                                                  1530 
2153   G4String& selectName = newValue;               1531   G4String& selectName = newValue;
2154   G4VViewer* viewer = fpVisManager -> GetView    1532   G4VViewer* viewer = fpVisManager -> GetViewer (selectName);
2155                                                  1533 
2156   if (!viewer) {                                 1534   if (!viewer) {
2157     if (verbosity >= G4VisManager::errors) {     1535     if (verbosity >= G4VisManager::errors) {
2158       G4warn << "ERROR: Viewer \"" << selectN << 1536       G4cerr << "ERROR: Viewer \"" << selectName << "\"";
2159       G4warn << " not found - \"/vis/viewer/l << 1537       G4cerr << " not found - \"/vis/viewer/list\""
2160   "\n  to see possibilities."                    1538   "\n  to see possibilities."
2161        << G4endl;                                1539        << G4endl;
2162     }                                            1540     }
2163     return;                                      1541     return;
2164   }                                              1542   }
2165                                                  1543 
2166   if (viewer == fpVisManager -> GetCurrentVie    1544   if (viewer == fpVisManager -> GetCurrentViewer ()) {
2167     if (verbosity >= G4VisManager::warnings)     1545     if (verbosity >= G4VisManager::warnings) {
2168       G4warn << "WARNING: Viewer \"" << viewe << 1546       G4cout << "WARNING: Viewer \"" << viewer -> GetName () << "\""
2169        << " already selected." << G4endl;        1547        << " already selected." << G4endl;
2170     }                                            1548     }
2171     return;                                      1549     return;
2172   }                                              1550   }
2173                                                  1551 
2174   // Set pointers, call SetView and print con << 1552   fpVisManager -> SetCurrentViewer (viewer);  // Prints confirmation.
2175   fpVisManager -> SetCurrentViewer (viewer);  << 
2176                                                  1553 
2177   RefreshIfRequired(viewer);                     1554   RefreshIfRequired(viewer);
2178                                               << 
2179   // Update GUI scene tree (make sure it's in << 
2180   viewer->UpdateGUISceneTree();               << 
2181 }                                                1555 }
2182                                                  1556 
2183 ////////////// /vis/viewer/update ///////////    1557 ////////////// /vis/viewer/update ///////////////////////////////////////
2184                                                  1558 
2185 G4VisCommandViewerUpdate::G4VisCommandViewerU    1559 G4VisCommandViewerUpdate::G4VisCommandViewerUpdate () {
2186   G4bool omitable, currentAsDefault;             1560   G4bool omitable, currentAsDefault;
2187   fpCommand = new G4UIcmdWithAString ("/vis/v    1561   fpCommand = new G4UIcmdWithAString ("/vis/viewer/update", this);
2188   fpCommand -> SetGuidance                       1562   fpCommand -> SetGuidance
2189     ("Triggers graphical database post-proces    1563     ("Triggers graphical database post-processing for viewers"
2190      "\nusing that technique.");                 1564      "\nusing that technique.");
2191   fpCommand -> SetGuidance                       1565   fpCommand -> SetGuidance
2192     ("For such viewers the view only becomes     1566     ("For such viewers the view only becomes visible with this command."
2193      "\nBy default, acts on current viewer.      1567      "\nBy default, acts on current viewer.  \"/vis/viewer/list\""
2194      "\nto see possible viewers.  Viewer beco    1568      "\nto see possible viewers.  Viewer becomes current.");
2195   fpCommand -> SetParameterName ("viewer-name    1569   fpCommand -> SetParameterName ("viewer-name",
2196          omitable = true,                        1570          omitable = true,
2197          currentAsDefault = true);               1571          currentAsDefault = true);
2198 }                                                1572 }
2199                                                  1573 
2200 G4VisCommandViewerUpdate::~G4VisCommandViewer    1574 G4VisCommandViewerUpdate::~G4VisCommandViewerUpdate () {
2201   delete fpCommand;                              1575   delete fpCommand;
2202 }                                                1576 }
2203                                                  1577 
2204 G4String G4VisCommandViewerUpdate::GetCurrent    1578 G4String G4VisCommandViewerUpdate::GetCurrentValue (G4UIcommand*) {
2205   G4VViewer* viewer = fpVisManager -> GetCurr    1579   G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
2206   if (viewer) {                                  1580   if (viewer) {
2207     return viewer -> GetName ();                 1581     return viewer -> GetName ();
2208   }                                              1582   }
2209   else {                                         1583   else {
2210     return "none";                               1584     return "none";
2211   }                                              1585   }
2212 }                                                1586 }
2213                                                  1587 
2214 void G4VisCommandViewerUpdate::SetNewValue (G    1588 void G4VisCommandViewerUpdate::SetNewValue (G4UIcommand*, G4String newValue) {
2215                                                  1589 
2216   G4VisManager::Verbosity verbosity = fpVisMa    1590   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2217                                                  1591 
2218   G4String& updateName = newValue;               1592   G4String& updateName = newValue;
2219                                                  1593 
2220   G4VViewer* viewer = fpVisManager -> GetView    1594   G4VViewer* viewer = fpVisManager -> GetViewer (updateName);
2221   if (!viewer) {                                 1595   if (!viewer) {
2222     if (verbosity >= G4VisManager::errors) {     1596     if (verbosity >= G4VisManager::errors) {
2223       G4warn <<                               << 1597       G4cout <<
2224   "WARNING: command \"/vis/viewer/update\" co    1598   "WARNING: command \"/vis/viewer/update\" could not be applied: no current viewer."
2225        << G4endl;                                1599        << G4endl;
2226     }                                            1600     }
2227     return;                                      1601     return;
2228   }                                              1602   }
2229                                                  1603 
2230   G4VSceneHandler* sceneHandler = viewer->Get    1604   G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
2231   if (!sceneHandler) {                           1605   if (!sceneHandler) {
2232     if (verbosity >= G4VisManager::errors) {     1606     if (verbosity >= G4VisManager::errors) {
2233       G4warn << "ERROR: Viewer \"" << updateN << 1607       G4cerr << "ERROR: Viewer \"" << updateName << "\"" <<
2234   " has no scene handler - report serious bug    1608   " has no scene handler - report serious bug."
2235        << G4endl;                                1609        << G4endl;
2236     }                                            1610     }
2237     return;                                      1611     return;
2238   }                                              1612   }
2239                                                  1613 
2240   G4Scene* scene = sceneHandler->GetScene();     1614   G4Scene* scene = sceneHandler->GetScene();
2241   if (!scene) {                                  1615   if (!scene) {
2242     if (verbosity >= G4VisManager::confirmati    1616     if (verbosity >= G4VisManager::confirmations) {
2243       G4cout << "NOTE: SceneHandler \"" << sc    1617       G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
2244        << "\", to which viewer \"" << updateN    1618        << "\", to which viewer \"" << updateName << "\"" <<
2245   "\n  is attached, has no scene - \"/vis/sce    1619   "\n  is attached, has no scene - \"/vis/scene/create\" and"
2246   " \"/vis/sceneHandler/attach\""                1620   " \"/vis/sceneHandler/attach\""
2247   "\n  (or use compound command \"/vis/drawVo    1621   "\n  (or use compound command \"/vis/drawVolume\")."
2248        << G4endl;                                1622        << G4endl;
2249     }                                            1623     }
2250     return;                                      1624     return;
2251   }                                              1625   }
2252                                                  1626 
2253   if (verbosity >= G4VisManager::confirmation    1627   if (verbosity >= G4VisManager::confirmations) {
2254     G4cout << "Viewer \"" << viewer -> GetNam    1628     G4cout << "Viewer \"" << viewer -> GetName () << "\"";
2255     G4cout << " post-processing triggered." <    1629     G4cout << " post-processing triggered." << G4endl;
2256   }                                              1630   }
2257   viewer -> ShowView ();                         1631   viewer -> ShowView ();
2258   // Assume future need to "refresh" transien    1632   // Assume future need to "refresh" transients...
2259   sceneHandler -> SetMarkForClearingTransient    1633   sceneHandler -> SetMarkForClearingTransientStore(true);
2260 }                                                1634 }
2261                                                  1635 
2262 ////////////// /vis/viewer/zoom and zoomTo //    1636 ////////////// /vis/viewer/zoom and zoomTo ////////////////////////////
2263                                                  1637 
2264 G4VisCommandViewerZoom::G4VisCommandViewerZoo    1638 G4VisCommandViewerZoom::G4VisCommandViewerZoom ():
2265   fZoomMultiplier (1.),                          1639   fZoomMultiplier (1.),
2266   fZoomTo         (1.)                           1640   fZoomTo         (1.)
2267 {                                                1641 {
2268   G4bool omitable, currentAsDefault;             1642   G4bool omitable, currentAsDefault;
2269                                                  1643 
2270   fpCommandZoom = new G4UIcmdWithADouble         1644   fpCommandZoom = new G4UIcmdWithADouble
2271     ("/vis/viewer/zoom", this);                  1645     ("/vis/viewer/zoom", this);
2272   fpCommandZoom -> SetGuidance ("Incremental     1646   fpCommandZoom -> SetGuidance ("Incremental zoom.");
2273   fpCommandZoom -> SetGuidance                   1647   fpCommandZoom -> SetGuidance
2274     ("Multiplies current magnification by thi    1648     ("Multiplies current magnification by this factor.");
2275   fpCommandZoom -> SetParameterName("multipli    1649   fpCommandZoom -> SetParameterName("multiplier",
2276              omitable=true,                      1650              omitable=true,
2277              currentAsDefault=true);             1651              currentAsDefault=true);
2278                                                  1652 
2279   fpCommandZoomTo = new G4UIcmdWithADouble       1653   fpCommandZoomTo = new G4UIcmdWithADouble
2280     ("/vis/viewer/zoomTo", this);                1654     ("/vis/viewer/zoomTo", this);
2281   fpCommandZoomTo -> SetGuidance ("Absolute z    1655   fpCommandZoomTo -> SetGuidance ("Absolute zoom.");
2282   fpCommandZoomTo -> SetGuidance                 1656   fpCommandZoomTo -> SetGuidance
2283     ("Magnifies standard magnification by thi    1657     ("Magnifies standard magnification by this factor.");
2284   fpCommandZoomTo -> SetParameterName("factor    1658   fpCommandZoomTo -> SetParameterName("factor",
2285                omitable=true,                    1659                omitable=true,
2286                currentAsDefault=true);           1660                currentAsDefault=true);
2287 }                                                1661 }
2288                                                  1662 
2289 G4VisCommandViewerZoom::~G4VisCommandViewerZo    1663 G4VisCommandViewerZoom::~G4VisCommandViewerZoom () {
2290   delete fpCommandZoom;                          1664   delete fpCommandZoom;
2291   delete fpCommandZoomTo;                        1665   delete fpCommandZoomTo;
2292 }                                                1666 }
2293                                                  1667 
2294 G4String G4VisCommandViewerZoom::GetCurrentVa    1668 G4String G4VisCommandViewerZoom::GetCurrentValue (G4UIcommand* command) {
2295   G4String currentValue;                         1669   G4String currentValue;
2296   if (command == fpCommandZoom) {                1670   if (command == fpCommandZoom) {
2297     currentValue = fpCommandZoom->ConvertToSt    1671     currentValue = fpCommandZoom->ConvertToString(fZoomMultiplier);
2298   }                                              1672   }
2299   else if (command == fpCommandZoomTo) {         1673   else if (command == fpCommandZoomTo) {
2300     currentValue = fpCommandZoomTo->ConvertTo    1674     currentValue = fpCommandZoomTo->ConvertToString(fZoomTo);
2301   }                                              1675   }
2302   return currentValue;                           1676   return currentValue;
2303 }                                                1677 }
2304                                                  1678 
2305 void G4VisCommandViewerZoom::SetNewValue (G4U    1679 void G4VisCommandViewerZoom::SetNewValue (G4UIcommand* command,
2306             G4String newValue) {                 1680             G4String newValue) {
2307                                                  1681 
2308                                                  1682 
2309   G4VisManager::Verbosity verbosity = fpVisMa    1683   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2310                                                  1684 
2311   G4VViewer* currentViewer = fpVisManager->Ge    1685   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
2312   if (!currentViewer) {                          1686   if (!currentViewer) {
2313     if (verbosity >= G4VisManager::errors) {     1687     if (verbosity >= G4VisManager::errors) {
2314       G4warn <<                               << 1688       G4cerr <<
2315   "ERROR: G4VisCommandsViewerZoom::SetNewValu    1689   "ERROR: G4VisCommandsViewerZoom::SetNewValue: no current viewer."
2316        << G4endl;                                1690        << G4endl;
2317     }                                            1691     }
2318     return;                                      1692     return;
2319   }                                              1693   }
2320                                                  1694 
2321   G4ViewParameters vp = currentViewer->GetVie    1695   G4ViewParameters vp = currentViewer->GetViewParameters();
2322                                                  1696 
2323   if (command == fpCommandZoom) {                1697   if (command == fpCommandZoom) {
2324     fZoomMultiplier = fpCommandZoom->GetNewDo    1698     fZoomMultiplier = fpCommandZoom->GetNewDoubleValue(newValue);
2325     vp.MultiplyZoomFactor(fZoomMultiplier);      1699     vp.MultiplyZoomFactor(fZoomMultiplier);
2326   }                                              1700   }
2327   else if (command == fpCommandZoomTo) {         1701   else if (command == fpCommandZoomTo) {
2328     fZoomTo = fpCommandZoom->GetNewDoubleValu    1702     fZoomTo = fpCommandZoom->GetNewDoubleValue(newValue);
2329     vp.SetZoomFactor(fZoomTo);                   1703     vp.SetZoomFactor(fZoomTo);
2330   }                                              1704   }
2331                                                  1705 
2332   if (verbosity >= G4VisManager::confirmation    1706   if (verbosity >= G4VisManager::confirmations) {
2333     G4cout << "Zoom factor changed to " << vp    1707     G4cout << "Zoom factor changed to " << vp.GetZoomFactor() << G4endl;
2334   }                                              1708   }
2335                                                  1709 
2336   SetViewParameters(currentViewer, vp);          1710   SetViewParameters(currentViewer, vp);
2337 }                                                1711 }
2338                                                  1712