Geant4_10
G4OpenGLViewerMessenger.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: G4OpenGLViewerMessenger.cc 66373 2012-12-18 09:41:34Z gcosmo $
28 
29 #ifdef G4VIS_BUILD_OPENGL_DRIVER
30 
31 #include "G4OpenGLViewerMessenger.hh"
32 
33 #include "G4OpenGLViewer.hh"
34 #include "G4OpenGLStoredViewer.hh"
35 #include "G4OpenGLStoredSceneHandler.hh"
36 #include "G4UImanager.hh"
37 #include "G4UIcommand.hh"
38 #include "G4UIdirectory.hh"
39 #include "G4UIcmdWithoutParameter.hh"
40 #include "G4UIcmdWithADouble.hh"
41 #include "G4UIcmdWithABool.hh"
42 #include "G4UIcmdWithAString.hh"
43 #include "G4UIcmdWithAnInteger.hh"
44 #include "G4VisManager.hh"
45 #include <sstream>
46 
47 G4OpenGLViewerMessenger*
48 G4OpenGLViewerMessenger::fpInstance = 0;
49 
50 G4OpenGLViewerMessenger*
51 G4OpenGLViewerMessenger::GetInstance()
52 {
53  if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
54  return fpInstance;
55 }
56 
57 G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
58 {
59  G4bool omitable;
60 
61  fpDirectory = new G4UIdirectory("/vis/ogl/");
62  fpDirectory->SetGuidance("G4OpenGLViewer commands.");
63 
64  fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
65  fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
66 
67  G4UIparameter* parameter;
68 
69  fpCommandDisplayHeadTime =
70  new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
71  fpCommandDisplayHeadTime->SetGuidance
72  ("Display head time of range in 2D text.");
73  parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
74  parameter->SetDefaultValue(false);
75  fpCommandDisplayHeadTime->SetParameter(parameter);
76  parameter = new G4UIparameter ("screenX", 'd', omitable = true);
77  parameter->SetGuidance("-1 < screenX < 1");
78  parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
79  parameter->SetDefaultValue(-0.9);
80  fpCommandDisplayHeadTime->SetParameter(parameter);
81  parameter = new G4UIparameter ("screenY", 'd', omitable = true);
82  parameter->SetGuidance("-1 < screenY < 1");
83  parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
84  parameter->SetDefaultValue(-0.9);
85  fpCommandDisplayHeadTime->SetParameter(parameter);
86  parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
87  parameter->SetDefaultValue(24.);
88  fpCommandDisplayHeadTime->SetParameter(parameter);
89  parameter = new G4UIparameter ("red", 'd', omitable = true);
90  parameter->SetParameterRange("red >= 0. && red <= 1.");
91  parameter->SetDefaultValue(0.);
92  fpCommandDisplayHeadTime->SetParameter(parameter);
93  parameter = new G4UIparameter ("green", 'd', omitable = true);
94  parameter->SetParameterRange("green >= 0. && green <= 1.");
95  parameter->SetDefaultValue(1.);
96  fpCommandDisplayHeadTime->SetParameter(parameter);
97  parameter = new G4UIparameter ("blue", 'd', omitable = true);
98  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
99  parameter->SetDefaultValue(1.);
100  fpCommandDisplayHeadTime->SetParameter(parameter);
101 
102  fpCommandDisplayLightFront =
103  new G4UIcommand("/vis/ogl/set/displayLightFront", this);
104  fpCommandDisplayLightFront->SetGuidance
105  ("Display the light front at head time.");
106  fpCommandDisplayLightFront->SetGuidance
107  ("Tip: The trajectories can appear of jump ahead of the light front"
108  "\nbecause their time range overlaps the viewer's time range. To"
109  "\naverage out this discrete time effect, advance the light front by"
110  "\nhalf the trajectories interval. E.g., if the trajectory time slice"
111  "\ninterval is 0.01 ns:"
112  "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
113  "\nTo prevent them beating the light front at all:"
114  "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
115  parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
116  parameter->SetDefaultValue(false);
117  fpCommandDisplayLightFront->SetParameter(parameter);
118  parameter = new G4UIparameter ("originX", 'd', omitable = true);
119  parameter->SetDefaultValue(0.);
120  fpCommandDisplayLightFront->SetParameter(parameter);
121  parameter = new G4UIparameter ("originY", 'd', omitable = true);
122  parameter->SetDefaultValue(0.);
123  fpCommandDisplayLightFront->SetParameter(parameter);
124  parameter = new G4UIparameter ("originZ", 'd', omitable = true);
125  parameter->SetDefaultValue(0.);
126  fpCommandDisplayLightFront->SetParameter(parameter);
127  parameter = new G4UIparameter ("space_unit", 's', omitable = true);
128  parameter->SetDefaultValue("m");
129  fpCommandDisplayLightFront->SetParameter(parameter);
130  parameter = new G4UIparameter ("originT", 'd', omitable = true);
131  parameter->SetDefaultValue(0.);
132  fpCommandDisplayLightFront->SetParameter(parameter);
133  parameter = new G4UIparameter ("time_unit", 's', omitable = true);
134  parameter->SetDefaultValue("s");
135  fpCommandDisplayLightFront->SetParameter(parameter);
136  parameter = new G4UIparameter ("red", 'd', omitable = true);
137  parameter->SetParameterRange("red >= 0. && red <= 1.");
138  parameter->SetDefaultValue(0.);
139  fpCommandDisplayLightFront->SetParameter(parameter);
140  parameter = new G4UIparameter ("green", 'd', omitable = true);
141  parameter->SetParameterRange("green >= 0. && green <= 1.");
142  parameter->SetDefaultValue(1.);
143  fpCommandDisplayLightFront->SetParameter(parameter);
144  parameter = new G4UIparameter ("blue", 'd', omitable = true);
145  parameter->SetParameterRange("blue >= 0. && blue <= 1.");
146  parameter->SetDefaultValue(0.);
147  fpCommandDisplayLightFront->SetParameter(parameter);
148 
149  fpCommandDisplayListLimit =
150  new G4UIcmdWithAnInteger("/vis/ogl/set/displayListLimit", this);
151  fpCommandDisplayListLimit->SetGuidance
152  ("Set/reset display list limit (to avoid memory exhaustion).");
153  fpCommandDisplayListLimit->SetParameterName("limit", omitable = true);
154  fpCommandDisplayListLimit->SetDefaultValue(50000);
155  fpCommandDisplayListLimit->SetRange("limit>=10000");
156 
157  fpCommandEndTime =
158  new G4UIcommand("/vis/ogl/set/endTime", this);
159  fpCommandEndTime->SetGuidance("Set end and range of track time.");
160  parameter = new G4UIparameter ("end-time", 'd', omitable = false);
161  parameter->SetDefaultValue(DBL_MAX);
162  fpCommandEndTime->SetParameter(parameter);
163  parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
164  parameter->SetDefaultValue("ns");
165  fpCommandEndTime->SetParameter(parameter);
166  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
167  parameter->SetDefaultValue(-1.);
168  fpCommandEndTime->SetParameter(parameter);
169  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
170  parameter->SetDefaultValue("ns");
171  fpCommandEndTime->SetParameter(parameter);
172 
173  fpCommandEventsDrawInterval =
174  new G4UIcmdWithAnInteger("/vis/ogl/set/eventsDrawInterval", this);
175  fpCommandEventsDrawInterval->SetGuidance
176  ("Set number of events allowed in drawing pipeline - speeds drawing");
177  fpCommandEventsDrawInterval->SetGuidance
178  ("By default, the screen is updated at the end of every event."
179  "\nAllowing OpenGL to buffer several events can make a big improvement"
180  "\nin drawing speed.");
181  fpCommandEventsDrawInterval->SetParameterName("interval", omitable = true);
182  fpCommandEventsDrawInterval->SetDefaultValue(1);
183 
184  fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
185  fpCommandFade->SetGuidance
186  ("0: no fade; 1: maximum fade with time within range.");
187  fpCommandFade->SetParameterName("fadefactor", omitable = false);
188  fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
189  fpCommandFade->SetDefaultValue(0.);
190 
191  fpCommandPrintEPS =
192  new G4UIcmdWithoutParameter("/vis/ogl/printEPS", this);
193  fpCommandPrintEPS->SetGuidance("Print Encapsulated PostScript file.");
194  fpCommandPrintEPS->SetGuidance
195  ("Generates files with names G4OpenGL_n.eps, where n is a sequence"
196  "\nnumber, starting at 0."
197  "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
198 
199  fpCommandPrintFilename =
200  new G4UIcommand("/vis/ogl/set/printFilename", this);
201  fpCommandPrintFilename->SetGuidance ("Set print filename");
202  fpCommandPrintFilename->SetGuidance ("Setting 'incremental' will increment filename by one at each new print, starting at 0");
203  G4UIparameter* parameterPrintFilename;
204  parameterPrintFilename = new G4UIparameter ("name", 's', omitable = true);
205  parameterPrintFilename->SetDefaultValue("G4OpenGL");
206  fpCommandPrintFilename->SetParameter(parameterPrintFilename);
207  parameterPrintFilename = new G4UIparameter ("incremental", 'b', omitable = true);
208  parameterPrintFilename->SetDefaultValue(1);
209  fpCommandPrintFilename->SetParameter(parameterPrintFilename);
210 
211  fpCommandPrintMode = new G4UIcmdWithAString
212  ("/vis/ogl/set/printMode",this);
213  fpCommandPrintMode->SetGuidance("Set print mode");
214  fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
215  fpCommandPrintMode->SetCandidates("vectored pixmap");
216  fpCommandPrintMode->SetDefaultValue("vectored");
217 
218  fpCommandPrintSize =
219  new G4UIcommand("/vis/ogl/set/printSize", this);
220  fpCommandPrintSize->SetGuidance ("Set print size");
221  fpCommandPrintSize->SetGuidance ("Tip : -1 will mean 'print size' = 'window size'");
222  fpCommandPrintSize->SetGuidance (" Setting size greatter than your maximum graphic card capacity , will set the size to maximum size.");
223  G4UIparameter* parameterPrintSize;
224  parameterPrintSize = new G4UIparameter ("width", 'd', omitable = false);
225  parameterPrintSize->SetDefaultValue(-1);
226  fpCommandPrintSize->SetParameter(parameterPrintSize);
227  parameterPrintSize = new G4UIparameter ("height", 'd', omitable = false);
228  parameterPrintSize->SetDefaultValue(-1);
229  fpCommandPrintSize->SetParameter(parameterPrintSize);
230 
231  fpCommandStartTime =
232  new G4UIcommand("/vis/ogl/set/startTime", this);
233  fpCommandStartTime->SetGuidance("Set start and range of track time.");
234  parameter = new G4UIparameter ("start-time", 'd', omitable = false);
235  parameter->SetDefaultValue(-DBL_MAX);
236  fpCommandStartTime->SetParameter(parameter);
237  parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
238  parameter->SetDefaultValue("ns");
239  fpCommandStartTime->SetParameter(parameter);
240  parameter = new G4UIparameter ("time-range", 'd', omitable = true);
241  parameter->SetDefaultValue(-1.);
242  fpCommandStartTime->SetParameter(parameter);
243  parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
244  parameter->SetDefaultValue("ns");
245  fpCommandStartTime->SetParameter(parameter);
246 
247  fpCommandTransparency =
248  new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
249  fpCommandTransparency->SetGuidance
250  ("True/false to enable/disable rendering of transparent objects.");
251  fpCommandTransparency->SetParameterName
252  ("transparency-enabled", omitable = true);
253  fpCommandTransparency->SetDefaultValue(true);
254 }
255 
256 G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
257 {
258  delete fpCommandTransparency;
259  delete fpCommandStartTime;
260  delete fpCommandPrintSize;
261  delete fpCommandPrintMode;
262  delete fpCommandPrintFilename;
263  delete fpCommandPrintEPS;
264  delete fpCommandFade;
265  delete fpCommandEventsDrawInterval;
266  delete fpCommandEndTime;
267  delete fpCommandDisplayListLimit;
268  delete fpCommandDisplayLightFront;
269  delete fpCommandDisplayHeadTime;
270  delete fpDirectorySet;
271  delete fpDirectory;
272 
273  delete fpInstance;
274 }
275 
276 void G4OpenGLViewerMessenger::SetNewValue
277 (G4UIcommand* command, G4String newValue)
278 {
279  G4VisManager* pVisManager = G4VisManager::GetInstance();
280 
281  G4VViewer* pViewer = pVisManager->GetCurrentViewer();
282 
283  if (!pViewer) {
284  G4cout <<
285  "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
286  "\n \"/vis/open\", or similar, to get one."
287  << G4endl;
288  return;
289  }
290 
291  G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
292 
293  if (!pOGLViewer) {
294  G4cout <<
295  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
296  "\n OGL. (It is \""
297  << pViewer->GetName() <<
298  "\".)\n Use \"/vis/viewer/select\" or \"/vis/open\"."
299  << G4endl;
300  return;
301  }
302 
303  if (command == fpCommandPrintEPS)
304  {
305  pOGLViewer->printEPS();
306  if (pOGLViewer->fVP.IsAutoRefresh())
307  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
308  return;
309  }
310 
311  if (command == fpCommandPrintSize)
312  {
313  G4int width,height;
314  std::istringstream iss(newValue);
315  iss >> width
316  >> height;
317  pOGLViewer->setPrintSize(width,height);
318  return;
319  }
320 
321  if (command == fpCommandPrintFilename)
322  {
323  G4String name;
324  G4bool inc;
325  std::istringstream iss(newValue);
326  iss >> name
327  >> inc;
328  pOGLViewer->setPrintFilename(name,inc);
329  return;
330  }
331 
332  if (command == fpCommandPrintMode)
333  {
334  if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
335  if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
336  return;
337  }
338 
339  if (command == fpCommandTransparency)
340  {
341  pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
342  if (pOGLViewer->fVP.IsAutoRefresh())
343  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
344  return;
345  }
346 
347  G4OpenGLStoredViewer* pOGLSViewer =
348  dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
349 
350  if (!pOGLSViewer)
351  {
352  G4cout <<
353  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
354  "\n (It is \"" << pViewer->GetName() << "\".)"
355  "\n This feature is only implemented for OGL Stored viewers."
356  "\n Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
357  << G4endl;
358  return;
359  }
360 
361  if (command == fpCommandDisplayHeadTime)
362  {
363  G4String display;
364  G4double screenX, screenY, screenSize, red, green, blue;
365  std::istringstream iss(newValue);
366  iss >> display >> screenX >> screenY
367  >> screenSize >> red >> green >> blue;
368  pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
369  pOGLSViewer->fDisplayHeadTimeX = screenX;
370  pOGLSViewer->fDisplayHeadTimeY = screenY;
371  pOGLSViewer->fDisplayHeadTimeSize = screenSize;
372  pOGLSViewer->fDisplayHeadTimeRed = red;
373  pOGLSViewer->fDisplayHeadTimeGreen = green;
374  pOGLSViewer->fDisplayHeadTimeBlue = blue;
375  return;
376  }
377 
378  if (command == fpCommandDisplayLightFront)
379  {
380  G4String display, originX, originY, originZ, unitS, originT, unitT;
381  G4double red, green, blue;
382  std::istringstream iss(newValue);
383  iss >> display
384  >> originX >> originY >> originZ >> unitS
385  >> originT >> unitT
386  >> red >> green >> blue;
387  pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
388  pOGLSViewer->fDisplayLightFrontX =
389  command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
390  pOGLSViewer->fDisplayLightFrontY =
391  command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
392  pOGLSViewer->fDisplayLightFrontZ =
393  command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
394  pOGLSViewer->fDisplayLightFrontT =
395  command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
396  pOGLSViewer->fDisplayLightFrontRed = red;
397  pOGLSViewer->fDisplayLightFrontGreen = green;
398  pOGLSViewer->fDisplayLightFrontBlue = blue;
399  return;
400  }
401 
402  if (command == fpCommandEndTime)
403  {
404  G4String end_time_string, end_time_unit,
405  time_range_string, time_range_unit;
406  std::istringstream iss(newValue);
407  iss >> end_time_string >> end_time_unit
408  >> time_range_string >> time_range_unit;
409  pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
410  (G4String(end_time_string + ' ' + end_time_unit));
411  G4double timeRange = command->ConvertToDimensionedDouble
412  (G4String(time_range_string + ' ' + time_range_unit));
413  if (timeRange > 0.) {
414  pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
415  }
416  if (pOGLSViewer->fVP.IsAutoRefresh())
417  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
418  return;
419  }
420 
421  if (command == fpCommandFade)
422  {
423  pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
424  if (pOGLSViewer->fVP.IsAutoRefresh())
425  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
426  return;
427  }
428 
429  if (command == fpCommandStartTime)
430  {
431  G4String start_time_string, start_time_unit,
432  time_range_string, time_range_unit;
433  std::istringstream iss(newValue);
434  iss >> start_time_string >> start_time_unit
435  >> time_range_string >> time_range_unit;
436  pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
437  (G4String(start_time_string + ' ' + start_time_unit));
438  G4double timeRange = command->ConvertToDimensionedDouble
439  (G4String(time_range_string + ' ' + time_range_unit));
440  if (timeRange > 0.) {
441  pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
442  }
443  if (pOGLSViewer->fVP.IsAutoRefresh())
444  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
445  return;
446  }
447 
448  G4VSceneHandler* pSceneHandler = pViewer->GetSceneHandler();
449 
450  if (!pSceneHandler) {
451  G4cout <<
452  "G4OpenGLViewerMessenger::SetNewValue: This viewer has no scene handler."
453  "\n Shouldn't happen - please report circumstances."
454  "\n (Viewer is \"" << pViewer->GetName() << "\".)"
455  "\n Try \"/vis/open\", or similar, to get one."
456  << G4endl;
457  return;
458  }
459 
460  G4OpenGLSceneHandler* pOGLSceneHandler =
461  dynamic_cast<G4OpenGLSceneHandler*>(pSceneHandler);
462 
463  if (!pOGLSceneHandler) {
464  G4cout <<
465  "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
466  "\n OGL. (Viewer is \"" << pViewer->GetName() << "\".)"
467  "\n (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
468  "\n Use \"/vis/sceneHandler/list\" and \"/vis/sceneHandler/select\""
469  "\n or \"/vis/open\"."
470  << G4endl;
471  return;
472  }
473 
474  if (command == fpCommandEventsDrawInterval)
475  {
476  G4int eventsDrawInterval =
477  fpCommandEventsDrawInterval->GetNewIntValue(newValue);
478  pOGLSceneHandler->SetEventsDrawInterval(eventsDrawInterval);
479  return;
480  }
481 
482  G4OpenGLStoredSceneHandler* pOGLSSceneHandler =
483  dynamic_cast<G4OpenGLStoredSceneHandler*>(pViewer->GetSceneHandler());
484 
485  if (!pOGLSSceneHandler) {
486  G4cout <<
487  "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
488  "\n OGLS (Stored). (Viewer is \"" << pViewer->GetName() << "\".)"
489  "\n (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
490  "\n This feature is only implemented for OGL Stored"
491  "\n scene handlers. Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
492  << G4endl;
493  return;
494  }
495 
496  if (command == fpCommandDisplayListLimit)
497  {
498  G4int displayListLimit =
499  fpCommandDisplayListLimit->GetNewIntValue(newValue);
500  pOGLSSceneHandler->SetDisplayListLimit(displayListLimit);
501  return;
502  }
503 }
504 
505 #endif
G4UIcmdWithAString::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAString.cc:42
G4VViewer::GetName
const G4String & GetName() const
G4UIcommand::SetParameter
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:152
red
Definition: test07.cc:36
G4UIdirectory.hh
G4UIcmdWithAnInteger::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAnInteger.cc:47
G4UIcmdWithAnInteger::GetNewIntValue
static G4int GetNewIntValue(const char *paramString)
Definition: G4UIcmdWithAnInteger.cc:41
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition: G4UIparameter.hh:95
G4UIcmdWithAString.hh
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:83
G4VSceneHandler::GetName
const G4String & GetName() const
width
#define width
G4VisManager.hh
name
const XML_Char * name
Definition: expat.h:151
G4UIcmdWithADouble.hh
G4OpenGLViewer.hh
G4OpenGLViewerMessenger::SetNewValue
void SetNewValue(G4UIcommand *, G4String)
blue
Definition: test07.cc:36
G4int
int G4int
Definition: G4Types.hh:78
G4OpenGLStoredViewer.hh
G4UIcommand::ConvertToDimensionedDouble
static G4double ConvertToDimensionedDouble(const char *st)
Definition: G4UIcommand.cc:437
G4UIcmdWithABool::SetDefaultValue
void SetDefaultValue(G4bool defVal)
Definition: G4UIcmdWithABool.cc:55
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:58
G4UIcmdWithABool::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithABool.cc:47
G4OpenGLViewerMessenger.hh
G4cout
G4GLOB_DLL std::ostream G4cout
G4UIcommand.hh
G4OpenGLViewerMessenger::GetInstance
static G4OpenGLViewerMessenger * GetInstance()
G4UIcommand::ConvertToBool
static G4bool ConvertToBool(const char *st)
Definition: G4UIcommand.cc:411
G4bool
bool G4bool
Definition: G4Types.hh:79
G4UIcommand::SetRange
void SetRange(const char *rs)
Definition: G4UIcommand.hh:125
G4UIcommand::SetGuidance
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
G4OpenGLStoredSceneHandler.hh
G4UIcommand::ConvertToDouble
static G4double ConvertToDouble(const char *st)
Definition: G4UIcommand.cc:429
G4UImanager.hh
G4UIcmdWithAString::SetDefaultValue
void SetDefaultValue(const char *defVal)
Definition: G4UIcmdWithAString.cc:57
G4UIcmdWithADouble::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithADouble.cc:47
G4VViewer::GetSceneHandler
G4VSceneHandler * GetSceneHandler() const
G4UIcmdWithADouble::SetDefaultValue
void SetDefaultValue(G4double defVal)
Definition: G4UIcmdWithADouble.cc:55
G4UIcmdWithAnInteger.hh
G4UIcmdWithAString::SetCandidates
void SetCandidates(const char *candidateList)
Definition: G4UIcmdWithAString.cc:50
G4endl
#define G4endl
Definition: G4ios.hh:61
G4VisManager::GetCurrentViewer
G4VViewer * GetCurrentViewer() const
G4UIcmdWithAnInteger::SetDefaultValue
void SetDefaultValue(G4int defVal)
Definition: G4UIcmdWithAnInteger.cc:55
G4double
double G4double
Definition: G4Types.hh:76
G4UIparameter::SetGuidance
void SetGuidance(const char *theGuidance)
Definition: G4UIparameter.hh:138
G4UIcmdWithoutParameter.hh
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83
G4UImanager::ApplyCommand
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:419
G4UIcmdWithABool.hh
Generated on Sat Dec 14 2013 14:35:12 for Geant4_10 by   doxygen 1.8.5