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


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
                                                   >>  27 // $Id: G4VisCommandsViewerSet.cc,v 1.50 2009/05/13 18:17:25 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-03 $
 27                                                    29 
 28 // /vis/viewer/set commands - John Allison  16     30 // /vis/viewer/set commands - John Allison  16th May 2000
 29                                                    31 
 30 #include "G4VisCommandsViewerSet.hh"               32 #include "G4VisCommandsViewerSet.hh"
 31                                                    33 
 32 #include "G4UIcommand.hh"                          34 #include "G4UIcommand.hh"
 33 #include "G4UIcmdWithoutParameter.hh"          << 
 34 #include "G4UIcmdWithAString.hh"                   35 #include "G4UIcmdWithAString.hh"
 35 #include "G4UIcmdWithABool.hh"                     36 #include "G4UIcmdWithABool.hh"
 36 #include "G4UIcmdWithAnInteger.hh"                 37 #include "G4UIcmdWithAnInteger.hh"
 37 #include "G4UIcmdWithADouble.hh"                   38 #include "G4UIcmdWithADouble.hh"
 38 #include "G4UIcmdWith3VectorAndUnit.hh"            39 #include "G4UIcmdWith3VectorAndUnit.hh"
 39 #include "G4UnitsTable.hh"                         40 #include "G4UnitsTable.hh"
 40 #include "G4VisManager.hh"                         41 #include "G4VisManager.hh"
 41 #include "G4Polyhedron.hh"                         42 #include "G4Polyhedron.hh"
 42 #include "G4SystemOfUnits.hh"                  << 
 43                                                    43 
 44 #include <sstream>                                 44 #include <sstream>
 45 #include <iomanip>                             <<  45 #include <cctype>
 46 #include <utility>                             << 
 47                                                << 
 48 #define G4warn G4cout                          << 
 49                                                    46 
 50 G4VisCommandsViewerSet::G4VisCommandsViewerSet     47 G4VisCommandsViewerSet::G4VisCommandsViewerSet ():
 51 fLightsVector    (G4ThreeVector(1.,1.,1.)),    <<  48   fLightsVector    (G4ThreeVector(1.,1.,1.)),
 52 fUpVector        (G4ThreeVector(0.,1.,0.)),    <<  49   fUpVector        (G4ThreeVector(0.,1.,0.)),
 53 fViewpointVector (G4ThreeVector(0.,0.,1.))     <<  50   fViewpointVector (G4ThreeVector(0.,0.,1.))
 54 {                                                  51 {
 55   G4bool omitable;                                 52   G4bool omitable;
 56   G4UIparameter* parameter;                        53   G4UIparameter* parameter;
 57                                                    54 
 58   fpCommandAll = new G4UIcmdWithAString ("/vis     55   fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
 59   fpCommandAll->SetGuidance                        56   fpCommandAll->SetGuidance
 60   ("Copies view parameters.");                 <<  57     ("Copies view parameters.");
 61   fpCommandAll->SetGuidance                    << 
 62   ("Copies ALL view parameters (except the aut << 
 63    "\nfrom-viewer to current viewer. You may n << 
 64   fpCommandAll->SetGuidance                        58   fpCommandAll->SetGuidance
 65   ("Note: to copy only the camera-specific par <<  59     ("Copies view parameters (except the autoRefresh status) from"
 66    "\n\"/vis/viewer/copyfrom\".");             <<  60      "\nfrom-viewer to current viewer.");
 67   fpCommandAll->SetParameterName ("from-viewer     61   fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
 68                                                    62 
 69   fpCommandAutoRefresh = new G4UIcmdWithABool      63   fpCommandAutoRefresh = new G4UIcmdWithABool
 70   ("/vis/viewer/set/autoRefresh",this);        <<  64     ("/vis/viewer/set/autoRefresh",this);
 71   fpCommandAutoRefresh->SetGuidance("Sets auto     65   fpCommandAutoRefresh->SetGuidance("Sets auto-refresh.");
 72   fpCommandAutoRefresh->SetGuidance                66   fpCommandAutoRefresh->SetGuidance
 73   ("If true, view is automatically refreshed a <<  67     ("If true, view is automatically refreshed after a change of"
 74    "\nview parameters.");                      <<  68      "\nview parameters.");
 75   fpCommandAutoRefresh->SetParameterName("auto     69   fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true);
 76   fpCommandAutoRefresh->SetDefaultValue(true);     70   fpCommandAutoRefresh->SetDefaultValue(true);
 77                                                    71 
 78   fpCommandAuxEdge = new G4UIcmdWithABool          72   fpCommandAuxEdge = new G4UIcmdWithABool
 79   ("/vis/viewer/set/auxiliaryEdge",this);      <<  73     ("/vis/viewer/set/auxiliaryEdge",this);
 80   fpCommandAuxEdge->SetGuidance("Sets visibili     74   fpCommandAuxEdge->SetGuidance("Sets visibility of auxiliary edges");
 81   fpCommandAuxEdge->SetGuidance                    75   fpCommandAuxEdge->SetGuidance
 82   ("Auxiliary edges, i.e., those that are part <<  76     ("Auxiliary edges, i.e., those that are part of a curved surface,"
 83    "\nsometimes called soft edges, become visi <<  77      "\nsometimes called soft edges, become visible/invisible.");
 84   fpCommandAuxEdge->SetParameterName("edge",om     78   fpCommandAuxEdge->SetParameterName("edge",omitable = true);
 85   fpCommandAuxEdge->SetDefaultValue(true);         79   fpCommandAuxEdge->SetDefaultValue(true);
 86                                                    80 
 87   fpCommandBackground = new G4UIcommand            81   fpCommandBackground = new G4UIcommand
 88   ("/vis/viewer/set/background",this);         <<  82     ("/vis/viewer/set/background",this);
 89   fpCommandBackground->SetGuidance                 83   fpCommandBackground->SetGuidance
 90   ("Set background colour and transparency (de <<  84     ("Set background colour and transparency (default black and opaque).");
 91   fpCommandBackground->SetGuidance(ConvertToCo <<  85   fpCommandBackground->SetGuidance
                                                   >>  86     ("Accepts (a) RGB triplet. e.g., \".3 .4 .5\", or"
                                                   >>  87      "\n(b) string such as \"white\", \"black\", \"grey\", \"red\"..."
                                                   >>  88      "\n(c) an additional number for opacity, e.g., \".3 .4 .5 .6\""
                                                   >>  89      "\n    or \"grey ! ! .6\" (note \"!\"'s for unused green and blue parameters),"
                                                   >>  90      "\n    e.g. \"! ! ! 0.\" for a transparent background.");
 92   parameter = new G4UIparameter("red_or_string     91   parameter = new G4UIparameter("red_or_string", 's', omitable = true);
 93   parameter -> SetDefaultValue ("0.");             92   parameter -> SetDefaultValue ("0.");
 94   fpCommandBackground -> SetParameter (paramet     93   fpCommandBackground -> SetParameter (parameter);
 95   parameter = new G4UIparameter("green", 'd',      94   parameter = new G4UIparameter("green", 'd', omitable = true);
 96   parameter -> SetDefaultValue (0.);               95   parameter -> SetDefaultValue (0.);
 97   fpCommandBackground -> SetParameter (paramet     96   fpCommandBackground -> SetParameter (parameter);
 98   parameter = new G4UIparameter ("blue", 'd',      97   parameter = new G4UIparameter ("blue", 'd', omitable = true);
 99   parameter -> SetDefaultValue (0.);               98   parameter -> SetDefaultValue (0.);
100   fpCommandBackground -> SetParameter (paramet     99   fpCommandBackground -> SetParameter (parameter);
101   parameter = new G4UIparameter ("opacity", 'd    100   parameter = new G4UIparameter ("opacity", 'd', omitable = true);
102   parameter -> SetDefaultValue (1.);              101   parameter -> SetDefaultValue (1.);
103   fpCommandBackground -> SetParameter (paramet    102   fpCommandBackground -> SetParameter (parameter);
104                                                   103 
105   fpCommandCulling = new G4UIcommand("/vis/vie    104   fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
106   fpCommandCulling->SetGuidance ("Set culling     105   fpCommandCulling->SetGuidance ("Set culling options.");
107   fpCommandCulling->SetGuidance                   106   fpCommandCulling->SetGuidance
108   ("\"global\": enables/disables all other cul << 107     ("\"global\": enables/disables all other culling options.");
109   fpCommandCulling->SetGuidance                   108   fpCommandCulling->SetGuidance
110   ("\"coveredDaughters\": culls, i.e., elimina << 109     ("\"coveredDaughters\": culls, i.e., eliminates, volumes that would not"
111    "\nbe seen because covered by ancestor volu << 110      "\nbe seen because covered by ancester volumes in surface drawing mode,"
112    "\nand then only if the ancestors are visib << 111      "\nand then only if the ancesters are visible and opaque, and then only"
113    "\nif no sections or cutaways are in operat << 112      "\nif no sections or cutaways are in operation.  Intended solely to"
114    "\nimprove the speed of rendering visible v << 113      "\nimprove the speed of rendering visible volumes.");
115   fpCommandCulling->SetGuidance                   114   fpCommandCulling->SetGuidance
116   ("\"invisible\": culls objects with the invi << 115     ("\"invisible\": culls objects with the invisible attribute set.");
117   fpCommandCulling->SetGuidance                   116   fpCommandCulling->SetGuidance
118   ("\"density\": culls volumes with density lo << 117     ("\"density\": culls volumes with density lower than threshold.  Useful"
119    "\nfor eliminating \"container volumes\" wi << 118      "\nfor eliminating \"container volumes\" with no physical correspondence,"
120    "\nwhose material is usually air.  If this  << 119      "\nwhose material is usually air.  If this is selected, provide threshold"
121    "\ndensity and unit (e.g., g/cm3, mg/cm3 or << 120      "\ndensity and unit (g/cm3 mg/cm3 or kg/m3)."
122    );                                          << 121      );
123   parameter = new G4UIparameter("culling-optio    122   parameter = new G4UIparameter("culling-option",'s',omitable = false);
124   parameter->SetParameterCandidates               123   parameter->SetParameterCandidates
125   ("global coveredDaughters invisible density" << 124     ("global coveredDaughters invisible density");
126   fpCommandCulling->SetParameter(parameter);      125   fpCommandCulling->SetParameter(parameter);
127   parameter = new G4UIparameter("action",'b',o    126   parameter = new G4UIparameter("action",'b',omitable = true);
128   parameter->SetDefaultValue(1);                  127   parameter->SetDefaultValue(1);
129   fpCommandCulling->SetParameter(parameter);      128   fpCommandCulling->SetParameter(parameter);
130   parameter = new G4UIparameter("density-thres    129   parameter = new G4UIparameter("density-threshold",'d',omitable = true);
131   parameter->SetDefaultValue("0.01");             130   parameter->SetDefaultValue("0.01");
132   fpCommandCulling->SetParameter(parameter);      131   fpCommandCulling->SetParameter(parameter);
133   parameter = new G4UIparameter("unit",'s',omi    132   parameter = new G4UIparameter("unit",'s',omitable = true);
134   // parameter->SetParameterCandidates ("g/cm3 << 133   parameter->SetParameterCandidates ("g/cm3, mg/cm3 kg/m3");
135   // Instead of the above, SetNewValue accepts << 
136   parameter->SetDefaultValue("g/cm3");            134   parameter->SetDefaultValue("g/cm3");
137   fpCommandCulling->SetParameter(parameter);      135   fpCommandCulling->SetParameter(parameter);
138                                                   136 
139   fpCommandCutawayMode =                          137   fpCommandCutawayMode =
140   new G4UIcmdWithAString ("/vis/viewer/set/cut << 138     new G4UIcmdWithAString ("/vis/viewer/set/cutawayMode", this);
141   fpCommandCutawayMode->SetGuidance               139   fpCommandCutawayMode->SetGuidance
142   ("Sets cutaway mode - add (union) or multipl << 140     ("Sets cutaway mode - add (union) or multiply (intersection).");
143   fpCommandCutawayMode->SetParameterName ("cut    141   fpCommandCutawayMode->SetParameterName ("cutaway-mode",omitable = false);
144   fpCommandCutawayMode->SetCandidates ("add un    142   fpCommandCutawayMode->SetCandidates ("add union multiply intersection");
145   fpCommandCutawayMode->SetDefaultValue("union    143   fpCommandCutawayMode->SetDefaultValue("union");
146                                                   144 
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    145   fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
184   fpCommandEdge->SetGuidance                      146   fpCommandEdge->SetGuidance
185   ("Edges become visible/invisible in surface  << 147     ("Edges become visible/invisible in surface mode.");
186   fpCommandEdge->SetParameterName("edge",omita    148   fpCommandEdge->SetParameterName("edge",omitable = true);
187   fpCommandEdge->SetDefaultValue(true);           149   fpCommandEdge->SetDefaultValue(true);
188                                                   150 
189   fpCommandExplodeFactor = new G4UIcommand        151   fpCommandExplodeFactor = new G4UIcommand
190   ("/vis/viewer/set/explodeFactor", this);     << 152     ("/vis/viewer/set/explodeFactor", this);
191   fpCommandExplodeFactor->SetGuidance             153   fpCommandExplodeFactor->SetGuidance
192   ("Moves top-level drawn volumes by this fact << 154     ("Moves top-level drawn volumes by this factor from this centre.");
193   parameter = new G4UIparameter("explodeFactor    155   parameter = new G4UIparameter("explodeFactor", 'd', omitable=true);
194   parameter->SetParameterRange("explodeFactor>    156   parameter->SetParameterRange("explodeFactor>=1.");
195   parameter->SetDefaultValue(1.);                 157   parameter->SetDefaultValue(1.);
196   fpCommandExplodeFactor->SetParameter(paramet    158   fpCommandExplodeFactor->SetParameter(parameter);
197   parameter = new G4UIparameter("x",'d',omitab    159   parameter = new G4UIparameter("x",'d',omitable = true);
198   parameter->SetDefaultValue  (0);                160   parameter->SetDefaultValue  (0);
199   parameter->SetGuidance      ("Coordinate of     161   parameter->SetGuidance      ("Coordinate of explode centre.");
200   fpCommandExplodeFactor->SetParameter(paramet    162   fpCommandExplodeFactor->SetParameter(parameter);
201   parameter = new G4UIparameter("y",'d',omitab    163   parameter = new G4UIparameter("y",'d',omitable = true);
202   parameter->SetDefaultValue  (0);                164   parameter->SetDefaultValue  (0);
203   parameter->SetGuidance      ("Coordinate of     165   parameter->SetGuidance      ("Coordinate of explode centre.");
204   fpCommandExplodeFactor->SetParameter(paramet    166   fpCommandExplodeFactor->SetParameter(parameter);
205   parameter = new G4UIparameter("z",'d',omitab    167   parameter = new G4UIparameter("z",'d',omitable = true);
206   parameter->SetDefaultValue  (0);                168   parameter->SetDefaultValue  (0);
207   parameter->SetGuidance      ("Coordinate of     169   parameter->SetGuidance      ("Coordinate of explode centre.");
208   fpCommandExplodeFactor->SetParameter(paramet    170   fpCommandExplodeFactor->SetParameter(parameter);
209   parameter = new G4UIparameter("unit",'s',omi    171   parameter = new G4UIparameter("unit",'s',omitable = true);
210   parameter->SetDefaultValue  ("m");              172   parameter->SetDefaultValue  ("m");
211   parameter->SetGuidance      ("Unit of explod    173   parameter->SetGuidance      ("Unit of explode centre.");
212   fpCommandExplodeFactor->SetParameter(paramet    174   fpCommandExplodeFactor->SetParameter(parameter);
213                                                   175 
214   fpCommandGlobalLineWidthScale = new G4UIcmdW    176   fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble
215   ("/vis/viewer/set/globalLineWidthScale", thi << 177     ("/vis/viewer/set/globalLineWidthScale", this);
216   fpCommandGlobalLineWidthScale->SetGuidance      178   fpCommandGlobalLineWidthScale->SetGuidance
217   ("Multiplies line widths by this factor.");  << 179     ("Multiplies line widths by this factor.");
218   fpCommandGlobalLineWidthScale->                 180   fpCommandGlobalLineWidthScale->
219   SetParameterName("scale-factor", omitable=tr << 181     SetParameterName("scale-factor", omitable=true);
220   fpCommandGlobalLineWidthScale->SetDefaultVal    182   fpCommandGlobalLineWidthScale->SetDefaultValue(1.);
221                                                   183 
222   fpCommandGlobalMarkerScale = new G4UIcmdWith    184   fpCommandGlobalMarkerScale = new G4UIcmdWithADouble
223   ("/vis/viewer/set/globalMarkerScale", this); << 185     ("/vis/viewer/set/globalMarkerScale", this);
224   fpCommandGlobalMarkerScale->SetGuidance         186   fpCommandGlobalMarkerScale->SetGuidance
225   ("Multiplies marker sizes by this factor."); << 187     ("Multiplies marker sizes by this factor.");
226   fpCommandGlobalMarkerScale->                    188   fpCommandGlobalMarkerScale->
227   SetParameterName("scale-factor", omitable=tr << 189     SetParameterName("scale-factor", omitable=true);
228   fpCommandGlobalMarkerScale->SetDefaultValue(    190   fpCommandGlobalMarkerScale->SetDefaultValue(1.);
229                                                   191 
230   fpCommandHiddenEdge =                           192   fpCommandHiddenEdge =
231   new G4UIcmdWithABool("/vis/viewer/set/hidden << 193     new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
232   fpCommandHiddenEdge->SetGuidance                194   fpCommandHiddenEdge->SetGuidance
233   ("Edges become hidden/seen in wireframe or s << 195     ("Edges become hidden/seen in wireframe or surface mode.");
234   fpCommandHiddenEdge->SetParameterName("hidde    196   fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
235   fpCommandHiddenEdge->SetDefaultValue(true);     197   fpCommandHiddenEdge->SetDefaultValue(true);
236                                                   198 
237   fpCommandHiddenMarker =                         199   fpCommandHiddenMarker =
238   new G4UIcmdWithABool("/vis/viewer/set/hidden << 200     new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
239   fpCommandHiddenMarker->SetGuidance              201   fpCommandHiddenMarker->SetGuidance
240   ("If true, closer objects hide markers. Othe << 202     ("If true, closer objects hide markers. Otherwise, markers always show.");
241   fpCommandHiddenMarker->SetParameterName("hid    203   fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
242   fpCommandHiddenMarker->SetDefaultValue(true)    204   fpCommandHiddenMarker->SetDefaultValue(true);
243                                                   205 
244   fpCommandLightsMove = new G4UIcmdWithAString    206   fpCommandLightsMove = new G4UIcmdWithAString
245   ("/vis/viewer/set/lightsMove",this);         << 207     ("/vis/viewer/set/lightsMove",this);
246   fpCommandLightsMove->SetGuidance                208   fpCommandLightsMove->SetGuidance
247   ("Lights move with camera or with object");  << 209     ("Lights move with camera or with object");
248   fpCommandLightsMove->SetParameterName("light    210   fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
249   fpCommandLightsMove->SetCandidates              211   fpCommandLightsMove->SetCandidates
250   ("cam camera with-camera obj object with-obj << 212     ("cam camera with-camera obj object with-object");
251                                                   213 
252   fpCommandLightsThetaPhi = new G4UIcommand       214   fpCommandLightsThetaPhi = new G4UIcommand
253   ("/vis/viewer/set/lightsThetaPhi", this);    << 215     ("/vis/viewer/set/lightsThetaPhi", this);
254   fpCommandLightsThetaPhi->SetGuidance            216   fpCommandLightsThetaPhi->SetGuidance
255   ("Set direction from target to lights.");    << 217     ("Set direction from target to lights.");
256   parameter = new G4UIparameter("theta", 'd',     218   parameter = new G4UIparameter("theta", 'd', omitable = true);
257   parameter -> SetDefaultValue(60.);              219   parameter -> SetDefaultValue(60.);
258   fpCommandLightsThetaPhi -> SetParameter (par    220   fpCommandLightsThetaPhi -> SetParameter (parameter);
259   parameter = new G4UIparameter("phi", 'd', om    221   parameter = new G4UIparameter("phi", 'd', omitable = true);
260   parameter -> SetDefaultValue(45.);              222   parameter -> SetDefaultValue(45.);
261   fpCommandLightsThetaPhi -> SetParameter (par    223   fpCommandLightsThetaPhi -> SetParameter (parameter);
262   parameter = new G4UIparameter ("unit", 's',     224   parameter = new G4UIparameter ("unit", 's', omitable = true);
263   parameter -> SetDefaultValue ("deg");           225   parameter -> SetDefaultValue ("deg");
264   fpCommandLightsThetaPhi -> SetParameter (par    226   fpCommandLightsThetaPhi -> SetParameter (parameter);
265                                                   227 
266   fpCommandLightsVector = new G4UIcommand         228   fpCommandLightsVector = new G4UIcommand
267   ("/vis/viewer/set/lightsVector", this);      << 229     ("/vis/viewer/set/lightsVector", this);
268   fpCommandLightsVector->SetGuidance              230   fpCommandLightsVector->SetGuidance
269   ("Set direction from target to lights.");    << 231     ("Set direction from target to lights.");
270   parameter = new G4UIparameter("x", 'd', omit    232   parameter = new G4UIparameter("x", 'd', omitable = true);
271   parameter -> SetDefaultValue (1);               233   parameter -> SetDefaultValue (1);
272   fpCommandLightsVector -> SetParameter (param    234   fpCommandLightsVector -> SetParameter (parameter);
273   parameter = new G4UIparameter("y", 'd', omit    235   parameter = new G4UIparameter("y", 'd', omitable = true);
274   parameter -> SetDefaultValue (1);               236   parameter -> SetDefaultValue (1);
275   fpCommandLightsVector -> SetParameter (param    237   fpCommandLightsVector -> SetParameter (parameter);
276   parameter = new G4UIparameter ("z", 'd', omi    238   parameter = new G4UIparameter ("z", 'd', omitable = true);
277   parameter -> SetDefaultValue (1);               239   parameter -> SetDefaultValue (1);
278   fpCommandLightsVector -> SetParameter (param    240   fpCommandLightsVector -> SetParameter (parameter);
279                                                   241 
280   fpCommandLineSegments = new G4UIcmdWithAnInt    242   fpCommandLineSegments = new G4UIcmdWithAnInteger
281   ("/vis/viewer/set/lineSegmentsPerCircle",thi << 243     ("/vis/viewer/set/lineSegmentsPerCircle",this);
282   fpCommandLineSegments->SetGuidance              244   fpCommandLineSegments->SetGuidance
283   ("Set number of sides per circle for polygon << 245     ("Set number of sides per circle for polygon/polyhedron drawing.");
284   fpCommandLineSegments->SetGuidance              246   fpCommandLineSegments->SetGuidance
285   ("Refers to graphical representation of obje << 247  ("Refers to graphical representation of objects with curved lines/surfaces.");
286   fpCommandLineSegments->SetParameterName("lin    248   fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
287   fpCommandLineSegments->SetDefaultValue(24);     249   fpCommandLineSegments->SetDefaultValue(24);
288                                                   250 
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         251   fpCommandPicking = new G4UIcmdWithABool
304   ("/vis/viewer/set/picking",this);            << 252     ("/vis/viewer/set/picking",this);
305   fpCommandPicking->SetGuidance("Sets picking,    253   fpCommandPicking->SetGuidance("Sets picking, if available.");
306   fpCommandPicking->SetGuidance                   254   fpCommandPicking->SetGuidance
307   ("If true, view is set up for picking, if av << 255     ("If true, view is set up for picking, if available."
308   fpCommandPicking->SetGuidance                << 256      "\nFor required actions, watch for instructions for viewer.");
309   ("You may need to issue \"/vis/viewer/update << 
310   fpCommandPicking->SetGuidance                << 
311   ("For required actions, watch for instructio << 
312   fpCommandPicking->SetParameterName("picking"    257   fpCommandPicking->SetParameterName("picking",omitable = true);
313   fpCommandPicking->SetDefaultValue(true);        258   fpCommandPicking->SetDefaultValue(true);
314                                                   259 
315   fpCommandProjection = new G4UIcommand("/vis/    260   fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
316   fpCommandProjection->SetGuidance                261   fpCommandProjection->SetGuidance
317   ("Set projection style - o[rthogonal] or p[e << 262     ("Orthogonal or perspective projection.");
318    "\nIf p[erspective], also set field half an << 
319   parameter = new G4UIparameter("projection",'    263   parameter = new G4UIparameter("projection",'s',omitable = true);
320   parameter->SetParameterCandidates("o orthogo    264   parameter->SetParameterCandidates("o orthogonal p perspective");
321   parameter->SetDefaultValue("orthogonal");       265   parameter->SetDefaultValue("orthogonal");
322   fpCommandProjection->SetParameter(parameter)    266   fpCommandProjection->SetParameter(parameter);
323   parameter = new G4UIparameter("field-half-an    267   parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
324   parameter->SetDefaultValue(30.);                268   parameter->SetDefaultValue(30.);
325   //parameter->SetCurrentAsDefault(true);      << 
326   fpCommandProjection->SetParameter(parameter)    269   fpCommandProjection->SetParameter(parameter);
327   parameter = new G4UIparameter("unit",'s',omi    270   parameter = new G4UIparameter("unit",'s',omitable = true);
328   parameter->SetDefaultValue("deg");              271   parameter->SetDefaultValue("deg");
329   //parameter->SetCurrentAsDefault(true);      << 
330   fpCommandProjection->SetParameter(parameter)    272   fpCommandProjection->SetParameter(parameter);
331                                                   273 
332   fpCommandRotationStyle = new G4UIcmdWithAStr << 
333   ("/vis/viewer/set/rotationStyle",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    274   fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
344   fpCommandSectionPlane -> SetGuidance            275   fpCommandSectionPlane -> SetGuidance
345   ("Set plane for drawing section (DCUT).");   << 276     ("Set plane for drawing section (DCUT).");
346   fpCommandSectionPlane -> SetGuidance            277   fpCommandSectionPlane -> SetGuidance
347   ("E.g., for a y-z plane at x = 1 cm:"        << 278     ("E.g., for a y-z plane at x = 1 cm:"
348    "\n\"/vis/viewer/set/sectionPlane on 1 0 0  << 279      "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
349    "\nTo turn off: /vis/viewer/set/sectionPlan << 280      "\nTo turn off: /vis/viewer/set/sectionPlane off");
350   parameter  =  new G4UIparameter("Selector",'    281   parameter  =  new G4UIparameter("Selector",'c',true);
351   parameter  -> SetDefaultValue  ("on");          282   parameter  -> SetDefaultValue  ("on");
352   fpCommandSectionPlane->SetParameter(paramete    283   fpCommandSectionPlane->SetParameter(parameter);
353   parameter  =  new G4UIparameter("x",'d',omit    284   parameter  =  new G4UIparameter("x",'d',omitable = true);
354   parameter  -> SetDefaultValue  (0);             285   parameter  -> SetDefaultValue  (0);
355   parameter  -> SetGuidance      ("Coordinate     286   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
356   fpCommandSectionPlane->SetParameter(paramete    287   fpCommandSectionPlane->SetParameter(parameter);
357   parameter  =  new G4UIparameter("y",'d',omit    288   parameter  =  new G4UIparameter("y",'d',omitable = true);
358   parameter  -> SetDefaultValue  (0);             289   parameter  -> SetDefaultValue  (0);
359   parameter  -> SetGuidance      ("Coordinate     290   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
360   fpCommandSectionPlane->SetParameter(paramete    291   fpCommandSectionPlane->SetParameter(parameter);
361   parameter  =  new G4UIparameter("z",'d',omit    292   parameter  =  new G4UIparameter("z",'d',omitable = true);
362   parameter  -> SetDefaultValue  (0);             293   parameter  -> SetDefaultValue  (0);
363   parameter  -> SetGuidance      ("Coordinate     294   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
364   fpCommandSectionPlane->SetParameter(paramete    295   fpCommandSectionPlane->SetParameter(parameter);
365   parameter  =  new G4UIparameter("unit",'s',o    296   parameter  =  new G4UIparameter("unit",'s',omitable = true);
366   parameter  -> SetDefaultValue  ("m");           297   parameter  -> SetDefaultValue  ("m");
367   parameter  -> SetGuidance      ("Unit of poi    298   parameter  -> SetGuidance      ("Unit of point on the plane.");
368   fpCommandSectionPlane->SetParameter(paramete    299   fpCommandSectionPlane->SetParameter(parameter);
369   parameter  =  new G4UIparameter("nx",'d',omi    300   parameter  =  new G4UIparameter("nx",'d',omitable = true);
370   parameter  -> SetDefaultValue  (1);             301   parameter  -> SetDefaultValue  (1);
371   parameter  -> SetGuidance      ("Component o    302   parameter  -> SetGuidance      ("Component of plane normal.");
372   fpCommandSectionPlane->SetParameter(paramete    303   fpCommandSectionPlane->SetParameter(parameter);
373   parameter  =  new G4UIparameter("ny",'d',omi    304   parameter  =  new G4UIparameter("ny",'d',omitable = true);
374   parameter  -> SetDefaultValue  (0);             305   parameter  -> SetDefaultValue  (0);
375   parameter  -> SetGuidance      ("Component o    306   parameter  -> SetGuidance      ("Component of plane normal.");
376   fpCommandSectionPlane->SetParameter(paramete    307   fpCommandSectionPlane->SetParameter(parameter);
377   parameter  =  new G4UIparameter("nz",'d',omi    308   parameter  =  new G4UIparameter("nz",'d',omitable = true);
378   parameter  -> SetDefaultValue  (0);             309   parameter  -> SetDefaultValue  (0);
379   parameter  -> SetGuidance      ("Component o    310   parameter  -> SetGuidance      ("Component of plane normal.");
380   fpCommandSectionPlane->SetParameter(paramete    311   fpCommandSectionPlane->SetParameter(parameter);
381                                                   312 
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    313   fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
411   fpCommandStyle->SetGuidance                     314   fpCommandStyle->SetGuidance
412   ("Set style of drawing - w[ireframe] or s[ur << 315     ("Set style of drawing - w[ireframe] or s[urface].");
413   fpCommandStyle->SetGuidance                  << 316   fpCommandStyle->SetGuidance 
414   ("(Hidden line drawing is controlled by \"/v << 317     ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
415   fpCommandStyle->SetParameterName ("style",om    318   fpCommandStyle->SetParameterName ("style",omitable = false);
416   fpCommandStyle->SetCandidates("w wireframe s << 
417                                                   319 
418   fpCommandTargetPoint = new G4UIcmdWith3Vecto    320   fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit
419   ("/vis/viewer/set/targetPoint", this);       << 321     ("/vis/viewer/set/targetPoint", this);
420   fpCommandTargetPoint->SetGuidance               322   fpCommandTargetPoint->SetGuidance
421   ("Set target point.");                       << 323     ("Set target point.");
422   fpCommandTargetPoint->SetGuidance               324   fpCommandTargetPoint->SetGuidance
423   ("This sets the \"Current Target Point\" rel << 325     ("This sets the \"Current Target Point\" relative to the \"Standard");
424   fpCommandTargetPoint->SetGuidance               326   fpCommandTargetPoint->SetGuidance
425   ("Target Point\" so that the actual target p << 327     ("Target Point\" so that the actual target point is as requested.");
426   fpCommandTargetPoint->SetGuidance               328   fpCommandTargetPoint->SetGuidance
427   ("(See G4ViewParameters.hh for an explanatio << 329     ("(See G4ViewParameters.hh for an explanation of target points.)");
428   fpCommandTargetPoint->SetParameterName("x",     330   fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false);
429   fpCommandTargetPoint->SetUnitCategory("Lengt    331   fpCommandTargetPoint->SetUnitCategory("Length");
430                                                   332 
431   fpCommandUpThetaPhi = new G4UIcommand           333   fpCommandUpThetaPhi = new G4UIcommand
432   ("/vis/viewer/set/upThetaPhi", this);        << 334     ("/vis/viewer/set/upThetaPhi", this);
433   fpCommandUpThetaPhi -> SetGuidance ("Set up     335   fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
434   fpCommandUpThetaPhi -> SetGuidance              336   fpCommandUpThetaPhi -> SetGuidance
435   ("Viewer will attempt always to show this di << 337     ("Viewer will attempt always to show this direction upwards.");
436   parameter = new G4UIparameter("theta", 'd',     338   parameter = new G4UIparameter("theta", 'd', omitable = true);
437   parameter -> SetDefaultValue (90.);             339   parameter -> SetDefaultValue (90.);
438   fpCommandUpThetaPhi -> SetParameter (paramet    340   fpCommandUpThetaPhi -> SetParameter (parameter);
439   parameter = new G4UIparameter("phi", 'd', om    341   parameter = new G4UIparameter("phi", 'd', omitable = true);
440   parameter -> SetDefaultValue (90.);             342   parameter -> SetDefaultValue (90.);
441   fpCommandUpThetaPhi -> SetParameter (paramet    343   fpCommandUpThetaPhi -> SetParameter (parameter);
442   parameter = new G4UIparameter ("unit", 's',     344   parameter = new G4UIparameter ("unit", 's', omitable = true);
443   parameter -> SetDefaultValue ("deg");           345   parameter -> SetDefaultValue ("deg");
444   fpCommandUpThetaPhi -> SetParameter (paramet    346   fpCommandUpThetaPhi -> SetParameter (parameter);
445                                                   347 
446   fpCommandUpVector = new G4UIcommand             348   fpCommandUpVector = new G4UIcommand
447   ("/vis/viewer/set/upVector", this);          << 349     ("/vis/viewer/set/upVector", this);
448   fpCommandUpVector -> SetGuidance ("Set up ve    350   fpCommandUpVector -> SetGuidance ("Set up vector.");
449   fpCommandUpVector -> SetGuidance                351   fpCommandUpVector -> SetGuidance
450   ("Viewer will attempt always to show this di << 352     ("Viewer will attempt always to show this direction upwards.");
451   parameter = new G4UIparameter("x", 'd', omit    353   parameter = new G4UIparameter("x", 'd', omitable = true);
452   parameter -> SetDefaultValue (0.);              354   parameter -> SetDefaultValue (0.);
453   fpCommandUpVector -> SetParameter (parameter    355   fpCommandUpVector -> SetParameter (parameter);
454   parameter = new G4UIparameter("y", 'd', omit    356   parameter = new G4UIparameter("y", 'd', omitable = true);
455   parameter -> SetDefaultValue (1.);              357   parameter -> SetDefaultValue (1.);
456   fpCommandUpVector -> SetParameter (parameter    358   fpCommandUpVector -> SetParameter (parameter);
457   parameter = new G4UIparameter ("z", 'd', omi    359   parameter = new G4UIparameter ("z", 'd', omitable = true);
458   parameter -> SetDefaultValue (0.);              360   parameter -> SetDefaultValue (0.);
459   fpCommandUpVector -> SetParameter (parameter    361   fpCommandUpVector -> SetParameter (parameter);
460                                                   362 
461   fpCommandViewpointThetaPhi = new G4UIcommand    363   fpCommandViewpointThetaPhi = new G4UIcommand
462   ("/vis/viewer/set/viewpointThetaPhi", this); << 364     ("/vis/viewer/set/viewpointThetaPhi", this);
463   fpCommandViewpointThetaPhi -> SetGuidance       365   fpCommandViewpointThetaPhi -> SetGuidance
464   ("Set direction from target to camera.");    << 366     ("Set direction from target to camera.");
465   fpCommandViewpointThetaPhi -> SetGuidance       367   fpCommandViewpointThetaPhi -> SetGuidance
466   ("Also changes lightpoint direction if light    368   ("Also changes lightpoint direction if lights are set to move with camera.");
467   parameter = new G4UIparameter("theta", 'd',     369   parameter = new G4UIparameter("theta", 'd', omitable = true);
468   parameter -> SetDefaultValue (60.);             370   parameter -> SetDefaultValue (60.);
469   fpCommandViewpointThetaPhi -> SetParameter (    371   fpCommandViewpointThetaPhi -> SetParameter (parameter);
470   parameter = new G4UIparameter("phi", 'd', om    372   parameter = new G4UIparameter("phi", 'd', omitable = true);
471   parameter -> SetDefaultValue (45.);             373   parameter -> SetDefaultValue (45.);
472   fpCommandViewpointThetaPhi -> SetParameter (    374   fpCommandViewpointThetaPhi -> SetParameter (parameter);
473   parameter = new G4UIparameter ("unit", 's',     375   parameter = new G4UIparameter ("unit", 's', omitable = true);
474   parameter -> SetDefaultValue ("deg");           376   parameter -> SetDefaultValue ("deg");
475   fpCommandViewpointThetaPhi -> SetParameter (    377   fpCommandViewpointThetaPhi -> SetParameter (parameter);
476                                                   378 
477   fpCommandViewpointVector = new G4UIcommand      379   fpCommandViewpointVector = new G4UIcommand
478   ("/vis/viewer/set/viewpointVector", this);   << 380     ("/vis/viewer/set/viewpointVector", this);
479   fpCommandViewpointVector -> SetGuidance         381   fpCommandViewpointVector -> SetGuidance
480   ("Set direction from target to camera.");    << 382     ("Set direction from target to camera.");
481   fpCommandViewpointVector -> SetGuidance         383   fpCommandViewpointVector -> SetGuidance
482   ("Also changes lightpoint direction if light    384   ("Also changes lightpoint direction if lights are set to move with camera.");
483   parameter = new G4UIparameter("x", 'd', omit    385   parameter = new G4UIparameter("x", 'd', omitable = true);
484   parameter -> SetDefaultValue (1.);              386   parameter -> SetDefaultValue (1.);
485   fpCommandViewpointVector -> SetParameter (pa    387   fpCommandViewpointVector -> SetParameter (parameter);
486   parameter = new G4UIparameter("y", 'd', omit    388   parameter = new G4UIparameter("y", 'd', omitable = true);
487   parameter -> SetDefaultValue (1.);              389   parameter -> SetDefaultValue (1.);
488   fpCommandViewpointVector -> SetParameter (pa    390   fpCommandViewpointVector -> SetParameter (parameter);
489   parameter = new G4UIparameter ("z", 'd', omi    391   parameter = new G4UIparameter ("z", 'd', omitable = true);
490   parameter -> SetDefaultValue (1.);              392   parameter -> SetDefaultValue (1.);
491   fpCommandViewpointVector -> SetParameter (pa    393   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 }                                                 394 }
637                                                   395 
638 G4VisCommandsViewerSet::~G4VisCommandsViewerSe    396 G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
639   delete fpCommandTimeWindowStartTime;         << 397   delete fpCommandAll;
640   delete fpCommandTimeWindowFadeFactor;        << 
641   delete fpCommandTimeWindowEndTime;           << 
642   delete fpCommandTimeWindowDisplayLightFront; << 
643   delete fpCommandTimeWindowDisplayHeadTime;   << 
644   delete fpTimeWindowDirectory;                << 
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;                << 
661   delete fpCommandLightsVector;                << 
662   delete fpCommandLightsThetaPhi;              << 
663   delete fpCommandLightsMove;                  << 
664   delete fpCommandHiddenMarker;                << 
665   delete fpCommandHiddenEdge;                  << 
666   delete fpCommandGlobalMarkerScale;           << 
667   delete fpCommandGlobalLineWidthScale;        << 
668   delete fpCommandExplodeFactor;               << 
669   delete fpCommandEdge;                        << 
670   delete fpCommandDefaultTextColour;           << 
671   delete fpCommandDefaultColour;               << 
672   delete fpCommandCutawayMode;                 << 
673   delete fpCommandCulling;                     << 
674   delete fpCommandBackground;                  << 
675   delete fpCommandAuxEdge;                        398   delete fpCommandAuxEdge;
676   delete fpCommandAutoRefresh;                    399   delete fpCommandAutoRefresh;
677   delete fpCommandAll;                         << 400   delete fpCommandBackground;
                                                   >> 401   delete fpCommandCulling;
                                                   >> 402   delete fpCommandCutawayMode;
                                                   >> 403   delete fpCommandEdge;
                                                   >> 404   delete fpCommandExplodeFactor;
                                                   >> 405   delete fpCommandGlobalLineWidthScale;
                                                   >> 406   delete fpCommandGlobalMarkerScale;
                                                   >> 407   delete fpCommandHiddenEdge;
                                                   >> 408   delete fpCommandHiddenMarker;
                                                   >> 409   delete fpCommandLineSegments;
                                                   >> 410   delete fpCommandLightsMove;
                                                   >> 411   delete fpCommandLightsThetaPhi;
                                                   >> 412   delete fpCommandLightsVector;
                                                   >> 413   delete fpCommandPicking;
                                                   >> 414   delete fpCommandProjection;
                                                   >> 415   delete fpCommandSectionPlane;
                                                   >> 416   delete fpCommandStyle;
                                                   >> 417   delete fpCommandTargetPoint;
                                                   >> 418   delete fpCommandUpThetaPhi;
                                                   >> 419   delete fpCommandUpVector;
                                                   >> 420   delete fpCommandViewpointThetaPhi;
                                                   >> 421   delete fpCommandViewpointVector;
678 }                                                 422 }
679                                                   423 
680 G4String G4VisCommandsViewerSet::GetCurrentVal    424 G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand*) {
681   return "";                                      425   return "";
682 }                                                 426 }
683                                                   427 
684 void G4VisCommandsViewerSet::SetNewValue          428 void G4VisCommandsViewerSet::SetNewValue
685 (G4UIcommand* command,G4String newValue) {        429 (G4UIcommand* command,G4String newValue) {
686                                                   430 
687   G4VisManager::Verbosity verbosity = fpVisMan    431   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
688                                                   432 
689   G4VViewer* currentViewer = fpVisManager->Get    433   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
690   if (!currentViewer) {                           434   if (!currentViewer) {
691     if (verbosity >= G4VisManager::errors) {      435     if (verbosity >= G4VisManager::errors) {
692       G4warn <<                                << 436       G4cout << 
693       "ERROR: G4VisCommandsViewerSet::SetNewVa << 437   "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
694       << G4endl;                               << 438        << G4endl;
695     }                                             439     }
696     return;                                       440     return;
697   }                                               441   }
698                                                   442 
699   G4ViewParameters vp = currentViewer->GetView    443   G4ViewParameters vp = currentViewer->GetViewParameters();
700                                                   444 
701   if (command == fpCommandAll) {                  445   if (command == fpCommandAll) {
702     G4VViewer* fromViewer = fpVisManager->GetV    446     G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
703     if (!fromViewer) {                            447     if (!fromViewer) {
704       if (verbosity >= G4VisManager::errors) {    448       if (verbosity >= G4VisManager::errors) {
705         G4warn <<                              << 449   G4cout <<
706         "ERROR: G4VisCommandsViewerSet::SetNew << 450     "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
707         "\n  unrecognised from-viewer."        << 451     "\n  unrecognised from-viewer."
708         << G4endl;                             << 452          << G4endl;
709       }                                           453       }
710       return;                                     454       return;
711     }                                             455     }
712     if (fromViewer == currentViewer) {            456     if (fromViewer == currentViewer) {
713       if (verbosity >= G4VisManager::warnings)    457       if (verbosity >= G4VisManager::warnings) {
714         G4warn <<                              << 458       G4cout <<
715         "WARNING: G4VisCommandsViewerSet::SetN << 459   "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
716         "\n  from-viewer and current viewer ar << 460   "\n  from-viewer and current viewer are identical."
717         << G4endl;                             << 461        << G4endl;
718       }                                           462       }
719       return;                                     463       return;
720     }                                             464     }
721     // Copy view parameters except for autoRef << 465     // Copy view parameters except for autoRefresh...
722     auto keepAutoRefresh = vp.IsAutoRefresh(); << 466     G4bool currentAutoRefresh =
723     auto keepBackground  = vp.GetBackgroundCol << 467       currentViewer->GetViewParameters().IsAutoRefresh();
724     vp = fromViewer->GetViewParameters();         468     vp = fromViewer->GetViewParameters();
725     vp.SetAutoRefresh(keepAutoRefresh);        << 469     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    470     if (verbosity >= G4VisManager::confirmations) {
737       G4cout << "View parameters of viewer \""    471       G4cout << "View parameters of viewer \"" << currentViewer->GetName()
738       << "\"\n  set to those of viewer \"" <<  << 472        << "\"\n  set to those of viewer \"" << fromViewer->GetName()
739       << "\"."                                 << 473        << "\"."
740       << G4endl;                               << 474        << G4endl;
741     }                                          << 
742     if (verbosity >= G4VisManager::warnings) { << 
743       G4warn << "You may need \"/vis/viewer/re << 
744       << G4endl;                               << 
745     }                                             475     }
746   }                                               476   }
747                                                   477 
748   else if (command == fpCommandAutoRefresh) {     478   else if (command == fpCommandAutoRefresh) {
749     G4bool autoRefresh = G4UIcommand::ConvertT    479     G4bool autoRefresh = G4UIcommand::ConvertToBool(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);               480     vp.SetAutoRefresh(autoRefresh);
763     if (verbosity >= G4VisManager::confirmatio    481     if (verbosity >= G4VisManager::confirmations) {
764       G4cout << "Views will ";                    482       G4cout << "Views will ";
765       if (!vp.IsAutoRefresh()) G4cout << "not     483       if (!vp.IsAutoRefresh()) G4cout << "not ";
766       G4cout << "be automatically refreshed af    484       G4cout << "be automatically refreshed after a change of view parameters."
767       << G4endl;                               << 485        << G4endl;
768     }                                             486     }
769     if (!vp.IsAutoRefresh()) {                    487     if (!vp.IsAutoRefresh()) {
770       currentViewer->SetViewParameters(vp);       488       currentViewer->SetViewParameters(vp);
771       return;  // Avoid a refresh if auto-refr << 489       return;  // Avoid a refresh id auto-refresh has been set to off...
772     }  // ...otherwise take normal action.        490     }  // ...otherwise take normal action.
773   }                                               491   }
774                                                   492 
775   else if (command == fpCommandAuxEdge) {         493   else if (command == fpCommandAuxEdge) {
776     vp.SetAuxEdgeVisible(G4UIcommand::ConvertT    494     vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
777     if (verbosity >= G4VisManager::confirmatio    495     if (verbosity >= G4VisManager::confirmations) {
778       G4cout << "Auxiliary edges will ";          496       G4cout << "Auxiliary edges will ";
779       if (!vp.IsAuxEdgeVisible()) G4cout << "n    497       if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
780       G4cout << "be visible." << G4endl;          498       G4cout << "be visible." << G4endl;
781     }                                             499     }
782   }                                               500   }
783                                                   501 
784   else if (command == fpCommandBackground) {      502   else if (command == fpCommandBackground) {
785     G4String redOrString;                         503     G4String redOrString;
786     G4double green, blue, opacity;                504     G4double green, blue, opacity;
787     std::istringstream iss(newValue);             505     std::istringstream iss(newValue);
788     iss >> redOrString >> green >> blue >> opa    506     iss >> redOrString >> green >> blue >> opacity;
789     G4Colour colour(0.,0.,0.);  // Default bla    507     G4Colour colour(0.,0.,0.);  // Default black and opaque.
790     ConvertToColour(colour, redOrString, green << 508     const size_t iPos0 = 0;
                                                   >> 509     if (std::isalpha(redOrString[iPos0])) {
                                                   >> 510       G4Colour::GetColour(redOrString, colour); // Remains default (black) if
                                                   >> 511             // not found.
                                                   >> 512     } else {
                                                   >> 513       colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue));
                                                   >> 514     }
                                                   >> 515     colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
791     vp.SetBackgroundColour(colour);               516     vp.SetBackgroundColour(colour);
792     if (verbosity >= G4VisManager::confirmatio    517     if (verbosity >= G4VisManager::confirmations) {
793       G4cout << "Background colour "              518       G4cout << "Background colour "
794       << vp.GetBackgroundColour()              << 519        << vp.GetBackgroundColour()
795       << " requested."                         << 520        << " requested."
796       << G4endl;                               << 521        << G4endl;
797     }                                             522     }
798   }                                               523   }
799                                                   524 
800   else if (command == fpCommandCulling) {         525   else if (command == fpCommandCulling) {
801     G4String cullingOption, stringFlag, unit;     526     G4String cullingOption, stringFlag, unit;
802     G4double density;                             527     G4double density;
803     std::istringstream is (newValue);             528     std::istringstream is (newValue);
804     is >> cullingOption >> stringFlag >> densi    529     is >> cullingOption >> stringFlag >> density >> unit;
805     G4bool boolFlag = G4UIcommand::ConvertToBo    530     G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
806     if (cullingOption == "global") {              531     if (cullingOption == "global") {
807       vp.SetCulling(boolFlag);                    532       vp.SetCulling(boolFlag);
808       if (verbosity >= G4VisManager::confirmat    533       if (verbosity >= G4VisManager::confirmations) {
809         G4cout <<                              << 534   G4cout <<
810         "G4VisCommandsViewerSet::SetNewValue:  << 535     "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
811         " set to " << G4UIcommand::ConvertToSt << 536     " set to " << G4UIcommand::ConvertToString(boolFlag) <<
812         ".\n  Does not change specific culling << 537     ".\n  Does not change specific culling flags."
813         << G4endl;                             << 538          << G4endl;
814       }                                           539       }
815     }                                             540     }
816     else if (cullingOption == "coveredDaughter    541     else if (cullingOption == "coveredDaughters") {
817       vp.SetCullingCovered(boolFlag);             542       vp.SetCullingCovered(boolFlag);
818       if (verbosity >= G4VisManager::confirmat    543       if (verbosity >= G4VisManager::confirmations) {
819         G4cout <<                              << 544   G4cout <<
820         "G4VisCommandsViewerSet::SetNewValue:  << 545     "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
821         "\n  daughters flag set to "           << 546     "\n  daughters flag set to "
822         << G4UIcommand::ConvertToString(boolFl << 547          << G4UIcommand::ConvertToString(boolFlag) <<
823         ".  Daughters covered by opaque mother << 548     ".  Daughters covered by opaque mothers"
824         "\n  will be culled, i.e., not drawn,  << 549     "\n  will be culled, i.e., not drawn, if this flag is true."
825         "\n  Note: this is only effective in s << 550     "\n  Note: this is only effective in surface drawing style,"
826         "\n  and then only if the volumes are  << 551     "\n  and then only if the volumes are visible and opaque, and then"
827         "\n  only if no sections or cutaways a << 552     "\n  only if no sections or cutaways are in operation."
828         << G4endl;                             << 553          << G4endl;
829       }                                           554       }
830     }                                             555     }
831     else if (cullingOption == "invisible") {      556     else if (cullingOption == "invisible") {
832       vp.SetCullingInvisible(boolFlag);           557       vp.SetCullingInvisible(boolFlag);
833       if (verbosity >= G4VisManager::confirmat    558       if (verbosity >= G4VisManager::confirmations) {
834         G4cout <<                              << 559   G4cout <<
835         "G4VisCommandsViewerSet::SetNewValue:  << 560     "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
836         "\n  flag set to "                     << 561     "\n  flag set to "
837         << boolFlag << G4UIcommand::ConvertToS << 562          << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
838         ".  Volumes marked invisible will be c << 563     ".  Volumes marked invisible will be culled,"
839         "\n  i.e., not drawn, if this flag is  << 564     "\n  i.e., not drawn, if this flag is true."
840         << G4endl;                             << 565          << G4endl;
841       }                                           566       }
842     }                                             567     }
843     else if (cullingOption == "density") {        568     else if (cullingOption == "density") {
844       const G4String where =                   << 569       vp.SetDensityCulling(boolFlag);
845       "G4VisCommandsViewerSet::SetNewValue: cu << 
846       if (boolFlag) {                             570       if (boolFlag) {
847         G4double valueOfUnit;                  << 571   density *= G4UnitDefinition::GetValueOf(unit);
848         // "Volumic Mass" is Michel's phrase f << 572   vp.SetVisibleDensity(density);
849         if (ProvideValueOfUnit(where,unit,"Vol << 573       }
850           // Successful outcome of unit search << 574       else {
851           vp.SetDensityCulling(boolFlag);      << 575   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       }                                           576       }
861       if (verbosity >= G4VisManager::confirmat    577       if (verbosity >= G4VisManager::confirmations) {
862         G4cout                                 << 578   G4cout <<
863         << where                               << 579     "G4VisCommandsViewerSet::SetNewValue: culling: culling by density"
864         << "\n  flag set to "                  << 580     "\n  flag set to " << G4UIcommand::ConvertToString(boolFlag) <<
865         << std::boolalpha << vp.IsDensityCulli << 581     ".  Volumes with density less than " <<
866         << ".  Volumes with density less than  << 582     G4BestUnit(density,"Volumic Mass") <<
867         << G4BestUnit(density,"Volumic Mass")  << 583     "\n  will be culled, i.e., not drawn, if this flag is true."
868         << "\n  will be culled, i.e., not draw << 584          << G4endl;
869         << G4endl;                             << 
870       }                                           585       }
871     }                                             586     }
872     else {                                        587     else {
873       if (verbosity >= G4VisManager::errors) {    588       if (verbosity >= G4VisManager::errors) {
874         G4warn <<                              << 589   G4cout <<
875         "ERROR: G4VisCommandsViewerSet::SetNew << 590     "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
876         "\n  option not recognised."           << 591     "\n  option not recognised."
877         << G4endl;                             << 592          << G4endl;
878       }                                           593       }
879     }                                             594     }
880   }                                               595   }
881                                                   596 
882   else if (command == fpCommandCutawayMode) {     597   else if (command == fpCommandCutawayMode) {
883     if (newValue == "add" || newValue == "unio    598     if (newValue == "add" || newValue == "union")
884       vp.SetCutawayMode(G4ViewParameters::cuta    599       vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
885     if (newValue == "multiply" || newValue ==     600     if (newValue == "multiply" || newValue == "intersection")
886       vp.SetCutawayMode(G4ViewParameters::cuta    601       vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
887                                                << 602  
888     if (verbosity >= G4VisManager::confirmatio    603     if (verbosity >= G4VisManager::confirmations) {
889       G4cout << "Cutaway mode set to ";           604       G4cout << "Cutaway mode set to ";
890       if (vp.GetCutawayMode() == G4ViewParamet    605       if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
891         G4cout << "cutawayUnion";              << 606   G4cout << "cutawayUnion";
892       if (vp.GetCutawayMode() == G4ViewParamet    607       if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
893         G4cout << "cutawayIntersection";       << 608   G4cout << "cutawayIntersection";
894       G4cout << G4endl;                           609       G4cout << G4endl;
895     }                                             610     }
896   }                                               611   }
897                                                   612 
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) {            613   else if (command == fpCommandEdge) {
935     G4ViewParameters::DrawingStyle existingSty    614     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
936     if (G4UIcommand::ConvertToBool(newValue))  << 615     if (G4UIcommand::ConvertToBool(newValue)) {
937       switch (existingStyle) {                    616       switch (existingStyle) {
938         case G4ViewParameters::wireframe:      << 617       case G4ViewParameters::wireframe:
939           break;                               << 618   break;
940         case G4ViewParameters::hlr:            << 619       case G4ViewParameters::hlr:
941           break;                               << 620   break;
942         case G4ViewParameters::hsr:            << 621       case G4ViewParameters::hsr:
943           vp.SetDrawingStyle(G4ViewParameters: << 622   vp.SetDrawingStyle(G4ViewParameters::hlhsr);
944           break;                               << 623         break;
945         case G4ViewParameters::hlhsr:          << 624       case G4ViewParameters::hlhsr:
946           break;                               << 625         break;
947         case G4ViewParameters::cloud:          << 
948           break;                               << 
949       }                                           626       }
950     }                                             627     }
951     else {  // false                           << 628     else {
952       switch (existingStyle) {                    629       switch (existingStyle) {
953         case G4ViewParameters::wireframe:      << 630       case G4ViewParameters::wireframe:
954           break;                               << 631   break;
955         case G4ViewParameters::hlr:            << 632       case G4ViewParameters::hlr:
956           break;                               << 633   break;
957         case G4ViewParameters::hsr:            << 634       case G4ViewParameters::hsr:
958           break;                               << 635   break;
959         case G4ViewParameters::hlhsr:          << 636       case G4ViewParameters::hlhsr:
960           vp.SetDrawingStyle(G4ViewParameters: << 637   vp.SetDrawingStyle(G4ViewParameters::hsr);
961           break;                               << 638   break;
962         case G4ViewParameters::cloud:          << 
963           break;                               << 
964       }                                           639       }
965     }                                             640     }
966     if (verbosity >= G4VisManager::confirmatio    641     if (verbosity >= G4VisManager::confirmations) {
967       G4cout << "Drawing style of viewer \"" <    642       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
968       << "\" set to " << vp.GetDrawingStyle()  << 643        << "\" set to " << vp.GetDrawingStyle()
969       << G4endl;                               << 644        << G4endl;
970     }                                             645     }
971   }                                               646   }
972                                                   647 
973   else if (command == fpCommandExplodeFactor)     648   else if (command == fpCommandExplodeFactor) {
974     G4double explodeFactor, x, y, z;              649     G4double explodeFactor, x, y, z;
975     G4String unitString;                          650     G4String unitString;
976     std::istringstream is (newValue);             651     std::istringstream is (newValue);
977     is >> explodeFactor >> x >> y >> z >> unit    652     is >> explodeFactor >> x >> y >> z >> unitString;
978     G4double unit = G4UIcommand::ValueOf(unitS    653     G4double unit = G4UIcommand::ValueOf(unitString);
979     vp.SetExplodeFactor(explodeFactor);           654     vp.SetExplodeFactor(explodeFactor);
980     vp.SetExplodeCentre(G4Point3D(x * unit, y     655     vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
981     if (verbosity >= G4VisManager::confirmatio    656     if (verbosity >= G4VisManager::confirmations) {
982       G4cout << "Explode factor changed to " <    657       G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
983       << " from centre " << vp.GetExplodeCentr << 658        << " from centre " << vp.GetExplodeCentre()
984       << G4endl;                               << 659        << G4endl;
985     }                                             660     }
986   }                                               661   }
987                                                   662 
988   else if (command == fpCommandGlobalLineWidth    663   else if (command == fpCommandGlobalLineWidthScale) {
989     G4double globalLineWidthScale                 664     G4double globalLineWidthScale
990     = fpCommandGlobalLineWidthScale->GetNewDou << 665       = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
991     vp.SetGlobalLineWidthScale(globalLineWidth    666     vp.SetGlobalLineWidthScale(globalLineWidthScale);
992     if (verbosity >= G4VisManager::confirmatio    667     if (verbosity >= G4VisManager::confirmations) {
993       G4cout << "Global Line Width Scale chang    668       G4cout << "Global Line Width Scale changed to "
994       << vp.GetGlobalLineWidthScale() << G4end << 669        << vp.GetGlobalLineWidthScale() << G4endl;
995     }                                             670     }
996   }                                               671   }
997                                                   672 
998   else if (command == fpCommandGlobalMarkerSca    673   else if (command == fpCommandGlobalMarkerScale) {
999     G4double globalMarkerScale                    674     G4double globalMarkerScale
1000     = fpCommandGlobalMarkerScale->GetNewDoubl << 675       = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
1001     vp.SetGlobalMarkerScale(globalMarkerScale    676     vp.SetGlobalMarkerScale(globalMarkerScale);
1002     if (verbosity >= G4VisManager::confirmati    677     if (verbosity >= G4VisManager::confirmations) {
1003       G4cout << "Global Marker Scale changed     678       G4cout << "Global Marker Scale changed to "
1004       << vp.GetGlobalMarkerScale() << G4endl; << 679        << vp.GetGlobalMarkerScale() << G4endl;
1005     }                                            680     }
1006   }                                              681   }
1007                                                  682 
1008   else if (command == fpCommandHiddenEdge) {     683   else if (command == fpCommandHiddenEdge) {
1009     G4ViewParameters::DrawingStyle existingSt    684     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1010     if (G4UIcommand::ConvertToBool(newValue))    685     if (G4UIcommand::ConvertToBool(newValue)) {
1011       switch (existingStyle) {                   686       switch (existingStyle) {
1012         case G4ViewParameters::wireframe:     << 687       case G4ViewParameters::wireframe:
1013           vp.SetDrawingStyle(G4ViewParameters << 688   vp.SetDrawingStyle(G4ViewParameters::hlr);
1014           break;                              << 689   break;
1015         case G4ViewParameters::hlr:           << 690       case G4ViewParameters::hlr:
1016           break;                              << 691   break;
1017         case G4ViewParameters::hsr:           << 692       case G4ViewParameters::hsr:
1018           vp.SetDrawingStyle(G4ViewParameters << 693   vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1019           break;                              << 694         break;
1020         case G4ViewParameters::hlhsr:         << 695       case G4ViewParameters::hlhsr:
1021           break;                              << 696         break;
1022         case G4ViewParameters::cloud:         << 
1023           break;                              << 
1024       }                                          697       }
1025     }                                            698     }
1026     else {                                       699     else {
1027       switch (existingStyle) {                   700       switch (existingStyle) {
1028         case G4ViewParameters::wireframe:     << 701       case G4ViewParameters::wireframe:
1029           break;                              << 702   break;
1030         case G4ViewParameters::hlr:           << 703       case G4ViewParameters::hlr:
1031           vp.SetDrawingStyle(G4ViewParameters << 704   vp.SetDrawingStyle(G4ViewParameters::wireframe);
1032           break;                              << 705   break;
1033         case G4ViewParameters::hsr:           << 706       case G4ViewParameters::hsr:
1034           break;                              << 707   break;
1035         case G4ViewParameters::hlhsr:         << 708       case G4ViewParameters::hlhsr:
1036           vp.SetDrawingStyle(G4ViewParameters << 709   vp.SetDrawingStyle(G4ViewParameters::hsr);
1037           break;                              << 710   break;
1038         case G4ViewParameters::cloud:         << 
1039           break;                              << 
1040       }                                          711       }
1041     }                                            712     }
1042     if (verbosity >= G4VisManager::confirmati    713     if (verbosity >= G4VisManager::confirmations) {
1043       G4cout << "Drawing style of viewer \""     714       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1044       << "\" set to " << vp.GetDrawingStyle() << 715        << "\" set to " << vp.GetDrawingStyle()
1045       << G4endl;                              << 716        << G4endl;
1046     }                                            717     }
1047   }                                              718   }
1048                                                  719 
1049   else if (command == fpCommandHiddenMarker)     720   else if (command == fpCommandHiddenMarker) {
1050     G4bool hidden = G4UIcommand::ConvertToBoo    721     G4bool hidden = G4UIcommand::ConvertToBool(newValue);
1051     if (hidden) vp.SetMarkerHidden();            722     if (hidden) vp.SetMarkerHidden();
1052     else vp.SetMarkerNotHidden();                723     else vp.SetMarkerNotHidden();
1053     if (verbosity >= G4VisManager::confirmati    724     if (verbosity >= G4VisManager::confirmations) {
1054       G4cout << "Markers will ";                 725       G4cout << "Markers will ";
1055       if (vp.IsMarkerNotHidden()) G4cout << "    726       if (vp.IsMarkerNotHidden()) G4cout << "not ";
1056       G4cout << "be hidden under solid object    727       G4cout << "be hidden under solid objects." << G4endl;
1057     }                                            728     }
1058   }                                              729   }
1059                                                  730 
1060   else if (command == fpCommandLightsMove) {     731   else if (command == fpCommandLightsMove) {
1061     if (newValue.find("cam") != G4String::npo << 732     G4String s (newValue);
1062       vp.SetLightsMoveWithCamera(true);       << 733     if (s.find("cam") != G4String::npos) vp.SetLightsMoveWithCamera(true);
1063     else if(newValue.find("obj") != G4String: << 734     else if(s.find("obj") != G4String::npos) vp.SetLightsMoveWithCamera(false);
1064       vp.SetLightsMoveWithCamera(false);      << 
1065     else {                                       735     else {
1066       if (verbosity >= G4VisManager::errors)     736       if (verbosity >= G4VisManager::errors) {
1067         G4warn << "ERROR: \"" << newValue <<  << 737   G4cout << "ERROR: \"" << newValue << "\" not recognised."
1068         "  Looking for \"cam\" or \"obj\" in  << 738   "  Looking for \"cam\" or \"obj\" in string." << G4endl;
1069       }                                          739       }
1070     }                                            740     }
1071     if (verbosity >= G4VisManager::confirmati    741     if (verbosity >= G4VisManager::confirmations) {
1072       G4cout << "Lights move with ";             742       G4cout << "Lights move with ";
1073       if (vp.GetLightsMoveWithCamera())          743       if (vp.GetLightsMoveWithCamera())
1074         G4cout << "camera (object appears to  << 744   G4cout << "camera (object appears to rotate).";
1075       else G4cout << "object (the viewer appe    745       else G4cout << "object (the viewer appears to be moving).";
1076       G4cout << G4endl;                          746       G4cout << G4endl;
1077     }                                            747     }
1078   }                                              748   }
1079                                                  749 
1080   else if (command == fpCommandLightsThetaPhi    750   else if (command == fpCommandLightsThetaPhi) {
1081     G4double theta, phi;                         751     G4double theta, phi;
1082     if (ConvertToDoublePair(newValue, theta,  << 752     ConvertToDoublePair(newValue, theta, phi);
1083       G4double x = std::sin (theta) * std::co << 753     G4double x = std::sin (theta) * std::cos (phi);
1084       G4double y = std::sin (theta) * std::si << 754     G4double y = std::sin (theta) * std::sin (phi);
1085       G4double z = std::cos (theta);          << 755     G4double z = std::cos (theta);
1086       fLightsVector = G4ThreeVector (x, y, z) << 756     fLightsVector = G4ThreeVector (x, y, z);
1087       vp.SetLightpointDirection(fLightsVector << 757     vp.SetLightpointDirection(fLightsVector);
1088       if (verbosity >= G4VisManager::confirma << 758     if (verbosity >= G4VisManager::confirmations) {
1089         G4cout << "Lights direction set to "  << 759       G4cout << "Lights direction set to "
1090         << vp.GetLightpointDirection() << G4e << 760        << vp.GetLightpointDirection() << G4endl;
1091       }                                       << 
1092     }                                            761     }
1093   }                                              762   }
1094                                                  763 
1095   else if (command == fpCommandLightsVector)     764   else if (command == fpCommandLightsVector) {
1096     fLightsVector = G4UIcommand::ConvertTo3Ve    765     fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
1097     vp.SetLightpointDirection(fLightsVector);    766     vp.SetLightpointDirection(fLightsVector);
1098     if (verbosity >= G4VisManager::confirmati    767     if (verbosity >= G4VisManager::confirmations) {
1099       G4cout << "Lights direction set to "       768       G4cout << "Lights direction set to "
1100       << vp.GetLightpointDirection() << G4end << 769        << 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     }                                            770     }
1109   }                                              771   }
1110                                                  772 
1111   else if (command == fpCommandLineSegments)     773   else if (command == fpCommandLineSegments) {
1112     G4int nSides = G4UIcommand::ConvertToInt(    774     G4int nSides = G4UIcommand::ConvertToInt(newValue);
1113     nSides = vp.SetNoOfSides(nSides);            775     nSides = vp.SetNoOfSides(nSides);
1114     if (verbosity >= G4VisManager::confirmati    776     if (verbosity >= G4VisManager::confirmations) {
1115       G4cout <<                                  777       G4cout <<
1116       "Number of line segments per circle in  << 778   "Number of line segements per circle in polygon approximation is "
1117       << nSides << G4endl;                    << 779        << 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     }                                            780     }
1129   }                                              781   }
1130                                                  782 
1131   else if (command == fpCommandPicking) {        783   else if (command == fpCommandPicking) {
1132     vp.SetPicking(G4UIcommand::ConvertToBool(    784     vp.SetPicking(G4UIcommand::ConvertToBool(newValue));
1133     if (verbosity >= G4VisManager::confirmati    785     if (verbosity >= G4VisManager::confirmations) {
1134       G4cout << "Picking ";                      786       G4cout << "Picking ";
1135       if (vp.IsPicking()) G4cout << "requeste    787       if (vp.IsPicking()) G4cout << "requested.";
1136       else G4cout << "inhibited.";               788       else G4cout << "inhibited.";
1137       G4cout << G4endl;                          789       G4cout << G4endl;
1138     }                                            790     }
1139     if (verbosity >= G4VisManager::warnings)  << 
1140       G4warn << "You may need to issue \"/vis << 
1141       << G4endl;                              << 
1142     }                                         << 
1143   }                                              791   }
1144                                                  792 
1145   else if (command == fpCommandProjection) {     793   else if (command == fpCommandProjection) {
1146     G4double fieldHalfAngle;                     794     G4double fieldHalfAngle;
1147     const size_t iPos0 = 0;                      795     const size_t iPos0 = 0;
1148     if (newValue[iPos0] == 'o') {  // "orthog    796     if (newValue[iPos0] == 'o') {  // "orthogonal"
1149       fieldHalfAngle = 0.;                       797       fieldHalfAngle = 0.;
1150     }                                            798     }
1151     else if (newValue[iPos0] == 'p') {  // "p    799     else if (newValue[iPos0] == 'p') {  // "perspective"
1152       G4String dummy;                            800       G4String dummy;
1153       G4String unit;                             801       G4String unit;
1154       std::istringstream is (newValue);          802       std::istringstream is (newValue);
1155       is >> dummy >> fieldHalfAngle >> unit;     803       is >> dummy >> fieldHalfAngle >> unit;
1156       fieldHalfAngle *= G4UIcommand::ValueOf(    804       fieldHalfAngle *= G4UIcommand::ValueOf(unit);
1157       if (fieldHalfAngle > 89.5 * deg || fiel    805       if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
1158         if (verbosity >= G4VisManager::errors << 806   if (verbosity >= G4VisManager::errors) {
1159           G4warn <<                           << 807     G4cout <<
1160           "ERROR: Field half angle should be  << 808       "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
1161           G4warn << G4endl;                   << 809     G4cout << G4endl;
1162         }                                     << 810   }
1163         return;                               << 811   return;
1164       }                                          812       }
1165     }                                            813     }
1166     else {                                       814     else {
1167       if (verbosity >= G4VisManager::errors)     815       if (verbosity >= G4VisManager::errors) {
1168         G4warn << "ERROR: \"" << newValue <<  << 816   G4cout << "ERROR: \"" << newValue << "\" not recognised."
1169         "  Looking for 'o' or 'p' first chara << 817     "  Looking for 'o' or 'p' first character." << G4endl;
1170       }                                          818       }
1171       return;                                    819       return;
1172     }                                            820     }
1173     vp.SetFieldHalfAngle(fieldHalfAngle);        821     vp.SetFieldHalfAngle(fieldHalfAngle);
1174     if (verbosity >= G4VisManager::confirmati    822     if (verbosity >= G4VisManager::confirmations) {
1175       G4cout << "Projection style of viewer \    823       G4cout << "Projection style of viewer \"" << currentViewer->GetName()
1176       << "\" set to ";                        << 824        << "\" set to ";
1177       if (fieldHalfAngle == 0.) {                825       if (fieldHalfAngle == 0.) {
1178         G4cout << "orthogonal.";              << 826   G4cout << "orthogonal.";
1179       }                                          827       }
1180       else {                                     828       else {
1181         G4cout << "perspective\n  with half a << 829   G4cout << "perspective\n  with half angle " << fieldHalfAngle / deg
1182         << " degrees.";                       << 830          << " degrees.";
1183       }                                          831       }
1184       G4cout << G4endl;                          832       G4cout << G4endl;
1185     }                                            833     }
1186   }                                              834   }
1187                                                  835 
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)     836   else if (command == fpCommandSectionPlane) {
1209     G4String choice, unit;                       837     G4String choice, unit;
1210     G4double x, y, z, nx, ny, nz, F = 1.;     << 838     G4double x, y, z, nx, ny, nz;
1211     std::istringstream is (newValue);            839     std::istringstream is (newValue);
1212     is >> choice >> x >> y >> z >> unit >> nx    840     is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
                                                   >> 841 
1213     G4int iSelector = -1;                        842     G4int iSelector = -1;
1214     if (G4StrUtil::icompare(choice, "off") == << 843     if (choice.compareTo("off",G4String::ignoreCase) == 0 ||
1215         !G4UIcommand::ConvertToBool(choice))  << 844   !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
1216     if (G4StrUtil::icompare(choice, "on") ==  << 845     if (choice.compareTo("on",G4String::ignoreCase) == 0 ||
1217         G4UIcommand::ConvertToBool(choice)) i << 846   G4UIcommand::ConvertToBool(choice)) iSelector = 1;
1218     if (iSelector < 0) {                         847     if (iSelector < 0) {
1219       if (verbosity >= G4VisManager::errors)     848       if (verbosity >= G4VisManager::errors) {
1220         G4warn << "Choice not recognised (on/ << 849   G4cout << "Choice not recognised (on/true or off/false)." << G4endl;
                                                   >> 850   G4cout << "Section drawing is currently: ";
                                                   >> 851   if (vp.IsSection ()) G4cout << "on";
                                                   >> 852   else                    G4cout << "off";
                                                   >> 853   G4cout << ".\nSection plane is currently: "
                                                   >> 854          << vp.GetSectionPlane ();
                                                   >> 855   G4cout << G4endl;
1221       }                                          856       }
1222       goto write_result;                      << 857       return;
1223     }                                            858     }
1224     // iSelector can only be 0 or 1           << 859 
                                                   >> 860     G4double F = 1.;
1225     switch (iSelector) {                         861     switch (iSelector) {
1226       case 0:                                 << 862     default:
1227         vp.UnsetSectionPlane();               << 863     case 0:
1228         break;                                << 864       vp.UnsetSectionPlane();
1229       case 1:                                 << 865       break;
1230         F = G4UIcommand::ValueOf(unit);       << 866     case 1:
1231         x *= F; y *= F; z *= F;               << 867       F = G4UIcommand::ValueOf(unit);
1232         if (nx == 0. && ny == 0. && nz == 0.) << 868       x *= F; y *= F; z *= F;
1233           if (verbosity >= G4VisManager::erro << 869       vp.SetSectionPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
1234             G4warn << "Null normal." << G4end << 870       vp.SetViewpointDirection(G4Normal3D(nx,ny,nz));
1235           }                                   << 871       break;
1236           break;;                             << 
1237         }                                     << 
1238         // Make sure normal is normalised     << 
1239         const G4Normal3D& normal = G4Normal3D << 
1240         vp.SetSectionPlane(G4Plane3D(normal,  << 
1241         vp.SetViewpointDirection(normal);     << 
1242         break;                                << 
1243     }                                            872     }
1244   write_result:                               << 873 
1245     if (verbosity >= G4VisManager::confirmati    874     if (verbosity >= G4VisManager::confirmations) {
1246       G4cout << "Section drawing is: ";       << 875       G4cout << "Section drawing is now: ";
1247       if (vp.IsSection ()) G4cout << "on";       876       if (vp.IsSection ()) G4cout << "on";
1248       else                 G4cout << "off";   << 877       else                    G4cout << "off";
1249       G4cout << ".\nSection plane is now: "      878       G4cout << ".\nSection plane is now: "
1250       << vp.GetSectionPlane ();               << 879        << vp.GetSectionPlane ();
1251       G4cout << G4endl;                          880       G4cout << G4endl;
1252     }                                            881     }
1253   }                                              882   }
1254                                                  883 
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;                       << 
1274     }                                         << 
1275   }                                           << 
1276                                               << 
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) {          884   else if (command == fpCommandStyle) {
1356     G4ViewParameters::DrawingStyle existingSt    885     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1357     const size_t iPos0 = 0;                      886     const size_t iPos0 = 0;
1358     if (newValue[iPos0] == 'w') {  // "wirefr    887     if (newValue[iPos0] == 'w') {  // "wireframe"
1359       switch (existingStyle) {                   888       switch (existingStyle) {
1360         case G4ViewParameters::wireframe:     << 889       case G4ViewParameters::wireframe:
1361           break;                              << 890   break;
1362         case G4ViewParameters::hlr:           << 891       case G4ViewParameters::hlr:
1363           break;                              << 892   break;
1364         case G4ViewParameters::hsr:           << 893       case G4ViewParameters::hsr:
1365           vp.SetDrawingStyle(G4ViewParameters << 894   vp.SetDrawingStyle(G4ViewParameters::wireframe);
1366           break;                              << 895         break;
1367         case G4ViewParameters::hlhsr:         << 896       case G4ViewParameters::hlhsr:
1368           vp.SetDrawingStyle(G4ViewParameters << 897   vp.SetDrawingStyle(G4ViewParameters::hlr);
1369           break;                              << 898         break;
1370         case G4ViewParameters::cloud:         << 
1371           vp.SetDrawingStyle(G4ViewParameters << 
1372           break;                              << 
1373       }                                          899       }
1374     }                                            900     }
1375     else if (newValue[iPos0] == 's') {  // "s    901     else if (newValue[iPos0] == 's') {  // "surface"
1376       switch (existingStyle) {                   902       switch (existingStyle) {
1377         case G4ViewParameters::wireframe:     << 903       case G4ViewParameters::wireframe:
1378           vp.SetDrawingStyle(G4ViewParameters << 904   vp.SetDrawingStyle(G4ViewParameters::hsr);
1379           break;                              << 905   break;
1380         case G4ViewParameters::hlr:           << 906       case G4ViewParameters::hlr:
1381           vp.SetDrawingStyle(G4ViewParameters << 907   vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1382           break;                              << 908   break;
1383         case G4ViewParameters::hsr:           << 909       case G4ViewParameters::hsr:
1384           break;                              << 910   break;
1385         case G4ViewParameters::hlhsr:         << 911       case G4ViewParameters::hlhsr:
1386           break;                              << 912   break;
1387         case G4ViewParameters::cloud:         << 
1388           vp.SetDrawingStyle(G4ViewParameters << 
1389           break;                              << 
1390      }                                        << 
1391     }                                         << 
1392     else if (newValue[iPos0] == 'c') {  // "c << 
1393       switch (existingStyle) {                << 
1394         case G4ViewParameters::wireframe:     << 
1395           vp.SetDrawingStyle(G4ViewParameters << 
1396           break;                              << 
1397         case G4ViewParameters::hlr:           << 
1398           vp.SetDrawingStyle(G4ViewParameters << 
1399           break;                              << 
1400         case G4ViewParameters::hsr:           << 
1401           vp.SetDrawingStyle(G4ViewParameters << 
1402           break;                              << 
1403         case G4ViewParameters::hlhsr:         << 
1404           vp.SetDrawingStyle(G4ViewParameters << 
1405           break;                              << 
1406         case G4ViewParameters::cloud:         << 
1407           break;                              << 
1408       }                                          913       }
1409     }                                            914     }
1410     else {                                       915     else {
1411       if (verbosity >= G4VisManager::errors)     916       if (verbosity >= G4VisManager::errors) {
1412         G4warn << "ERROR: \"" << newValue <<  << 917   G4cout << "ERROR: \"" << newValue << "\" not recognised."
1413         "  Looking for 'w' or 's' or 'c' firs << 918     "  Looking for 'w' or 's' first character." << G4endl;
1414       }                                          919       }
1415       return;                                    920       return;
1416     }                                            921     }
1417     if (verbosity >= G4VisManager::confirmati    922     if (verbosity >= G4VisManager::confirmations) {
1418       G4cout << "Drawing style of viewer \""     923       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1419       << "\" set to " << vp.GetDrawingStyle() << 924        << "\" set to " << vp.GetDrawingStyle()
1420       << G4endl;                              << 925        << G4endl;
1421     }                                            926     }
1422   }                                              927   }
1423                                                  928 
1424   else if (command == fpCommandTargetPoint) {    929   else if (command == fpCommandTargetPoint) {
1425     G4ThreeVector targetPoint =                  930     G4ThreeVector targetPoint =
1426     fpCommandTargetPoint->GetNew3VectorValue( << 931       fpCommandTargetPoint->GetNew3VectorValue(newValue);
1427     const G4Point3D& standardTargetPoint =       932     const G4Point3D& standardTargetPoint =
1428     currentViewer->GetSceneHandler()->GetScen << 933       currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint();
1429     vp.SetCurrentTargetPoint(targetPoint - st    934     vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint);
1430     if (verbosity >= G4VisManager::confirmati    935     if (verbosity >= G4VisManager::confirmations) {
1431       G4cout << "Target point set to "           936       G4cout << "Target point set to "
1432       << fpCommandTargetPoint->ConvertToStrin << 937        << fpCommandTargetPoint->ConvertToStringWithBestUnit
1433       (targetPoint)                           << 938   (targetPoint)
1434       << "\n\"Current Target Point\" set to   << 939        << "\n\"Current Target Point\" set to  "
1435       << fpCommandTargetPoint->ConvertToStrin << 940        << fpCommandTargetPoint->ConvertToStringWithBestUnit
1436       (vp.GetCurrentTargetPoint())            << 941   (vp.GetCurrentTargetPoint())
1437       << "\n\"Standard Target Point\" is "    << 942        << "\n\"Standard Target Point\" is "
1438       << fpCommandTargetPoint->ConvertToStrin << 943        << fpCommandTargetPoint->ConvertToStringWithBestUnit
1439       (standardTargetPoint)                   << 944   (standardTargetPoint)
1440       << G4endl;                              << 945        << G4endl;
1441     }                                            946     }
1442   }                                              947   }
1443                                                  948 
1444   else if (command == fpCommandUpThetaPhi) {     949   else if (command == fpCommandUpThetaPhi) {
1445     G4double theta, phi;                         950     G4double theta, phi;
1446     if (ConvertToDoublePair(newValue, theta,  << 951     ConvertToDoublePair(newValue, theta, phi);
1447       G4double x = std::sin (theta) * std::co << 952     G4double x = std::sin (theta) * std::cos (phi);
1448       G4double y = std::sin (theta) * std::si << 953     G4double y = std::sin (theta) * std::sin (phi);
1449       G4double z = std::cos (theta);          << 954     G4double z = std::cos (theta);
1450       fUpVector = G4ThreeVector (x, y, z);    << 955     fUpVector = G4ThreeVector (x, y, z);
1451       vp.SetUpVector(fUpVector);              << 956     vp.SetUpVector(fUpVector);
1452       if (verbosity >= G4VisManager::confirma << 957     if (verbosity >= G4VisManager::confirmations) {
1453         G4cout << "Up direction set to " << v << 958       G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1454       }                                       << 
1455     }                                            959     }
1456   }                                              960   }
1457                                                  961 
1458   else if (command == fpCommandUpVector) {       962   else if (command == fpCommandUpVector) {
1459     fUpVector = G4UIcommand::ConvertTo3Vector    963     fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
1460     vp.SetUpVector(fUpVector);                   964     vp.SetUpVector(fUpVector);
1461     if (verbosity >= G4VisManager::confirmati    965     if (verbosity >= G4VisManager::confirmations) {
1462       G4cout << "Up direction set to " << vp.    966       G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1463     }                                            967     }
1464   }                                              968   }
1465                                                  969 
1466   else if (command == fpCommandViewpointTheta    970   else if (command == fpCommandViewpointThetaPhi) {
1467     G4double theta, phi;                         971     G4double theta, phi;
1468     if (ConvertToDoublePair(newValue, theta,  << 972     ConvertToDoublePair(newValue, theta, phi);
1469       G4double x = std::sin (theta) * std::co << 973     G4double x = std::sin (theta) * std::cos (phi);
1470       G4double y = std::sin (theta) * std::si << 974     G4double y = std::sin (theta) * std::sin (phi);
1471       G4double z = std::cos (theta);          << 975     G4double z = std::cos (theta);
1472       fViewpointVector = G4ThreeVector (x, y, << 976     fViewpointVector = G4ThreeVector (x, y, z);
1473       vp.SetViewAndLights(fViewpointVector);  << 977     vp.SetViewAndLights(fViewpointVector);
1474       if (verbosity >= G4VisManager::confirma << 978     if (verbosity >= G4VisManager::confirmations) {
1475         G4cout << "Viewpoint direction set to << 979       G4cout << "Viewpoint direction set to "
1476         << vp.GetViewpointDirection() << G4en << 980        << vp.GetViewpointDirection() << G4endl;
1477         if (vp.GetLightsMoveWithCamera ()) {  << 981       if (vp.GetLightsMoveWithCamera ()) {
1478           G4cout << "Lightpoint direction set << 982   G4cout << "Lightpoint direction set to "
1479           << vp.GetActualLightpointDirection  << 983          << vp.GetActualLightpointDirection () << G4endl;
1480         }                                     << 
1481       }                                          984       }
1482     }                                            985     }
1483   }                                              986   }
1484                                                  987 
1485   else if (command == fpCommandViewpointVecto    988   else if (command == fpCommandViewpointVector) {
1486     G4ThreeVector viewpointVector = G4UIcomma << 989     fViewpointVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
1487     if (viewpointVector.mag2() <= 0.) {       << 990     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    991     if (verbosity >= G4VisManager::confirmations) {
1584       G4cout << "Time window fade factor chan << 992       G4cout << "Viewpoint direction set to "
1585       << G4endl;                              << 993        << vp.GetViewpointDirection() << G4endl;
1586     }                                         << 994       if (vp.GetLightsMoveWithCamera ()) {
1587   }                                           << 995   G4cout << "Lightpoint direction set to "
1588                                               << 996          << 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       }                                          997       }
1612       G4cout << G4endl;                       << 
1613     }                                            998     }
1614   }                                              999   }
1615                                                  1000 
1616   else {                                         1001   else {
1617     if (verbosity >= G4VisManager::errors) {     1002     if (verbosity >= G4VisManager::errors) {
1618       G4warn <<                               << 1003       G4cout <<
1619       "ERROR: G4VisCommandsViewerSet::SetNewV << 1004   "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1620       << G4endl;                              << 1005        << G4endl;
1621     }                                            1006     }
1622     return;                                      1007     return;
1623   }                                              1008   }
1624                                                  1009 
1625   SetViewParameters(currentViewer,vp);           1010   SetViewParameters(currentViewer,vp);
1626 }                                                1011 }
1627                                                  1012