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

Last change on this file since 1346 was 1346, checked in by garnier, 15 years ago

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