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 ]

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