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