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

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

before tag

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