| 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 // $Id: G4VisCommandsCompound.cc,v 1.38 2007/03/27 15:41:34 allison Exp $
>> 28 // GEANT4 tag $Name: geant4-08-03-patch-01 $
27 29
28 // Compound /vis/ commands - John Allison 15t 30 // Compound /vis/ commands - John Allison 15th May 2000
29 31
30 #include "G4VisCommandsCompound.hh" 32 #include "G4VisCommandsCompound.hh"
31 33
32 #include "G4VisManager.hh" 34 #include "G4VisManager.hh"
33 #include "G4UImanager.hh" 35 #include "G4UImanager.hh"
34 #include "G4UIcommandTree.hh" <<
35 #include "G4UIcmdWithAString.hh" 36 #include "G4UIcmdWithAString.hh"
36 37
37 #include <sstream> 38 #include <sstream>
38 #include <set> <<
39 <<
40 #define G4warn G4cout <<
41 39
42 ////////////// /vis/drawTree ///////////////// 40 ////////////// /vis/drawTree ///////////////////////////////////////
43 41
44 G4VisCommandDrawTree::G4VisCommandDrawTree() { 42 G4VisCommandDrawTree::G4VisCommandDrawTree() {
45 G4bool omitable; 43 G4bool omitable;
46 fpCommand = new G4UIcommand("/vis/drawTree", 44 fpCommand = new G4UIcommand("/vis/drawTree", this);
47 fpCommand->SetGuidance 45 fpCommand->SetGuidance
48 ("Produces a representation of the geometr << 46 ("(DTREE) Creates a scene consisting of this physical volume and"
49 "\nguidance is given on running the comma << 47 "\n produces a representation of the geometry hieracrhy.");
50 "\nfor \"/vis/ASCIITree/verbose\"."); << 48 fpCommand->SetGuidance("The scene becomes current.");
51 fpCommand->SetGuidance("The pre-existing sce <<
52 G4UIparameter* parameter; 49 G4UIparameter* parameter;
53 parameter = new G4UIparameter("physical-volu 50 parameter = new G4UIparameter("physical-volume-name", 's', omitable = true);
54 parameter -> SetDefaultValue("world"); 51 parameter -> SetDefaultValue("world");
55 fpCommand -> SetParameter (parameter); 52 fpCommand -> SetParameter (parameter);
56 parameter = new G4UIparameter("system", 's', 53 parameter = new G4UIparameter("system", 's', omitable = true);
57 parameter -> SetDefaultValue("ATree"); 54 parameter -> SetDefaultValue("ATree");
58 fpCommand -> SetParameter (parameter); 55 fpCommand -> SetParameter (parameter);
59 } 56 }
60 57
61 G4VisCommandDrawTree::~G4VisCommandDrawTree() 58 G4VisCommandDrawTree::~G4VisCommandDrawTree() {
62 delete fpCommand; 59 delete fpCommand;
63 } 60 }
64 61
65 void G4VisCommandDrawTree::SetNewValue(G4UIcom 62 void G4VisCommandDrawTree::SetNewValue(G4UIcommand*, G4String newValue) {
66 63
67 G4String pvname, system; 64 G4String pvname, system;
68 std::istringstream is(newValue); 65 std::istringstream is(newValue);
69 is >> pvname >> system; 66 is >> pvname >> system;
70 67
71 // Note: The second parameter, "system", is <<
72 // a choice of dedicated tree printing/displ <<
73 // the only such dedicated system is ASCIITr <<
74 // specify OGLSX, for example. So to avoid <<
75 // feature to systems that have "Tree" in th <<
76 <<
77 // Of course, some other systems, such as OG <<
78 // built-in. The HepRApp offline browser al <<
79 // built in. <<
80 <<
81 if (!G4StrUtil::contains(system, "Tree")) { <<
82 system = "ATree"; <<
83 } <<
84 <<
85 G4VGraphicsSystem* keepSystem = fpVisManager <<
86 G4Scene* keepScene = fpVisManager->GetCurren <<
87 G4VSceneHandler* keepSceneHandler = fpVisMan <<
88 G4VViewer* keepViewer = fpVisManager->GetCur <<
89 G4VisManager::Verbosity keepVisVerbosity = f <<
90 G4bool keepAbleness = fpVisManager->GetConcr <<
91 <<
92 G4UImanager* UImanager = G4UImanager::GetUIp 68 G4UImanager* UImanager = G4UImanager::GetUIpointer();
93 G4int keepUIVerbose = UImanager->GetVerboseL << 69 G4int keepVerbose = UImanager->GetVerboseLevel();
94 G4int newVerbose(0); 70 G4int newVerbose(0);
95 if (keepUIVerbose >= 2 || << 71 if (keepVerbose >= 2 ||
96 fpVisManager->GetVerbosity() >= G4VisMan 72 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
97 newVerbose = 2; 73 newVerbose = 2;
98 UImanager->SetVerboseLevel(newVerbose); 74 UImanager->SetVerboseLevel(newVerbose);
99 << 75 UImanager->ApplyCommand(G4String("/vis/open " + system));
100 auto errorCode = UImanager->ApplyCommand(G4S << 76 UImanager->ApplyCommand(G4String("/vis/drawVolume " + pvname));
101 if (errorCode == 0) { << 77 UImanager->ApplyCommand("/vis/viewer/flush");
102 if (!keepAbleness) { // Enable temporaril << 78 UImanager->SetVerboseLevel(keepVerbose);
103 fpVisManager->SetVerboseLevel("Quiet"); <<
104 UImanager->ApplyCommand("/vis/enable"); <<
105 fpVisManager->SetVerboseLevel(keepVisVer <<
106 } <<
107 UImanager->ApplyCommand("/vis/viewer/reset <<
108 UImanager->ApplyCommand(G4String("/vis/dra <<
109 UImanager->ApplyCommand("/vis/viewer/flush <<
110 if (!keepAbleness) { // Disable again <<
111 fpVisManager->SetVerboseLevel("Quiet"); <<
112 UImanager->ApplyCommand("/vis/disable"); <<
113 fpVisManager->SetVerboseLevel(keepVisVer <<
114 } <<
115 if (keepViewer) { <<
116 if (fpVisManager->GetVerbosity() >= G4Vi <<
117 G4warn << "Reverting to " << keepViewe <<
118 } <<
119 fpVisManager->SetCurrentGraphicsSystem(k <<
120 fpVisManager->SetCurrentScene(keepScene) <<
121 fpVisManager->SetCurrentSceneHandler(kee <<
122 fpVisManager->SetCurrentViewer(keepViewe <<
123 } <<
124 } <<
125 UImanager->SetVerboseLevel(keepUIVerbose); <<
126 } 79 }
127 80
128 ////////////// /vis/drawView ///////////////// 81 ////////////// /vis/drawView ///////////////////////////////////////
129 82
130 G4VisCommandDrawView::G4VisCommandDrawView() { 83 G4VisCommandDrawView::G4VisCommandDrawView() {
131 G4bool omitable; 84 G4bool omitable;
132 fpCommand = new G4UIcommand("/vis/drawView", 85 fpCommand = new G4UIcommand("/vis/drawView", this);
133 fpCommand->SetGuidance 86 fpCommand->SetGuidance
134 ("Draw view from this angle, etc."); 87 ("Draw view from this angle, etc.");
135 G4UIparameter* parameter; 88 G4UIparameter* parameter;
136 parameter = new G4UIparameter("theta-degrees 89 parameter = new G4UIparameter("theta-degrees", 'd', omitable = true);
137 parameter -> SetDefaultValue(0.); 90 parameter -> SetDefaultValue(0.);
138 fpCommand -> SetParameter (parameter); 91 fpCommand -> SetParameter (parameter);
139 parameter = new G4UIparameter("phi-degrees", 92 parameter = new G4UIparameter("phi-degrees", 'd', omitable = true);
140 parameter -> SetDefaultValue(0.); 93 parameter -> SetDefaultValue(0.);
141 fpCommand -> SetParameter (parameter); 94 fpCommand -> SetParameter (parameter);
142 parameter = new G4UIparameter("pan-right", ' 95 parameter = new G4UIparameter("pan-right", 'd', omitable = true);
143 parameter -> SetDefaultValue(0.); 96 parameter -> SetDefaultValue(0.);
144 fpCommand -> SetParameter (parameter); 97 fpCommand -> SetParameter (parameter);
145 parameter = new G4UIparameter("pan-up", 'd', 98 parameter = new G4UIparameter("pan-up", 'd', omitable = true);
146 parameter -> SetDefaultValue(0.); 99 parameter -> SetDefaultValue(0.);
147 fpCommand -> SetParameter (parameter); 100 fpCommand -> SetParameter (parameter);
148 parameter = new G4UIparameter("pan-unit", 's 101 parameter = new G4UIparameter("pan-unit", 's', omitable = true);
149 parameter -> SetDefaultValue("cm"); 102 parameter -> SetDefaultValue("cm");
150 fpCommand -> SetParameter (parameter); 103 fpCommand -> SetParameter (parameter);
151 parameter = new G4UIparameter("zoom-factor", 104 parameter = new G4UIparameter("zoom-factor", 'd', omitable = true);
152 parameter -> SetDefaultValue(1.); 105 parameter -> SetDefaultValue(1.);
153 fpCommand -> SetParameter (parameter); 106 fpCommand -> SetParameter (parameter);
154 parameter = new G4UIparameter("dolly", 'd', 107 parameter = new G4UIparameter("dolly", 'd', omitable = true);
155 parameter -> SetDefaultValue(0.); 108 parameter -> SetDefaultValue(0.);
156 fpCommand -> SetParameter (parameter); 109 fpCommand -> SetParameter (parameter);
157 parameter = new G4UIparameter("dolly-unit", 110 parameter = new G4UIparameter("dolly-unit", 's', omitable = true);
158 parameter -> SetDefaultValue("cm"); 111 parameter -> SetDefaultValue("cm");
159 fpCommand -> SetParameter (parameter); 112 fpCommand -> SetParameter (parameter);
160 } 113 }
161 114
162 G4VisCommandDrawView::~G4VisCommandDrawView() 115 G4VisCommandDrawView::~G4VisCommandDrawView() {
163 delete fpCommand; 116 delete fpCommand;
164 } 117 }
165 118
166 void G4VisCommandDrawView::SetNewValue(G4UIcom 119 void G4VisCommandDrawView::SetNewValue(G4UIcommand*, G4String newValue) {
167 120
168 G4VisManager::Verbosity verbosity = fpVisMan 121 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
169 122
170 G4VViewer* currentViewer = fpVisManager->Get 123 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
171 if (!currentViewer) { 124 if (!currentViewer) {
172 if (verbosity >= G4VisManager::warnings) { 125 if (verbosity >= G4VisManager::warnings) {
173 G4warn << << 126 G4cout <<
174 "WARNING: G4VisCommandsDrawView::SetNewValue 127 "WARNING: G4VisCommandsDrawView::SetNewValue: no current viewer."
175 << G4endl; 128 << G4endl;
176 } 129 }
177 return; 130 return;
178 } 131 }
179 132
180 G4String thetaDeg; 133 G4String thetaDeg;
181 G4String phiDeg; 134 G4String phiDeg;
182 G4String panRight; 135 G4String panRight;
183 G4String panUp; 136 G4String panUp;
184 G4String panUnit; 137 G4String panUnit;
185 G4String zoomFactor; 138 G4String zoomFactor;
186 G4String dolly; 139 G4String dolly;
187 G4String dollyUnit; 140 G4String dollyUnit;
188 std::istringstream is(newValue); 141 std::istringstream is(newValue);
189 is >> thetaDeg >> phiDeg >> panRight >> panU 142 is >> thetaDeg >> phiDeg >> panRight >> panUp >> panUnit
190 >> zoomFactor >> dolly >> dollyUnit; 143 >> zoomFactor >> dolly >> dollyUnit;
191 144
192 G4UImanager* UImanager = G4UImanager::GetUIp 145 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 146 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 147 G4int newVerbose(0);
>> 148 if (keepVerbose >= 2 ||
>> 149 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
>> 150 newVerbose = 2;
>> 151 UImanager->SetVerboseLevel(newVerbose);
193 G4ViewParameters vp = currentViewer->GetView 152 G4ViewParameters vp = currentViewer->GetViewParameters();
194 G4bool keepAutoRefresh = vp.IsAutoRefresh(); 153 G4bool keepAutoRefresh = vp.IsAutoRefresh();
195 vp.SetAutoRefresh(false); 154 vp.SetAutoRefresh(false);
196 currentViewer->SetViewParameters(vp); 155 currentViewer->SetViewParameters(vp);
197 UImanager->ApplyCommand( 156 UImanager->ApplyCommand(
198 G4String("/vis/viewer/set/viewpointThetaPh 157 G4String("/vis/viewer/set/viewpointThetaPhi " + thetaDeg + " " + phiDeg + " deg"));
199 UImanager->ApplyCommand( 158 UImanager->ApplyCommand(
200 G4String("/vis/viewer/panTo " + panRight + 159 G4String("/vis/viewer/panTo " + panRight + " " + panUp + " " + panUnit));
201 UImanager->ApplyCommand( 160 UImanager->ApplyCommand(
202 G4String("/vis/viewer/zoomTo " + zoomFacto 161 G4String("/vis/viewer/zoomTo " + zoomFactor));
203 vp = currentViewer->GetViewParameters(); 162 vp = currentViewer->GetViewParameters();
204 vp.SetAutoRefresh(keepAutoRefresh); 163 vp.SetAutoRefresh(keepAutoRefresh);
205 currentViewer->SetViewParameters(vp); 164 currentViewer->SetViewParameters(vp);
206 UImanager->ApplyCommand( 165 UImanager->ApplyCommand(
207 G4String("/vis/viewer/dollyTo " + dolly + 166 G4String("/vis/viewer/dollyTo " + dolly + " " + dollyUnit));
208 } << 167 UImanager->SetVerboseLevel(keepVerbose);
209 <<
210 ////////////// /vis/drawLogicalVolume //////// <<
211 <<
212 G4VisCommandDrawLogicalVolume::G4VisCommandDra <<
213 fpCommand = new G4UIcommand("/vis/drawLogica <<
214 fpCommand->SetGuidance <<
215 ("Draws logical volume with additional compo <<
216 fpCommand->SetGuidance <<
217 ("Synonymous with \"/vis/specify\"."); <<
218 fpCommand->SetGuidance <<
219 ("Creates a scene consisting of this logical <<
220 "\n current viewer to draw it. The scene b <<
221 const G4UIcommandTree* tree = G4UImanager::G <<
222 const G4UIcommand* addLogVolCmd = tree->Find <<
223 // Pick up guidance from /vis/scene/add/logi <<
224 CopyGuidanceFrom(addLogVolCmd,fpCommand); <<
225 // Pick up parameters from /vis/scene/add/lo <<
226 CopyParametersFrom(addLogVolCmd,fpCommand); <<
227 } <<
228 <<
229 G4VisCommandDrawLogicalVolume::~G4VisCommandDr <<
230 delete fpCommand; <<
231 } <<
232 <<
233 void G4VisCommandDrawLogicalVolume::SetNewValu <<
234 G4VisManager::Verbosity verbosity = fpVisMan <<
235 G4UImanager* UImanager = G4UImanager::GetUIp <<
236 G4VViewer* currentViewer = fpVisManager->Get <<
237 const G4ViewParameters& currentViewParams = <<
238 G4bool keepAutoRefresh = currentViewParams.I <<
239 if (keepAutoRefresh) UImanager->ApplyCommand <<
240 UImanager->ApplyCommand("/vis/scene/create") <<
241 UImanager->ApplyCommand(G4String("/vis/scene <<
242 UImanager->ApplyCommand("/vis/sceneHandler/a <<
243 G4ViewParameters::DrawingStyle keepDrawingSt <<
244 if(keepDrawingStyle != G4ViewParameters::wir <<
245 UImanager->ApplyCommand("/vis/viewer/set/s <<
246 G4bool keepMarkerNotHidden = currentViewPara <<
247 if (!keepMarkerNotHidden) UImanager->ApplyCo <<
248 if (keepAutoRefresh) UImanager->ApplyCommand <<
249 if (verbosity >= G4VisManager::warnings) { <<
250 if (keepDrawingStyle != currentViewParams. <<
251 G4warn <<
252 << "Drawing style changed to wireframe. <<
253 G4String style, edge; <<
254 switch (keepDrawingStyle) { <<
255 case G4ViewParameters::wireframe: <<
256 style = "wireframe"; edge = "false"; <<
257 case G4ViewParameters::hlr: <<
258 style = "wireframe"; edge = "true"; <<
259 case G4ViewParameters::hsr: <<
260 style = "surface"; edge = "false"; b <<
261 case G4ViewParameters::hlhsr: <<
262 style = "surface"; edge = "true"; br <<
263 case G4ViewParameters::cloud: <<
264 style = "cloud"; edge = ""; break; <<
265 } <<
266 G4warn << "\n /vis/viewer/set/style " + <<
267 if (!edge.empty()) G4warn << "\n /vis/v <<
268 G4warn << G4endl; <<
269 } <<
270 if (keepMarkerNotHidden != currentViewPara <<
271 G4warn <<
272 << "Markers changed to \"not hidden\". T <<
273 << "\n /vis/viewer/set/hiddenmarker tru <<
274 << G4endl; <<
275 } <<
276 } <<
277 static G4bool warned = false; <<
278 if (verbosity >= G4VisManager::confirmations <<
279 G4cout << <<
280 "NOTE: For systems which are not \"auto-re <<
281 "\n issue \"/vis/viewer/refresh\" or \"/v <<
282 << G4endl; <<
283 warned = true; <<
284 } <<
285 } 168 }
286 169
287 ////////////// /vis/drawVolume /////////////// 170 ////////////// /vis/drawVolume ///////////////////////////////////////
288 171
289 G4VisCommandDrawVolume::G4VisCommandDrawVolume 172 G4VisCommandDrawVolume::G4VisCommandDrawVolume() {
290 fpCommand = new G4UIcommand("/vis/drawVolume << 173 G4bool omitable;
>> 174 fpCommand = new G4UIcmdWithAString("/vis/drawVolume", this);
291 fpCommand->SetGuidance 175 fpCommand->SetGuidance
292 ("Creates a scene containing this physical v << 176 ("Creates a scene containing this physical volume and asks the"
293 "\ncurrent viewer to draw it. The scene be << 177 "\ncurrent viewer to draw it. The scene becomes current.");
294 const G4UIcommandTree* tree = G4UImanager::G << 178 fpCommand -> SetGuidance
295 const G4UIcommand* addVolCmd = tree->FindPat << 179 ("If physical-volume-name is \"world\" (the default), the main geometry"
296 // Pick up guidance from /vis/scene/add/volu << 180 "\ntree (material world) is drawn. If \"worlds\", all worlds - material"
297 CopyGuidanceFrom(addVolCmd,fpCommand); << 181 "\nworld and parallel worlds, if any - are drawn. Otherwise a search of"
298 // Pick up parameters from /vis/scene/add/vo << 182 "\nall worlds is made, taking the first matching occurence only. To see"
299 CopyParametersFrom(addVolCmd,fpCommand); << 183 "\na representation of the geometry hierarchy of the worlds, try"
>> 184 "\n\"/vis/drawTree [worlds]\" or one of the driver/browser combinations"
>> 185 "\nthat have the required functionality, e.g., HepRepFile/XML with the"
>> 186 "\nWIRED3/4 browser.");
>> 187 fpCommand->SetParameterName("physical-volume-name", omitable = true);
>> 188 fpCommand->SetDefaultValue("world");
300 } 189 }
301 190
302 G4VisCommandDrawVolume::~G4VisCommandDrawVolum 191 G4VisCommandDrawVolume::~G4VisCommandDrawVolume() {
303 delete fpCommand; 192 delete fpCommand;
304 } 193 }
305 194
306 void G4VisCommandDrawVolume::SetNewValue(G4UIc 195 void G4VisCommandDrawVolume::SetNewValue(G4UIcommand*, G4String newValue) {
307 G4VisManager::Verbosity verbosity = fpVisMan 196 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
308 G4UImanager* UImanager = G4UImanager::GetUIp 197 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 198 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 199 G4int newVerbose(0);
>> 200 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
>> 201 newVerbose = 2;
>> 202 UImanager->SetVerboseLevel(newVerbose);
309 UImanager->ApplyCommand("/vis/scene/create") 203 UImanager->ApplyCommand("/vis/scene/create");
310 UImanager->ApplyCommand(G4String("/vis/scene 204 UImanager->ApplyCommand(G4String("/vis/scene/add/volume " + newValue));
311 UImanager->ApplyCommand("/vis/sceneHandler/a 205 UImanager->ApplyCommand("/vis/sceneHandler/attach");
>> 206 UImanager->SetVerboseLevel(keepVerbose);
312 static G4bool warned = false; 207 static G4bool warned = false;
313 if (verbosity >= G4VisManager::confirmations 208 if (verbosity >= G4VisManager::confirmations && !warned) {
314 G4cout << 209 G4cout <<
315 "NOTE: For systems which are not \"auto- 210 "NOTE: For systems which are not \"auto-refresh\" you will need to"
316 "\n issue \"/vis/viewer/refresh\" or \" 211 "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
317 << G4endl; 212 << G4endl;
318 warned = true; 213 warned = true;
319 } 214 }
320 } 215 }
321 216
322 ////////////// /vis/open ///////////////////// 217 ////////////// /vis/open ///////////////////////////////////////
323 218
324 G4VisCommandOpen::G4VisCommandOpen() { 219 G4VisCommandOpen::G4VisCommandOpen() {
325 G4bool omitable; 220 G4bool omitable;
326 fpCommand = new G4UIcommand("/vis/open", thi 221 fpCommand = new G4UIcommand("/vis/open", this);
327 fpCommand->SetGuidance 222 fpCommand->SetGuidance
328 ("Creates a scene handler and viewer ready << 223 ("Creates a scene handler ready for drawing.");
329 fpCommand->SetGuidance 224 fpCommand->SetGuidance
330 ("The scene handler and viewer names are a << 225 ("The scene handler becomes current (the name is auto-generated).");
331 // Pick up guidance from /vis/viewer/create <<
332 const G4UIcommandTree* tree = G4UImanager::G <<
333 const G4UIcommand* viewerCreateCmd = tree->F <<
334 CopyGuidanceFrom(viewerCreateCmd,fpCommand,2 <<
335 G4UIparameter* parameter; 226 G4UIparameter* parameter;
336 parameter = new G4UIparameter("graphics-syst << 227 parameter = new G4UIparameter("graphics-system-name", 's', omitable = false);
337 parameter->SetCurrentAsDefault(true); << 228 const G4GraphicsSystemList& gslist =
>> 229 fpVisManager->GetAvailableGraphicsSystems();
>> 230 G4String candidates;
>> 231 for (size_t igslist = 0; igslist < gslist.size(); igslist++) {
>> 232 const G4String& name = gslist[igslist]->GetName();
>> 233 const G4String& nickname = gslist[igslist]->GetNickname();
>> 234 if (nickname.isNull()) {
>> 235 candidates += name;
>> 236 }
>> 237 else {
>> 238 candidates += nickname;
>> 239 }
>> 240 candidates += " ";
>> 241 }
>> 242 candidates = candidates.strip();
>> 243 parameter->SetParameterCandidates(candidates);
338 fpCommand->SetParameter(parameter); 244 fpCommand->SetParameter(parameter);
339 parameter = new G4UIparameter("window-size-h 245 parameter = new G4UIparameter("window-size-hint", 's', omitable = true);
340 parameter->SetGuidance 246 parameter->SetGuidance
341 ("integer (pixels) for square window place 247 ("integer (pixels) for square window placed by window manager or"
342 " X-Windows-type geometry string, e.g. 60 248 " X-Windows-type geometry string, e.g. 600x600-100+100");
343 parameter->SetCurrentAsDefault(true); << 249 parameter->SetDefaultValue("600");
344 fpCommand->SetParameter(parameter); 250 fpCommand->SetParameter(parameter);
345 } 251 }
346 252
347 G4VisCommandOpen::~G4VisCommandOpen() { 253 G4VisCommandOpen::~G4VisCommandOpen() {
348 delete fpCommand; 254 delete fpCommand;
349 } 255 }
350 256
351 G4String G4VisCommandOpen::GetCurrentValue(G4U << 257 void G4VisCommandOpen::SetNewValue (G4UIcommand*, G4String newValue) {
352 { <<
353 G4String graphicsSystemName, windowSizeHint; <<
354 auto graphicsSystem = fpVisManager->GetCurre <<
355 if (graphicsSystem) { <<
356 // Take name and hint from latest graphics <<
357 graphicsSystemName = graphicsSystem->GetNa <<
358 auto viewer = fpVisManager->GetCurrentView <<
359 if (viewer) { <<
360 windowSizeHint = viewer->GetViewParamete <<
361 } <<
362 else { // Viewer not yet created? <<
363 windowSizeHint = fpVisManager->GetDefaul <<
364 } <<
365 } <<
366 else { // No graphics system yet - must be <<
367 graphicsSystemName = fpVisManager->GetDefa <<
368 windowSizeHint = fpVisManager->GetDefaultX <<
369 } <<
370 return graphicsSystemName + ' ' + windowSize <<
371 } <<
372 <<
373 void G4VisCommandOpen::SetNewValue (G4UIcomman <<
374 { <<
375 G4String systemName, windowSizeHint; 258 G4String systemName, windowSizeHint;
376 std::istringstream is(newValue); 259 std::istringstream is(newValue);
377 is >> systemName >> windowSizeHint; 260 is >> systemName >> windowSizeHint;
378 G4UImanager* UImanager = G4UImanager::GetUIp 261 G4UImanager* UImanager = G4UImanager::GetUIpointer();
379 << 262 G4int keepVerbose = UImanager->GetVerboseLevel();
380 auto errorCode = UImanager->ApplyCommand(G4S << 263 G4int newVerbose(0);
381 if (errorCode) { << 264 if (keepVerbose >= 2 ||
382 G4warn << "sub-command \"/vis/sceneHandler << 265 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
383 goto finish; << 266 newVerbose = 2;
384 } << 267 UImanager->SetVerboseLevel(newVerbose);
385 << 268 UImanager->ApplyCommand(G4String("/vis/sceneHandler/create " + systemName));
386 errorCode = UImanager->ApplyCommand(G4String << 269 UImanager->ApplyCommand(G4String("/vis/viewer/create ! ! " + windowSizeHint));
387 if (errorCode) { << 270 UImanager->SetVerboseLevel(keepVerbose);
388 G4warn << "sub-command \"/vis/viewer/creat <<
389 goto finish; <<
390 } <<
391 <<
392 finish: <<
393 if (errorCode) { <<
394 fpVisManager->PrintAvailableGraphicsSystem <<
395 if (errorCode != JustWarning) { <<
396 G4ExceptionDescription ed; <<
397 ed << "Invoked command has failed - see <<
398 command->CommandFailed(errorCode,ed); <<
399 } <<
400 } <<
401 } <<
402 <<
403 ////////////// /vis/plot ///////////////////// <<
404 <<
405 G4VisCommandPlot::G4VisCommandPlot () <<
406 { <<
407 G4bool omitable; <<
408 G4UIparameter* parameter; <<
409 <<
410 fpCommand = new G4UIcommand("/vis/plot", thi <<
411 fpCommand -> SetGuidance("Draws plots."); <<
412 parameter = new G4UIparameter ("type", 's', <<
413 parameter -> SetParameterCandidates("h1 h2") <<
414 fpCommand -> SetParameter (parameter); <<
415 parameter = new G4UIparameter ("id", 'i', om <<
416 fpCommand -> SetParameter (parameter); <<
417 #ifdef TOOLS_USE_FREETYPE <<
418 parameter = new G4UIparameter ("style", 's', <<
419 parameter -> SetParameterCandidates("none RO <<
420 parameter -> SetDefaultValue("ROOT_default") <<
421 fpCommand -> SetParameter (parameter); <<
422 #endif <<
423 } <<
424 <<
425 G4VisCommandPlot::~G4VisCommandPlot () <<
426 { <<
427 delete fpCommand; <<
428 } <<
429 <<
430 G4String G4VisCommandPlot::GetCurrentValue (G4 <<
431 { <<
432 return ""; <<
433 } <<
434 <<
435 void G4VisCommandPlot::SetNewValue (G4UIcomman <<
436 { <<
437 auto currentViewer = fpVisManager->GetCurren <<
438 if (currentViewer->GetName().find("TOOLSSG") <<
439 G4warn << <<
440 "WARNING: Current viewer not able to draw <<
441 "\n Try \"/vis/open TSG\", then \"/vis/pl <<
442 << G4endl; <<
443 return; <<
444 } <<
445 <<
446 std::istringstream is (newValue); <<
447 G4String type, id; <<
448 is >> type >> id; <<
449 #ifdef TOOLS_USE_FREETYPE <<
450 G4String style; <<
451 is >> style; <<
452 #endif <<
453 <<
454 auto keepEnable = fpVisManager->IsEnabled(); <<
455 <<
456 auto ui = G4UImanager::GetUIpointer(); <<
457 ui->ApplyCommand("/vis/enable"); <<
458 ui->ApplyCommand("/vis/viewer/resetCameraPar <<
459 ui->ApplyCommand("/vis/scene/create"); <<
460 ui->ApplyCommand("/vis/scene/endOfEventActio <<
461 static G4int plotterID = 0; <<
462 std::ostringstream ossPlotter; <<
463 ossPlotter << "plotter-" << plotterID++; <<
464 const G4String& plotterName = ossPlotter.str <<
465 ui->ApplyCommand("/vis/plotter/create " + pl <<
466 ui->ApplyCommand("/vis/scene/add/plotter " + <<
467 ui->ApplyCommand("/vis/plotter/add/" + type <<
468 #ifdef TOOLS_USE_FREETYPE <<
469 if (style != "none") { <<
470 ui->ApplyCommand("/vis/plotter/addStyle " <<
471 } <<
472 #endif <<
473 ui->ApplyCommand("/vis/sceneHandler/attach") <<
474 <<
475 if (!keepEnable) { <<
476 fpVisManager->Disable(); <<
477 G4warn << <<
478 "WARNING: drawing was enabled for plotting <<
479 << G4endl; <<
480 } <<
481 } 271 }
482 272
483 ////////////// /vis/specify ////////////////// 273 ////////////// /vis/specify ///////////////////////////////////////
484 274
485 G4VisCommandSpecify::G4VisCommandSpecify() { 275 G4VisCommandSpecify::G4VisCommandSpecify() {
486 G4bool omitable; 276 G4bool omitable;
487 fpCommand = new G4UIcommand("/vis/specify", 277 fpCommand = new G4UIcommand("/vis/specify", this);
488 fpCommand->SetGuidance 278 fpCommand->SetGuidance
489 ("Draws logical volume with Boolean compon 279 ("Draws logical volume with Boolean components, voxels and readout geometry.");
490 fpCommand->SetGuidance 280 fpCommand->SetGuidance
491 ("Synonymous with \"/vis/drawLogicalVolume <<
492 fpCommand->SetGuidance <<
493 ("Creates a scene consisting of this logic 281 ("Creates a scene consisting of this logical volume and asks the"
494 "\n current viewer to draw it to the spe 282 "\n current viewer to draw it to the specified depth of descent"
495 "\n showing boolean components (if any), << 283 "\n showing boolean components (if any), voxels (if any)"
496 "\n readout geometry (if any), local axe << 284 "\n and readout geometry (if any), under control of the appropriate flag.");
497 "\n under control of the appropriate fla <<
498 fpCommand->SetGuidance 285 fpCommand->SetGuidance
499 ("Note: voxels are not constructed until sta << 286 ("Note: voxels are not constructed until start of run - /run/beamOn.");
500 "\n (For voxels without a run, \"/run/beam <<
501 fpCommand->SetGuidance("The scene becomes cu 287 fpCommand->SetGuidance("The scene becomes current.");
502 G4UIparameter* parameter; 288 G4UIparameter* parameter;
503 parameter = new G4UIparameter("logical-volum 289 parameter = new G4UIparameter("logical-volume-name", 's', omitable = false);
504 fpCommand->SetParameter(parameter); 290 fpCommand->SetParameter(parameter);
505 parameter = new G4UIparameter("depth-of-desc 291 parameter = new G4UIparameter("depth-of-descent", 'i', omitable = true);
506 parameter->SetDefaultValue(1); 292 parameter->SetDefaultValue(1);
507 fpCommand->SetParameter(parameter); 293 fpCommand->SetParameter(parameter);
508 parameter = new G4UIparameter("booleans-flag 294 parameter = new G4UIparameter("booleans-flag", 'b', omitable = true);
509 parameter->SetDefaultValue(true); 295 parameter->SetDefaultValue(true);
510 fpCommand->SetParameter(parameter); 296 fpCommand->SetParameter(parameter);
511 parameter = new G4UIparameter("voxels-flag", 297 parameter = new G4UIparameter("voxels-flag", 'b', omitable = true);
512 parameter->SetDefaultValue(true); 298 parameter->SetDefaultValue(true);
513 fpCommand->SetParameter(parameter); 299 fpCommand->SetParameter(parameter);
514 parameter = new G4UIparameter("readout-flag" 300 parameter = new G4UIparameter("readout-flag", 'b', omitable = true);
515 parameter->SetDefaultValue(true); 301 parameter->SetDefaultValue(true);
516 fpCommand->SetParameter(parameter); 302 fpCommand->SetParameter(parameter);
517 parameter = new G4UIparameter("axes-flag", ' <<
518 parameter->SetDefaultValue(true); <<
519 parameter -> SetGuidance ("Set \"false\" to <<
520 fpCommand->SetParameter(parameter); <<
521 parameter = new G4UIparameter("check-overlap <<
522 parameter->SetDefaultValue(true); <<
523 parameter -> SetGuidance ("Set \"false\" to <<
524 fpCommand->SetParameter(parameter); <<
525 } 303 }
526 304
527 G4VisCommandSpecify::~G4VisCommandSpecify() { 305 G4VisCommandSpecify::~G4VisCommandSpecify() {
528 delete fpCommand; 306 delete fpCommand;
529 } 307 }
530 308
531 void G4VisCommandSpecify::SetNewValue(G4UIcomm 309 void G4VisCommandSpecify::SetNewValue(G4UIcommand*, G4String newValue) {
532 G4VisManager::Verbosity verbosity = fpVisMan 310 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
533 G4UImanager* UImanager = G4UImanager::GetUIp 311 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 312 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 313 G4int newVerbose(0);
>> 314 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
>> 315 newVerbose = 2;
>> 316 UImanager->SetVerboseLevel(newVerbose);
534 // UImanager->ApplyCommand(G4String("/geomet 317 // UImanager->ApplyCommand(G4String("/geometry/print " + newValue));
535 UImanager->ApplyCommand("/vis/scene/create") 318 UImanager->ApplyCommand("/vis/scene/create");
536 UImanager->ApplyCommand(G4String("/vis/scene 319 UImanager->ApplyCommand(G4String("/vis/scene/add/logicalVolume " + newValue));
537 UImanager->ApplyCommand("/vis/sceneHandler/a 320 UImanager->ApplyCommand("/vis/sceneHandler/attach");
>> 321 UImanager->SetVerboseLevel(keepVerbose);
538 static G4bool warned = false; 322 static G4bool warned = false;
539 if (verbosity >= G4VisManager::confirmations 323 if (verbosity >= G4VisManager::confirmations && !warned) {
540 G4cout << 324 G4cout <<
541 "NOTE: For systems which are not \"auto- 325 "NOTE: For systems which are not \"auto-refresh\" you will need to"
542 "\n issue \"/vis/viewer/refresh\" or \" 326 "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
543 << G4endl; 327 << G4endl;
544 warned = true; 328 warned = true;
545 } 329 }
546 } 330 }
547 331