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