Geant4  9.6.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4VisCommandsCompound.cc
Go to the documentation of this file.
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$
28 
29 // Compound /vis/ commands - John Allison 15th May 2000
30 
31 #include "G4VisCommandsCompound.hh"
32 
33 #include "G4VisManager.hh"
34 #include "G4UImanager.hh"
35 #include "G4UIcmdWithAString.hh"
36 
37 #include <sstream>
38 
40 
41 G4VisCommandDrawTree::G4VisCommandDrawTree() {
42  G4bool omitable;
43  fpCommand = new G4UIcommand("/vis/drawTree", this);
44  fpCommand->SetGuidance
45  ("(DTREE) Creates a scene consisting of this physical volume and"
46  "\n produces a representation of the geometry hieracrhy.");
47  fpCommand->SetGuidance("The scene becomes current.");
48  G4UIparameter* parameter;
49  parameter = new G4UIparameter("physical-volume-name", 's', omitable = true);
50  parameter -> SetDefaultValue("world");
51  fpCommand -> SetParameter (parameter);
52  parameter = new G4UIparameter("system", 's', omitable = true);
53  parameter -> SetDefaultValue("ATree");
54  fpCommand -> SetParameter (parameter);
55 }
56 
57 G4VisCommandDrawTree::~G4VisCommandDrawTree() {
58  delete fpCommand;
59 }
60 
61 void G4VisCommandDrawTree::SetNewValue(G4UIcommand*, G4String newValue) {
62 
63  G4String pvname, system;
64  std::istringstream is(newValue);
65  is >> pvname >> system;
66 
67  G4VGraphicsSystem* keepSystem = fpVisManager->GetCurrentGraphicsSystem();
68  G4Scene* keepScene = fpVisManager->GetCurrentScene();
69  G4VSceneHandler* keepSceneHandler = fpVisManager->GetCurrentSceneHandler();
70  G4VViewer* keepViewer = fpVisManager->GetCurrentViewer();
71 
72  G4UImanager* UImanager = G4UImanager::GetUIpointer();
73  G4int keepVerbose = UImanager->GetVerboseLevel();
74  G4int newVerbose(0);
75  if (keepVerbose >= 2 ||
76  fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
77  newVerbose = 2;
78  UImanager->SetVerboseLevel(newVerbose);
79  UImanager->ApplyCommand(G4String("/vis/open " + system));
80  UImanager->ApplyCommand(G4String("/vis/drawVolume " + pvname));
81  UImanager->ApplyCommand("/vis/viewer/flush");
82  UImanager->SetVerboseLevel(keepVerbose);
83 
84  if (keepViewer) {
85  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
86  G4cout << "Reverting to " << keepViewer->GetName() << G4endl;
87  }
88  fpVisManager->SetCurrentGraphicsSystem(keepSystem);
89  fpVisManager->SetCurrentScene(keepScene);
90  fpVisManager->SetCurrentSceneHandler(keepSceneHandler);
91  fpVisManager->SetCurrentViewer(keepViewer);
92  }
93 }
94 
96 
97 G4VisCommandDrawView::G4VisCommandDrawView() {
98  G4bool omitable;
99  fpCommand = new G4UIcommand("/vis/drawView", this);
100  fpCommand->SetGuidance
101  ("Draw view from this angle, etc.");
102  G4UIparameter* parameter;
103  parameter = new G4UIparameter("theta-degrees", 'd', omitable = true);
104  parameter -> SetDefaultValue(0.);
105  fpCommand -> SetParameter (parameter);
106  parameter = new G4UIparameter("phi-degrees", 'd', omitable = true);
107  parameter -> SetDefaultValue(0.);
108  fpCommand -> SetParameter (parameter);
109  parameter = new G4UIparameter("pan-right", 'd', omitable = true);
110  parameter -> SetDefaultValue(0.);
111  fpCommand -> SetParameter (parameter);
112  parameter = new G4UIparameter("pan-up", 'd', omitable = true);
113  parameter -> SetDefaultValue(0.);
114  fpCommand -> SetParameter (parameter);
115  parameter = new G4UIparameter("pan-unit", 's', omitable = true);
116  parameter -> SetDefaultValue("cm");
117  fpCommand -> SetParameter (parameter);
118  parameter = new G4UIparameter("zoom-factor", 'd', omitable = true);
119  parameter -> SetDefaultValue(1.);
120  fpCommand -> SetParameter (parameter);
121  parameter = new G4UIparameter("dolly", 'd', omitable = true);
122  parameter -> SetDefaultValue(0.);
123  fpCommand -> SetParameter (parameter);
124  parameter = new G4UIparameter("dolly-unit", 's', omitable = true);
125  parameter -> SetDefaultValue("cm");
126  fpCommand -> SetParameter (parameter);
127 }
128 
129 G4VisCommandDrawView::~G4VisCommandDrawView() {
130  delete fpCommand;
131 }
132 
133 void G4VisCommandDrawView::SetNewValue(G4UIcommand*, G4String newValue) {
134 
135  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
136 
137  G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
138  if (!currentViewer) {
139  if (verbosity >= G4VisManager::warnings) {
140  G4cout <<
141  "WARNING: G4VisCommandsDrawView::SetNewValue: no current viewer."
142  << G4endl;
143  }
144  return;
145  }
146 
147  G4String thetaDeg;
148  G4String phiDeg;
149  G4String panRight;
150  G4String panUp;
151  G4String panUnit;
152  G4String zoomFactor;
153  G4String dolly;
154  G4String dollyUnit;
155  std::istringstream is(newValue);
156  is >> thetaDeg >> phiDeg >> panRight >> panUp >> panUnit
157  >> zoomFactor >> dolly >> dollyUnit;
158 
159  G4UImanager* UImanager = G4UImanager::GetUIpointer();
160  G4int keepVerbose = UImanager->GetVerboseLevel();
161  G4int newVerbose(0);
162  if (keepVerbose >= 2 ||
163  fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
164  newVerbose = 2;
165  UImanager->SetVerboseLevel(newVerbose);
166  G4ViewParameters vp = currentViewer->GetViewParameters();
167  G4bool keepAutoRefresh = vp.IsAutoRefresh();
168  vp.SetAutoRefresh(false);
169  currentViewer->SetViewParameters(vp);
170  UImanager->ApplyCommand(
171  G4String("/vis/viewer/set/viewpointThetaPhi " + thetaDeg + " " + phiDeg + " deg"));
172  UImanager->ApplyCommand(
173  G4String("/vis/viewer/panTo " + panRight + " " + panUp + " " + panUnit));
174  UImanager->ApplyCommand(
175  G4String("/vis/viewer/zoomTo " + zoomFactor));
176  vp = currentViewer->GetViewParameters();
177  vp.SetAutoRefresh(keepAutoRefresh);
178  currentViewer->SetViewParameters(vp);
179  UImanager->ApplyCommand(
180  G4String("/vis/viewer/dollyTo " + dolly + " " + dollyUnit));
181  UImanager->SetVerboseLevel(keepVerbose);
182 }
183 
185 
186 G4VisCommandDrawVolume::G4VisCommandDrawVolume() {
187  G4bool omitable;
188  fpCommand = new G4UIcmdWithAString("/vis/drawVolume", this);
189  fpCommand->SetGuidance
190  ("Creates a scene containing this physical volume and asks the"
191  "\ncurrent viewer to draw it. The scene becomes current.");
192  fpCommand -> SetGuidance
193  ("If physical-volume-name is \"world\" (the default), the main geometry"
194  "\ntree (material world) is drawn. If \"worlds\", all worlds - material"
195  "\nworld and parallel worlds, if any - are drawn. Otherwise a search of"
196  "\nall worlds is made, taking the first matching occurence only. To see"
197  "\na representation of the geometry hierarchy of the worlds, try"
198  "\n\"/vis/drawTree [worlds]\" or one of the driver/browser combinations"
199  "\nthat have the required functionality, e.g., HepRep");
200  fpCommand->SetParameterName("physical-volume-name", omitable = true);
201  fpCommand->SetDefaultValue("world");
202 }
203 
204 G4VisCommandDrawVolume::~G4VisCommandDrawVolume() {
205  delete fpCommand;
206 }
207 
208 void G4VisCommandDrawVolume::SetNewValue(G4UIcommand*, G4String newValue) {
209  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
210  G4UImanager* UImanager = G4UImanager::GetUIpointer();
211  G4int keepVerbose = UImanager->GetVerboseLevel();
212  G4int newVerbose(0);
213  if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
214  newVerbose = 2;
215  UImanager->SetVerboseLevel(newVerbose);
216  UImanager->ApplyCommand("/vis/scene/create");
217  UImanager->ApplyCommand(G4String("/vis/scene/add/volume " + newValue));
218  UImanager->ApplyCommand("/vis/sceneHandler/attach");
219  UImanager->SetVerboseLevel(keepVerbose);
220  static G4bool warned = false;
221  if (verbosity >= G4VisManager::confirmations && !warned) {
222  G4cout <<
223  "NOTE: For systems which are not \"auto-refresh\" you will need to"
224  "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
225  << G4endl;
226  warned = true;
227  }
228 }
229 
231 
232 G4VisCommandOpen::G4VisCommandOpen() {
233  G4bool omitable;
234  fpCommand = new G4UIcommand("/vis/open", this);
235  fpCommand->SetGuidance
236  ("Creates a scene handler ready for drawing.");
237  fpCommand->SetGuidance
238  ("The scene handler becomes current (the name is auto-generated).");
239  G4UIparameter* parameter;
240  parameter = new G4UIparameter("graphics-system-name", 's', omitable = false);
241  const G4GraphicsSystemList& gslist =
242  fpVisManager->GetAvailableGraphicsSystems();
243  G4String candidates;
244  for (size_t igslist = 0; igslist < gslist.size(); igslist++) {
245  const G4String& name = gslist[igslist]->GetName();
246  const G4String& nickname = gslist[igslist]->GetNickname();
247  if (nickname.isNull()) {
248  candidates += name;
249  }
250  else {
251  candidates += nickname;
252  }
253  candidates += " ";
254  }
255  candidates = candidates.strip();
256  parameter->SetParameterCandidates(candidates);
257  fpCommand->SetParameter(parameter);
258  parameter = new G4UIparameter("window-size-hint", 's', omitable = true);
259  parameter->SetGuidance
260  ("integer (pixels) for square window placed by window manager or"
261  " X-Windows-type geometry string, e.g. 600x600-100+100");
262  parameter->SetDefaultValue("600");
263  fpCommand->SetParameter(parameter);
264 }
265 
266 G4VisCommandOpen::~G4VisCommandOpen() {
267  delete fpCommand;
268 }
269 
270 void G4VisCommandOpen::SetNewValue (G4UIcommand*, G4String newValue) {
271  G4String systemName, windowSizeHint;
272  std::istringstream is(newValue);
273  is >> systemName >> windowSizeHint;
274  G4UImanager* UImanager = G4UImanager::GetUIpointer();
275  G4int keepVerbose = UImanager->GetVerboseLevel();
276  G4int newVerbose(0);
277  if (keepVerbose >= 2 ||
278  fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
279  newVerbose = 2;
280  UImanager->SetVerboseLevel(newVerbose);
281  UImanager->ApplyCommand(G4String("/vis/sceneHandler/create " + systemName));
282  UImanager->ApplyCommand(G4String("/vis/viewer/create ! ! " + windowSizeHint));
283  UImanager->SetVerboseLevel(keepVerbose);
284 }
285 
287 
288 G4VisCommandSpecify::G4VisCommandSpecify() {
289  G4bool omitable;
290  fpCommand = new G4UIcommand("/vis/specify", this);
291  fpCommand->SetGuidance
292  ("Draws logical volume with Boolean components, voxels and readout geometry.");
293  fpCommand->SetGuidance
294  ("Creates a scene consisting of this logical volume and asks the"
295  "\n current viewer to draw it to the specified depth of descent"
296  "\n showing boolean components (if any), voxels (if any)"
297  "\n and readout geometry (if any), under control of the appropriate flag.");
298  fpCommand->SetGuidance
299  ("Note: voxels are not constructed until start of run - /run/beamOn.");
300  fpCommand->SetGuidance("The scene becomes current.");
301  G4UIparameter* parameter;
302  parameter = new G4UIparameter("logical-volume-name", 's', omitable = false);
303  fpCommand->SetParameter(parameter);
304  parameter = new G4UIparameter("depth-of-descent", 'i', omitable = true);
305  parameter->SetDefaultValue(1);
306  fpCommand->SetParameter(parameter);
307  parameter = new G4UIparameter("booleans-flag", 'b', omitable = true);
308  parameter->SetDefaultValue(true);
309  fpCommand->SetParameter(parameter);
310  parameter = new G4UIparameter("voxels-flag", 'b', omitable = true);
311  parameter->SetDefaultValue(true);
312  fpCommand->SetParameter(parameter);
313  parameter = new G4UIparameter("readout-flag", 'b', omitable = true);
314  parameter->SetDefaultValue(true);
315  fpCommand->SetParameter(parameter);
316 }
317 
318 G4VisCommandSpecify::~G4VisCommandSpecify() {
319  delete fpCommand;
320 }
321 
322 void G4VisCommandSpecify::SetNewValue(G4UIcommand*, G4String newValue) {
323  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
324  G4UImanager* UImanager = G4UImanager::GetUIpointer();
325  G4int keepVerbose = UImanager->GetVerboseLevel();
326  G4int newVerbose(0);
327  if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
328  newVerbose = 2;
329  UImanager->SetVerboseLevel(newVerbose);
330  // UImanager->ApplyCommand(G4String("/geometry/print " + newValue));
331  UImanager->ApplyCommand("/vis/scene/create");
332  UImanager->ApplyCommand(G4String("/vis/scene/add/logicalVolume " + newValue));
333  UImanager->ApplyCommand("/vis/sceneHandler/attach");
334  UImanager->SetVerboseLevel(keepVerbose);
335  static G4bool warned = false;
336  if (verbosity >= G4VisManager::confirmations && !warned) {
337  G4cout <<
338  "NOTE: For systems which are not \"auto-refresh\" you will need to"
339  "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
340  << G4endl;
341  warned = true;
342  }
343 }
Generated on Sat May 25 2013 14:34:15 for Geant4 by   doxygen 1.8.4