| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // <<
26 // 7 //
>> 8 // $Id: G4VisCommandsScene.cc,v 1.15 2000/05/29 09:21:40 johna Exp $
>> 9 // GEANT4 tag $Name: geant4-02-00 $
27 10
28 // /vis/scene commands - John Allison 9th Aug 11 // /vis/scene commands - John Allison 9th August 1998
29 12
30 #include "G4VisCommandsScene.hh" 13 #include "G4VisCommandsScene.hh"
31 14
32 #include "G4VisManager.hh" 15 #include "G4VisManager.hh"
33 #include "G4TransportationManager.hh" 16 #include "G4TransportationManager.hh"
34 #include "G4RunManager.hh" <<
35 #include "G4RunManagerFactory.hh" <<
36 #include "G4Run.hh" <<
37 #include "G4PhysicalVolumeModel.hh" 17 #include "G4PhysicalVolumeModel.hh"
38 #include "G4ApplicationState.hh" 18 #include "G4ApplicationState.hh"
39 #include "G4UImanager.hh" 19 #include "G4UImanager.hh"
40 #include "G4UIcommand.hh" 20 #include "G4UIcommand.hh"
41 #include "G4UIcmdWithAString.hh" 21 #include "G4UIcmdWithAString.hh"
42 #include "G4UIcmdWithoutParameter.hh" <<
43 #include "G4ios.hh" 22 #include "G4ios.hh"
44 #include <sstream> << 23 #include "g4std/strstream"
45 <<
46 #define G4warn G4cout <<
47 24
48 G4VVisCommandScene::G4VVisCommandScene () {} 25 G4VVisCommandScene::G4VVisCommandScene () {}
49 26
50 G4VVisCommandScene::~G4VVisCommandScene () {} 27 G4VVisCommandScene::~G4VVisCommandScene () {}
51 28
52 G4String G4VVisCommandScene::CurrentSceneName 29 G4String G4VVisCommandScene::CurrentSceneName () {
53 const G4Scene* pScene = fpVisManager -> GetC 30 const G4Scene* pScene = fpVisManager -> GetCurrentScene ();
54 G4String currentSceneName = "none"; << 31 G4String currentSceneName;
55 if (pScene) currentSceneName = pScene -> Get 32 if (pScene) currentSceneName = pScene -> GetName ();
56 return currentSceneName; 33 return currentSceneName;
57 } 34 }
58 35
59 ////////////// /vis/scene/activateModel ////// << 36 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 <<
154 std::vector<G4Scene::Model>& runDurationMode <<
155 pScene->SetRunDurationModelList(); <<
156 for (size_t i = 0; i < runDurationModelList. <<
157 const G4String& modelName = runDurationMod <<
158 if (searchString == "all" || modelName.fin <<
159 any = true; <<
160 runDurationModelList[i].fActive = activa <<
161 if (verbosity >= G4VisManager::warnings) <<
162 G4warn << "Model \"" << modelName; <<
163 if (activate) G4warn << "\" activated."; <<
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 37
186 std::vector<G4Scene::Model>& endOfRunModelLi << 38 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
187 pScene->SetEndOfRunModelList(); << 39 G4int iScene, nScenes = sceneList.entries ();
188 for (size_t i = 0; i < endOfRunModelList.siz << 40 G4String nameList;
189 const G4String& modelName = endOfRunModelL << 41 for (iScene = 0; iScene < nScenes; iScene++) {
190 if (searchString == "all" || modelName.fin << 42 nameList += sceneList [iScene] -> GetName () + " ";
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 } 43 }
201 << 44 nameList = nameList.strip ();
202 if (!any) { << 45 sceneNameCommandsIterator i;
203 if (verbosity >= G4VisManager::warnings) { << 46 for (i = sceneNameCommands.begin (); i != sceneNameCommands.end (); ++i) {
204 G4warn << "WARNING: No match found." << << 47 (*i)->GetParameter (0) -> SetParameterCandidates (nameList);
205 } <<
206 return; <<
207 } 48 }
>> 49 }
208 50
209 CheckSceneAndNotifyHandlers (pScene); << 51 void G4VVisCommandScene::UpdateVisManagerScene
>> 52 (const G4String& sceneName) {
>> 53 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
>> 54 G4int iScene, nScenes = sceneList.entries ();
>> 55 for (iScene = 0; iScene < nScenes; iScene++) {
>> 56 if (sceneList [iScene] -> GetName () == sceneName) break;
>> 57 }
>> 58 G4Scene* pScene = 0; // Zero unless scene has been found...
>> 59 if (iScene < nScenes) pScene = sceneList [iScene];
>> 60 fpVisManager -> SetCurrentScene (pScene);
210 } 61 }
211 62
212 ////////////// /vis/scene/create ///////////// 63 ////////////// /vis/scene/create ///////////////////////////////////////
213 64
214 G4VisCommandSceneCreate::G4VisCommandSceneCrea 65 G4VisCommandSceneCreate::G4VisCommandSceneCreate (): fId (0) {
215 G4bool omitable; << 66 G4bool omitable, currentAsDefault;
216 fpCommand = new G4UIcmdWithAString ("/vis/sc 67 fpCommand = new G4UIcmdWithAString ("/vis/scene/create", this);
217 fpCommand -> SetGuidance << 68 fpCommand -> SetGuidance ("/vis/scene/create [<scene-name>]");
218 ("Creates an empty scene."); << 69 fpCommand -> SetGuidance ("Creates an empty scene.");
219 fpCommand -> SetGuidance << 70 fpCommand -> SetGuidance ("Invents a name if not supplied.");
220 ("Invents a name if not supplied. This sc << 71 fpCommand -> SetGuidance ("This scene becomes current.");
221 fpCommand -> SetParameterName ("scene-name", << 72 fpCommand -> SetParameterName ("scene-name",
>> 73 omitable = true,
>> 74 currentAsDefault = true);
>> 75 sceneNameCommands.push_back (fpCommand);
222 } 76 }
223 77
224 G4VisCommandSceneCreate::~G4VisCommandSceneCre 78 G4VisCommandSceneCreate::~G4VisCommandSceneCreate () {
225 delete fpCommand; 79 delete fpCommand;
226 } 80 }
227 81
228 G4String G4VisCommandSceneCreate::NextName () 82 G4String G4VisCommandSceneCreate::NextName () {
229 std::ostringstream oss; << 83 char nextName [20];
230 oss << "scene-" << fId; << 84 G4std::ostrstream ost (nextName, 20);
231 return oss.str(); << 85 ost << "scene-" << fId << G4std::ends;
>> 86 return nextName;
232 } 87 }
233 88
234 G4String G4VisCommandSceneCreate::GetCurrentVa << 89 G4String G4VisCommandSceneCreate::GetCurrentValue (G4UIcommand* command) {
235 return ""; << 90 return NextName ();
236 } 91 }
237 92
238 void G4VisCommandSceneCreate::SetNewValue (G4U << 93 void G4VisCommandSceneCreate::SetNewValue (G4UIcommand* command,
239 << 94 G4String newValue) {
240 G4VisManager::Verbosity verbosity = fpVisMan <<
241 <<
242 G4String& newName = newValue; 95 G4String& newName = newValue;
243 G4String nextName = NextName (); 96 G4String nextName = NextName ();
244 97
245 if (newName == "") { 98 if (newName == "") {
246 newName = nextName; 99 newName = nextName;
247 } 100 }
248 if (newName == nextName) fId++; 101 if (newName == nextName) fId++;
249 102
250 G4SceneList& sceneList = fpVisManager -> Set 103 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
251 std::size_t iScene, nScenes = sceneList.size << 104 G4int iScene, nScenes = sceneList.entries ();
252 for (iScene = 0; iScene < nScenes; ++iScene) << 105 for (iScene = 0; iScene < nScenes; iScene++) {
253 if (sceneList [iScene] -> GetName () == ne 106 if (sceneList [iScene] -> GetName () == newName) break;
254 } 107 }
255 if (iScene < nScenes) { 108 if (iScene < nScenes) {
256 if (verbosity >= G4VisManager::warnings) { << 109 G4cout << "Scene \"" << newName << "\" already exists." << G4endl;
257 G4warn << "WARNING: Scene \"" << newName <<
258 << "\n New scene not created." <<
259 << G4endl; <<
260 } <<
261 } else { <<
262 <<
263 // Add empty scene data object to list... <<
264 G4Scene* pScene = new G4Scene (newName); <<
265 sceneList.push_back (pScene); <<
266 fpVisManager -> SetCurrentScene (pScene); <<
267 <<
268 if (verbosity >= G4VisManager::confirmatio <<
269 G4cout << "New empty scene \"" << newNam <<
270 } <<
271 } <<
272 } <<
273 <<
274 ////////////// /vis/scene/endOfEventAction /// <<
275 <<
276 G4VisCommandSceneEndOfEventAction::G4VisComman <<
277 G4bool omitable; <<
278 fpCommand = new G4UIcommand ("/vis/scene/end <<
279 fpCommand -> SetGuidance <<
280 ("Accumulate or refresh the viewer for eac <<
281 fpCommand -> SetGuidance <<
282 ("\"accumulate\": viewer accumulates hits, <<
283 fpCommand -> SetGuidance <<
284 ("\"refresh\": viewer shows them at end of <<
285 "\n viewers, refreshes the screen just b <<
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 } <<
297 <<
298 G4VisCommandSceneEndOfEventAction::~G4VisComma <<
299 delete fpCommand; <<
300 } <<
301 <<
302 G4String G4VisCommandSceneEndOfEventAction::Ge <<
303 return ""; <<
304 } <<
305 <<
306 void G4VisCommandSceneEndOfEventAction::SetNew <<
307 G4String newValue) { <<
308 <<
309 G4VisManager::Verbosity verbosity = fpVisMan <<
310 <<
311 G4String action; <<
312 G4int maxNumberOfKeptEvents; <<
313 std::istringstream is (newValue); <<
314 is >> action >> maxNumberOfKeptEvents; <<
315 <<
316 G4Scene* pScene = fpVisManager->GetCurrentSc <<
317 if (!pScene) { <<
318 if (verbosity >= G4VisManager::errors) { <<
319 G4warn << "ERROR: No current scene. Ple <<
320 } <<
321 return; <<
322 } <<
323 <<
324 G4VSceneHandler* pSceneHandler = fpVisManage <<
325 if (!pSceneHandler) { <<
326 if (verbosity >= G4VisManager::errors) { <<
327 G4warn << "ERROR: No current sceneHandle <<
328 } <<
329 return; <<
330 } <<
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 } 110 }
350 else { 111 else {
351 if (verbosity >= G4VisManager::errors) { <<
352 G4warn << <<
353 "ERROR: unrecognised parameter \"" << action <<
354 << G4endl; <<
355 } <<
356 return; <<
357 } <<
358 112
359 // Change of transients behaviour, so... << 113 sceneList.append (new G4Scene (newName));
360 fpVisManager->ResetTransientsDrawnFlags(); << 114 // Adds empty scene data object to list.
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 115
376 if (verbosity >= G4VisManager::confirmations << 116 UpdateVisManagerScene (newName);
377 G4cout << "End of event action set to "; << 117 G4cout << "New empty scene \"" << newName << "\" created." << G4endl;
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 } <<
387 G4cout << G4endl; <<
388 } <<
389 118
390 if (!pScene->GetRefreshAtEndOfEvent() && << 119 UpdateCandidateLists ();
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 } 120 }
411 } 121 }
412 122
413 ////////////// /vis/scene/endOfRunAction ///// << 123 ////////////// /vis/scene/edit ///////////////////////////////////////
414 124
415 G4VisCommandSceneEndOfRunAction::G4VisCommandS << 125 G4VisCommandSceneEdit::G4VisCommandSceneEdit () {
416 G4bool omitable; << 126 G4bool omitable, currentAsDefault;
417 fpCommand = new G4UIcmdWithAString ("/vis/sc << 127 fpCommand = new G4UIcmdWithAString ("/vis/scene/edit", this);
418 fpCommand -> SetGuidance << 128 fpCommand -> SetGuidance ("/vis/scene/edit [<scene-name>]");
419 ("Accumulate or refresh the viewer for eac << 129 fpCommand -> SetGuidance ("Edits a scene (default current scene).");
420 fpCommand -> SetGuidance << 130 fpCommand -> SetGuidance ("This scene becomes current.");
421 ("\"accumulate\": viewer accumulates hits, << 131 fpCommand -> SetParameterName ("scene-name",
422 fpCommand -> SetGuidance << 132 omitable = true,
423 ("\"refresh\": viewer shows them at end of << 133 currentAsDefault = true);
424 "\n viewers, refreshes the screen just b << 134 sceneNameCommands.push_back (fpCommand);
425 "\n event of the next run."); <<
426 fpCommand -> SetGuidance ("The detector rema <<
427 fpCommand -> SetParameterName ("action", omi <<
428 fpCommand -> SetCandidates ("accumulate refr <<
429 fpCommand -> SetDefaultValue ("refresh"); <<
430 } 135 }
431 136
432 G4VisCommandSceneEndOfRunAction::~G4VisCommand << 137 G4VisCommandSceneEdit::~G4VisCommandSceneEdit () {
433 delete fpCommand; 138 delete fpCommand;
434 } 139 }
435 140
436 G4String G4VisCommandSceneEndOfRunAction::GetC << 141 G4String G4VisCommandSceneEdit::GetCurrentValue (G4UIcommand* command) {
437 return ""; << 142 return CurrentSceneName ();
438 } 143 }
439 144
440 void G4VisCommandSceneEndOfRunAction::SetNewVa << 145 void G4VisCommandSceneEdit::SetNewValue (G4UIcommand* command,
441 G4String newValue) { << 146 G4String newValue) {
442 << 147 G4String sceneName;
443 G4VisManager::Verbosity verbosity = fpVisMan << 148 G4std::istrstream is ((char*)newValue.data());
>> 149 is >> sceneName;
444 150
445 G4String action; << 151 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
446 std::istringstream is (newValue); << 152 G4int iScene, nScenes = sceneList.entries ();
447 is >> action; << 153 G4Scene* pScene;
448 << 154 for (iScene = 0; iScene < nScenes; iScene++) {
449 G4Scene* pScene = fpVisManager->GetCurrentSc << 155 pScene = sceneList [iScene];
450 if (!pScene) { << 156 if (pScene -> GetName () == sceneName) break;
451 if (verbosity >= G4VisManager::errors) { <<
452 G4warn << "ERROR: No current scene. Ple <<
453 } <<
454 return; <<
455 } 157 }
456 << 158 if (iScene >= nScenes) {
457 G4VSceneHandler* pSceneHandler = fpVisManage << 159 G4cout << "G4VisCommandSceneEdit::SetNewValue: Scene \""
458 if (!pSceneHandler) { << 160 << sceneName << "\" not found."
459 if (verbosity >= G4VisManager::errors) { << 161 "\n /vis/scene/list to see scenes."
460 G4warn << "ERROR: No current sceneHandle << 162 << G4endl;
461 } <<
462 return; 163 return;
463 } 164 }
464 <<
465 if (action == "accumulate") { <<
466 if (pScene->GetRefreshAtEndOfEvent()) { <<
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 } <<
478 else if (action == "refresh") { <<
479 pScene->SetRefreshAtEndOfRun(true); <<
480 pSceneHandler->SetMarkForClearingTransient <<
481 } <<
482 else { 165 else {
483 if (verbosity >= G4VisManager::errors) { << 166 G4cout << "Scene \"" << sceneName << "\" contains:" << G4endl;
484 G4warn << << 167 G4String uiCommand ("/vis/scene/list ");
485 "ERROR: unrecognised parameter \"" << action << 168 uiCommand += sceneName;
486 << G4endl; << 169 uiCommand += " 1";
487 } << 170 G4UImanager::GetUIpointer () -> ApplyCommand (uiCommand);
488 return; << 171 G4cout <<
>> 172 "(YOU CAN DO NOTHING YET - /vis/scene/edit FACILITY IN PREPARATION."
>> 173 << G4endl;
489 } 174 }
490 175
491 // Change of transients behaviour, so... << 176 UpdateVisManagerScene (sceneName);
492 fpVisManager->ResetTransientsDrawnFlags(); <<
493 <<
494 if (verbosity >= G4VisManager::confirmations <<
495 G4cout << "End of run action set to \""; <<
496 if (pScene->GetRefreshAtEndOfRun()) G4cout <<
497 else G4cout << "accumulate"; <<
498 G4cout << "\"" << G4endl; <<
499 } <<
500 } 177 }
501 178
502 ////////////// /vis/scene/list /////////////// 179 ////////////// /vis/scene/list ///////////////////////////////////////
503 180
504 G4VisCommandSceneList::G4VisCommandSceneList ( 181 G4VisCommandSceneList::G4VisCommandSceneList () {
505 G4bool omitable; 182 G4bool omitable;
506 fpCommand = new G4UIcommand ("/vis/scene/lis 183 fpCommand = new G4UIcommand ("/vis/scene/list", this);
>> 184 fpCommand -> SetGuidance ("/vis/scene/list [<scene-name>] [<verbosity>]");
507 fpCommand -> SetGuidance ("Lists scene(s).") 185 fpCommand -> SetGuidance ("Lists scene(s).");
>> 186 fpCommand -> SetGuidance ("<scene-name> default is \"all\"");
508 fpCommand -> SetGuidance 187 fpCommand -> SetGuidance
509 ("\"help /vis/verbose\" for definition of << 188 ("<verbosity> is 0/1/2 for short/medium/long listing.");
510 G4UIparameter* parameter; 189 G4UIparameter* parameter;
511 parameter = new G4UIparameter ("scene-name", << 190 parameter = new G4UIparameter ("scene-name", 's',
>> 191 omitable = true);
>> 192 parameter -> SetCurrentAsDefault (false);
512 parameter -> SetDefaultValue ("all"); 193 parameter -> SetDefaultValue ("all");
513 fpCommand -> SetParameter (parameter); 194 fpCommand -> SetParameter (parameter);
514 parameter = new G4UIparameter ("verbosity", << 195 parameter = new G4UIparameter ("verbosity", 'i',
515 parameter -> SetDefaultValue ("warnings"); << 196 omitable = true);
>> 197 parameter -> SetCurrentAsDefault (false);
>> 198 parameter -> SetDefaultValue (0);
516 fpCommand -> SetParameter (parameter); 199 fpCommand -> SetParameter (parameter);
>> 200 sceneNameCommands.push_back (fpCommand);
517 } 201 }
518 202
519 G4VisCommandSceneList::~G4VisCommandSceneList 203 G4VisCommandSceneList::~G4VisCommandSceneList () {
520 delete fpCommand; 204 delete fpCommand;
521 } 205 }
522 206
523 G4String G4VisCommandSceneList::GetCurrentValu << 207 G4String G4VisCommandSceneList::GetCurrentValue (G4UIcommand* command) {
524 return ""; 208 return "";
525 } 209 }
526 210
527 void G4VisCommandSceneList::SetNewValue (G4UIc << 211 void G4VisCommandSceneList::SetNewValue (G4UIcommand* command,
528 G4String name, verbosityString; << 212 G4String newValue) {
529 std::istringstream is (newValue); << 213 G4String name;
530 is >> name >> verbosityString; << 214 G4int verbosity;
531 G4VisManager::Verbosity verbosity = << 215 G4std::istrstream is ((char*)newValue.data());
532 fpVisManager->GetVerbosityValue(verbosityS << 216 is >> name >> verbosity;
533 const G4Scene* currentScene = fpVisManager - <<
534 G4String currentName; <<
535 if (currentScene) currentName = currentScene <<
536 217
537 G4SceneList& sceneList = fpVisManager -> Set 218 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
538 std::size_t iScene, nScenes = sceneList.size << 219 G4int iScene, nScenes = sceneList.entries ();
539 G4bool found = false; 220 G4bool found = false;
540 for (iScene = 0; iScene < nScenes; ++iScene) << 221 for (iScene = 0; iScene < nScenes; iScene++) {
541 G4Scene* pScene = sceneList [iScene]; 222 G4Scene* pScene = sceneList [iScene];
542 const G4String& iName = pScene -> GetName 223 const G4String& iName = pScene -> GetName ();
543 if (name != "all") { 224 if (name != "all") {
544 if (name != iName) continue; 225 if (name != iName) continue;
545 } 226 }
546 found = true; 227 found = true;
547 if (iName == currentName) { << 228 G4cout << "Scene name: \"" << iName << "\"";
548 G4cout << " (current)"; << 229 if (verbosity == 1) {
549 } << 230 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:"; 231 G4cout << "\n Run-duration models:";
557 std::size_t nRunModels = pScene -> GetRu << 232 G4int nRunModels = pScene -> GetRunDurationModelList ().entries ();
558 if (nRunModels == 0) { 233 if (nRunModels == 0) {
559 G4cout << " none."; 234 G4cout << " none.";
560 } 235 }
561 for (i = 0; i < nRunModels; ++i) { << 236 for (i = 0; i < nRunModels; i++) {
562 if (pScene -> GetRunDurationModelList()[i].f << 237 G4VModel* pModel = pScene -> GetRunDurationModelList () [i];
563 G4cout << "\n Active: "; << 238 G4cout << "\n " << pModel -> GetGlobalDescription ();
564 else G4cout << "\n Inactive: "; <<
565 G4VModel* pModel = pScene -> GetRunDurationM <<
566 G4cout << pModel -> GetGlobalDescription (); <<
567 } 239 }
568 G4cout << "\n End-of-event models:"; 240 G4cout << "\n End-of-event models:";
569 std::size_t nEOEModels = pScene -> GetEn << 241 G4int nEOEModels = pScene -> GetEndOfEventModelList ().entries ();
570 if (nEOEModels == 0) { 242 if (nEOEModels == 0) {
571 G4cout << " none."; 243 G4cout << " none.";
572 } 244 }
573 for (i = 0; i < nEOEModels; ++i) { << 245 for (i = 0; i < nEOEModels; i++) {
574 if (pScene -> GetEndOfEventModelList()[i].fA << 246 G4VModel* pModel = pScene -> GetEndOfEventModelList () [i];
575 G4cout << "\n Active: "; << 247 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 } 248 }
592 } 249 }
593 if (verbosity >= G4VisManager::parameters) << 250 if (verbosity >= 2) {
594 G4cout << "\n " << *sceneList [iScene]; 251 G4cout << "\n " << *sceneList [iScene];
595 } 252 }
596 G4cout << G4endl; 253 G4cout << G4endl;
597 } 254 }
598 if (!found) { 255 if (!found) {
599 G4warn << "No scenes found"; << 256 G4cout << "No scenes found";
600 if (name != "all") { 257 if (name != "all") {
601 G4warn << " of name \"" << name << "\""; << 258 G4cout << " of name \"" << name << "\"";
602 } 259 }
603 G4warn << "." << G4endl; << 260 G4cout << "." << G4endl;
604 } 261 }
605 } 262 }
606 263
607 ////////////// /vis/scene/notifyHandlers ///// 264 ////////////// /vis/scene/notifyHandlers /////////////////////////
608 265
609 G4VisCommandSceneNotifyHandlers::G4VisCommandS 266 G4VisCommandSceneNotifyHandlers::G4VisCommandSceneNotifyHandlers () {
610 G4bool omitable; << 267 G4bool omitable, currentAsDefault;
611 fpCommand = new G4UIcommand ("/vis/scene/not << 268 fpCommand = new G4UIcmdWithAString ("/vis/scene/notifyHandlers", this);
>> 269 fpCommand -> SetGuidance ("/vis/scene/notifyHandlers [<scene-name>]");
612 fpCommand -> SetGuidance 270 fpCommand -> SetGuidance
613 ("Notifies scene handlers and forces re-re << 271 ("Notifies scene handlers of possible changes of scene.");
614 fpCommand -> SetGuidance << 272 fpCommand -> SetGuidance ("<scene-name> default is current scene name.");
615 ("Notifies the handler(s) of the specified <<
616 "\nreconstruction of any graphical databa <<
617 "\nClears and refreshes all viewers of cu <<
618 "\n The default action \"refresh\" does <<
619 "\n /vis/viewer/update)." <<
620 "\nIf \"flush\" is specified, it issues a <<
621 "\n \"refresh\" - \"update\" and initiat <<
622 "\n for graphics systems which need it." <<
623 fpCommand -> SetGuidance <<
624 ("The default for <scene-name> is the curr <<
625 fpCommand -> SetGuidance 273 fpCommand -> SetGuidance
626 ("This command does not change current sce 274 ("This command does not change current scene, scene handler or viewer.");
627 G4UIparameter* parameter; << 275 fpCommand -> SetParameterName ("scene-name",
628 parameter = new G4UIparameter ("scene-name", << 276 omitable = true,
629 omitable = true); << 277 currentAsDefault = true);
630 parameter -> SetCurrentAsDefault(true); << 278 sceneNameCommands.push_back (fpCommand);
631 fpCommand -> SetParameter (parameter); <<
632 parameter = new G4UIparameter ("refresh-flus <<
633 omitable = true); <<
634 parameter -> SetDefaultValue("refresh"); <<
635 parameter -> SetParameterCandidates("r refre <<
636 fpCommand -> SetParameter (parameter); <<
637 } 279 }
638 280
639 G4VisCommandSceneNotifyHandlers::~G4VisCommand 281 G4VisCommandSceneNotifyHandlers::~G4VisCommandSceneNotifyHandlers () {
640 delete fpCommand; 282 delete fpCommand;
641 } 283 }
642 284
643 G4String G4VisCommandSceneNotifyHandlers::GetC << 285 G4String G4VisCommandSceneNotifyHandlers::GetCurrentValue
>> 286 (G4UIcommand* command) {
644 return CurrentSceneName (); 287 return CurrentSceneName ();
645 } 288 }
646 289
647 void G4VisCommandSceneNotifyHandlers::SetNewVa << 290 void G4VisCommandSceneNotifyHandlers::SetNewValue (G4UIcommand* command,
648 G4String newValue) { 291 G4String newValue) {
649 << 292 G4String& sceneName = newValue;
650 G4VisManager::Verbosity verbosity = fpVisMan <<
651 <<
652 G4String sceneName, refresh_flush; <<
653 std::istringstream is (newValue); <<
654 is >> sceneName >> refresh_flush; <<
655 G4bool flush = false; <<
656 if (refresh_flush[0] == 'f') flush = true; <<
657 <<
658 const G4SceneList& sceneList = fpVisManager 293 const G4SceneList& sceneList = fpVisManager -> GetSceneList ();
659 G4SceneHandlerList& sceneHandlerList = 294 G4SceneHandlerList& sceneHandlerList =
660 fpVisManager -> SetAvailableSceneHandlers 295 fpVisManager -> SetAvailableSceneHandlers ();
661 296
662 // Check scene name. 297 // Check scene name.
663 const std::size_t nScenes = sceneList.size ( << 298 const G4int nScenes = sceneList.entries ();
664 std::size_t iScene; << 299 G4int iScene;
665 for (iScene = 0; iScene < nScenes; ++iScene) << 300 for (iScene = 0; iScene < nScenes; iScene++) {
666 G4Scene* scene = sceneList [iScene]; 301 G4Scene* scene = sceneList [iScene];
667 if (sceneName == scene -> GetName ()) brea << 302 if (sceneName == scene -> GetName ()) {
668 } << 303 scene -> AddWorldIfEmpty ();
669 if (iScene >= nScenes ) { << 304 break;
670 if (verbosity >= G4VisManager::warnings) { <<
671 G4warn << "WARNING: Scene \"" << sceneNa <<
672 "\n /vis/scene/list to see scenes." <<
673 << G4endl; <<
674 } 305 }
675 return; <<
676 } <<
677 <<
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 } 306 }
696 G4Scene* pCurrentScene = fpVisManager -> Get << 307 if (iScene >= nScenes ) {
697 if (!pCurrentScene) { << 308 G4cout << "Scene \"" << sceneName << "\" not found."
698 if (verbosity >= G4VisManager::warnings) { << 309 "\n /vis/scene/list to see scenes."
699 G4warn << "WARNING: No current scene." << 310 << G4endl;
700 << G4endl; <<
701 } <<
702 return; 311 return;
703 } 312 }
704 313
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 314 // For each scene handler, if it contains the scene, clear and
711 // rebuild the graphical database, then for 315 // rebuild the graphical database, then for each viewer set (make
712 // current), clear, (re)draw, and show. 316 // current), clear, (re)draw, and show.
713 const std::size_t nSceneHandlers = sceneHand << 317 const G4int nSceneHandlers = sceneHandlerList.entries ();
714 for (std::size_t iSH = 0; iSH < nSceneHandle << 318 for (G4int iSH = 0; iSH < nSceneHandlers; iSH++) {
715 G4VSceneHandler* aSceneHandler = sceneHand 319 G4VSceneHandler* aSceneHandler = sceneHandlerList [iSH];
716 G4Scene* aScene = aSceneHandler -> GetScen 320 G4Scene* aScene = aSceneHandler -> GetScene ();
717 if (aScene) { 321 if (aScene) {
718 const G4String& aSceneName = aScene -> G 322 const G4String& aSceneName = aScene -> GetName ();
719 if (sceneName == aSceneName) { 323 if (sceneName == aSceneName) {
720 aScene->CalculateExtent(); // Check and rec << 324 aSceneHandler -> ClearStore ();
>> 325 aSceneHandler -> ClearTransientStore ();
721 G4ViewerList& viewerList = aSceneHandler -> 326 G4ViewerList& viewerList = aSceneHandler -> SetViewerList ();
722 const std::size_t nViewers = viewerList.size << 327 const G4int nViewers = viewerList.entries ();
723 for (std::size_t iV = 0; iV < nViewers; ++iV << 328 for (G4int iV = 0; iV < nViewers; iV++) {
724 G4VViewer* aViewer = viewerList [iV]; 329 G4VViewer* aViewer = viewerList [iV];
725 // Force rebuild of graphical database, if << 330 aViewer -> ClearView ();
726 aViewer -> NeedKernelVisit(); << 331 aViewer -> DrawView ();
727 if (aViewer->GetViewParameters().IsAutoRef << 332 // Triggers rebuild of graphical database by notifying the scene
728 aSceneHandler -> SetCurrentViewer (aView << 333 // handler. The viewer is supposed to be smart enough to know
729 // Ensure consistency of vis manager... << 334 // when not to do this. E.g., the second viewer of a scene
730 fpVisManager -> SetCurrentViewer(aViewer << 335 // handler does not do it.
731 fpVisManager -> SetCurrentSceneHandler(a << 336 G4cout << "Viewer \"" << aViewer -> GetName ()
732 fpVisManager -> SetCurrentScene(aScene); << 337 << "\" of scene handler \"" << aSceneHandler -> GetName ()
733 aViewer -> SetView (); << 338 << "\"\n prepared at request of scene \"" << sceneName
734 aViewer -> ClearView (); << 339 << "\"." << G4endl;
735 aViewer -> DrawView (); <<
736 if (flush) aViewer -> ShowView (); <<
737 if (verbosity >= G4VisManager::confirmat <<
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 } <<
761 } 340 }
762 } 341 }
763 } 342 }
764 else { 343 else {
765 if (verbosity >= G4VisManager::warnings) << 344 G4cout << "G4VisCommandSceneNotifyHandlers: scene handler \""
766 G4warn << "WARNING: G4VisCommandSceneNotifyH << 345 << aSceneHandler->GetName()
767 << aSceneHandler->GetName() << 346 << "\" has a null scene."
768 << "\" has a null scene." <<
769 << G4endl; 347 << G4endl;
770 } <<
771 } <<
772 } <<
773 <<
774 // Reclaim original context - but set viewer <<
775 // handler, because the latter might have be <<
776 // and, not yet having a viewer, the current <<
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) { <<
786 G4ViewerList& viewerList = pCurrentSceneHa <<
787 const std::size_t nViewers = viewerList.si <<
788 if (nViewers) { <<
789 pCurrentSceneHandler -> SetCurrentViewer <<
790 // JA: I don't think we need this. SetVi <<
791 // if (pCurrentViewer && pCurrentSceneHa <<
792 // pCurrentViewer -> SetView (); <<
793 // } <<
794 } 348 }
795 } 349 }
796 } 350 }
797 351
798 ////////////// /vis/scene/removeModel //////// << 352 ////////////// /vis/scene/remove ///////////////////////////////////////
799 353
800 G4VisCommandSceneRemoveModel::G4VisCommandScen << 354 G4VisCommandSceneRemove::G4VisCommandSceneRemove () {
801 G4bool omitable; << 355 G4bool omitable, currentAsDefault;
802 fpCommand = new G4UIcommand ("/vis/scene/rem << 356 fpCommand = new G4UIcmdWithAString ("/vis/scene/remove", this);
803 fpCommand -> SetGuidance("Remove model."); << 357 fpCommand -> SetGuidance ("/vis/scene/remove <scene-name>");
804 fpCommand -> SetGuidance << 358 fpCommand -> SetGuidance ("Removes scenes.");
805 ("Attempts to match search string to name of << 359 fpCommand -> SetGuidance
806 fpCommand -> SetGuidance << 360 ("/vis/scene/list to see possibilities.");
807 ("Use \"/vis/scene/list\" to see model names << 361 fpCommand -> SetParameterName ("scene-name",
808 G4UIparameter* parameter; << 362 omitable = false,
809 parameter = new G4UIparameter ("search-strin << 363 currentAsDefault = true);
810 fpCommand -> SetParameter (parameter); << 364 sceneNameCommands.push_back (fpCommand);
811 } 365 }
812 366
813 G4VisCommandSceneRemoveModel::~G4VisCommandSce << 367 G4VisCommandSceneRemove::~G4VisCommandSceneRemove () {
814 delete fpCommand; 368 delete fpCommand;
815 } 369 }
816 370
817 G4String G4VisCommandSceneRemoveModel::GetCurr << 371 G4String G4VisCommandSceneRemove::GetCurrentValue (G4UIcommand* command) {
818 return ""; << 372 return CurrentSceneName ();
819 } 373 }
820 374
821 void G4VisCommandSceneRemoveModel::SetNewValue << 375 void G4VisCommandSceneRemove::SetNewValue (G4UIcommand* command,
822 G4String newValue) { << 376 G4String newValue) {
823 << 377 G4String& removeName = newValue;
824 G4VisManager::Verbosity verbosity = fpVisMan << 378 const G4String& currentSceneName =
825 << 379 fpVisManager -> GetCurrentScene () -> GetName ();
826 G4String searchString; << 380 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
827 std::istringstream is (newValue); << 381 G4int iScene, nScenes = sceneList.entries ();
828 is >> searchString; << 382 for (iScene = 0; iScene < nScenes; iScene++) {
829 << 383 if (sceneList [iScene] -> GetName () == removeName) break;
830 G4Scene* pScene = fpVisManager->GetCurrentSc <<
831 if (!pScene) { <<
832 if (verbosity >= G4VisManager::errors) { <<
833 G4warn << "ERROR: No current scene. Ple <<
834 } <<
835 return; <<
836 } <<
837 <<
838 G4VSceneHandler* pSceneHandler = fpVisManage <<
839 if (!pSceneHandler) { <<
840 if (verbosity >= G4VisManager::errors) { <<
841 G4warn << "ERROR: No current sceneHandle <<
842 } <<
843 return; <<
844 } 384 }
845 << 385 if (iScene < nScenes) {
846 G4bool any = false; << 386 delete sceneList [iScene];
847 << 387 sceneList.removeAt (iScene);
848 std::vector<G4Scene::Model>& runDurationMode << 388 G4cout << "Scene \"" << removeName << "\" removed." << G4endl;
849 pScene->SetRunDurationModelList(); << 389 UpdateCandidateLists ();
850 for (size_t i = 0; i < runDurationModelList. << 390 if (sceneList.isEmpty ()) {
851 const G4String& modelName = << 391 UpdateVisManagerScene ();
852 runDurationModelList[i].fpModel->GetGlobal << 392 G4cout << "No scenes left. Please create a new one." << G4endl;
853 if (modelName.find(searchString) != std::s <<
854 runDurationModelList.erase(runDurationMo <<
855 any = true; <<
856 if (verbosity >= G4VisManager::warnings) <<
857 G4warn << "Model \"" << modelName << "\" rem <<
858 } <<
859 break; // Allow only one model at a tim <<
860 } 393 }
861 } << 394 else {
862 << 395 if (currentSceneName == removeName) {
863 std::vector<G4Scene::Model>& endOfEventModel << 396 UpdateVisManagerScene (sceneList [0] -> GetName ());
864 pScene->SetEndOfEventModelList(); << 397 G4cout << "Current scene is now \""
865 for (size_t i = 0; i < endOfEventModelList.s << 398 << fpVisManager -> GetCurrentScene () -> GetName ()
866 const G4String& modelName = << 399 << "\"" << G4endl;
867 endOfEventModelList[i].fpModel->GetGlobalD <<
868 if (modelName.find(searchString) != std::s <<
869 endOfEventModelList.erase(endOfEventMode <<
870 any = true; <<
871 if (verbosity >= G4VisManager::warnings) <<
872 G4warn << "Model \"" << modelName << "\" rem <<
873 } 400 }
874 break; // Allow only one model at a tim << 401 else {
875 } << 402 G4cout << "Current scene unchanged." << G4endl;
876 } <<
877 <<
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 } 403 }
889 break; // Allow only one model at a tim <<
890 } 404 }
891 } 405 }
892 << 406 else {
893 if (!any) { << 407 G4cout << "Scene \"" << removeName
894 if (verbosity >= G4VisManager::warnings) { << 408 << "\" not found - \"/vis/scene/list\" to see possibilities."
895 G4warn << "WARNING: No match found." << << 409 << G4endl;
896 } <<
897 return; <<
898 } 410 }
899 <<
900 CheckSceneAndNotifyHandlers (pScene); <<
901 } 411 }
902 412
903 ////////////// /vis/scene/select ///////////// 413 ////////////// /vis/scene/select ///////////////////////////////////////
904 414
905 G4VisCommandSceneSelect::G4VisCommandSceneSele 415 G4VisCommandSceneSelect::G4VisCommandSceneSelect () {
906 G4bool omitable; << 416 G4bool omitable, currentAsDefault;
907 fpCommand = new G4UIcmdWithAString ("/vis/sc 417 fpCommand = new G4UIcmdWithAString ("/vis/scene/select", this);
908 fpCommand -> SetGuidance ("Selects a scene") << 418 fpCommand -> SetGuidance ("/vis/scene/select [<scene-name>]");
>> 419 fpCommand -> SetGuidance ("Selects current scene.");
909 fpCommand -> SetGuidance 420 fpCommand -> SetGuidance
910 ("Makes the scene current. \"/vis/scene/lis << 421 ("Specify scene by name (\"/vis/scene/list\" to see possibilities).");
911 "\n possible scene names."); << 422 fpCommand -> SetParameterName ("scene-name",
912 fpCommand -> SetParameterName ("scene-name", << 423 omitable = true,
>> 424 currentAsDefault = true);
>> 425 sceneNameCommands.push_back (fpCommand);
913 } 426 }
914 427
915 G4VisCommandSceneSelect::~G4VisCommandSceneSel 428 G4VisCommandSceneSelect::~G4VisCommandSceneSelect () {
916 delete fpCommand; 429 delete fpCommand;
917 } 430 }
918 431
919 G4String G4VisCommandSceneSelect::GetCurrentVa << 432 G4String G4VisCommandSceneSelect::GetCurrentValue (G4UIcommand* command) {
920 return ""; << 433 return CurrentSceneName ();
921 } 434 }
922 435
923 void G4VisCommandSceneSelect::SetNewValue (G4U << 436 void G4VisCommandSceneSelect::SetNewValue (G4UIcommand* command,
924 << 437 G4String newValue) {
925 G4VisManager::Verbosity verbosity = fpVisMan <<
926 <<
927 G4String& selectName = newValue; 438 G4String& selectName = newValue;
928 G4SceneList& sceneList = fpVisManager -> Set 439 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
929 std::size_t iScene, nScenes = sceneList.size << 440 G4int iScene, nScenes = sceneList.entries ();
930 for (iScene = 0; iScene < nScenes; ++iScene) << 441 for (iScene = 0; iScene < nScenes; iScene++) {
931 if (sceneList [iScene] -> GetName () == se 442 if (sceneList [iScene] -> GetName () == selectName) break;
932 } 443 }
933 if (iScene >= nScenes) { << 444 G4cout << "Scene \"" << selectName;
934 if (verbosity >= G4VisManager::warnings) { << 445 if (iScene < nScenes) {
935 G4warn << "WARNING: Scene \"" << selectN << 446 UpdateVisManagerScene (selectName);
936 << "\" not found - \"/vis/scene/list\" t << 447 G4cout << "\" selected." << G4endl;
937 << G4endl; <<
938 } <<
939 return; <<
940 } <<
941 <<
942 if (verbosity >= G4VisManager::confirmations <<
943 G4cout << "Scene \"" << selectName <<
944 << "\" 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 } 448 }
986 G4Scene* pCurrentScene = fpVisManager -> Get << 449 else {
987 if (!pCurrentScene) { << 450 G4cout << "\" not found - \"/vis/scene/list\" to see possibilities."
988 if (verbosity >= G4VisManager::warnings) { << 451 << G4endl;
989 G4warn << "WARNING: No current scene." <<
990 << G4endl; <<
991 } <<
992 return; <<
993 } 452 }
994 <<
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 } 453 }
1044 454