| 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: G4VisCommandsScene.cc,v 1.30 2001/11/12 18:22:11 johna Exp $
>> 25 // GEANT4 tag $Name: geant4-04-00 $
27 26
28 // /vis/scene commands - John Allison 9th Aug 27 // /vis/scene commands - John Allison 9th August 1998
29 28
30 #include "G4VisCommandsScene.hh" 29 #include "G4VisCommandsScene.hh"
31 30
32 #include "G4VisManager.hh" 31 #include "G4VisManager.hh"
33 #include "G4TransportationManager.hh" 32 #include "G4TransportationManager.hh"
34 #include "G4RunManager.hh" <<
35 #include "G4RunManagerFactory.hh" <<
36 #include "G4Run.hh" <<
37 #include "G4PhysicalVolumeModel.hh" 33 #include "G4PhysicalVolumeModel.hh"
38 #include "G4ApplicationState.hh" 34 #include "G4ApplicationState.hh"
39 #include "G4UImanager.hh" 35 #include "G4UImanager.hh"
40 #include "G4UIcommand.hh" 36 #include "G4UIcommand.hh"
41 #include "G4UIcmdWithAString.hh" 37 #include "G4UIcmdWithAString.hh"
42 #include "G4UIcmdWithoutParameter.hh" <<
43 #include "G4ios.hh" 38 #include "G4ios.hh"
44 #include <sstream> << 39 #include "g4std/strstream"
45 <<
46 #define G4warn G4cout <<
47 40
48 G4VVisCommandScene::G4VVisCommandScene () {} 41 G4VVisCommandScene::G4VVisCommandScene () {}
49 42
50 G4VVisCommandScene::~G4VVisCommandScene () {} 43 G4VVisCommandScene::~G4VVisCommandScene () {}
51 44
52 G4String G4VVisCommandScene::CurrentSceneName 45 G4String G4VVisCommandScene::CurrentSceneName () {
53 const G4Scene* pScene = fpVisManager -> GetC 46 const G4Scene* pScene = fpVisManager -> GetCurrentScene ();
54 G4String currentSceneName = "none"; << 47 G4String currentSceneName;
55 if (pScene) currentSceneName = pScene -> Get 48 if (pScene) currentSceneName = pScene -> GetName ();
56 return currentSceneName; 49 return currentSceneName;
57 } 50 }
58 51
59 ////////////// /vis/scene/activateModel ////// << 52 void G4VVisCommandScene::UpdateCandidateLists () {
60 <<
61 G4VisCommandSceneActivateModel::G4VisCommandSc <<
62 G4bool omitable; <<
63 fpCommand = new G4UIcommand ("/vis/scene/act <<
64 fpCommand -> SetGuidance <<
65 ("Activate or de-activate model."); <<
66 fpCommand -> SetGuidance <<
67 ("Attempts to match search string to name <<
68 fpCommand -> SetGuidance <<
69 ("Use \"/vis/scene/list\" to see model nam <<
70 fpCommand -> SetGuidance <<
71 ("If name == \"all\" (default), all models <<
72 G4UIparameter* parameter; <<
73 parameter = new G4UIparameter ("search-strin <<
74 parameter -> SetDefaultValue ("all"); <<
75 fpCommand -> SetParameter (parameter); <<
76 parameter = new G4UIparameter ("activate", ' <<
77 parameter -> SetDefaultValue (true); <<
78 fpCommand -> SetParameter (parameter); <<
79 } <<
80 <<
81 G4VisCommandSceneActivateModel::~G4VisCommandS <<
82 delete fpCommand; <<
83 } <<
84 <<
85 G4String G4VisCommandSceneActivateModel::GetCu <<
86 return ""; <<
87 } <<
88 <<
89 void G4VisCommandSceneActivateModel::SetNewVal <<
90 G4String newValue) { <<
91 <<
92 G4VisManager::Verbosity verbosity = fpVisMan <<
93 <<
94 G4String searchString, activateString; <<
95 std::istringstream is (newValue); <<
96 // Need to handle the possibility that the s <<
97 // contains embedded blanks within quotation <<
98 // (This arises if the search string is auto <<
99 // global description, as in G4UIQt, clickin <<
100 auto lastQuotationMark = newValue.find_last_ <<
101 if (lastQuotationMark != std::string::npos) <<
102 auto firstQuotationMark = newValue.find_fi <<
103 if (lastQuotationMark != firstQuotationMar <<
104 // Note: there must not be more quotatio <<
105 searchString = newValue.substr <<
106 (firstQuotationMark + 1, lastQuotationMa <<
107 activateString = newValue.substr(lastQuo <<
108 // Perhaps we ought to check number of q <<
109 G4int nQuotes = 0; <<
110 for (auto c : newValue) { <<
111 if (c == '"') nQuotes++; <<
112 } <<
113 if (nQuotes > 2) { <<
114 G4ExceptionDescription ed; <<
115 ed << "More than 2 quotation marks in <<
116 G4Exception("G4VisCommandSceneActivate <<
117 } <<
118 } <<
119 } <<
120 else { <<
121 // None or one quotation marks - just inpu <<
122 is >> searchString >> activateString; <<
123 } <<
124 G4bool activate = G4UIcommand::ConvertToBool <<
125 <<
126 G4Scene* pScene = fpVisManager->GetCurrentSc <<
127 if (!pScene) { <<
128 if (verbosity >= G4VisManager::errors) { <<
129 G4warn << "ERROR: No current scene. Ple <<
130 } <<
131 return; <<
132 } <<
133 <<
134 G4VSceneHandler* pSceneHandler = fpVisManage <<
135 if (!pSceneHandler) { <<
136 if (verbosity >= G4VisManager::errors) { <<
137 G4warn << "ERROR: No current sceneHandle <<
138 } <<
139 return; <<
140 } <<
141 <<
142 if (searchString == "all" && !activate) { <<
143 if (verbosity >= G4VisManager::warnings) { <<
144 G4warn << <<
145 "WARNING: You are not allowed to de-activate <<
146 "\n Command ignored." <<
147 << G4endl; <<
148 } <<
149 return; <<
150 } <<
151 <<
152 G4bool any = false; <<
153 53
154 std::vector<G4Scene::Model>& runDurationMode << 54 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
155 pScene->SetRunDurationModelList(); << 55 G4int iScene, nScenes = sceneList.size ();
156 for (size_t i = 0; i < runDurationModelList. << 56 G4String nameList;
157 const G4String& modelName = runDurationMod << 57 for (iScene = 0; iScene < nScenes; iScene++) {
158 if (searchString == "all" || modelName.fin << 58 nameList += sceneList [iScene] -> GetName () + " ";
159 any = true; << 59 }
160 runDurationModelList[i].fActive = activa << 60 nameList = nameList.strip ();
161 if (verbosity >= G4VisManager::warnings) << 61 sceneNameCommandsIterator i;
162 G4warn << "Model \"" << modelName; << 62 for (i = sceneNameCommands.begin (); i != sceneNameCommands.end (); ++i) {
163 if (activate) G4warn << "\" activated."; << 63 (*i)->GetParameter (0) -> SetParameterCandidates (nameList);
164 else G4warn << "\" de-activated."; <<
165 G4warn << G4endl; <<
166 } <<
167 } <<
168 } <<
169 <<
170 std::vector<G4Scene::Model>& endOfEventModel <<
171 pScene->SetEndOfEventModelList(); <<
172 for (size_t i = 0; i < endOfEventModelList.s <<
173 const G4String& modelName = endOfEventMode <<
174 if (searchString == "all" || modelName.fin <<
175 any = true; <<
176 endOfEventModelList[i].fActive = activat <<
177 if (verbosity >= G4VisManager::warnings) <<
178 G4warn << "Model \"" << modelName; <<
179 if (activate) G4warn << "\" activated."; <<
180 else G4warn << "\" de-activated."; <<
181 G4warn << G4endl; <<
182 } <<
183 } <<
184 } <<
185 <<
186 std::vector<G4Scene::Model>& endOfRunModelLi <<
187 pScene->SetEndOfRunModelList(); <<
188 for (size_t i = 0; i < endOfRunModelList.siz <<
189 const G4String& modelName = endOfRunModelL <<
190 if (searchString == "all" || modelName.fin <<
191 any = true; <<
192 endOfRunModelList[i].fActive = activate; <<
193 if (verbosity >= G4VisManager::warnings) <<
194 G4warn << "Model \"" << modelName; <<
195 if (activate) G4warn << "\" activated."; <<
196 else G4warn << "\" de-activated."; <<
197 G4warn << G4endl; <<
198 } <<
199 } <<
200 } <<
201 <<
202 if (!any) { <<
203 if (verbosity >= G4VisManager::warnings) { <<
204 G4warn << "WARNING: No match found." << <<
205 } <<
206 return; <<
207 } 64 }
208 <<
209 CheckSceneAndNotifyHandlers (pScene); <<
210 } 65 }
211 66
212 ////////////// /vis/scene/create ///////////// 67 ////////////// /vis/scene/create ///////////////////////////////////////
213 68
214 G4VisCommandSceneCreate::G4VisCommandSceneCrea 69 G4VisCommandSceneCreate::G4VisCommandSceneCreate (): fId (0) {
215 G4bool omitable; << 70 G4bool omitable, currentAsDefault;
216 fpCommand = new G4UIcmdWithAString ("/vis/sc 71 fpCommand = new G4UIcmdWithAString ("/vis/scene/create", this);
217 fpCommand -> SetGuidance << 72 fpCommand -> SetGuidance ("/vis/scene/create [<scene-name>]");
218 ("Creates an empty scene."); << 73 fpCommand -> SetGuidance ("Creates an empty scene.");
219 fpCommand -> SetGuidance << 74 fpCommand -> SetGuidance ("Invents a name if not supplied.");
220 ("Invents a name if not supplied. This sc << 75 fpCommand -> SetGuidance ("This scene becomes current.");
221 fpCommand -> SetParameterName ("scene-name", << 76 fpCommand -> SetParameterName ("scene-name",
>> 77 omitable = true,
>> 78 currentAsDefault = true);
>> 79 sceneNameCommands.push_back (fpCommand);
222 } 80 }
223 81
224 G4VisCommandSceneCreate::~G4VisCommandSceneCre 82 G4VisCommandSceneCreate::~G4VisCommandSceneCreate () {
225 delete fpCommand; 83 delete fpCommand;
226 } 84 }
227 85
228 G4String G4VisCommandSceneCreate::NextName () 86 G4String G4VisCommandSceneCreate::NextName () {
229 std::ostringstream oss; << 87 char nextName [20];
230 oss << "scene-" << fId; << 88 G4std::ostrstream ost (nextName, 20);
231 return oss.str(); << 89 ost << "scene-" << fId << G4std::ends;
>> 90 return nextName;
232 } 91 }
233 92
234 G4String G4VisCommandSceneCreate::GetCurrentVa << 93 G4String G4VisCommandSceneCreate::GetCurrentValue (G4UIcommand* command) {
235 return ""; << 94 return NextName ();
236 } 95 }
237 96
238 void G4VisCommandSceneCreate::SetNewValue (G4U << 97 void G4VisCommandSceneCreate::SetNewValue (G4UIcommand* command,
>> 98 G4String newValue) {
239 99
240 G4VisManager::Verbosity verbosity = fpVisMan 100 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
241 101
242 G4String& newName = newValue; 102 G4String& newName = newValue;
243 G4String nextName = NextName (); 103 G4String nextName = NextName ();
244 104
245 if (newName == "") { 105 if (newName == "") {
246 newName = nextName; 106 newName = nextName;
247 } 107 }
248 if (newName == nextName) fId++; 108 if (newName == nextName) fId++;
249 109
250 G4SceneList& sceneList = fpVisManager -> Set 110 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
251 std::size_t iScene, nScenes = sceneList.size << 111 G4int iScene, nScenes = sceneList.size ();
252 for (iScene = 0; iScene < nScenes; ++iScene) << 112 for (iScene = 0; iScene < nScenes; iScene++) {
253 if (sceneList [iScene] -> GetName () == ne 113 if (sceneList [iScene] -> GetName () == newName) break;
254 } 114 }
255 if (iScene < nScenes) { 115 if (iScene < nScenes) {
256 if (verbosity >= G4VisManager::warnings) { 116 if (verbosity >= G4VisManager::warnings) {
257 G4warn << "WARNING: Scene \"" << newName << 117 G4cout << "WARNING: Scene \"" << newName << "\" already exists."
258 << "\n New scene not created." <<
259 << G4endl; 118 << G4endl;
260 } 119 }
261 } else { << 120 }
>> 121 else {
262 122
263 // Add empty scene data object to list... << 123 sceneList.push_back (new G4Scene (newName));
264 G4Scene* pScene = new G4Scene (newName); << 124 // Adds empty scene data object to list.
265 sceneList.push_back (pScene); <<
266 fpVisManager -> SetCurrentScene (pScene); <<
267 125
268 if (verbosity >= G4VisManager::confirmatio 126 if (verbosity >= G4VisManager::confirmations) {
269 G4cout << "New empty scene \"" << newNam 127 G4cout << "New empty scene \"" << newName << "\" created." << G4endl;
270 } 128 }
>> 129
>> 130 UpdateCandidateLists ();
271 } 131 }
>> 132 UpdateVisManagerScene (newName);
272 } 133 }
273 134
274 ////////////// /vis/scene/endOfEventAction /// << 135 ////////////// /vis/scene/edit ///////////////////////////////////////
275 136
276 G4VisCommandSceneEndOfEventAction::G4VisComman << 137 G4VisCommandSceneEdit::G4VisCommandSceneEdit () {
277 G4bool omitable; << 138 G4bool omitable, currentAsDefault;
278 fpCommand = new G4UIcommand ("/vis/scene/end << 139 fpCommand = new G4UIcmdWithAString ("/vis/scene/edit", this);
279 fpCommand -> SetGuidance << 140 fpCommand -> SetGuidance ("/vis/scene/edit [<scene-name>]");
280 ("Accumulate or refresh the viewer for eac << 141 fpCommand -> SetGuidance ("Edits a scene (default current scene).");
281 fpCommand -> SetGuidance << 142 fpCommand -> SetGuidance ("This scene becomes current.");
282 ("\"accumulate\": viewer accumulates hits, << 143 fpCommand -> SetParameterName ("scene-name",
283 fpCommand -> SetGuidance << 144 omitable = true,
284 ("\"refresh\": viewer shows them at end of << 145 currentAsDefault = true);
285 "\n viewers, refreshes the screen just b << 146 sceneNameCommands.push_back (fpCommand);
286 G4UIparameter* parameter; <<
287 parameter = new G4UIparameter ("action", 's' <<
288 parameter -> SetParameterCandidates ("accumu <<
289 parameter -> SetDefaultValue ("refresh"); <<
290 fpCommand -> SetParameter (parameter); <<
291 parameter = new G4UIparameter ("maxNumber", <<
292 parameter -> SetDefaultValue (100); <<
293 parameter -> SetGuidance <<
294 ("Maximum number of events kept. Unlimited <<
295 fpCommand -> SetParameter (parameter); <<
296 } 147 }
297 148
298 G4VisCommandSceneEndOfEventAction::~G4VisComma << 149 G4VisCommandSceneEdit::~G4VisCommandSceneEdit () {
299 delete fpCommand; 150 delete fpCommand;
300 } 151 }
301 152
302 G4String G4VisCommandSceneEndOfEventAction::Ge << 153 G4String G4VisCommandSceneEdit::GetCurrentValue (G4UIcommand* command) {
303 return ""; << 154 return CurrentSceneName ();
304 } 155 }
305 156
306 void G4VisCommandSceneEndOfEventAction::SetNew << 157 void G4VisCommandSceneEdit::SetNewValue (G4UIcommand* command,
307 G4String newValue) { << 158 G4String newValue) {
308 159
309 G4VisManager::Verbosity verbosity = fpVisMan 160 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
310 161
311 G4String action; << 162 G4String sceneName;
312 G4int maxNumberOfKeptEvents; << 163 G4std::istrstream is ((char*)newValue.data());
313 std::istringstream is (newValue); << 164 is >> sceneName;
314 is >> action >> maxNumberOfKeptEvents; <<
315 165
316 G4Scene* pScene = fpVisManager->GetCurrentSc << 166 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
317 if (!pScene) { << 167 G4int iScene, nScenes = sceneList.size ();
318 if (verbosity >= G4VisManager::errors) { << 168 G4Scene* pScene;
319 G4warn << "ERROR: No current scene. Ple << 169 for (iScene = 0; iScene < nScenes; iScene++) {
320 } << 170 pScene = sceneList [iScene];
321 return; << 171 if (pScene -> GetName () == sceneName) break;
322 } 172 }
323 << 173 if (iScene >= nScenes) {
324 G4VSceneHandler* pSceneHandler = fpVisManage << 174 if (verbosity >= G4VisManager::warnings) {
325 if (!pSceneHandler) { << 175 G4cout << "WARNING: G4VisCommandSceneEdit::SetNewValue: Scene \""
326 if (verbosity >= G4VisManager::errors) { << 176 << sceneName << "\" not found."
327 G4warn << "ERROR: No current sceneHandle << 177 "\n /vis/scene/list to see scenes."
>> 178 << G4endl;
328 } 179 }
329 return; 180 return;
330 } 181 }
331 <<
332 if (action == "accumulate") { <<
333 pScene->SetRefreshAtEndOfEvent(false); <<
334 pScene->SetMaxNumberOfKeptEvents(maxNumber <<
335 } <<
336 else if (action == "refresh") { <<
337 if (!pScene->GetRefreshAtEndOfRun()) { <<
338 if (verbosity >= G4VisManager::errors) { <<
339 G4warn << <<
340 "ERROR: Cannot refresh events unless runs <<
341 "\n Use \"/vis/scene/endOfRun refresh\"." <<
342 << G4endl; <<
343 } <<
344 } else { <<
345 pScene->SetRefreshAtEndOfEvent(true); <<
346 pScene->SetMaxNumberOfKeptEvents(maxNumb <<
347 pSceneHandler->SetMarkForClearingTransie <<
348 } <<
349 } <<
350 else { 182 else {
351 if (verbosity >= G4VisManager::errors) { << 183 if (verbosity >= G4VisManager::confirmations) {
352 G4warn << << 184 G4cout << "Scene \"" << sceneName << "\" contains:" << G4endl;
353 "ERROR: unrecognised parameter \"" << action << 185 G4String uiCommand ("/vis/scene/list ");
354 << G4endl; << 186 uiCommand += sceneName;
355 } << 187 uiCommand += " confirmations";
356 return; << 188 G4UImanager::GetUIpointer () -> ApplyCommand (uiCommand);
357 } << 189 G4cout <<
358 << 190 "BUT...YOU CAN DO NOTHING YET - /vis/scene/edit FACILITY IN PREPARATION."
359 // Change of transients behaviour, so... << 191 << G4endl;
360 fpVisManager->ResetTransientsDrawnFlags(); <<
361 <<
362 // Are there any events currently kept... <<
363 size_t nCurrentlyKept = 0; <<
364 G4RunManager* runManager = G4RunManagerFacto <<
365 if(runManager) <<
366 { <<
367 const G4Run* currentRun = runManager->GetC <<
368 if(currentRun) <<
369 { <<
370 const std::vector<const G4Event*>* event <<
371 if(events) <<
372 nCurrentlyKept = events->size(); <<
373 } <<
374 } <<
375 <<
376 if (verbosity >= G4VisManager::confirmations <<
377 G4cout << "End of event action set to "; <<
378 if (pScene->GetRefreshAtEndOfEvent()) G4co <<
379 else { <<
380 G4cout << "\"accumulate\"." <<
381 "\n Maximum number of events to be kept: " <<
382 << maxNumberOfKeptEvents <<
383 << " (unlimited if negative)." <<
384 "\n This may be changed with, e.g., " <<
385 "\"/vis/scene/endOfEventAction accumulate 10 <<
386 } 192 }
387 G4cout << G4endl; <<
388 } 193 }
389 194
390 if (!pScene->GetRefreshAtEndOfEvent() && << 195 UpdateVisManagerScene (sceneName);
391 maxNumberOfKeptEvents != 0 && <<
392 verbosity >= G4VisManager::warnings) { <<
393 G4warn << "WARNING: "; <<
394 if (nCurrentlyKept) { <<
395 G4warn << <<
396 "\n There are currently " << nCurrentlyKept <<
397 << " events kept for refreshing and/or <<
398 } else { <<
399 G4warn << "The vis manager will keep "; <<
400 if (maxNumberOfKeptEvents < 0) G4warn << <<
401 else G4warn << "up to " << maxNumberOfKe <<
402 G4warn << " events."; <<
403 if (maxNumberOfKeptEvents > 1 || maxNumb <<
404 G4warn << <<
405 "\n This may use a lot of memory." <<
406 "\n It may be changed with, e.g., " <<
407 "\"/vis/scene/endOfEventAction accumulate <<
408 } <<
409 G4warn << G4endl; <<
410 } <<
411 } 196 }
412 197
413 ////////////// /vis/scene/endOfRunAction ///// << 198 ////////////// /vis/scene/endOfEventAction ////////////////////////////
414 199
415 G4VisCommandSceneEndOfRunAction::G4VisCommandS << 200 G4VisCommandSceneEndOfEventAction::G4VisCommandSceneEndOfEventAction () {
416 G4bool omitable; 201 G4bool omitable;
417 fpCommand = new G4UIcmdWithAString ("/vis/sc << 202 fpCommand = new G4UIcmdWithAString ("/vis/scene/endOfEventAction", this);
418 fpCommand -> SetGuidance <<
419 ("Accumulate or refresh the viewer for eac <<
420 fpCommand -> SetGuidance 203 fpCommand -> SetGuidance
421 ("\"accumulate\": viewer accumulates hits, << 204 ("/vis/scene/endOfEventAction [accumulate|refresh]");
422 fpCommand -> SetGuidance 205 fpCommand -> SetGuidance
423 ("\"refresh\": viewer shows them at end of << 206 ("Requests viewer to refresh hits, tracks, etc., at end of event."
424 "\n viewers, refreshes the screen just b << 207 "\n Or they are accumulated. Detector remains or is redrawn.");
425 "\n event of the next run."); << 208 fpCommand -> SetParameterName ("action",
426 fpCommand -> SetGuidance ("The detector rema << 209 omitable = true);
427 fpCommand -> SetParameterName ("action", omi <<
428 fpCommand -> SetCandidates ("accumulate refr 210 fpCommand -> SetCandidates ("accumulate refresh");
429 fpCommand -> SetDefaultValue ("refresh"); 211 fpCommand -> SetDefaultValue ("refresh");
430 } 212 }
431 213
432 G4VisCommandSceneEndOfRunAction::~G4VisCommand << 214 G4VisCommandSceneEndOfEventAction::~G4VisCommandSceneEndOfEventAction () {
433 delete fpCommand; 215 delete fpCommand;
434 } 216 }
435 217
436 G4String G4VisCommandSceneEndOfRunAction::GetC << 218 G4String G4VisCommandSceneEndOfEventAction::GetCurrentValue
>> 219 (G4UIcommand* command) {
437 return ""; 220 return "";
438 } 221 }
439 222
440 void G4VisCommandSceneEndOfRunAction::SetNewVa << 223 void G4VisCommandSceneEndOfEventAction::SetNewValue (G4UIcommand* command,
441 G4String newValue) { 224 G4String newValue) {
442 225
443 G4VisManager::Verbosity verbosity = fpVisMan 226 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
444 227
445 G4String action; 228 G4String action;
446 std::istringstream is (newValue); << 229 G4std::istrstream is ((char*)newValue.data());
447 is >> action; 230 is >> action;
448 231
449 G4Scene* pScene = fpVisManager->GetCurrentSc 232 G4Scene* pScene = fpVisManager->GetCurrentScene();
450 if (!pScene) { 233 if (!pScene) {
451 if (verbosity >= G4VisManager::errors) { 234 if (verbosity >= G4VisManager::errors) {
452 G4warn << "ERROR: No current scene. Ple << 235 G4cout << "ERROR: No current scene. Please create one." << G4endl;
453 } <<
454 return; <<
455 } <<
456 <<
457 G4VSceneHandler* pSceneHandler = fpVisManage <<
458 if (!pSceneHandler) { <<
459 if (verbosity >= G4VisManager::errors) { <<
460 G4warn << "ERROR: No current sceneHandle <<
461 } 236 }
462 return; 237 return;
463 } 238 }
464 239
465 if (action == "accumulate") { 240 if (action == "accumulate") {
466 if (pScene->GetRefreshAtEndOfEvent()) { << 241 pScene->SetRefreshAtEndOfEvent(false);
467 if (verbosity >= G4VisManager::errors) { <<
468 G4warn << <<
469 "ERROR: Cannot accumulate runs unless even <<
470 "\n Use \"/vis/scene/endOfEventAction acc <<
471 << G4endl; <<
472 } <<
473 } <<
474 else { <<
475 pScene->SetRefreshAtEndOfRun(false); <<
476 } <<
477 } 242 }
478 else if (action == "refresh") { 243 else if (action == "refresh") {
479 pScene->SetRefreshAtEndOfRun(true); << 244 pScene->SetRefreshAtEndOfEvent(true);
480 pSceneHandler->SetMarkForClearingTransient <<
481 } 245 }
482 else { 246 else {
483 if (verbosity >= G4VisManager::errors) { 247 if (verbosity >= G4VisManager::errors) {
484 G4warn << << 248 G4cout <<
485 "ERROR: unrecognised parameter \"" << action 249 "ERROR: unrecognised parameter \"" << action << "\"."
486 << G4endl; 250 << G4endl;
487 } 251 }
488 return; 252 return;
489 } 253 }
490 254
491 // Change of transients behaviour, so... <<
492 fpVisManager->ResetTransientsDrawnFlags(); <<
493 <<
494 if (verbosity >= G4VisManager::confirmations 255 if (verbosity >= G4VisManager::confirmations) {
495 G4cout << "End of run action set to \""; << 256 G4cout << "End of event action set to \"";
496 if (pScene->GetRefreshAtEndOfRun()) G4cout << 257 if (pScene->GetRefreshAtEndOfEvent()) G4cout << "refresh";
497 else G4cout << "accumulate"; 258 else G4cout << "accumulate";
498 G4cout << "\"" << G4endl; 259 G4cout << "\"" << G4endl;
499 } 260 }
500 } 261 }
501 262
502 ////////////// /vis/scene/list /////////////// 263 ////////////// /vis/scene/list ///////////////////////////////////////
503 264
504 G4VisCommandSceneList::G4VisCommandSceneList ( 265 G4VisCommandSceneList::G4VisCommandSceneList () {
505 G4bool omitable; 266 G4bool omitable;
506 fpCommand = new G4UIcommand ("/vis/scene/lis 267 fpCommand = new G4UIcommand ("/vis/scene/list", this);
>> 268 fpCommand -> SetGuidance ("/vis/scene/list [<scene-name>] [<verbosity>]");
507 fpCommand -> SetGuidance ("Lists scene(s).") 269 fpCommand -> SetGuidance ("Lists scene(s).");
>> 270 fpCommand -> SetGuidance ("<scene-name> default is \"all\"");
508 fpCommand -> SetGuidance 271 fpCommand -> SetGuidance
509 ("\"help /vis/verbose\" for definition of << 272 ("See /vis/verbose for definition of verbosity.");
510 G4UIparameter* parameter; 273 G4UIparameter* parameter;
511 parameter = new G4UIparameter ("scene-name", << 274 parameter = new G4UIparameter ("scene-name", 's',
>> 275 omitable = true);
>> 276 parameter -> SetCurrentAsDefault (false);
512 parameter -> SetDefaultValue ("all"); 277 parameter -> SetDefaultValue ("all");
513 fpCommand -> SetParameter (parameter); 278 fpCommand -> SetParameter (parameter);
514 parameter = new G4UIparameter ("verbosity", << 279 parameter = new G4UIparameter ("verbosity", 's',
515 parameter -> SetDefaultValue ("warnings"); << 280 omitable = true);
>> 281 parameter -> SetCurrentAsDefault (false);
>> 282 parameter -> SetDefaultValue (0);
516 fpCommand -> SetParameter (parameter); 283 fpCommand -> SetParameter (parameter);
>> 284 sceneNameCommands.push_back (fpCommand);
517 } 285 }
518 286
519 G4VisCommandSceneList::~G4VisCommandSceneList 287 G4VisCommandSceneList::~G4VisCommandSceneList () {
520 delete fpCommand; 288 delete fpCommand;
521 } 289 }
522 290
523 G4String G4VisCommandSceneList::GetCurrentValu << 291 G4String G4VisCommandSceneList::GetCurrentValue (G4UIcommand* command) {
524 return ""; 292 return "";
525 } 293 }
526 294
527 void G4VisCommandSceneList::SetNewValue (G4UIc << 295 void G4VisCommandSceneList::SetNewValue (G4UIcommand* command,
>> 296 G4String newValue) {
528 G4String name, verbosityString; 297 G4String name, verbosityString;
529 std::istringstream is (newValue); << 298 G4std::istrstream is ((char*)newValue.data());
530 is >> name >> verbosityString; 299 is >> name >> verbosityString;
531 G4VisManager::Verbosity verbosity = 300 G4VisManager::Verbosity verbosity =
532 fpVisManager->GetVerbosityValue(verbosityS 301 fpVisManager->GetVerbosityValue(verbosityString);
533 const G4Scene* currentScene = fpVisManager - <<
534 G4String currentName; <<
535 if (currentScene) currentName = currentScene <<
536 302
537 G4SceneList& sceneList = fpVisManager -> Set 303 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
538 std::size_t iScene, nScenes = sceneList.size << 304 G4int iScene, nScenes = sceneList.size ();
539 G4bool found = false; 305 G4bool found = false;
540 for (iScene = 0; iScene < nScenes; ++iScene) << 306 for (iScene = 0; iScene < nScenes; iScene++) {
541 G4Scene* pScene = sceneList [iScene]; 307 G4Scene* pScene = sceneList [iScene];
542 const G4String& iName = pScene -> GetName 308 const G4String& iName = pScene -> GetName ();
543 if (name != "all") { 309 if (name != "all") {
544 if (name != iName) continue; 310 if (name != iName) continue;
545 } 311 }
546 found = true; 312 found = true;
547 if (iName == currentName) { << 313 G4cout << "Scene name: \"" << iName << "\"";
548 G4cout << " (current)"; << 314 if (verbosity >= G4VisManager::confirmations) {
549 } << 315 G4int i;
550 else { <<
551 G4cout << " "; <<
552 } <<
553 G4cout << " scene \"" << iName << "\""; <<
554 if (verbosity >= G4VisManager::warnings) { <<
555 std::size_t i; <<
556 G4cout << "\n Run-duration models:"; 316 G4cout << "\n Run-duration models:";
557 std::size_t nRunModels = pScene -> GetRu << 317 G4int nRunModels = pScene -> GetRunDurationModelList ().size ();
558 if (nRunModels == 0) { 318 if (nRunModels == 0) {
559 G4cout << " none."; 319 G4cout << " none.";
560 } 320 }
561 for (i = 0; i < nRunModels; ++i) { << 321 for (i = 0; i < nRunModels; i++) {
562 if (pScene -> GetRunDurationModelList()[i].f << 322 G4VModel* pModel = pScene -> GetRunDurationModelList () [i];
563 G4cout << "\n Active: "; << 323 G4cout << "\n " << pModel -> GetGlobalDescription ();
564 else G4cout << "\n Inactive: "; <<
565 G4VModel* pModel = pScene -> GetRunDurationM <<
566 G4cout << pModel -> GetGlobalDescription (); <<
567 } 324 }
568 G4cout << "\n End-of-event models:"; 325 G4cout << "\n End-of-event models:";
569 std::size_t nEOEModels = pScene -> GetEn << 326 G4int nEOEModels = pScene -> GetEndOfEventModelList ().size ();
570 if (nEOEModels == 0) { 327 if (nEOEModels == 0) {
571 G4cout << " none."; 328 G4cout << " none.";
572 } 329 }
573 for (i = 0; i < nEOEModels; ++i) { << 330 for (i = 0; i < nEOEModels; i++) {
574 if (pScene -> GetEndOfEventModelList()[i].fA << 331 G4VModel* pModel = pScene -> GetEndOfEventModelList () [i];
575 G4cout << "\n Active: "; << 332 G4cout << "\n " << pModel -> GetGlobalDescription ();
576 else G4cout << "\n Inactive: "; <<
577 G4VModel* pModel = pScene -> GetEndOfEventMo <<
578 G4cout << pModel -> GetGlobalDescription (); <<
579 } <<
580 G4cout << "\n End-of-run models:"; <<
581 std::size_t nEORModels = pScene -> GetEn <<
582 if (nEORModels == 0) { <<
583 G4cout << " none."; <<
584 } <<
585 for (i = 0; i < nEORModels; ++i) { <<
586 if (pScene -> GetEndOfRunModelList()[i].fAct <<
587 G4cout << "\n Active: "; <<
588 else G4cout << "\n Inactive: "; <<
589 G4VModel* pModel = pScene -> GetEndOfRunMode <<
590 G4cout << pModel -> GetGlobalDescription (); <<
591 } 333 }
592 } 334 }
593 if (verbosity >= G4VisManager::parameters) 335 if (verbosity >= G4VisManager::parameters) {
594 G4cout << "\n " << *sceneList [iScene]; 336 G4cout << "\n " << *sceneList [iScene];
595 } 337 }
596 G4cout << G4endl; 338 G4cout << G4endl;
597 } 339 }
598 if (!found) { 340 if (!found) {
599 G4warn << "No scenes found"; << 341 G4cout << "No scenes found";
600 if (name != "all") { 342 if (name != "all") {
601 G4warn << " of name \"" << name << "\""; << 343 G4cout << " of name \"" << name << "\"";
602 } 344 }
603 G4warn << "." << G4endl; << 345 G4cout << "." << G4endl;
604 } 346 }
605 } 347 }
606 348
607 ////////////// /vis/scene/notifyHandlers ///// 349 ////////////// /vis/scene/notifyHandlers /////////////////////////
608 350
609 G4VisCommandSceneNotifyHandlers::G4VisCommandS 351 G4VisCommandSceneNotifyHandlers::G4VisCommandSceneNotifyHandlers () {
610 G4bool omitable; 352 G4bool omitable;
611 fpCommand = new G4UIcommand ("/vis/scene/not 353 fpCommand = new G4UIcommand ("/vis/scene/notifyHandlers", this);
612 fpCommand -> SetGuidance 354 fpCommand -> SetGuidance
613 ("Notifies scene handlers and forces re-re << 355 ("/vis/scene/notifyHandlers [<scene-name>] [r[efresh]|f[lush]]");
>> 356 fpCommand -> SetGuidance
>> 357 ("Notifies scene handlers of possible changes of scene.");
>> 358 fpCommand -> SetGuidance ("<scene-name> default is current scene name.");
614 fpCommand -> SetGuidance 359 fpCommand -> SetGuidance
615 ("Notifies the handler(s) of the specified << 360 ("Clears and refreshes all viewers of current scene."
616 "\nreconstruction of any graphical databa <<
617 "\nClears and refreshes all viewers of cu <<
618 "\n The default action \"refresh\" does 361 "\n The default action \"refresh\" does not issue \"update\" (see"
619 "\n /vis/viewer/update)." 362 "\n /vis/viewer/update)."
620 "\nIf \"flush\" is specified, it issues a 363 "\nIf \"flush\" is specified, it issues an \"update\" as well as"
621 "\n \"refresh\" - \"update\" and initiat << 364 "\n \"refresh\". Useful for refreshing and initiating post-processing"
622 "\n for graphics systems which need it." << 365 "\n for graphics systems which need post-processing.");
623 fpCommand -> SetGuidance <<
624 ("The default for <scene-name> is the curr <<
625 fpCommand -> SetGuidance 366 fpCommand -> SetGuidance
626 ("This command does not change current sce 367 ("This command does not change current scene, scene handler or viewer.");
627 G4UIparameter* parameter; 368 G4UIparameter* parameter;
628 parameter = new G4UIparameter ("scene-name", 369 parameter = new G4UIparameter ("scene-name", 's',
629 omitable = true); 370 omitable = true);
630 parameter -> SetCurrentAsDefault(true); 371 parameter -> SetCurrentAsDefault(true);
631 fpCommand -> SetParameter (parameter); 372 fpCommand -> SetParameter (parameter);
632 parameter = new G4UIparameter ("refresh-flus 373 parameter = new G4UIparameter ("refresh-flush", 's',
633 omitable = true); 374 omitable = true);
634 parameter -> SetDefaultValue("refresh"); 375 parameter -> SetDefaultValue("refresh");
635 parameter -> SetParameterCandidates("r refre <<
636 fpCommand -> SetParameter (parameter); 376 fpCommand -> SetParameter (parameter);
>> 377 sceneNameCommands.push_back (fpCommand);
637 } 378 }
638 379
639 G4VisCommandSceneNotifyHandlers::~G4VisCommand 380 G4VisCommandSceneNotifyHandlers::~G4VisCommandSceneNotifyHandlers () {
640 delete fpCommand; 381 delete fpCommand;
641 } 382 }
642 383
643 G4String G4VisCommandSceneNotifyHandlers::GetC << 384 G4String G4VisCommandSceneNotifyHandlers::GetCurrentValue
>> 385 (G4UIcommand* command) {
644 return CurrentSceneName (); 386 return CurrentSceneName ();
645 } 387 }
646 388
647 void G4VisCommandSceneNotifyHandlers::SetNewVa << 389 void G4VisCommandSceneNotifyHandlers::SetNewValue (G4UIcommand* command,
648 G4String newValue) { 390 G4String newValue) {
649 391
650 G4VisManager::Verbosity verbosity = fpVisMan 392 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
651 393
652 G4String sceneName, refresh_flush; 394 G4String sceneName, refresh_flush;
653 std::istringstream is (newValue); << 395 G4std::istrstream is ((char*)newValue.data());
654 is >> sceneName >> refresh_flush; 396 is >> sceneName >> refresh_flush;
655 G4bool flush = false; << 397 G4bool flush(false);
656 if (refresh_flush[0] == 'f') flush = true; << 398 if (refresh_flush(0) == 'f') flush = true;
657 399
658 const G4SceneList& sceneList = fpVisManager 400 const G4SceneList& sceneList = fpVisManager -> GetSceneList ();
659 G4SceneHandlerList& sceneHandlerList = 401 G4SceneHandlerList& sceneHandlerList =
660 fpVisManager -> SetAvailableSceneHandlers 402 fpVisManager -> SetAvailableSceneHandlers ();
661 403
662 // Check scene name. 404 // Check scene name.
663 const std::size_t nScenes = sceneList.size ( << 405 const G4int nScenes = sceneList.size ();
664 std::size_t iScene; << 406 G4int iScene;
665 for (iScene = 0; iScene < nScenes; ++iScene) << 407 for (iScene = 0; iScene < nScenes; iScene++) {
666 G4Scene* scene = sceneList [iScene]; 408 G4Scene* scene = sceneList [iScene];
667 if (sceneName == scene -> GetName ()) brea 409 if (sceneName == scene -> GetName ()) break;
668 } 410 }
669 if (iScene >= nScenes ) { 411 if (iScene >= nScenes ) {
670 if (verbosity >= G4VisManager::warnings) { 412 if (verbosity >= G4VisManager::warnings) {
671 G4warn << "WARNING: Scene \"" << sceneNa << 413 G4cout << "WARNING: Scene \"" << sceneName << "\" not found."
672 "\n /vis/scene/list to see scenes." 414 "\n /vis/scene/list to see scenes."
673 << G4endl; 415 << G4endl;
674 } 416 }
675 return; 417 return;
676 } 418 }
677 419
678 // Store current context... <<
679 G4VSceneHandler* pCurrentSceneHandler = <<
680 fpVisManager -> GetCurrentSceneHandler(); <<
681 if (!pCurrentSceneHandler) { <<
682 if (verbosity >= G4VisManager::warnings) { <<
683 G4warn << "WARNING: No current scene han <<
684 << G4endl; <<
685 } <<
686 return; <<
687 } <<
688 G4VViewer* pCurrentViewer = fpVisManager -> <<
689 if (!pCurrentViewer) { <<
690 if (verbosity >= G4VisManager::warnings) { <<
691 G4warn << "WARNING: No current viewer." <<
692 << G4endl; <<
693 } <<
694 return; <<
695 } <<
696 G4Scene* pCurrentScene = fpVisManager -> Get <<
697 if (!pCurrentScene) { <<
698 if (verbosity >= G4VisManager::warnings) { <<
699 G4warn << "WARNING: No current scene." <<
700 << G4endl; <<
701 } <<
702 return; <<
703 } <<
704 <<
705 G4VisManager::Verbosity currentVerbosity = f <<
706 <<
707 // Suppress messages during this process (on <<
708 //fpVisManager -> SetVerboseLevel(G4VisManag <<
709 <<
710 // For each scene handler, if it contains th 420 // For each scene handler, if it contains the scene, clear and
711 // rebuild the graphical database, then for 421 // rebuild the graphical database, then for each viewer set (make
712 // current), clear, (re)draw, and show. 422 // current), clear, (re)draw, and show.
713 const std::size_t nSceneHandlers = sceneHand << 423 const G4int nSceneHandlers = sceneHandlerList.size ();
714 for (std::size_t iSH = 0; iSH < nSceneHandle << 424 for (G4int iSH = 0; iSH < nSceneHandlers; iSH++) {
715 G4VSceneHandler* aSceneHandler = sceneHand 425 G4VSceneHandler* aSceneHandler = sceneHandlerList [iSH];
716 G4Scene* aScene = aSceneHandler -> GetScen 426 G4Scene* aScene = aSceneHandler -> GetScene ();
717 if (aScene) { 427 if (aScene) {
718 const G4String& aSceneName = aScene -> G 428 const G4String& aSceneName = aScene -> GetName ();
719 if (sceneName == aSceneName) { 429 if (sceneName == aSceneName) {
720 aScene->CalculateExtent(); // Check and rec << 430 // Clear store and force a rebuild of graphical database...
>> 431 aSceneHandler -> ClearStore ();
721 G4ViewerList& viewerList = aSceneHandler -> 432 G4ViewerList& viewerList = aSceneHandler -> SetViewerList ();
722 const std::size_t nViewers = viewerList.size << 433 const G4int nViewers = viewerList.size ();
723 for (std::size_t iV = 0; iV < nViewers; ++iV << 434 for (G4int iV = 0; iV < nViewers; iV++) {
724 G4VViewer* aViewer = viewerList [iV]; 435 G4VViewer* aViewer = viewerList [iV];
725 // Force rebuild of graphical database, if << 436 aSceneHandler -> SetCurrentViewer (aViewer); // Temporarily.
726 aViewer -> NeedKernelVisit(); << 437 aViewer -> SetView (); // Temporarily switch contexts.
727 if (aViewer->GetViewParameters().IsAutoRef << 438 //??aViewer -> ClearView ();
728 aSceneHandler -> SetCurrentViewer (aView << 439 aViewer -> DrawView ();
729 // Ensure consistency of vis manager... << 440 if (flush) aViewer -> ShowView ();
730 fpVisManager -> SetCurrentViewer(aViewer << 441 if (verbosity >= G4VisManager::confirmations) {
731 fpVisManager -> SetCurrentSceneHandler(a << 442 G4cout << "Viewer \"" << aViewer -> GetName ()
732 fpVisManager -> SetCurrentScene(aScene); << 443 << "\" of scene handler \"" << aSceneHandler -> GetName ()
733 aViewer -> SetView (); << 444 << "\"\n ";
734 aViewer -> ClearView (); << 445 if (flush) G4cout << "flushed";
735 aViewer -> DrawView (); << 446 else G4cout << "refreshed";
736 if (flush) aViewer -> ShowView (); << 447 G4cout << " at request of scene \"" << sceneName
737 if (verbosity >= G4VisManager::confirmat << 448 << "\"." << G4endl;
738 G4cout << "Viewer \"" << aViewer -> Ge <<
739 << "\" of scene handler \"" << aScene <<
740 << "\"\n "; <<
741 if (flush) G4cout << "flushed"; <<
742 else G4cout << "refreshed"; <<
743 G4cout << " at request of scene \"" << <<
744 << "\"." << G4endl; <<
745 } <<
746 } else { <<
747 if (verbosity >= G4VisManager::confirmat <<
748 G4cout << "NOTE: The scene, \"" <<
749 << sceneName <<
750 << "\", of viewer \"" <<
751 << aViewer -> GetName () <<
752 << "\"\n of scene handler \"" <<
753 << aSceneHandler -> GetName () <<
754 << "\" has changed. To see effect," <<
755 << "\n \"/vis/viewer/select " <<
756 << aViewer -> GetShortName () <<
757 << "\" and \"/vis/viewer/rebuild\"." <<
758 << G4endl; <<
759 } <<
760 } 449 }
761 } 450 }
762 } 451 }
763 } 452 }
764 else { 453 else {
765 if (verbosity >= G4VisManager::warnings) 454 if (verbosity >= G4VisManager::warnings) {
766 G4warn << "WARNING: G4VisCommandSceneNotifyH << 455 G4cout << "WARNING: G4VisCommandSceneNotifyHandlers: scene handler \""
767 << aSceneHandler->GetName() 456 << aSceneHandler->GetName()
768 << "\" has a null scene." 457 << "\" has a null scene."
769 << G4endl; 458 << G4endl;
770 } 459 }
771 } 460 }
772 } 461 }
773 << 462 // Reclaim original context...
774 // Reclaim original context - but set viewer << 463 G4VSceneHandler* pCurrentSceneHandler =
775 // handler, because the latter might have be << 464 fpVisManager -> GetCurrentSceneHandler();
776 // and, not yet having a viewer, the current << 465 G4VViewer* pCurrentViewer = fpVisManager -> GetCurrentViewer();
777 // temporarily, refer to another scene handl <<
778 // actually resets the scene handler, which <<
779 // so we set it again on the next line... <<
780 fpVisManager -> SetCurrentViewer(pCurrentVie <<
781 fpVisManager -> SetCurrentSceneHandler(pCurr <<
782 fpVisManager -> SetCurrentScene(pCurrentScen <<
783 fpVisManager -> SetVerboseLevel(currentVerbo <<
784 // Take care of special case of scene handle <<
785 if (pCurrentSceneHandler) { 466 if (pCurrentSceneHandler) {
786 G4ViewerList& viewerList = pCurrentSceneHa << 467 pCurrentSceneHandler -> SetCurrentViewer (pCurrentViewer);
787 const std::size_t nViewers = viewerList.si << 468 if (pCurrentViewer && pCurrentSceneHandler->GetScene())
788 if (nViewers) { << 469 pCurrentViewer -> SetView ();
789 pCurrentSceneHandler -> SetCurrentViewer <<
790 // JA: I don't think we need this. SetVi <<
791 // if (pCurrentViewer && pCurrentSceneHa <<
792 // pCurrentViewer -> SetView (); <<
793 // } <<
794 } <<
795 } 470 }
796 } 471 }
797 472
798 ////////////// /vis/scene/removeModel //////// << 473 ////////////// /vis/scene/remove ///////////////////////////////////////
799 474
800 G4VisCommandSceneRemoveModel::G4VisCommandScen << 475 G4VisCommandSceneRemove::G4VisCommandSceneRemove () {
801 G4bool omitable; << 476 G4bool omitable, currentAsDefault;
802 fpCommand = new G4UIcommand ("/vis/scene/rem << 477 fpCommand = new G4UIcmdWithAString ("/vis/scene/remove", this);
803 fpCommand -> SetGuidance("Remove model."); << 478 fpCommand -> SetGuidance ("/vis/scene/remove <scene-name>");
804 fpCommand -> SetGuidance << 479 fpCommand -> SetGuidance ("Removes scenes.");
805 ("Attempts to match search string to name of <<
806 fpCommand -> SetGuidance 480 fpCommand -> SetGuidance
807 ("Use \"/vis/scene/list\" to see model names << 481 ("/vis/scene/list to see possibilities.");
808 G4UIparameter* parameter; << 482 fpCommand -> SetParameterName ("scene-name",
809 parameter = new G4UIparameter ("search-strin << 483 omitable = false,
810 fpCommand -> SetParameter (parameter); << 484 currentAsDefault = true);
>> 485 sceneNameCommands.push_back (fpCommand);
811 } 486 }
812 487
813 G4VisCommandSceneRemoveModel::~G4VisCommandSce << 488 G4VisCommandSceneRemove::~G4VisCommandSceneRemove () {
814 delete fpCommand; 489 delete fpCommand;
815 } 490 }
816 491
817 G4String G4VisCommandSceneRemoveModel::GetCurr << 492 G4String G4VisCommandSceneRemove::GetCurrentValue (G4UIcommand* command) {
818 return ""; << 493 return CurrentSceneName ();
819 } 494 }
820 495
821 void G4VisCommandSceneRemoveModel::SetNewValue << 496 void G4VisCommandSceneRemove::SetNewValue (G4UIcommand* command,
822 G4String newValue) { << 497 G4String newValue) {
823 498
824 G4VisManager::Verbosity verbosity = fpVisMan 499 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
825 500
826 G4String searchString; << 501 G4String& removeName = newValue;
827 std::istringstream is (newValue); << 502 const G4String& currentSceneName =
828 is >> searchString; << 503 fpVisManager -> GetCurrentScene () -> GetName ();
829 << 504 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
830 G4Scene* pScene = fpVisManager->GetCurrentSc << 505 G4SceneListIterator iScene;
831 if (!pScene) { << 506 for (iScene = sceneList.begin(); iScene != sceneList.end(); ++iScene) {
832 if (verbosity >= G4VisManager::errors) { << 507 if ((*iScene) -> GetName () == removeName) break;
833 G4warn << "ERROR: No current scene. Ple << 508 }
834 } << 509 if (iScene != sceneList.end()) {
835 return; << 510 delete *iScene;
836 } << 511 sceneList.erase (iScene);
837 << 512 if (verbosity >= G4VisManager::confirmations) {
838 G4VSceneHandler* pSceneHandler = fpVisManage << 513 G4cout << "Scene \"" << removeName << "\" removed." << G4endl;
839 if (!pSceneHandler) { <<
840 if (verbosity >= G4VisManager::errors) { <<
841 G4warn << "ERROR: No current sceneHandle <<
842 } 514 }
843 return; << 515 UpdateCandidateLists ();
844 } << 516 if (sceneList.empty ()) {
845 <<
846 G4bool any = false; <<
847 <<
848 std::vector<G4Scene::Model>& runDurationMode <<
849 pScene->SetRunDurationModelList(); <<
850 for (size_t i = 0; i < runDurationModelList. <<
851 const G4String& modelName = <<
852 runDurationModelList[i].fpModel->GetGlobal <<
853 if (modelName.find(searchString) != std::s <<
854 runDurationModelList.erase(runDurationMo <<
855 any = true; <<
856 if (verbosity >= G4VisManager::warnings) 517 if (verbosity >= G4VisManager::warnings) {
857 G4warn << "Model \"" << modelName << "\" rem << 518 G4cout << "WARNING: No scenes left. Please create a new one."
>> 519 << G4endl;
858 } 520 }
859 break; // Allow only one model at a tim << 521 UpdateVisManagerScene ();
860 } 522 }
861 } << 523 else {
862 << 524 if (currentSceneName == removeName) {
863 std::vector<G4Scene::Model>& endOfEventModel << 525 if (verbosity >= G4VisManager::warnings) {
864 pScene->SetEndOfEventModelList(); << 526 G4cout << "WARNING: Current scene is now \""
865 for (size_t i = 0; i < endOfEventModelList.s << 527 << fpVisManager -> GetCurrentScene () -> GetName ()
866 const G4String& modelName = << 528 << "\"" << G4endl;
867 endOfEventModelList[i].fpModel->GetGlobalD << 529 }
868 if (modelName.find(searchString) != std::s << 530 UpdateVisManagerScene (sceneList [0] -> GetName ());
869 endOfEventModelList.erase(endOfEventMode <<
870 any = true; <<
871 if (verbosity >= G4VisManager::warnings) <<
872 G4warn << "Model \"" << modelName << "\" rem <<
873 } 531 }
874 break; // Allow only one model at a tim << 532 else {
875 } << 533 if (verbosity >= G4VisManager::confirmations) {
876 } << 534 G4cout << "Current scene unchanged." << G4endl;
877 << 535 }
878 std::vector<G4Scene::Model>& endOfRunModelLi <<
879 pScene->SetEndOfRunModelList(); <<
880 for (size_t i = 0; i < endOfRunModelList.siz <<
881 const G4String& modelName = <<
882 endOfRunModelList[i].fpModel->GetGlobalDes <<
883 if (modelName.find(searchString) != std::s <<
884 endOfRunModelList.erase(endOfRunModelLis <<
885 any = true; <<
886 if (verbosity >= G4VisManager::warnings) <<
887 G4warn << "Model \"" << modelName << "\" rem <<
888 } 536 }
889 break; // Allow only one model at a tim <<
890 } 537 }
891 } 538 }
892 << 539 else {
893 if (!any) { <<
894 if (verbosity >= G4VisManager::warnings) { 540 if (verbosity >= G4VisManager::warnings) {
895 G4warn << "WARNING: No match found." << << 541 G4cout << "WARNING: Scene \"" << removeName
>> 542 << "\" not found - \"/vis/scene/list\" to see possibilities."
>> 543 << G4endl;
896 } 544 }
897 return; <<
898 } 545 }
899 <<
900 CheckSceneAndNotifyHandlers (pScene); <<
901 } 546 }
902 547
903 ////////////// /vis/scene/select ///////////// 548 ////////////// /vis/scene/select ///////////////////////////////////////
904 549
905 G4VisCommandSceneSelect::G4VisCommandSceneSele 550 G4VisCommandSceneSelect::G4VisCommandSceneSelect () {
906 G4bool omitable; << 551 G4bool omitable, currentAsDefault;
907 fpCommand = new G4UIcmdWithAString ("/vis/sc 552 fpCommand = new G4UIcmdWithAString ("/vis/scene/select", this);
908 fpCommand -> SetGuidance ("Selects a scene") << 553 fpCommand -> SetGuidance ("/vis/scene/select [<scene-name>]");
>> 554 fpCommand -> SetGuidance ("Selects current scene.");
909 fpCommand -> SetGuidance 555 fpCommand -> SetGuidance
910 ("Makes the scene current. \"/vis/scene/lis << 556 ("Specify scene by name (\"/vis/scene/list\" to see possibilities).");
911 "\n possible scene names."); << 557 fpCommand -> SetParameterName ("scene-name",
912 fpCommand -> SetParameterName ("scene-name", << 558 omitable = true,
>> 559 currentAsDefault = true);
>> 560 sceneNameCommands.push_back (fpCommand);
913 } 561 }
914 562
915 G4VisCommandSceneSelect::~G4VisCommandSceneSel 563 G4VisCommandSceneSelect::~G4VisCommandSceneSelect () {
916 delete fpCommand; 564 delete fpCommand;
917 } 565 }
918 566
919 G4String G4VisCommandSceneSelect::GetCurrentVa << 567 G4String G4VisCommandSceneSelect::GetCurrentValue (G4UIcommand* command) {
920 return ""; << 568 return CurrentSceneName ();
921 } 569 }
922 570
923 void G4VisCommandSceneSelect::SetNewValue (G4U << 571 void G4VisCommandSceneSelect::SetNewValue (G4UIcommand* command,
>> 572 G4String newValue) {
924 573
925 G4VisManager::Verbosity verbosity = fpVisMan 574 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
926 575
927 G4String& selectName = newValue; 576 G4String& selectName = newValue;
928 G4SceneList& sceneList = fpVisManager -> Set 577 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
929 std::size_t iScene, nScenes = sceneList.size << 578 G4int iScene, nScenes = sceneList.size ();
930 for (iScene = 0; iScene < nScenes; ++iScene) << 579 for (iScene = 0; iScene < nScenes; iScene++) {
931 if (sceneList [iScene] -> GetName () == se 580 if (sceneList [iScene] -> GetName () == selectName) break;
932 } 581 }
933 if (iScene >= nScenes) { 582 if (iScene >= nScenes) {
934 if (verbosity >= G4VisManager::warnings) { 583 if (verbosity >= G4VisManager::warnings) {
935 G4warn << "WARNING: Scene \"" << selectN << 584 G4cout << "WARNING: Scene \"" << selectName
936 << "\" not found - \"/vis/scene/list\" t << 585 << "\" not found - \"/vis/scene/list\" to see possibilities."
937 << G4endl; << 586 << G4endl;
938 } 587 }
939 return; 588 return;
940 } 589 }
941 590
942 if (verbosity >= G4VisManager::confirmations 591 if (verbosity >= G4VisManager::confirmations) {
943 G4cout << "Scene \"" << selectName 592 G4cout << "Scene \"" << selectName
944 << "\" selected." << G4endl; << 593 << "\" selected." << G4endl;
945 } <<
946 <<
947 CheckSceneAndNotifyHandlers (sceneList [iSce <<
948 } <<
949 <<
950 ////////////// /vis/scene/showExtents //////// <<
951 <<
952 G4VisCommandSceneShowExtents::G4VisCommandScen <<
953 fpCommand = new G4UIcmdWithoutParameter ("/v <<
954 fpCommand -> SetGuidance ("Prints and draws <<
955 } <<
956 <<
957 G4VisCommandSceneShowExtents::~G4VisCommandSce <<
958 delete fpCommand; <<
959 } <<
960 <<
961 G4String G4VisCommandSceneShowExtents::GetCurr <<
962 return ""; <<
963 } <<
964 <<
965 void G4VisCommandSceneShowExtents::SetNewValue <<
966 <<
967 G4VisManager::Verbosity verbosity = fpVisMan <<
968 <<
969 G4VSceneHandler* pCurrentSceneHandler = <<
970 fpVisManager -> GetCurrentSceneHandler(); <<
971 if (!pCurrentSceneHandler) { <<
972 if (verbosity >= G4VisManager::warnings) { <<
973 G4warn << "WARNING: No current scene han <<
974 << G4endl; <<
975 } <<
976 return; <<
977 } <<
978 G4VViewer* pCurrentViewer = fpVisManager -> <<
979 if (!pCurrentViewer) { <<
980 if (verbosity >= G4VisManager::warnings) { <<
981 G4warn << "WARNING: No current viewer." <<
982 << G4endl; <<
983 } <<
984 return; <<
985 } <<
986 G4Scene* pCurrentScene = fpVisManager -> Get <<
987 if (!pCurrentScene) { <<
988 if (verbosity >= G4VisManager::warnings) { <<
989 G4warn << "WARNING: No current scene." <<
990 << G4endl; <<
991 } <<
992 return; <<
993 } 594 }
>> 595 UpdateVisManagerScene (selectName);
994 596
995 G4cout << "\n Run-duration models:"; <<
996 std::size_t nRunModels = pCurrentScene -> Ge <<
997 if (nRunModels == 0) { <<
998 G4cout << " none."; <<
999 } <<
1000 for (std::size_t i = 0; i < nRunModels; ++i <<
1001 if (pCurrentScene -> GetRunDurationModelL <<
1002 G4cout << "\n Active: "; <<
1003 else G4cout << "\n Inactive: "; <<
1004 G4VModel* pModel = pCurrentScene -> GetRu <<
1005 const G4VisExtent& transformedExtent = pM <<
1006 G4cout << pModel -> GetGlobalDescription <<
1007 << "\n" << transformedExtent; <<
1008 DrawExtent(transformedExtent); <<
1009 } <<
1010 G4cout << "\n End-of-event models:"; <<
1011 std::size_t nEOEModels = pCurrentScene -> G <<
1012 if (nEOEModels == 0) { <<
1013 G4cout << " none."; <<
1014 } <<
1015 for (std::size_t i = 0; i < nEOEModels; ++i <<
1016 if (pCurrentScene -> GetEndOfEventModelLi <<
1017 G4cout << "\n Active: "; <<
1018 else G4cout << "\n Inactive: "; <<
1019 G4VModel* pModel = pCurrentScene -> GetEn <<
1020 const G4VisExtent& transformedExtent = pM <<
1021 G4cout << pModel -> GetGlobalDescription <<
1022 << "\n" << transformedExtent; <<
1023 DrawExtent(transformedExtent); <<
1024 } <<
1025 G4cout << "\n End-of-run models:"; <<
1026 std::size_t nEORModels = pCurrentScene -> G <<
1027 if (nEORModels == 0) { <<
1028 G4cout << " none."; <<
1029 } <<
1030 for (std::size_t i = 0; i < nEORModels; ++i <<
1031 if (pCurrentScene -> GetEndOfRunModelList <<
1032 G4cout << "\n Active: "; <<
1033 else G4cout << "\n Inactive: "; <<
1034 G4VModel* pModel = pCurrentScene -> GetEn <<
1035 const G4VisExtent& transformedExtent = pM <<
1036 G4cout << pModel -> GetGlobalDescription <<
1037 << "\n" << transformedExtent; <<
1038 DrawExtent(transformedExtent); <<
1039 } <<
1040 G4cout << "\n Overall extent:\n"; <<
1041 DrawExtent(pCurrentScene->GetExtent()); <<
1042 G4cout << G4endl; <<
1043 } 597 }
1044 598