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

Last change on this file since 892 was 891, checked in by garnier, 17 years ago

pre-tag revision and some improvments
  • Property svn:mime-type set to text/cpp
File size: 53.9 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.70 2008/04/30 10:07:28 allison Exp $
28// GEANT4 tag $Name: HEAD $
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 if (cloneName == "none") {
441 G4int subID = 0;
442 do {
443 cloneName = originalName;
444 std::ostringstream oss;
445 oss << '-' << subID++;
446 G4String::size_type lastDashPosition, nextSpacePosition;
447 if ((lastDashPosition = cloneName.rfind('-')) != G4String::npos &&
448 (nextSpacePosition = cloneName.find(" ", lastDashPosition)) !=
449 G4String::npos) {
450 cloneName.insert(nextSpacePosition, oss.str());
451 } else {
452 cloneName.insert(cloneName.find(' '), oss.str());
453 }
454 } while (fpVisManager -> GetViewer (cloneName));
455 }
456
457 if (fpVisManager -> GetViewer (cloneName)) {
458 if (verbosity >= G4VisManager::errors) {
459 G4cout << "ERROR: Putative clone viewer \"" << cloneName
460 << "\" already exists."
461 << G4endl;
462 }
463 return;
464 }
465
466 G4String windowSizeHint =
467 originalViewer->GetViewParameters().GetXGeometryString();
468
469 G4UImanager* UImanager = G4UImanager::GetUIpointer();
470 G4int keepVerbose = UImanager->GetVerboseLevel();
471 G4int newVerbose(0);
472 if (keepVerbose >= 2 ||
473 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
474 newVerbose = 2;
475 UImanager->SetVerboseLevel(newVerbose);
476 UImanager->ApplyCommand(G4String("/vis/viewer/select " + originalName));
477 UImanager->ApplyCommand
478 (G4String("/vis/viewer/create ! \"" + cloneName + "\" " + windowSizeHint));
479 UImanager->ApplyCommand(G4String("/vis/viewer/set/all " + originalName));
480 UImanager->SetVerboseLevel(keepVerbose);
481
482 if (verbosity >= G4VisManager::confirmations) {
483 G4cout << "Viewer \"" << originalName << "\" cloned." << G4endl;
484 G4cout << "Clone \"" << cloneName << "\" now current." << G4endl;
485 }
486}
487
488////////////// /vis/viewer/create ///////////////////////////////////////
489
490G4VisCommandViewerCreate::G4VisCommandViewerCreate ():
491 fId (0),
492 NoValue(0x0000),
493 XValue(0x0001),
494 YValue(0x0002),
495 WidthValue(0x0004),
496 HeightValue(0x0008),
497 AllValues(0x000F),
498 XNegative(0x0010),
499 YNegative(0x0020) {
500 G4bool omitable;
501 fpCommand = new G4UIcommand ("/vis/viewer/create", this);
502 fpCommand -> SetGuidance
503 ("Creates a viewer for the specified scene handler.");
504 fpCommand -> SetGuidance
505 ("Default scene handler is the current scene handler. Invents a name"
506 "\nif not supplied. (Note: the system adds information to the name"
507 "\nfor identification - only the characters up to the first blank are"
508 "\nused for removing, selecting, etc.) This scene handler and viewer"
509 "\nbecome current.");
510 G4UIparameter* parameter;
511 parameter = new G4UIparameter ("scene-handler", 's', omitable = true);
512 parameter -> SetCurrentAsDefault (true);
513 fpCommand -> SetParameter (parameter);
514 parameter = new G4UIparameter ("viewer-name", 's', omitable = true);
515 parameter -> SetCurrentAsDefault (true);
516 fpCommand -> SetParameter (parameter);
517 parameter = new G4UIparameter ("window-size-hint", 's', omitable = true);
518 parameter->SetGuidance
519 ("integer (pixels) for square window placed by window manager or"
520 " X-Windows-type geometry string, e.g. 600x600-100+100");
521 parameter->SetDefaultValue("600");
522 fpCommand -> SetParameter (parameter);
523}
524
525G4VisCommandViewerCreate::~G4VisCommandViewerCreate () {
526 delete fpCommand;
527}
528
529G4String G4VisCommandViewerCreate::NextName () {
530 std::ostringstream oss;
531 G4VSceneHandler* sceneHandler = fpVisManager -> GetCurrentSceneHandler ();
532 oss << "viewer-" << fId << " (";
533 if (sceneHandler) {
534 oss << sceneHandler -> GetGraphicsSystem () -> GetName ();
535 }
536 else {
537 oss << "no_scene_handlers";
538 }
539 oss << ")";
540 return oss.str();
541}
542
543G4String G4VisCommandViewerCreate::GetCurrentValue (G4UIcommand*) {
544 G4String currentValue;
545 G4VSceneHandler* currentSceneHandler =
546 fpVisManager -> GetCurrentSceneHandler ();
547 if (currentSceneHandler) {
548 currentValue = currentSceneHandler -> GetName ();
549 }
550 else {
551 currentValue = "none";
552 }
553 currentValue += ' ';
554 currentValue += '"';
555 currentValue += NextName ();
556 currentValue += '"';
557
558 currentValue += " 600"; // Default number of pixels for window size hint.
559
560 return currentValue;
561}
562
563void G4VisCommandViewerCreate::SetNewValue (G4UIcommand*, G4String newValue) {
564
565 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
566
567 G4String sceneHandlerName, newName;
568 G4String windowSizeHintString;
569 std::istringstream is (newValue);
570 is >> sceneHandlerName;
571
572 // Now need to handle the possibility that the second string
573 // contains embedded blanks within quotation marks...
574 char c;
575 while (is.get(c) && c == ' '){}
576 if (c == '"') {
577 while (is.get(c) && c != '"') {newName += c;}
578 }
579 else {
580 newName += c;
581 while (is.get(c) && c != ' ') {newName += c;}
582 }
583 newName = newName.strip (G4String::both, ' ');
584 newName = newName.strip (G4String::both, '"');
585
586 // Now get window size hint...
587 is >> windowSizeHintString;
588
589 const G4SceneHandlerList& sceneHandlerList =
590 fpVisManager -> GetAvailableSceneHandlers ();
591 G4int nHandlers = sceneHandlerList.size ();
592 if (nHandlers <= 0) {
593 if (verbosity >= G4VisManager::errors) {
594 G4cout <<
595 "ERROR: G4VisCommandViewerCreate::SetNewValue: no scene handlers."
596 "\n Create a scene handler with \"/vis/sceneHandler/create\""
597 << G4endl;
598 }
599 return;
600 }
601
602 G4int iHandler;
603 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
604 if (sceneHandlerList [iHandler] -> GetName () == sceneHandlerName) break;
605 }
606
607 if (iHandler < 0 || iHandler >= nHandlers) {
608 // Invalid command line argument or none.
609 // This shouldn't happen!!!!!!
610 if (verbosity >= G4VisManager::errors) {
611 G4cout << "G4VisCommandViewerCreate::SetNewValue:"
612 " invalid scene handler specified."
613 << G4endl;
614 }
615 return;
616 }
617
618 // Valid index. Set current scene handler and graphics system in
619 // preparation for creating viewer.
620 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
621 if (sceneHandler != fpVisManager -> GetCurrentSceneHandler ()) {
622 fpVisManager -> SetCurrentSceneHandler (sceneHandler);
623 }
624
625 // Now deal with name of viewer.
626 G4String nextName = NextName ();
627 if (newName == "") {
628 newName = nextName;
629 }
630 if (newName == nextName) fId++;
631 G4String newShortName = fpVisManager -> ViewerShortName (newName);
632
633 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
634 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
635 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
636 for (size_t iViewer = 0; iViewer < viewerList.size (); iViewer++) {
637 if (viewerList [iViewer] -> GetShortName () == newShortName ) {
638 if (verbosity >= G4VisManager::errors) {
639 G4cout << "ERROR: Viewer \"" << newShortName << "\" already exists."
640 << G4endl;
641 }
642 return;
643 }
644 }
645 }
646
647
648 // Parse windowSizeHintString to extract first field for backwards
649 // compatibility...
650 std::istringstream issw;
651 G4int windowSizeHint;
652 size_t i;
653#ifdef G4DEBUG
654 printf("G4VisCommandViewerCreate::SetNewValue string\n");
655#endif
656 for (i = 0; i < windowSizeHintString.size(); ++i) {
657 char c = windowSizeHintString[i];
658#ifdef G4DEBUG
659 printf("%c",c);
660#endif
661 if (c == 'x' || c == 'X' || c == '+' || c == '-') break;
662 }
663#ifdef G4DEBUG
664 printf("\n");
665#endif
666 if (i != windowSizeHintString.size()) {
667 // x or X or + or - found - must be a X-Window-type geometry string...
668 // Pick out the first field for backwards compatibility...
669 issw.str(windowSizeHintString.substr(0,i));
670 issw >> windowSizeHint;
671 } else { // ...old-style integer...
672 issw.str(windowSizeHintString);
673 if (!(issw >> windowSizeHint)) {
674 if (verbosity >= G4VisManager::errors) {
675 G4cout << "ERROR: Unrecognised geometry string \""
676 << windowSizeHintString
677 << "\". Using 600."
678 << G4endl;
679 }
680 windowSizeHint = 600;
681 }
682 // Reconstitute windowSizeHintString...
683 std::ostringstream ossw;
684 ossw << windowSizeHint << 'x' << windowSizeHint;
685 windowSizeHintString = ossw.str();
686 }
687 fpVisManager->SetWindowSizeHint (windowSizeHint, windowSizeHint);
688 fpVisManager->SetXGeometryString(windowSizeHintString);
689 // WindowSizeHint and XGeometryString are picked up from the vis
690 // manager in the G4VViewer constructor. They have to be held by
691 // the vis manager until the viewer is contructed - next line...
692
693 ////////
694
695 int x,y = 0;
696 unsigned int w,h = 9999999;
697
698 int m = ParseGeometry( windowSizeHintString, &x, &y, &w, &h );
699 // QSize minSize = main_widget->minimumSize();
700 // QSize maxSize = main_widget->maximumSize();
701 if ( (m & XValue) == 0 )
702 x = -1;
703 if ( (m & YValue) == 0 )
704 y = -2;
705 if ( (m & WidthValue) == 0 )
706 w = -3;
707 if ( (m & HeightValue) == 0 )
708 h = -4;
709// w = QMIN(w,maxSize.width());
710// h = QMIN(h,maxSize.height());
711// w = QMAX(w,minSize.width());
712// h = QMAX(h,minSize.height());
713// if ( (m & XNegative) ) {
714// x = desktop()->width() + x - w;
715// qt_widget_tlw_gravity = 3;
716// }
717// if ( (m & YNegative) ) {
718// y = desktop()->height() + y - h;
719// qt_widget_tlw_gravity = (m & XNegative) ? 9 : 7;
720// }
721// main_widget->setGeometry( x, y, w, h );
722
723#ifdef G4DEBUG
724 printf ("Lecture X:%d Y:%d W:%d H:%d\n",x,y,w,h);
725 ////////
726#endif
727
728 // Create viewer.
729 fpVisManager -> CreateViewer (newName);
730 G4VViewer* newViewer = fpVisManager -> GetCurrentViewer ();
731 if (newViewer && newViewer -> GetName () == newName) {
732 if (verbosity >= G4VisManager::confirmations) {
733 G4cout << "New viewer \"" << newName << "\" created." << G4endl;
734 }
735 }
736 else {
737 if (verbosity >= G4VisManager::errors) {
738 if (newViewer) {
739 G4cout << "ERROR: New viewer doesn\'t match!!! Curious!!" << G4endl;
740 } else {
741 G4cout << "WARNING: No viewer created." << G4endl;
742 }
743 }
744 }
745 // Refresh if appropriate...
746 if (newViewer) {
747 if (newViewer->GetViewParameters().IsAutoRefresh()) {
748 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
749 }
750 else {
751 if (verbosity >= G4VisManager::confirmations) {
752 G4cout << "Issue /vis/viewer/refresh to see effect." << G4endl;
753 }
754 }
755 }
756}
757
758////////////// /vis/viewer/dolly and dollyTo ////////////////////////////
759
760G4VisCommandViewerDolly::G4VisCommandViewerDolly ():
761 fDollyIncrement (0.),
762 fDollyTo (0.)
763{
764 G4bool omitable, currentAsDefault;
765
766 fpCommandDolly = new G4UIcmdWithADoubleAndUnit
767 ("/vis/viewer/dolly", this);
768 fpCommandDolly -> SetGuidance
769 ("Incremental dolly.");
770 fpCommandDolly -> SetGuidance
771 ("Moves the camera incrementally towards target point.");
772 fpCommandDolly -> SetParameterName("increment",
773 omitable=true,
774 currentAsDefault=true);
775 fpCommandDolly -> SetDefaultUnit("m");
776
777 fpCommandDollyTo = new G4UIcmdWithADoubleAndUnit
778 ("/vis/viewer/dollyTo", this);
779 fpCommandDollyTo -> SetGuidance
780 ("Dolly to specific coordinate.");
781 fpCommandDollyTo -> SetGuidance
782 ("Places the camera towards target point relative to standard camera point.");
783 fpCommandDollyTo -> SetParameterName("distance",
784 omitable=true,
785 currentAsDefault=true);
786 fpCommandDollyTo -> SetDefaultUnit("m");
787}
788
789G4VisCommandViewerDolly::~G4VisCommandViewerDolly () {
790 delete fpCommandDolly;
791 delete fpCommandDollyTo;
792}
793
794G4String G4VisCommandViewerDolly::GetCurrentValue (G4UIcommand* command) {
795 G4String currentValue;
796 if (command == fpCommandDolly) {
797 currentValue = fpCommandDolly->ConvertToString(fDollyIncrement, "m");
798 }
799 else if (command == fpCommandDollyTo) {
800 currentValue = fpCommandDollyTo->ConvertToString(fDollyTo, "m");
801 }
802 return currentValue;
803}
804
805void G4VisCommandViewerDolly::SetNewValue (G4UIcommand* command,
806 G4String newValue) {
807
808
809 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
810
811 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
812 if (!currentViewer) {
813 if (verbosity >= G4VisManager::errors) {
814 G4cout <<
815 "ERROR: G4VisCommandsViewerDolly::SetNewValue: no current viewer."
816 << G4endl;
817 }
818 return;
819 }
820
821 G4ViewParameters vp = currentViewer->GetViewParameters();
822
823 if (command == fpCommandDolly) {
824 fDollyIncrement = fpCommandDolly->GetNewDoubleValue(newValue);
825 vp.IncrementDolly(fDollyIncrement);
826 }
827 else if (command == fpCommandDollyTo) {
828 fDollyTo = fpCommandDolly->GetNewDoubleValue(newValue);
829 vp.SetDolly(fDollyTo);
830 }
831
832 if (verbosity >= G4VisManager::confirmations) {
833 G4cout << "Dolly distance changed to " << vp.GetDolly() << G4endl;
834 }
835
836 SetViewParameters(currentViewer, vp);
837}
838
839////////////// /vis/viewer/flush ///////////////////////////////////////
840
841G4VisCommandViewerFlush::G4VisCommandViewerFlush () {
842 G4bool omitable, currentAsDefault;
843 fpCommand = new G4UIcmdWithAString ("/vis/viewer/flush", this);
844 fpCommand -> SetGuidance
845 ("Compound command: \"/vis/viewer/refresh\" + \"/vis/viewer/update\".");
846 fpCommand -> SetGuidance
847 ("Useful for refreshing and initiating post-processing for graphics"
848 "\nsystems which need post-processing. By default, acts on current"
849 "\nviewer. \"/vis/viewer/list\" to see possible viewers. Viewer"
850 "\nbecomes current.");
851 fpCommand -> SetParameterName ("viewer-name",
852 omitable = true,
853 currentAsDefault = true);
854}
855
856G4VisCommandViewerFlush::~G4VisCommandViewerFlush () {
857 delete fpCommand;
858}
859
860G4String G4VisCommandViewerFlush::GetCurrentValue
861(G4UIcommand*) {
862 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
863 return viewer ? viewer -> GetName () : G4String("none");
864}
865
866void G4VisCommandViewerFlush::SetNewValue (G4UIcommand*, G4String newValue) {
867
868 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
869
870 G4String& flushName = newValue;
871 G4VViewer* viewer = fpVisManager -> GetViewer (flushName);
872 if (!viewer) {
873 if (verbosity >= G4VisManager::errors) {
874 G4cout << "ERROR: Viewer \"" << flushName << "\"" <<
875 " not found - \"/vis/viewer/list\"\n to see possibilities."
876 << G4endl;
877 }
878 return;
879 }
880
881 G4UImanager* ui = G4UImanager::GetUIpointer();
882 G4int keepVerbose = ui->GetVerboseLevel();
883 G4int newVerbose(0);
884 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
885 newVerbose = 2;
886 ui->SetVerboseLevel(newVerbose);
887 ui->ApplyCommand(G4String("/vis/viewer/refresh " + flushName));
888 ui->ApplyCommand(G4String("/vis/viewer/update " + flushName));
889 ui->SetVerboseLevel(keepVerbose);
890 if (verbosity >= G4VisManager::confirmations) {
891 G4cout << "Viewer \"" << viewer -> GetName () << "\""
892 << " flushed." << G4endl;
893 }
894}
895
896////////////// /vis/viewer/list ///////////////////////////////////////
897
898G4VisCommandViewerList::G4VisCommandViewerList () {
899 G4bool omitable;
900 fpCommand = new G4UIcommand ("/vis/viewer/list", this);
901 fpCommand -> SetGuidance ("Lists viewers(s).");
902 fpCommand -> SetGuidance
903 ("See \"/vis/verbose\" for definition of verbosity.");
904 G4UIparameter* parameter;
905 parameter = new G4UIparameter("viewer-name", 's',
906 omitable = true);
907 parameter -> SetDefaultValue ("all");
908 fpCommand -> SetParameter (parameter);
909 parameter = new G4UIparameter ("verbosity", 's',
910 omitable = true);
911 parameter -> SetDefaultValue ("warnings");
912 fpCommand -> SetParameter (parameter);
913}
914
915G4VisCommandViewerList::~G4VisCommandViewerList () {
916 delete fpCommand;
917}
918
919G4String G4VisCommandViewerList::GetCurrentValue (G4UIcommand*) {
920 return "";
921}
922
923void G4VisCommandViewerList::SetNewValue (G4UIcommand*, G4String newValue) {
924 G4String name, verbosityString;
925 std::istringstream is (newValue);
926 is >> name >> verbosityString;
927 G4String shortName = fpVisManager -> ViewerShortName (name);
928 G4VisManager::Verbosity verbosity =
929 fpVisManager->GetVerbosityValue(verbosityString);
930
931 const G4VViewer* currentViewer = fpVisManager -> GetCurrentViewer ();
932 G4String currentViewerShortName;
933 if (currentViewer) {
934 currentViewerShortName = currentViewer -> GetShortName ();
935 }
936 else {
937 currentViewerShortName = "none";
938 }
939
940 const G4SceneHandlerList& sceneHandlerList = fpVisManager -> GetAvailableSceneHandlers ();
941 G4int nHandlers = sceneHandlerList.size ();
942 G4bool found = false;
943 G4bool foundCurrent = false;
944 for (int iHandler = 0; iHandler < nHandlers; iHandler++) {
945 G4VSceneHandler* sceneHandler = sceneHandlerList [iHandler];
946 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
947 G4cout << "Scene handler \"" << sceneHandler -> GetName ();
948 const G4Scene* pScene = sceneHandler -> GetScene ();
949 if (pScene) {
950 G4cout << "\", scene \"" << pScene -> GetName () << "\":";
951 }
952 G4int nViewers = viewerList.size ();
953 if (nViewers == 0) {
954 G4cout << "\n No viewers for this scene handler." << G4endl;
955 }
956 else {
957 for (int iViewer = 0; iViewer < nViewers; iViewer++) {
958 const G4VViewer* thisViewer = viewerList [iViewer];
959 G4String thisName = thisViewer -> GetName ();
960 G4String thisShortName = thisViewer -> GetShortName ();
961 if (name != "all") {
962 if (thisShortName != shortName) continue;
963 }
964 found = true;
965 G4cout << "\n ";
966 if (thisShortName == currentViewerShortName) {
967 foundCurrent = true;
968 G4cout << "(current)";
969 }
970 else {
971 G4cout << " ";
972 }
973 G4cout << " viewer \"" << thisName << "\"";
974 if (verbosity >= G4VisManager::parameters) {
975 G4cout << "\n " << *thisViewer;
976 }
977 }
978 }
979 G4cout << G4endl;
980 }
981
982 if (!foundCurrent) {
983 G4cout << "No valid current viewer - please create or select one."
984 << G4endl;
985 }
986
987 if (!found) {
988 G4cout << "No viewers";
989 if (name != "all") {
990 G4cout << " of name \"" << name << "\"";
991 }
992 G4cout << " found." << G4endl;
993 }
994}
995
996////////////// /vis/viewer/pan and panTo ////////////////////////////
997
998G4VisCommandViewerPan::G4VisCommandViewerPan ():
999 fPanIncrementRight (0.),
1000 fPanIncrementUp (0.),
1001 fPanToRight (0.),
1002 fPanToUp (0.)
1003{
1004 G4bool omitable;
1005
1006 fpCommandPan = new G4UIcommand
1007 ("/vis/viewer/pan", this);
1008 fpCommandPan -> SetGuidance
1009 ("Incremental pan.");
1010 fpCommandPan -> SetGuidance
1011 ("Moves the camera incrementally right and up by these amounts (as seen"
1012 "\nfrom viewpoint direction).");
1013 G4UIparameter* parameter;
1014 parameter = new G4UIparameter("right-increment", 'd', omitable = true);
1015 parameter -> SetCurrentAsDefault (true);
1016 fpCommandPan -> SetParameter (parameter);
1017 parameter = new G4UIparameter("up-increment", 'd', omitable = true);
1018 parameter -> SetCurrentAsDefault (true);
1019 fpCommandPan -> SetParameter (parameter);
1020 parameter = new G4UIparameter ("unit", 's', omitable = true);
1021 parameter -> SetDefaultValue ("m");
1022 fpCommandPan -> SetParameter (parameter);
1023
1024 fpCommandPanTo = new G4UIcommand
1025 ("/vis/viewer/panTo", this);
1026 fpCommandPanTo -> SetGuidance
1027 ("Pan to specific coordinate.");
1028 fpCommandPanTo -> SetGuidance
1029 ("Places the camera in this position right and up relative to standard"
1030 "\ntarget point (as seen from viewpoint direction).");
1031 parameter = new G4UIparameter("right", 'd', omitable = true);
1032 parameter -> SetCurrentAsDefault (true);
1033 fpCommandPanTo -> SetParameter (parameter);
1034 parameter = new G4UIparameter("up", 'd', omitable = true);
1035 parameter -> SetCurrentAsDefault (true);
1036 fpCommandPanTo -> SetParameter (parameter);
1037 parameter = new G4UIparameter ("unit", 's', omitable = true);
1038 parameter -> SetDefaultValue ("m");
1039 fpCommandPanTo -> SetParameter (parameter);
1040}
1041
1042G4VisCommandViewerPan::~G4VisCommandViewerPan () {
1043 delete fpCommandPan;
1044 delete fpCommandPanTo;
1045}
1046
1047G4String G4VisCommandViewerPan::GetCurrentValue (G4UIcommand* command) {
1048 G4String currentValue;
1049 if (command == fpCommandPan) {
1050 currentValue = ConvertToString(fPanIncrementRight, fPanIncrementUp, "m");
1051 }
1052 else if (command == fpCommandPanTo) {
1053 currentValue = ConvertToString(fPanToRight, fPanToUp, "m");
1054 }
1055 return currentValue;
1056}
1057
1058void G4VisCommandViewerPan::SetNewValue (G4UIcommand* command,
1059 G4String newValue) {
1060
1061
1062 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1063
1064 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1065 if (!currentViewer) {
1066 if (verbosity >= G4VisManager::errors) {
1067 G4cout <<
1068 "ERROR: G4VisCommandsViewerPan::SetNewValue: no current viewer."
1069 << G4endl;
1070 }
1071 return;
1072 }
1073
1074 G4ViewParameters vp = currentViewer->GetViewParameters();
1075
1076 if (command == fpCommandPan) {
1077 ConvertToDoublePair(newValue, fPanIncrementRight, fPanIncrementUp);
1078 vp.IncrementPan(fPanIncrementRight, fPanIncrementUp);
1079 }
1080 else if (command == fpCommandPanTo) {
1081 ConvertToDoublePair(newValue, fPanToRight, fPanToUp);
1082 vp.SetPan(fPanToRight, fPanToUp);
1083 }
1084
1085 if (verbosity >= G4VisManager::confirmations) {
1086 G4cout << "Current target point now " << vp.GetCurrentTargetPoint()
1087 << G4endl;
1088 }
1089
1090 SetViewParameters(currentViewer, vp);
1091}
1092
1093////////////// /vis/viewer/rebuild ///////////////////////////////////////
1094
1095G4VisCommandViewerRebuild::G4VisCommandViewerRebuild () {
1096 G4bool omitable, currentAsDefault;
1097 fpCommand = new G4UIcmdWithAString ("/vis/viewer/rebuild", this);
1098 fpCommand -> SetGuidance ("Forces rebuild of graphical database.");
1099 fpCommand -> SetGuidance
1100 ("By default, acts on current viewer. \"/vis/viewer/list\""
1101 "\nto see possible viewers. Viewer becomes current.");
1102 fpCommand -> SetParameterName ("viewer-name",
1103 omitable = true,
1104 currentAsDefault = true);
1105}
1106
1107G4VisCommandViewerRebuild::~G4VisCommandViewerRebuild () {
1108 delete fpCommand;
1109}
1110
1111G4String G4VisCommandViewerRebuild::GetCurrentValue (G4UIcommand*) {
1112 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1113 if (viewer) {
1114 return viewer -> GetName ();
1115 }
1116 else {
1117 return "none";
1118 }
1119}
1120
1121void G4VisCommandViewerRebuild::SetNewValue (G4UIcommand*, G4String newValue) {
1122
1123 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1124
1125 G4String& rebuildName = newValue;
1126 G4VViewer* viewer = fpVisManager -> GetViewer (rebuildName);
1127 if (!viewer) {
1128 if (verbosity >= G4VisManager::errors) {
1129 G4cout << "ERROR: Viewer \"" << rebuildName
1130 << "\" not found - \"/vis/viewer/list\" to see possibilities."
1131 << G4endl;
1132 }
1133 return;
1134 }
1135
1136 viewer->NeedKernelVisit();
1137
1138 // Check auto-refresh and print confirmations, but without changing
1139 // view paramters...
1140 SetViewParameters(viewer, viewer->GetViewParameters());
1141}
1142
1143////////////// /vis/viewer/refresh ///////////////////////////////////////
1144
1145G4VisCommandViewerRefresh::G4VisCommandViewerRefresh () {
1146 G4bool omitable, currentAsDefault;
1147 fpCommand = new G4UIcmdWithAString ("/vis/viewer/refresh", this);
1148 fpCommand -> SetGuidance
1149 ("Refreshes viewer.");
1150 fpCommand -> SetGuidance
1151 ("By default, acts on current viewer. \"/vis/viewer/list\""
1152 "\nto see possible viewers. Viewer becomes current.");
1153 fpCommand -> SetParameterName ("viewer-name",
1154 omitable = true,
1155 currentAsDefault = true);
1156}
1157
1158G4VisCommandViewerRefresh::~G4VisCommandViewerRefresh () {
1159 delete fpCommand;
1160}
1161
1162G4String G4VisCommandViewerRefresh::GetCurrentValue (G4UIcommand*) {
1163 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1164 return viewer ? viewer -> GetName () : G4String("none");
1165}
1166
1167void G4VisCommandViewerRefresh::SetNewValue (G4UIcommand*, G4String newValue) {
1168
1169 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1170 G4bool warn(verbosity >= G4VisManager::warnings);
1171
1172 G4String& refreshName = newValue;
1173 G4VViewer* viewer = fpVisManager -> GetViewer (refreshName);
1174 if (!viewer) {
1175 if (verbosity >= G4VisManager::errors) {
1176 G4cout << "ERROR: Viewer \"" << refreshName << "\"" <<
1177 " not found - \"/vis/viewer/list\"\n to see possibilities."
1178 << G4endl;
1179 }
1180 return;
1181 }
1182
1183 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1184 if (!sceneHandler) {
1185 if (verbosity >= G4VisManager::errors) {
1186 G4cout << "ERROR: Viewer \"" << refreshName << "\"" <<
1187 " has no scene handler - report serious bug."
1188 << G4endl;
1189 }
1190 return;
1191 }
1192
1193 G4Scene* scene = sceneHandler->GetScene();
1194 if (!scene) {
1195 if (verbosity >= G4VisManager::confirmations) {
1196 G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
1197 << "\", to which viewer \"" << refreshName << "\"" <<
1198 "\n is attached, has no scene - \"/vis/scene/create\" and"
1199 " \"/vis/sceneHandler/attach\""
1200 "\n (or use compound command \"/vis/drawVolume\")."
1201 << G4endl;
1202 }
1203 return;
1204 }
1205 if (scene->GetRunDurationModelList().empty()) {
1206 G4bool successful = scene -> AddWorldIfEmpty (warn);
1207 if (!successful) {
1208 if (verbosity >= G4VisManager::warnings) {
1209 G4cout <<
1210 "WARNING: Scene is empty. Perhaps no geometry exists."
1211 "\n Try /run/initialize."
1212 << G4endl;
1213 }
1214 return;
1215 }
1216 // Scene has changed. UpdateVisManagerScene issues
1217 // /vis/scene/notifyHandlers, which does a refresh anyway, so the
1218 // ordinary refresh becomes part of the else phrase...
1219 UpdateVisManagerScene(scene->GetName());
1220 } else {
1221 if (verbosity >= G4VisManager::confirmations) {
1222 G4cout << "Refreshing viewer \"" << viewer -> GetName () << "\"..."
1223 << G4endl;
1224 }
1225 viewer -> SetView ();
1226 viewer -> ClearView ();
1227 viewer -> DrawView ();
1228 if (verbosity >= G4VisManager::confirmations) {
1229 G4cout << "Viewer \"" << viewer -> GetName () << "\"" << " refreshed."
1230 "\n (You might also need \"/vis/viewer/update\".)" << G4endl;
1231 }
1232 }
1233}
1234
1235////////////// /vis/viewer/reset ///////////////////////////////////////
1236
1237G4VisCommandViewerReset::G4VisCommandViewerReset () {
1238 G4bool omitable, currentAsDefault;
1239 fpCommand = new G4UIcmdWithAString ("/vis/viewer/reset", this);
1240 fpCommand -> SetGuidance ("Resets viewer.");
1241 fpCommand -> SetGuidance
1242 ("By default, acts on current viewer. \"/vis/viewer/list\""
1243 "\nto see possible viewers. Viewer becomes current.");
1244 fpCommand -> SetParameterName ("viewer-name",
1245 omitable = true,
1246 currentAsDefault = true);
1247}
1248
1249G4VisCommandViewerReset::~G4VisCommandViewerReset () {
1250 delete fpCommand;
1251}
1252
1253G4String G4VisCommandViewerReset::GetCurrentValue (G4UIcommand*) {
1254 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1255 if (viewer) {
1256 return viewer -> GetName ();
1257 }
1258 else {
1259 return "none";
1260 }
1261}
1262
1263void G4VisCommandViewerReset::SetNewValue (G4UIcommand*, G4String newValue) {
1264
1265 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1266
1267 G4String& resetName = newValue;
1268 G4VViewer* viewer = fpVisManager -> GetViewer (resetName);
1269 if (!viewer) {
1270 if (verbosity >= G4VisManager::errors) {
1271 G4cout << "ERROR: Viewer \"" << resetName
1272 << "\" not found - \"/vis/viewer/list\" to see possibilities."
1273 << G4endl;
1274 }
1275 return;
1276 }
1277
1278 SetViewParameters(viewer, viewer->GetDefaultViewParameters());
1279}
1280
1281////////////// /vis/viewer/scale and scaleTo ////////////////////////////
1282
1283G4VisCommandViewerScale::G4VisCommandViewerScale ():
1284 fScaleMultiplier (G4Vector3D (1., 1., 1.)),
1285 fScaleTo (G4Vector3D (1., 1., 1.))
1286{
1287 G4bool omitable, currentAsDefault;
1288
1289 fpCommandScale = new G4UIcmdWith3Vector
1290 ("/vis/viewer/scale", this);
1291 fpCommandScale -> SetGuidance ("Incremental (non-uniform) scaling.");
1292 fpCommandScale -> SetGuidance
1293 ("Multiplies components of current scaling by components of this factor."
1294 "\n Scales (x,y,z) by corresponding components of the resulting factor.");
1295 fpCommandScale -> SetGuidance
1296 ("");
1297 fpCommandScale -> SetParameterName
1298 ("x-scale-multiplier","y-scale-multiplier","z-scale-multiplier",
1299 omitable=true, currentAsDefault=true);
1300
1301 fpCommandScaleTo = new G4UIcmdWith3Vector
1302 ("/vis/viewer/scaleTo", this);
1303 fpCommandScaleTo -> SetGuidance ("Absolute (non-uniform) scaling.");
1304 fpCommandScaleTo -> SetGuidance
1305 ("Scales (x,y,z) by corresponding components of this factor.");
1306 fpCommandScaleTo -> SetParameterName
1307 ("x-scale-factor","y-scale-factor","z-scale-factor",
1308 omitable=true, currentAsDefault=true);
1309}
1310
1311G4VisCommandViewerScale::~G4VisCommandViewerScale () {
1312 delete fpCommandScale;
1313 delete fpCommandScaleTo;
1314}
1315
1316G4String G4VisCommandViewerScale::GetCurrentValue (G4UIcommand* command) {
1317 G4String currentValue;
1318 if (command == fpCommandScale) {
1319 currentValue = fpCommandScale->ConvertToString(G4ThreeVector(fScaleMultiplier));
1320 }
1321 else if (command == fpCommandScaleTo) {
1322 currentValue = fpCommandScaleTo->ConvertToString(G4ThreeVector(fScaleTo));
1323 }
1324 return currentValue;
1325}
1326
1327void G4VisCommandViewerScale::SetNewValue (G4UIcommand* command,
1328 G4String newValue) {
1329
1330
1331 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1332
1333 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1334 if (!currentViewer) {
1335 if (verbosity >= G4VisManager::errors) {
1336 G4cout <<
1337 "ERROR: G4VisCommandsViewerScale::SetNewValue: no current viewer."
1338 << G4endl;
1339 }
1340 return;
1341 }
1342
1343 G4ViewParameters vp = currentViewer->GetViewParameters();
1344
1345 if (command == fpCommandScale) {
1346 fScaleMultiplier = fpCommandScale->GetNew3VectorValue(newValue);
1347 vp.MultiplyScaleFactor(fScaleMultiplier);
1348 }
1349 else if (command == fpCommandScaleTo) {
1350 fScaleTo = fpCommandScale->GetNew3VectorValue(newValue);
1351 vp.SetScaleFactor(fScaleTo);
1352 }
1353
1354 if (verbosity >= G4VisManager::confirmations) {
1355 G4cout << "Scale factor changed to " << vp.GetScaleFactor() << G4endl;
1356 }
1357
1358 SetViewParameters(currentViewer, vp);
1359}
1360
1361////////////// /vis/viewer/select ///////////////////////////////////////
1362
1363G4VisCommandViewerSelect::G4VisCommandViewerSelect () {
1364 G4bool omitable;
1365 fpCommand = new G4UIcmdWithAString ("/vis/viewer/select", this);
1366 fpCommand -> SetGuidance ("Selects viewer.");
1367 fpCommand -> SetGuidance
1368 ("Specify viewer by name. \"/vis/viewer/list\" to see possible viewers.");
1369 fpCommand -> SetParameterName ("viewer-name", omitable = false);
1370}
1371
1372G4VisCommandViewerSelect::~G4VisCommandViewerSelect () {
1373 delete fpCommand;
1374}
1375
1376G4String G4VisCommandViewerSelect::GetCurrentValue (G4UIcommand*) {
1377 return "";
1378}
1379
1380void G4VisCommandViewerSelect::SetNewValue (G4UIcommand*, G4String newValue) {
1381
1382 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1383
1384 G4String& selectName = newValue;
1385 G4VViewer* viewer = fpVisManager -> GetViewer (selectName);
1386
1387 if (!viewer) {
1388 if (verbosity >= G4VisManager::errors) {
1389 G4cout << "ERROR: Viewer \"" << selectName << "\"";
1390 G4cout << " not found - \"/vis/viewer/list\""
1391 "\n to see possibilities."
1392 << G4endl;
1393 }
1394 return;
1395 }
1396
1397 if (viewer == fpVisManager -> GetCurrentViewer ()) {
1398 if (verbosity >= G4VisManager::warnings) {
1399 G4cout << "WARNING: Viewer \"" << viewer -> GetName () << "\""
1400 << " already selected." << G4endl;
1401 }
1402 return;
1403 }
1404
1405 fpVisManager -> SetCurrentViewer (viewer); // Prints confirmation.
1406
1407 SetViewParameters(viewer, viewer->GetViewParameters());
1408}
1409
1410////////////// /vis/viewer/update ///////////////////////////////////////
1411
1412G4VisCommandViewerUpdate::G4VisCommandViewerUpdate () {
1413 G4bool omitable, currentAsDefault;
1414 fpCommand = new G4UIcmdWithAString ("/vis/viewer/update", this);
1415 fpCommand -> SetGuidance
1416 ("Triggers graphical database post-processing for viewers"
1417 "\nusing that technique.");
1418 fpCommand -> SetGuidance
1419 ("For such viewers the view only becomes visible with this command."
1420 "\nBy default, acts on current viewer. \"/vis/viewer/list\""
1421 "\nto see possible viewers. Viewer becomes current.");
1422 fpCommand -> SetParameterName ("viewer-name",
1423 omitable = true,
1424 currentAsDefault = true);
1425}
1426
1427G4VisCommandViewerUpdate::~G4VisCommandViewerUpdate () {
1428 delete fpCommand;
1429}
1430
1431G4String G4VisCommandViewerUpdate::GetCurrentValue (G4UIcommand*) {
1432 G4VViewer* viewer = fpVisManager -> GetCurrentViewer ();
1433 if (viewer) {
1434 return viewer -> GetName ();
1435 }
1436 else {
1437 return "none";
1438 }
1439}
1440
1441void G4VisCommandViewerUpdate::SetNewValue (G4UIcommand*, G4String newValue) {
1442
1443 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1444
1445 G4String& updateName = newValue;
1446
1447 G4VViewer* viewer = fpVisManager -> GetViewer (updateName);
1448 if (!viewer) {
1449 if (verbosity >= G4VisManager::errors) {
1450 G4cout <<
1451 "ERROR: G4VisCommandsViewerUpdate::SetNewValue: no current viewer."
1452 << G4endl;
1453 }
1454 return;
1455 }
1456
1457 G4VSceneHandler* sceneHandler = viewer->GetSceneHandler();
1458 if (!sceneHandler) {
1459 if (verbosity >= G4VisManager::errors) {
1460 G4cout << "ERROR: Viewer \"" << updateName << "\"" <<
1461 " has no scene handler - report serious bug."
1462 << G4endl;
1463 }
1464 return;
1465 }
1466
1467 G4Scene* scene = sceneHandler->GetScene();
1468 if (!scene) {
1469 if (verbosity >= G4VisManager::confirmations) {
1470 G4cout << "NOTE: SceneHandler \"" << sceneHandler->GetName()
1471 << "\", to which viewer \"" << updateName << "\"" <<
1472 "\n is attached, has no scene - \"/vis/scene/create\" and"
1473 " \"/vis/sceneHandler/attach\""
1474 "\n (or use compound command \"/vis/drawVolume\")."
1475 << G4endl;
1476 }
1477 return;
1478 }
1479
1480 if (viewer) {
1481 if (verbosity >= G4VisManager::confirmations) {
1482 G4cout << "Viewer \"" << viewer -> GetName () << "\"";
1483 G4cout << " post-processing triggered." << G4endl;
1484 }
1485 viewer -> ShowView ();
1486 // Assume future need to "refresh" transients...
1487 sceneHandler -> SetMarkForClearingTransientStore(true);
1488 }
1489 else {
1490 if (verbosity >= G4VisManager::errors) {
1491 G4cout << "ERROR: Viewer \"" << updateName << "\"";
1492 G4cout << " not found - \"/vis/viewer/list\""
1493 "\n to see possibilities." << G4endl;
1494 }
1495 }
1496}
1497
1498////////////// /vis/viewer/zoom and zoomTo ////////////////////////////
1499
1500G4VisCommandViewerZoom::G4VisCommandViewerZoom ():
1501 fZoomMultiplier (1.),
1502 fZoomTo (1.)
1503{
1504 G4bool omitable, currentAsDefault;
1505
1506 fpCommandZoom = new G4UIcmdWithADouble
1507 ("/vis/viewer/zoom", this);
1508 fpCommandZoom -> SetGuidance ("Incremental zoom.");
1509 fpCommandZoom -> SetGuidance
1510 ("Multiplies current magnification by this factor.");
1511 fpCommandZoom -> SetParameterName("multiplier",
1512 omitable=true,
1513 currentAsDefault=true);
1514
1515 fpCommandZoomTo = new G4UIcmdWithADouble
1516 ("/vis/viewer/zoomTo", this);
1517 fpCommandZoomTo -> SetGuidance ("Absolute zoom.");
1518 fpCommandZoomTo -> SetGuidance
1519 ("Magnifies standard magnification by this factor.");
1520 fpCommandZoomTo -> SetParameterName("factor",
1521 omitable=true,
1522 currentAsDefault=true);
1523}
1524
1525G4VisCommandViewerZoom::~G4VisCommandViewerZoom () {
1526 delete fpCommandZoom;
1527 delete fpCommandZoomTo;
1528}
1529
1530G4String G4VisCommandViewerZoom::GetCurrentValue (G4UIcommand* command) {
1531 G4String currentValue;
1532 if (command == fpCommandZoom) {
1533 currentValue = fpCommandZoom->ConvertToString(fZoomMultiplier);
1534 }
1535 else if (command == fpCommandZoomTo) {
1536 currentValue = fpCommandZoomTo->ConvertToString(fZoomTo);
1537 }
1538 return currentValue;
1539}
1540
1541void G4VisCommandViewerZoom::SetNewValue (G4UIcommand* command,
1542 G4String newValue) {
1543
1544
1545 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1546
1547 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
1548 if (!currentViewer) {
1549 if (verbosity >= G4VisManager::errors) {
1550 G4cout <<
1551 "ERROR: G4VisCommandsViewerZoom::SetNewValue: no current viewer."
1552 << G4endl;
1553 }
1554 return;
1555 }
1556
1557 G4ViewParameters vp = currentViewer->GetViewParameters();
1558
1559 if (command == fpCommandZoom) {
1560 fZoomMultiplier = fpCommandZoom->GetNewDoubleValue(newValue);
1561 vp.MultiplyZoomFactor(fZoomMultiplier);
1562 }
1563 else if (command == fpCommandZoomTo) {
1564 fZoomTo = fpCommandZoom->GetNewDoubleValue(newValue);
1565 vp.SetZoomFactor(fZoomTo);
1566 }
1567
1568 if (verbosity >= G4VisManager::confirmations) {
1569 G4cout << "Zoom factor changed to " << vp.GetZoomFactor() << G4endl;
1570 }
1571
1572 SetViewParameters(currentViewer, vp);
1573}
1574
1575/* Keep from :
1576 * ftp://ftp.trolltech.com/qt/source/qt-embedded-free-3.0.6.tar.gz/qt-embedded-free-3.0.6/src/kernel/qapplication_qws.cpp
1577 *
1578 * ParseGeometry parses strings of the form
1579 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
1580 * width, height, xoffset, and yoffset are unsigned integers.
1581 * Example: "=80x24+300-49"
1582 * The equal sign is optional.
1583 * It returns a bitmask that indicates which of the four values
1584 * were actually found in the string. For each value found,
1585 * the corresponding argument is updated; for each value
1586 * not found, the corresponding argument is left unchanged.
1587 */
1588
1589
1590int G4VisCommandViewerCreate::ParseGeometry (
1591 const char *string,
1592 int *x,
1593 int *y,
1594 unsigned int *width,
1595 unsigned int *height)
1596{
1597
1598 int mask = NoValue;
1599 register char *strind;
1600 unsigned int tempWidth, tempHeight;
1601 int tempX, tempY;
1602 char *nextCharacter;
1603 if ( (string == NULL) || (*string == '\0')) {
1604 return(mask);
1605 }
1606 if (*string == '=')
1607 string++; /* ignore possible '=' at beg of geometry spec */
1608 strind = (char *)string;
1609 if (*strind != '+' && *strind != '-' && *strind != 'x') {
1610 tempWidth = ReadInteger(strind, &nextCharacter);
1611 if (strind == nextCharacter)
1612 return (0);
1613 strind = nextCharacter;
1614 mask |= WidthValue;
1615 }
1616 if (*strind == 'x' || *strind == 'X') {
1617 strind++;
1618 tempHeight = ReadInteger(strind, &nextCharacter);
1619 if (strind == nextCharacter)
1620 return (0);
1621 strind = nextCharacter;
1622 mask |= HeightValue;
1623 }
1624
1625 if ((*strind == '+') || (*strind == '-')) {
1626 if (*strind == '-') {
1627 strind++;
1628 tempX = -ReadInteger(strind, &nextCharacter);
1629 if (strind == nextCharacter)
1630 return (0);
1631 strind = nextCharacter;
1632 mask |= XNegative;
1633
1634 }
1635 else
1636 { strind++;
1637 tempX = ReadInteger(strind, &nextCharacter);
1638 if (strind == nextCharacter)
1639 return(0);
1640 strind = nextCharacter;
1641 }
1642 mask |= XValue;
1643 if ((*strind == '+') || (*strind == '-')) {
1644 if (*strind == '-') {
1645 strind++;
1646 tempY = -ReadInteger(strind, &nextCharacter);
1647 if (strind == nextCharacter)
1648 return(0);
1649 strind = nextCharacter;
1650 mask |= YNegative;
1651 }
1652 else
1653 {
1654 strind++;
1655 tempY = ReadInteger(strind, &nextCharacter);
1656 if (strind == nextCharacter)
1657 return(0);
1658 strind = nextCharacter;
1659 }
1660 mask |= YValue;
1661 }
1662 }
1663 /* If strind isn't at the end of the string the it's an invalid
1664 geometry specification. */
1665 if (*strind != '\0') return (0);
1666 if (mask & XValue)
1667 *x = tempX;
1668 if (mask & YValue)
1669 *y = tempY;
1670 if (mask & WidthValue)
1671 *width = tempWidth;
1672 if (mask & HeightValue)
1673 *height = tempHeight;
1674 return (mask);
1675}
1676
1677/* Keep from :
1678 * ftp://ftp.trolltech.com/qt/source/qt-embedded-free-3.0.6.tar.gz/qt-embedded-free-3.0.6/src/kernel/qapplication_qws.cpp
1679 *
1680 */
1681int G4VisCommandViewerCreate::ReadInteger(char *string, char **NextString)
1682{
1683 register int Result = 0;
1684 int Sign = 1;
1685
1686 if (*string == '+')
1687 string++;
1688 else if (*string == '-')
1689 {
1690 string++;
1691 Sign = -1;
1692 }
1693 for (; (*string >= '0') && (*string <= '9'); string++)
1694 {
1695 Result = (Result * 10) + (*string - '0');
1696 }
1697 *NextString = string;
1698 if (Sign >= 0)
1699 return (Result);
1700 else
1701 return (-Result);
1702}
Note: See TracBrowser for help on using the repository browser.