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