source: trunk/source/visualization/management/src/G4VisCommandsScene.cc @ 806

Last change on this file since 806 was 606, checked in by garnier, 17 years ago

r647@mac-90108: laurentgarnier | 2007-11-15 11:32:46 +0100
Ok en Qt 4.3.0
  • Property svn:mime-type set to text/cpp
File size: 22.0 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: G4VisCommandsScene.cc,v 1.67 2007/11/10 15:03:56 allison Exp $
28// GEANT4 tag $Name:  $
29
30// /vis/scene commands - John Allison  9th August 1998
31
32#include "G4VisCommandsScene.hh"
33
34#include "G4VisManager.hh"
35#include "G4TransportationManager.hh"
36#include "G4RunManager.hh"
37#include "G4Run.hh"
38#include "G4PhysicalVolumeModel.hh"
39#include "G4ApplicationState.hh"
40#include "G4UImanager.hh"
41#include "G4UIcommand.hh"
42#include "G4UIcmdWithAString.hh"
43#include "G4ios.hh"
44#include <sstream>
45
46G4VVisCommandScene::G4VVisCommandScene () {}
47
48G4VVisCommandScene::~G4VVisCommandScene () {}
49
50G4String G4VVisCommandScene::CurrentSceneName () {
51  const G4Scene* pScene = fpVisManager -> GetCurrentScene ();
52  G4String currentSceneName;
53  if (pScene) currentSceneName = pScene -> GetName ();
54  return currentSceneName;
55}
56
57////////////// /vis/scene/create ///////////////////////////////////////
58
59G4VisCommandSceneCreate::G4VisCommandSceneCreate (): fId (0) {
60  G4bool omitable;
61  fpCommand = new G4UIcmdWithAString ("/vis/scene/create", this);
62  fpCommand -> SetGuidance
63    ("Creates an empty scene.");
64  fpCommand -> SetGuidance
65    ("Invents a name if not supplied.  This scene becomes current.");
66  fpCommand -> SetParameterName ("scene-name", omitable = true);
67}
68
69G4VisCommandSceneCreate::~G4VisCommandSceneCreate () {
70  delete fpCommand;
71}
72
73G4String G4VisCommandSceneCreate::NextName () {
74  std::ostringstream oss;
75  oss << "scene-" << fId;
76  return oss.str();
77}
78
79G4String G4VisCommandSceneCreate::GetCurrentValue (G4UIcommand*) {
80  return "";
81}
82
83void G4VisCommandSceneCreate::SetNewValue (G4UIcommand*, G4String newValue) {
84
85  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
86
87  G4String& newName = newValue;
88  G4String nextName = NextName ();
89
90  if (newName == "") {
91    newName = nextName;
92  }
93  if (newName == nextName) fId++;
94
95  G4SceneList& sceneList = fpVisManager -> SetSceneList ();
96  G4int iScene, nScenes = sceneList.size ();
97  for (iScene = 0; iScene < nScenes; iScene++) {
98    if (sceneList [iScene] -> GetName () == newName) break;
99  }
100  if (iScene < nScenes) {
101    if (verbosity >= G4VisManager::warnings) {
102      G4cout << "WARNING: Scene \"" << newName << "\" already exists."
103             << "\n  New scene not created."
104             << G4endl;
105    }
106  } else {
107
108    // Add empty scene data object to list...
109    G4Scene* pScene = new G4Scene (newName);
110    sceneList.push_back (pScene);
111    fpVisManager -> SetCurrentScene (pScene);
112
113    if (verbosity >= G4VisManager::confirmations) {
114      G4cout << "New empty scene \"" << newName << "\" created." << G4endl;
115    }
116  }
117}
118
119////////////// /vis/scene/endOfEventAction ////////////////////////////
120
121G4VisCommandSceneEndOfEventAction::G4VisCommandSceneEndOfEventAction () {
122  G4bool omitable;
123  fpCommand = new G4UIcommand ("/vis/scene/endOfEventAction", this);
124  fpCommand -> SetGuidance
125    ("Accumulate or refresh the viewer for each new event.");
126  fpCommand -> SetGuidance
127    ("\"accumulate\": viewer accumulates hits, etc., event by event, or");
128  fpCommand -> SetGuidance
129    ("\"refresh\": viewer shows them at end of event or, for direct-screen"
130     "\n  viewers, refreshes the screen just before drawing the next event.");
131  G4UIparameter* parameter;
132  parameter = new G4UIparameter ("action", 's', omitable = true);
133  parameter -> SetParameterCandidates ("accumulate refresh");
134  parameter -> SetDefaultValue ("refresh");
135  fpCommand -> SetParameter (parameter);
136  parameter = new G4UIparameter ("maxNumber", 'i', omitable = true);
137  parameter -> SetDefaultValue (100);
138  parameter -> SetGuidance
139  ("Maximum number of events kept.  Unlimited if negative.");
140  fpCommand -> SetParameter (parameter);
141}
142
143G4VisCommandSceneEndOfEventAction::~G4VisCommandSceneEndOfEventAction () {
144  delete fpCommand;
145}
146
147G4String G4VisCommandSceneEndOfEventAction::GetCurrentValue(G4UIcommand*) {
148  return "";
149}
150
151void G4VisCommandSceneEndOfEventAction::SetNewValue (G4UIcommand*,
152                                                     G4String newValue) {
153
154  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
155
156  G4String action;
157  G4int maxNumberOfKeptEvents;
158  std::istringstream is (newValue);
159  is >> action >> maxNumberOfKeptEvents;
160
161  G4Scene* pScene = fpVisManager->GetCurrentScene();
162  if (!pScene) {
163    if (verbosity >= G4VisManager::errors) {
164      G4cout << "ERROR: No current scene.  Please create one." << G4endl;
165    }
166    return;
167  }
168
169  G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
170  if (!pSceneHandler) {
171    if (verbosity >= G4VisManager::errors) {
172      G4cout << "ERROR: No current sceneHandler.  Please create one." << G4endl;
173    }
174    return;
175  }
176
177  if (action == "accumulate") {
178    pScene->SetRefreshAtEndOfEvent(false);
179    pScene->SetMaxNumberOfKeptEvents(maxNumberOfKeptEvents);
180  }
181  else if (action == "refresh") {
182    if (!pScene->GetRefreshAtEndOfRun()) {
183      if (verbosity >= G4VisManager::errors) {
184        G4cout <<
185          "ERROR: Cannot refresh events unless runs refresh too."
186          "\n  Use \"/vis/scene/endOfRun refresh\"."
187               << G4endl;
188      }
189    } else {
190      pScene->SetRefreshAtEndOfEvent(true);
191      pSceneHandler->SetMarkForClearingTransientStore(true);
192    }
193  }
194  else {
195    if (verbosity >= G4VisManager::errors) {
196      G4cout <<
197        "ERROR: unrecognised parameter \"" << action << "\"."
198             << G4endl;
199    }
200    return;
201  }
202
203  // Change of transients behaviour, so...
204  fpVisManager->ResetTransientsDrawnFlags();
205
206  // Are there any events currently kept...
207  size_t nCurrentlyKept = 0;
208  G4RunManager* runManager = G4RunManager::GetRunManager();
209  if (runManager) {
210    const G4Run* currentRun = runManager->GetCurrentRun();
211    if (currentRun) {
212      const std::vector<const G4Event*>* events =
213        currentRun->GetEventVector();
214      if (events) nCurrentlyKept = events->size();
215    }
216  }
217
218  if (verbosity >= G4VisManager::confirmations) {
219    G4cout << "End of event action set to ";
220    if (pScene->GetRefreshAtEndOfEvent()) G4cout << "\"refresh\".";
221    else {
222      G4cout << "\"accumulate\"."
223        "\n  Maximum number of events to be kept: "
224             << maxNumberOfKeptEvents
225             << " (unlimited if negative)."
226        "\n  This may be changed with, e.g., "
227        "\"/vis/scene/endOfEventAction accumulate 1000\".";
228    }
229    G4cout << G4endl;
230  }
231
232  if (!pScene->GetRefreshAtEndOfEvent() &&
233      maxNumberOfKeptEvents != 0 &&
234      verbosity >= G4VisManager::warnings) {
235    G4cout << "WARNING: ";
236    if (nCurrentlyKept) {
237      G4cout <<
238        "\n  There are currently " << nCurrentlyKept
239             << " events kept for refreshing and/or reviewing.";
240    } else {
241      G4cout << "The vis manager will keep ";
242      if (maxNumberOfKeptEvents < 0) G4cout << "an unlimited number of";
243      else G4cout << "up to " << maxNumberOfKeptEvents;
244      G4cout << " events.";
245      if (maxNumberOfKeptEvents > 1 || maxNumberOfKeptEvents < 0)
246        G4cout << "\n  This may use a lot of memory.";
247    }
248    G4cout << G4endl;
249  }
250}
251
252////////////// /vis/scene/endOfRunAction ////////////////////////////
253
254G4VisCommandSceneEndOfRunAction::G4VisCommandSceneEndOfRunAction () {
255  G4bool omitable;
256  fpCommand = new G4UIcmdWithAString ("/vis/scene/endOfRunAction", this);
257  fpCommand -> SetGuidance
258    ("Accumulate or refresh the viewer for each new run.");
259  fpCommand -> SetGuidance
260    ("\"accumulate\": viewer accumulates hits, etc., run by run, or");
261  fpCommand -> SetGuidance
262    ("\"refresh\": viewer shows them at end of run or, for direct-screen"
263     "\n  viewers, refreshes the screen just before drawing the first"
264     "\n  event of the next run.");
265  fpCommand -> SetGuidance ("The detector remains or is redrawn.");
266  fpCommand -> SetParameterName ("action", omitable = true);
267  fpCommand -> SetCandidates ("accumulate refresh");
268  fpCommand -> SetDefaultValue ("refresh");
269}
270
271G4VisCommandSceneEndOfRunAction::~G4VisCommandSceneEndOfRunAction () {
272  delete fpCommand;
273}
274
275G4String G4VisCommandSceneEndOfRunAction::GetCurrentValue(G4UIcommand*) {
276  return "";
277}
278
279void G4VisCommandSceneEndOfRunAction::SetNewValue (G4UIcommand*,
280                                                     G4String newValue) {
281
282  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
283
284  G4String action;
285  std::istringstream is (newValue);
286  is >> action;
287
288  G4Scene* pScene = fpVisManager->GetCurrentScene();
289  if (!pScene) {
290    if (verbosity >= G4VisManager::errors) {
291      G4cout << "ERROR: No current scene.  Please create one." << G4endl;
292    }
293    return;
294  }
295
296  G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
297  if (!pSceneHandler) {
298    if (verbosity >= G4VisManager::errors) {
299      G4cout << "ERROR: No current sceneHandler.  Please create one." << G4endl;
300    }
301    return;
302  }
303
304  if (action == "accumulate") {
305    if (pScene->GetRefreshAtEndOfEvent()) {
306      if (verbosity >= G4VisManager::errors) {
307        G4cout <<
308          "ERROR: Cannot accumulate runs unless events accumulate too."
309          "\n  Use \"/vis/scene/endOfEventAction accumulate\"."
310               << G4endl;
311      }
312    }
313    else {
314      pScene->SetRefreshAtEndOfRun(false);
315    }
316  }
317  else if (action == "refresh") {
318    pScene->SetRefreshAtEndOfRun(true);
319    pSceneHandler->SetMarkForClearingTransientStore(true);
320  }
321  else {
322    if (verbosity >= G4VisManager::errors) {
323      G4cout <<
324        "ERROR: unrecognised parameter \"" << action << "\"."
325             << G4endl;
326    }
327    return;
328  }
329
330  // Change of transients behaviour, so...
331  fpVisManager->ResetTransientsDrawnFlags();
332
333  if (verbosity >= G4VisManager::confirmations) {
334    G4cout << "End of run action set to \"";
335    if (pScene->GetRefreshAtEndOfRun()) G4cout << "refresh";
336    else G4cout << "accumulate";
337    G4cout << "\"" << G4endl;
338  }
339}
340
341////////////// /vis/scene/list ///////////////////////////////////////
342
343G4VisCommandSceneList::G4VisCommandSceneList () {
344  G4bool omitable;
345  fpCommand = new G4UIcommand ("/vis/scene/list", this);
346  fpCommand -> SetGuidance ("Lists scene(s).");
347  fpCommand -> SetGuidance
348    ("\"help /vis/verbose\" for definition of verbosity.");
349  G4UIparameter* parameter;
350  parameter = new G4UIparameter ("scene-name", 's', omitable = true);
351  parameter -> SetDefaultValue ("all");
352  fpCommand -> SetParameter (parameter);
353  parameter = new G4UIparameter ("verbosity", 's', omitable = true);
354  parameter -> SetDefaultValue ("warnings");
355  fpCommand -> SetParameter (parameter);
356}
357
358G4VisCommandSceneList::~G4VisCommandSceneList () {
359  delete fpCommand;
360}
361
362G4String G4VisCommandSceneList::GetCurrentValue (G4UIcommand*) {
363  return "";
364}
365
366void G4VisCommandSceneList::SetNewValue (G4UIcommand*, G4String newValue) {
367  G4String name, verbosityString;
368  std::istringstream is (newValue);
369  is >> name >> verbosityString;
370  G4VisManager::Verbosity verbosity =
371    fpVisManager->GetVerbosityValue(verbosityString);
372  const G4Scene* currentScene = fpVisManager -> GetCurrentScene ();
373  G4String currentName;
374  if (currentScene) currentName = currentScene->GetName();
375
376  G4SceneList& sceneList = fpVisManager -> SetSceneList ();
377  G4int iScene, nScenes = sceneList.size ();
378  G4bool found = false;
379  for (iScene = 0; iScene < nScenes; iScene++) {
380    G4Scene* pScene = sceneList [iScene];
381    const G4String& iName = pScene -> GetName ();
382    if (name != "all") {
383      if (name != iName) continue;
384    }
385    found = true;
386    if (iName == currentName) {
387      G4cout << "  (current)";
388    }
389    else {
390      G4cout << "           ";
391    }
392    G4cout << " scene \"" << iName << "\"";
393    if (verbosity >= G4VisManager::confirmations) {
394      G4int i;
395      G4cout << "\n  Run-duration models:";
396      G4int nRunModels = pScene -> GetRunDurationModelList ().size ();
397      if (nRunModels == 0) {
398        G4cout << " none.";
399      }
400      for (i = 0; i < nRunModels; i++) {
401        G4VModel* pModel = pScene -> GetRunDurationModelList () [i];
402        G4cout << "\n    " << pModel -> GetGlobalDescription ();
403      }
404      G4cout << "\n  End-of-event models:";
405      G4int nEOEModels = pScene -> GetEndOfEventModelList ().size ();
406      if (nEOEModels == 0) {
407        G4cout << " none.";
408      }
409      for (i = 0; i < nEOEModels; i++) {
410        G4VModel* pModel = pScene -> GetEndOfEventModelList () [i];
411        G4cout << "\n    " << pModel -> GetGlobalDescription ();
412      }
413    }
414    if (verbosity >= G4VisManager::parameters) {
415      G4cout << "\n  " << *sceneList [iScene];
416    }
417    G4cout << G4endl;
418  }
419  if (!found) {
420    G4cout << "No scenes found";
421    if (name != "all") {
422      G4cout << " of name \"" << name << "\"";
423    }
424    G4cout << "." << G4endl;
425  }
426}
427
428////////////// /vis/scene/notifyHandlers /////////////////////////
429
430G4VisCommandSceneNotifyHandlers::G4VisCommandSceneNotifyHandlers () {
431  G4bool omitable;
432  fpCommand = new G4UIcommand ("/vis/scene/notifyHandlers", this);
433  fpCommand -> SetGuidance
434    ("Notifies scene handlers and forces re-rendering.");
435  fpCommand -> SetGuidance
436    ("Notifies the handler(s) of the specified scene and forces a"
437     "\nreconstruction of any graphical databases."
438     "\nClears and refreshes all viewers of current scene."
439     "\n  The default action \"refresh\" does not issue \"update\" (see"
440     "\n    /vis/viewer/update)."
441     "\nIf \"flush\" is specified, it issues an \"update\" as well as"
442     "\n  \"refresh\" - \"update\" and initiates post-processing"
443     "\n  for graphics systems which need it.");
444  fpCommand -> SetGuidance
445    ("The default for <scene-name> is the current scene name.");
446  fpCommand -> SetGuidance
447    ("This command does not change current scene, scene handler or viewer.");
448  G4UIparameter* parameter;
449  parameter = new G4UIparameter ("scene-name", 's',
450                                 omitable = true);
451  parameter -> SetCurrentAsDefault(true);
452  fpCommand -> SetParameter (parameter);
453  parameter = new G4UIparameter ("refresh-flush", 's',
454                                 omitable = true);
455  parameter -> SetDefaultValue("refresh");
456  parameter -> SetParameterCandidates("r refresh f flush");
457  fpCommand -> SetParameter (parameter);
458}
459
460G4VisCommandSceneNotifyHandlers::~G4VisCommandSceneNotifyHandlers () {
461  delete fpCommand;
462}
463
464G4String G4VisCommandSceneNotifyHandlers::GetCurrentValue(G4UIcommand*) {
465  return CurrentSceneName ();
466}
467
468void G4VisCommandSceneNotifyHandlers::SetNewValue (G4UIcommand*,
469                                                   G4String newValue) {
470
471  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
472
473  G4String sceneName, refresh_flush;
474  std::istringstream is (newValue);
475  is >> sceneName >> refresh_flush;
476  G4bool flush = false;
477  if (refresh_flush(0) == 'f') flush = true;
478
479  const G4SceneList& sceneList = fpVisManager -> GetSceneList ();
480  G4SceneHandlerList& sceneHandlerList =
481    fpVisManager -> SetAvailableSceneHandlers ();
482
483  // Check scene name.
484  const G4int nScenes = sceneList.size ();
485  G4int iScene;
486  for (iScene = 0; iScene < nScenes; iScene++) {
487    G4Scene* scene = sceneList [iScene];
488    if (sceneName == scene -> GetName ()) break;
489  }
490  if (iScene >= nScenes ) {
491    if (verbosity >= G4VisManager::warnings) {
492      G4cout << "WARNING: Scene \"" << sceneName << "\" not found."
493        "\n  /vis/scene/list to see scenes."
494             << G4endl;
495    }
496    return;
497  }
498
499  // Store current context...
500  G4VSceneHandler* pCurrentSceneHandler =
501    fpVisManager -> GetCurrentSceneHandler();
502  if (!pCurrentSceneHandler) {
503    if (verbosity >= G4VisManager::warnings) {
504      G4cout << "WARNING: No current scene handler."
505             << G4endl;
506    }
507    return;
508  }
509  G4VViewer* pCurrentViewer = fpVisManager -> GetCurrentViewer();
510  if (!pCurrentViewer) {
511    if (verbosity >= G4VisManager::warnings) {
512      G4cout << "WARNING: No current viewer."
513             << G4endl;
514    }
515    return;
516  }
517  G4Scene* pCurrentScene = fpVisManager -> GetCurrentScene();
518  if (!pCurrentScene) {
519    if (verbosity >= G4VisManager::warnings) {
520      G4cout << "WARNING: No current scene."
521             << G4endl;
522    }
523    return;
524  }
525  G4VisManager::Verbosity currentVerbosity = fpVisManager -> GetVerbosity();
526
527  // Suppress messages during this process (only print errors)...
528  //fpVisManager -> SetVerboseLevel(G4VisManager::errors);
529
530  // For each scene handler, if it contains the scene, clear and
531  // rebuild the graphical database, then for each viewer set (make
532  // current), clear, (re)draw, and show.
533  const G4int nSceneHandlers = sceneHandlerList.size ();
534  for (G4int iSH = 0; iSH < nSceneHandlers; iSH++) {
535    G4VSceneHandler* aSceneHandler = sceneHandlerList [iSH];
536    G4Scene* aScene = aSceneHandler -> GetScene ();
537    if (aScene) {
538      const G4String& aSceneName = aScene -> GetName ();
539      if (sceneName == aSceneName) {
540        // Clear store and force a rebuild of graphical database...
541        //aSceneHandler -> ClearStore (); // Not nec??  Done below
542        //with NeedKernelVisit and DrawView.  JA.
543        G4ViewerList& viewerList = aSceneHandler -> SetViewerList ();
544        const G4int nViewers = viewerList.size ();
545        for (G4int iV = 0; iV < nViewers; iV++) {
546          G4VViewer* aViewer = viewerList [iV];
547          if (aViewer->GetViewParameters().IsAutoRefresh()) {
548            aSceneHandler -> SetCurrentViewer (aViewer);
549            // Ensure consistency of vis manager...
550            fpVisManager -> SetCurrentViewer(aViewer);
551            fpVisManager -> SetCurrentSceneHandler(aSceneHandler);
552            fpVisManager -> SetCurrentScene(aScene);
553            // Re-draw, forcing rebuild of graphics database, if any...
554            aViewer -> NeedKernelVisit();
555            aViewer -> SetView ();
556            aViewer -> ClearView ();
557            aViewer -> DrawView ();
558            if (flush) aViewer -> ShowView ();
559            if (verbosity >= G4VisManager::confirmations) {
560              G4cout << "Viewer \"" << aViewer -> GetName ()
561                     << "\" of scene handler \"" << aSceneHandler -> GetName ()
562                     << "\"\n  ";
563              if (flush) G4cout << "flushed";
564              else G4cout << "refreshed";
565              G4cout << " at request of scene \"" << sceneName
566                     << "\"." << G4endl;
567            }
568          } else {
569            if (verbosity >= G4VisManager::warnings) {
570              G4cout << "WARNING: The scene, \""
571                     << sceneName
572                     << "\", of viewer \""
573                     << aViewer -> GetName ()
574                     << "\"\n  of scene handler \""
575                     << aSceneHandler -> GetName ()
576                     << "\"  has changed.  To see effect,"
577                     << "\n  \"/vis/viewer/select "
578                     << aViewer -> GetShortName ()
579                     << "\" and \"/vis/viewer/rebuild\"."
580                     << G4endl;
581            }
582          }
583        }
584      }
585    }
586    else {
587      if (verbosity >= G4VisManager::warnings) {
588        G4cout << "WARNING: G4VisCommandSceneNotifyHandlers: scene handler \""
589               << aSceneHandler->GetName()
590               << "\" has a null scene."
591               << G4endl;
592      }
593    }
594  }
595
596  // Reclaim original context - but set viewer first, then scene
597  // handler, because the latter might have been created very recently
598  // and, not yet having a viewer, the current viewer will,
599  // temporarily, refer to another scene handler.  SetCurrentViewer
600  // actually resets the scene handler, which is what we don't want,
601  // so we set it again on the next line...
602  fpVisManager -> SetCurrentViewer(pCurrentViewer);
603  fpVisManager -> SetCurrentSceneHandler(pCurrentSceneHandler);
604  fpVisManager -> SetCurrentScene(pCurrentScene);
605  fpVisManager -> SetVerboseLevel(currentVerbosity);
606  // Take care of special case of scene handler with no viewer yet. 
607  if (pCurrentSceneHandler) {
608    G4ViewerList& viewerList = pCurrentSceneHandler -> SetViewerList ();
609    const G4int nViewers = viewerList.size ();
610    if (nViewers) {
611      pCurrentSceneHandler -> SetCurrentViewer (pCurrentViewer);
612      if (pCurrentViewer && pCurrentSceneHandler->GetScene()) {
613        pCurrentViewer -> SetView ();
614      }
615    }
616  }
617}
618
619////////////// /vis/scene/select ///////////////////////////////////////
620
621G4VisCommandSceneSelect::G4VisCommandSceneSelect () {
622  G4bool omitable;
623  fpCommand = new G4UIcmdWithAString ("/vis/scene/select", this);
624  fpCommand -> SetGuidance ("Selects a scene");
625  fpCommand -> SetGuidance
626    ("Makes the scene current.  \"/vis/scene/list\" to see"
627     "\n possible scene names.");
628  fpCommand -> SetParameterName ("scene-name", omitable = false);
629}
630
631G4VisCommandSceneSelect::~G4VisCommandSceneSelect () {
632  delete fpCommand;
633}
634
635G4String G4VisCommandSceneSelect::GetCurrentValue (G4UIcommand*) {
636  return "";
637}
638
639void G4VisCommandSceneSelect::SetNewValue (G4UIcommand*, G4String newValue) {
640
641  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
642
643  G4String& selectName = newValue;
644  G4SceneList& sceneList = fpVisManager -> SetSceneList ();
645  G4int iScene, nScenes = sceneList.size ();
646  for (iScene = 0; iScene < nScenes; iScene++) {
647    if (sceneList [iScene] -> GetName () == selectName) break;
648  }
649  if (iScene >= nScenes) {
650    if (verbosity >= G4VisManager::warnings) {
651      G4cout << "WARNING: Scene \"" << selectName
652             << "\" not found - \"/vis/scene/list\" to see possibilities."
653             << G4endl;
654    }
655    return;
656  }
657
658  if (verbosity >= G4VisManager::confirmations) {
659    G4cout << "Scene \"" << selectName
660           << "\" selected." << G4endl;
661  }
662  UpdateVisManagerScene (selectName);
663}
Note: See TracBrowser for help on using the repository browser.