source: trunk/source/visualization/management/src/G4VisCommandsViewer.cc@ 1123

Last change on this file since 1123 was 1041, checked in by garnier, 17 years ago

en test
  • Property svn:mime-type set to text/cpp
File size: 49.2 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4VisCommandsViewer.cc,v 1.75 2009/01/19 15:47:49 lgarnier Exp $
28// GEANT4 tag $Name: $
29
30// /vis/viewer commands - John Allison 25th October 1998
31
32#include "G4VisCommandsViewer.hh"
33
34#include "G4VisManager.hh"
35#include "G4GraphicsSystemList.hh"
36#include "G4VisCommandsScene.hh"
37#include "G4UImanager.hh"
38#include "G4UIcommand.hh"
39#include "G4UIcmdWithoutParameter.hh"
40#include "G4UIcmdWithAString.hh"
41#include "G4UIcmdWithADouble.hh"
42#include "G4UIcmdWithADoubleAndUnit.hh"
43#include "G4UIcmdWith3Vector.hh"
44#include "G4UnitsTable.hh"
45#include "G4ios.hh"
46#include <sstream>
47
48G4VVisCommandViewer::G4VVisCommandViewer () {}
49
50G4VVisCommandViewer::~G4VVisCommandViewer () {}
51
52void G4VVisCommandViewer::SetViewParameters
53(G4VViewer* viewer, const G4ViewParameters& viewParams) {
54 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
55 viewer->SetViewParameters(viewParams);
56 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
57 if (sceneHandler && sceneHandler->GetScene()) {
58 if (viewParams.IsAutoRefresh()) {
59 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
60 }
61 else {
62 if (verbosity >= G4VisManager::confirmations) {
63 G4cout << "Issue /vis/viewer/refresh to see effect." << G4endl;
64 }
65 }
66 }
67}
68
69////////////// /vis/viewer/addCutawayPlane ///////////////////////////////////////
70
71G4VisCommandViewerAddCutawayPlane::G4VisCommandViewerAddCutawayPlane () {
72 G4bool omitable;
73 fpCommand = new G4UIcommand ("/vis/viewer/addCutawayPlane", this);
74 fpCommand -> SetGuidance
75 ("Add cutaway plane to current viewer.");
76 G4UIparameter* parameter;
77 parameter = new G4UIparameter("x",'d',omitable = true);
78 parameter -> SetDefaultValue (0);
79 parameter -> SetGuidance ("Coordinate of point on the plane.");
80 fpCommand->SetParameter(parameter);
81 parameter = new G4UIparameter("y",'d',omitable = true);
82 parameter -> SetDefaultValue (0);
83 parameter -> SetGuidance ("Coordinate of point on the plane.");
84 fpCommand->SetParameter(parameter);
85 parameter = new G4UIparameter("z",'d',omitable = true);
86 parameter -> SetDefaultValue (0);
87 parameter -> SetGuidance ("Coordinate of point on the plane.");
88 fpCommand->SetParameter(parameter);
89 parameter = new G4UIparameter("unit",'s',omitable = true);
90 parameter -> SetDefaultValue ("m");
91 parameter -> SetGuidance ("Unit of point on the plane.");
92 fpCommand->SetParameter(parameter);
93 parameter = new G4UIparameter("nx",'d',omitable = true);
94 parameter -> SetDefaultValue (1);
95 parameter -> SetGuidance ("Component of plane normal.");
96 fpCommand->SetParameter(parameter);
97 parameter = new G4UIparameter("ny",'d',omitable = true);
98 parameter -> SetDefaultValue (0);
99 parameter -> SetGuidance ("Component of plane normal.");
100 fpCommand->SetParameter(parameter);
101 parameter = new G4UIparameter("nz",'d',omitable = true);
102 parameter -> SetDefaultValue (0);
103 parameter -> SetGuidance ("Component of plane normal.");
104 fpCommand->SetParameter(parameter);
105}
106
107G4VisCommandViewerAddCutawayPlane::~G4VisCommandViewerAddCutawayPlane () {
108 delete fpCommand;
109}
110
111G4String G4VisCommandViewerAddCutawayPlane::GetCurrentValue (G4UIcommand*) {
112 return "";
113}
114
115void G4VisCommandViewerAddCutawayPlane::SetNewValue (G4UIcommand*, G4String newValue) {
116
117 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
118
119 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
120 if (!viewer) {
121 if (verbosity >= G4VisManager::errors) {
122 G4cout <<
123 "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
124 << G4endl;
125 }
126 return;
127 }
128
129 G4double x, y, z, nx, ny, nz;
130 G4String unit;
131 std::istringstream is (newValue);
132 is >> x >> y >> z >> unit >> nx >> ny >> nz;
133 G4double F = G4UIcommand::ValueOf(unit);
134 x *= F; y *= F; z *= F;
135
136 G4ViewParameters vp = viewer->GetViewParameters();
137 vp.AddCutawayPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
138 if (verbosity >= G4VisManager::confirmations) {
139 G4cout << "Cutaway planes for viewer \"" << viewer->GetName() << "\" now:";
140 const G4Planes& cutaways = vp.GetCutawayPlanes();
141 for (size_t i = 0; i < cutaways.size(); ++i)
142 G4cout << "\n " << i << ": " << cutaways[i];
143 G4cout << G4endl;
144 }
145
146 SetViewParameters(viewer, vp);
147}
148
149////////////// /vis/viewer/changeCutawayPlane ///////////////////////////////////////
150
151G4VisCommandViewerChangeCutawayPlane::G4VisCommandViewerChangeCutawayPlane () {
152 G4bool omitable;
153 fpCommand = new G4UIcommand ("/vis/viewer/changeCutawayPlane", this);
154 fpCommand -> SetGuidance("Change cutaway plane.");
155 G4UIparameter* parameter;
156 parameter = new G4UIparameter("index",'i',omitable = false);
157 parameter -> SetGuidance ("Index of plane: 0, 1, 2.");
158 fpCommand->SetParameter(parameter);
159 parameter = new G4UIparameter("x",'d',omitable = true);
160 parameter -> SetDefaultValue (0);
161 parameter -> SetGuidance ("Coordinate of point on the plane.");
162 fpCommand->SetParameter(parameter);
163 parameter = new G4UIparameter("y",'d',omitable = true);
164 parameter -> SetDefaultValue (0);
165 parameter -> SetGuidance ("Coordinate of point on the plane.");
166 fpCommand->SetParameter(parameter);
167 parameter = new G4UIparameter("z",'d',omitable = true);
168 parameter -> SetDefaultValue (0);
169 parameter -> SetGuidance ("Coordinate of point on the plane.");
170 fpCommand->SetParameter(parameter);
171 parameter = new G4UIparameter("unit",'s',omitable = true);
172 parameter -> SetDefaultValue ("m");
173 parameter -> SetGuidance ("Unit of point on the plane.");
174 fpCommand->SetParameter(parameter);
175 parameter = new G4UIparameter("nx",'d',omitable = true);
176 parameter -> SetDefaultValue (1);
177 parameter -> SetGuidance ("Component of plane normal.");
178 fpCommand->SetParameter(parameter);
179 parameter = new G4UIparameter("ny",'d',omitable = true);
180 parameter -> SetDefaultValue (0);
181 parameter -> SetGuidance ("Component of plane normal.");
182 fpCommand->SetParameter(parameter);
183 parameter = new G4UIparameter("nz",'d',omitable = true);
184 parameter -> SetDefaultValue (0);
185 parameter -> SetGuidance ("Component of plane normal.");
186 fpCommand->SetParameter(parameter);
187}
188
189G4VisCommandViewerChangeCutawayPlane::~G4VisCommandViewerChangeCutawayPlane () {
190 delete fpCommand;
191}
192
193G4String G4VisCommandViewerChangeCutawayPlane::GetCurrentValue (G4UIcommand*) {
194 return "";
195}
196
197void G4VisCommandViewerChangeCutawayPlane::SetNewValue (G4UIcommand*, G4String newValue) {
198
199 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
200
201 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
202 if (!viewer) {
203 if (verbosity >= G4VisManager::errors) {
204 G4cout <<
205 "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
206 << G4endl;
207 }
208 return;
209 }
210
211 size_t index;
212 G4double x, y, z, nx, ny, nz;
213 G4String unit;
214 std::istringstream is (newValue);
215 is >> index >> x >> y >> z >> unit >> nx >> ny >> nz;
216 G4double F = G4UIcommand::ValueOf(unit);
217 x *= F; y *= F; z *= F;
218
219 G4ViewParameters vp = viewer->GetViewParameters();
220 vp.ChangeCutawayPlane(index,
221 G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
222 if (verbosity >= G4VisManager::confirmations) {
223 G4cout << "Cutaway planes for viewer \"" << viewer->GetName() << "\" now:";
224 const G4Planes& cutaways = vp.GetCutawayPlanes();
225 for (size_t i = 0; i < cutaways.size(); ++i)
226 G4cout << "\n " << i << ": " << cutaways[i];
227 G4cout << G4endl;
228 }
229
230 SetViewParameters(viewer, vp);
231}
232
233////////////// /vis/viewer/clear ///////////////////////////////////////
234
235G4VisCommandViewerClear::G4VisCommandViewerClear () {
236 G4bool omitable, currentAsDefault;
237 fpCommand = new G4UIcmdWithAString ("/vis/viewer/clear", this);
238 fpCommand -> SetGuidance ("Clears viewer.");
239 fpCommand -> SetGuidance
240 ("By default, clears current viewer. Specified viewer becomes current."
241 "\n\"/vis/viewer/list\" to see possible viewer names.");
242 fpCommand -> SetParameterName ("viewer-name",
243 omitable = true,
244 currentAsDefault = true);
245}
246
247G4VisCommandViewerClear::~G4VisCommandViewerClear () {
248 delete fpCommand;
249}
250
251G4String G4VisCommandViewerClear::GetCurrentValue (G4UIcommand*) {
252 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
253 return viewer ? viewer -> GetName () : G4String("none");
254}
255
256void G4VisCommandViewerClear::SetNewValue (G4UIcommand*, G4String newValue) {
257
258 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
259
260 G4String& clearName = newValue;
261 G4VViewer* viewer = fpVisManager -> GetViewer (clearName);
262 if (!viewer) {
263 if (verbosity >= G4VisManager::errors) {
264 G4cout << "ERROR: Viewer \"" << clearName
265 << "\" not found - \"/vis/viewer/list\" to see possibilities."
266 << G4endl;
267 }
268 return;
269 }
270
271#ifdef G4DEBUG_VIS_MANAGEMENT
272 printf("G4VisCommandViewerClear::SetNewValue Call ClearView()\n");
273#endif
274 viewer->ClearView();
275#ifdef G4DEBUG_VIS_MANAGEMENT
276 printf("G4VisCommandViewerClear::SetNewValue Call ClearView() END\n");
277 printf("G4VisCommandViewerClear::SetNewValue Call FinishView()\n");
278#endif
279 viewer->FinishView();
280#ifdef G4DEBUG_VIS_MANAGEMENT
281 printf("G4VisCommandViewerClear::SetNewValue Call FinishView() END\n");
282#endif
283 if (verbosity >= G4VisManager::confirmations) {
284 G4cout << "Viewer \"" << clearName << "\" cleared." << G4endl;
285 }
286
287}
288
289////////////// /vis/viewer/clearCutawayPlanes ///////////////////////////////////////
290
291G4VisCommandViewerClearCutawayPlanes::G4VisCommandViewerClearCutawayPlanes () {
292 fpCommand = new G4UIcmdWithoutParameter
293 ("/vis/viewer/clearCutawayPlanes", this);
294 fpCommand -> SetGuidance ("Clear cutaway planes of current viewer.");
295}
296
297G4VisCommandViewerClearCutawayPlanes::~G4VisCommandViewerClearCutawayPlanes () {
298 delete fpCommand;
299}
300
301G4String G4VisCommandViewerClearCutawayPlanes::GetCurrentValue (G4UIcommand*) {
302 return "";
303}
304
305void G4VisCommandViewerClearCutawayPlanes::SetNewValue (G4UIcommand*, G4String) {
306
307 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
308
309 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
310 if (!viewer) {
311 if (verbosity >= G4VisManager::errors) {
312 G4cout <<
313 "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
314 << G4endl;
315 }
316 return;
317 }
318
319 G4ViewParameters vp = viewer->GetViewParameters();
320 vp.ClearCutawayPlanes();
321 if (verbosity >= G4VisManager::confirmations) {
322 G4cout << "Cutaway planes for viewer \"" << viewer->GetName()
323 << "\" now cleared." << G4endl;
324 }
325
326 SetViewParameters(viewer, vp);
327}
328
329////////////// /vis/viewer/clearTransients //////////////////////////
330
331G4VisCommandViewerClearTransients::G4VisCommandViewerClearTransients () {
332 G4bool omitable, currentAsDefault;
333 fpCommand = new G4UIcmdWithAString ("/vis/viewer/clearTransients", this);
334 fpCommand -> SetGuidance ("Clears transients from viewer.");
335 fpCommand -> SetGuidance
336 ("By default, operates on current viewer. Specified viewer becomes current."
337 "\n\"/vis/viewer/list\" to see possible viewer names.");
338 fpCommand -> SetParameterName ("viewer-name",
339 omitable = true,
340 currentAsDefault = true);
341}
342
343G4VisCommandViewerClearTransients::~G4VisCommandViewerClearTransients () {
344 delete fpCommand;
345}
346
347G4String G4VisCommandViewerClearTransients::GetCurrentValue (G4UIcommand*) {
348 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
349 return viewer ? viewer -> GetName () : G4String("none");
350}
351
352void G4VisCommandViewerClearTransients::SetNewValue (G4UIcommand*, G4String newValue) {
353
354 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
355
356 G4String& clearName = newValue;
357 G4VViewer* viewer = fpVisManager -> GetViewer (clearName);
358 if (!viewer) {
359 if (verbosity >= G4VisManager::errors) {
360 G4cout << "ERROR: Viewer \"" << clearName
361 << "\" not found - \"/vis/viewer/list\" to see possibilities."
362 << G4endl;
363 }
364 return;
365 }
366
367 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
368 sceneHandler->SetMarkForClearingTransientStore(false);
369 fpVisManager->ResetTransientsDrawnFlags();
370 sceneHandler->ClearTransientStore();
371 if (verbosity >= G4VisManager::confirmations) {
372 G4cout << "Viewer \"" << clearName << "\" cleared of transients."
373 << G4endl;
374 }
375
376}
377
378////////////// /vis/viewer/clone ///////////////////////////////////////
379
380G4VisCommandViewerClone::G4VisCommandViewerClone () {
381 G4bool omitable;
382 fpCommand = new G4UIcommand ("/vis/viewer/clone", this);
383 fpCommand -> SetGuidance ("Clones viewer.");
384 fpCommand -> SetGuidance
385 ("By default, clones current viewer. Clone becomes current."
386 "\nClone name, if not provided, is derived from the original name."
387 "\n\"/vis/viewer/list\" to see possible viewer names.");
388 G4UIparameter* parameter;
389 parameter = new G4UIparameter ("original-viewer-name", 's', omitable = true);
390 parameter -> SetCurrentAsDefault (true);
391 fpCommand -> SetParameter (parameter);
392 parameter = new G4UIparameter ("clone-name", 's', omitable = true);
393 parameter -> SetDefaultValue ("none");
394 fpCommand -> SetParameter (parameter);
395}
396
397G4VisCommandViewerClone::~G4VisCommandViewerClone () {
398 delete fpCommand;
399}
400
401G4String G4VisCommandViewerClone::GetCurrentValue (G4UIcommand*) {
402 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
403 G4String originalName = viewer ? viewer -> GetName () : G4String("none");
404 return "\"" + originalName + "\"";
405}
406
407void G4VisCommandViewerClone::SetNewValue (G4UIcommand*, G4String newValue) {
408
409 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
410
411 G4String originalName, cloneName;
412 std::istringstream is (newValue);
413
414 // Need to handle the possibility that the names contain embedded
415 // blanks within quotation marks...
416 char c;
417 while (is.get(c) && c == ' '){}
418 if (c == '"') {
419 while (is.get(c) && c != '"') {originalName += c;}
420 }
421 else {
422 originalName += c;
423 while (is.get(c) && c != ' ') {originalName += c;}
424 }
425 originalName = originalName.strip (G4String::both, ' ');
426 originalName = originalName.strip (G4String::both, '"');
427
428 G4VViewer* originalViewer = fpVisManager -> GetViewer (originalName);
429 if (!originalViewer) {
430 if (verbosity >= G4VisManager::errors) {
431 G4cout << "ERROR: Viewer \"" << originalName
432 << "\" not found - \"/vis/viewer/list\" to see possibilities."
433 << G4endl;
434 }
435 return;
436 }
437 originalName = originalViewer->GetName(); // Ensures long name.
438
439 while (is.get(c) && c == ' '){}
440 if (c == '"') {
441 while (is.get(c) && c != '"') {cloneName += c;}
442 }
443 else {
444 cloneName += c;
445 while (is.get(c) && c != ' ') {cloneName += c;}
446 }
447 cloneName = cloneName.strip (G4String::both, ' ');
448 cloneName = cloneName.strip (G4String::both, '"');
449
450 if (cloneName == "none") {
451 G4int subID = 0;
452 do {
453 cloneName = originalName;
454 std::ostringstream oss;
455 oss << '-' << subID++;
456 G4String::size_type lastDashPosition, nextSpacePosition;
457 if ((lastDashPosition = cloneName.rfind('-')) != G4String::npos &&
458 (nextSpacePosition = cloneName.find(" ", lastDashPosition)) !=
459 G4String::npos) {
460 cloneName.insert(nextSpacePosition, oss.str());
461 } else {
462 cloneName.insert(cloneName.find(' '), oss.str());
463 }
464 } while (fpVisManager -> GetViewer (cloneName));
465 }
466
467 if (fpVisManager -> GetViewer (cloneName)) {
468 if (verbosity >= G4VisManager::errors) {
469 G4cout << "ERROR: Putative clone viewer \"" << cloneName
470 << "\" already exists."
471 << G4endl;
472 }
473 return;
474 }
475
476 G4String windowSizeHint =
477 originalViewer->GetViewParameters().GetXGeometryString();
478
479 G4UImanager* UImanager = G4UImanager::GetUIpointer();
480 G4int keepVerbose = UImanager->GetVerboseLevel();
481 G4int newVerbose(0);
482 if (keepVerbose >= 2 ||
483 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
484 newVerbose = 2;
485 UImanager->SetVerboseLevel(newVerbose);
486 UImanager->ApplyCommand(G4String("/vis/viewer/select " + originalName));
487 UImanager->ApplyCommand
488 (G4String("/vis/viewer/create ! \"" + cloneName + "\" " + windowSizeHint));
489 UImanager->ApplyCommand(G4String("/vis/viewer/set/all " + originalName));
490 UImanager->SetVerboseLevel(keepVerbose);
491
492 if (verbosity >= G4VisManager::confirmations) {
493 G4cout << "Viewer \"" << originalName << "\" cloned." << G4endl;
494 G4cout << "Clone \"" << cloneName << "\" now current." << G4endl;
495 }
496}
497
498////////////// /vis/viewer/create ///////////////////////////////////////
499
500G4VisCommandViewerCreate::G4VisCommandViewerCreate (): fId (0) {
501 G4bool omitable;
502 fpCommand = new G4UIcommand ("/vis/viewer/create", this);
503 fpCommand -> SetGuidance
504 ("Creates a viewer for the specified scene handler.");
505 fpCommand -> SetGuidance
506 ("Default scene handler is the current scene handler. Invents a name"
507 "\nif not supplied. (Note: the system adds information to the name"
508 "\nfor identification - only the characters up to the first blank are"
509 "\nused for removing, selecting, etc.) This scene handler and viewer"
510 "\nbecome current.");
511 G4UIparameter* parameter;
512 parameter = new G4UIparameter ("scene-handler", 's', omitable = true);
513 parameter -> SetCurrentAsDefault (true);
514 fpCommand -> SetParameter (parameter);
515 parameter = new G4UIparameter ("viewer-name", 's', omitable = true);
516 parameter -> SetCurrentAsDefault (true);
517 fpCommand -> SetParameter (parameter);
518 parameter = new G4UIparameter ("window-size-hint", 's', omitable = true);
519 parameter->SetGuidance
520 ("integer (pixels) for square window placed by window manager or"
521 " X-Windows-type geometry string, e.g. 600x600-100+100");
522 parameter->SetDefaultValue("600");
523 fpCommand -> SetParameter (parameter);
524}
525
526G4VisCommandViewerCreate::~G4VisCommandViewerCreate () {
527 delete fpCommand;
528}
529
530G4String G4VisCommandViewerCreate::NextName () {
531 std::ostringstream oss;
532 G4VSceneHandler* sceneHandler = fpVisManager -> GetCurrentSceneHandler ();
533 oss << "viewer-" << fId << " (";
534 if (sceneHandler) {
535 oss << sceneHandler -> GetGraphicsSystem () -> GetName ();
536 }
537 else {
538 oss << "no_scene_handlers";
539 }
540 oss << ")";
541 return oss.str();
542}
543
544G4String G4VisCommandViewerCreate::GetCurrentValue (G4UIcommand*) {
545 G4String currentValue;
546 G4VSceneHandler* currentSceneHandler =
547 fpVisManager -> GetCurrentSceneHandler ();
548 if (currentSceneHandler) {
549 currentValue = currentSceneHandler -> GetName ();
550 }
551 else {
552 currentValue = "none";
553 }
554 currentValue += ' ';
555 currentValue += '"';
556 currentValue += NextName ();
557 currentValue += '"';
558
559 currentValue += " 600"; // Default number of pixels for window size hint.
560
561 return currentValue;
562}
563
564void G4VisCommandViewerCreate::SetNewValue (G4UIcommand*, G4String newValue) {
565
566 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
567
568 G4String sceneHandlerName, newName;
569 G4String windowSizeHintString;
570 std::istringstream is (newValue);
571 is >> sceneHandlerName;
572
573 // Now need to handle the possibility that the second string
574 // contains embedded blanks within quotation marks...
575 char c;
576 while (is.get(c) && c == ' '){}
577 if (c == '"') {
578 while (is.get(c) && c != '"') {newName += c;}
579 }
580 else {
581 newName += c;
582 while (is.get(c) && c != ' ') {newName += c;}
583 }
584 newName = newName.strip (G4String::both, ' ');
585 newName = newName.strip (G4String::both, '"');
586
587 // Now get window size hint...
588 is >> windowSizeHintString;
589
590 const G4SceneHandlerList& sceneHandlerList =
591 fpVisManager -> GetAvailableSceneHandlers ();
592 G4int nHandlers = sceneHandlerList.size ();
593 if (nHandlers <= 0) {
594 if (verbosity >= G4VisManager::errors) {
595 G4cout <<
596 "ERROR: G4VisCommandViewerCreate::SetNewValue: no scene handlers."
597 "\n Create a scene handler with \"/vis/sceneHandler/create\""
598 << G4endl;
599 }
600 return;
601 }
602
603 G4int iHandler;
604 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
605 if (sceneHandlerList [iHandler] -> GetName () == sceneHandlerName) break;
606 }
607
608 if (iHandler < 0 || iHandler >= nHandlers) {
609 // Invalid command line argument or none.
610 // This shouldn't happen!!!!!!
611 if (verbosity >= G4VisManager::errors) {
612 G4cout << "G4VisCommandViewerCreate::SetNewValue:"
613 " invalid scene handler specified."
614 << G4endl;
615 }
616 return;
617 }
618
619 // Valid index. Set current scene handler and graphics system in
620 // preparation for creating viewer.
621 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
622 if (sceneHandler != fpVisManager -> GetCurrentSceneHandler ()) {
623 fpVisManager -> SetCurrentSceneHandler (sceneHandler);
624 }
625
626 // Now deal with name of viewer.
627 G4String nextName = NextName ();
628 if (newName == "") {
629 newName = nextName;
630 }
631 if (newName == nextName) fId++;
632 G4String newShortName = fpVisManager -> ViewerShortName (newName);
633
634 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
635 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
636 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
637 for (size_t iViewer = 0; iViewer < viewerList.size (); iViewer++) {
638 if (viewerList [iViewer] -> GetShortName () == newShortName ) {
639 if (verbosity >= G4VisManager::errors) {
640 G4cout << "ERROR: Viewer \"" << newShortName << "\" already exists."
641 << G4endl;
642 }
643 return;
644 }
645 }
646 }
647
648 // WindowSizeHint and XGeometryString are picked up from the vis
649 // manager in the G4VViewer constructor. In G4VisManager, after Viewer
650 // creation, we will store theses parameters in G4ViewParameters.
651
652 fpVisManager -> CreateViewer (newName,windowSizeHintString);
653
654 G4VViewer* newViewer = fpVisManager -> GetCurrentViewer ();
655 if (newViewer && newViewer -> GetName () == newName) {
656 if (verbosity >= G4VisManager::confirmations) {
657 G4cout << "New viewer \"" << newName << "\" created." << G4endl;
658 }
659 }
660 else {
661 if (verbosity >= G4VisManager::errors) {
662 if (newViewer) {
663 G4cout << "ERROR: New viewer doesn\'t match!!! Curious!!" << G4endl;
664 } else {
665 G4cout << "WARNING: No viewer created." << G4endl;
666 }
667 }
668 }
669 // Refresh if appropriate...
670 if (newViewer) {
671 if (newViewer->GetViewParameters().IsAutoRefresh()) {
672 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
673 }
674 else {
675 if (verbosity >= G4VisManager::confirmations) {
676 G4cout << "Issue /vis/viewer/refresh to see effect." << G4endl;
677 }
678 }
679 }
680}
681
682////////////// /vis/viewer/dolly and dollyTo ////////////////////////////
683
684G4VisCommandViewerDolly::G4VisCommandViewerDolly ():
685 fDollyIncrement (0.),
686 fDollyTo (0.)
687{
688 G4bool omitable, currentAsDefault;
689
690 fpCommandDolly = new G4UIcmdWithADoubleAndUnit
691 ("/vis/viewer/dolly", this);
692 fpCommandDolly -> SetGuidance
693 ("Incremental dolly.");
694 fpCommandDolly -> SetGuidance
695 ("Moves the camera incrementally towards target point.");
696 fpCommandDolly -> SetParameterName("increment",
697 omitable=true,
698 currentAsDefault=true);
699 fpCommandDolly -> SetDefaultUnit("m");
700
701 fpCommandDollyTo = new G4UIcmdWithADoubleAndUnit
702 ("/vis/viewer/dollyTo", this);
703 fpCommandDollyTo -> SetGuidance
704 ("Dolly to specific coordinate.");
705 fpCommandDollyTo -> SetGuidance
706 ("Places the camera towards target point relative to standard camera point.");
707 fpCommandDollyTo -> SetParameterName("distance",
708 omitable=true,
709 currentAsDefault=true);
710 fpCommandDollyTo -> SetDefaultUnit("m");
711}
712
713G4VisCommandViewerDolly::~G4VisCommandViewerDolly () {
714 delete fpCommandDolly;
715 delete fpCommandDollyTo;
716}
717
718G4String G4VisCommandViewerDolly::GetCurrentValue (G4UIcommand* command) {
719 G4String currentValue;
720 if (command == fpCommandDolly) {
721 currentValue = fpCommandDolly->ConvertToString(fDollyIncrement, "m");
722 }
723 else if (command == fpCommandDollyTo) {
724 currentValue = fpCommandDollyTo->ConvertToString(fDollyTo, "m");
725 }
726 return currentValue;
727}
728
729void G4VisCommandViewerDolly::SetNewValue (G4UIcommand* command,
730 G4String newValue) {
731
732
733 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
734
735 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
736 if (!currentViewer) {
737 if (verbosity >= G4VisManager::errors) {
738 G4cout <<
739 "ERROR: G4VisCommandsViewerDolly::SetNewValue: no current viewer."
740 << G4endl;
741 }
742 return;
743 }
744
745 G4ViewParameters vp = currentViewer->GetViewParameters();
746
747 if (command == fpCommandDolly) {
748 fDollyIncrement = fpCommandDolly->GetNewDoubleValue(newValue);
749 vp.IncrementDolly(fDollyIncrement);
750 }
751 else if (command == fpCommandDollyTo) {
752 fDollyTo = fpCommandDolly->GetNewDoubleValue(newValue);
753 vp.SetDolly(fDollyTo);
754 }
755
756 if (verbosity >= G4VisManager::confirmations) {
757 G4cout << "Dolly distance changed to " << vp.GetDolly() << G4endl;
758 }
759
760 SetViewParameters(currentViewer, vp);
761}
762
763////////////// /vis/viewer/flush ///////////////////////////////////////
764
765G4VisCommandViewerFlush::G4VisCommandViewerFlush () {
766 G4bool omitable, currentAsDefault;
767 fpCommand = new G4UIcmdWithAString ("/vis/viewer/flush", this);
768 fpCommand -> SetGuidance
769 ("Compound command: \"/vis/viewer/refresh\" + \"/vis/viewer/update\".");
770 fpCommand -> SetGuidance
771 ("Useful for refreshing and initiating post-processing for graphics"
772 "\nsystems which need post-processing. By default, acts on current"
773 "\nviewer. \"/vis/viewer/list\" to see possible viewers. Viewer"
774 "\nbecomes current.");
775 fpCommand -> SetParameterName ("viewer-name",
776 omitable = true,
777 currentAsDefault = true);
778}
779
780G4VisCommandViewerFlush::~G4VisCommandViewerFlush () {
781 delete fpCommand;
782}
783
784G4String G4VisCommandViewerFlush::GetCurrentValue
785(G4UIcommand*) {
786 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
787 return viewer ? viewer -> GetName () : G4String("none");
788}
789
790void G4VisCommandViewerFlush::SetNewValue (G4UIcommand*, G4String newValue) {
791
792 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
793
794 G4String& flushName = newValue;
795 G4VViewer* viewer = fpVisManager -> GetViewer (flushName);
796 if (!viewer) {
797 if (verbosity >= G4VisManager::errors) {
798 G4cout << "ERROR: Viewer \"" << flushName << "\"" <<
799 " not found - \"/vis/viewer/list\"\n to see possibilities."
800 << G4endl;
801 }
802 return;
803 }
804
805 G4UImanager* ui = G4UImanager::GetUIpointer();
806 G4int keepVerbose = ui->GetVerboseLevel();
807 G4int newVerbose(0);
808 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
809 newVerbose = 2;
810 ui->SetVerboseLevel(newVerbose);
811 ui->ApplyCommand(G4String("/vis/viewer/refresh " + flushName));
812 ui->ApplyCommand(G4String("/vis/viewer/update " + flushName));
813 ui->SetVerboseLevel(keepVerbose);
814 if (verbosity >= G4VisManager::confirmations) {
815 G4cout << "Viewer \"" << viewer -> GetName () << "\""
816 << " flushed." << G4endl;
817 }
818}
819
820////////////// /vis/viewer/list ///////////////////////////////////////
821
822G4VisCommandViewerList::G4VisCommandViewerList () {
823 G4bool omitable;
824 fpCommand = new G4UIcommand ("/vis/viewer/list", this);
825 fpCommand -> SetGuidance ("Lists viewers(s).");
826 fpCommand -> SetGuidance
827 ("See \"/vis/verbose\" for definition of verbosity.");
828 G4UIparameter* parameter;
829 parameter = new G4UIparameter("viewer-name", 's',
830 omitable = true);
831 parameter -> SetDefaultValue ("all");
832 fpCommand -> SetParameter (parameter);
833 parameter = new G4UIparameter ("verbosity", 's',
834 omitable = true);
835 parameter -> SetDefaultValue ("warnings");
836 fpCommand -> SetParameter (parameter);
837}
838
839G4VisCommandViewerList::~G4VisCommandViewerList () {
840 delete fpCommand;
841}
842
843G4String G4VisCommandViewerList::GetCurrentValue (G4UIcommand*) {
844 return "";
845}
846
847void G4VisCommandViewerList::SetNewValue (G4UIcommand*, G4String newValue) {
848 G4String name, verbosityString;
849 std::istringstream is (newValue);
850 is >> name >> verbosityString;
851 G4String shortName = fpVisManager -> ViewerShortName (name);
852 G4VisManager::Verbosity verbosity =
853 fpVisManager->GetVerbosityValue(verbosityString);
854
855 const G4VViewer* currentViewer = fpVisManager -> GetCurrentViewer ();
856 G4String currentViewerShortName;
857 if (currentViewer) {
858 currentViewerShortName = currentViewer -> GetShortName ();
859 }
860 else {
861 currentViewerShortName = "none";
862 }
863
864 const G4SceneHandlerList& sceneHandlerList = fpVisManager -> GetAvailableSceneHandlers ();
865 G4int nHandlers = sceneHandlerList.size ();
866 G4bool found = false;
867 G4bool foundCurrent = false;
868 for (int iHandler = 0; iHandler < nHandlers; iHandler++) {
869 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
870 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
871 G4cout << "Scene handler \"" << sceneHandler -> GetName ();
872 const G4Scene* pScene = sceneHandler -> GetScene ();
873 if (pScene) {
874 G4cout << "\", scene \"" << pScene -> GetName () << "\":";
875 }
876 G4int nViewers = viewerList.size ();
877 if (nViewers == 0) {
878 G4cout << "\n No viewers for this scene handler." << G4endl;
879 }
880 else {
881 for (int iViewer = 0; iViewer < nViewers; iViewer++) {
882 const G4VViewer* thisViewer = viewerList [iViewer];
883 G4String thisName = thisViewer -> GetName ();
884 G4String thisShortName = thisViewer -> GetShortName ();
885 if (name != "all") {
886 if (thisShortName != shortName) continue;
887 }
888 found = true;
889 G4cout << "\n ";
890 if (thisShortName == currentViewerShortName) {
891 foundCurrent = true;
892 G4cout << "(current)";
893 }
894 else {
895 G4cout << " ";
896 }
897 G4cout << " viewer \"" << thisName << "\"";
898 if (verbosity >= G4VisManager::parameters) {
899 G4cout << "\n " << *thisViewer;
900 }
901 }
902 }
903 G4cout << G4endl;
904 }
905
906 if (!foundCurrent) {
907 G4cout << "No valid current viewer - please create or select one."
908 << G4endl;
909 }
910
911 if (!found) {
912 G4cout << "No viewers";
913 if (name != "all") {
914 G4cout << " of name \"" << name << "\"";
915 }
916 G4cout << " found." << G4endl;
917 }
918}
919
920////////////// /vis/viewer/pan and panTo ////////////////////////////
921
922G4VisCommandViewerPan::G4VisCommandViewerPan ():
923 fPanIncrementRight (0.),
924 fPanIncrementUp (0.),
925 fPanToRight (0.),
926 fPanToUp (0.)
927{
928 G4bool omitable;
929
930 fpCommandPan = new G4UIcommand
931 ("/vis/viewer/pan", this);
932 fpCommandPan -> SetGuidance
933 ("Incremental pan.");
934 fpCommandPan -> SetGuidance
935 ("Moves the camera incrementally right and up by these amounts (as seen"
936 "\nfrom viewpoint direction).");
937 G4UIparameter* parameter;
938 parameter = new G4UIparameter("right-increment", 'd', omitable = true);
939 parameter -> SetCurrentAsDefault (true);
940 fpCommandPan -> SetParameter (parameter);
941 parameter = new G4UIparameter("up-increment", 'd', omitable = true);
942 parameter -> SetCurrentAsDefault (true);
943 fpCommandPan -> SetParameter (parameter);
944 parameter = new G4UIparameter ("unit", 's', omitable = true);
945 parameter -> SetDefaultValue ("m");
946 fpCommandPan -> SetParameter (parameter);
947
948 fpCommandPanTo = new G4UIcommand
949 ("/vis/viewer/panTo", this);
950 fpCommandPanTo -> SetGuidance
951 ("Pan to specific coordinate.");
952 fpCommandPanTo -> SetGuidance
953 ("Places the camera in this position right and up relative to standard"
954 "\ntarget point (as seen from viewpoint direction).");
955 parameter = new G4UIparameter("right", 'd', omitable = true);
956 parameter -> SetCurrentAsDefault (true);
957 fpCommandPanTo -> SetParameter (parameter);
958 parameter = new G4UIparameter("up", 'd', omitable = true);
959 parameter -> SetCurrentAsDefault (true);
960 fpCommandPanTo -> SetParameter (parameter);
961 parameter = new G4UIparameter ("unit", 's', omitable = true);
962 parameter -> SetDefaultValue ("m");
963 fpCommandPanTo -> SetParameter (parameter);
964}
965
966G4VisCommandViewerPan::~G4VisCommandViewerPan () {
967 delete fpCommandPan;
968 delete fpCommandPanTo;
969}
970
971G4String G4VisCommandViewerPan::GetCurrentValue (G4UIcommand* command) {
972 G4String currentValue;
973 if (command == fpCommandPan) {
974 currentValue = ConvertToString(fPanIncrementRight, fPanIncrementUp, "m");
975 }
976 else if (command == fpCommandPanTo) {
977 currentValue = ConvertToString(fPanToRight, fPanToUp, "m");
978 }
979 return currentValue;
980}
981
982void G4VisCommandViewerPan::SetNewValue (G4UIcommand* command,
983 G4String newValue) {
984
985
986 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
987
988 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
989 if (!currentViewer) {
990 if (verbosity >= G4VisManager::errors) {
991 G4cout <<
992 "ERROR: G4VisCommandsViewerPan::SetNewValue: no current viewer."
993 << G4endl;
994 }
995 return;
996 }
997
998 G4ViewParameters vp = currentViewer->GetViewParameters();
999
1000 if (command == fpCommandPan) {
1001 ConvertToDoublePair(newValue, fPanIncrementRight, fPanIncrementUp);
1002 vp.IncrementPan(fPanIncrementRight, fPanIncrementUp);
1003 }
1004 else if (command == fpCommandPanTo) {
1005 ConvertToDoublePair(newValue, fPanToRight, fPanToUp);
1006 vp.SetPan(fPanToRight, fPanToUp);
1007 }
1008
1009 if (verbosity >= G4VisManager::confirmations) {
1010 G4cout << "Current target point now " << vp.GetCurrentTargetPoint()
1011 << G4endl;
1012 }
1013
1014 SetViewParameters(currentViewer, vp);
1015}
1016
1017////////////// /vis/viewer/rebuild ///////////////////////////////////////
1018
1019G4VisCommandViewerRebuild::G4VisCommandViewerRebuild () {
1020 G4bool omitable, currentAsDefault;
1021 fpCommand = new G4UIcmdWithAString ("/vis/viewer/rebuild", this);
1022 fpCommand -> SetGuidance ("Forces rebuild of graphical database.");
1023 fpCommand -> SetGuidance
1024 ("By default, acts on current viewer. \"/vis/viewer/list\""
1025 "\nto see possible viewers. Viewer becomes current.");
1026 fpCommand -> SetParameterName ("viewer-name",
1027 omitable = true,
1028 currentAsDefault = true);
1029}
1030
1031G4VisCommandViewerRebuild::~G4VisCommandViewerRebuild () {
1032 delete fpCommand;
1033}
1034
1035G4String G4VisCommandViewerRebuild::GetCurrentValue (G4UIcommand*) {
1036 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1037 if (viewer) {
1038 return viewer -> GetName ();
1039 }
1040 else {
1041 return "none";
1042 }
1043}
1044
1045void G4VisCommandViewerRebuild::SetNewValue (G4UIcommand*, G4String newValue) {
1046
1047 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1048
1049 G4String& rebuildName = newValue;
1050 G4VViewer* viewer = fpVisManager -> GetViewer (rebuildName);
1051 if (!viewer) {
1052 if (verbosity >= G4VisManager::errors) {
1053 G4cout << "ERROR: Viewer \"" << rebuildName
1054 << "\" not found - \"/vis/viewer/list\" to see possibilities."
1055 << G4endl;
1056 }
1057 return;
1058 }
1059
1060 viewer->NeedKernelVisit();
1061
1062 // Check auto-refresh and print confirmations, but without changing
1063 // view paramters...
1064 SetViewParameters(viewer, viewer->GetViewParameters());
1065}
1066
1067////////////// /vis/viewer/refresh ///////////////////////////////////////
1068
1069G4VisCommandViewerRefresh::G4VisCommandViewerRefresh () {
1070 G4bool omitable, currentAsDefault;
1071 fpCommand = new G4UIcmdWithAString ("/vis/viewer/refresh", this);
1072 fpCommand -> SetGuidance
1073 ("Refreshes viewer.");
1074 fpCommand -> SetGuidance
1075 ("By default, acts on current viewer. \"/vis/viewer/list\""
1076 "\nto see possible viewers. Viewer becomes current.");
1077 fpCommand -> SetParameterName ("viewer-name",
1078 omitable = true,
1079 currentAsDefault = true);
1080}
1081
1082G4VisCommandViewerRefresh::~G4VisCommandViewerRefresh () {
1083 delete fpCommand;
1084}
1085
1086G4String G4VisCommandViewerRefresh::GetCurrentValue (G4UIcommand*) {
1087 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1088 return viewer ? viewer -> GetName () : G4String("none");
1089}
1090
1091void G4VisCommandViewerRefresh::SetNewValue (G4UIcommand*, G4String newValue) {
1092
1093 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1094 G4bool warn(verbosity >= G4VisManager::warnings);
1095
1096 G4String& refreshName = newValue;
1097 G4VViewer* viewer = fpVisManager -> GetViewer (refreshName);
1098 if (!viewer) {
1099 if (verbosity >= G4VisManager::errors) {
1100 G4cout << "ERROR: Viewer \"" << refreshName << "\"" <<
1101 " not found - \"/vis/viewer/list\"\n to see possibilities."
1102 << G4endl;
1103 }
1104 return;
1105 }
1106
1107 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1108 if (!sceneHandler) {
1109 if (verbosity >= G4VisManager::errors) {
1110 G4cout << "ERROR: Viewer \"" << refreshName << "\"" <<
1111 " has no scene handler - report serious bug."
1112 << G4endl;
1113 }
1114 return;
1115 }
1116
1117 G4Scene* scene = sceneHandler->GetScene();
1118 if (!scene) {
1119 if (verbosity >= G4VisManager::confirmations) {
1120 G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
1121 << "\", to which viewer \"" << refreshName << "\"" <<
1122 "\n is attached, has no scene - \"/vis/scene/create\" and"
1123 " \"/vis/sceneHandler/attach\""
1124 "\n (or use compound command \"/vis/drawVolume\")."
1125 << G4endl;
1126 }
1127 return;
1128 }
1129 if (scene->GetRunDurationModelList().empty()) {
1130 G4bool successful = scene -> AddWorldIfEmpty (warn);
1131 if (!successful) {
1132 if (verbosity >= G4VisManager::warnings) {
1133 G4cout <<
1134 "WARNING: Scene is empty. Perhaps no geometry exists."
1135 "\n Try /run/initialize."
1136 << G4endl;
1137 }
1138 return;
1139 }
1140 // Scene has changed. UpdateVisManagerScene issues
1141 // /vis/scene/notifyHandlers, which does a refresh anyway, so the
1142 // ordinary refresh becomes part of the else phrase...
1143 UpdateVisManagerScene(scene->GetName());
1144 } else {
1145 if (verbosity >= G4VisManager::confirmations) {
1146 G4cout << "Refreshing viewer \"" << viewer -> GetName () << "\"..."
1147 << G4endl;
1148 }
1149#ifdef G4DEBUG_VIS_MANAGEMENT
1150 printf("G4VisCommandViewerRefresh::SetNewValue Call SetView()\n");
1151#endif
1152 viewer -> SetView ();
1153#ifdef G4DEBUG_VIS_MANAGEMENT
1154 printf("G4VisCommandViewerRefresh::SetNewValue Call SetView() END\n");
1155 printf("G4VisCommandViewerRefresh::SetNewValue Call ClearView()\n");
1156#endif
1157 viewer -> ClearView ();
1158#ifdef G4DEBUG_VIS_MANAGEMENT
1159 printf("G4VisCommandViewerRefresh::SetNewValue Call ClearView() END\n");
1160 printf("G4VisCommandViewerRefresh::SetNewValue Call DrawView()\n");
1161#endif
1162 viewer -> DrawView ();
1163#ifdef G4DEBUG_VIS_MANAGEMENT
1164 printf("G4VisCommandViewerRefresh::SetNewValue Call DrawView() END\n");
1165#endif
1166 if (verbosity >= G4VisManager::confirmations) {
1167 G4cout << "Viewer \"" << viewer -> GetName () << "\"" << " refreshed."
1168 "\n (You might also need \"/vis/viewer/update\".)" << G4endl;
1169 }
1170 }
1171}
1172
1173////////////// /vis/viewer/reset ///////////////////////////////////////
1174
1175G4VisCommandViewerReset::G4VisCommandViewerReset () {
1176 G4bool omitable, currentAsDefault;
1177 fpCommand = new G4UIcmdWithAString ("/vis/viewer/reset", this);
1178 fpCommand -> SetGuidance ("Resets viewer.");
1179 fpCommand -> SetGuidance
1180 ("By default, acts on current viewer. \"/vis/viewer/list\""
1181 "\nto see possible viewers. Viewer becomes current.");
1182 fpCommand -> SetParameterName ("viewer-name",
1183 omitable = true,
1184 currentAsDefault = true);
1185}
1186
1187G4VisCommandViewerReset::~G4VisCommandViewerReset () {
1188 delete fpCommand;
1189}
1190
1191G4String G4VisCommandViewerReset::GetCurrentValue (G4UIcommand*) {
1192 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1193 if (viewer) {
1194 return viewer -> GetName ();
1195 }
1196 else {
1197 return "none";
1198 }
1199}
1200
1201void G4VisCommandViewerReset::SetNewValue (G4UIcommand*, G4String newValue) {
1202
1203 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1204
1205 G4String& resetName = newValue;
1206 G4VViewer* viewer = fpVisManager -> GetViewer (resetName);
1207 if (!viewer) {
1208 if (verbosity >= G4VisManager::errors) {
1209 G4cout << "ERROR: Viewer \"" << resetName
1210 << "\" not found - \"/vis/viewer/list\" to see possibilities."
1211 << G4endl;
1212 }
1213 return;
1214 }
1215
1216 SetViewParameters(viewer, viewer->GetDefaultViewParameters());
1217}
1218
1219////////////// /vis/viewer/scale and scaleTo ////////////////////////////
1220
1221G4VisCommandViewerScale::G4VisCommandViewerScale ():
1222 fScaleMultiplier (G4Vector3D (1., 1., 1.)),
1223 fScaleTo (G4Vector3D (1., 1., 1.))
1224{
1225 G4bool omitable, currentAsDefault;
1226
1227 fpCommandScale = new G4UIcmdWith3Vector
1228 ("/vis/viewer/scale", this);
1229 fpCommandScale -> SetGuidance ("Incremental (non-uniform) scaling.");
1230 fpCommandScale -> SetGuidance
1231 ("Multiplies components of current scaling by components of this factor."
1232 "\n Scales (x,y,z) by corresponding components of the resulting factor.");
1233 fpCommandScale -> SetGuidance
1234 ("");
1235 fpCommandScale -> SetParameterName
1236 ("x-scale-multiplier","y-scale-multiplier","z-scale-multiplier",
1237 omitable=true, currentAsDefault=true);
1238
1239 fpCommandScaleTo = new G4UIcmdWith3Vector
1240 ("/vis/viewer/scaleTo", this);
1241 fpCommandScaleTo -> SetGuidance ("Absolute (non-uniform) scaling.");
1242 fpCommandScaleTo -> SetGuidance
1243 ("Scales (x,y,z) by corresponding components of this factor.");
1244 fpCommandScaleTo -> SetParameterName
1245 ("x-scale-factor","y-scale-factor","z-scale-factor",
1246 omitable=true, currentAsDefault=true);
1247}
1248
1249G4VisCommandViewerScale::~G4VisCommandViewerScale () {
1250 delete fpCommandScale;
1251 delete fpCommandScaleTo;
1252}
1253
1254G4String G4VisCommandViewerScale::GetCurrentValue (G4UIcommand* command) {
1255 G4String currentValue;
1256 if (command == fpCommandScale) {
1257 currentValue = fpCommandScale->ConvertToString(G4ThreeVector(fScaleMultiplier));
1258 }
1259 else if (command == fpCommandScaleTo) {
1260 currentValue = fpCommandScaleTo->ConvertToString(G4ThreeVector(fScaleTo));
1261 }
1262 return currentValue;
1263}
1264
1265void G4VisCommandViewerScale::SetNewValue (G4UIcommand* command,
1266 G4String newValue) {
1267
1268
1269 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1270
1271 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1272 if (!currentViewer) {
1273 if (verbosity >= G4VisManager::errors) {
1274 G4cout <<
1275 "ERROR: G4VisCommandsViewerScale::SetNewValue: no current viewer."
1276 << G4endl;
1277 }
1278 return;
1279 }
1280
1281 G4ViewParameters vp = currentViewer->GetViewParameters();
1282
1283 if (command == fpCommandScale) {
1284 fScaleMultiplier = fpCommandScale->GetNew3VectorValue(newValue);
1285 vp.MultiplyScaleFactor(fScaleMultiplier);
1286 }
1287 else if (command == fpCommandScaleTo) {
1288 fScaleTo = fpCommandScale->GetNew3VectorValue(newValue);
1289 vp.SetScaleFactor(fScaleTo);
1290 }
1291
1292 if (verbosity >= G4VisManager::confirmations) {
1293 G4cout << "Scale factor changed to " << vp.GetScaleFactor() << G4endl;
1294 }
1295
1296 SetViewParameters(currentViewer, vp);
1297}
1298
1299////////////// /vis/viewer/select ///////////////////////////////////////
1300
1301G4VisCommandViewerSelect::G4VisCommandViewerSelect () {
1302 G4bool omitable;
1303 fpCommand = new G4UIcmdWithAString ("/vis/viewer/select", this);
1304 fpCommand -> SetGuidance ("Selects viewer.");
1305 fpCommand -> SetGuidance
1306 ("Specify viewer by name. \"/vis/viewer/list\" to see possible viewers.");
1307 fpCommand -> SetParameterName ("viewer-name", omitable = false);
1308}
1309
1310G4VisCommandViewerSelect::~G4VisCommandViewerSelect () {
1311 delete fpCommand;
1312}
1313
1314G4String G4VisCommandViewerSelect::GetCurrentValue (G4UIcommand*) {
1315 return "";
1316}
1317
1318void G4VisCommandViewerSelect::SetNewValue (G4UIcommand*, G4String newValue) {
1319
1320 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1321
1322 G4String& selectName = newValue;
1323 G4VViewer* viewer = fpVisManager -> GetViewer (selectName);
1324
1325 if (!viewer) {
1326 if (verbosity >= G4VisManager::errors) {
1327 G4cout << "ERROR: Viewer \"" << selectName << "\"";
1328 G4cout << " not found - \"/vis/viewer/list\""
1329 "\n to see possibilities."
1330 << G4endl;
1331 }
1332 return;
1333 }
1334
1335 if (viewer == fpVisManager -> GetCurrentViewer ()) {
1336 if (verbosity >= G4VisManager::warnings) {
1337 G4cout << "WARNING: Viewer \"" << viewer -> GetName () << "\""
1338 << " already selected." << G4endl;
1339 }
1340 return;
1341 }
1342
1343 fpVisManager -> SetCurrentViewer (viewer); // Prints confirmation.
1344
1345 SetViewParameters(viewer, viewer->GetViewParameters());
1346}
1347
1348////////////// /vis/viewer/update ///////////////////////////////////////
1349
1350G4VisCommandViewerUpdate::G4VisCommandViewerUpdate () {
1351 G4bool omitable, currentAsDefault;
1352 fpCommand = new G4UIcmdWithAString ("/vis/viewer/update", this);
1353 fpCommand -> SetGuidance
1354 ("Triggers graphical database post-processing for viewers"
1355 "\nusing that technique.");
1356 fpCommand -> SetGuidance
1357 ("For such viewers the view only becomes visible with this command."
1358 "\nBy default, acts on current viewer. \"/vis/viewer/list\""
1359 "\nto see possible viewers. Viewer becomes current.");
1360 fpCommand -> SetParameterName ("viewer-name",
1361 omitable = true,
1362 currentAsDefault = true);
1363}
1364
1365G4VisCommandViewerUpdate::~G4VisCommandViewerUpdate () {
1366 delete fpCommand;
1367}
1368
1369G4String G4VisCommandViewerUpdate::GetCurrentValue (G4UIcommand*) {
1370 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1371 if (viewer) {
1372 return viewer -> GetName ();
1373 }
1374 else {
1375 return "none";
1376 }
1377}
1378
1379void G4VisCommandViewerUpdate::SetNewValue (G4UIcommand*, G4String newValue) {
1380
1381 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1382
1383 G4String& updateName = newValue;
1384
1385 G4VViewer* viewer = fpVisManager -> GetViewer (updateName);
1386 if (!viewer) {
1387 if (verbosity >= G4VisManager::errors) {
1388 G4cout <<
1389 "ERROR: G4VisCommandsViewerUpdate::SetNewValue: no current viewer."
1390 << G4endl;
1391 }
1392 return;
1393 }
1394
1395 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1396 if (!sceneHandler) {
1397 if (verbosity >= G4VisManager::errors) {
1398 G4cout << "ERROR: Viewer \"" << updateName << "\"" <<
1399 " has no scene handler - report serious bug."
1400 << G4endl;
1401 }
1402 return;
1403 }
1404
1405 G4Scene* scene = sceneHandler->GetScene();
1406 if (!scene) {
1407 if (verbosity >= G4VisManager::confirmations) {
1408 G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
1409 << "\", to which viewer \"" << updateName << "\"" <<
1410 "\n is attached, has no scene - \"/vis/scene/create\" and"
1411 " \"/vis/sceneHandler/attach\""
1412 "\n (or use compound command \"/vis/drawVolume\")."
1413 << G4endl;
1414 }
1415 return;
1416 }
1417
1418 if (viewer) {
1419 if (verbosity >= G4VisManager::confirmations) {
1420 G4cout << "Viewer \"" << viewer -> GetName () << "\"";
1421 G4cout << " post-processing triggered." << G4endl;
1422 }
1423 viewer -> ShowView ();
1424 // Assume future need to "refresh" transients...
1425 sceneHandler -> SetMarkForClearingTransientStore(true);
1426 }
1427 else {
1428 if (verbosity >= G4VisManager::errors) {
1429 G4cout << "ERROR: Viewer \"" << updateName << "\"";
1430 G4cout << " not found - \"/vis/viewer/list\""
1431 "\n to see possibilities." << G4endl;
1432 }
1433 }
1434}
1435
1436////////////// /vis/viewer/zoom and zoomTo ////////////////////////////
1437
1438G4VisCommandViewerZoom::G4VisCommandViewerZoom ():
1439 fZoomMultiplier (1.),
1440 fZoomTo (1.)
1441{
1442 G4bool omitable, currentAsDefault;
1443
1444 fpCommandZoom = new G4UIcmdWithADouble
1445 ("/vis/viewer/zoom", this);
1446 fpCommandZoom -> SetGuidance ("Incremental zoom.");
1447 fpCommandZoom -> SetGuidance
1448 ("Multiplies current magnification by this factor.");
1449 fpCommandZoom -> SetParameterName("multiplier",
1450 omitable=true,
1451 currentAsDefault=true);
1452
1453 fpCommandZoomTo = new G4UIcmdWithADouble
1454 ("/vis/viewer/zoomTo", this);
1455 fpCommandZoomTo -> SetGuidance ("Absolute zoom.");
1456 fpCommandZoomTo -> SetGuidance
1457 ("Magnifies standard magnification by this factor.");
1458 fpCommandZoomTo -> SetParameterName("factor",
1459 omitable=true,
1460 currentAsDefault=true);
1461}
1462
1463G4VisCommandViewerZoom::~G4VisCommandViewerZoom () {
1464 delete fpCommandZoom;
1465 delete fpCommandZoomTo;
1466}
1467
1468G4String G4VisCommandViewerZoom::GetCurrentValue (G4UIcommand* command) {
1469 G4String currentValue;
1470 if (command == fpCommandZoom) {
1471 currentValue = fpCommandZoom->ConvertToString(fZoomMultiplier);
1472 }
1473 else if (command == fpCommandZoomTo) {
1474 currentValue = fpCommandZoomTo->ConvertToString(fZoomTo);
1475 }
1476 return currentValue;
1477}
1478
1479void G4VisCommandViewerZoom::SetNewValue (G4UIcommand* command,
1480 G4String newValue) {
1481
1482
1483 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1484
1485 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1486 if (!currentViewer) {
1487 if (verbosity >= G4VisManager::errors) {
1488 G4cout <<
1489 "ERROR: G4VisCommandsViewerZoom::SetNewValue: no current viewer."
1490 << G4endl;
1491 }
1492 return;
1493 }
1494
1495 G4ViewParameters vp = currentViewer->GetViewParameters();
1496
1497 if (command == fpCommandZoom) {
1498 fZoomMultiplier = fpCommandZoom->GetNewDoubleValue(newValue);
1499 vp.MultiplyZoomFactor(fZoomMultiplier);
1500 }
1501 else if (command == fpCommandZoomTo) {
1502 fZoomTo = fpCommandZoom->GetNewDoubleValue(newValue);
1503 vp.SetZoomFactor(fZoomTo);
1504 }
1505
1506 if (verbosity >= G4VisManager::confirmations) {
1507 G4cout << "Zoom factor changed to " << vp.GetZoomFactor() << G4endl;
1508 }
1509
1510 SetViewParameters(currentViewer, vp);
1511}
Note: See TracBrowser for help on using the repository browser.