| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 27
28 // /vis/geometry commands - John Allison 31st 28 // /vis/geometry commands - John Allison 31st January 2006
29 29
30 #include "G4VisCommandsGeometrySet.hh" 30 #include "G4VisCommandsGeometrySet.hh"
31 31
32 #include "G4UIcommand.hh" 32 #include "G4UIcommand.hh"
33 #include "G4VisManager.hh" 33 #include "G4VisManager.hh"
34 #include "G4LogicalVolumeStore.hh" 34 #include "G4LogicalVolumeStore.hh"
35 #include "G4UImanager.hh" 35 #include "G4UImanager.hh"
36 36
37 #include <sstream> 37 #include <sstream>
38 38
39 #define G4warn G4cout 39 #define G4warn G4cout
40 40
41 void G4VVisCommandGeometrySet::Set 41 void G4VVisCommandGeometrySet::Set
42 (const G4String& requestedName, << 42 (G4String requestedName,
43 const G4VVisCommandGeometrySetFunction& setFu 43 const G4VVisCommandGeometrySetFunction& setFunction,
44 G4int requestedDepth) 44 G4int requestedDepth)
45 { 45 {
46 G4VisManager::Verbosity verbosity = fpVisMan 46 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
47 G4LogicalVolumeStore* pLVStore = G4LogicalVo 47 G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance();
48 G4bool found = false; 48 G4bool found = false;
49 for (std::size_t iLV = 0; iLV < pLVStore->si 49 for (std::size_t iLV = 0; iLV < pLVStore->size(); ++iLV ) {
50 G4LogicalVolume* pLV = (*pLVStore)[iLV]; 50 G4LogicalVolume* pLV = (*pLVStore)[iLV];
51 const G4String& logVolName = pLV->GetName( 51 const G4String& logVolName = pLV->GetName();
52 if (logVolName == requestedName) found = t 52 if (logVolName == requestedName) found = true;
53 if (requestedName == "all" || logVolName = 53 if (requestedName == "all" || logVolName == requestedName) {
54 SetLVVisAtts(pLV, setFunction, 0, reques 54 SetLVVisAtts(pLV, setFunction, 0, requestedDepth);
55 } 55 }
56 } 56 }
57 if (requestedName != "all" && !found) { 57 if (requestedName != "all" && !found) {
58 if (verbosity >= G4VisManager::errors) { 58 if (verbosity >= G4VisManager::errors) {
59 G4warn << "ERROR: Logical volume \"" << 59 G4warn << "ERROR: Logical volume \"" << requestedName
60 << "\" not found in logical volume stor 60 << "\" not found in logical volume store." << G4endl;
61 } 61 }
62 return; 62 return;
63 } 63 }
64 // Recalculate extent of any physical volume 64 // Recalculate extent of any physical volume model in run duration lists
65 for (const auto& scene : fpVisManager->GetSc 65 for (const auto& scene : fpVisManager->GetSceneList()) {
66 const auto& runDurationModelList = scene-> 66 const auto& runDurationModelList = scene->GetRunDurationModelList();
67 for (const auto& sceneModel : runDurationM 67 for (const auto& sceneModel : runDurationModelList) {
68 auto model = sceneModel.fpModel; 68 auto model = sceneModel.fpModel;
69 auto pvModel = dynamic_cast<G4PhysicalVo 69 auto pvModel = dynamic_cast<G4PhysicalVolumeModel*>(model);
70 if (pvModel) pvModel->CalculateExtent(); 70 if (pvModel) pvModel->CalculateExtent();
71 } 71 }
72 // And re-calculate the scene's extent 72 // And re-calculate the scene's extent
73 scene->CalculateExtent(); 73 scene->CalculateExtent();
74 } 74 }
75 if (fpVisManager->GetCurrentViewer()) { 75 if (fpVisManager->GetCurrentViewer()) {
76 G4UImanager::GetUIpointer()->ApplyCommand( 76 G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
77 } 77 }
78 } 78 }
79 79
80 void G4VVisCommandGeometrySet::SetLVVisAtts 80 void G4VVisCommandGeometrySet::SetLVVisAtts
81 (G4LogicalVolume* pLV, 81 (G4LogicalVolume* pLV,
82 const G4VVisCommandGeometrySetFunction& setFu 82 const G4VVisCommandGeometrySetFunction& setFunction,
83 G4int depth, G4int requestedDepth) 83 G4int depth, G4int requestedDepth)
84 { 84 {
85 G4VisManager::Verbosity verbosity = fpVisMan 85 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
86 const G4VisAttributes* oldVisAtts = pLV->Get 86 const G4VisAttributes* oldVisAtts = pLV->GetVisAttributes();
87 fVisAttsMap.insert(std::make_pair(pLV,oldVis 87 fVisAttsMap.insert(std::make_pair(pLV,oldVisAtts)); // Store old vis atts.
88 G4VisAttributes* newVisAtts = new G4VisAttri 88 G4VisAttributes* newVisAtts = new G4VisAttributes; // Memory leak!
89 if (oldVisAtts) { 89 if (oldVisAtts) {
90 *newVisAtts = *oldVisAtts; 90 *newVisAtts = *oldVisAtts;
91 } 91 }
92 setFunction(newVisAtts); // Sets whatever a 92 setFunction(newVisAtts); // Sets whatever attribute determined by
93 // function object. 93 // function object.
94 pLV->SetVisAttributes(newVisAtts); 94 pLV->SetVisAttributes(newVisAtts);
95 if (verbosity >= G4VisManager::confirmations 95 if (verbosity >= G4VisManager::confirmations) {
96 G4cout << "\nLogical Volume \"" << pLV->Ge 96 G4cout << "\nLogical Volume \"" << pLV->GetName()
97 << "\": setting vis attributes:"; 97 << "\": setting vis attributes:";
98 if (oldVisAtts) { 98 if (oldVisAtts) {
99 G4cout << "\nwas: " << *oldVisAtts; 99 G4cout << "\nwas: " << *oldVisAtts;
100 } else { 100 } else {
101 G4cout << "\n(no old attributes)"; 101 G4cout << "\n(no old attributes)";
102 } 102 }
103 G4cout << "\nnow: " << *newVisAtts 103 G4cout << "\nnow: " << *newVisAtts
104 << G4endl; 104 << G4endl;
105 } 105 }
106 if (requestedDepth < 0 || depth < requestedD 106 if (requestedDepth < 0 || depth < requestedDepth) {
107 G4int nDaughters = (G4int)pLV->GetNoDaught 107 G4int nDaughters = (G4int)pLV->GetNoDaughters();
108 for (G4int i = 0; i < nDaughters; ++i) { 108 for (G4int i = 0; i < nDaughters; ++i) {
109 SetLVVisAtts(pLV->GetDaughter(i)->GetLog 109 SetLVVisAtts(pLV->GetDaughter(i)->GetLogicalVolume(),
110 setFunction, ++depth, requestedDepth); 110 setFunction, ++depth, requestedDepth);
111 } 111 }
112 } 112 }
113 } 113 }
114 114
115 ////////////// /vis/geometry/set/colour ////// 115 ////////////// /vis/geometry/set/colour ///////////////////////////////////////
116 116
117 G4VisCommandGeometrySetColour::G4VisCommandGeo 117 G4VisCommandGeometrySetColour::G4VisCommandGeometrySetColour()
118 { 118 {
119 G4bool omitable; 119 G4bool omitable;
120 fpCommand = new G4UIcommand("/vis/geometry/s 120 fpCommand = new G4UIcommand("/vis/geometry/set/colour", this);
121 fpCommand->SetGuidance("Sets colour of logic 121 fpCommand->SetGuidance("Sets colour of logical volume(s).");
122 fpCommand->SetGuidance("\"all\" sets all log 122 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
123 fpCommand->SetGuidance 123 fpCommand->SetGuidance
124 ("Optionally propagates down hierarchy to 124 ("Optionally propagates down hierarchy to given depth.");
125 G4UIparameter* parameter; 125 G4UIparameter* parameter;
126 parameter = new G4UIparameter ("logical-volu 126 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
127 parameter->SetDefaultValue("all"); 127 parameter->SetDefaultValue("all");
128 fpCommand->SetParameter(parameter); 128 fpCommand->SetParameter(parameter);
129 parameter = new G4UIparameter("depth", 'd', 129 parameter = new G4UIparameter("depth", 'd', omitable = true);
130 parameter->SetDefaultValue(0); 130 parameter->SetDefaultValue(0);
131 parameter->SetGuidance 131 parameter->SetGuidance
132 ("Depth of propagation (-1 means unlimited 132 ("Depth of propagation (-1 means unlimited depth).");
133 fpCommand->SetParameter(parameter); 133 fpCommand->SetParameter(parameter);
134 parameter = new G4UIparameter("red", 's', om 134 parameter = new G4UIparameter("red", 's', omitable = true);
135 parameter->SetDefaultValue("1."); 135 parameter->SetDefaultValue("1.");
136 parameter->SetGuidance 136 parameter->SetGuidance
137 ("Red component or a string, e.g., \"blue\ 137 ("Red component or a string, e.g., \"blue\", in which case succeeding colour components are ignored.");
138 fpCommand->SetParameter(parameter); 138 fpCommand->SetParameter(parameter);
139 parameter = new G4UIparameter("green", 'd', 139 parameter = new G4UIparameter("green", 'd', omitable = true);
140 parameter->SetDefaultValue(1.); 140 parameter->SetDefaultValue(1.);
141 fpCommand->SetParameter(parameter); 141 fpCommand->SetParameter(parameter);
142 parameter = new G4UIparameter("blue", 'd', o 142 parameter = new G4UIparameter("blue", 'd', omitable = true);
143 parameter->SetDefaultValue(1.); 143 parameter->SetDefaultValue(1.);
144 fpCommand->SetParameter(parameter); 144 fpCommand->SetParameter(parameter);
145 parameter = new G4UIparameter("opacity", 'd' 145 parameter = new G4UIparameter("opacity", 'd', omitable = true);
146 parameter->SetDefaultValue(1.); 146 parameter->SetDefaultValue(1.);
147 fpCommand->SetParameter(parameter); 147 fpCommand->SetParameter(parameter);
148 } 148 }
149 149
150 G4VisCommandGeometrySetColour::~G4VisCommandGe 150 G4VisCommandGeometrySetColour::~G4VisCommandGeometrySetColour()
151 { 151 {
152 delete fpCommand; 152 delete fpCommand;
153 } 153 }
154 154
155 G4String G4VisCommandGeometrySetColour::GetCur 155 G4String G4VisCommandGeometrySetColour::GetCurrentValue(G4UIcommand*)
156 { 156 {
157 return ""; 157 return "";
158 } 158 }
159 159
160 void G4VisCommandGeometrySetColour::SetNewValu 160 void G4VisCommandGeometrySetColour::SetNewValue
161 (G4UIcommand*, G4String newValue) 161 (G4UIcommand*, G4String newValue)
162 { 162 {
163 G4String name, redOrString; 163 G4String name, redOrString;
164 G4int requestedDepth; 164 G4int requestedDepth;
165 G4double green, blue, opacity; 165 G4double green, blue, opacity;
166 std::istringstream iss(newValue); 166 std::istringstream iss(newValue);
167 iss >> name >> requestedDepth >> redOrString 167 iss >> name >> requestedDepth >> redOrString >> green >> blue >> opacity;
168 G4Colour colour(1,1,1,1); // Default white 168 G4Colour colour(1,1,1,1); // Default white and opaque.
169 ConvertToColour(colour, redOrString, green, 169 ConvertToColour(colour, redOrString, green, blue, opacity);
170 G4VisCommandGeometrySetColourFunction setCol 170 G4VisCommandGeometrySetColourFunction setColour(colour);
171 Set(name, setColour, requestedDepth); 171 Set(name, setColour, requestedDepth);
172 } 172 }
173 173
174 ////////////// /vis/geometry/set/daughtersInvi 174 ////////////// /vis/geometry/set/daughtersInvisible //////////////////////
175 175
176 G4VisCommandGeometrySetDaughtersInvisible::G4V 176 G4VisCommandGeometrySetDaughtersInvisible::G4VisCommandGeometrySetDaughtersInvisible()
177 { 177 {
178 G4bool omitable; 178 G4bool omitable;
179 fpCommand = new G4UIcommand("/vis/geometry/s 179 fpCommand = new G4UIcommand("/vis/geometry/set/daughtersInvisible", this);
180 fpCommand->SetGuidance("Makes daughters of l 180 fpCommand->SetGuidance("Makes daughters of logical volume(s) invisible.");
181 fpCommand->SetGuidance("\"all\" sets all log 181 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
182 fpCommand->SetGuidance 182 fpCommand->SetGuidance
183 ("Optionally propagates down hierarchy to 183 ("Optionally propagates down hierarchy to given depth.");
184 G4UIparameter* parameter; 184 G4UIparameter* parameter;
185 parameter = new G4UIparameter ("logical-volu 185 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
186 parameter->SetDefaultValue("all"); 186 parameter->SetDefaultValue("all");
187 fpCommand->SetParameter(parameter); 187 fpCommand->SetParameter(parameter);
188 parameter = new G4UIparameter("depth", 'd', 188 parameter = new G4UIparameter("depth", 'd', omitable = true);
189 parameter->SetDefaultValue(0); 189 parameter->SetDefaultValue(0);
190 parameter->SetGuidance 190 parameter->SetGuidance
191 ("Depth of propagation (-1 means unlimited 191 ("Depth of propagation (-1 means unlimited depth).");
192 fpCommand->SetParameter(parameter); 192 fpCommand->SetParameter(parameter);
193 parameter = new G4UIparameter("daughtersInvi 193 parameter = new G4UIparameter("daughtersInvisible", 'b', omitable = true);
194 parameter->SetDefaultValue(true); 194 parameter->SetDefaultValue(true);
195 fpCommand->SetParameter(parameter); 195 fpCommand->SetParameter(parameter);
196 } 196 }
197 197
198 G4VisCommandGeometrySetDaughtersInvisible::~G4 198 G4VisCommandGeometrySetDaughtersInvisible::~G4VisCommandGeometrySetDaughtersInvisible()
199 { 199 {
200 delete fpCommand; 200 delete fpCommand;
201 } 201 }
202 202
203 G4String 203 G4String
204 G4VisCommandGeometrySetDaughtersInvisible::Get 204 G4VisCommandGeometrySetDaughtersInvisible::GetCurrentValue(G4UIcommand*)
205 { 205 {
206 return ""; 206 return "";
207 } 207 }
208 208
209 void G4VisCommandGeometrySetDaughtersInvisible 209 void G4VisCommandGeometrySetDaughtersInvisible::SetNewValue
210 (G4UIcommand*, G4String newValue) 210 (G4UIcommand*, G4String newValue)
211 { 211 {
212 G4String name; 212 G4String name;
213 G4int requestedDepth; 213 G4int requestedDepth;
214 G4String daughtersInvisibleString; 214 G4String daughtersInvisibleString;
215 std::istringstream iss(newValue); 215 std::istringstream iss(newValue);
216 iss >> name >> requestedDepth >> daughtersIn 216 iss >> name >> requestedDepth >> daughtersInvisibleString;
217 G4bool daughtersInvisible = 217 G4bool daughtersInvisible =
218 G4UIcommand::ConvertToBool(daughtersInvisi 218 G4UIcommand::ConvertToBool(daughtersInvisibleString);
219 219
220 if (requestedDepth !=0) { 220 if (requestedDepth !=0) {
221 requestedDepth = 0; 221 requestedDepth = 0;
222 if (fpVisManager->GetVerbosity() >= G4VisM 222 if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
223 G4warn << "Recursive application suppres 223 G4warn << "Recursive application suppressed for this attribute."
224 << G4endl; 224 << G4endl;
225 } 225 }
226 } 226 }
227 227
228 G4VisCommandGeometrySetDaughtersInvisibleFun 228 G4VisCommandGeometrySetDaughtersInvisibleFunction
229 setDaughtersInvisible(daughtersInvisible); 229 setDaughtersInvisible(daughtersInvisible);
230 Set(name, setDaughtersInvisible, requestedDe 230 Set(name, setDaughtersInvisible, requestedDepth);
231 231
232 G4VViewer* pViewer = fpVisManager->GetCurren 232 G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
233 if (pViewer) { 233 if (pViewer) {
234 const G4ViewParameters& viewParams = pView 234 const G4ViewParameters& viewParams = pViewer->GetViewParameters();
235 if (fpVisManager->GetVerbosity() >= G4VisM 235 if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
236 if (!viewParams.IsCulling()) { 236 if (!viewParams.IsCulling()) {
237 G4warn << 237 G4warn <<
238 "Culling must be on - \"/vis/viewer/set/cu 238 "Culling must be on - \"/vis/viewer/set/culling global true\" - to see effect."
239 << G4endl; 239 << G4endl;
240 } 240 }
241 } 241 }
242 } 242 }
243 } 243 }
244 244
245 ////////////// /vis/geometry/set/forceAuxEdgeV 245 ////////////// /vis/geometry/set/forceAuxEdgeVisible /////////////////////////
246 246
247 G4VisCommandGeometrySetForceAuxEdgeVisible::G4 247 G4VisCommandGeometrySetForceAuxEdgeVisible::G4VisCommandGeometrySetForceAuxEdgeVisible()
248 { 248 {
249 G4bool omitable; 249 G4bool omitable;
250 fpCommand = new G4UIcommand("/vis/geometry/s 250 fpCommand = new G4UIcommand("/vis/geometry/set/forceAuxEdgeVisible", this);
251 fpCommand->SetGuidance 251 fpCommand->SetGuidance
252 ("Forces auxiliary (soft) edges of logical 252 ("Forces auxiliary (soft) edges of logical volume(s) to be visible,"
253 "\nregardless of the view parameters."); 253 "\nregardless of the view parameters.");
254 fpCommand->SetGuidance("\"all\" sets all log 254 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
255 fpCommand->SetGuidance 255 fpCommand->SetGuidance
256 ("Optionally propagates down hierarchy to 256 ("Optionally propagates down hierarchy to given depth.");
257 G4UIparameter* parameter; 257 G4UIparameter* parameter;
258 parameter = new G4UIparameter ("logical-volu 258 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
259 parameter->SetDefaultValue("all"); 259 parameter->SetDefaultValue("all");
260 fpCommand->SetParameter(parameter); 260 fpCommand->SetParameter(parameter);
261 parameter = new G4UIparameter("depth", 'd', 261 parameter = new G4UIparameter("depth", 'd', omitable = true);
262 parameter->SetDefaultValue(0); 262 parameter->SetDefaultValue(0);
263 parameter->SetGuidance 263 parameter->SetGuidance
264 ("Depth of propagation (-1 means unlimited 264 ("Depth of propagation (-1 means unlimited depth).");
265 fpCommand->SetParameter(parameter); 265 fpCommand->SetParameter(parameter);
266 parameter = new G4UIparameter("forceAuxEdgeV 266 parameter = new G4UIparameter("forceAuxEdgeVisible", 'b', omitable = true);
267 parameter->SetDefaultValue(true); 267 parameter->SetDefaultValue(true);
268 fpCommand->SetParameter(parameter); 268 fpCommand->SetParameter(parameter);
269 } 269 }
270 270
271 G4VisCommandGeometrySetForceAuxEdgeVisible::~G 271 G4VisCommandGeometrySetForceAuxEdgeVisible::~G4VisCommandGeometrySetForceAuxEdgeVisible()
272 { 272 {
273 delete fpCommand; 273 delete fpCommand;
274 } 274 }
275 275
276 G4String 276 G4String
277 G4VisCommandGeometrySetForceAuxEdgeVisible::Ge 277 G4VisCommandGeometrySetForceAuxEdgeVisible::GetCurrentValue(G4UIcommand*)
278 { 278 {
279 return ""; 279 return "";
280 } 280 }
281 281
282 void G4VisCommandGeometrySetForceAuxEdgeVisibl 282 void G4VisCommandGeometrySetForceAuxEdgeVisible::SetNewValue
283 (G4UIcommand*, G4String newValue) 283 (G4UIcommand*, G4String newValue)
284 { 284 {
285 G4String name; 285 G4String name;
286 G4int requestedDepth; 286 G4int requestedDepth;
287 G4String forceAuxEdgeVisibleString; 287 G4String forceAuxEdgeVisibleString;
288 std::istringstream iss(newValue); 288 std::istringstream iss(newValue);
289 iss >> name >> requestedDepth >> forceAuxEdg 289 iss >> name >> requestedDepth >> forceAuxEdgeVisibleString;
290 G4bool forceAuxEdgeVisible = 290 G4bool forceAuxEdgeVisible =
291 G4UIcommand::ConvertToBool(forceAuxEdgeVis 291 G4UIcommand::ConvertToBool(forceAuxEdgeVisibleString);;
292 292
293 G4VisCommandGeometrySetForceAuxEdgeVisibleFu 293 G4VisCommandGeometrySetForceAuxEdgeVisibleFunction
294 setForceAuxEdgeVisible(forceAuxEdgeVisible 294 setForceAuxEdgeVisible(forceAuxEdgeVisible);
295 Set(name, setForceAuxEdgeVisible, requestedD 295 Set(name, setForceAuxEdgeVisible, requestedDepth);
296 } 296 }
297 297
298 ////////////// /vis/geometry/set/forceCloud // 298 ////////////// /vis/geometry/set/forceCloud /////////////////////////
299 299
300 G4VisCommandGeometrySetForceCloud::G4VisComman 300 G4VisCommandGeometrySetForceCloud::G4VisCommandGeometrySetForceCloud()
301 { 301 {
302 G4bool omitable; 302 G4bool omitable;
303 fpCommand = new G4UIcommand("/vis/geometry/s 303 fpCommand = new G4UIcommand("/vis/geometry/set/forceCloud", this);
304 fpCommand->SetGuidance 304 fpCommand->SetGuidance
305 ("Forces logical volume(s) always to be draw 305 ("Forces logical volume(s) always to be drawn as a cloud of points,"
306 "\nregardless of the view parameters."); 306 "\nregardless of the view parameters.");
307 fpCommand->SetGuidance("\"all\" sets all log 307 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
308 fpCommand->SetGuidance 308 fpCommand->SetGuidance
309 ("Optionally propagates down hierarchy to 309 ("Optionally propagates down hierarchy to given depth.");
310 G4UIparameter* parameter; 310 G4UIparameter* parameter;
311 parameter = new G4UIparameter ("logical-volu 311 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
312 parameter->SetDefaultValue("all"); 312 parameter->SetDefaultValue("all");
313 fpCommand->SetParameter(parameter); 313 fpCommand->SetParameter(parameter);
314 parameter = new G4UIparameter("depth", 'd', 314 parameter = new G4UIparameter("depth", 'd', omitable = true);
315 parameter->SetDefaultValue(0); 315 parameter->SetDefaultValue(0);
316 parameter->SetGuidance 316 parameter->SetGuidance
317 ("Depth of propagation (-1 means unlimited 317 ("Depth of propagation (-1 means unlimited depth).");
318 fpCommand->SetParameter(parameter); 318 fpCommand->SetParameter(parameter);
319 parameter = new G4UIparameter("forceCloud", 319 parameter = new G4UIparameter("forceCloud", 'b', omitable = true);
320 parameter->SetDefaultValue(true); 320 parameter->SetDefaultValue(true);
321 fpCommand->SetParameter(parameter); 321 fpCommand->SetParameter(parameter);
322 parameter = new G4UIparameter("nPoints", 'd' 322 parameter = new G4UIparameter("nPoints", 'd', omitable = true);
323 parameter->SetGuidance 323 parameter->SetGuidance
324 ("<= 0 means under control of viewer."); 324 ("<= 0 means under control of viewer.");
325 parameter->SetDefaultValue(0); 325 parameter->SetDefaultValue(0);
326 fpCommand->SetParameter(parameter); 326 fpCommand->SetParameter(parameter);
327 } 327 }
328 328
329 G4VisCommandGeometrySetForceCloud::~G4VisComma 329 G4VisCommandGeometrySetForceCloud::~G4VisCommandGeometrySetForceCloud()
330 { 330 {
331 delete fpCommand; 331 delete fpCommand;
332 } 332 }
333 333
334 G4String 334 G4String
335 G4VisCommandGeometrySetForceCloud::GetCurrentV 335 G4VisCommandGeometrySetForceCloud::GetCurrentValue(G4UIcommand*)
336 { 336 {
337 return ""; 337 return "";
338 } 338 }
339 339
340 void G4VisCommandGeometrySetForceCloud::SetNew 340 void G4VisCommandGeometrySetForceCloud::SetNewValue
341 (G4UIcommand*, G4String newValue) 341 (G4UIcommand*, G4String newValue)
342 { 342 {
343 G4String name, forceCloudString; 343 G4String name, forceCloudString;
344 G4int requestedDepth, nPoints; 344 G4int requestedDepth, nPoints;
345 std::istringstream iss(newValue); 345 std::istringstream iss(newValue);
346 iss >> name >> requestedDepth >> forceCloudS 346 iss >> name >> requestedDepth >> forceCloudString >> nPoints;
347 G4bool forceCloud = G4UIcommand::ConvertToBo 347 G4bool forceCloud = G4UIcommand::ConvertToBool(forceCloudString);;
348 348
349 G4VisCommandGeometrySetForceCloudFunction se 349 G4VisCommandGeometrySetForceCloudFunction setForceCloud(forceCloud,nPoints);
350 Set(name, setForceCloud, requestedDepth); 350 Set(name, setForceCloud, requestedDepth);
351 } 351 }
352 352
353 ////////////// /vis/geometry/set/forceLineSegm 353 ////////////// /vis/geometry/set/forceLineSegmentsPerCircle /////////////////////////
354 354
355 G4VisCommandGeometrySetForceLineSegmentsPerCir 355 G4VisCommandGeometrySetForceLineSegmentsPerCircle::G4VisCommandGeometrySetForceLineSegmentsPerCircle()
356 { 356 {
357 G4bool omitable; 357 G4bool omitable;
358 fpCommand = new G4UIcommand("/vis/geometry/s 358 fpCommand = new G4UIcommand("/vis/geometry/set/forceLineSegmentsPerCircle", this);
359 fpCommand->SetGuidance 359 fpCommand->SetGuidance
360 ("Forces number of line segments per circl 360 ("Forces number of line segments per circle, the precision with which a"
361 "\ncurved line or surface is represented 361 "\ncurved line or surface is represented by a polygon or polyhedron,"
362 "\nregardless of the view parameters."); 362 "\nregardless of the view parameters.");
363 fpCommand->SetGuidance("\"all\" sets all log 363 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
364 fpCommand->SetGuidance 364 fpCommand->SetGuidance
365 ("Optionally propagates down hierarchy to 365 ("Optionally propagates down hierarchy to given depth.");
366 G4UIparameter* parameter; 366 G4UIparameter* parameter;
367 parameter = new G4UIparameter ("logical-volu 367 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
368 parameter->SetDefaultValue("all"); 368 parameter->SetDefaultValue("all");
369 fpCommand->SetParameter(parameter); 369 fpCommand->SetParameter(parameter);
370 parameter = new G4UIparameter("depth", 'd', 370 parameter = new G4UIparameter("depth", 'd', omitable = true);
371 parameter->SetDefaultValue(0); 371 parameter->SetDefaultValue(0);
372 parameter->SetGuidance 372 parameter->SetGuidance
373 ("Depth of propagation (-1 means unlimited 373 ("Depth of propagation (-1 means unlimited depth).");
374 fpCommand->SetParameter(parameter); 374 fpCommand->SetParameter(parameter);
375 parameter = new G4UIparameter("lineSegmentsP 375 parameter = new G4UIparameter("lineSegmentsPerCircle", 'd', omitable = true);
376 parameter->SetGuidance 376 parameter->SetGuidance
377 ("<= 0 means not forced, i.e., under contr 377 ("<= 0 means not forced, i.e., under control of viewer.");
378 parameter->SetDefaultValue(0); 378 parameter->SetDefaultValue(0);
379 fpCommand->SetParameter(parameter); 379 fpCommand->SetParameter(parameter);
380 } 380 }
381 381
382 G4VisCommandGeometrySetForceLineSegmentsPerCir 382 G4VisCommandGeometrySetForceLineSegmentsPerCircle::~G4VisCommandGeometrySetForceLineSegmentsPerCircle()
383 { 383 {
384 delete fpCommand; 384 delete fpCommand;
385 } 385 }
386 386
387 G4String 387 G4String
388 G4VisCommandGeometrySetForceLineSegmentsPerCir 388 G4VisCommandGeometrySetForceLineSegmentsPerCircle::GetCurrentValue(G4UIcommand*)
389 { 389 {
390 return ""; 390 return "";
391 } 391 }
392 392
393 void G4VisCommandGeometrySetForceLineSegmentsP 393 void G4VisCommandGeometrySetForceLineSegmentsPerCircle::SetNewValue
394 (G4UIcommand*, G4String newValue) 394 (G4UIcommand*, G4String newValue)
395 { 395 {
396 G4String name; 396 G4String name;
397 G4int requestedDepth; 397 G4int requestedDepth;
398 G4int lineSegmentsPerCircle; 398 G4int lineSegmentsPerCircle;
399 std::istringstream iss(newValue); 399 std::istringstream iss(newValue);
400 iss >> name >> requestedDepth >> lineSegment 400 iss >> name >> requestedDepth >> lineSegmentsPerCircle;
401 401
402 G4VisCommandGeometrySetForceLineSegmentsPerC 402 G4VisCommandGeometrySetForceLineSegmentsPerCircleFunction
403 setForceLineSegmentsPerCircle(lineSegmentsPe 403 setForceLineSegmentsPerCircle(lineSegmentsPerCircle);
404 Set(name, setForceLineSegmentsPerCircle, req 404 Set(name, setForceLineSegmentsPerCircle, requestedDepth);
405 } 405 }
406 406
407 ////////////// /vis/geometry/set/forceSolid // 407 ////////////// /vis/geometry/set/forceSolid /////////////////////////
408 408
409 G4VisCommandGeometrySetForceSolid::G4VisComman 409 G4VisCommandGeometrySetForceSolid::G4VisCommandGeometrySetForceSolid()
410 { 410 {
411 G4bool omitable; 411 G4bool omitable;
412 fpCommand = new G4UIcommand("/vis/geometry/s 412 fpCommand = new G4UIcommand("/vis/geometry/set/forceSolid", this);
413 fpCommand->SetGuidance 413 fpCommand->SetGuidance
414 ("Forces logical volume(s) always to be dra 414 ("Forces logical volume(s) always to be drawn solid (surface drawing),"
415 "\nregardless of the view parameters."); 415 "\nregardless of the view parameters.");
416 fpCommand->SetGuidance("\"all\" sets all log 416 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
417 fpCommand->SetGuidance 417 fpCommand->SetGuidance
418 ("Optionally propagates down hierarchy to 418 ("Optionally propagates down hierarchy to given depth.");
419 G4UIparameter* parameter; 419 G4UIparameter* parameter;
420 parameter = new G4UIparameter ("logical-volu 420 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
421 parameter->SetDefaultValue("all"); 421 parameter->SetDefaultValue("all");
422 fpCommand->SetParameter(parameter); 422 fpCommand->SetParameter(parameter);
423 parameter = new G4UIparameter("depth", 'd', 423 parameter = new G4UIparameter("depth", 'd', omitable = true);
424 parameter->SetDefaultValue(0); 424 parameter->SetDefaultValue(0);
425 parameter->SetGuidance 425 parameter->SetGuidance
426 ("Depth of propagation (-1 means unlimited 426 ("Depth of propagation (-1 means unlimited depth).");
427 fpCommand->SetParameter(parameter); 427 fpCommand->SetParameter(parameter);
428 parameter = new G4UIparameter("force", 'b', 428 parameter = new G4UIparameter("force", 'b', omitable = true);
429 parameter->SetDefaultValue(true); 429 parameter->SetDefaultValue(true);
430 fpCommand->SetParameter(parameter); 430 fpCommand->SetParameter(parameter);
431 } 431 }
432 432
433 G4VisCommandGeometrySetForceSolid::~G4VisComma 433 G4VisCommandGeometrySetForceSolid::~G4VisCommandGeometrySetForceSolid()
434 { 434 {
435 delete fpCommand; 435 delete fpCommand;
436 } 436 }
437 437
438 G4String 438 G4String
439 G4VisCommandGeometrySetForceSolid::GetCurrentV 439 G4VisCommandGeometrySetForceSolid::GetCurrentValue(G4UIcommand*)
440 { 440 {
441 return ""; 441 return "";
442 } 442 }
443 443
444 void G4VisCommandGeometrySetForceSolid::SetNew 444 void G4VisCommandGeometrySetForceSolid::SetNewValue
445 (G4UIcommand*, G4String newValue) 445 (G4UIcommand*, G4String newValue)
446 { 446 {
447 G4String name; 447 G4String name;
448 G4int requestedDepth; 448 G4int requestedDepth;
449 G4String forceString; 449 G4String forceString;
450 std::istringstream iss(newValue); 450 std::istringstream iss(newValue);
451 iss >> name >> requestedDepth >> forceString 451 iss >> name >> requestedDepth >> forceString;
452 G4bool force = G4UIcommand::ConvertToBool(fo 452 G4bool force = G4UIcommand::ConvertToBool(forceString);
453 453
454 G4VisCommandGeometrySetForceSolidFunction se 454 G4VisCommandGeometrySetForceSolidFunction setForceSolid(force);
455 Set(name, setForceSolid, requestedDepth); 455 Set(name, setForceSolid, requestedDepth);
456 } 456 }
457 457
458 ////////////// /vis/geometry/set/forceWirefram 458 ////////////// /vis/geometry/set/forceWireframe /////////////////////////
459 459
460 G4VisCommandGeometrySetForceWireframe::G4VisCo 460 G4VisCommandGeometrySetForceWireframe::G4VisCommandGeometrySetForceWireframe()
461 { 461 {
462 G4bool omitable; 462 G4bool omitable;
463 fpCommand = new G4UIcommand("/vis/geometry/s 463 fpCommand = new G4UIcommand("/vis/geometry/set/forceWireframe", this);
464 fpCommand->SetGuidance 464 fpCommand->SetGuidance
465 ("Forces logical volume(s) always to be dra 465 ("Forces logical volume(s) always to be drawn as wireframe,"
466 "\nregardless of the view parameters."); 466 "\nregardless of the view parameters.");
467 fpCommand->SetGuidance("\"all\" sets all log 467 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
468 fpCommand->SetGuidance 468 fpCommand->SetGuidance
469 ("Optionally propagates down hierarchy to 469 ("Optionally propagates down hierarchy to given depth.");
470 G4UIparameter* parameter; 470 G4UIparameter* parameter;
471 parameter = new G4UIparameter ("logical-volu 471 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
472 parameter->SetDefaultValue("all"); 472 parameter->SetDefaultValue("all");
473 fpCommand->SetParameter(parameter); 473 fpCommand->SetParameter(parameter);
474 parameter = new G4UIparameter("depth", 'd', 474 parameter = new G4UIparameter("depth", 'd', omitable = true);
475 parameter->SetDefaultValue(0); 475 parameter->SetDefaultValue(0);
476 parameter->SetGuidance 476 parameter->SetGuidance
477 ("Depth of propagation (-1 means unlimited 477 ("Depth of propagation (-1 means unlimited depth).");
478 fpCommand->SetParameter(parameter); 478 fpCommand->SetParameter(parameter);
479 parameter = new G4UIparameter("forceWirefram 479 parameter = new G4UIparameter("forceWireframe", 'b', omitable = true);
480 parameter->SetDefaultValue(true); 480 parameter->SetDefaultValue(true);
481 fpCommand->SetParameter(parameter); 481 fpCommand->SetParameter(parameter);
482 } 482 }
483 483
484 G4VisCommandGeometrySetForceWireframe::~G4VisC 484 G4VisCommandGeometrySetForceWireframe::~G4VisCommandGeometrySetForceWireframe()
485 { 485 {
486 delete fpCommand; 486 delete fpCommand;
487 } 487 }
488 488
489 G4String 489 G4String
490 G4VisCommandGeometrySetForceWireframe::GetCurr 490 G4VisCommandGeometrySetForceWireframe::GetCurrentValue(G4UIcommand*)
491 { 491 {
492 return ""; 492 return "";
493 } 493 }
494 494
495 void G4VisCommandGeometrySetForceWireframe::Se 495 void G4VisCommandGeometrySetForceWireframe::SetNewValue
496 (G4UIcommand*, G4String newValue) 496 (G4UIcommand*, G4String newValue)
497 { 497 {
498 G4String name; 498 G4String name;
499 G4int requestedDepth; 499 G4int requestedDepth;
500 G4String forceWireframeString; 500 G4String forceWireframeString;
501 std::istringstream iss(newValue); 501 std::istringstream iss(newValue);
502 iss >> name >> requestedDepth >> forceWirefr 502 iss >> name >> requestedDepth >> forceWireframeString;
503 G4bool forceWireframe = G4UIcommand::Convert 503 G4bool forceWireframe = G4UIcommand::ConvertToBool(forceWireframeString);
504 504
505 G4VisCommandGeometrySetForceWireframeFunctio 505 G4VisCommandGeometrySetForceWireframeFunction
506 setForceWireframe(forceWireframe); 506 setForceWireframe(forceWireframe);
507 Set(name, setForceWireframe, requestedDepth) 507 Set(name, setForceWireframe, requestedDepth);
508 } 508 }
509 509
510 ////////////// /vis/geometry/set/lineStyle /// 510 ////////////// /vis/geometry/set/lineStyle /////////////////////////////////
511 511
512 G4VisCommandGeometrySetLineStyle::G4VisCommand 512 G4VisCommandGeometrySetLineStyle::G4VisCommandGeometrySetLineStyle()
513 { 513 {
514 G4bool omitable; 514 G4bool omitable;
515 fpCommand = new G4UIcommand("/vis/geometry/s 515 fpCommand = new G4UIcommand("/vis/geometry/set/lineStyle", this);
516 fpCommand->SetGuidance("Sets line style of l 516 fpCommand->SetGuidance("Sets line style of logical volume(s) drawing.");
517 fpCommand->SetGuidance("\"all\" sets all log 517 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
518 fpCommand->SetGuidance 518 fpCommand->SetGuidance
519 ("Optionally propagates down hierarchy to 519 ("Optionally propagates down hierarchy to given depth.");
520 G4UIparameter* parameter; 520 G4UIparameter* parameter;
521 parameter = new G4UIparameter ("logical-volu 521 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
522 parameter->SetDefaultValue("all"); 522 parameter->SetDefaultValue("all");
523 fpCommand->SetParameter(parameter); 523 fpCommand->SetParameter(parameter);
524 parameter = new G4UIparameter("depth", 'd', 524 parameter = new G4UIparameter("depth", 'd', omitable = true);
525 parameter->SetDefaultValue(0); 525 parameter->SetDefaultValue(0);
526 parameter->SetGuidance 526 parameter->SetGuidance
527 ("Depth of propagation (-1 means unlimited 527 ("Depth of propagation (-1 means unlimited depth).");
528 fpCommand->SetParameter(parameter); 528 fpCommand->SetParameter(parameter);
529 parameter = new G4UIparameter("lineStyle", ' 529 parameter = new G4UIparameter("lineStyle", 's', omitable = true);
530 parameter->SetParameterCandidates("unbroken 530 parameter->SetParameterCandidates("unbroken dashed dotted");
531 parameter->SetDefaultValue("unbroken"); 531 parameter->SetDefaultValue("unbroken");
532 fpCommand->SetParameter(parameter); 532 fpCommand->SetParameter(parameter);
533 } 533 }
534 534
535 G4VisCommandGeometrySetLineStyle::~G4VisComman 535 G4VisCommandGeometrySetLineStyle::~G4VisCommandGeometrySetLineStyle()
536 { 536 {
537 delete fpCommand; 537 delete fpCommand;
538 } 538 }
539 539
540 G4String 540 G4String
541 G4VisCommandGeometrySetLineStyle::GetCurrentVa 541 G4VisCommandGeometrySetLineStyle::GetCurrentValue(G4UIcommand*)
542 { 542 {
543 return ""; 543 return "";
544 } 544 }
545 545
546 void G4VisCommandGeometrySetLineStyle::SetNewV 546 void G4VisCommandGeometrySetLineStyle::SetNewValue
547 (G4UIcommand*, G4String newValue) 547 (G4UIcommand*, G4String newValue)
548 { 548 {
549 G4String name, lineStyleString; 549 G4String name, lineStyleString;
550 G4int requestedDepth; 550 G4int requestedDepth;
551 std::istringstream iss(newValue); 551 std::istringstream iss(newValue);
552 iss >> name >> requestedDepth >> lineStyleSt 552 iss >> name >> requestedDepth >> lineStyleString;
553 G4VisAttributes::LineStyle lineStyle = G4Vis 553 G4VisAttributes::LineStyle lineStyle = G4VisAttributes::unbroken;
554 if (lineStyleString == "unbroken") lineStyle 554 if (lineStyleString == "unbroken") lineStyle = G4VisAttributes::unbroken;
555 if (lineStyleString == "dashed") lineStyle = 555 if (lineStyleString == "dashed") lineStyle = G4VisAttributes::dashed;
556 if (lineStyleString == "dotted") lineStyle = 556 if (lineStyleString == "dotted") lineStyle = G4VisAttributes::dotted;
557 557
558 G4VisCommandGeometrySetLineStyleFunction set 558 G4VisCommandGeometrySetLineStyleFunction setLineStyle(lineStyle);
559 Set(name, setLineStyle, requestedDepth); 559 Set(name, setLineStyle, requestedDepth);
560 } 560 }
561 561
562 ////////////// /vis/geometry/set/lineWidth /// 562 ////////////// /vis/geometry/set/lineWidth /////////////////////////////////
563 563
564 G4VisCommandGeometrySetLineWidth::G4VisCommand 564 G4VisCommandGeometrySetLineWidth::G4VisCommandGeometrySetLineWidth()
565 { 565 {
566 G4bool omitable; 566 G4bool omitable;
567 fpCommand = new G4UIcommand("/vis/geometry/s 567 fpCommand = new G4UIcommand("/vis/geometry/set/lineWidth", this);
568 fpCommand->SetGuidance("Sets line width of l 568 fpCommand->SetGuidance("Sets line width of logical volume(s) drawing.");
569 fpCommand->SetGuidance("\"all\" sets all log 569 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
570 fpCommand->SetGuidance 570 fpCommand->SetGuidance
571 ("Optionally propagates down hierarchy to 571 ("Optionally propagates down hierarchy to given depth.");
572 G4UIparameter* parameter; 572 G4UIparameter* parameter;
573 parameter = new G4UIparameter ("logical-volu 573 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
574 parameter->SetDefaultValue("all"); 574 parameter->SetDefaultValue("all");
575 fpCommand->SetParameter(parameter); 575 fpCommand->SetParameter(parameter);
576 parameter = new G4UIparameter("depth", 'd', 576 parameter = new G4UIparameter("depth", 'd', omitable = true);
577 parameter->SetDefaultValue(0); 577 parameter->SetDefaultValue(0);
578 parameter->SetGuidance 578 parameter->SetGuidance
579 ("Depth of propagation (-1 means unlimited 579 ("Depth of propagation (-1 means unlimited depth).");
580 fpCommand->SetParameter(parameter); 580 fpCommand->SetParameter(parameter);
581 parameter = new G4UIparameter("lineWidth", ' 581 parameter = new G4UIparameter("lineWidth", 'd', omitable = true);
582 parameter->SetDefaultValue(1.); 582 parameter->SetDefaultValue(1.);
583 fpCommand->SetParameter(parameter); 583 fpCommand->SetParameter(parameter);
584 } 584 }
585 585
586 G4VisCommandGeometrySetLineWidth::~G4VisComman 586 G4VisCommandGeometrySetLineWidth::~G4VisCommandGeometrySetLineWidth()
587 { 587 {
588 delete fpCommand; 588 delete fpCommand;
589 } 589 }
590 590
591 G4String 591 G4String
592 G4VisCommandGeometrySetLineWidth::GetCurrentVa 592 G4VisCommandGeometrySetLineWidth::GetCurrentValue(G4UIcommand*)
593 { 593 {
594 return ""; 594 return "";
595 } 595 }
596 596
597 void G4VisCommandGeometrySetLineWidth::SetNewV 597 void G4VisCommandGeometrySetLineWidth::SetNewValue
598 (G4UIcommand*, G4String newValue) 598 (G4UIcommand*, G4String newValue)
599 { 599 {
600 G4String name; 600 G4String name;
601 G4int requestedDepth; 601 G4int requestedDepth;
602 G4double lineWidth; 602 G4double lineWidth;
603 std::istringstream iss(newValue); 603 std::istringstream iss(newValue);
604 iss >> name >> requestedDepth >> lineWidth; 604 iss >> name >> requestedDepth >> lineWidth;
605 605
606 G4VisCommandGeometrySetLineWidthFunction set 606 G4VisCommandGeometrySetLineWidthFunction setLineWidth(lineWidth);
607 Set(name, setLineWidth, requestedDepth); 607 Set(name, setLineWidth, requestedDepth);
608 } 608 }
609 609
610 ////////////// /vis/geometry/set/visibility // 610 ////////////// /vis/geometry/set/visibility ///////////////////////////////////////
611 611
612 G4VisCommandGeometrySetVisibility::G4VisComman 612 G4VisCommandGeometrySetVisibility::G4VisCommandGeometrySetVisibility()
613 { 613 {
614 G4bool omitable; 614 G4bool omitable;
615 fpCommand = new G4UIcommand("/vis/geometry/s 615 fpCommand = new G4UIcommand("/vis/geometry/set/visibility", this);
616 fpCommand->SetGuidance("Sets visibility of l 616 fpCommand->SetGuidance("Sets visibility of logical volume(s).");
617 fpCommand->SetGuidance("\"all\" sets all log 617 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
618 fpCommand->SetGuidance 618 fpCommand->SetGuidance
619 ("Optionally propagates down hierarchy to 619 ("Optionally propagates down hierarchy to given depth.");
620 G4UIparameter* parameter; 620 G4UIparameter* parameter;
621 parameter = new G4UIparameter ("logical-volu 621 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
622 parameter->SetDefaultValue("all"); 622 parameter->SetDefaultValue("all");
623 fpCommand->SetParameter(parameter); 623 fpCommand->SetParameter(parameter);
624 parameter = new G4UIparameter("depth", 'd', 624 parameter = new G4UIparameter("depth", 'd', omitable = true);
625 parameter->SetDefaultValue(0); 625 parameter->SetDefaultValue(0);
626 parameter->SetGuidance 626 parameter->SetGuidance
627 ("Depth of propagation (-1 means unlimited 627 ("Depth of propagation (-1 means unlimited depth).");
628 fpCommand->SetParameter(parameter); 628 fpCommand->SetParameter(parameter);
629 parameter = new G4UIparameter("visibility", 629 parameter = new G4UIparameter("visibility", 'b', omitable = true);
630 parameter->SetDefaultValue(true); 630 parameter->SetDefaultValue(true);
631 fpCommand->SetParameter(parameter); 631 fpCommand->SetParameter(parameter);
632 } 632 }
633 633
634 G4VisCommandGeometrySetVisibility::~G4VisComma 634 G4VisCommandGeometrySetVisibility::~G4VisCommandGeometrySetVisibility()
635 { 635 {
636 delete fpCommand; 636 delete fpCommand;
637 } 637 }
638 638
639 G4String G4VisCommandGeometrySetVisibility::Ge 639 G4String G4VisCommandGeometrySetVisibility::GetCurrentValue(G4UIcommand*)
640 { 640 {
641 return ""; 641 return "";
642 } 642 }
643 643
644 void G4VisCommandGeometrySetVisibility::SetNew 644 void G4VisCommandGeometrySetVisibility::SetNewValue
645 (G4UIcommand*, G4String newValue) 645 (G4UIcommand*, G4String newValue)
646 { 646 {
647 G4String name; 647 G4String name;
648 G4int requestedDepth; 648 G4int requestedDepth;
649 G4String visibilityString; 649 G4String visibilityString;
650 std::istringstream iss(newValue); 650 std::istringstream iss(newValue);
651 iss >> name >> requestedDepth >> visibilityS 651 iss >> name >> requestedDepth >> visibilityString;
652 G4bool visibility = G4UIcommand::ConvertToBo 652 G4bool visibility = G4UIcommand::ConvertToBool(visibilityString);
653 653
654 G4VisCommandGeometrySetVisibilityFunction se 654 G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
655 Set(name, setVisibility, requestedDepth); 655 Set(name, setVisibility, requestedDepth);
656 656
657 G4VViewer* pViewer = fpVisManager->GetCurren 657 G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
658 if (pViewer) { 658 if (pViewer) {
659 const G4ViewParameters& viewParams = pView 659 const G4ViewParameters& viewParams = pViewer->GetViewParameters();
660 if (fpVisManager->GetVerbosity() >= G4VisM 660 if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
661 if (!viewParams.IsCulling() || 661 if (!viewParams.IsCulling() ||
662 !viewParams.IsCullingInvisible()) { 662 !viewParams.IsCullingInvisible()) {
663 G4warn << 663 G4warn <<
664 "Culling must be on - \"/vis/viewer/set/cu 664 "Culling must be on - \"/vis/viewer/set/culling global true\" and"
665 "\n \"/vis/viewer/set/culling invisible t 665 "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
666 << G4endl; 666 << G4endl;
667 } 667 }
668 } 668 }
669 } 669 }
670 } 670 }
671 671
672 void G4VisCommandGeometrySetVisibility::SetNew 672 void G4VisCommandGeometrySetVisibility::SetNewValueOnLV
673 (G4LogicalVolume* pLV, G4int requestedDepth,G4 673 (G4LogicalVolume* pLV, G4int requestedDepth,G4bool visibility)
674 { 674 {
675 if (!pLV) return; 675 if (!pLV) return;
676 G4VisCommandGeometrySetVisibilityFunction se 676 G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
677 SetLVVisAtts(pLV, setVisibility, 0, requeste 677 SetLVVisAtts(pLV, setVisibility, 0, requestedDepth);
678 678
679 G4VViewer* pViewer = fpVisManager->GetCurren 679 G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
680 if (pViewer) { 680 if (pViewer) {
681 G4UImanager::GetUIpointer()->ApplyCommand( 681 G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
682 const G4ViewParameters& viewParams = pView 682 const G4ViewParameters& viewParams = pViewer->GetViewParameters();
683 if (fpVisManager->GetVerbosity() >= G4VisM 683 if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
684 if (!viewParams.IsCulling() || 684 if (!viewParams.IsCulling() ||
685 !viewParams.IsCullingInvisible()) { 685 !viewParams.IsCullingInvisible()) {
686 G4warn << 686 G4warn <<
687 "Culling must be on - \"/vis/viewer/set/cu 687 "Culling must be on - \"/vis/viewer/set/culling global true\" and"
688 "\n \"/vis/viewer/set/culling invisible t 688 "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
689 << G4endl; 689 << G4endl;
690 } 690 }
691 } 691 }
692 } 692 }
693 } 693 }
694 694