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