Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommandsGeometrySet.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/management/src/G4VisCommandsGeometrySet.cc (Version 11.3.0) and /visualization/management/src/G4VisCommandsGeometrySet.cc (Version 10.0.p3)


  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 // $Id: G4VisCommandsGeometrySet.cc 66870 2013-01-14 23:38:59Z adotti $
 27                                                    28 
 28 // /vis/geometry commands - John Allison  31st     29 // /vis/geometry commands - John Allison  31st January 2006
 29                                                    30 
 30 #include "G4VisCommandsGeometrySet.hh"             31 #include "G4VisCommandsGeometrySet.hh"
 31                                                    32 
 32 #include "G4UIcommand.hh"                          33 #include "G4UIcommand.hh"
 33 #include "G4VisManager.hh"                         34 #include "G4VisManager.hh"
 34 #include "G4LogicalVolumeStore.hh"                 35 #include "G4LogicalVolumeStore.hh"
 35 #include "G4UImanager.hh"                          36 #include "G4UImanager.hh"
 36                                                    37 
 37 #include <sstream>                                 38 #include <sstream>
 38                                                <<  39 #include <cctype>
 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 (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       G4cout << "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 << 
 65   for (const auto& scene : fpVisManager->GetSc << 
 66     const auto& runDurationModelList = scene-> << 
 67     for (const auto& sceneModel : runDurationM << 
 68       auto model = sceneModel.fpModel;         << 
 69       auto pvModel = dynamic_cast<G4PhysicalVo << 
 70       if (pvModel) pvModel->CalculateExtent(); << 
 71     }                                          << 
 72     // And re-calculate the scene's extent     << 
 73     scene->CalculateExtent();                  << 
 74   }                                            << 
 75   if (fpVisManager->GetCurrentViewer()) {          64   if (fpVisManager->GetCurrentViewer()) {
 76     G4UImanager::GetUIpointer()->ApplyCommand(     65     G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
 77   }                                                66   }
 78 }                                                  67 }
 79                                                    68 
 80 void G4VVisCommandGeometrySet::SetLVVisAtts        69 void G4VVisCommandGeometrySet::SetLVVisAtts
 81 (G4LogicalVolume* pLV,                             70 (G4LogicalVolume* pLV,
 82  const G4VVisCommandGeometrySetFunction& setFu     71  const G4VVisCommandGeometrySetFunction& setFunction,
 83  G4int depth, G4int requestedDepth)                72  G4int depth, G4int requestedDepth)
 84 {                                                  73 {
 85   G4VisManager::Verbosity verbosity = fpVisMan     74   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 86   const G4VisAttributes* oldVisAtts = pLV->Get     75   const G4VisAttributes* oldVisAtts = pLV->GetVisAttributes();
 87   fVisAttsMap.insert(std::make_pair(pLV,oldVis     76   fVisAttsMap.insert(std::make_pair(pLV,oldVisAtts));  // Store old vis atts.
 88   G4VisAttributes* newVisAtts = new G4VisAttri     77   G4VisAttributes* newVisAtts = new G4VisAttributes;   // Memory leak!
 89   if (oldVisAtts) {                                78   if (oldVisAtts) {
 90     *newVisAtts = *oldVisAtts;                     79     *newVisAtts = *oldVisAtts;
 91   }                                                80   }
 92   setFunction(newVisAtts);  // Sets whatever a     81   setFunction(newVisAtts);  // Sets whatever attribute determined by
 93           // function object.                      82           // function object.
 94   pLV->SetVisAttributes(newVisAtts);               83   pLV->SetVisAttributes(newVisAtts);
 95   if (verbosity >= G4VisManager::confirmations     84   if (verbosity >= G4VisManager::confirmations) {
 96     G4cout << "\nLogical Volume \"" << pLV->Ge     85     G4cout << "\nLogical Volume \"" << pLV->GetName()
 97      << "\": setting vis attributes:";         <<  86      << "\": setting vis attributes:\nwas: " << *oldVisAtts
 98     if (oldVisAtts) {                          <<  87      << "\nnow: " << *newVisAtts
 99       G4cout << "\nwas: " << *oldVisAtts;      << 
100     } else {                                   << 
101       G4cout << "\n(no old attributes)";       << 
102     }                                          << 
103     G4cout << "\nnow: " << *newVisAtts         << 
104      << G4endl;                                    88      << G4endl;
105   }                                                89   }
106   if (requestedDepth < 0 || depth < requestedD <<  90   if (requestedDepth < 0 || depth++ < requestedDepth) {
107     G4int nDaughters = (G4int)pLV->GetNoDaught <<  91     G4int nDaughters = pLV->GetNoDaughters();
108     for (G4int i = 0; i < nDaughters; ++i) {       92     for (G4int i = 0; i < nDaughters; ++i) {
109       SetLVVisAtts(pLV->GetDaughter(i)->GetLog     93       SetLVVisAtts(pLV->GetDaughter(i)->GetLogicalVolume(),
110        setFunction, ++depth, requestedDepth);  <<  94        setFunction, depth, requestedDepth);
111     }                                              95     }
112   }                                                96   }
113 }                                                  97 }
114                                                    98 
115 ////////////// /vis/geometry/set/colour //////     99 ////////////// /vis/geometry/set/colour ///////////////////////////////////////
116                                                   100 
117 G4VisCommandGeometrySetColour::G4VisCommandGeo    101 G4VisCommandGeometrySetColour::G4VisCommandGeometrySetColour()
118 {                                                 102 {
119   G4bool omitable;                                103   G4bool omitable;
120   fpCommand = new G4UIcommand("/vis/geometry/s    104   fpCommand = new G4UIcommand("/vis/geometry/set/colour", this);
121   fpCommand->SetGuidance("Sets colour of logic    105   fpCommand->SetGuidance("Sets colour of logical volume(s).");
122   fpCommand->SetGuidance("\"all\" sets all log    106   fpCommand->SetGuidance("\"all\" sets all logical volumes.");
123   fpCommand->SetGuidance                          107   fpCommand->SetGuidance
124     ("Optionally propagates down hierarchy to     108     ("Optionally propagates down hierarchy to given depth.");
125   G4UIparameter* parameter;                       109   G4UIparameter* parameter;
126   parameter = new G4UIparameter ("logical-volu    110   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
127   parameter->SetDefaultValue("all");              111   parameter->SetDefaultValue("all");
128   fpCommand->SetParameter(parameter);             112   fpCommand->SetParameter(parameter);
129   parameter = new G4UIparameter("depth", 'd',     113   parameter = new G4UIparameter("depth", 'd', omitable = true);
130   parameter->SetDefaultValue(0);                  114   parameter->SetDefaultValue(0);
131   parameter->SetGuidance                          115   parameter->SetGuidance
132     ("Depth of propagation (-1 means unlimited    116     ("Depth of propagation (-1 means unlimited depth).");
133   fpCommand->SetParameter(parameter);             117   fpCommand->SetParameter(parameter);
134   parameter = new G4UIparameter("red", 's', om    118   parameter = new G4UIparameter("red", 's', omitable = true);
135   parameter->SetDefaultValue("1.");               119   parameter->SetDefaultValue("1.");
136   parameter->SetGuidance                          120   parameter->SetGuidance
137     ("Red component or a string, e.g., \"blue\    121     ("Red component or a string, e.g., \"blue\", in which case succeeding colour components are ignored.");
138   fpCommand->SetParameter(parameter);             122   fpCommand->SetParameter(parameter);
139   parameter = new G4UIparameter("green", 'd',     123   parameter = new G4UIparameter("green", 'd', omitable = true);
140   parameter->SetDefaultValue(1.);                 124   parameter->SetDefaultValue(1.);
141   fpCommand->SetParameter(parameter);             125   fpCommand->SetParameter(parameter);
142   parameter = new G4UIparameter("blue", 'd', o    126   parameter = new G4UIparameter("blue", 'd', omitable = true);
143   parameter->SetDefaultValue(1.);                 127   parameter->SetDefaultValue(1.);
144   fpCommand->SetParameter(parameter);             128   fpCommand->SetParameter(parameter);
145   parameter = new G4UIparameter("opacity", 'd'    129   parameter = new G4UIparameter("opacity", 'd', omitable = true);
146   parameter->SetDefaultValue(1.);                 130   parameter->SetDefaultValue(1.);
147   fpCommand->SetParameter(parameter);             131   fpCommand->SetParameter(parameter);
148 }                                                 132 }
149                                                   133 
150 G4VisCommandGeometrySetColour::~G4VisCommandGe    134 G4VisCommandGeometrySetColour::~G4VisCommandGeometrySetColour()
151 {                                                 135 {
152   delete fpCommand;                               136   delete fpCommand;
153 }                                                 137 }
154                                                   138 
155 G4String G4VisCommandGeometrySetColour::GetCur    139 G4String G4VisCommandGeometrySetColour::GetCurrentValue(G4UIcommand*)
156 {                                                 140 {
157   return "";                                      141   return "";
158 }                                                 142 }
159                                                   143 
160 void G4VisCommandGeometrySetColour::SetNewValu    144 void G4VisCommandGeometrySetColour::SetNewValue
161 (G4UIcommand*, G4String newValue)                 145 (G4UIcommand*, G4String newValue)
162 {                                                 146 {
163   G4String name, redOrString;                     147   G4String name, redOrString;
164   G4int requestedDepth;                           148   G4int requestedDepth;
165   G4double green, blue, opacity;                  149   G4double green, blue, opacity;
166   std::istringstream iss(newValue);               150   std::istringstream iss(newValue);
167   iss >> name >> requestedDepth >> redOrString    151   iss >> name >> requestedDepth >> redOrString >> green >> blue >> opacity;
168   G4Colour colour(1,1,1,1);  // Default white     152   G4Colour colour(1,1,1,1);  // Default white and opaque.
169   ConvertToColour(colour, redOrString, green,  << 153   const size_t iPos0 = 0;
                                                   >> 154   if (std::isalpha(redOrString[iPos0])) {
                                                   >> 155     if (!G4Colour::GetColour(redOrString, colour)) {
                                                   >> 156       if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
                                                   >> 157         G4cout << "WARNING: Colour \"" << redOrString
                                                   >> 158                << "\" not found.  Defaulting to white and opaque."
                                                   >> 159                << G4endl;
                                                   >> 160       }
                                                   >> 161     }
                                                   >> 162   } else {
                                                   >> 163     colour = G4Colour(G4UIcommand::ConvertToDouble(redOrString), green, blue);
                                                   >> 164   }
                                                   >> 165   colour = G4Colour
                                                   >> 166     (colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
                                                   >> 167 
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(false);
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(false);
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 // << 
299                                                << 
300 G4VisCommandGeometrySetForceCloud::G4VisComman << 
301 {                                              << 
302   G4bool omitable;                             << 
303   fpCommand = new G4UIcommand("/vis/geometry/s << 
304   fpCommand->SetGuidance                       << 
305   ("Forces logical volume(s) always to be draw << 
306    "\nregardless of the view parameters.");    << 
307   fpCommand->SetGuidance("\"all\" sets all log << 
308   fpCommand->SetGuidance                       << 
309     ("Optionally propagates down hierarchy to  << 
310   G4UIparameter* parameter;                    << 
311   parameter = new G4UIparameter ("logical-volu << 
312   parameter->SetDefaultValue("all");           << 
313   fpCommand->SetParameter(parameter);          << 
314   parameter = new G4UIparameter("depth", 'd',  << 
315   parameter->SetDefaultValue(0);               << 
316   parameter->SetGuidance                       << 
317     ("Depth of propagation (-1 means unlimited << 
318   fpCommand->SetParameter(parameter);          << 
319   parameter = new G4UIparameter("forceCloud",  << 
320   parameter->SetDefaultValue(true);            << 
321   fpCommand->SetParameter(parameter);          << 
322   parameter = new G4UIparameter("nPoints", 'd' << 
323   parameter->SetGuidance                       << 
324     ("<= 0 means under control of viewer.");   << 
325   parameter->SetDefaultValue(0);               << 
326   fpCommand->SetParameter(parameter);          << 
327 }                                              << 
328                                                << 
329 G4VisCommandGeometrySetForceCloud::~G4VisComma << 
330 {                                              << 
331   delete fpCommand;                            << 
332 }                                              << 
333                                                << 
334 G4String                                       << 
335 G4VisCommandGeometrySetForceCloud::GetCurrentV << 
336 {                                              << 
337   return "";                                   << 
338 }                                              << 
339                                                << 
340 void G4VisCommandGeometrySetForceCloud::SetNew << 
341 (G4UIcommand*, G4String newValue)              << 
342 {                                              << 
343   G4String name, forceCloudString;             << 
344   G4int requestedDepth, nPoints;               << 
345   std::istringstream iss(newValue);            << 
346   iss >> name >> requestedDepth >> forceCloudS << 
347   G4bool forceCloud = G4UIcommand::ConvertToBo << 
348                                                << 
349   G4VisCommandGeometrySetForceCloudFunction se << 
350   Set(name, setForceCloud, requestedDepth);    << 
351 }                                              << 
352                                                << 
353 ////////////// /vis/geometry/set/forceLineSegm    296 ////////////// /vis/geometry/set/forceLineSegmentsPerCircle /////////////////////////
354                                                   297 
355 G4VisCommandGeometrySetForceLineSegmentsPerCir    298 G4VisCommandGeometrySetForceLineSegmentsPerCircle::G4VisCommandGeometrySetForceLineSegmentsPerCircle()
356 {                                                 299 {
357   G4bool omitable;                                300   G4bool omitable;
358   fpCommand = new G4UIcommand("/vis/geometry/s    301   fpCommand = new G4UIcommand("/vis/geometry/set/forceLineSegmentsPerCircle", this);
359   fpCommand->SetGuidance                          302   fpCommand->SetGuidance
360     ("Forces number of line segments per circl    303     ("Forces number of line segments per circle, the precision with which a"
361      "\ncurved line or surface is represented     304      "\ncurved line or surface is represented by a polygon or polyhedron,"
362      "\nregardless of the view parameters.");     305      "\nregardless of the view parameters.");
363   fpCommand->SetGuidance("\"all\" sets all log    306   fpCommand->SetGuidance("\"all\" sets all logical volumes.");
364   fpCommand->SetGuidance                          307   fpCommand->SetGuidance
365     ("Optionally propagates down hierarchy to     308     ("Optionally propagates down hierarchy to given depth.");
366   G4UIparameter* parameter;                       309   G4UIparameter* parameter;
367   parameter = new G4UIparameter ("logical-volu    310   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
368   parameter->SetDefaultValue("all");              311   parameter->SetDefaultValue("all");
369   fpCommand->SetParameter(parameter);             312   fpCommand->SetParameter(parameter);
370   parameter = new G4UIparameter("depth", 'd',     313   parameter = new G4UIparameter("depth", 'd', omitable = true);
371   parameter->SetDefaultValue(0);                  314   parameter->SetDefaultValue(0);
372   parameter->SetGuidance                          315   parameter->SetGuidance
373     ("Depth of propagation (-1 means unlimited    316     ("Depth of propagation (-1 means unlimited depth).");
374   fpCommand->SetParameter(parameter);             317   fpCommand->SetParameter(parameter);
375   parameter = new G4UIparameter("lineSegmentsP    318   parameter = new G4UIparameter("lineSegmentsPerCircle", 'd', omitable = true);
376   parameter->SetGuidance                          319   parameter->SetGuidance
377     ("<= 0 means not forced, i.e., under contr << 320     ("< 0 means not forced, i.e., under control of viewer.");
378   parameter->SetDefaultValue(0);               << 321   parameter->SetDefaultValue(-1);
379   fpCommand->SetParameter(parameter);             322   fpCommand->SetParameter(parameter);
380 }                                                 323 }
381                                                   324 
382 G4VisCommandGeometrySetForceLineSegmentsPerCir    325 G4VisCommandGeometrySetForceLineSegmentsPerCircle::~G4VisCommandGeometrySetForceLineSegmentsPerCircle()
383 {                                                 326 {
384   delete fpCommand;                               327   delete fpCommand;
385 }                                                 328 }
386                                                   329 
387 G4String                                          330 G4String
388 G4VisCommandGeometrySetForceLineSegmentsPerCir    331 G4VisCommandGeometrySetForceLineSegmentsPerCircle::GetCurrentValue(G4UIcommand*)
389 {                                                 332 {
390   return "";                                      333   return "";
391 }                                                 334 }
392                                                   335 
393 void G4VisCommandGeometrySetForceLineSegmentsP    336 void G4VisCommandGeometrySetForceLineSegmentsPerCircle::SetNewValue
394 (G4UIcommand*, G4String newValue)                 337 (G4UIcommand*, G4String newValue)
395 {                                                 338 {
396   G4String name;                                  339   G4String name;
397   G4int requestedDepth;                           340   G4int requestedDepth;
398   G4int lineSegmentsPerCircle;                    341   G4int lineSegmentsPerCircle;
399   std::istringstream iss(newValue);               342   std::istringstream iss(newValue);
400   iss >> name >> requestedDepth >> lineSegment    343   iss >> name >> requestedDepth >> lineSegmentsPerCircle;
401                                                   344 
402   G4VisCommandGeometrySetForceLineSegmentsPerC << 345   G4VisCommandGeometrySetForceLineSegmentsPerCircleFunction setForceLineSegmentsPerCircle(lineSegmentsPerCircle);
403   setForceLineSegmentsPerCircle(lineSegmentsPe << 
404   Set(name, setForceLineSegmentsPerCircle, req    346   Set(name, setForceLineSegmentsPerCircle, requestedDepth);
405 }                                                 347 }
406                                                   348 
407 ////////////// /vis/geometry/set/forceSolid //    349 ////////////// /vis/geometry/set/forceSolid /////////////////////////
408                                                   350 
409 G4VisCommandGeometrySetForceSolid::G4VisComman    351 G4VisCommandGeometrySetForceSolid::G4VisCommandGeometrySetForceSolid()
410 {                                                 352 {
411   G4bool omitable;                                353   G4bool omitable;
412   fpCommand = new G4UIcommand("/vis/geometry/s    354   fpCommand = new G4UIcommand("/vis/geometry/set/forceSolid", this);
413   fpCommand->SetGuidance                          355   fpCommand->SetGuidance
414    ("Forces logical volume(s) always to be dra    356    ("Forces logical volume(s) always to be drawn solid (surface drawing),"
415     "\nregardless of the view parameters.");      357     "\nregardless of the view parameters.");
416   fpCommand->SetGuidance("\"all\" sets all log    358   fpCommand->SetGuidance("\"all\" sets all logical volumes.");
417   fpCommand->SetGuidance                          359   fpCommand->SetGuidance
418     ("Optionally propagates down hierarchy to     360     ("Optionally propagates down hierarchy to given depth.");
419   G4UIparameter* parameter;                       361   G4UIparameter* parameter;
420   parameter = new G4UIparameter ("logical-volu    362   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
421   parameter->SetDefaultValue("all");              363   parameter->SetDefaultValue("all");
422   fpCommand->SetParameter(parameter);             364   fpCommand->SetParameter(parameter);
423   parameter = new G4UIparameter("depth", 'd',     365   parameter = new G4UIparameter("depth", 'd', omitable = true);
424   parameter->SetDefaultValue(0);                  366   parameter->SetDefaultValue(0);
425   parameter->SetGuidance                          367   parameter->SetGuidance
426     ("Depth of propagation (-1 means unlimited    368     ("Depth of propagation (-1 means unlimited depth).");
427   fpCommand->SetParameter(parameter);             369   fpCommand->SetParameter(parameter);
428   parameter = new G4UIparameter("force", 'b',  << 370   parameter = new G4UIparameter("forceSolid", 'b', omitable = true);
429   parameter->SetDefaultValue(true);            << 371   parameter->SetDefaultValue(false);
430   fpCommand->SetParameter(parameter);             372   fpCommand->SetParameter(parameter);
431 }                                                 373 }
432                                                   374 
433 G4VisCommandGeometrySetForceSolid::~G4VisComma    375 G4VisCommandGeometrySetForceSolid::~G4VisCommandGeometrySetForceSolid()
434 {                                                 376 {
435   delete fpCommand;                               377   delete fpCommand;
436 }                                                 378 }
437                                                   379 
438 G4String                                          380 G4String
439 G4VisCommandGeometrySetForceSolid::GetCurrentV    381 G4VisCommandGeometrySetForceSolid::GetCurrentValue(G4UIcommand*)
440 {                                                 382 {
441   return "";                                      383   return "";
442 }                                                 384 }
443                                                   385 
444 void G4VisCommandGeometrySetForceSolid::SetNew    386 void G4VisCommandGeometrySetForceSolid::SetNewValue
445 (G4UIcommand*, G4String newValue)                 387 (G4UIcommand*, G4String newValue)
446 {                                                 388 {
447   G4String name;                                  389   G4String name;
448   G4int requestedDepth;                           390   G4int requestedDepth;
449   G4String forceString;                        << 391   G4String forceSolidString;
450   std::istringstream iss(newValue);               392   std::istringstream iss(newValue);
451   iss >> name >> requestedDepth >> forceString << 393   iss >> name >> requestedDepth >> forceSolidString;
452   G4bool force = G4UIcommand::ConvertToBool(fo << 394   G4bool forceSolid = G4UIcommand::ConvertToBool(forceSolidString);
453                                                   395 
454   G4VisCommandGeometrySetForceSolidFunction se << 396   G4VisCommandGeometrySetForceSolidFunction setForceSolid(forceSolid);
455   Set(name, setForceSolid, requestedDepth);       397   Set(name, setForceSolid, requestedDepth);
456 }                                                 398 }
457                                                   399 
458 ////////////// /vis/geometry/set/forceWirefram    400 ////////////// /vis/geometry/set/forceWireframe /////////////////////////
459                                                   401 
460 G4VisCommandGeometrySetForceWireframe::G4VisCo    402 G4VisCommandGeometrySetForceWireframe::G4VisCommandGeometrySetForceWireframe()
461 {                                                 403 {
462   G4bool omitable;                                404   G4bool omitable;
463   fpCommand = new G4UIcommand("/vis/geometry/s    405   fpCommand = new G4UIcommand("/vis/geometry/set/forceWireframe", this);
464   fpCommand->SetGuidance                          406   fpCommand->SetGuidance
465    ("Forces logical volume(s) always to be dra    407    ("Forces logical volume(s) always to be drawn as wireframe,"
466     "\nregardless of the view parameters.");      408     "\nregardless of the view parameters.");
467   fpCommand->SetGuidance("\"all\" sets all log    409   fpCommand->SetGuidance("\"all\" sets all logical volumes.");
468   fpCommand->SetGuidance                          410   fpCommand->SetGuidance
469     ("Optionally propagates down hierarchy to     411     ("Optionally propagates down hierarchy to given depth.");
470   G4UIparameter* parameter;                       412   G4UIparameter* parameter;
471   parameter = new G4UIparameter ("logical-volu    413   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
472   parameter->SetDefaultValue("all");              414   parameter->SetDefaultValue("all");
473   fpCommand->SetParameter(parameter);             415   fpCommand->SetParameter(parameter);
474   parameter = new G4UIparameter("depth", 'd',     416   parameter = new G4UIparameter("depth", 'd', omitable = true);
475   parameter->SetDefaultValue(0);                  417   parameter->SetDefaultValue(0);
476   parameter->SetGuidance                          418   parameter->SetGuidance
477     ("Depth of propagation (-1 means unlimited    419     ("Depth of propagation (-1 means unlimited depth).");
478   fpCommand->SetParameter(parameter);             420   fpCommand->SetParameter(parameter);
479   parameter = new G4UIparameter("forceWirefram    421   parameter = new G4UIparameter("forceWireframe", 'b', omitable = true);
480   parameter->SetDefaultValue(true);            << 422   parameter->SetDefaultValue(false);
481   fpCommand->SetParameter(parameter);             423   fpCommand->SetParameter(parameter);
482 }                                                 424 }
483                                                   425 
484 G4VisCommandGeometrySetForceWireframe::~G4VisC    426 G4VisCommandGeometrySetForceWireframe::~G4VisCommandGeometrySetForceWireframe()
485 {                                                 427 {
486   delete fpCommand;                               428   delete fpCommand;
487 }                                                 429 }
488                                                   430 
489 G4String                                          431 G4String
490 G4VisCommandGeometrySetForceWireframe::GetCurr    432 G4VisCommandGeometrySetForceWireframe::GetCurrentValue(G4UIcommand*)
491 {                                                 433 {
492   return "";                                      434   return "";
493 }                                                 435 }
494                                                   436 
495 void G4VisCommandGeometrySetForceWireframe::Se    437 void G4VisCommandGeometrySetForceWireframe::SetNewValue
496 (G4UIcommand*, G4String newValue)                 438 (G4UIcommand*, G4String newValue)
497 {                                                 439 {
498   G4String name;                                  440   G4String name;
499   G4int requestedDepth;                           441   G4int requestedDepth;
500   G4String forceWireframeString;                  442   G4String forceWireframeString;
501   std::istringstream iss(newValue);               443   std::istringstream iss(newValue);
502   iss >> name >> requestedDepth >> forceWirefr    444   iss >> name >> requestedDepth >> forceWireframeString;
503   G4bool forceWireframe = G4UIcommand::Convert    445   G4bool forceWireframe = G4UIcommand::ConvertToBool(forceWireframeString);
504                                                   446 
505   G4VisCommandGeometrySetForceWireframeFunctio    447   G4VisCommandGeometrySetForceWireframeFunction
506     setForceWireframe(forceWireframe);            448     setForceWireframe(forceWireframe);
507   Set(name, setForceWireframe, requestedDepth)    449   Set(name, setForceWireframe, requestedDepth);
508 }                                                 450 }
509                                                   451 
510 ////////////// /vis/geometry/set/lineStyle ///    452 ////////////// /vis/geometry/set/lineStyle /////////////////////////////////
511                                                   453 
512 G4VisCommandGeometrySetLineStyle::G4VisCommand    454 G4VisCommandGeometrySetLineStyle::G4VisCommandGeometrySetLineStyle()
513 {                                                 455 {
514   G4bool omitable;                                456   G4bool omitable;
515   fpCommand = new G4UIcommand("/vis/geometry/s    457   fpCommand = new G4UIcommand("/vis/geometry/set/lineStyle", this);
516   fpCommand->SetGuidance("Sets line style of l    458   fpCommand->SetGuidance("Sets line style of logical volume(s) drawing.");
517   fpCommand->SetGuidance("\"all\" sets all log    459   fpCommand->SetGuidance("\"all\" sets all logical volumes.");
518   fpCommand->SetGuidance                          460   fpCommand->SetGuidance
519     ("Optionally propagates down hierarchy to     461     ("Optionally propagates down hierarchy to given depth.");
520   G4UIparameter* parameter;                       462   G4UIparameter* parameter;
521   parameter = new G4UIparameter ("logical-volu    463   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
522   parameter->SetDefaultValue("all");              464   parameter->SetDefaultValue("all");
523   fpCommand->SetParameter(parameter);             465   fpCommand->SetParameter(parameter);
524   parameter = new G4UIparameter("depth", 'd',     466   parameter = new G4UIparameter("depth", 'd', omitable = true);
525   parameter->SetDefaultValue(0);                  467   parameter->SetDefaultValue(0);
526   parameter->SetGuidance                          468   parameter->SetGuidance
527     ("Depth of propagation (-1 means unlimited    469     ("Depth of propagation (-1 means unlimited depth).");
528   fpCommand->SetParameter(parameter);             470   fpCommand->SetParameter(parameter);
529   parameter = new G4UIparameter("lineStyle", '    471   parameter = new G4UIparameter("lineStyle", 's', omitable = true);
530   parameter->SetParameterCandidates("unbroken     472   parameter->SetParameterCandidates("unbroken dashed dotted");
531   parameter->SetDefaultValue("unbroken");         473   parameter->SetDefaultValue("unbroken");
532   fpCommand->SetParameter(parameter);             474   fpCommand->SetParameter(parameter);
533 }                                                 475 }
534                                                   476 
535 G4VisCommandGeometrySetLineStyle::~G4VisComman    477 G4VisCommandGeometrySetLineStyle::~G4VisCommandGeometrySetLineStyle()
536 {                                                 478 {
537   delete fpCommand;                               479   delete fpCommand;
538 }                                                 480 }
539                                                   481 
540 G4String                                          482 G4String
541 G4VisCommandGeometrySetLineStyle::GetCurrentVa    483 G4VisCommandGeometrySetLineStyle::GetCurrentValue(G4UIcommand*)
542 {                                                 484 {
543   return "";                                      485   return "";
544 }                                                 486 }
545                                                   487 
546 void G4VisCommandGeometrySetLineStyle::SetNewV    488 void G4VisCommandGeometrySetLineStyle::SetNewValue
547 (G4UIcommand*, G4String newValue)                 489 (G4UIcommand*, G4String newValue)
548 {                                                 490 {
549   G4String name, lineStyleString;                 491   G4String name, lineStyleString;
550   G4int requestedDepth;                           492   G4int requestedDepth;
551   std::istringstream iss(newValue);               493   std::istringstream iss(newValue);
552   iss >> name >> requestedDepth >> lineStyleSt    494   iss >> name >> requestedDepth >> lineStyleString;
553   G4VisAttributes::LineStyle lineStyle = G4Vis    495   G4VisAttributes::LineStyle lineStyle = G4VisAttributes::unbroken;
554   if (lineStyleString == "unbroken") lineStyle    496   if (lineStyleString == "unbroken") lineStyle = G4VisAttributes::unbroken;
555   if (lineStyleString == "dashed") lineStyle =    497   if (lineStyleString == "dashed") lineStyle = G4VisAttributes::dashed;
556   if (lineStyleString == "dotted") lineStyle =    498   if (lineStyleString == "dotted") lineStyle = G4VisAttributes::dotted;
557                                                   499 
558   G4VisCommandGeometrySetLineStyleFunction set    500   G4VisCommandGeometrySetLineStyleFunction setLineStyle(lineStyle);
559   Set(name, setLineStyle, requestedDepth);        501   Set(name, setLineStyle, requestedDepth);
560 }                                                 502 }
561                                                   503 
562 ////////////// /vis/geometry/set/lineWidth ///    504 ////////////// /vis/geometry/set/lineWidth /////////////////////////////////
563                                                   505 
564 G4VisCommandGeometrySetLineWidth::G4VisCommand    506 G4VisCommandGeometrySetLineWidth::G4VisCommandGeometrySetLineWidth()
565 {                                                 507 {
566   G4bool omitable;                                508   G4bool omitable;
567   fpCommand = new G4UIcommand("/vis/geometry/s    509   fpCommand = new G4UIcommand("/vis/geometry/set/lineWidth", this);
568   fpCommand->SetGuidance("Sets line width of l    510   fpCommand->SetGuidance("Sets line width of logical volume(s) drawing.");
569   fpCommand->SetGuidance("\"all\" sets all log    511   fpCommand->SetGuidance("\"all\" sets all logical volumes.");
570   fpCommand->SetGuidance                          512   fpCommand->SetGuidance
571     ("Optionally propagates down hierarchy to     513     ("Optionally propagates down hierarchy to given depth.");
572   G4UIparameter* parameter;                       514   G4UIparameter* parameter;
573   parameter = new G4UIparameter ("logical-volu    515   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
574   parameter->SetDefaultValue("all");              516   parameter->SetDefaultValue("all");
575   fpCommand->SetParameter(parameter);             517   fpCommand->SetParameter(parameter);
576   parameter = new G4UIparameter("depth", 'd',     518   parameter = new G4UIparameter("depth", 'd', omitable = true);
577   parameter->SetDefaultValue(0);                  519   parameter->SetDefaultValue(0);
578   parameter->SetGuidance                          520   parameter->SetGuidance
579     ("Depth of propagation (-1 means unlimited    521     ("Depth of propagation (-1 means unlimited depth).");
580   fpCommand->SetParameter(parameter);             522   fpCommand->SetParameter(parameter);
581   parameter = new G4UIparameter("lineWidth", '    523   parameter = new G4UIparameter("lineWidth", 'd', omitable = true);
582   parameter->SetDefaultValue(1.);                 524   parameter->SetDefaultValue(1.);
583   fpCommand->SetParameter(parameter);             525   fpCommand->SetParameter(parameter);
584 }                                                 526 }
585                                                   527 
586 G4VisCommandGeometrySetLineWidth::~G4VisComman    528 G4VisCommandGeometrySetLineWidth::~G4VisCommandGeometrySetLineWidth()
587 {                                                 529 {
588   delete fpCommand;                               530   delete fpCommand;
589 }                                                 531 }
590                                                   532 
591 G4String                                          533 G4String
592 G4VisCommandGeometrySetLineWidth::GetCurrentVa    534 G4VisCommandGeometrySetLineWidth::GetCurrentValue(G4UIcommand*)
593 {                                                 535 {
594   return "";                                      536   return "";
595 }                                                 537 }
596                                                   538 
597 void G4VisCommandGeometrySetLineWidth::SetNewV    539 void G4VisCommandGeometrySetLineWidth::SetNewValue
598 (G4UIcommand*, G4String newValue)                 540 (G4UIcommand*, G4String newValue)
599 {                                                 541 {
600   G4String name;                                  542   G4String name;
601   G4int requestedDepth;                           543   G4int requestedDepth;
602   G4double lineWidth;                             544   G4double lineWidth;
603   std::istringstream iss(newValue);               545   std::istringstream iss(newValue);
604   iss >> name >> requestedDepth >> lineWidth;     546   iss >> name >> requestedDepth >> lineWidth;
605                                                   547 
606   G4VisCommandGeometrySetLineWidthFunction set    548   G4VisCommandGeometrySetLineWidthFunction setLineWidth(lineWidth);
607   Set(name, setLineWidth, requestedDepth);        549   Set(name, setLineWidth, requestedDepth);
608 }                                                 550 }
609                                                   551 
610 ////////////// /vis/geometry/set/visibility //    552 ////////////// /vis/geometry/set/visibility ///////////////////////////////////////
611                                                   553 
612 G4VisCommandGeometrySetVisibility::G4VisComman    554 G4VisCommandGeometrySetVisibility::G4VisCommandGeometrySetVisibility()
613 {                                                 555 {
614   G4bool omitable;                                556   G4bool omitable;
615   fpCommand = new G4UIcommand("/vis/geometry/s    557   fpCommand = new G4UIcommand("/vis/geometry/set/visibility", this);
616   fpCommand->SetGuidance("Sets visibility of l    558   fpCommand->SetGuidance("Sets visibility of logical volume(s).");
617   fpCommand->SetGuidance("\"all\" sets all log    559   fpCommand->SetGuidance("\"all\" sets all logical volumes.");
618   fpCommand->SetGuidance                          560   fpCommand->SetGuidance
619     ("Optionally propagates down hierarchy to     561     ("Optionally propagates down hierarchy to given depth.");
620   G4UIparameter* parameter;                       562   G4UIparameter* parameter;
621   parameter = new G4UIparameter ("logical-volu    563   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
622   parameter->SetDefaultValue("all");              564   parameter->SetDefaultValue("all");
623   fpCommand->SetParameter(parameter);             565   fpCommand->SetParameter(parameter);
624   parameter = new G4UIparameter("depth", 'd',     566   parameter = new G4UIparameter("depth", 'd', omitable = true);
625   parameter->SetDefaultValue(0);                  567   parameter->SetDefaultValue(0);
626   parameter->SetGuidance                          568   parameter->SetGuidance
627     ("Depth of propagation (-1 means unlimited    569     ("Depth of propagation (-1 means unlimited depth).");
628   fpCommand->SetParameter(parameter);             570   fpCommand->SetParameter(parameter);
629   parameter = new G4UIparameter("visibility",     571   parameter = new G4UIparameter("visibility", 'b', omitable = true);
630   parameter->SetDefaultValue(true);               572   parameter->SetDefaultValue(true);
631   fpCommand->SetParameter(parameter);             573   fpCommand->SetParameter(parameter);
632 }                                                 574 }
633                                                   575 
634 G4VisCommandGeometrySetVisibility::~G4VisComma    576 G4VisCommandGeometrySetVisibility::~G4VisCommandGeometrySetVisibility()
635 {                                                 577 {
636   delete fpCommand;                               578   delete fpCommand;
637 }                                                 579 }
638                                                   580 
639 G4String G4VisCommandGeometrySetVisibility::Ge    581 G4String G4VisCommandGeometrySetVisibility::GetCurrentValue(G4UIcommand*)
640 {                                                 582 {
641   return "";                                      583   return "";
642 }                                                 584 }
643                                                   585 
644 void G4VisCommandGeometrySetVisibility::SetNew    586 void G4VisCommandGeometrySetVisibility::SetNewValue
645 (G4UIcommand*, G4String newValue)                 587 (G4UIcommand*, G4String newValue)
646 {                                                 588 {
647   G4String name;                                  589   G4String name;
648   G4int requestedDepth;                           590   G4int requestedDepth;
649   G4String visibilityString;                      591   G4String visibilityString;
650   std::istringstream iss(newValue);               592   std::istringstream iss(newValue);
651   iss >> name >> requestedDepth >> visibilityS    593   iss >> name >> requestedDepth >> visibilityString;
652   G4bool visibility = G4UIcommand::ConvertToBo    594   G4bool visibility = G4UIcommand::ConvertToBool(visibilityString);
653                                                   595 
654   G4VisCommandGeometrySetVisibilityFunction se    596   G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
655   Set(name, setVisibility, requestedDepth);       597   Set(name, setVisibility, requestedDepth);
656                                                   598 
657   G4VViewer* pViewer = fpVisManager->GetCurren    599   G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
658   if (pViewer) {                                  600   if (pViewer) {
659     const G4ViewParameters& viewParams = pView    601     const G4ViewParameters& viewParams = pViewer->GetViewParameters();
660     if (fpVisManager->GetVerbosity() >= G4VisM    602     if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
661       if (!viewParams.IsCulling() ||              603       if (!viewParams.IsCulling() ||
662     !viewParams.IsCullingInvisible()) {           604     !viewParams.IsCullingInvisible()) {
663   G4warn <<                                    << 605   G4cout <<
664     "Culling must be on - \"/vis/viewer/set/cu    606     "Culling must be on - \"/vis/viewer/set/culling global true\" and"
665     "\n  \"/vis/viewer/set/culling invisible t    607     "\n  \"/vis/viewer/set/culling invisible true\" - to see effect."
666          << G4endl;                               608          << G4endl;
667       }                                           609       }
668     }                                             610     }
669   }                                               611   }
670 }                                                 612 }
671                                                   613 
672 void G4VisCommandGeometrySetVisibility::SetNew    614 void G4VisCommandGeometrySetVisibility::SetNewValueOnLV
673 (G4LogicalVolume* pLV, G4int requestedDepth,G4    615 (G4LogicalVolume* pLV, G4int requestedDepth,G4bool visibility)
674 {                                                 616 {
675   if (!pLV) return;                               617   if (!pLV) return;
676   G4VisCommandGeometrySetVisibilityFunction se    618   G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
677   SetLVVisAtts(pLV, setVisibility, 0, requeste    619   SetLVVisAtts(pLV, setVisibility, 0, requestedDepth);
678                                                   620 
679   G4VViewer* pViewer = fpVisManager->GetCurren    621   G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
680   if (pViewer) {                                  622   if (pViewer) {
681     G4UImanager::GetUIpointer()->ApplyCommand(    623     G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
682     const G4ViewParameters& viewParams = pView    624     const G4ViewParameters& viewParams = pViewer->GetViewParameters();
683     if (fpVisManager->GetVerbosity() >= G4VisM    625     if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
684       if (!viewParams.IsCulling() ||              626       if (!viewParams.IsCulling() ||
685     !viewParams.IsCullingInvisible()) {           627     !viewParams.IsCullingInvisible()) {
686   G4warn <<                                    << 628   G4cout <<
687     "Culling must be on - \"/vis/viewer/set/cu    629     "Culling must be on - \"/vis/viewer/set/culling global true\" and"
688     "\n  \"/vis/viewer/set/culling invisible t    630     "\n  \"/vis/viewer/set/culling invisible true\" - to see effect."
689          << G4endl;                               631          << G4endl;
690       }                                           632       }
691     }                                             633     }
692   }                                               634   }
693 }                                                 635 }
694                                                   636