Geant4 Cross Reference

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


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: G4VisCommandsViewerSet.cc,v 1.19 2002/05/01 09:55:28 johna Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-04-01 $
 27                                                    26 
 28 // /vis/viewer/set commands - John Allison  16     27 // /vis/viewer/set commands - John Allison  16th May 2000
 29                                                    28 
 30 #include "G4VisCommandsViewerSet.hh"               29 #include "G4VisCommandsViewerSet.hh"
 31                                                    30 
 32 #include "G4UIcommand.hh"                          31 #include "G4UIcommand.hh"
 33 #include "G4UIcmdWithoutParameter.hh"          << 
 34 #include "G4UIcmdWithAString.hh"                   32 #include "G4UIcmdWithAString.hh"
 35 #include "G4UIcmdWithABool.hh"                     33 #include "G4UIcmdWithABool.hh"
 36 #include "G4UIcmdWithAnInteger.hh"                 34 #include "G4UIcmdWithAnInteger.hh"
 37 #include "G4UIcmdWithADouble.hh"               << 
 38 #include "G4UIcmdWith3VectorAndUnit.hh"        << 
 39 #include "G4UnitsTable.hh"                         35 #include "G4UnitsTable.hh"
 40 #include "G4VisManager.hh"                         36 #include "G4VisManager.hh"
 41 #include "G4Polyhedron.hh"                     << 
 42 #include "G4SystemOfUnits.hh"                  << 
 43                                                << 
 44 #include <sstream>                             << 
 45 #include <iomanip>                             << 
 46 #include <utility>                             << 
 47                                                << 
 48 #define G4warn G4cout                          << 
 49                                                    37 
 50 G4VisCommandsViewerSet::G4VisCommandsViewerSet     38 G4VisCommandsViewerSet::G4VisCommandsViewerSet ():
 51 fLightsVector    (G4ThreeVector(1.,1.,1.)),    <<  39   fLightsVector    (G4ThreeVector(1.,1.,1.)),
 52 fUpVector        (G4ThreeVector(0.,1.,0.)),    <<  40   fUpVector        (G4ThreeVector(0.,1.,0.)),
 53 fViewpointVector (G4ThreeVector(0.,0.,1.))     <<  41   fViewpointVector (G4ThreeVector(0.,0.,1.))
 54 {                                                  42 {
 55   G4bool omitable;                                 43   G4bool omitable;
 56   G4UIparameter* parameter;                        44   G4UIparameter* parameter;
 57                                                    45 
 58   fpCommandAll = new G4UIcmdWithAString ("/vis     46   fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
 59   fpCommandAll->SetGuidance                        47   fpCommandAll->SetGuidance
 60   ("Copies view parameters.");                 <<  48     ("/vis/viewer/set/all <from-viewer-name>"
 61   fpCommandAll->SetGuidance                    <<  49      "\nCopies view parameters (except the autoRefresh status) from"
 62   ("Copies ALL view parameters (except the aut <<  50      "\n  from-viewer to current viewer.");
 63    "\nfrom-viewer to current viewer. You may n << 
 64   fpCommandAll->SetGuidance                    << 
 65   ("Note: to copy only the camera-specific par << 
 66    "\n\"/vis/viewer/copyfrom\".");             << 
 67   fpCommandAll->SetParameterName ("from-viewer     51   fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
                                                   >>  52   viewerNameCommands.push_back (fpCommandAll);
 68                                                    53 
 69   fpCommandAutoRefresh = new G4UIcmdWithABool      54   fpCommandAutoRefresh = new G4UIcmdWithABool
 70   ("/vis/viewer/set/autoRefresh",this);        <<  55     ("/vis/viewer/set/autoRefresh",this);
 71   fpCommandAutoRefresh->SetGuidance("Sets auto << 
 72   fpCommandAutoRefresh->SetGuidance                56   fpCommandAutoRefresh->SetGuidance
 73   ("If true, view is automatically refreshed a <<  57     ("/vis/viewer/set/autoRefresh [true|false]");
 74    "\nview parameters.");                      <<  58   fpCommandAutoRefresh->SetGuidance
                                                   >>  59     ("DEPRECATED COMMAND.  Will be removed from next major release.");
                                                   >>  60   fpCommandAutoRefresh->SetGuidance
                                                   >>  61     ("View is automatically refreshed after a change of view parameters.");
 75   fpCommandAutoRefresh->SetParameterName("auto     62   fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true);
 76   fpCommandAutoRefresh->SetDefaultValue(true); <<  63   fpCommandAutoRefresh->SetDefaultValue(false);
 77                                                << 
 78   fpCommandAuxEdge = new G4UIcmdWithABool      << 
 79   ("/vis/viewer/set/auxiliaryEdge",this);      << 
 80   fpCommandAuxEdge->SetGuidance("Sets visibili << 
 81   fpCommandAuxEdge->SetGuidance                << 
 82   ("Auxiliary edges, i.e., those that are part << 
 83    "\nsometimes called soft edges, become visi << 
 84   fpCommandAuxEdge->SetParameterName("edge",om << 
 85   fpCommandAuxEdge->SetDefaultValue(true);     << 
 86                                                << 
 87   fpCommandBackground = new G4UIcommand        << 
 88   ("/vis/viewer/set/background",this);         << 
 89   fpCommandBackground->SetGuidance             << 
 90   ("Set background colour and transparency (de << 
 91   fpCommandBackground->SetGuidance(ConvertToCo << 
 92   parameter = new G4UIparameter("red_or_string << 
 93   parameter -> SetDefaultValue ("0.");         << 
 94   fpCommandBackground -> SetParameter (paramet << 
 95   parameter = new G4UIparameter("green", 'd',  << 
 96   parameter -> SetDefaultValue (0.);           << 
 97   fpCommandBackground -> SetParameter (paramet << 
 98   parameter = new G4UIparameter ("blue", 'd',  << 
 99   parameter -> SetDefaultValue (0.);           << 
100   fpCommandBackground -> SetParameter (paramet << 
101   parameter = new G4UIparameter ("opacity", 'd << 
102   parameter -> SetDefaultValue (1.);           << 
103   fpCommandBackground -> SetParameter (paramet << 
104                                                    64 
105   fpCommandCulling = new G4UIcommand("/vis/vie     65   fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
106   fpCommandCulling->SetGuidance ("Set culling  << 
107   fpCommandCulling->SetGuidance                << 
108   ("\"global\": enables/disables all other cul << 
109   fpCommandCulling->SetGuidance                    66   fpCommandCulling->SetGuidance
110   ("\"coveredDaughters\": culls, i.e., elimina <<  67     ("/vis/viewer/set/culling global|coveredDaughters|invisible|density"
111    "\nbe seen because covered by ancestor volu <<  68      " [true|false] [density] [unit]");
112    "\nand then only if the ancestors are visib << 
113    "\nif no sections or cutaways are in operat << 
114    "\nimprove the speed of rendering visible v << 
115   fpCommandCulling->SetGuidance                    69   fpCommandCulling->SetGuidance
116   ("\"invisible\": culls objects with the invi <<  70     ("If density option is true, provide threshold density and unit");
117   fpCommandCulling->SetGuidance                    71   fpCommandCulling->SetGuidance
118   ("\"density\": culls volumes with density lo <<  72     ("Unit is g/cm3, mg/cm3 or kg/m3");
119    "\nfor eliminating \"container volumes\" wi << 
120    "\nwhose material is usually air.  If this  << 
121    "\ndensity and unit (e.g., g/cm3, mg/cm3 or << 
122    );                                          << 
123   parameter = new G4UIparameter("culling-optio     73   parameter = new G4UIparameter("culling-option",'s',omitable = false);
124   parameter->SetParameterCandidates                74   parameter->SetParameterCandidates
125   ("global coveredDaughters invisible density" <<  75     ("global coveredDaughters invisible density");
126   fpCommandCulling->SetParameter(parameter);       76   fpCommandCulling->SetParameter(parameter);
127   parameter = new G4UIparameter("action",'b',o <<  77   parameter = new G4UIparameter("flag",'b',omitable = true);
128   parameter->SetDefaultValue(1);               <<  78   parameter->SetDefaultValue("true");
129   fpCommandCulling->SetParameter(parameter);       79   fpCommandCulling->SetParameter(parameter);
130   parameter = new G4UIparameter("density-thres <<  80   parameter = new G4UIparameter("density",'d',omitable = true);
131   parameter->SetDefaultValue("0.01");              81   parameter->SetDefaultValue("0.01");
132   fpCommandCulling->SetParameter(parameter);       82   fpCommandCulling->SetParameter(parameter);
133   parameter = new G4UIparameter("unit",'s',omi     83   parameter = new G4UIparameter("unit",'s',omitable = true);
134   // parameter->SetParameterCandidates ("g/cm3 << 
135   // Instead of the above, SetNewValue accepts << 
136   parameter->SetDefaultValue("g/cm3");             84   parameter->SetDefaultValue("g/cm3");
137   fpCommandCulling->SetParameter(parameter);       85   fpCommandCulling->SetParameter(parameter);
138                                                    86 
139   fpCommandCutawayMode =                       << 
140   new G4UIcmdWithAString ("/vis/viewer/set/cut << 
141   fpCommandCutawayMode->SetGuidance            << 
142   ("Sets cutaway mode - add (union) or multipl << 
143   fpCommandCutawayMode->SetParameterName ("cut << 
144   fpCommandCutawayMode->SetCandidates ("add un << 
145   fpCommandCutawayMode->SetDefaultValue("union << 
146                                                << 
147   fpCommandDefaultColour = new G4UIcommand     << 
148   ("/vis/viewer/set/defaultColour",this);      << 
149   fpCommandDefaultColour->SetGuidance          << 
150   ("Set defaultColour colour and transparency  << 
151   fpCommandDefaultColour->SetGuidance(ConvertT << 
152   parameter = new G4UIparameter("red_or_string << 
153   parameter -> SetDefaultValue ("1.");         << 
154   fpCommandDefaultColour -> SetParameter (para << 
155   parameter = new G4UIparameter("green", 'd',  << 
156   parameter -> SetDefaultValue (1.);           << 
157   fpCommandDefaultColour -> SetParameter (para << 
158   parameter = new G4UIparameter ("blue", 'd',  << 
159   parameter -> SetDefaultValue (1.);           << 
160   fpCommandDefaultColour -> SetParameter (para << 
161   parameter = new G4UIparameter ("opacity", 'd << 
162   parameter -> SetDefaultValue (1.);           << 
163   fpCommandDefaultColour -> SetParameter (para << 
164                                                << 
165   fpCommandDefaultTextColour = new G4UIcommand << 
166   ("/vis/viewer/set/defaultTextColour",this);  << 
167   fpCommandDefaultTextColour->SetGuidance      << 
168   ("Set defaultTextColour colour and transpare << 
169   fpCommandDefaultTextColour->SetGuidance(Conv << 
170   parameter = new G4UIparameter("red_or_string << 
171   parameter -> SetDefaultValue ("0.");         << 
172   fpCommandDefaultTextColour -> SetParameter ( << 
173   parameter = new G4UIparameter("green", 'd',  << 
174   parameter -> SetDefaultValue (0.);           << 
175   fpCommandDefaultTextColour -> SetParameter ( << 
176   parameter = new G4UIparameter ("blue", 'd',  << 
177   parameter -> SetDefaultValue (1.);           << 
178   fpCommandDefaultTextColour -> SetParameter ( << 
179   parameter = new G4UIparameter ("opacity", 'd << 
180   parameter -> SetDefaultValue (1.);           << 
181   fpCommandDefaultTextColour -> SetParameter ( << 
182                                                << 
183   fpCommandEdge = new G4UIcmdWithABool("/vis/v     87   fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
184   fpCommandEdge->SetGuidance                   <<  88   fpCommandEdge->SetGuidance("/vis/viewer/set/edge [true|false]");
185   ("Edges become visible/invisible in surface  << 
186   fpCommandEdge->SetParameterName("edge",omita     89   fpCommandEdge->SetParameterName("edge",omitable = true);
187   fpCommandEdge->SetDefaultValue(true);            90   fpCommandEdge->SetDefaultValue(true);
188                                                    91 
189   fpCommandExplodeFactor = new G4UIcommand     << 
190   ("/vis/viewer/set/explodeFactor", this);     << 
191   fpCommandExplodeFactor->SetGuidance          << 
192   ("Moves top-level drawn volumes by this fact << 
193   parameter = new G4UIparameter("explodeFactor << 
194   parameter->SetParameterRange("explodeFactor> << 
195   parameter->SetDefaultValue(1.);              << 
196   fpCommandExplodeFactor->SetParameter(paramet << 
197   parameter = new G4UIparameter("x",'d',omitab << 
198   parameter->SetDefaultValue  (0);             << 
199   parameter->SetGuidance      ("Coordinate of  << 
200   fpCommandExplodeFactor->SetParameter(paramet << 
201   parameter = new G4UIparameter("y",'d',omitab << 
202   parameter->SetDefaultValue  (0);             << 
203   parameter->SetGuidance      ("Coordinate of  << 
204   fpCommandExplodeFactor->SetParameter(paramet << 
205   parameter = new G4UIparameter("z",'d',omitab << 
206   parameter->SetDefaultValue  (0);             << 
207   parameter->SetGuidance      ("Coordinate of  << 
208   fpCommandExplodeFactor->SetParameter(paramet << 
209   parameter = new G4UIparameter("unit",'s',omi << 
210   parameter->SetDefaultValue  ("m");           << 
211   parameter->SetGuidance      ("Unit of explod << 
212   fpCommandExplodeFactor->SetParameter(paramet << 
213                                                << 
214   fpCommandGlobalLineWidthScale = new G4UIcmdW << 
215   ("/vis/viewer/set/globalLineWidthScale", thi << 
216   fpCommandGlobalLineWidthScale->SetGuidance   << 
217   ("Multiplies line widths by this factor.");  << 
218   fpCommandGlobalLineWidthScale->              << 
219   SetParameterName("scale-factor", omitable=tr << 
220   fpCommandGlobalLineWidthScale->SetDefaultVal << 
221                                                << 
222   fpCommandGlobalMarkerScale = new G4UIcmdWith << 
223   ("/vis/viewer/set/globalMarkerScale", this); << 
224   fpCommandGlobalMarkerScale->SetGuidance      << 
225   ("Multiplies marker sizes by this factor."); << 
226   fpCommandGlobalMarkerScale->                 << 
227   SetParameterName("scale-factor", omitable=tr << 
228   fpCommandGlobalMarkerScale->SetDefaultValue( << 
229                                                << 
230   fpCommandHiddenEdge =                            92   fpCommandHiddenEdge =
231   new G4UIcmdWithABool("/vis/viewer/set/hidden <<  93     new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
232   fpCommandHiddenEdge->SetGuidance             <<  94   fpCommandHiddenEdge->SetGuidance("/vis/viewer/set/edge [true|false]");
233   ("Edges become hidden/seen in wireframe or s << 
234   fpCommandHiddenEdge->SetParameterName("hidde     95   fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
235   fpCommandHiddenEdge->SetDefaultValue(true);      96   fpCommandHiddenEdge->SetDefaultValue(true);
236                                                    97 
237   fpCommandHiddenMarker =                          98   fpCommandHiddenMarker =
238   new G4UIcmdWithABool("/vis/viewer/set/hidden <<  99     new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
239   fpCommandHiddenMarker->SetGuidance              100   fpCommandHiddenMarker->SetGuidance
240   ("If true, closer objects hide markers. Othe << 101     ("/vis/viewer/set/hiddenMarker [true|false]");
241   fpCommandHiddenMarker->SetParameterName("hid    102   fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
242   fpCommandHiddenMarker->SetDefaultValue(true)    103   fpCommandHiddenMarker->SetDefaultValue(true);
243                                                   104 
244   fpCommandLightsMove = new G4UIcmdWithAString    105   fpCommandLightsMove = new G4UIcmdWithAString
245   ("/vis/viewer/set/lightsMove",this);         << 106     ("/vis/viewer/set/lightsMove",this);
                                                   >> 107   fpCommandLightsMove->SetGuidance
                                                   >> 108     ("/vis/viewer/set/lightsMove with-camera|with-object");
246   fpCommandLightsMove->SetGuidance                109   fpCommandLightsMove->SetGuidance
247   ("Lights move with camera or with object");  << 110     ("Note: parameter will be parsed for \"cam\" or \"obj\".");
248   fpCommandLightsMove->SetParameterName("light    111   fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
249   fpCommandLightsMove->SetCandidates           << 112   // fpCommandLightsMove->SetCandidates("move-with-camera move-with-object");
250   ("cam camera with-camera obj object with-obj << 113   // Own parsing.
251                                                   114 
252   fpCommandLightsThetaPhi = new G4UIcommand       115   fpCommandLightsThetaPhi = new G4UIcommand
253   ("/vis/viewer/set/lightsThetaPhi", this);    << 116     ("/vis/viewer/set/lightsThetaPhi", this);
254   fpCommandLightsThetaPhi->SetGuidance         << 117   fpCommandLightsThetaPhi -> SetGuidance
255   ("Set direction from target to lights.");    << 118     ("/vis/viewer/set/lightsThetaPhi  [<theta>] [<phi>] [deg|rad]");
                                                   >> 119   fpCommandLightsThetaPhi -> SetGuidance
                                                   >> 120     ("Set direction from target to lights.");
256   parameter = new G4UIparameter("theta", 'd',     121   parameter = new G4UIparameter("theta", 'd', omitable = true);
257   parameter -> SetDefaultValue(60.);           << 122   parameter -> SetCurrentAsDefault (true);
258   fpCommandLightsThetaPhi -> SetParameter (par    123   fpCommandLightsThetaPhi -> SetParameter (parameter);
259   parameter = new G4UIparameter("phi", 'd', om    124   parameter = new G4UIparameter("phi", 'd', omitable = true);
260   parameter -> SetDefaultValue(45.);           << 125   parameter -> SetCurrentAsDefault (true);
261   fpCommandLightsThetaPhi -> SetParameter (par    126   fpCommandLightsThetaPhi -> SetParameter (parameter);
262   parameter = new G4UIparameter ("unit", 's',     127   parameter = new G4UIparameter ("unit", 's', omitable = true);
263   parameter -> SetDefaultValue ("deg");           128   parameter -> SetDefaultValue ("deg");
264   fpCommandLightsThetaPhi -> SetParameter (par    129   fpCommandLightsThetaPhi -> SetParameter (parameter);
265                                                   130 
266   fpCommandLightsVector = new G4UIcommand         131   fpCommandLightsVector = new G4UIcommand
267   ("/vis/viewer/set/lightsVector", this);      << 132     ("/vis/viewer/set/lightsVector", this);
268   fpCommandLightsVector->SetGuidance           << 133   fpCommandLightsVector -> SetGuidance
269   ("Set direction from target to lights.");    << 134     ("/vis/viewer/set/lightsVector  [<x>] [<y>] [<z>]");
                                                   >> 135   fpCommandLightsVector -> SetGuidance
                                                   >> 136     ("Set direction from target to lights.");
270   parameter = new G4UIparameter("x", 'd', omit    137   parameter = new G4UIparameter("x", 'd', omitable = true);
271   parameter -> SetDefaultValue (1);            << 138   parameter -> SetCurrentAsDefault (true);
272   fpCommandLightsVector -> SetParameter (param    139   fpCommandLightsVector -> SetParameter (parameter);
273   parameter = new G4UIparameter("y", 'd', omit    140   parameter = new G4UIparameter("y", 'd', omitable = true);
274   parameter -> SetDefaultValue (1);            << 141   parameter -> SetCurrentAsDefault (true);
275   fpCommandLightsVector -> SetParameter (param    142   fpCommandLightsVector -> SetParameter (parameter);
276   parameter = new G4UIparameter ("z", 'd', omi    143   parameter = new G4UIparameter ("z", 'd', omitable = true);
277   parameter -> SetDefaultValue (1);            << 144   parameter -> SetCurrentAsDefault (true);
278   fpCommandLightsVector -> SetParameter (param    145   fpCommandLightsVector -> SetParameter (parameter);
279                                                   146 
280   fpCommandLineSegments = new G4UIcmdWithAnInt    147   fpCommandLineSegments = new G4UIcmdWithAnInteger
281   ("/vis/viewer/set/lineSegmentsPerCircle",thi << 148     ("/vis/viewer/set/lineSegmentsPerCircle",this);
282   fpCommandLineSegments->SetGuidance              149   fpCommandLineSegments->SetGuidance
283   ("Set number of sides per circle for polygon << 150     ("/vis/viewer/set/lineSegmentsPerCircle  [<number-of-sides-per-circle>]");
284   fpCommandLineSegments->SetGuidance              151   fpCommandLineSegments->SetGuidance
285   ("Refers to graphical representation of obje << 152     ("  Number of sides per circle in polygon/polyhedron graphical"
                                                   >> 153      "\nrepresentation of objects with curved lines/surfaces.");
286   fpCommandLineSegments->SetParameterName("lin    154   fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
287   fpCommandLineSegments->SetDefaultValue(24);     155   fpCommandLineSegments->SetDefaultValue(24);
288                                                   156 
289   fpCommandLineWidth = new G4UIcmdWithoutParam << 
290   ("/vis/viewer/set/lineWidth",this);          << 
291   fpCommandLineWidth->SetGuidance              << 
292   ("Use \"/vis/viewer/set/globalLineWidthScale << 
293    "\nFor trajectories use \"/vis/modeling/tra << 
294    "\nFor volumes use \"/vis/geometry/set/line << 
295                                                << 
296   fpCommandNumberOfCloudPoints = new G4UIcmdWi << 
297   ("/vis/viewer/set/numberOfCloudPoints",this) << 
298   fpCommandNumberOfCloudPoints->SetGuidance    << 
299   ("Set number of points to be used for cloud  << 
300   fpCommandNumberOfCloudPoints->SetParameterNa << 
301   fpCommandNumberOfCloudPoints->SetDefaultValu << 
302                                                << 
303   fpCommandPicking = new G4UIcmdWithABool      << 
304   ("/vis/viewer/set/picking",this);            << 
305   fpCommandPicking->SetGuidance("Sets picking, << 
306   fpCommandPicking->SetGuidance                << 
307   ("If true, view is set up for picking, if av << 
308   fpCommandPicking->SetGuidance                << 
309   ("You may need to issue \"/vis/viewer/update << 
310   fpCommandPicking->SetGuidance                << 
311   ("For required actions, watch for instructio << 
312   fpCommandPicking->SetParameterName("picking" << 
313   fpCommandPicking->SetDefaultValue(true);     << 
314                                                << 
315   fpCommandProjection = new G4UIcommand("/vis/    157   fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
316   fpCommandProjection->SetGuidance                158   fpCommandProjection->SetGuidance
317   ("Set projection style - o[rthogonal] or p[e << 159     ("/vis/viewer/set/projection"
318    "\nIf p[erspective], also set field half an << 160      " o[rthogonal]|p[erspective] [<field-half-angle>] [deg|rad]");
                                                   >> 161   fpCommandProjection->SetGuidance
                                                   >> 162     ("Note: 1st parameter will be parsed for first character \"o\" or \"p\".");
                                                   >> 163   fpCommandProjection->SetGuidance("Default: orthogonal 30 deg");
319   parameter = new G4UIparameter("projection",'    164   parameter = new G4UIparameter("projection",'s',omitable = true);
320   parameter->SetParameterCandidates("o orthogo << 
321   parameter->SetDefaultValue("orthogonal");       165   parameter->SetDefaultValue("orthogonal");
322   fpCommandProjection->SetParameter(parameter)    166   fpCommandProjection->SetParameter(parameter);
323   parameter = new G4UIparameter("field-half-an    167   parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
324   parameter->SetDefaultValue(30.);                168   parameter->SetDefaultValue(30.);
325   //parameter->SetCurrentAsDefault(true);      << 
326   fpCommandProjection->SetParameter(parameter)    169   fpCommandProjection->SetParameter(parameter);
327   parameter = new G4UIparameter("unit",'s',omi    170   parameter = new G4UIparameter("unit",'s',omitable = true);
328   parameter->SetDefaultValue("deg");              171   parameter->SetDefaultValue("deg");
329   //parameter->SetCurrentAsDefault(true);      << 
330   fpCommandProjection->SetParameter(parameter)    172   fpCommandProjection->SetParameter(parameter);
331                                                   173 
332   fpCommandRotationStyle = new G4UIcmdWithAStr << 174   fpCommandSectionPlane = new G4UIcommand 
333   ("/vis/viewer/set/rotationStyle",this);      << 175     ("/vis/viewer/set/sectionPlane",this);
334   fpCommandRotationStyle->SetGuidance          << 
335   ("Set style of rotation - constrainUpDirecti << 
336   fpCommandRotationStyle->SetGuidance          << 
337   ("constrainUpDirection: conventional HEP vie << 
338   fpCommandRotationStyle->SetGuidance          << 
339   ("freeRotation: Google-like rotation, using  << 
340   fpCommandRotationStyle->SetParameterName ("s << 
341   fpCommandRotationStyle->SetCandidates("const << 
342                                                << 
343   fpCommandSectionPlane = new G4UIcommand("/vi << 
344   fpCommandSectionPlane -> SetGuidance            176   fpCommandSectionPlane -> SetGuidance
345   ("Set plane for drawing section (DCUT).");   << 177     (
346   fpCommandSectionPlane -> SetGuidance         << 178      "Set plane for drawing section (DCUT).  Specify plane by"
347   ("E.g., for a y-z plane at x = 1 cm:"        << 179      "\nx y z units nx ny nz, e.g., for a y-z plane at x = 1 cm:"
348    "\n\"/vis/viewer/set/sectionPlane on 1 0 0  << 180      "\n/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0"
349    "\nTo turn off: /vis/viewer/set/sectionPlan << 181      );
350   parameter  =  new G4UIparameter("Selector",'    182   parameter  =  new G4UIparameter("Selector",'c',true);
351   parameter  -> SetDefaultValue  ("on");       << 183   parameter  -> SetDefaultValue  ("?");
352   fpCommandSectionPlane->SetParameter(paramete    184   fpCommandSectionPlane->SetParameter(parameter);
353   parameter  =  new G4UIparameter("x",'d',omit    185   parameter  =  new G4UIparameter("x",'d',omitable = true);
354   parameter  -> SetDefaultValue  (0);             186   parameter  -> SetDefaultValue  (0);
355   parameter  -> SetGuidance      ("Coordinate     187   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
356   fpCommandSectionPlane->SetParameter(paramete    188   fpCommandSectionPlane->SetParameter(parameter);
357   parameter  =  new G4UIparameter("y",'d',omit    189   parameter  =  new G4UIparameter("y",'d',omitable = true);
358   parameter  -> SetDefaultValue  (0);             190   parameter  -> SetDefaultValue  (0);
359   parameter  -> SetGuidance      ("Coordinate     191   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
360   fpCommandSectionPlane->SetParameter(paramete    192   fpCommandSectionPlane->SetParameter(parameter);
361   parameter  =  new G4UIparameter("z",'d',omit    193   parameter  =  new G4UIparameter("z",'d',omitable = true);
362   parameter  -> SetDefaultValue  (0);             194   parameter  -> SetDefaultValue  (0);
363   parameter  -> SetGuidance      ("Coordinate     195   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
364   fpCommandSectionPlane->SetParameter(paramete    196   fpCommandSectionPlane->SetParameter(parameter);
365   parameter  =  new G4UIparameter("unit",'s',o    197   parameter  =  new G4UIparameter("unit",'s',omitable = true);
366   parameter  -> SetDefaultValue  ("m");        << 198   parameter  -> SetDefaultValue  ("cm");
367   parameter  -> SetGuidance      ("Unit of poi    199   parameter  -> SetGuidance      ("Unit of point on the plane.");
368   fpCommandSectionPlane->SetParameter(paramete    200   fpCommandSectionPlane->SetParameter(parameter);
369   parameter  =  new G4UIparameter("nx",'d',omi    201   parameter  =  new G4UIparameter("nx",'d',omitable = true);
370   parameter  -> SetDefaultValue  (1);             202   parameter  -> SetDefaultValue  (1);
371   parameter  -> SetGuidance      ("Component o    203   parameter  -> SetGuidance      ("Component of plane normal.");
372   fpCommandSectionPlane->SetParameter(paramete    204   fpCommandSectionPlane->SetParameter(parameter);
373   parameter  =  new G4UIparameter("ny",'d',omi    205   parameter  =  new G4UIparameter("ny",'d',omitable = true);
374   parameter  -> SetDefaultValue  (0);             206   parameter  -> SetDefaultValue  (0);
375   parameter  -> SetGuidance      ("Component o    207   parameter  -> SetGuidance      ("Component of plane normal.");
376   fpCommandSectionPlane->SetParameter(paramete    208   fpCommandSectionPlane->SetParameter(parameter);
377   parameter  =  new G4UIparameter("nz",'d',omi    209   parameter  =  new G4UIparameter("nz",'d',omitable = true);
378   parameter  -> SetDefaultValue  (0);             210   parameter  -> SetDefaultValue  (0);
379   parameter  -> SetGuidance      ("Component o    211   parameter  -> SetGuidance      ("Component of plane normal.");
380   fpCommandSectionPlane->SetParameter(paramete    212   fpCommandSectionPlane->SetParameter(parameter);
381                                                   213 
382   fpCommandSpecialMeshRendering = new G4UIcmdW << 
383   ("/vis/viewer/set/specialMeshRendering",this << 
384   fpCommandSpecialMeshRendering -> SetGuidance << 
385   ("Request special rendering of volumes (mesh << 
386   fpCommandSpecialMeshRendering->SetParameterN << 
387   fpCommandSpecialMeshRendering->SetDefaultVal << 
388                                                << 
389   fpCommandSpecialMeshRenderingOption = new G4 << 
390   ("/vis/viewer/set/specialMeshRenderingOption << 
391   fpCommandSpecialMeshRenderingOption->SetGuid << 
392   ("Set special mesh rendering option - \"defa << 
393   fpCommandSpecialMeshRenderingOption->SetPara << 
394   fpCommandSpecialMeshRenderingOption->SetCand << 
395   fpCommandSpecialMeshRenderingOption->SetDefa << 
396                                                << 
397   fpCommandSpecialMeshVolumes = new G4UIcomman << 
398   ("/vis/viewer/set/specialMeshVolumes",this); << 
399   fpCommandSpecialMeshVolumes -> SetGuidance   << 
400   ("Specify the volumes for special rendering. << 
401    "\nand is interpreted to mean \"all found m << 
402   fpCommandSpecialMeshVolumes->SetGuidance     << 
403   ("Please provide a list of space-separated p << 
404    "\nnumber pairs. Negative copy number means << 
405   parameter = new G4UIparameter("volumes",'s', << 
406   parameter->SetGuidance                       << 
407   ("List of physical volume names and copy num << 
408   fpCommandSpecialMeshVolumes->SetParameter(pa << 
409                                                << 
410   fpCommandStyle = new G4UIcmdWithAString ("/v    214   fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
                                                   >> 215   fpCommandStyle->SetGuidance ("/vis/viewer/set/style wireframe|surface");
411   fpCommandStyle->SetGuidance                     216   fpCommandStyle->SetGuidance
412   ("Set style of drawing - w[ireframe] or s[ur << 217     ("Note: parameter will be parsed for first character \"w\" or \"s\".");
413   fpCommandStyle->SetGuidance                  << 
414   ("(Hidden line drawing is controlled by \"/v << 
415   fpCommandStyle->SetParameterName ("style",om    218   fpCommandStyle->SetParameterName ("style",omitable = false);
416   fpCommandStyle->SetCandidates("w wireframe s << 219   // fpCommandStyle->SetCandidates("wireframe surface");  // Own parsing.
417                                                << 
418   fpCommandTargetPoint = new G4UIcmdWith3Vecto << 
419   ("/vis/viewer/set/targetPoint", this);       << 
420   fpCommandTargetPoint->SetGuidance            << 
421   ("Set target point.");                       << 
422   fpCommandTargetPoint->SetGuidance            << 
423   ("This sets the \"Current Target Point\" rel << 
424   fpCommandTargetPoint->SetGuidance            << 
425   ("Target Point\" so that the actual target p << 
426   fpCommandTargetPoint->SetGuidance            << 
427   ("(See G4ViewParameters.hh for an explanatio << 
428   fpCommandTargetPoint->SetParameterName("x",  << 
429   fpCommandTargetPoint->SetUnitCategory("Lengt << 
430                                                   220 
431   fpCommandUpThetaPhi = new G4UIcommand           221   fpCommandUpThetaPhi = new G4UIcommand
432   ("/vis/viewer/set/upThetaPhi", this);        << 222     ("/vis/viewer/set/upThetaPhi", this);
433   fpCommandUpThetaPhi -> SetGuidance ("Set up  << 
434   fpCommandUpThetaPhi -> SetGuidance              223   fpCommandUpThetaPhi -> SetGuidance
435   ("Viewer will attempt always to show this di << 224     ("/vis/viewer/set/upThetaPhi  [<theta>] [<phi>] [deg|rad]");
                                                   >> 225   fpCommandUpThetaPhi -> SetGuidance
                                                   >> 226     ("Set up vector.  Viewer will attempt always to show"
                                                   >> 227      " this direction upwards.");
436   parameter = new G4UIparameter("theta", 'd',     228   parameter = new G4UIparameter("theta", 'd', omitable = true);
437   parameter -> SetDefaultValue (90.);          << 229   parameter -> SetCurrentAsDefault (true);
438   fpCommandUpThetaPhi -> SetParameter (paramet    230   fpCommandUpThetaPhi -> SetParameter (parameter);
439   parameter = new G4UIparameter("phi", 'd', om    231   parameter = new G4UIparameter("phi", 'd', omitable = true);
440   parameter -> SetDefaultValue (90.);          << 232   parameter -> SetCurrentAsDefault (true);
441   fpCommandUpThetaPhi -> SetParameter (paramet    233   fpCommandUpThetaPhi -> SetParameter (parameter);
442   parameter = new G4UIparameter ("unit", 's',     234   parameter = new G4UIparameter ("unit", 's', omitable = true);
443   parameter -> SetDefaultValue ("deg");           235   parameter -> SetDefaultValue ("deg");
444   fpCommandUpThetaPhi -> SetParameter (paramet    236   fpCommandUpThetaPhi -> SetParameter (parameter);
445                                                   237 
446   fpCommandUpVector = new G4UIcommand             238   fpCommandUpVector = new G4UIcommand
447   ("/vis/viewer/set/upVector", this);          << 239     ("/vis/viewer/set/upVector", this);
448   fpCommandUpVector -> SetGuidance ("Set up ve << 240   fpCommandUpVector -> SetGuidance
                                                   >> 241     ("/vis/viewer/set/upVector  [<x>] [<y>] [<z>]");
449   fpCommandUpVector -> SetGuidance                242   fpCommandUpVector -> SetGuidance
450   ("Viewer will attempt always to show this di << 243     ("Set up vector.  Viewer will attempt always to show"
                                                   >> 244      " this direction upwards.");
451   parameter = new G4UIparameter("x", 'd', omit    245   parameter = new G4UIparameter("x", 'd', omitable = true);
452   parameter -> SetDefaultValue (0.);           << 246   parameter -> SetCurrentAsDefault (true);
453   fpCommandUpVector -> SetParameter (parameter    247   fpCommandUpVector -> SetParameter (parameter);
454   parameter = new G4UIparameter("y", 'd', omit    248   parameter = new G4UIparameter("y", 'd', omitable = true);
455   parameter -> SetDefaultValue (1.);           << 249   parameter -> SetCurrentAsDefault (true);
456   fpCommandUpVector -> SetParameter (parameter    250   fpCommandUpVector -> SetParameter (parameter);
457   parameter = new G4UIparameter ("z", 'd', omi    251   parameter = new G4UIparameter ("z", 'd', omitable = true);
458   parameter -> SetDefaultValue (0.);           << 252   parameter -> SetCurrentAsDefault (true);
459   fpCommandUpVector -> SetParameter (parameter    253   fpCommandUpVector -> SetParameter (parameter);
460                                                   254 
461   fpCommandViewpointThetaPhi = new G4UIcommand    255   fpCommandViewpointThetaPhi = new G4UIcommand
462   ("/vis/viewer/set/viewpointThetaPhi", this); << 256     ("/vis/viewer/set/viewpointThetaPhi", this);
463   fpCommandViewpointThetaPhi -> SetGuidance       257   fpCommandViewpointThetaPhi -> SetGuidance
464   ("Set direction from target to camera.");    << 258     ("/vis/viewer/set/viewpointThetaPhi  [<theta>] [<phi>] [deg|rad]");
465   fpCommandViewpointThetaPhi -> SetGuidance       259   fpCommandViewpointThetaPhi -> SetGuidance
466   ("Also changes lightpoint direction if light << 260     ("Set direction from target to camera.  Also changes lightpoint direction"
                                                   >> 261      "\nif lights are set to move with camera.");
467   parameter = new G4UIparameter("theta", 'd',     262   parameter = new G4UIparameter("theta", 'd', omitable = true);
468   parameter -> SetDefaultValue (60.);          << 263   parameter -> SetCurrentAsDefault (true);
469   fpCommandViewpointThetaPhi -> SetParameter (    264   fpCommandViewpointThetaPhi -> SetParameter (parameter);
470   parameter = new G4UIparameter("phi", 'd', om    265   parameter = new G4UIparameter("phi", 'd', omitable = true);
471   parameter -> SetDefaultValue (45.);          << 266   parameter -> SetCurrentAsDefault (true);
472   fpCommandViewpointThetaPhi -> SetParameter (    267   fpCommandViewpointThetaPhi -> SetParameter (parameter);
473   parameter = new G4UIparameter ("unit", 's',     268   parameter = new G4UIparameter ("unit", 's', omitable = true);
474   parameter -> SetDefaultValue ("deg");           269   parameter -> SetDefaultValue ("deg");
475   fpCommandViewpointThetaPhi -> SetParameter (    270   fpCommandViewpointThetaPhi -> SetParameter (parameter);
476                                                   271 
477   fpCommandViewpointVector = new G4UIcommand      272   fpCommandViewpointVector = new G4UIcommand
478   ("/vis/viewer/set/viewpointVector", this);   << 273     ("/vis/viewer/set/viewpointVector", this);
479   fpCommandViewpointVector -> SetGuidance         274   fpCommandViewpointVector -> SetGuidance
480   ("Set direction from target to camera.");    << 275     ("/vis/viewer/set/viewpointVector  [<x>] [<y>] [<z>]");
481   fpCommandViewpointVector -> SetGuidance         276   fpCommandViewpointVector -> SetGuidance
482   ("Also changes lightpoint direction if light << 277     ("Set direction from target to camera.  Also changes lightpoint direction"
                                                   >> 278      "\nif lights are set to move with camera.");
483   parameter = new G4UIparameter("x", 'd', omit    279   parameter = new G4UIparameter("x", 'd', omitable = true);
484   parameter -> SetDefaultValue (1.);           << 280   parameter -> SetCurrentAsDefault (true);
485   fpCommandViewpointVector -> SetParameter (pa    281   fpCommandViewpointVector -> SetParameter (parameter);
486   parameter = new G4UIparameter("y", 'd', omit    282   parameter = new G4UIparameter("y", 'd', omitable = true);
487   parameter -> SetDefaultValue (1.);           << 283   parameter -> SetCurrentAsDefault (true);
488   fpCommandViewpointVector -> SetParameter (pa    284   fpCommandViewpointVector -> SetParameter (parameter);
489   parameter = new G4UIparameter ("z", 'd', omi    285   parameter = new G4UIparameter ("z", 'd', omitable = true);
490   parameter -> SetDefaultValue (1.);           << 286   parameter -> SetCurrentAsDefault (true);
491   fpCommandViewpointVector -> SetParameter (pa    287   fpCommandViewpointVector -> SetParameter (parameter);
492                                                << 
493   fpTimeWindowDirectory = new G4UIdirectory (" << 
494   fpTimeWindowDirectory -> SetGuidance ("Set t << 
495   G4String timeWindowGuidance =                << 
496   "For these commands use"                     << 
497   "\n  /vis/scene/add/trajectories rich"       << 
498   "\n  /vis/modeling/trajectories/drawByCharge << 
499   "\nthen typically"                           << 
500   "\n  /vis/viewer/set/timeWindow/displayLight << 
501   "\n  /vis/viewer/set/timeWindow/displayHeadT << 
502   "\n  /vis/viewer/set/timeWindow/fadeFactor 1 << 
503   "\n  /run/beamOn # or several until you get  << 
504   "\n  /vis/viewer/set/timeWindow/startTime 0  << 
505   "\n  /vis/viewer/save"                       << 
506   "\n  /vis/viewer/set/timeWindow/startTime 1  << 
507   "\nthen zoom, pan etc to a view of interest  << 
508   "\n  /vis/viewer/save"                       << 
509   "\nthen repeat with next start time, another << 
510   "\n  /vis/viewer/interpolate";               << 
511                                                << 
512   fpCommandTimeWindowDisplayHeadTime =         << 
513   new G4UIcommand("/vis/viewer/set/timeWindow/ << 
514   fpCommandTimeWindowDisplayHeadTime->SetGuida << 
515   ("Display head time of range in 2D text.");  << 
516   fpCommandTimeWindowDisplayHeadTime->SetGuida << 
517   parameter = new G4UIparameter ("displayHeadT << 
518   parameter->SetDefaultValue(false);           << 
519   fpCommandTimeWindowDisplayHeadTime->SetParam << 
520   parameter = new G4UIparameter ("screenX", 'd << 
521   parameter->SetGuidance("-1 < screenX < 1");  << 
522   parameter->SetParameterRange("screenX >= -1. << 
523   parameter->SetDefaultValue(-0.9);            << 
524   fpCommandTimeWindowDisplayHeadTime->SetParam << 
525   parameter = new G4UIparameter ("screenY", 'd << 
526   parameter->SetGuidance("-1 < screenY < 1");  << 
527   parameter->SetParameterRange("screenY >= -1. << 
528   parameter->SetDefaultValue(-0.9);            << 
529   fpCommandTimeWindowDisplayHeadTime->SetParam << 
530   parameter = new G4UIparameter ("screenSize", << 
531   parameter->SetDefaultValue(24.);             << 
532   fpCommandTimeWindowDisplayHeadTime->SetParam << 
533   parameter = new G4UIparameter ("red", 'd', o << 
534   parameter->SetParameterRange("red >= 0. && r << 
535   parameter->SetDefaultValue(0.);              << 
536   fpCommandTimeWindowDisplayHeadTime->SetParam << 
537   parameter = new G4UIparameter ("green", 'd', << 
538   parameter->SetParameterRange("green >= 0. && << 
539   parameter->SetDefaultValue(1.);              << 
540   fpCommandTimeWindowDisplayHeadTime->SetParam << 
541   parameter = new G4UIparameter ("blue", 'd',  << 
542   parameter->SetParameterRange("blue >= 0. &&  << 
543   parameter->SetDefaultValue(1.);              << 
544   fpCommandTimeWindowDisplayHeadTime->SetParam << 
545                                                << 
546   fpCommandTimeWindowDisplayLightFront =       << 
547   new G4UIcommand("/vis/viewer/set/timeWindow/ << 
548   fpCommandTimeWindowDisplayLightFront->SetGui << 
549   ("Display the light front at head time.");   << 
550   fpCommandTimeWindowDisplayLightFront->SetGui << 
551   ("Tip: The trajectories can appear of jump a << 
552    "\nbecause their time range overlaps the vi << 
553    "\naverage out this discrete time effect, a << 
554    "\nhalf the trajectories interval. E.g., if << 
555    "\ninterval is 0.01 ns:"                    << 
556    "\n  /vis/viewer/set/timeWindow/displayLigh << 
557    "\nTo prevent them beating the light front  << 
558    "\n  /vis/viewer/set/timeWindow/displayLigh << 
559   fpCommandTimeWindowDisplayLightFront->SetGui << 
560   parameter = new G4UIparameter ("displayLight << 
561   parameter->SetDefaultValue(true);            << 
562   fpCommandTimeWindowDisplayLightFront->SetPar << 
563   parameter = new G4UIparameter ("originX", 'd << 
564   parameter->SetDefaultValue(0.);              << 
565   fpCommandTimeWindowDisplayLightFront->SetPar << 
566   parameter = new G4UIparameter ("originY", 'd << 
567   parameter->SetDefaultValue(0.);              << 
568   fpCommandTimeWindowDisplayLightFront->SetPar << 
569   parameter = new G4UIparameter ("originZ", 'd << 
570   parameter->SetDefaultValue(0.);              << 
571   fpCommandTimeWindowDisplayLightFront->SetPar << 
572   parameter = new G4UIparameter ("space_unit", << 
573   parameter->SetDefaultValue("m");             << 
574   fpCommandTimeWindowDisplayLightFront->SetPar << 
575   parameter = new G4UIparameter ("originT", 'd << 
576   parameter->SetDefaultValue(0.);              << 
577   fpCommandTimeWindowDisplayLightFront->SetPar << 
578   parameter = new G4UIparameter ("time_unit",  << 
579   parameter->SetDefaultValue("s");             << 
580   fpCommandTimeWindowDisplayLightFront->SetPar << 
581   parameter = new G4UIparameter ("red", 'd', o << 
582   parameter->SetParameterRange("red >= 0. && r << 
583   parameter->SetDefaultValue(0.);              << 
584   fpCommandTimeWindowDisplayLightFront->SetPar << 
585   parameter = new G4UIparameter ("green", 'd', << 
586   parameter->SetParameterRange("green >= 0. && << 
587   parameter->SetDefaultValue(1.);              << 
588   fpCommandTimeWindowDisplayLightFront->SetPar << 
589   parameter = new G4UIparameter ("blue", 'd',  << 
590   parameter->SetParameterRange("blue >= 0. &&  << 
591   parameter->SetDefaultValue(0.);              << 
592   fpCommandTimeWindowDisplayLightFront->SetPar << 
593                                                << 
594   fpCommandTimeWindowEndTime =                 << 
595   new G4UIcommand("/vis/viewer/set/timeWindow/ << 
596   fpCommandTimeWindowEndTime->SetGuidance("Set << 
597   fpCommandTimeWindowEndTime->SetGuidance(time << 
598   parameter = new G4UIparameter ("end-time", ' << 
599   parameter->SetDefaultValue(G4VisAttributes:: << 
600   fpCommandTimeWindowEndTime->SetParameter(par << 
601   parameter = new G4UIparameter ("end-time-uni << 
602   parameter->SetDefaultValue("ns");            << 
603   fpCommandTimeWindowEndTime->SetParameter(par << 
604   parameter = new G4UIparameter ("time-range", << 
605   parameter->SetDefaultValue(-1.);             << 
606   fpCommandTimeWindowEndTime->SetParameter(par << 
607   parameter = new G4UIparameter ("time-range-u << 
608   parameter->SetDefaultValue("ns");            << 
609   fpCommandTimeWindowEndTime->SetParameter(par << 
610                                                << 
611   fpCommandTimeWindowFadeFactor =              << 
612   new G4UIcmdWithADouble("/vis/viewer/set/time << 
613   fpCommandTimeWindowFadeFactor->SetGuidance   << 
614   ("0: no fade; 1: maximum fade with time wind << 
615   fpCommandTimeWindowFadeFactor->SetGuidance(t << 
616   fpCommandTimeWindowFadeFactor->SetParameterN << 
617   fpCommandTimeWindowFadeFactor->SetRange("fad << 
618   fpCommandTimeWindowFadeFactor->SetDefaultVal << 
619                                                << 
620   fpCommandTimeWindowStartTime =               << 
621   new G4UIcommand("/vis/viewer/set/timeWindow/ << 
622   fpCommandTimeWindowStartTime->SetGuidance("S << 
623   fpCommandTimeWindowStartTime->SetGuidance(ti << 
624   parameter = new G4UIparameter ("start-time", << 
625   parameter->SetDefaultValue(-G4VisAttributes: << 
626   fpCommandTimeWindowStartTime->SetParameter(p << 
627   parameter = new G4UIparameter ("start-time-u << 
628   parameter->SetDefaultValue("ns");            << 
629   fpCommandTimeWindowStartTime->SetParameter(p << 
630   parameter = new G4UIparameter ("time-range", << 
631   parameter->SetDefaultValue(-1.);             << 
632   fpCommandTimeWindowStartTime->SetParameter(p << 
633   parameter = new G4UIparameter ("time-range-u << 
634   parameter->SetDefaultValue("ns");            << 
635   fpCommandTimeWindowStartTime->SetParameter(p << 
636 }                                                 288 }
637                                                   289 
638 G4VisCommandsViewerSet::~G4VisCommandsViewerSe    290 G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
639   delete fpCommandTimeWindowStartTime;         << 291   delete fpCommandAll;
640   delete fpCommandTimeWindowFadeFactor;        << 292   delete fpCommandAutoRefresh;
641   delete fpCommandTimeWindowEndTime;           << 293   delete fpCommandCulling;
642   delete fpCommandTimeWindowDisplayLightFront; << 294   delete fpCommandEdge;
643   delete fpCommandTimeWindowDisplayHeadTime;   << 295   delete fpCommandHiddenEdge;
644   delete fpTimeWindowDirectory;                << 296   delete fpCommandHiddenMarker;
645   delete fpCommandViewpointVector;             << 
646   delete fpCommandViewpointThetaPhi;           << 
647   delete fpCommandUpVector;                    << 
648   delete fpCommandUpThetaPhi;                  << 
649   delete fpCommandTargetPoint;                 << 
650   delete fpCommandStyle;                       << 
651   delete fpCommandSpecialMeshVolumes;          << 
652   delete fpCommandSpecialMeshRenderingOption;  << 
653   delete fpCommandSpecialMeshRendering;        << 
654   delete fpCommandSectionPlane;                << 
655   delete fpCommandRotationStyle;               << 
656   delete fpCommandProjection;                  << 
657   delete fpCommandPicking;                     << 
658   delete fpCommandNumberOfCloudPoints;         << 
659   delete fpCommandLineWidth;                   << 
660   delete fpCommandLineSegments;                   297   delete fpCommandLineSegments;
661   delete fpCommandLightsVector;                << 
662   delete fpCommandLightsThetaPhi;              << 
663   delete fpCommandLightsMove;                     298   delete fpCommandLightsMove;
664   delete fpCommandHiddenMarker;                << 299   delete fpCommandLightsThetaPhi;
665   delete fpCommandHiddenEdge;                  << 300   delete fpCommandLightsVector;
666   delete fpCommandGlobalMarkerScale;           << 301   delete fpCommandProjection;
667   delete fpCommandGlobalLineWidthScale;        << 302   delete fpCommandSectionPlane;
668   delete fpCommandExplodeFactor;               << 303   delete fpCommandStyle;
669   delete fpCommandEdge;                        << 304   delete fpCommandUpThetaPhi;
670   delete fpCommandDefaultTextColour;           << 305   delete fpCommandUpVector;
671   delete fpCommandDefaultColour;               << 306   delete fpCommandViewpointThetaPhi;
672   delete fpCommandCutawayMode;                 << 307   delete fpCommandViewpointVector;
673   delete fpCommandCulling;                     << 
674   delete fpCommandBackground;                  << 
675   delete fpCommandAuxEdge;                     << 
676   delete fpCommandAutoRefresh;                 << 
677   delete fpCommandAll;                         << 
678 }                                                 308 }
679                                                   309 
680 G4String G4VisCommandsViewerSet::GetCurrentVal << 310 G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand* command) {
681   return "";                                   << 311   G4String currentValue;
                                                   >> 312   if (command == fpCommandLightsThetaPhi) {
                                                   >> 313     currentValue = ConvertToString(fLightsVector.theta(),
                                                   >> 314          fLightsVector.phi(), "deg");
                                                   >> 315   }
                                                   >> 316   else if (command == fpCommandLightsVector) {
                                                   >> 317     currentValue = ConvertToString(fLightsVector);
                                                   >> 318   }
                                                   >> 319   else if (command == fpCommandViewpointThetaPhi) {
                                                   >> 320     currentValue = ConvertToString(fViewpointVector.theta(),
                                                   >> 321          fViewpointVector.phi(), "deg");
                                                   >> 322   }
                                                   >> 323   else if (command == fpCommandViewpointVector) {
                                                   >> 324     currentValue = ConvertToString(fViewpointVector);
                                                   >> 325   }
                                                   >> 326   else {
                                                   >> 327     currentValue = "invalid";
                                                   >> 328   }
                                                   >> 329   return currentValue;
682 }                                                 330 }
683                                                   331 
684 void G4VisCommandsViewerSet::SetNewValue          332 void G4VisCommandsViewerSet::SetNewValue
685 (G4UIcommand* command,G4String newValue) {        333 (G4UIcommand* command,G4String newValue) {
686                                                   334 
687   G4VisManager::Verbosity verbosity = fpVisMan    335   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
688                                                   336 
689   G4VViewer* currentViewer = fpVisManager->Get    337   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
690   if (!currentViewer) {                           338   if (!currentViewer) {
691     if (verbosity >= G4VisManager::errors) {      339     if (verbosity >= G4VisManager::errors) {
692       G4warn <<                                << 340       G4cout << 
693       "ERROR: G4VisCommandsViewerSet::SetNewVa << 341   "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
694       << G4endl;                               << 342        << G4endl;
695     }                                             343     }
696     return;                                       344     return;
697   }                                               345   }
698                                                   346 
699   G4ViewParameters vp = currentViewer->GetView    347   G4ViewParameters vp = currentViewer->GetViewParameters();
700                                                   348 
701   if (command == fpCommandAll) {                  349   if (command == fpCommandAll) {
702     G4VViewer* fromViewer = fpVisManager->GetV    350     G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
703     if (!fromViewer) {                            351     if (!fromViewer) {
704       if (verbosity >= G4VisManager::errors) {    352       if (verbosity >= G4VisManager::errors) {
705         G4warn <<                              << 353   G4cout <<
706         "ERROR: G4VisCommandsViewerSet::SetNew << 354     "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
707         "\n  unrecognised from-viewer."        << 355     "\n  unrecognised from-viewer."
708         << G4endl;                             << 356          << G4endl;
709       }                                           357       }
710       return;                                     358       return;
711     }                                             359     }
712     if (fromViewer == currentViewer) {            360     if (fromViewer == currentViewer) {
713       if (verbosity >= G4VisManager::warnings)    361       if (verbosity >= G4VisManager::warnings) {
714         G4warn <<                              << 362       G4cout <<
715         "WARNING: G4VisCommandsViewerSet::SetN << 363   "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
716         "\n  from-viewer and current viewer ar << 364   "\n  from-viewer and current viewer are identical."
717         << G4endl;                             << 365        << G4endl;
718       }                                           366       }
719       return;                                     367       return;
720     }                                             368     }
721     // Copy view parameters except for autoRef << 369     // Copy view parameters except for autoRefresh...
722     auto keepAutoRefresh = vp.IsAutoRefresh(); << 370     G4bool currentAutoRefresh =
723     auto keepBackground  = vp.GetBackgroundCol << 371       currentViewer->GetViewParameters().IsAutoRefresh();
724     vp = fromViewer->GetViewParameters();         372     vp = fromViewer->GetViewParameters();
725     vp.SetAutoRefresh(keepAutoRefresh);        << 373     vp.SetAutoRefresh(currentAutoRefresh);
726     vp.SetBackgroundColour(keepBackground);    << 
727     // Concatenate any private vis attributes  << 
728     const std::vector<G4ModelingParameters::Vi << 
729     privateVAMs = fromViewer->GetPrivateVisAtt << 
730     if (privateVAMs) {                         << 
731       std::vector<G4ModelingParameters::VisAtt << 
732       for (i = privateVAMs->begin(); i != priv << 
733         vp.AddVisAttributesModifier(*i);       << 
734       }                                        << 
735     }                                          << 
736     if (verbosity >= G4VisManager::confirmatio    374     if (verbosity >= G4VisManager::confirmations) {
737       G4cout << "View parameters of viewer \""    375       G4cout << "View parameters of viewer \"" << currentViewer->GetName()
738       << "\"\n  set to those of viewer \"" <<  << 376        << "\"\n  set to those of viewer \"" << fromViewer->GetName()
739       << "\"."                                 << 377        << "\"."
740       << G4endl;                               << 378        << G4endl;
741     }                                          << 
742     if (verbosity >= G4VisManager::warnings) { << 
743       G4warn << "You may need \"/vis/viewer/re << 
744       << G4endl;                               << 
745     }                                             379     }
746   }                                               380   }
747                                                   381 
748   else if (command == fpCommandAutoRefresh) {     382   else if (command == fpCommandAutoRefresh) {
749     G4bool autoRefresh = G4UIcommand::ConvertT << 383     G4bool autoRefresh = GetNewBoolValue(newValue);
750     const G4ViewParameters& defaultVP =        << 
751     currentViewer->GetDefaultViewParameters(); << 
752     if (autoRefresh && !defaultVP.IsAutoRefres << 
753       if (verbosity >= G4VisManager::warnings) << 
754         G4warn                                 << 
755         << "WARNING: "                         << 
756         << currentViewer->GetName() << " is NO << 
757         << "\n  so cannot be set to auto-refre << 
758         << G4endl;                             << 
759       }                                        << 
760       return;                                  << 
761     }                                          << 
762     vp.SetAutoRefresh(autoRefresh);               384     vp.SetAutoRefresh(autoRefresh);
                                                   >> 385     if (verbosity >= G4VisManager::warnings) {
                                                   >> 386       G4cout <<
                                                   >> 387   "/vis/viewer/set/autoRefresh is a DEPRECATED COMMAND."
                                                   >> 388   "\n  It will be removed from next major release."
                                                   >> 389        << G4endl;
                                                   >> 390     }
763     if (verbosity >= G4VisManager::confirmatio    391     if (verbosity >= G4VisManager::confirmations) {
764       G4cout << "Views will ";                    392       G4cout << "Views will ";
765       if (!vp.IsAutoRefresh()) G4cout << "not     393       if (!vp.IsAutoRefresh()) G4cout << "not ";
766       G4cout << "be automatically refreshed af    394       G4cout << "be automatically refreshed after a change of view parameters."
767       << G4endl;                               << 395        << G4endl;
768     }                                          << 
769     if (!vp.IsAutoRefresh()) {                 << 
770       currentViewer->SetViewParameters(vp);    << 
771       return;  // Avoid a refresh if auto-refr << 
772     }  // ...otherwise take normal action.     << 
773   }                                            << 
774                                                << 
775   else if (command == fpCommandAuxEdge) {      << 
776     vp.SetAuxEdgeVisible(G4UIcommand::ConvertT << 
777     if (verbosity >= G4VisManager::confirmatio << 
778       G4cout << "Auxiliary edges will ";       << 
779       if (!vp.IsAuxEdgeVisible()) G4cout << "n << 
780       G4cout << "be visible." << G4endl;       << 
781     }                                          << 
782   }                                            << 
783                                                << 
784   else if (command == fpCommandBackground) {   << 
785     G4String redOrString;                      << 
786     G4double green, blue, opacity;             << 
787     std::istringstream iss(newValue);          << 
788     iss >> redOrString >> green >> blue >> opa << 
789     G4Colour colour(0.,0.,0.);  // Default bla << 
790     ConvertToColour(colour, redOrString, green << 
791     vp.SetBackgroundColour(colour);            << 
792     if (verbosity >= G4VisManager::confirmatio << 
793       G4cout << "Background colour "           << 
794       << vp.GetBackgroundColour()              << 
795       << " requested."                         << 
796       << G4endl;                               << 
797     }                                             396     }
798   }                                               397   }
799                                                   398 
800   else if (command == fpCommandCulling) {         399   else if (command == fpCommandCulling) {
801     G4String cullingOption, stringFlag, unit;     400     G4String cullingOption, stringFlag, unit;
802     G4double density;                             401     G4double density;
803     std::istringstream is (newValue);          << 402     G4bool boolFlag;
                                                   >> 403     G4std::istrstream is ((char*)newValue.data());
804     is >> cullingOption >> stringFlag >> densi    404     is >> cullingOption >> stringFlag >> density >> unit;
805     G4bool boolFlag = G4UIcommand::ConvertToBo << 405     boolFlag = GetNewBoolValue(stringFlag);
806     if (cullingOption == "global") {              406     if (cullingOption == "global") {
807       vp.SetCulling(boolFlag);                    407       vp.SetCulling(boolFlag);
808       if (verbosity >= G4VisManager::confirmat    408       if (verbosity >= G4VisManager::confirmations) {
809         G4cout <<                              << 409   G4cout <<
810         "G4VisCommandsViewerSet::SetNewValue:  << 410     "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
811         " set to " << G4UIcommand::ConvertToSt << 411     " set to " << ConvertToString(boolFlag) <<
812         ".\n  Does not change specific culling << 412     ".\n  Does not change specific culling flags."
813         << G4endl;                             << 413          << G4endl;
814       }                                           414       }
815     }                                             415     }
816     else if (cullingOption == "coveredDaughter    416     else if (cullingOption == "coveredDaughters") {
817       vp.SetCullingCovered(boolFlag);             417       vp.SetCullingCovered(boolFlag);
818       if (verbosity >= G4VisManager::confirmat    418       if (verbosity >= G4VisManager::confirmations) {
819         G4cout <<                              << 419   G4cout <<
820         "G4VisCommandsViewerSet::SetNewValue:  << 420     "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
821         "\n  daughters flag set to "           << 421     "\n  daughters flag set to "
822         << G4UIcommand::ConvertToString(boolFl << 422          << ConvertToString(boolFlag) <<
823         ".  Daughters covered by opaque mother << 423     ".  Daughters covered by opaque mothers"
824         "\n  will be culled, i.e., not drawn,  << 424     "\n  will be culled, i.e., not drawn, if this flag is true."
825         "\n  Note: this is only effective in s << 425     "\n  Note: this is only effective in surface drawing style,"
826         "\n  and then only if the volumes are  << 426     "\n  and then only if the volumes are visible and opaque, and then"
827         "\n  only if no sections or cutaways a << 427     "\n  only if no sections or cutways are in operation."
828         << G4endl;                             << 428          << G4endl;
829       }                                           429       }
830     }                                             430     }
831     else if (cullingOption == "invisible") {      431     else if (cullingOption == "invisible") {
832       vp.SetCullingInvisible(boolFlag);           432       vp.SetCullingInvisible(boolFlag);
833       if (verbosity >= G4VisManager::confirmat    433       if (verbosity >= G4VisManager::confirmations) {
834         G4cout <<                              << 434   G4cout <<
835         "G4VisCommandsViewerSet::SetNewValue:  << 435     "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
836         "\n  flag set to "                     << 436     "\n  flag set to "
837         << boolFlag << G4UIcommand::ConvertToS << 437          << boolFlag << ConvertToString(boolFlag) <<
838         ".  Volumes marked invisible will be c << 438     ".  Volumes marked invisible will be culled,"
839         "\n  i.e., not drawn, if this flag is  << 439     "\n  i.e., not drawn, if this flag is true."
840         << G4endl;                             << 440          << G4endl;
841       }                                           441       }
842     }                                             442     }
843     else if (cullingOption == "density") {        443     else if (cullingOption == "density") {
844       const G4String where =                   << 444       vp.SetDensityCulling(boolFlag);
845       "G4VisCommandsViewerSet::SetNewValue: cu << 
846       if (boolFlag) {                             445       if (boolFlag) {
847         G4double valueOfUnit;                  << 446   density *= G4UnitDefinition::GetValueOf(unit);
848         // "Volumic Mass" is Michel's phrase f << 447   vp.SetVisibleDensity(density);
849         if (ProvideValueOfUnit(where,unit,"Vol << 448       }
850           // Successful outcome of unit search << 449       else {
851           vp.SetDensityCulling(boolFlag);      << 450   density = vp.GetVisibleDensity();
852           density *= valueOfUnit;              << 
853           vp.SetVisibleDensity(density);       << 
854         } else {                               << 
855           // Unsuccessful outcome of unit sear << 
856           density = vp.GetVisibleDensity();    << 
857         }                                      << 
858       } else {  // Reset flag but density unch << 
859         vp.SetDensityCulling(boolFlag);        << 
860       }                                           451       }
861       if (verbosity >= G4VisManager::confirmat    452       if (verbosity >= G4VisManager::confirmations) {
862         G4cout                                 << 453   G4cout <<
863         << where                               << 454     "G4VisCommandsViewerSet::SetNewValue: culling: culling by density"
864         << "\n  flag set to "                  << 455     "\n  flag set to " << ConvertToString(boolFlag) <<
865         << std::boolalpha << vp.IsDensityCulli << 456     ".  Volumes with density less than " <<
866         << ".  Volumes with density less than  << 457     G4BestUnit(density,"Volumic Mass") <<
867         << G4BestUnit(density,"Volumic Mass")  << 458     "\n  will be culled, i.e., not drawn, if this flag is true."
868         << "\n  will be culled, i.e., not draw << 459          << G4endl;
869         << G4endl;                             << 
870       }                                           460       }
871     }                                             461     }
872     else {                                        462     else {
873       if (verbosity >= G4VisManager::errors) {    463       if (verbosity >= G4VisManager::errors) {
874         G4warn <<                              << 464   G4cout <<
875         "ERROR: G4VisCommandsViewerSet::SetNew << 465     "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
876         "\n  option not recognised."           << 466     "\n  option not recognised."
877         << G4endl;                             << 467          << G4endl;
878       }                                           468       }
879     }                                             469     }
880   }                                               470   }
881                                                   471 
882   else if (command == fpCommandCutawayMode) {  << 
883     if (newValue == "add" || newValue == "unio << 
884       vp.SetCutawayMode(G4ViewParameters::cuta << 
885     if (newValue == "multiply" || newValue ==  << 
886       vp.SetCutawayMode(G4ViewParameters::cuta << 
887                                                << 
888     if (verbosity >= G4VisManager::confirmatio << 
889       G4cout << "Cutaway mode set to ";        << 
890       if (vp.GetCutawayMode() == G4ViewParamet << 
891         G4cout << "cutawayUnion";              << 
892       if (vp.GetCutawayMode() == G4ViewParamet << 
893         G4cout << "cutawayIntersection";       << 
894       G4cout << G4endl;                        << 
895     }                                          << 
896   }                                            << 
897                                                << 
898   else if (command == fpCommandDefaultColour)  << 
899     G4String redOrString;                      << 
900     G4double green, blue, opacity;             << 
901     std::istringstream iss(newValue);          << 
902     iss >> redOrString >> green >> blue >> opa << 
903     G4Colour colour(1.,1.,1.);  // Default whi << 
904     ConvertToColour(colour, redOrString, green << 
905     G4VisAttributes va = vp.GetDefaultVisAttri << 
906     va.SetColour(colour);                      << 
907     vp.SetDefaultVisAttributes(va);            << 
908     if (verbosity >= G4VisManager::confirmatio << 
909       G4cout << "Default colour "              << 
910       << vp.GetDefaultVisAttributes()->GetColo << 
911       << " requested."                         << 
912       << G4endl;                               << 
913     }                                          << 
914   }                                            << 
915                                                << 
916   else if (command == fpCommandDefaultTextColo << 
917     G4String redOrString;                      << 
918     G4double green, blue, opacity;             << 
919     std::istringstream iss(newValue);          << 
920     iss >> redOrString >> green >> blue >> opa << 
921     G4Colour colour(1.,1.,1.);  // Default whi << 
922     ConvertToColour(colour, redOrString, green << 
923     G4VisAttributes va = vp.GetDefaultTextVisA << 
924     va.SetColour(colour);                      << 
925     vp.SetDefaultTextVisAttributes(va);        << 
926     if (verbosity >= G4VisManager::confirmatio << 
927       G4cout << "Default colour "              << 
928       << vp.GetDefaultTextVisAttributes()->Get << 
929       << " requested."                         << 
930       << G4endl;                               << 
931     }                                          << 
932   }                                            << 
933                                                << 
934   else if (command == fpCommandEdge) {            472   else if (command == fpCommandEdge) {
935     G4ViewParameters::DrawingStyle existingSty    473     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
936     if (G4UIcommand::ConvertToBool(newValue))  << 474     if (GetNewBoolValue(newValue)) {
937       switch (existingStyle) {                    475       switch (existingStyle) {
938         case G4ViewParameters::wireframe:      << 476       case G4ViewParameters::wireframe:
939           break;                               << 477   break;
940         case G4ViewParameters::hlr:            << 478       case G4ViewParameters::hlr:
941           break;                               << 479   break;
942         case G4ViewParameters::hsr:            << 480       case G4ViewParameters::hsr:
943           vp.SetDrawingStyle(G4ViewParameters: << 481   vp.SetDrawingStyle(G4ViewParameters::hlhsr);
944           break;                               << 482         break;
945         case G4ViewParameters::hlhsr:          << 483       case G4ViewParameters::hlhsr:
946           break;                               << 484         break;
947         case G4ViewParameters::cloud:          << 
948           break;                               << 
949       }                                           485       }
950     }                                             486     }
951     else {  // false                           << 487     else {
952       switch (existingStyle) {                    488       switch (existingStyle) {
953         case G4ViewParameters::wireframe:      << 489       case G4ViewParameters::wireframe:
954           break;                               << 490   break;
955         case G4ViewParameters::hlr:            << 491       case G4ViewParameters::hlr:
956           break;                               << 492   break;
957         case G4ViewParameters::hsr:            << 493       case G4ViewParameters::hsr:
958           break;                               << 494   break;
959         case G4ViewParameters::hlhsr:          << 495       case G4ViewParameters::hlhsr:
960           vp.SetDrawingStyle(G4ViewParameters: << 496   vp.SetDrawingStyle(G4ViewParameters::hsr);
961           break;                               << 497   break;
962         case G4ViewParameters::cloud:          << 
963           break;                               << 
964       }                                           498       }
965     }                                             499     }
966     if (verbosity >= G4VisManager::confirmatio    500     if (verbosity >= G4VisManager::confirmations) {
967       G4cout << "Drawing style of viewer \"" <    501       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
968       << "\" set to " << vp.GetDrawingStyle()  << 502        << "\" set to " << vp.GetDrawingStyle()
969       << G4endl;                               << 503        << G4endl;
970     }                                          << 
971   }                                            << 
972                                                << 
973   else if (command == fpCommandExplodeFactor)  << 
974     G4double explodeFactor, x, y, z;           << 
975     G4String unitString;                       << 
976     std::istringstream is (newValue);          << 
977     is >> explodeFactor >> x >> y >> z >> unit << 
978     G4double unit = G4UIcommand::ValueOf(unitS << 
979     vp.SetExplodeFactor(explodeFactor);        << 
980     vp.SetExplodeCentre(G4Point3D(x * unit, y  << 
981     if (verbosity >= G4VisManager::confirmatio << 
982       G4cout << "Explode factor changed to " < << 
983       << " from centre " << vp.GetExplodeCentr << 
984       << G4endl;                               << 
985     }                                          << 
986   }                                            << 
987                                                << 
988   else if (command == fpCommandGlobalLineWidth << 
989     G4double globalLineWidthScale              << 
990     = fpCommandGlobalLineWidthScale->GetNewDou << 
991     vp.SetGlobalLineWidthScale(globalLineWidth << 
992     if (verbosity >= G4VisManager::confirmatio << 
993       G4cout << "Global Line Width Scale chang << 
994       << vp.GetGlobalLineWidthScale() << G4end << 
995     }                                          << 
996   }                                            << 
997                                                << 
998   else if (command == fpCommandGlobalMarkerSca << 
999     G4double globalMarkerScale                 << 
1000     = fpCommandGlobalMarkerScale->GetNewDoubl << 
1001     vp.SetGlobalMarkerScale(globalMarkerScale << 
1002     if (verbosity >= G4VisManager::confirmati << 
1003       G4cout << "Global Marker Scale changed  << 
1004       << vp.GetGlobalMarkerScale() << G4endl; << 
1005     }                                            504     }
1006   }                                              505   }
1007                                                  506 
1008   else if (command == fpCommandHiddenEdge) {     507   else if (command == fpCommandHiddenEdge) {
1009     G4ViewParameters::DrawingStyle existingSt    508     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1010     if (G4UIcommand::ConvertToBool(newValue)) << 509     if (GetNewBoolValue(newValue)) {
1011       switch (existingStyle) {                   510       switch (existingStyle) {
1012         case G4ViewParameters::wireframe:     << 511       case G4ViewParameters::wireframe:
1013           vp.SetDrawingStyle(G4ViewParameters << 512   vp.SetDrawingStyle(G4ViewParameters::hlr);
1014           break;                              << 513   break;
1015         case G4ViewParameters::hlr:           << 514       case G4ViewParameters::hlr:
1016           break;                              << 515   break;
1017         case G4ViewParameters::hsr:           << 516       case G4ViewParameters::hsr:
1018           vp.SetDrawingStyle(G4ViewParameters << 517   vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1019           break;                              << 518         break;
1020         case G4ViewParameters::hlhsr:         << 519       case G4ViewParameters::hlhsr:
1021           break;                              << 520         break;
1022         case G4ViewParameters::cloud:         << 
1023           break;                              << 
1024       }                                          521       }
1025     }                                            522     }
1026     else {                                       523     else {
1027       switch (existingStyle) {                   524       switch (existingStyle) {
1028         case G4ViewParameters::wireframe:     << 525       case G4ViewParameters::wireframe:
1029           break;                              << 526   break;
1030         case G4ViewParameters::hlr:           << 527       case G4ViewParameters::hlr:
1031           vp.SetDrawingStyle(G4ViewParameters << 528   vp.SetDrawingStyle(G4ViewParameters::wireframe);
1032           break;                              << 529   break;
1033         case G4ViewParameters::hsr:           << 530       case G4ViewParameters::hsr:
1034           break;                              << 531   break;
1035         case G4ViewParameters::hlhsr:         << 532       case G4ViewParameters::hlhsr:
1036           vp.SetDrawingStyle(G4ViewParameters << 533   vp.SetDrawingStyle(G4ViewParameters::hsr);
1037           break;                              << 534   break;
1038         case G4ViewParameters::cloud:         << 
1039           break;                              << 
1040       }                                          535       }
1041     }                                            536     }
1042     if (verbosity >= G4VisManager::confirmati    537     if (verbosity >= G4VisManager::confirmations) {
1043       G4cout << "Drawing style of viewer \""     538       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1044       << "\" set to " << vp.GetDrawingStyle() << 539        << "\" set to " << vp.GetDrawingStyle()
1045       << G4endl;                              << 540        << G4endl;
1046     }                                            541     }
1047   }                                              542   }
1048                                                  543 
1049   else if (command == fpCommandHiddenMarker)     544   else if (command == fpCommandHiddenMarker) {
1050     G4bool hidden = G4UIcommand::ConvertToBoo << 545     G4bool hidden = GetNewBoolValue(newValue);
1051     if (hidden) vp.SetMarkerHidden();            546     if (hidden) vp.SetMarkerHidden();
1052     else vp.SetMarkerNotHidden();                547     else vp.SetMarkerNotHidden();
1053     if (verbosity >= G4VisManager::confirmati    548     if (verbosity >= G4VisManager::confirmations) {
1054       G4cout << "Markers will ";                 549       G4cout << "Markers will ";
1055       if (vp.IsMarkerNotHidden()) G4cout << "    550       if (vp.IsMarkerNotHidden()) G4cout << "not ";
1056       G4cout << "be hidden under solid object    551       G4cout << "be hidden under solid objects." << G4endl;
1057     }                                            552     }
1058   }                                              553   }
1059                                                  554 
1060   else if (command == fpCommandLightsMove) {     555   else if (command == fpCommandLightsMove) {
1061     if (newValue.find("cam") != G4String::npo << 556     G4String s (newValue);
1062       vp.SetLightsMoveWithCamera(true);       << 557     if (s.find("cam") != G4String::npos) vp.SetLightsMoveWithCamera(true);
1063     else if(newValue.find("obj") != G4String: << 558     else if(s.find("obj") != G4String::npos) vp.SetLightsMoveWithCamera(false);
1064       vp.SetLightsMoveWithCamera(false);      << 
1065     else {                                       559     else {
1066       if (verbosity >= G4VisManager::errors)     560       if (verbosity >= G4VisManager::errors) {
1067         G4warn << "ERROR: \"" << newValue <<  << 561   G4cout << "ERROR: \"" << newValue << "\" not recognised."
1068         "  Looking for \"cam\" or \"obj\" in  << 562   "  Looking for \"cam\" or \"obj\" in string." << G4endl;
1069       }                                          563       }
1070     }                                            564     }
1071     if (verbosity >= G4VisManager::confirmati    565     if (verbosity >= G4VisManager::confirmations) {
1072       G4cout << "Lights move with ";             566       G4cout << "Lights move with ";
1073       if (vp.GetLightsMoveWithCamera())          567       if (vp.GetLightsMoveWithCamera())
1074         G4cout << "camera (object appears to  << 568   G4cout << "camera (object appears to rotate).";
1075       else G4cout << "object (the viewer appe    569       else G4cout << "object (the viewer appears to be moving).";
1076       G4cout << G4endl;                          570       G4cout << G4endl;
1077     }                                            571     }
1078   }                                              572   }
1079                                                  573 
1080   else if (command == fpCommandLightsThetaPhi    574   else if (command == fpCommandLightsThetaPhi) {
1081     G4double theta, phi;                         575     G4double theta, phi;
1082     if (ConvertToDoublePair(newValue, theta,  << 576     GetNewDoublePairValue(newValue, theta, phi);
1083       G4double x = std::sin (theta) * std::co << 577     G4double x = sin (theta) * cos (phi);
1084       G4double y = std::sin (theta) * std::si << 578     G4double y = sin (theta) * sin (phi);
1085       G4double z = std::cos (theta);          << 579     G4double z = cos (theta);
1086       fLightsVector = G4ThreeVector (x, y, z) << 580     fLightsVector = G4ThreeVector (x, y, z);
1087       vp.SetLightpointDirection(fLightsVector << 581     vp.SetLightpointDirection(fLightsVector);
1088       if (verbosity >= G4VisManager::confirma << 582     if (verbosity >= G4VisManager::confirmations) {
1089         G4cout << "Lights direction set to "  << 583       G4cout << "Lights direction set to "
1090         << vp.GetLightpointDirection() << G4e << 584        << vp.GetLightpointDirection() << G4endl;
1091       }                                       << 
1092     }                                            585     }
1093   }                                              586   }
1094                                                  587 
1095   else if (command == fpCommandLightsVector)     588   else if (command == fpCommandLightsVector) {
1096     fLightsVector = G4UIcommand::ConvertTo3Ve << 589     fLightsVector = GetNew3VectorValue(newValue);
1097     vp.SetLightpointDirection(fLightsVector);    590     vp.SetLightpointDirection(fLightsVector);
1098     if (verbosity >= G4VisManager::confirmati    591     if (verbosity >= G4VisManager::confirmations) {
1099       G4cout << "Lights direction set to "       592       G4cout << "Lights direction set to "
1100       << vp.GetLightpointDirection() << G4end << 593        << vp.GetLightpointDirection() << G4endl;
1101     }                                         << 
1102   }                                           << 
1103                                               << 
1104   else if (command == fpCommandLineWidth) {   << 
1105     if (verbosity >= G4VisManager::errors) {  << 
1106       // A do-nothing command                 << 
1107       G4warn << command->GetGuidanceLine(0) < << 
1108     }                                            594     }
1109   }                                              595   }
1110                                                  596 
1111   else if (command == fpCommandLineSegments)     597   else if (command == fpCommandLineSegments) {
1112     G4int nSides = G4UIcommand::ConvertToInt( << 598     G4int nSides = GetNewIntValue(newValue);
1113     nSides = vp.SetNoOfSides(nSides);         << 599     vp.SetNoOfSides(nSides);
1114     if (verbosity >= G4VisManager::confirmati    600     if (verbosity >= G4VisManager::confirmations) {
1115       G4cout <<                                  601       G4cout <<
1116       "Number of line segments per circle in  << 602   "Number of line segements per circle in polygon approximation is "
1117       << nSides << G4endl;                    << 603        << nSides << G4endl;
1118     }                                         << 
1119   }                                           << 
1120                                               << 
1121   else if (command == fpCommandNumberOfCloudP << 
1122     G4int nPoints = G4UIcommand::ConvertToInt << 
1123     nPoints = vp.SetNumberOfCloudPoints(nPoin << 
1124     if (verbosity >= G4VisManager::confirmati << 
1125       G4cout <<                               << 
1126       "Number of points to be used in cloud r << 
1127       << nPoints << G4endl;                   << 
1128     }                                         << 
1129   }                                           << 
1130                                               << 
1131   else if (command == fpCommandPicking) {     << 
1132     vp.SetPicking(G4UIcommand::ConvertToBool( << 
1133     if (verbosity >= G4VisManager::confirmati << 
1134       G4cout << "Picking ";                   << 
1135       if (vp.IsPicking()) G4cout << "requeste << 
1136       else G4cout << "inhibited.";            << 
1137       G4cout << G4endl;                       << 
1138     }                                         << 
1139     if (verbosity >= G4VisManager::warnings)  << 
1140       G4warn << "You may need to issue \"/vis << 
1141       << G4endl;                              << 
1142     }                                            604     }
1143   }                                              605   }
1144                                                  606 
1145   else if (command == fpCommandProjection) {     607   else if (command == fpCommandProjection) {
1146     G4double fieldHalfAngle;                     608     G4double fieldHalfAngle;
1147     const size_t iPos0 = 0;                   << 609     size_t iPos = 0;
1148     if (newValue[iPos0] == 'o') {  // "orthog << 610     if (newValue[iPos] == 'o') {  // "orthogonal"
1149       fieldHalfAngle = 0.;                       611       fieldHalfAngle = 0.;
1150     }                                            612     }
1151     else if (newValue[iPos0] == 'p') {  // "p << 613     else if (newValue[iPos] == 'p') {  // "perspective"
1152       G4String dummy;                            614       G4String dummy;
1153       G4String unit;                             615       G4String unit;
1154       std::istringstream is (newValue);       << 616       G4std::istrstream is ((char*)newValue.data());
1155       is >> dummy >> fieldHalfAngle >> unit;     617       is >> dummy >> fieldHalfAngle >> unit;
1156       fieldHalfAngle *= G4UIcommand::ValueOf( << 618       fieldHalfAngle *= ValueOf(unit);
1157       if (fieldHalfAngle > 89.5 * deg || fiel    619       if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
1158         if (verbosity >= G4VisManager::errors << 620   if (verbosity >= G4VisManager::errors) {
1159           G4warn <<                           << 621     G4cout <<
1160           "ERROR: Field half angle should be  << 622       "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
1161           G4warn << G4endl;                   << 623     G4cout << G4endl;
1162         }                                     << 624   }
1163         return;                               << 625   return;
1164       }                                          626       }
1165     }                                            627     }
1166     else {                                       628     else {
1167       if (verbosity >= G4VisManager::errors)     629       if (verbosity >= G4VisManager::errors) {
1168         G4warn << "ERROR: \"" << newValue <<  << 630   G4cout << "ERROR: \"" << newValue << "\" not recognised."
1169         "  Looking for 'o' or 'p' first chara << 631     "  Looking for 'o' or 'p' first character." << G4endl;
1170       }                                          632       }
1171       return;                                    633       return;
1172     }                                            634     }
1173     vp.SetFieldHalfAngle(fieldHalfAngle);        635     vp.SetFieldHalfAngle(fieldHalfAngle);
1174     if (verbosity >= G4VisManager::confirmati    636     if (verbosity >= G4VisManager::confirmations) {
1175       G4cout << "Projection style of viewer \    637       G4cout << "Projection style of viewer \"" << currentViewer->GetName()
1176       << "\" set to ";                        << 638        << "\" set to ";
1177       if (fieldHalfAngle == 0.) {                639       if (fieldHalfAngle == 0.) {
1178         G4cout << "orthogonal.";              << 640   G4cout << "orthogonal.";
1179       }                                          641       }
1180       else {                                     642       else {
1181         G4cout << "perspective\n  with half a << 643   G4cout << "perspective\n  with half angle " << fieldHalfAngle / deg
1182         << " degrees.";                       << 644          << " degrees.";
1183       }                                          645       }
1184       G4cout << G4endl;                          646       G4cout << G4endl;
1185     }                                            647     }
1186   }                                              648   }
1187                                                  649 
1188   else if (command == fpCommandRotationStyle) << 
1189     G4ViewParameters::RotationStyle style;    << 
1190     if (newValue == "constrainUpDirection")   << 
1191       style = G4ViewParameters::constrainUpDi << 
1192     else if (newValue == "freeRotation")      << 
1193       style = G4ViewParameters::freeRotation; << 
1194     else {                                    << 
1195       if (verbosity >= G4VisManager::errors)  << 
1196   G4warn << "ERROR: \"" << newValue << "\" no << 
1197       }                                       << 
1198       return;                                 << 
1199     }                                         << 
1200     vp.SetRotationStyle(style);               << 
1201     if (verbosity >= G4VisManager::confirmati << 
1202       G4cout << "Rotation style of viewer \"" << 
1203       << "\" set to " << vp.GetRotationStyle( << 
1204       << G4endl;                              << 
1205     }                                         << 
1206   }                                           << 
1207                                               << 
1208   else if (command == fpCommandSectionPlane)     650   else if (command == fpCommandSectionPlane) {
1209     G4String choice, unit;                       651     G4String choice, unit;
1210     G4double x, y, z, nx, ny, nz, F = 1.;     << 652     G4double x, y, z, nx, ny, nz;
1211     std::istringstream is (newValue);         << 653     const char* t = newValue;
                                                   >> 654     G4std::istrstream is ((char*)t);
1212     is >> choice >> x >> y >> z >> unit >> nx    655     is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
                                                   >> 656 
1213     G4int iSelector = -1;                        657     G4int iSelector = -1;
1214     if (G4StrUtil::icompare(choice, "off") == << 658     if (choice.compareTo("off",G4String::ignoreCase) == 0) iSelector = 0;
1215         !G4UIcommand::ConvertToBool(choice))  << 659     if (choice.compareTo("on",G4String::ignoreCase) == 0) iSelector = 1;
1216     if (G4StrUtil::icompare(choice, "on") ==  << 
1217         G4UIcommand::ConvertToBool(choice)) i << 
1218     if (iSelector < 0) {                         660     if (iSelector < 0) {
1219       if (verbosity >= G4VisManager::errors)     661       if (verbosity >= G4VisManager::errors) {
1220         G4warn << "Choice not recognised (on/ << 662   G4cout << "Choice not recognised (on/off)." << G4endl;
                                                   >> 663   G4cout << "Section drawing is currently: ";
                                                   >> 664   if (vp.IsSection ()) G4cout << "on";
                                                   >> 665   else                    G4cout << "off";
                                                   >> 666   G4cout << ".\nSection plane is currently: "
                                                   >> 667          << vp.GetSectionPlane ();
                                                   >> 668   G4cout << G4endl;
1221       }                                          669       }
1222       goto write_result;                      << 670       return;
1223     }                                            671     }
1224     // iSelector can only be 0 or 1           << 672 
                                                   >> 673     G4double F;
1225     switch (iSelector) {                         674     switch (iSelector) {
1226       case 0:                                 << 675     case 0:
1227         vp.UnsetSectionPlane();               << 676       vp.UnsetSectionPlane();
1228         break;                                << 677       break;
1229       case 1:                                 << 678     case 1:
1230         F = G4UIcommand::ValueOf(unit);       << 679       F = ValueOf(unit);
1231         x *= F; y *= F; z *= F;               << 680       x *= F; y *= F; z *= F;
1232         if (nx == 0. && ny == 0. && nz == 0.) << 681       vp.SetSectionPlane(G4Plane3D(G4Normal3D(nx,ny,nz),
1233           if (verbosity >= G4VisManager::erro << 682            G4Point3D(x,y,z)));
1234             G4warn << "Null normal." << G4end << 683       vp.SetViewpointDirection(G4Normal3D(nx,ny,nz));
1235           }                                   << 684       break;
1236           break;;                             << 685     default:
1237         }                                     << 686       if (verbosity >= G4VisManager::errors) {
1238         // Make sure normal is normalised     << 687   G4cout << "ERROR: Choice not recognised (on/off)."
1239         const G4Normal3D& normal = G4Normal3D << 688          << G4endl;
1240         vp.SetSectionPlane(G4Plane3D(normal,  << 689       }
1241         vp.SetViewpointDirection(normal);     << 690       break;
1242         break;                                << 
1243     }                                            691     }
1244   write_result:                               << 692 
1245     if (verbosity >= G4VisManager::confirmati    693     if (verbosity >= G4VisManager::confirmations) {
1246       G4cout << "Section drawing is: ";       << 694       G4cout << "Section drawing is now: ";
1247       if (vp.IsSection ()) G4cout << "on";       695       if (vp.IsSection ()) G4cout << "on";
1248       else                 G4cout << "off";   << 696       else                    G4cout << "off";
1249       G4cout << ".\nSection plane is now: "      697       G4cout << ".\nSection plane is now: "
1250       << vp.GetSectionPlane ();               << 698        << vp.GetSectionPlane ();
1251       G4cout << G4endl;                       << 
1252     }                                         << 
1253   }                                           << 
1254                                               << 
1255   else if (command == fpCommandSpecialMeshRen << 
1256     vp.SetSpecialMeshRendering(G4UIcommand::C << 
1257     if (verbosity >= G4VisManager::confirmati << 
1258       G4cout << "Special mesh rendering";     << 
1259       if (vp.IsSpecialMeshRendering()) {      << 
1260         G4cout << " requested. Current option << 
1261         << vp.GetSpecialMeshRenderingOption() << 
1262         if (vp.GetSpecialMeshVolumes().empty( << 
1263           G4cout << "any mesh.";              << 
1264         } else{                               << 
1265           G4cout << "selected volumes:";      << 
1266           for (const auto& pvNameCopyNo: vp.G << 
1267             G4cout << "\n  " << pvNameCopyNo. << 
1268             if (pvNameCopyNo.GetCopyNo() >= 0 << 
1269           }                                   << 
1270         }                                     << 
1271       }                                       << 
1272       else G4cout << ": off.";                << 
1273       G4cout << G4endl;                          699       G4cout << G4endl;
1274     }                                            700     }
1275   }                                              701   }
1276                                                  702 
1277   else if (command == fpCommandSpecialMeshRen << 
1278     G4ViewParameters::SMROption option = G4Vi << 
1279     if (newValue == "dots") {                 << 
1280       option = G4ViewParameters::meshAsDots;  << 
1281     }                                         << 
1282     else if(newValue == "surfaces") {         << 
1283       option = G4ViewParameters::meshAsSurfac << 
1284     }                                         << 
1285     vp.SetSpecialMeshRenderingOption(option); << 
1286     if (verbosity >= G4VisManager::confirmati << 
1287       G4cout << "Special mesh rendering optio << 
1288       << vp.GetSpecialMeshRenderingOption() < << 
1289       << G4endl;                              << 
1290     }                                         << 
1291   }                                           << 
1292                                               << 
1293   else if (command == fpCommandSpecialMeshVol << 
1294     std::vector<G4ModelingParameters::PVNameC << 
1295     if (newValue.empty()) {                   << 
1296       vp.SetSpecialMeshVolumes(requestedMeshe << 
1297     } else {                                  << 
1298       // Algorithm from Josuttis p.476.       << 
1299       G4String::size_type iBegin, iEnd;       << 
1300       iBegin = newValue.find_first_not_of(' ' << 
1301       while (iBegin != G4String::npos) {      << 
1302   iEnd = newValue.find_first_of(' ',iBegin);  << 
1303   if (iEnd == G4String::npos) {               << 
1304     iEnd = newValue.length();                 << 
1305   }                                           << 
1306   const G4String& name(newValue.substr(iBegin << 
1307   iBegin = newValue.find_first_not_of(' ',iEn << 
1308   if (iBegin == G4String::npos) {             << 
1309     if (verbosity >= G4VisManager::warnings)  << 
1310       G4warn <<                               << 
1311       "WARNING: G4VisCommandsViewerSet::SetNe << 
1312       "\n  A pair not found.  (There should b << 
1313       "\n  Command ignored."                  << 
1314       << G4endl;                              << 
1315       return;                                 << 
1316     }                                         << 
1317   }                                           << 
1318   iEnd = newValue.find_first_of(' ',iBegin);  << 
1319   if (iEnd == G4String::npos) {               << 
1320     iEnd = newValue.length();                 << 
1321   }                                           << 
1322   G4int copyNo;                               << 
1323   std::istringstream iss(newValue.substr(iBeg << 
1324   if (!(iss >> copyNo)) {                     << 
1325     if (verbosity >= G4VisManager::warnings)  << 
1326       G4warn <<                               << 
1327       "WARNING: G4VisCommandsViewerSet::SetNe << 
1328       "\n  Error reading copy number - it was << 
1329       "\n  Command ignored."                  << 
1330       << G4endl;                              << 
1331       return;                                 << 
1332     }                                         << 
1333   }                                           << 
1334   requestedMeshes.push_back(G4ModelingParamet << 
1335   iBegin = newValue.find_first_not_of(' ',iEn << 
1336       }                                       << 
1337       vp.SetSpecialMeshVolumes(requestedMeshe << 
1338     }                                         << 
1339     if (verbosity >= G4VisManager::confirmati << 
1340       if (vp.GetSpecialMeshVolumes().empty()) << 
1341   G4cout <<                                   << 
1342   "Special mesh list empty, which means \"all << 
1343   << G4endl;                                  << 
1344       } else {                                << 
1345   G4cout << "Selected special mesh volumes ar << 
1346   for (const auto& pvNameCopyNo: vp.GetSpecia << 
1347     G4cout << "\n  " << pvNameCopyNo.GetName( << 
1348     if (pvNameCopyNo.GetCopyNo() >= 0) G4cout << 
1349   }                                           << 
1350   G4cout << G4endl;                           << 
1351       }                                       << 
1352     }                                         << 
1353   }                                           << 
1354                                               << 
1355   else if (command == fpCommandStyle) {          703   else if (command == fpCommandStyle) {
1356     G4ViewParameters::DrawingStyle existingSt    704     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1357     const size_t iPos0 = 0;                   << 705     size_t iPos = 0;
1358     if (newValue[iPos0] == 'w') {  // "wirefr << 706     if (newValue[iPos] == 'w') {  // "wireframe"
1359       switch (existingStyle) {                   707       switch (existingStyle) {
1360         case G4ViewParameters::wireframe:     << 708       case G4ViewParameters::wireframe:
1361           break;                              << 709   break;
1362         case G4ViewParameters::hlr:           << 710       case G4ViewParameters::hlr:
1363           break;                              << 711   break;
1364         case G4ViewParameters::hsr:           << 712       case G4ViewParameters::hsr:
1365           vp.SetDrawingStyle(G4ViewParameters << 713   vp.SetDrawingStyle(G4ViewParameters::wireframe);
1366           break;                              << 714         break;
1367         case G4ViewParameters::hlhsr:         << 715       case G4ViewParameters::hlhsr:
1368           vp.SetDrawingStyle(G4ViewParameters << 716   vp.SetDrawingStyle(G4ViewParameters::hlr);
1369           break;                              << 717         break;
1370         case G4ViewParameters::cloud:         << 
1371           vp.SetDrawingStyle(G4ViewParameters << 
1372           break;                              << 
1373       }                                          718       }
1374     }                                            719     }
1375     else if (newValue[iPos0] == 's') {  // "s << 720     else if (newValue[iPos] == 's') {  // "surface"
1376       switch (existingStyle) {                << 
1377         case G4ViewParameters::wireframe:     << 
1378           vp.SetDrawingStyle(G4ViewParameters << 
1379           break;                              << 
1380         case G4ViewParameters::hlr:           << 
1381           vp.SetDrawingStyle(G4ViewParameters << 
1382           break;                              << 
1383         case G4ViewParameters::hsr:           << 
1384           break;                              << 
1385         case G4ViewParameters::hlhsr:         << 
1386           break;                              << 
1387         case G4ViewParameters::cloud:         << 
1388           vp.SetDrawingStyle(G4ViewParameters << 
1389           break;                              << 
1390      }                                        << 
1391     }                                         << 
1392     else if (newValue[iPos0] == 'c') {  // "c << 
1393       switch (existingStyle) {                   721       switch (existingStyle) {
1394         case G4ViewParameters::wireframe:     << 722       case G4ViewParameters::wireframe:
1395           vp.SetDrawingStyle(G4ViewParameters << 723   vp.SetDrawingStyle(G4ViewParameters::hsr);
1396           break;                              << 724   break;
1397         case G4ViewParameters::hlr:           << 725       case G4ViewParameters::hlr:
1398           vp.SetDrawingStyle(G4ViewParameters << 726   vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1399           break;                              << 727   break;
1400         case G4ViewParameters::hsr:           << 728       case G4ViewParameters::hsr:
1401           vp.SetDrawingStyle(G4ViewParameters << 729   break;
1402           break;                              << 730       case G4ViewParameters::hlhsr:
1403         case G4ViewParameters::hlhsr:         << 731   break;
1404           vp.SetDrawingStyle(G4ViewParameters << 
1405           break;                              << 
1406         case G4ViewParameters::cloud:         << 
1407           break;                              << 
1408       }                                          732       }
1409     }                                            733     }
1410     else {                                       734     else {
1411       if (verbosity >= G4VisManager::errors)     735       if (verbosity >= G4VisManager::errors) {
1412         G4warn << "ERROR: \"" << newValue <<  << 736   G4cout << "ERROR: \"" << newValue << "\" not recognised."
1413         "  Looking for 'w' or 's' or 'c' firs << 737     "  Looking for 'w' or 's' first character." << G4endl;
1414       }                                          738       }
1415       return;                                    739       return;
1416     }                                            740     }
1417     if (verbosity >= G4VisManager::confirmati    741     if (verbosity >= G4VisManager::confirmations) {
1418       G4cout << "Drawing style of viewer \""     742       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1419       << "\" set to " << vp.GetDrawingStyle() << 743        << "\" set to " << vp.GetDrawingStyle()
1420       << G4endl;                              << 744        << G4endl;
1421     }                                         << 
1422   }                                           << 
1423                                               << 
1424   else if (command == fpCommandTargetPoint) { << 
1425     G4ThreeVector targetPoint =               << 
1426     fpCommandTargetPoint->GetNew3VectorValue( << 
1427     const G4Point3D& standardTargetPoint =    << 
1428     currentViewer->GetSceneHandler()->GetScen << 
1429     vp.SetCurrentTargetPoint(targetPoint - st << 
1430     if (verbosity >= G4VisManager::confirmati << 
1431       G4cout << "Target point set to "        << 
1432       << fpCommandTargetPoint->ConvertToStrin << 
1433       (targetPoint)                           << 
1434       << "\n\"Current Target Point\" set to   << 
1435       << fpCommandTargetPoint->ConvertToStrin << 
1436       (vp.GetCurrentTargetPoint())            << 
1437       << "\n\"Standard Target Point\" is "    << 
1438       << fpCommandTargetPoint->ConvertToStrin << 
1439       (standardTargetPoint)                   << 
1440       << G4endl;                              << 
1441     }                                            745     }
1442   }                                              746   }
1443                                                  747 
1444   else if (command == fpCommandUpThetaPhi) {     748   else if (command == fpCommandUpThetaPhi) {
1445     G4double theta, phi;                         749     G4double theta, phi;
1446     if (ConvertToDoublePair(newValue, theta,  << 750     GetNewDoublePairValue(newValue, theta, phi);
1447       G4double x = std::sin (theta) * std::co << 751     G4double x = sin (theta) * cos (phi);
1448       G4double y = std::sin (theta) * std::si << 752     G4double y = sin (theta) * sin (phi);
1449       G4double z = std::cos (theta);          << 753     G4double z = cos (theta);
1450       fUpVector = G4ThreeVector (x, y, z);    << 754     fUpVector = G4ThreeVector (x, y, z);
1451       vp.SetUpVector(fUpVector);              << 755     vp.SetUpVector(fUpVector);
1452       if (verbosity >= G4VisManager::confirma << 756     if (verbosity >= G4VisManager::confirmations) {
1453         G4cout << "Up direction set to " << v << 757       G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1454       }                                       << 
1455     }                                            758     }
1456   }                                              759   }
1457                                                  760 
1458   else if (command == fpCommandUpVector) {       761   else if (command == fpCommandUpVector) {
1459     fUpVector = G4UIcommand::ConvertTo3Vector << 762     fUpVector = GetNew3VectorValue(newValue);
1460     vp.SetUpVector(fUpVector);                   763     vp.SetUpVector(fUpVector);
1461     if (verbosity >= G4VisManager::confirmati    764     if (verbosity >= G4VisManager::confirmations) {
1462       G4cout << "Up direction set to " << vp.    765       G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1463     }                                            766     }
1464   }                                              767   }
1465                                                  768 
1466   else if (command == fpCommandViewpointTheta    769   else if (command == fpCommandViewpointThetaPhi) {
1467     G4double theta, phi;                         770     G4double theta, phi;
1468     if (ConvertToDoublePair(newValue, theta,  << 771     GetNewDoublePairValue(newValue, theta, phi);
1469       G4double x = std::sin (theta) * std::co << 772     G4double x = sin (theta) * cos (phi);
1470       G4double y = std::sin (theta) * std::si << 773     G4double y = sin (theta) * sin (phi);
1471       G4double z = std::cos (theta);          << 774     G4double z = cos (theta);
1472       fViewpointVector = G4ThreeVector (x, y, << 775     fViewpointVector = G4ThreeVector (x, y, z);
1473       vp.SetViewAndLights(fViewpointVector);  << 776     vp.SetViewAndLights(fViewpointVector);
1474       if (verbosity >= G4VisManager::confirma << 777     if (verbosity >= G4VisManager::confirmations) {
1475         G4cout << "Viewpoint direction set to << 778       G4cout << "Viewpoint direction set to "
1476         << vp.GetViewpointDirection() << G4en << 779        << vp.GetViewpointDirection() << G4endl;
1477         if (vp.GetLightsMoveWithCamera ()) {  << 780       if (vp.GetLightsMoveWithCamera ()) {
1478           G4cout << "Lightpoint direction set << 781   G4cout << "Lightpoint direction set to "
1479           << vp.GetActualLightpointDirection  << 782          << vp.GetActualLightpointDirection () << G4endl;
1480         }                                     << 
1481       }                                          783       }
1482     }                                            784     }
1483   }                                              785   }
1484                                                  786 
1485   else if (command == fpCommandViewpointVecto    787   else if (command == fpCommandViewpointVector) {
1486     G4ThreeVector viewpointVector = G4UIcomma << 788     fViewpointVector = GetNew3VectorValue(newValue);
1487     if (viewpointVector.mag2() <= 0.) {       << 789     vp.SetViewAndLights(fViewpointVector);
1488       if (verbosity >= G4VisManager::errors)  << 
1489         G4warn << "ERROR: Null viewpoint vect << 
1490       }                                       << 
1491     } else {                                  << 
1492       fViewpointVector = viewpointVector.unit << 
1493       vp.SetViewAndLights(fViewpointVector);  << 
1494       if (verbosity >= G4VisManager::confirma << 
1495         G4cout << "Viewpoint direction set to << 
1496         << vp.GetViewpointDirection() << G4en << 
1497         if (vp.GetLightsMoveWithCamera ()) {  << 
1498           G4cout << "Lightpoint direction set << 
1499           << vp.GetActualLightpointDirection  << 
1500         }                                     << 
1501       }                                       << 
1502     }                                         << 
1503   }                                           << 
1504                                               << 
1505   else if (command == fpCommandTimeWindowDisp << 
1506   {                                           << 
1507     G4String display;                         << 
1508     G4double screenX, screenY, screenSize, re << 
1509     std::istringstream iss(newValue);         << 
1510     iss >> display >> screenX >> screenY      << 
1511     >> screenSize >> red >> green >> blue;    << 
1512     vp.SetDisplayHeadTime(command->ConvertToB << 
1513     vp.SetDisplayHeadTimeX(screenX);          << 
1514     vp.SetDisplayHeadTimeY(screenY);          << 
1515     vp.SetDisplayHeadTimeSize(screenSize);    << 
1516     vp.SetDisplayHeadTimeRed(red);            << 
1517     vp.SetDisplayHeadTimeGreen(green);        << 
1518     vp.SetDisplayHeadTimeBlue(blue);          << 
1519     if (verbosity >= G4VisManager::confirmati << 
1520       G4cout << "Display head time flag set:  << 
1521       << vp                                   << 
1522       << G4endl;                              << 
1523     }                                         << 
1524   }                                           << 
1525                                               << 
1526   else if (command == fpCommandTimeWindowDisp << 
1527   {                                           << 
1528     G4String display, originX, originY, origi << 
1529     G4double red, green, blue;                << 
1530     std::istringstream iss(newValue);         << 
1531     iss >> display                            << 
1532     >> originX >> originY >> originZ >> unitS << 
1533     >> originT >> unitT                       << 
1534     >> red >> green >> blue;                  << 
1535     vp.SetDisplayLightFront(command->ConvertT << 
1536     vp.SetDisplayLightFrontX                  << 
1537     (command->ConvertToDimensionedDouble(G4St << 
1538     vp.SetDisplayLightFrontY                  << 
1539     (command->ConvertToDimensionedDouble(G4St << 
1540     vp.SetDisplayLightFrontZ                  << 
1541     (command->ConvertToDimensionedDouble(G4St << 
1542     vp.SetDisplayLightFrontT                  << 
1543     (command->ConvertToDimensionedDouble(G4St << 
1544     vp.SetDisplayLightFrontRed(red);          << 
1545     vp.SetDisplayLightFrontGreen(green);      << 
1546     vp.SetDisplayLightFrontBlue(blue);        << 
1547     if (verbosity >= G4VisManager::confirmati << 
1548       G4cout << "Display light front flag set << 
1549       << vp                                   << 
1550       << G4endl;                              << 
1551     }                                         << 
1552   }                                           << 
1553                                               << 
1554   else if (command == fpCommandTimeWindowEndT << 
1555   {                                           << 
1556     G4String end_time_string, end_time_unit,  << 
1557     time_range_string, time_range_unit;       << 
1558     std::istringstream iss(newValue);         << 
1559     iss >> end_time_string >> end_time_unit   << 
1560     >> time_range_string >> time_range_unit;  << 
1561     vp.SetEndTime                             << 
1562     (command->ConvertToDimensionedDouble      << 
1563      (G4String(end_time_string + ' ' + end_ti << 
1564     G4double timeRange = command->ConvertToDi << 
1565     (G4String(time_range_string + ' ' + time_ << 
1566     if (timeRange > 0.) {                     << 
1567       vp.SetStartTime                         << 
1568       (vp.GetEndTime() - timeRange);          << 
1569     }                                         << 
1570     if (verbosity >= G4VisManager::confirmati << 
1571       G4cout                                  << 
1572       << "Time window start time: " << vp.Get << 
1573       << ", time window end time: " << vp.Get << 
1574       if (timeRange > 0.) {                   << 
1575         G4cout << "\n  (time range: " << time << 
1576       }                                       << 
1577       G4cout << G4endl;                       << 
1578     }                                         << 
1579   }                                           << 
1580                                               << 
1581   else if (command == fpCommandTimeWindowFade << 
1582     vp.SetFadeFactor(command->ConvertToDouble << 
1583     if (verbosity >= G4VisManager::confirmati    790     if (verbosity >= G4VisManager::confirmations) {
1584       G4cout << "Time window fade factor chan << 791       G4cout << "Viewpoint direction set to "
1585       << G4endl;                              << 792        << vp.GetViewpointDirection() << G4endl;
1586     }                                         << 793       if (vp.GetLightsMoveWithCamera ()) {
1587   }                                           << 794   G4cout << "Lightpoint direction set to "
1588                                               << 795          << vp.GetActualLightpointDirection () << G4endl;
1589   else if (command == fpCommandTimeWindowStar << 
1590   {                                           << 
1591     G4String start_time_string, start_time_un << 
1592     time_range_string, time_range_unit;       << 
1593     std::istringstream iss(newValue);         << 
1594     iss >> start_time_string >> start_time_un << 
1595     >> time_range_string >> time_range_unit;  << 
1596     vp.SetStartTime                           << 
1597     (command->ConvertToDimensionedDouble      << 
1598      (G4String(start_time_string + ' ' + star << 
1599     G4double timeRange = command->ConvertToDi << 
1600     (G4String(time_range_string + ' ' + time_ << 
1601     if (timeRange > 0.) {                     << 
1602       vp.SetEndTime                           << 
1603       (vp.GetStartTime() + timeRange);        << 
1604     }                                         << 
1605     if (verbosity >= G4VisManager::confirmati << 
1606       G4cout                                  << 
1607       << "Time window start time: " << vp.Get << 
1608       << ", time window end time: " << vp.Get << 
1609       if (timeRange > 0.) {                   << 
1610         G4cout << "\n  (time range: " << time << 
1611       }                                          796       }
1612       G4cout << G4endl;                       << 
1613     }                                            797     }
1614   }                                              798   }
1615                                                  799 
1616   else {                                         800   else {
1617     if (verbosity >= G4VisManager::errors) {     801     if (verbosity >= G4VisManager::errors) {
1618       G4warn <<                               << 802       G4cout <<
1619       "ERROR: G4VisCommandsViewerSet::SetNewV << 803   "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1620       << G4endl;                              << 804        << G4endl;
1621     }                                            805     }
1622     return;                                      806     return;
1623   }                                              807   }
1624                                                  808 
1625   SetViewParameters(currentViewer,vp);           809   SetViewParameters(currentViewer,vp);
1626 }                                                810 }
1627                                                  811