| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
>> 24 // $Id: G4VisCommandsCompound.cc,v 1.25 2003/06/16 17:14:21 gunter Exp $
>> 25 // GEANT4 tag $Name: geant4-05-02-patch-01 $
27 26
28 // Compound /vis/ commands - John Allison 15t 27 // Compound /vis/ commands - John Allison 15th May 2000
29 28
30 #include "G4VisCommandsCompound.hh" 29 #include "G4VisCommandsCompound.hh"
31 30
32 #include "G4VisManager.hh" 31 #include "G4VisManager.hh"
33 #include "G4UImanager.hh" 32 #include "G4UImanager.hh"
34 #include "G4UIcommandTree.hh" <<
35 #include "G4UIcmdWithAString.hh" 33 #include "G4UIcmdWithAString.hh"
36 34
37 #include <sstream> <<
38 #include <set> <<
39 <<
40 #define G4warn G4cout <<
41 <<
42 ////////////// /vis/drawTree ///////////////// 35 ////////////// /vis/drawTree ///////////////////////////////////////
43 36
44 G4VisCommandDrawTree::G4VisCommandDrawTree() { 37 G4VisCommandDrawTree::G4VisCommandDrawTree() {
45 G4bool omitable; 38 G4bool omitable;
46 fpCommand = new G4UIcommand("/vis/drawTree", 39 fpCommand = new G4UIcommand("/vis/drawTree", this);
>> 40 fpCommand->SetGuidance("/vis/drawTree [<physical-volume-name>] [<system>]");
>> 41 fpCommand->SetGuidance("Default: world ATree");
47 fpCommand->SetGuidance 42 fpCommand->SetGuidance
48 ("Produces a representation of the geometr << 43 ("(DTREE) Creates a scene consisting of this physical volume and"
49 "\nguidance is given on running the comma << 44 "\n produces a represntation of the geometry hieracrhy.");
50 "\nfor \"/vis/ASCIITree/verbose\"."); << 45 fpCommand->SetGuidance("The scene becomes current.");
51 fpCommand->SetGuidance("The pre-existing sce <<
52 G4UIparameter* parameter; 46 G4UIparameter* parameter;
53 parameter = new G4UIparameter("physical-volu << 47 parameter = new G4UIparameter("PVname", 's', omitable = true);
54 parameter -> SetDefaultValue("world"); 48 parameter -> SetDefaultValue("world");
55 fpCommand -> SetParameter (parameter); 49 fpCommand -> SetParameter (parameter);
56 parameter = new G4UIparameter("system", 's', 50 parameter = new G4UIparameter("system", 's', omitable = true);
57 parameter -> SetDefaultValue("ATree"); 51 parameter -> SetDefaultValue("ATree");
58 fpCommand -> SetParameter (parameter); 52 fpCommand -> SetParameter (parameter);
59 } 53 }
60 54
61 G4VisCommandDrawTree::~G4VisCommandDrawTree() 55 G4VisCommandDrawTree::~G4VisCommandDrawTree() {
62 delete fpCommand; 56 delete fpCommand;
63 } 57 }
64 58
65 void G4VisCommandDrawTree::SetNewValue(G4UIcom 59 void G4VisCommandDrawTree::SetNewValue(G4UIcommand*, G4String newValue) {
66 60
67 G4String pvname, system; 61 G4String pvname, system;
68 std::istringstream is(newValue); << 62 const char* t = newValue;
>> 63 std::istrstream is((char*)t);
69 is >> pvname >> system; 64 is >> pvname >> system;
70 65
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 66 G4UImanager* UImanager = G4UImanager::GetUIpointer();
93 G4int keepUIVerbose = UImanager->GetVerboseL << 67 G4int keepVerbose = UImanager->GetVerboseLevel();
94 G4int newVerbose(0); 68 G4int newVerbose(0);
95 if (keepUIVerbose >= 2 || << 69 if (keepVerbose >= 2 ||
96 fpVisManager->GetVerbosity() >= G4VisMan 70 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
97 newVerbose = 2; 71 newVerbose = 2;
98 UImanager->SetVerboseLevel(newVerbose); 72 UImanager->SetVerboseLevel(newVerbose);
99 << 73 UImanager->ApplyCommand(G4String("/vis/open " + system));
100 auto errorCode = UImanager->ApplyCommand(G4S << 74 UImanager->ApplyCommand(G4String("/vis/drawVolume " + pvname));
101 if (errorCode == 0) { << 75 UImanager->ApplyCommand("/vis/viewer/flush");
102 if (!keepAbleness) { // Enable temporaril << 76 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 } 77 }
127 78
128 ////////////// /vis/drawView ///////////////// 79 ////////////// /vis/drawView ///////////////////////////////////////
129 80
130 G4VisCommandDrawView::G4VisCommandDrawView() { 81 G4VisCommandDrawView::G4VisCommandDrawView() {
131 G4bool omitable; 82 G4bool omitable;
132 fpCommand = new G4UIcommand("/vis/drawView", 83 fpCommand = new G4UIcommand("/vis/drawView", this);
133 fpCommand->SetGuidance 84 fpCommand->SetGuidance
134 ("Draw view from this angle, etc."); << 85 ("/vis/drawView [<theta-deg>] [<phi-deg>] [<pan-right>] [<pan-up>]"
>> 86 " [<pan-unit>] [<zoom-factor>] [<dolly>] [<dolly-unit>]");
>> 87 fpCommand->SetGuidance("Default: 0 0 0 0 cm 1 0 cm");
135 G4UIparameter* parameter; 88 G4UIparameter* parameter;
136 parameter = new G4UIparameter("theta-degrees << 89 parameter = new G4UIparameter("theta-deg", '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-deg", '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 const char* t = newValue;
>> 142 std::istrstream is((char*)t);
189 is >> thetaDeg >> phiDeg >> panRight >> panU 143 is >> thetaDeg >> phiDeg >> panRight >> panUp >> panUnit
190 >> zoomFactor >> dolly >> dollyUnit; 144 >> zoomFactor >> dolly >> dollyUnit;
191 145
192 G4UImanager* UImanager = G4UImanager::GetUIp 146 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 147 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 148 G4int newVerbose(0);
>> 149 if (keepVerbose >= 2 ||
>> 150 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
>> 151 newVerbose = 2;
>> 152 UImanager->SetVerboseLevel(newVerbose);
193 G4ViewParameters vp = currentViewer->GetView 153 G4ViewParameters vp = currentViewer->GetViewParameters();
194 G4bool keepAutoRefresh = vp.IsAutoRefresh(); 154 G4bool keepAutoRefresh = vp.IsAutoRefresh();
195 vp.SetAutoRefresh(false); 155 vp.SetAutoRefresh(false);
196 currentViewer->SetViewParameters(vp); 156 currentViewer->SetViewParameters(vp);
197 UImanager->ApplyCommand( 157 UImanager->ApplyCommand(
198 G4String("/vis/viewer/set/viewpointThetaPh << 158 G4String("/vis/viewer/viewpointThetaPhi " + thetaDeg + " " + phiDeg + " deg"));
199 UImanager->ApplyCommand( 159 UImanager->ApplyCommand(
200 G4String("/vis/viewer/panTo " + panRight + 160 G4String("/vis/viewer/panTo " + panRight + " " + panUp + " " + panUnit));
201 UImanager->ApplyCommand( 161 UImanager->ApplyCommand(
202 G4String("/vis/viewer/zoomTo " + zoomFacto 162 G4String("/vis/viewer/zoomTo " + zoomFactor));
203 vp = currentViewer->GetViewParameters(); 163 vp = currentViewer->GetViewParameters();
204 vp.SetAutoRefresh(keepAutoRefresh); 164 vp.SetAutoRefresh(keepAutoRefresh);
205 currentViewer->SetViewParameters(vp); 165 currentViewer->SetViewParameters(vp);
206 UImanager->ApplyCommand( 166 UImanager->ApplyCommand(
207 G4String("/vis/viewer/dollyTo " + dolly + 167 G4String("/vis/viewer/dollyTo " + dolly + " " + dollyUnit));
208 } << 168 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 } 169 }
286 170
287 ////////////// /vis/drawVolume /////////////// 171 ////////////// /vis/drawVolume ///////////////////////////////////////
288 172
289 G4VisCommandDrawVolume::G4VisCommandDrawVolume 173 G4VisCommandDrawVolume::G4VisCommandDrawVolume() {
290 fpCommand = new G4UIcommand("/vis/drawVolume << 174 G4bool omitable;
>> 175 fpCommand = new G4UIcmdWithAString("/vis/drawVolume", this);
>> 176 fpCommand->SetGuidance("/vis/drawVolume [<physical-volume-name>]");
>> 177 fpCommand->SetGuidance("Default: world volume");
291 fpCommand->SetGuidance 178 fpCommand->SetGuidance
292 ("Creates a scene containing this physical v << 179 ("Creates a scene consisting of this physical volume and asks the"
293 "\ncurrent viewer to draw it. The scene be << 180 "\n current viewer to draw it.");
294 const G4UIcommandTree* tree = G4UImanager::G << 181 fpCommand->SetGuidance("The scene becomes current.");
295 const G4UIcommand* addVolCmd = tree->FindPat << 182 fpCommand->SetParameterName("physical-volume-name", omitable = true);
296 // Pick up guidance from /vis/scene/add/volu << 183 fpCommand->SetDefaultValue("world");
297 CopyGuidanceFrom(addVolCmd,fpCommand); <<
298 // Pick up parameters from /vis/scene/add/vo <<
299 CopyParametersFrom(addVolCmd,fpCommand); <<
300 } 184 }
301 185
302 G4VisCommandDrawVolume::~G4VisCommandDrawVolum 186 G4VisCommandDrawVolume::~G4VisCommandDrawVolume() {
303 delete fpCommand; 187 delete fpCommand;
304 } 188 }
305 189
306 void G4VisCommandDrawVolume::SetNewValue(G4UIc 190 void G4VisCommandDrawVolume::SetNewValue(G4UIcommand*, G4String newValue) {
307 G4VisManager::Verbosity verbosity = fpVisMan 191 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
308 G4UImanager* UImanager = G4UImanager::GetUIp 192 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 193 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 194 G4int newVerbose(0);
>> 195 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
>> 196 newVerbose = 2;
>> 197 UImanager->SetVerboseLevel(newVerbose);
309 UImanager->ApplyCommand("/vis/scene/create") 198 UImanager->ApplyCommand("/vis/scene/create");
310 UImanager->ApplyCommand(G4String("/vis/scene 199 UImanager->ApplyCommand(G4String("/vis/scene/add/volume " + newValue));
311 UImanager->ApplyCommand("/vis/sceneHandler/a 200 UImanager->ApplyCommand("/vis/sceneHandler/attach");
312 static G4bool warned = false; << 201 UImanager->SetVerboseLevel(keepVerbose);
313 if (verbosity >= G4VisManager::confirmations << 202 if (verbosity >= G4VisManager::warnings) {
314 G4cout << 203 G4cout <<
315 "NOTE: For systems which are not \"auto- << 204 "WARNING: For systems which are not \"auto-refresh\" you will need to"
316 "\n issue \"/vis/viewer/refresh\" or \" 205 "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
317 << G4endl; 206 << G4endl;
318 warned = true; <<
319 } 207 }
320 } 208 }
321 209
322 ////////////// /vis/open ///////////////////// 210 ////////////// /vis/open ///////////////////////////////////////
323 211
324 G4VisCommandOpen::G4VisCommandOpen() { 212 G4VisCommandOpen::G4VisCommandOpen() {
325 G4bool omitable; 213 G4bool omitable;
326 fpCommand = new G4UIcommand("/vis/open", thi 214 fpCommand = new G4UIcommand("/vis/open", this);
>> 215 fpCommand->SetGuidance("/vis/open [<graphics-system-name>] [<pixels>]");
327 fpCommand->SetGuidance 216 fpCommand->SetGuidance
328 ("Creates a scene handler and viewer ready << 217 ("For this graphics system, creates a scene handler ready for drawing.");
329 fpCommand->SetGuidance << 218 fpCommand->SetGuidance("The scene handler becomes current.");
330 ("The scene handler and viewer names are a << 219 fpCommand->SetGuidance("The scene handler name is auto-generated.");
331 // Pick up guidance from /vis/viewer/create << 220 fpCommand->SetGuidance("The 2nd parameter is the window size hint.");
332 const G4UIcommandTree* tree = G4UImanager::G <<
333 const G4UIcommand* viewerCreateCmd = tree->F <<
334 CopyGuidanceFrom(viewerCreateCmd,fpCommand,2 <<
335 G4UIparameter* parameter; 221 G4UIparameter* parameter;
336 parameter = new G4UIparameter("graphics-syst << 222 parameter = new G4UIparameter("graphics-system-name", 's', omitable = false);
337 parameter->SetCurrentAsDefault(true); << 223 const G4GraphicsSystemList& gslist =
>> 224 fpVisManager->GetAvailableGraphicsSystems();
>> 225 G4String candidates;
>> 226 for (size_t igslist = 0; igslist < gslist.size(); igslist++) {
>> 227 const G4String& name = gslist[igslist]->GetName();
>> 228 const G4String& nickname = gslist[igslist]->GetNickname();
>> 229 if (nickname.isNull()) {
>> 230 candidates += name;
>> 231 }
>> 232 else {
>> 233 candidates += nickname;
>> 234 }
>> 235 candidates += " ";
>> 236 }
>> 237 candidates = candidates.strip();
>> 238 parameter->SetParameterCandidates(candidates);
338 fpCommand->SetParameter(parameter); 239 fpCommand->SetParameter(parameter);
339 parameter = new G4UIparameter("window-size-h << 240 parameter = new G4UIparameter("pixels", 'i', omitable = true);
340 parameter->SetGuidance << 241 parameter->SetDefaultValue(600);
341 ("integer (pixels) for square window place <<
342 " X-Windows-type geometry string, e.g. 60 <<
343 parameter->SetCurrentAsDefault(true); <<
344 fpCommand->SetParameter(parameter); 242 fpCommand->SetParameter(parameter);
345 } 243 }
346 244
347 G4VisCommandOpen::~G4VisCommandOpen() { 245 G4VisCommandOpen::~G4VisCommandOpen() {
348 delete fpCommand; 246 delete fpCommand;
349 } 247 }
350 248
351 G4String G4VisCommandOpen::GetCurrentValue(G4U << 249 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; 250 G4String systemName, windowSizeHint;
376 std::istringstream is(newValue); << 251 const char* t = newValue;
>> 252 std::istrstream is((char*)t);
377 is >> systemName >> windowSizeHint; 253 is >> systemName >> windowSizeHint;
378 G4UImanager* UImanager = G4UImanager::GetUIp 254 G4UImanager* UImanager = G4UImanager::GetUIpointer();
379 << 255 G4int keepVerbose = UImanager->GetVerboseLevel();
380 auto errorCode = UImanager->ApplyCommand(G4S << 256 G4int newVerbose(0);
381 if (errorCode) { << 257 if (keepVerbose >= 2 ||
382 G4warn << "sub-command \"/vis/sceneHandler << 258 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
383 goto finish; << 259 newVerbose = 2;
384 } << 260 UImanager->SetVerboseLevel(newVerbose);
385 << 261 UImanager->ApplyCommand(G4String("/vis/sceneHandler/create " + systemName));
386 errorCode = UImanager->ApplyCommand(G4String << 262 UImanager->ApplyCommand(G4String("/vis/viewer/create ! ! " + windowSizeHint));
387 if (errorCode) { << 263 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 } 264 }
482 265
483 ////////////// /vis/specify ////////////////// 266 ////////////// /vis/specify ///////////////////////////////////////
484 267
485 G4VisCommandSpecify::G4VisCommandSpecify() { 268 G4VisCommandSpecify::G4VisCommandSpecify() {
486 G4bool omitable; 269 G4bool omitable;
487 fpCommand = new G4UIcommand("/vis/specify", << 270 fpCommand = new G4UIcmdWithAString("/vis/specify", this);
488 fpCommand->SetGuidance << 271 fpCommand->SetGuidance("/vis/specify <logical-volume-name>");
489 ("Draws logical volume with Boolean compon <<
490 fpCommand->SetGuidance <<
491 ("Synonymous with \"/vis/drawLogicalVolume <<
492 fpCommand->SetGuidance 272 fpCommand->SetGuidance
493 ("Creates a scene consisting of this logic 273 ("Creates a scene consisting of this logical volume and asks the"
494 "\n current viewer to draw it to the spe << 274 "\n current viewer to draw it and the geometry to print the"
495 "\n showing boolean components (if any), << 275 "\n specification.");
496 "\n readout geometry (if any), local axe <<
497 "\n under control of the appropriate fla <<
498 fpCommand->SetGuidance <<
499 ("Note: voxels are not constructed until sta <<
500 "\n (For voxels without a run, \"/run/beam <<
501 fpCommand->SetGuidance("The scene becomes cu 276 fpCommand->SetGuidance("The scene becomes current.");
502 G4UIparameter* parameter; << 277 fpCommand->SetParameterName("logical-volume-name", omitable = false);
503 parameter = new G4UIparameter("logical-volum <<
504 fpCommand->SetParameter(parameter); <<
505 parameter = new G4UIparameter("depth-of-desc <<
506 parameter->SetDefaultValue(1); <<
507 fpCommand->SetParameter(parameter); <<
508 parameter = new G4UIparameter("booleans-flag <<
509 parameter->SetDefaultValue(true); <<
510 fpCommand->SetParameter(parameter); <<
511 parameter = new G4UIparameter("voxels-flag", <<
512 parameter->SetDefaultValue(true); <<
513 fpCommand->SetParameter(parameter); <<
514 parameter = new G4UIparameter("readout-flag" <<
515 parameter->SetDefaultValue(true); <<
516 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 } 278 }
526 279
527 G4VisCommandSpecify::~G4VisCommandSpecify() { 280 G4VisCommandSpecify::~G4VisCommandSpecify() {
528 delete fpCommand; 281 delete fpCommand;
529 } 282 }
530 283
531 void G4VisCommandSpecify::SetNewValue(G4UIcomm 284 void G4VisCommandSpecify::SetNewValue(G4UIcommand*, G4String newValue) {
532 G4VisManager::Verbosity verbosity = fpVisMan 285 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
533 G4UImanager* UImanager = G4UImanager::GetUIp 286 G4UImanager* UImanager = G4UImanager::GetUIpointer();
534 // UImanager->ApplyCommand(G4String("/geomet << 287 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 288 G4int newVerbose(0);
>> 289 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
>> 290 newVerbose = 2;
>> 291 UImanager->SetVerboseLevel(newVerbose);
>> 292 UImanager->ApplyCommand(G4String("/geometry/print " + newValue));
535 UImanager->ApplyCommand("/vis/scene/create") 293 UImanager->ApplyCommand("/vis/scene/create");
536 UImanager->ApplyCommand(G4String("/vis/scene 294 UImanager->ApplyCommand(G4String("/vis/scene/add/logicalVolume " + newValue));
537 UImanager->ApplyCommand("/vis/sceneHandler/a 295 UImanager->ApplyCommand("/vis/sceneHandler/attach");
538 static G4bool warned = false; << 296 UImanager->SetVerboseLevel(keepVerbose);
539 if (verbosity >= G4VisManager::confirmations << 297 if (verbosity >= G4VisManager::warnings) {
540 G4cout << 298 G4cout <<
541 "NOTE: For systems which are not \"auto- << 299 "WARNING: For systems which are not \"auto-refresh\" you will need to"
542 "\n issue \"/vis/viewer/refresh\" or \" 300 "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
543 << G4endl; 301 << G4endl;
544 warned = true; <<
545 } 302 }
546 } 303 }
547 304