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

Last change on this file since 1168 was 1136, checked in by garnier, 16 years ago

debug updates
  • Property svn:mime-type set to text/cpp
File size: 49.3 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#ifdef G4DEBUG_VIS_MANAGEMENT
567 printf("G4VisCommandViewerCreate::SetNewValue : %s\n",newValue.c_str());
568#endif
569 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
570
571 G4String sceneHandlerName, newName;
572 G4String windowSizeHintString;
573 std::istringstream is (newValue);
574 is >> sceneHandlerName;
575
576 // Now need to handle the possibility that the second string
577 // contains embedded blanks within quotation marks...
578 char c;
579 while (is.get(c) && c == ' '){}
580 if (c == '"') {
581 while (is.get(c) && c != '"') {newName += c;}
582 }
583 else {
584 newName += c;
585 while (is.get(c) && c != ' ') {newName += c;}
586 }
587 newName = newName.strip (G4String::both, ' ');
588 newName = newName.strip (G4String::both, '"');
589
590 // Now get window size hint...
591 is >> windowSizeHintString;
592
593 const G4SceneHandlerList& sceneHandlerList =
594 fpVisManager -> GetAvailableSceneHandlers ();
595 G4int nHandlers = sceneHandlerList.size ();
596 if (nHandlers <= 0) {
597 if (verbosity >= G4VisManager::errors) {
598 G4cout <<
599 "ERROR: G4VisCommandViewerCreate::SetNewValue: no scene handlers."
600 "\n Create a scene handler with \"/vis/sceneHandler/create\""
601 << G4endl;
602 }
603 return;
604 }
605
606 G4int iHandler;
607 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
608 if (sceneHandlerList [iHandler] -> GetName () == sceneHandlerName) break;
609 }
610
611 if (iHandler < 0 || iHandler >= nHandlers) {
612 // Invalid command line argument or none.
613 // This shouldn't happen!!!!!!
614 if (verbosity >= G4VisManager::errors) {
615 G4cout << "G4VisCommandViewerCreate::SetNewValue:"
616 " invalid scene handler specified."
617 << G4endl;
618 }
619 return;
620 }
621
622 // Valid index. Set current scene handler and graphics system in
623 // preparation for creating viewer.
624 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
625 if (sceneHandler != fpVisManager -> GetCurrentSceneHandler ()) {
626 fpVisManager -> SetCurrentSceneHandler (sceneHandler);
627 }
628
629 // Now deal with name of viewer.
630 G4String nextName = NextName ();
631 if (newName == "") {
632 newName = nextName;
633 }
634 if (newName == nextName) fId++;
635 G4String newShortName = fpVisManager -> ViewerShortName (newName);
636
637 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
638 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
639 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
640 for (size_t iViewer = 0; iViewer < viewerList.size (); iViewer++) {
641 if (viewerList [iViewer] -> GetShortName () == newShortName ) {
642 if (verbosity >= G4VisManager::errors) {
643 G4cout << "ERROR: Viewer \"" << newShortName << "\" already exists."
644 << G4endl;
645 }
646 return;
647 }
648 }
649 }
650
651 // WindowSizeHint and XGeometryString are picked up from the vis
652 // manager in the G4VViewer constructor. In G4VisManager, after Viewer
653 // creation, we will store theses parameters in G4ViewParameters.
654
655 fpVisManager -> CreateViewer (newName,windowSizeHintString);
656
657 G4VViewer* newViewer = fpVisManager -> GetCurrentViewer ();
658 if (newViewer && newViewer -> GetName () == newName) {
659 if (verbosity >= G4VisManager::confirmations) {
660 G4cout << "New viewer \"" << newName << "\" created." << G4endl;
661 }
662 }
663 else {
664 if (verbosity >= G4VisManager::errors) {
665 if (newViewer) {
666 G4cout << "ERROR: New viewer doesn\'t match!!! Curious!!" << G4endl;
667 } else {
668 G4cout << "WARNING: No viewer created." << G4endl;
669 }
670 }
671 }
672 // Refresh if appropriate...
673 if (newViewer) {
674 if (newViewer->GetViewParameters().IsAutoRefresh()) {
675 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
676 }
677 else {
678 if (verbosity >= G4VisManager::confirmations) {
679 G4cout << "Issue /vis/viewer/refresh to see effect." << G4endl;
680 }
681 }
682 }
683}
684
685////////////// /vis/viewer/dolly and dollyTo ////////////////////////////
686
687G4VisCommandViewerDolly::G4VisCommandViewerDolly ():
688 fDollyIncrement (0.),
689 fDollyTo (0.)
690{
691 G4bool omitable, currentAsDefault;
692
693 fpCommandDolly = new G4UIcmdWithADoubleAndUnit
694 ("/vis/viewer/dolly", this);
695 fpCommandDolly -> SetGuidance
696 ("Incremental dolly.");
697 fpCommandDolly -> SetGuidance
698 ("Moves the camera incrementally towards target point.");
699 fpCommandDolly -> SetParameterName("increment",
700 omitable=true,
701 currentAsDefault=true);
702 fpCommandDolly -> SetDefaultUnit("m");
703
704 fpCommandDollyTo = new G4UIcmdWithADoubleAndUnit
705 ("/vis/viewer/dollyTo", this);
706 fpCommandDollyTo -> SetGuidance
707 ("Dolly to specific coordinate.");
708 fpCommandDollyTo -> SetGuidance
709 ("Places the camera towards target point relative to standard camera point.");
710 fpCommandDollyTo -> SetParameterName("distance",
711 omitable=true,
712 currentAsDefault=true);
713 fpCommandDollyTo -> SetDefaultUnit("m");
714}
715
716G4VisCommandViewerDolly::~G4VisCommandViewerDolly () {
717 delete fpCommandDolly;
718 delete fpCommandDollyTo;
719}
720
721G4String G4VisCommandViewerDolly::GetCurrentValue (G4UIcommand* command) {
722 G4String currentValue;
723 if (command == fpCommandDolly) {
724 currentValue = fpCommandDolly->ConvertToString(fDollyIncrement, "m");
725 }
726 else if (command == fpCommandDollyTo) {
727 currentValue = fpCommandDollyTo->ConvertToString(fDollyTo, "m");
728 }
729 return currentValue;
730}
731
732void G4VisCommandViewerDolly::SetNewValue (G4UIcommand* command,
733 G4String newValue) {
734
735
736 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
737
738 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
739 if (!currentViewer) {
740 if (verbosity >= G4VisManager::errors) {
741 G4cout <<
742 "ERROR: G4VisCommandsViewerDolly::SetNewValue: no current viewer."
743 << G4endl;
744 }
745 return;
746 }
747
748 G4ViewParameters vp = currentViewer->GetViewParameters();
749
750 if (command == fpCommandDolly) {
751 fDollyIncrement = fpCommandDolly->GetNewDoubleValue(newValue);
752 vp.IncrementDolly(fDollyIncrement);
753 }
754 else if (command == fpCommandDollyTo) {
755 fDollyTo = fpCommandDolly->GetNewDoubleValue(newValue);
756 vp.SetDolly(fDollyTo);
757 }
758
759 if (verbosity >= G4VisManager::confirmations) {
760 G4cout << "Dolly distance changed to " << vp.GetDolly() << G4endl;
761 }
762
763 SetViewParameters(currentViewer, vp);
764}
765
766////////////// /vis/viewer/flush ///////////////////////////////////////
767
768G4VisCommandViewerFlush::G4VisCommandViewerFlush () {
769 G4bool omitable, currentAsDefault;
770 fpCommand = new G4UIcmdWithAString ("/vis/viewer/flush", this);
771 fpCommand -> SetGuidance
772 ("Compound command: \"/vis/viewer/refresh\" + \"/vis/viewer/update\".");
773 fpCommand -> SetGuidance
774 ("Useful for refreshing and initiating post-processing for graphics"
775 "\nsystems which need post-processing. By default, acts on current"
776 "\nviewer. \"/vis/viewer/list\" to see possible viewers. Viewer"
777 "\nbecomes current.");
778 fpCommand -> SetParameterName ("viewer-name",
779 omitable = true,
780 currentAsDefault = true);
781}
782
783G4VisCommandViewerFlush::~G4VisCommandViewerFlush () {
784 delete fpCommand;
785}
786
787G4String G4VisCommandViewerFlush::GetCurrentValue
788(G4UIcommand*) {
789 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
790 return viewer ? viewer -> GetName () : G4String("none");
791}
792
793void G4VisCommandViewerFlush::SetNewValue (G4UIcommand*, G4String newValue) {
794
795 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
796
797 G4String& flushName = newValue;
798 G4VViewer* viewer = fpVisManager -> GetViewer (flushName);
799 if (!viewer) {
800 if (verbosity >= G4VisManager::errors) {
801 G4cout << "ERROR: Viewer \"" << flushName << "\"" <<
802 " not found - \"/vis/viewer/list\"\n to see possibilities."
803 << G4endl;
804 }
805 return;
806 }
807
808 G4UImanager* ui = G4UImanager::GetUIpointer();
809 G4int keepVerbose = ui->GetVerboseLevel();
810 G4int newVerbose(0);
811 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
812 newVerbose = 2;
813 ui->SetVerboseLevel(newVerbose);
814 ui->ApplyCommand(G4String("/vis/viewer/refresh " + flushName));
815 ui->ApplyCommand(G4String("/vis/viewer/update " + flushName));
816 ui->SetVerboseLevel(keepVerbose);
817 if (verbosity >= G4VisManager::confirmations) {
818 G4cout << "Viewer \"" << viewer -> GetName () << "\""
819 << " flushed." << G4endl;
820 }
821}
822
823////////////// /vis/viewer/list ///////////////////////////////////////
824
825G4VisCommandViewerList::G4VisCommandViewerList () {
826 G4bool omitable;
827 fpCommand = new G4UIcommand ("/vis/viewer/list", this);
828 fpCommand -> SetGuidance ("Lists viewers(s).");
829 fpCommand -> SetGuidance
830 ("See \"/vis/verbose\" for definition of verbosity.");
831 G4UIparameter* parameter;
832 parameter = new G4UIparameter("viewer-name", 's',
833 omitable = true);
834 parameter -> SetDefaultValue ("all");
835 fpCommand -> SetParameter (parameter);
836 parameter = new G4UIparameter ("verbosity", 's',
837 omitable = true);
838 parameter -> SetDefaultValue ("warnings");
839 fpCommand -> SetParameter (parameter);
840}
841
842G4VisCommandViewerList::~G4VisCommandViewerList () {
843 delete fpCommand;
844}
845
846G4String G4VisCommandViewerList::GetCurrentValue (G4UIcommand*) {
847 return "";
848}
849
850void G4VisCommandViewerList::SetNewValue (G4UIcommand*, G4String newValue) {
851 G4String name, verbosityString;
852 std::istringstream is (newValue);
853 is >> name >> verbosityString;
854 G4String shortName = fpVisManager -> ViewerShortName (name);
855 G4VisManager::Verbosity verbosity =
856 fpVisManager->GetVerbosityValue(verbosityString);
857
858 const G4VViewer* currentViewer = fpVisManager -> GetCurrentViewer ();
859 G4String currentViewerShortName;
860 if (currentViewer) {
861 currentViewerShortName = currentViewer -> GetShortName ();
862 }
863 else {
864 currentViewerShortName = "none";
865 }
866
867 const G4SceneHandlerList& sceneHandlerList = fpVisManager -> GetAvailableSceneHandlers ();
868 G4int nHandlers = sceneHandlerList.size ();
869 G4bool found = false;
870 G4bool foundCurrent = false;
871 for (int iHandler = 0; iHandler < nHandlers; iHandler++) {
872 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
873 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
874 G4cout << "Scene handler \"" << sceneHandler -> GetName ();
875 const G4Scene* pScene = sceneHandler -> GetScene ();
876 if (pScene) {
877 G4cout << "\", scene \"" << pScene -> GetName () << "\":";
878 }
879 G4int nViewers = viewerList.size ();
880 if (nViewers == 0) {
881 G4cout << "\n No viewers for this scene handler." << G4endl;
882 }
883 else {
884 for (int iViewer = 0; iViewer < nViewers; iViewer++) {
885 const G4VViewer* thisViewer = viewerList [iViewer];
886 G4String thisName = thisViewer -> GetName ();
887 G4String thisShortName = thisViewer -> GetShortName ();
888 if (name != "all") {
889 if (thisShortName != shortName) continue;
890 }
891 found = true;
892 G4cout << "\n ";
893 if (thisShortName == currentViewerShortName) {
894 foundCurrent = true;
895 G4cout << "(current)";
896 }
897 else {
898 G4cout << " ";
899 }
900 G4cout << " viewer \"" << thisName << "\"";
901 if (verbosity >= G4VisManager::parameters) {
902 G4cout << "\n " << *thisViewer;
903 }
904 }
905 }
906 G4cout << G4endl;
907 }
908
909 if (!foundCurrent) {
910 G4cout << "No valid current viewer - please create or select one."
911 << G4endl;
912 }
913
914 if (!found) {
915 G4cout << "No viewers";
916 if (name != "all") {
917 G4cout << " of name \"" << name << "\"";
918 }
919 G4cout << " found." << G4endl;
920 }
921}
922
923////////////// /vis/viewer/pan and panTo ////////////////////////////
924
925G4VisCommandViewerPan::G4VisCommandViewerPan ():
926 fPanIncrementRight (0.),
927 fPanIncrementUp (0.),
928 fPanToRight (0.),
929 fPanToUp (0.)
930{
931 G4bool omitable;
932
933 fpCommandPan = new G4UIcommand
934 ("/vis/viewer/pan", this);
935 fpCommandPan -> SetGuidance
936 ("Incremental pan.");
937 fpCommandPan -> SetGuidance
938 ("Moves the camera incrementally right and up by these amounts (as seen"
939 "\nfrom viewpoint direction).");
940 G4UIparameter* parameter;
941 parameter = new G4UIparameter("right-increment", 'd', omitable = true);
942 parameter -> SetCurrentAsDefault (true);
943 fpCommandPan -> SetParameter (parameter);
944 parameter = new G4UIparameter("up-increment", 'd', omitable = true);
945 parameter -> SetCurrentAsDefault (true);
946 fpCommandPan -> SetParameter (parameter);
947 parameter = new G4UIparameter ("unit", 's', omitable = true);
948 parameter -> SetDefaultValue ("m");
949 fpCommandPan -> SetParameter (parameter);
950
951 fpCommandPanTo = new G4UIcommand
952 ("/vis/viewer/panTo", this);
953 fpCommandPanTo -> SetGuidance
954 ("Pan to specific coordinate.");
955 fpCommandPanTo -> SetGuidance
956 ("Places the camera in this position right and up relative to standard"
957 "\ntarget point (as seen from viewpoint direction).");
958 parameter = new G4UIparameter("right", 'd', omitable = true);
959 parameter -> SetCurrentAsDefault (true);
960 fpCommandPanTo -> SetParameter (parameter);
961 parameter = new G4UIparameter("up", 'd', omitable = true);
962 parameter -> SetCurrentAsDefault (true);
963 fpCommandPanTo -> SetParameter (parameter);
964 parameter = new G4UIparameter ("unit", 's', omitable = true);
965 parameter -> SetDefaultValue ("m");
966 fpCommandPanTo -> SetParameter (parameter);
967}
968
969G4VisCommandViewerPan::~G4VisCommandViewerPan () {
970 delete fpCommandPan;
971 delete fpCommandPanTo;
972}
973
974G4String G4VisCommandViewerPan::GetCurrentValue (G4UIcommand* command) {
975 G4String currentValue;
976 if (command == fpCommandPan) {
977 currentValue = ConvertToString(fPanIncrementRight, fPanIncrementUp, "m");
978 }
979 else if (command == fpCommandPanTo) {
980 currentValue = ConvertToString(fPanToRight, fPanToUp, "m");
981 }
982 return currentValue;
983}
984
985void G4VisCommandViewerPan::SetNewValue (G4UIcommand* command,
986 G4String newValue) {
987
988
989 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
990
991 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
992 if (!currentViewer) {
993 if (verbosity >= G4VisManager::errors) {
994 G4cout <<
995 "ERROR: G4VisCommandsViewerPan::SetNewValue: no current viewer."
996 << G4endl;
997 }
998 return;
999 }
1000
1001 G4ViewParameters vp = currentViewer->GetViewParameters();
1002
1003 if (command == fpCommandPan) {
1004 ConvertToDoublePair(newValue, fPanIncrementRight, fPanIncrementUp);
1005 vp.IncrementPan(fPanIncrementRight, fPanIncrementUp);
1006 }
1007 else if (command == fpCommandPanTo) {
1008 ConvertToDoublePair(newValue, fPanToRight, fPanToUp);
1009 vp.SetPan(fPanToRight, fPanToUp);
1010 }
1011
1012 if (verbosity >= G4VisManager::confirmations) {
1013 G4cout << "Current target point now " << vp.GetCurrentTargetPoint()
1014 << G4endl;
1015 }
1016
1017 SetViewParameters(currentViewer, vp);
1018}
1019
1020////////////// /vis/viewer/rebuild ///////////////////////////////////////
1021
1022G4VisCommandViewerRebuild::G4VisCommandViewerRebuild () {
1023 G4bool omitable, currentAsDefault;
1024 fpCommand = new G4UIcmdWithAString ("/vis/viewer/rebuild", this);
1025 fpCommand -> SetGuidance ("Forces rebuild of graphical database.");
1026 fpCommand -> SetGuidance
1027 ("By default, acts on current viewer. \"/vis/viewer/list\""
1028 "\nto see possible viewers. Viewer becomes current.");
1029 fpCommand -> SetParameterName ("viewer-name",
1030 omitable = true,
1031 currentAsDefault = true);
1032}
1033
1034G4VisCommandViewerRebuild::~G4VisCommandViewerRebuild () {
1035 delete fpCommand;
1036}
1037
1038G4String G4VisCommandViewerRebuild::GetCurrentValue (G4UIcommand*) {
1039 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1040 if (viewer) {
1041 return viewer -> GetName ();
1042 }
1043 else {
1044 return "none";
1045 }
1046}
1047
1048void G4VisCommandViewerRebuild::SetNewValue (G4UIcommand*, G4String newValue) {
1049
1050 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1051
1052 G4String& rebuildName = newValue;
1053 G4VViewer* viewer = fpVisManager -> GetViewer (rebuildName);
1054 if (!viewer) {
1055 if (verbosity >= G4VisManager::errors) {
1056 G4cout << "ERROR: Viewer \"" << rebuildName
1057 << "\" not found - \"/vis/viewer/list\" to see possibilities."
1058 << G4endl;
1059 }
1060 return;
1061 }
1062
1063 viewer->NeedKernelVisit();
1064
1065 // Check auto-refresh and print confirmations, but without changing
1066 // view paramters...
1067 SetViewParameters(viewer, viewer->GetViewParameters());
1068}
1069
1070////////////// /vis/viewer/refresh ///////////////////////////////////////
1071
1072G4VisCommandViewerRefresh::G4VisCommandViewerRefresh () {
1073 G4bool omitable, currentAsDefault;
1074 fpCommand = new G4UIcmdWithAString ("/vis/viewer/refresh", this);
1075 fpCommand -> SetGuidance
1076 ("Refreshes viewer.");
1077 fpCommand -> SetGuidance
1078 ("By default, acts on current viewer. \"/vis/viewer/list\""
1079 "\nto see possible viewers. Viewer becomes current.");
1080 fpCommand -> SetParameterName ("viewer-name",
1081 omitable = true,
1082 currentAsDefault = true);
1083}
1084
1085G4VisCommandViewerRefresh::~G4VisCommandViewerRefresh () {
1086 delete fpCommand;
1087}
1088
1089G4String G4VisCommandViewerRefresh::GetCurrentValue (G4UIcommand*) {
1090 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1091 return viewer ? viewer -> GetName () : G4String("none");
1092}
1093
1094void G4VisCommandViewerRefresh::SetNewValue (G4UIcommand*, G4String newValue) {
1095
1096 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1097 G4bool warn(verbosity >= G4VisManager::warnings);
1098
1099 G4String& refreshName = newValue;
1100 G4VViewer* viewer = fpVisManager -> GetViewer (refreshName);
1101 if (!viewer) {
1102 if (verbosity >= G4VisManager::errors) {
1103 G4cout << "ERROR: Viewer \"" << refreshName << "\"" <<
1104 " not found - \"/vis/viewer/list\"\n to see possibilities."
1105 << G4endl;
1106 }
1107 return;
1108 }
1109
1110 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1111 if (!sceneHandler) {
1112 if (verbosity >= G4VisManager::errors) {
1113 G4cout << "ERROR: Viewer \"" << refreshName << "\"" <<
1114 " has no scene handler - report serious bug."
1115 << G4endl;
1116 }
1117 return;
1118 }
1119
1120 G4Scene* scene = sceneHandler->GetScene();
1121 if (!scene) {
1122 if (verbosity >= G4VisManager::confirmations) {
1123 G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
1124 << "\", to which viewer \"" << refreshName << "\"" <<
1125 "\n is attached, has no scene - \"/vis/scene/create\" and"
1126 " \"/vis/sceneHandler/attach\""
1127 "\n (or use compound command \"/vis/drawVolume\")."
1128 << G4endl;
1129 }
1130 return;
1131 }
1132 if (scene->GetRunDurationModelList().empty()) {
1133 G4bool successful = scene -> AddWorldIfEmpty (warn);
1134 if (!successful) {
1135 if (verbosity >= G4VisManager::warnings) {
1136 G4cout <<
1137 "WARNING: Scene is empty. Perhaps no geometry exists."
1138 "\n Try /run/initialize."
1139 << G4endl;
1140 }
1141 return;
1142 }
1143 // Scene has changed. UpdateVisManagerScene issues
1144 // /vis/scene/notifyHandlers, which does a refresh anyway, so the
1145 // ordinary refresh becomes part of the else phrase...
1146 UpdateVisManagerScene(scene->GetName());
1147 } else {
1148 if (verbosity >= G4VisManager::confirmations) {
1149 G4cout << "Refreshing viewer \"" << viewer -> GetName () << "\"..."
1150 << G4endl;
1151 }
1152#ifdef G4DEBUG_VIS_MANAGEMENT
1153 printf("G4VisCommandViewerRefresh::SetNewValue Call SetView()\n");
1154#endif
1155 viewer -> SetView ();
1156#ifdef G4DEBUG_VIS_MANAGEMENT
1157 printf("G4VisCommandViewerRefresh::SetNewValue Call SetView() END\n");
1158 printf("G4VisCommandViewerRefresh::SetNewValue Call ClearView()\n");
1159#endif
1160 viewer -> ClearView ();
1161#ifdef G4DEBUG_VIS_MANAGEMENT
1162 printf("G4VisCommandViewerRefresh::SetNewValue Call ClearView() END\n");
1163 printf("G4VisCommandViewerRefresh::SetNewValue Call DrawView()\n");
1164#endif
1165 viewer -> DrawView ();
1166#ifdef G4DEBUG_VIS_MANAGEMENT
1167 printf("G4VisCommandViewerRefresh::SetNewValue Call DrawView() END\n");
1168#endif
1169 if (verbosity >= G4VisManager::confirmations) {
1170 G4cout << "Viewer \"" << viewer -> GetName () << "\"" << " refreshed."
1171 "\n (You might also need \"/vis/viewer/update\".)" << G4endl;
1172 }
1173 }
1174}
1175
1176////////////// /vis/viewer/reset ///////////////////////////////////////
1177
1178G4VisCommandViewerReset::G4VisCommandViewerReset () {
1179 G4bool omitable, currentAsDefault;
1180 fpCommand = new G4UIcmdWithAString ("/vis/viewer/reset", this);
1181 fpCommand -> SetGuidance ("Resets viewer.");
1182 fpCommand -> SetGuidance
1183 ("By default, acts on current viewer. \"/vis/viewer/list\""
1184 "\nto see possible viewers. Viewer becomes current.");
1185 fpCommand -> SetParameterName ("viewer-name",
1186 omitable = true,
1187 currentAsDefault = true);
1188}
1189
1190G4VisCommandViewerReset::~G4VisCommandViewerReset () {
1191 delete fpCommand;
1192}
1193
1194G4String G4VisCommandViewerReset::GetCurrentValue (G4UIcommand*) {
1195 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1196 if (viewer) {
1197 return viewer -> GetName ();
1198 }
1199 else {
1200 return "none";
1201 }
1202}
1203
1204void G4VisCommandViewerReset::SetNewValue (G4UIcommand*, G4String newValue) {
1205
1206 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1207
1208 G4String& resetName = newValue;
1209 G4VViewer* viewer = fpVisManager -> GetViewer (resetName);
1210 if (!viewer) {
1211 if (verbosity >= G4VisManager::errors) {
1212 G4cout << "ERROR: Viewer \"" << resetName
1213 << "\" not found - \"/vis/viewer/list\" to see possibilities."
1214 << G4endl;
1215 }
1216 return;
1217 }
1218
1219 SetViewParameters(viewer, viewer->GetDefaultViewParameters());
1220}
1221
1222////////////// /vis/viewer/scale and scaleTo ////////////////////////////
1223
1224G4VisCommandViewerScale::G4VisCommandViewerScale ():
1225 fScaleMultiplier (G4Vector3D (1., 1., 1.)),
1226 fScaleTo (G4Vector3D (1., 1., 1.))
1227{
1228 G4bool omitable, currentAsDefault;
1229
1230 fpCommandScale = new G4UIcmdWith3Vector
1231 ("/vis/viewer/scale", this);
1232 fpCommandScale -> SetGuidance ("Incremental (non-uniform) scaling.");
1233 fpCommandScale -> SetGuidance
1234 ("Multiplies components of current scaling by components of this factor."
1235 "\n Scales (x,y,z) by corresponding components of the resulting factor.");
1236 fpCommandScale -> SetGuidance
1237 ("");
1238 fpCommandScale -> SetParameterName
1239 ("x-scale-multiplier","y-scale-multiplier","z-scale-multiplier",
1240 omitable=true, currentAsDefault=true);
1241
1242 fpCommandScaleTo = new G4UIcmdWith3Vector
1243 ("/vis/viewer/scaleTo", this);
1244 fpCommandScaleTo -> SetGuidance ("Absolute (non-uniform) scaling.");
1245 fpCommandScaleTo -> SetGuidance
1246 ("Scales (x,y,z) by corresponding components of this factor.");
1247 fpCommandScaleTo -> SetParameterName
1248 ("x-scale-factor","y-scale-factor","z-scale-factor",
1249 omitable=true, currentAsDefault=true);
1250}
1251
1252G4VisCommandViewerScale::~G4VisCommandViewerScale () {
1253 delete fpCommandScale;
1254 delete fpCommandScaleTo;
1255}
1256
1257G4String G4VisCommandViewerScale::GetCurrentValue (G4UIcommand* command) {
1258 G4String currentValue;
1259 if (command == fpCommandScale) {
1260 currentValue = fpCommandScale->ConvertToString(G4ThreeVector(fScaleMultiplier));
1261 }
1262 else if (command == fpCommandScaleTo) {
1263 currentValue = fpCommandScaleTo->ConvertToString(G4ThreeVector(fScaleTo));
1264 }
1265 return currentValue;
1266}
1267
1268void G4VisCommandViewerScale::SetNewValue (G4UIcommand* command,
1269 G4String newValue) {
1270
1271
1272 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1273
1274 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1275 if (!currentViewer) {
1276 if (verbosity >= G4VisManager::errors) {
1277 G4cout <<
1278 "ERROR: G4VisCommandsViewerScale::SetNewValue: no current viewer."
1279 << G4endl;
1280 }
1281 return;
1282 }
1283
1284 G4ViewParameters vp = currentViewer->GetViewParameters();
1285
1286 if (command == fpCommandScale) {
1287 fScaleMultiplier = fpCommandScale->GetNew3VectorValue(newValue);
1288 vp.MultiplyScaleFactor(fScaleMultiplier);
1289 }
1290 else if (command == fpCommandScaleTo) {
1291 fScaleTo = fpCommandScale->GetNew3VectorValue(newValue);
1292 vp.SetScaleFactor(fScaleTo);
1293 }
1294
1295 if (verbosity >= G4VisManager::confirmations) {
1296 G4cout << "Scale factor changed to " << vp.GetScaleFactor() << G4endl;
1297 }
1298
1299 SetViewParameters(currentViewer, vp);
1300}
1301
1302////////////// /vis/viewer/select ///////////////////////////////////////
1303
1304G4VisCommandViewerSelect::G4VisCommandViewerSelect () {
1305 G4bool omitable;
1306 fpCommand = new G4UIcmdWithAString ("/vis/viewer/select", this);
1307 fpCommand -> SetGuidance ("Selects viewer.");
1308 fpCommand -> SetGuidance
1309 ("Specify viewer by name. \"/vis/viewer/list\" to see possible viewers.");
1310 fpCommand -> SetParameterName ("viewer-name", omitable = false);
1311}
1312
1313G4VisCommandViewerSelect::~G4VisCommandViewerSelect () {
1314 delete fpCommand;
1315}
1316
1317G4String G4VisCommandViewerSelect::GetCurrentValue (G4UIcommand*) {
1318 return "";
1319}
1320
1321void G4VisCommandViewerSelect::SetNewValue (G4UIcommand*, G4String newValue) {
1322
1323 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1324
1325 G4String& selectName = newValue;
1326 G4VViewer* viewer = fpVisManager -> GetViewer (selectName);
1327
1328 if (!viewer) {
1329 if (verbosity >= G4VisManager::errors) {
1330 G4cout << "ERROR: Viewer \"" << selectName << "\"";
1331 G4cout << " not found - \"/vis/viewer/list\""
1332 "\n to see possibilities."
1333 << G4endl;
1334 }
1335 return;
1336 }
1337
1338 if (viewer == fpVisManager -> GetCurrentViewer ()) {
1339 if (verbosity >= G4VisManager::warnings) {
1340 G4cout << "WARNING: Viewer \"" << viewer -> GetName () << "\""
1341 << " already selected." << G4endl;
1342 }
1343 return;
1344 }
1345
1346 fpVisManager -> SetCurrentViewer (viewer); // Prints confirmation.
1347
1348 SetViewParameters(viewer, viewer->GetViewParameters());
1349}
1350
1351////////////// /vis/viewer/update ///////////////////////////////////////
1352
1353G4VisCommandViewerUpdate::G4VisCommandViewerUpdate () {
1354 G4bool omitable, currentAsDefault;
1355 fpCommand = new G4UIcmdWithAString ("/vis/viewer/update", this);
1356 fpCommand -> SetGuidance
1357 ("Triggers graphical database post-processing for viewers"
1358 "\nusing that technique.");
1359 fpCommand -> SetGuidance
1360 ("For such viewers the view only becomes visible with this command."
1361 "\nBy default, acts on current viewer. \"/vis/viewer/list\""
1362 "\nto see possible viewers. Viewer becomes current.");
1363 fpCommand -> SetParameterName ("viewer-name",
1364 omitable = true,
1365 currentAsDefault = true);
1366}
1367
1368G4VisCommandViewerUpdate::~G4VisCommandViewerUpdate () {
1369 delete fpCommand;
1370}
1371
1372G4String G4VisCommandViewerUpdate::GetCurrentValue (G4UIcommand*) {
1373 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1374 if (viewer) {
1375 return viewer -> GetName ();
1376 }
1377 else {
1378 return "none";
1379 }
1380}
1381
1382void G4VisCommandViewerUpdate::SetNewValue (G4UIcommand*, G4String newValue) {
1383
1384 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1385
1386 G4String& updateName = newValue;
1387
1388 G4VViewer* viewer = fpVisManager -> GetViewer (updateName);
1389 if (!viewer) {
1390 if (verbosity >= G4VisManager::errors) {
1391 G4cout <<
1392 "ERROR: G4VisCommandsViewerUpdate::SetNewValue: no current viewer."
1393 << G4endl;
1394 }
1395 return;
1396 }
1397
1398 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1399 if (!sceneHandler) {
1400 if (verbosity >= G4VisManager::errors) {
1401 G4cout << "ERROR: Viewer \"" << updateName << "\"" <<
1402 " has no scene handler - report serious bug."
1403 << G4endl;
1404 }
1405 return;
1406 }
1407
1408 G4Scene* scene = sceneHandler->GetScene();
1409 if (!scene) {
1410 if (verbosity >= G4VisManager::confirmations) {
1411 G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
1412 << "\", to which viewer \"" << updateName << "\"" <<
1413 "\n is attached, has no scene - \"/vis/scene/create\" and"
1414 " \"/vis/sceneHandler/attach\""
1415 "\n (or use compound command \"/vis/drawVolume\")."
1416 << G4endl;
1417 }
1418 return;
1419 }
1420
1421 if (viewer) {
1422 if (verbosity >= G4VisManager::confirmations) {
1423 G4cout << "Viewer \"" << viewer -> GetName () << "\"";
1424 G4cout << " post-processing triggered." << G4endl;
1425 }
1426 viewer -> ShowView ();
1427 // Assume future need to "refresh" transients...
1428 sceneHandler -> SetMarkForClearingTransientStore(true);
1429 }
1430 else {
1431 if (verbosity >= G4VisManager::errors) {
1432 G4cout << "ERROR: Viewer \"" << updateName << "\"";
1433 G4cout << " not found - \"/vis/viewer/list\""
1434 "\n to see possibilities." << G4endl;
1435 }
1436 }
1437}
1438
1439////////////// /vis/viewer/zoom and zoomTo ////////////////////////////
1440
1441G4VisCommandViewerZoom::G4VisCommandViewerZoom ():
1442 fZoomMultiplier (1.),
1443 fZoomTo (1.)
1444{
1445 G4bool omitable, currentAsDefault;
1446
1447 fpCommandZoom = new G4UIcmdWithADouble
1448 ("/vis/viewer/zoom", this);
1449 fpCommandZoom -> SetGuidance ("Incremental zoom.");
1450 fpCommandZoom -> SetGuidance
1451 ("Multiplies current magnification by this factor.");
1452 fpCommandZoom -> SetParameterName("multiplier",
1453 omitable=true,
1454 currentAsDefault=true);
1455
1456 fpCommandZoomTo = new G4UIcmdWithADouble
1457 ("/vis/viewer/zoomTo", this);
1458 fpCommandZoomTo -> SetGuidance ("Absolute zoom.");
1459 fpCommandZoomTo -> SetGuidance
1460 ("Magnifies standard magnification by this factor.");
1461 fpCommandZoomTo -> SetParameterName("factor",
1462 omitable=true,
1463 currentAsDefault=true);
1464}
1465
1466G4VisCommandViewerZoom::~G4VisCommandViewerZoom () {
1467 delete fpCommandZoom;
1468 delete fpCommandZoomTo;
1469}
1470
1471G4String G4VisCommandViewerZoom::GetCurrentValue (G4UIcommand* command) {
1472 G4String currentValue;
1473 if (command == fpCommandZoom) {
1474 currentValue = fpCommandZoom->ConvertToString(fZoomMultiplier);
1475 }
1476 else if (command == fpCommandZoomTo) {
1477 currentValue = fpCommandZoomTo->ConvertToString(fZoomTo);
1478 }
1479 return currentValue;
1480}
1481
1482void G4VisCommandViewerZoom::SetNewValue (G4UIcommand* command,
1483 G4String newValue) {
1484
1485
1486 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1487
1488 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1489 if (!currentViewer) {
1490 if (verbosity >= G4VisManager::errors) {
1491 G4cout <<
1492 "ERROR: G4VisCommandsViewerZoom::SetNewValue: no current viewer."
1493 << G4endl;
1494 }
1495 return;
1496 }
1497
1498 G4ViewParameters vp = currentViewer->GetViewParameters();
1499
1500 if (command == fpCommandZoom) {
1501 fZoomMultiplier = fpCommandZoom->GetNewDoubleValue(newValue);
1502 vp.MultiplyZoomFactor(fZoomMultiplier);
1503 }
1504 else if (command == fpCommandZoomTo) {
1505 fZoomTo = fpCommandZoom->GetNewDoubleValue(newValue);
1506 vp.SetZoomFactor(fZoomTo);
1507 }
1508
1509 if (verbosity >= G4VisManager::confirmations) {
1510 G4cout << "Zoom factor changed to " << vp.GetZoomFactor() << G4endl;
1511 }
1512
1513 SetViewParameters(currentViewer, vp);
1514}
Note: See TracBrowser for help on using the repository browser.