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