Geant4  10.03
G4VisCommandsGeometrySet.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: G4VisCommandsGeometrySet.cc 98797 2016-08-09 15:12:22Z gcosmo $
28 
29 // /vis/geometry commands - John Allison 31st January 2006
30 
32 
33 #include "G4UIcommand.hh"
34 #include "G4VisManager.hh"
35 #include "G4LogicalVolumeStore.hh"
36 #include "G4UImanager.hh"
37 
38 #include <sstream>
39 #include <cctype>
40 
42 (G4String requestedName,
43  const G4VVisCommandGeometrySetFunction& setFunction,
44  G4int requestedDepth)
45 {
46  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
48  G4bool found = false;
49  for (size_t iLV = 0; iLV < pLVStore->size(); iLV++ ) {
50  G4LogicalVolume* pLV = (*pLVStore)[iLV];
51  const G4String& logVolName = pLV->GetName();
52  if (logVolName == requestedName) found = true;
53  if (requestedName == "all" || logVolName == requestedName) {
54  SetLVVisAtts(pLV, setFunction, 0, requestedDepth);
55  }
56  }
57  if (requestedName != "all" && !found) {
58  if (verbosity >= G4VisManager::errors) {
59  G4cerr << "ERROR: Logical volume \"" << requestedName
60  << "\" not found in logical volume store." << G4endl;
61  }
62  return;
63  }
64  if (fpVisManager->GetCurrentViewer()) {
65  G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
66  }
67 }
68 
71  const G4VVisCommandGeometrySetFunction& setFunction,
72  G4int depth, G4int requestedDepth)
73 {
74  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
75  const G4VisAttributes* oldVisAtts = pLV->GetVisAttributes();
76  fVisAttsMap.insert(std::make_pair(pLV,oldVisAtts)); // Store old vis atts.
77  G4VisAttributes* newVisAtts = new G4VisAttributes; // Memory leak!
78  if (oldVisAtts) {
79  *newVisAtts = *oldVisAtts;
80  }
81  setFunction(newVisAtts); // Sets whatever attribute determined by
82  // function object.
83  pLV->SetVisAttributes(newVisAtts);
84  if (verbosity >= G4VisManager::confirmations) {
85  G4cout << "\nLogical Volume \"" << pLV->GetName()
86  << "\": setting vis attributes:";
87  if (oldVisAtts) {
88  G4cout << "\nwas: " << *oldVisAtts;
89  } else {
90  G4cout << "\n(no old attributes)";
91  }
92  G4cout << "\nnow: " << *newVisAtts
93  << G4endl;
94  }
95  if (requestedDepth < 0 || depth < requestedDepth) {
96  G4int nDaughters = pLV->GetNoDaughters();
97  for (G4int i = 0; i < nDaughters; ++i) {
98  SetLVVisAtts(pLV->GetDaughter(i)->GetLogicalVolume(),
99  setFunction, ++depth, requestedDepth);
100  }
101  }
102 }
103 
105 
107 {
108  G4bool omitable;
109  fpCommand = new G4UIcommand("/vis/geometry/set/colour", this);
110  fpCommand->SetGuidance("Sets colour of logical volume(s).");
111  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
113  ("Optionally propagates down hierarchy to given depth.");
114  G4UIparameter* parameter;
115  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
116  parameter->SetDefaultValue("all");
117  fpCommand->SetParameter(parameter);
118  parameter = new G4UIparameter("depth", 'd', omitable = true);
119  parameter->SetDefaultValue(0);
120  parameter->SetGuidance
121  ("Depth of propagation (-1 means unlimited depth).");
122  fpCommand->SetParameter(parameter);
123  parameter = new G4UIparameter("red", 's', omitable = true);
124  parameter->SetDefaultValue("1.");
125  parameter->SetGuidance
126  ("Red component or a string, e.g., \"blue\", in which case succeeding colour components are ignored.");
127  fpCommand->SetParameter(parameter);
128  parameter = new G4UIparameter("green", 'd', omitable = true);
129  parameter->SetDefaultValue(1.);
130  fpCommand->SetParameter(parameter);
131  parameter = new G4UIparameter("blue", 'd', omitable = true);
132  parameter->SetDefaultValue(1.);
133  fpCommand->SetParameter(parameter);
134  parameter = new G4UIparameter("opacity", 'd', omitable = true);
135  parameter->SetDefaultValue(1.);
136  fpCommand->SetParameter(parameter);
137 }
138 
140 {
141  delete fpCommand;
142 }
143 
145 {
146  return "";
147 }
148 
150 (G4UIcommand*, G4String newValue)
151 {
152  G4String name, redOrString;
153  G4int requestedDepth;
154  G4double green, blue, opacity;
155  std::istringstream iss(newValue);
156  iss >> name >> requestedDepth >> redOrString >> green >> blue >> opacity;
157  G4Colour colour(1,1,1,1); // Default white and opaque.
158  const size_t iPos0 = 0;
159  if (std::isalpha(redOrString[iPos0])) {
160  if (!G4Colour::GetColour(redOrString, colour)) {
161  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
162  G4cout << "WARNING: Colour \"" << redOrString
163  << "\" not found. Defaulting to white and opaque."
164  << G4endl;
165  }
166  }
167  } else {
168  colour = G4Colour(G4UIcommand::ConvertToDouble(redOrString), green, blue);
169  }
170  colour = G4Colour
171  (colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
172 
173  G4VisCommandGeometrySetColourFunction setColour(colour);
174  Set(name, setColour, requestedDepth);
175 }
176 
178 
180 {
181  G4bool omitable;
182  fpCommand = new G4UIcommand("/vis/geometry/set/daughtersInvisible", this);
183  fpCommand->SetGuidance("Makes daughters of logical volume(s) invisible.");
184  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
186  ("Optionally propagates down hierarchy to given depth.");
187  G4UIparameter* parameter;
188  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
189  parameter->SetDefaultValue("all");
190  fpCommand->SetParameter(parameter);
191  parameter = new G4UIparameter("depth", 'd', omitable = true);
192  parameter->SetDefaultValue(0);
193  parameter->SetGuidance
194  ("Depth of propagation (-1 means unlimited depth).");
195  fpCommand->SetParameter(parameter);
196  parameter = new G4UIparameter("daughtersInvisible", 'b', omitable = true);
197  parameter->SetDefaultValue(true);
198  fpCommand->SetParameter(parameter);
199 }
200 
202 {
203  delete fpCommand;
204 }
205 
206 G4String
208 {
209  return "";
210 }
211 
213 (G4UIcommand*, G4String newValue)
214 {
215  G4String name;
216  G4int requestedDepth;
217  G4String daughtersInvisibleString;
218  std::istringstream iss(newValue);
219  iss >> name >> requestedDepth >> daughtersInvisibleString;
220  G4bool daughtersInvisible =
221  G4UIcommand::ConvertToBool(daughtersInvisibleString);
222 
223  if (requestedDepth !=0) {
224  requestedDepth = 0;
225  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
226  G4cout << "Recursive application suppressed for this attribute."
227  << G4endl;
228  }
229  }
230 
232  setDaughtersInvisible(daughtersInvisible);
233  Set(name, setDaughtersInvisible, requestedDepth);
234 
235  G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
236  if (pViewer) {
237  const G4ViewParameters& viewParams = pViewer->GetViewParameters();
238  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
239  if (!viewParams.IsCulling()) {
240  G4cout <<
241  "Culling must be on - \"/vis/viewer/set/culling global true\" - to see effect."
242  << G4endl;
243  }
244  }
245  }
246 }
247 
249 
251 {
252  G4bool omitable;
253  fpCommand = new G4UIcommand("/vis/geometry/set/forceAuxEdgeVisible", this);
255  ("Forces auxiliary (soft) edges of logical volume(s) to be visible,"
256  "\nregardless of the view parameters.");
257  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
259  ("Optionally propagates down hierarchy to given depth.");
260  G4UIparameter* parameter;
261  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
262  parameter->SetDefaultValue("all");
263  fpCommand->SetParameter(parameter);
264  parameter = new G4UIparameter("depth", 'd', omitable = true);
265  parameter->SetDefaultValue(0);
266  parameter->SetGuidance
267  ("Depth of propagation (-1 means unlimited depth).");
268  fpCommand->SetParameter(parameter);
269  parameter = new G4UIparameter("forceAuxEdgeVisible", 'b', omitable = true);
270  parameter->SetDefaultValue(true);
271  fpCommand->SetParameter(parameter);
272 }
273 
275 {
276  delete fpCommand;
277 }
278 
279 G4String
281 {
282  return "";
283 }
284 
286 (G4UIcommand*, G4String newValue)
287 {
288  G4String name;
289  G4int requestedDepth;
290  G4String forceAuxEdgeVisibleString;
291  std::istringstream iss(newValue);
292  iss >> name >> requestedDepth >> forceAuxEdgeVisibleString;
293  G4bool forceAuxEdgeVisible =
294  G4UIcommand::ConvertToBool(forceAuxEdgeVisibleString);;
295 
297  setForceAuxEdgeVisible(forceAuxEdgeVisible);
298  Set(name, setForceAuxEdgeVisible, requestedDepth);
299 }
300 
302 
304 {
305  G4bool omitable;
306  fpCommand = new G4UIcommand("/vis/geometry/set/forceLineSegmentsPerCircle", this);
308  ("Forces number of line segments per circle, the precision with which a"
309  "\ncurved line or surface is represented by a polygon or polyhedron,"
310  "\nregardless of the view parameters.");
311  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
313  ("Optionally propagates down hierarchy to given depth.");
314  G4UIparameter* parameter;
315  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
316  parameter->SetDefaultValue("all");
317  fpCommand->SetParameter(parameter);
318  parameter = new G4UIparameter("depth", 'd', omitable = true);
319  parameter->SetDefaultValue(0);
320  parameter->SetGuidance
321  ("Depth of propagation (-1 means unlimited depth).");
322  fpCommand->SetParameter(parameter);
323  parameter = new G4UIparameter("lineSegmentsPerCircle", 'd', omitable = true);
324  parameter->SetGuidance
325  ("<= 0 means not forced, i.e., under control of viewer.");
326  parameter->SetDefaultValue(0);
327  fpCommand->SetParameter(parameter);
328 }
329 
331 {
332  delete fpCommand;
333 }
334 
335 G4String
337 {
338  return "";
339 }
340 
342 (G4UIcommand*, G4String newValue)
343 {
344  G4String name;
345  G4int requestedDepth;
346  G4int lineSegmentsPerCircle;
347  std::istringstream iss(newValue);
348  iss >> name >> requestedDepth >> lineSegmentsPerCircle;
349 
350  G4VisCommandGeometrySetForceLineSegmentsPerCircleFunction setForceLineSegmentsPerCircle(lineSegmentsPerCircle);
351  Set(name, setForceLineSegmentsPerCircle, requestedDepth);
352 }
353 
355 
357 {
358  G4bool omitable;
359  fpCommand = new G4UIcommand("/vis/geometry/set/forceSolid", this);
361  ("Forces logical volume(s) always to be drawn solid (surface drawing),"
362  "\nregardless of the view parameters.");
363  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
365  ("Optionally propagates down hierarchy to given depth.");
366  G4UIparameter* parameter;
367  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
368  parameter->SetDefaultValue("all");
369  fpCommand->SetParameter(parameter);
370  parameter = new G4UIparameter("depth", 'd', omitable = true);
371  parameter->SetDefaultValue(0);
372  parameter->SetGuidance
373  ("Depth of propagation (-1 means unlimited depth).");
374  fpCommand->SetParameter(parameter);
375  parameter = new G4UIparameter("forceSolid", 'b', omitable = true);
376  parameter->SetDefaultValue(true);
377  fpCommand->SetParameter(parameter);
378 }
379 
381 {
382  delete fpCommand;
383 }
384 
385 G4String
387 {
388  return "";
389 }
390 
392 (G4UIcommand*, G4String newValue)
393 {
394  G4String name;
395  G4int requestedDepth;
396  G4String forceSolidString;
397  std::istringstream iss(newValue);
398  iss >> name >> requestedDepth >> forceSolidString;
399  G4bool forceSolid = G4UIcommand::ConvertToBool(forceSolidString);
400 
401  G4VisCommandGeometrySetForceSolidFunction setForceSolid(forceSolid);
402  Set(name, setForceSolid, requestedDepth);
403 }
404 
406 
408 {
409  G4bool omitable;
410  fpCommand = new G4UIcommand("/vis/geometry/set/forceWireframe", this);
412  ("Forces logical volume(s) always to be drawn as wireframe,"
413  "\nregardless of the view parameters.");
414  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
416  ("Optionally propagates down hierarchy to given depth.");
417  G4UIparameter* parameter;
418  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
419  parameter->SetDefaultValue("all");
420  fpCommand->SetParameter(parameter);
421  parameter = new G4UIparameter("depth", 'd', omitable = true);
422  parameter->SetDefaultValue(0);
423  parameter->SetGuidance
424  ("Depth of propagation (-1 means unlimited depth).");
425  fpCommand->SetParameter(parameter);
426  parameter = new G4UIparameter("forceWireframe", 'b', omitable = true);
427  parameter->SetDefaultValue(true);
428  fpCommand->SetParameter(parameter);
429 }
430 
432 {
433  delete fpCommand;
434 }
435 
436 G4String
438 {
439  return "";
440 }
441 
443 (G4UIcommand*, G4String newValue)
444 {
445  G4String name;
446  G4int requestedDepth;
447  G4String forceWireframeString;
448  std::istringstream iss(newValue);
449  iss >> name >> requestedDepth >> forceWireframeString;
450  G4bool forceWireframe = G4UIcommand::ConvertToBool(forceWireframeString);
451 
453  setForceWireframe(forceWireframe);
454  Set(name, setForceWireframe, requestedDepth);
455 }
456 
458 
460 {
461  G4bool omitable;
462  fpCommand = new G4UIcommand("/vis/geometry/set/lineStyle", this);
463  fpCommand->SetGuidance("Sets line style of logical volume(s) drawing.");
464  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
466  ("Optionally propagates down hierarchy to given depth.");
467  G4UIparameter* parameter;
468  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
469  parameter->SetDefaultValue("all");
470  fpCommand->SetParameter(parameter);
471  parameter = new G4UIparameter("depth", 'd', omitable = true);
472  parameter->SetDefaultValue(0);
473  parameter->SetGuidance
474  ("Depth of propagation (-1 means unlimited depth).");
475  fpCommand->SetParameter(parameter);
476  parameter = new G4UIparameter("lineStyle", 's', omitable = true);
477  parameter->SetParameterCandidates("unbroken dashed dotted");
478  parameter->SetDefaultValue("unbroken");
479  fpCommand->SetParameter(parameter);
480 }
481 
483 {
484  delete fpCommand;
485 }
486 
487 G4String
489 {
490  return "";
491 }
492 
494 (G4UIcommand*, G4String newValue)
495 {
496  G4String name, lineStyleString;
497  G4int requestedDepth;
498  std::istringstream iss(newValue);
499  iss >> name >> requestedDepth >> lineStyleString;
501  if (lineStyleString == "unbroken") lineStyle = G4VisAttributes::unbroken;
502  if (lineStyleString == "dashed") lineStyle = G4VisAttributes::dashed;
503  if (lineStyleString == "dotted") lineStyle = G4VisAttributes::dotted;
504 
505  G4VisCommandGeometrySetLineStyleFunction setLineStyle(lineStyle);
506  Set(name, setLineStyle, requestedDepth);
507 }
508 
510 
512 {
513  G4bool omitable;
514  fpCommand = new G4UIcommand("/vis/geometry/set/lineWidth", this);
515  fpCommand->SetGuidance("Sets line width of logical volume(s) drawing.");
516  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
518  ("Optionally propagates down hierarchy to given depth.");
519  G4UIparameter* parameter;
520  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
521  parameter->SetDefaultValue("all");
522  fpCommand->SetParameter(parameter);
523  parameter = new G4UIparameter("depth", 'd', omitable = true);
524  parameter->SetDefaultValue(0);
525  parameter->SetGuidance
526  ("Depth of propagation (-1 means unlimited depth).");
527  fpCommand->SetParameter(parameter);
528  parameter = new G4UIparameter("lineWidth", 'd', omitable = true);
529  parameter->SetDefaultValue(1.);
530  fpCommand->SetParameter(parameter);
531 }
532 
534 {
535  delete fpCommand;
536 }
537 
538 G4String
540 {
541  return "";
542 }
543 
545 (G4UIcommand*, G4String newValue)
546 {
547  G4String name;
548  G4int requestedDepth;
549  G4double lineWidth;
550  std::istringstream iss(newValue);
551  iss >> name >> requestedDepth >> lineWidth;
552 
553  G4VisCommandGeometrySetLineWidthFunction setLineWidth(lineWidth);
554  Set(name, setLineWidth, requestedDepth);
555 }
556 
558 
560 {
561  G4bool omitable;
562  fpCommand = new G4UIcommand("/vis/geometry/set/visibility", this);
563  fpCommand->SetGuidance("Sets visibility of logical volume(s).");
564  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
566  ("Optionally propagates down hierarchy to given depth.");
567  G4UIparameter* parameter;
568  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
569  parameter->SetDefaultValue("all");
570  fpCommand->SetParameter(parameter);
571  parameter = new G4UIparameter("depth", 'd', omitable = true);
572  parameter->SetDefaultValue(0);
573  parameter->SetGuidance
574  ("Depth of propagation (-1 means unlimited depth).");
575  fpCommand->SetParameter(parameter);
576  parameter = new G4UIparameter("visibility", 'b', omitable = true);
577  parameter->SetDefaultValue(true);
578  fpCommand->SetParameter(parameter);
579 }
580 
582 {
583  delete fpCommand;
584 }
585 
587 {
588  return "";
589 }
590 
592 (G4UIcommand*, G4String newValue)
593 {
594  G4String name;
595  G4int requestedDepth;
596  G4String visibilityString;
597  std::istringstream iss(newValue);
598  iss >> name >> requestedDepth >> visibilityString;
599  G4bool visibility = G4UIcommand::ConvertToBool(visibilityString);
600 
601  G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
602  Set(name, setVisibility, requestedDepth);
603 
604  G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
605  if (pViewer) {
606  const G4ViewParameters& viewParams = pViewer->GetViewParameters();
607  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
608  if (!viewParams.IsCulling() ||
609  !viewParams.IsCullingInvisible()) {
610  G4cout <<
611  "Culling must be on - \"/vis/viewer/set/culling global true\" and"
612  "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
613  << G4endl;
614  }
615  }
616  }
617 }
618 
620 (G4LogicalVolume* pLV, G4int requestedDepth,G4bool visibility)
621 {
622  if (!pLV) return;
623  G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
624  SetLVVisAtts(pLV, setVisibility, 0, requestedDepth);
625 
626  G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
627  if (pViewer) {
628  G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
629  const G4ViewParameters& viewParams = pViewer->GetViewParameters();
630  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
631  if (!viewParams.IsCulling() ||
632  !viewParams.IsCullingInvisible()) {
633  G4cout <<
634  "Culling must be on - \"/vis/viewer/set/culling global true\" and"
635  "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
636  << G4endl;
637  }
638  }
639  }
640 }
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:152
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetParameterCandidates(const char *theString)
G4bool IsCullingInvisible() const
void Set(G4String logVolName, const G4VVisCommandGeometrySetFunction &, G4int requestedDepth)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
const G4ViewParameters & GetViewParameters() const
static G4bool GetColour(const G4String &key, G4Colour &result)
Definition: G4Colour.cc:126
G4VPhysicalVolume * GetDaughter(const G4int i) const
void SetDefaultValue(const char *theDefaultValue)
G4double GetBlue() const
Definition: G4Colour.hh:141
const char * name(G4int ptype)
void SetNewValueOnLV(G4LogicalVolume *pLV, G4int, G4bool)
Definition: test07.cc:36
int G4int
Definition: G4Types.hh:78
G4String GetCurrentValue(G4UIcommand *command)
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:58
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetNewValue(G4UIcommand *command, G4String newValue)
G4GLOB_DLL std::ostream G4cout
G4double GetRed() const
Definition: G4Colour.hh:139
static G4bool ConvertToBool(const char *st)
Definition: G4UIcommand.cc:425
bool G4bool
Definition: G4Types.hh:79
G4double GetGreen() const
Definition: G4Colour.hh:140
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
static G4double ConvertToDouble(const char *st)
Definition: G4UIcommand.cc:443
const G4VisAttributes * GetVisAttributes() const
static G4LogicalVolumeStore * GetInstance()
G4int GetNoDaughters() const
G4LogicalVolume * GetLogicalVolume() const
void SetLVVisAtts(G4LogicalVolume *, const G4VVisCommandGeometrySetFunction &, G4int depth, G4int requestedDepth)
void SetNewValue(G4UIcommand *command, G4String newValue)
void Set(G4int Elements, T *To, T Value)
Set's all the values in an array to a constant.
Definition: G4ArrayOps.hh:51
G4String GetCurrentValue(G4UIcommand *command)
#define G4endl
Definition: G4ios.hh:61
G4String GetCurrentValue(G4UIcommand *command)
const G4String & GetName() const
double G4double
Definition: G4Types.hh:76
G4String GetCurrentValue(G4UIcommand *command)
void SetGuidance(const char *theGuidance)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
G4bool IsCulling() const
void SetVisAttributes(const G4VisAttributes *pVA)
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:446
G4GLOB_DLL std::ostream G4cerr