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