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

Last change on this file since 1136 was 1136, checked in by garnier, 15 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.