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

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

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