Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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$
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
47G4OpenGLViewerMessenger*
48G4OpenGLViewerMessenger::fpInstance = 0;
49
50G4OpenGLViewerMessenger*
51G4OpenGLViewerMessenger::GetInstance()
52{
53 if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
54 return fpInstance;
55}
56
57G4OpenGLViewerMessenger::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
256G4OpenGLViewerMessenger::~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
276void 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
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
G4OpenGLViewerMessenger::GetInstance
static G4OpenGLViewerMessenger * GetInstance()
G4OpenGLViewerMessenger::SetNewValue
void SetNewValue(G4UIcommand *, G4String)
G4UIcmdWithABool::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithABool.cc:47
G4UIcmdWithABool::SetDefaultValue
void SetDefaultValue(G4bool defVal)
Definition: G4UIcmdWithABool.cc:55
G4UIcmdWithADouble::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithADouble.cc:47
G4UIcmdWithADouble::SetDefaultValue
void SetDefaultValue(G4double defVal)
Definition: G4UIcmdWithADouble.cc:55
G4UIcmdWithAString::SetCandidates
void SetCandidates(const char *candidateList)
Definition: G4UIcmdWithAString.cc:50
G4UIcmdWithAString::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAString.cc:42
G4UIcmdWithAString::SetDefaultValue
void SetDefaultValue(const char *defVal)
Definition: G4UIcmdWithAString.cc:57
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
G4UIcmdWithAnInteger::SetDefaultValue
void SetDefaultValue(G4int defVal)
Definition: G4UIcmdWithAnInteger.cc:55
G4UIcommand::SetParameter
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:147
G4UIcommand::SetGuidance
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:156
G4UIcommand::ConvertToBool
static G4bool ConvertToBool(const char *st)
Definition: G4UIcommand.cc:403
G4UIcommand::SetRange
void SetRange(const char *rs)
Definition: G4UIcommand.hh:120
G4UIcommand::ConvertToDouble
static G4double ConvertToDouble(const char *st)
Definition: G4UIcommand.cc:421
G4UIcommand::ConvertToDimensionedDouble
static G4double ConvertToDimensionedDouble(const char *st)
Definition: G4UIcommand.cc:429
G4UImanager::ApplyCommand
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:369
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:51
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:83
G4UIparameter::SetGuidance
void SetGuidance(const char *theGuidance)
Definition: G4UIparameter.hh:138
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition: G4UIparameter.hh:95
G4VSceneHandler::GetName
const G4String & GetName() const
G4VViewer::GetName
const G4String & GetName() const
G4VViewer::GetSceneHandler
G4VSceneHandler * GetSceneHandler() const
G4VisManager::GetCurrentViewer
G4VViewer * GetCurrentViewer() const
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83