| 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 // 7 //
26 // G4UIcontrolMessenger << 8 // $Id: G4UIcontrolMessenger.cc,v 1.1.10.1 1999/12/07 20:49:03 gunter Exp $
>> 9 // GEANT4 tag $Name: geant4-01-00 $
27 // 10 //
28 // Author: Makoto Asai, SLAC - 2001 <<
29 // ------------------------------------------- <<
30 11
31 #include "G4UIcontrolMessenger.hh" 12 #include "G4UIcontrolMessenger.hh"
32 << 13 #include "G4UImanager.hh"
33 #include "G4StateManager.hh" << 14 #include "G4UIdirectory.hh"
34 #include "G4Tokenizer.hh" <<
35 #include "G4UIaliasList.hh" <<
36 #include "G4UIcmdWithABool.hh" <<
37 #include "G4UIcmdWithAString.hh" 15 #include "G4UIcmdWithAString.hh"
38 #include "G4UIcmdWithAnInteger.hh" 16 #include "G4UIcmdWithAnInteger.hh"
39 #include "G4UIcmdWithoutParameter.hh" 17 #include "G4UIcmdWithoutParameter.hh"
40 #include "G4UIcommand.hh" <<
41 #include "G4UIdirectory.hh" <<
42 #include "G4UImanager.hh" <<
43 #include "G4UIparameter.hh" <<
44 #include "G4UIsession.hh" <<
45 #include "G4ios.hh" 18 #include "G4ios.hh"
46 19
47 #include <cstdlib> <<
48 <<
49 // ------------------------------------------- <<
50 G4UIcontrolMessenger::G4UIcontrolMessenger() 20 G4UIcontrolMessenger::G4UIcontrolMessenger()
51 { 21 {
52 controlDirectory = new G4UIdirectory("/contr 22 controlDirectory = new G4UIdirectory("/control/");
53 controlDirectory->SetGuidance("UI control co 23 controlDirectory->SetGuidance("UI control commands.");
54 24
55 macroPathCommand = new G4UIcmdWithAString("/ << 25 ExecuteCommand = new G4UIcmdWithAString("/control/execute",this);
56 macroPathCommand->SetGuidance( <<
57 "Set macro search path" <<
58 " with colon-separated list."); <<
59 macroPathCommand->SetParameterName("path", f <<
60 <<
61 ExecuteCommand = new G4UIcmdWithAString("/co <<
62 ExecuteCommand->SetGuidance("Execute a macro 26 ExecuteCommand->SetGuidance("Execute a macro file.");
63 ExecuteCommand->SetParameterName("fileName", << 27 ExecuteCommand->SetParameterName("fileName",false);
64 ExecuteCommand->SetToBeBroadcasted(false); << 28
65 << 29 verboseCommand = new G4UIcmdWithAnInteger("/control/verbose",this);
66 loopCommand = new G4UIcommand("/control/loop <<
67 loopCommand->SetGuidance("Execute a macro fi <<
68 loopCommand->SetGuidance("Loop counter can b <<
69 auto* param1 = new G4UIparameter("macroFile" <<
70 loopCommand->SetParameter(param1); <<
71 auto* param2 = new G4UIparameter("counterNam <<
72 loopCommand->SetParameter(param2); <<
73 auto* param3 = new G4UIparameter("initialVal <<
74 loopCommand->SetParameter(param3); <<
75 auto* param4 = new G4UIparameter("finalValue <<
76 loopCommand->SetParameter(param4); <<
77 auto* param5 = new G4UIparameter("stepSize", <<
78 param5->SetDefaultValue(1.0); <<
79 loopCommand->SetParameter(param5); <<
80 loopCommand->SetToBeBroadcasted(false); <<
81 <<
82 foreachCommand = new G4UIcommand("/control/f <<
83 foreachCommand->SetGuidance("Execute a macro <<
84 foreachCommand->SetGuidance("Loop counter ca <<
85 foreachCommand->SetGuidance("Values must be <<
86 auto* param6 = new G4UIparameter("macroFile" <<
87 foreachCommand->SetParameter(param6); <<
88 auto* param7 = new G4UIparameter("counterNam <<
89 foreachCommand->SetParameter(param7); <<
90 auto* param8 = new G4UIparameter("valueList" <<
91 foreachCommand->SetParameter(param8); <<
92 foreachCommand->SetToBeBroadcasted(false); <<
93 <<
94 suppressAbortionCommand = new G4UIcmdWithAnI <<
95 suppressAbortionCommand->SetGuidance("Suppre <<
96 suppressAbortionCommand->SetGuidance("Suppre <<
97 suppressAbortionCommand->SetGuidance(" <<
98 suppressAbortionCommand->SetGuidance( <<
99 " = 2 : full suppression, <<
100 "G4Exception"); <<
101 suppressAbortionCommand->SetGuidance( <<
102 "When abortion is suppressed, you will get <<
103 "G4Exception,"); <<
104 suppressAbortionCommand->SetGuidance( <<
105 "and there is NO guarantee for the correct <<
106 "error message."); <<
107 suppressAbortionCommand->SetParameterName("l <<
108 suppressAbortionCommand->SetRange("level >= <<
109 suppressAbortionCommand->SetDefaultValue(0); <<
110 <<
111 verboseCommand = new G4UIcmdWithAnInteger("/ <<
112 verboseCommand->SetGuidance("Applied command 30 verboseCommand->SetGuidance("Applied command will also be shown on screen.");
113 verboseCommand->SetGuidance("This command is 31 verboseCommand->SetGuidance("This command is useful with MACRO file.");
114 verboseCommand->SetGuidance(" 0 : silent"); 32 verboseCommand->SetGuidance(" 0 : silent");
115 verboseCommand->SetGuidance(" 1 : only the 33 verboseCommand->SetGuidance(" 1 : only the valid commands are shown.");
116 verboseCommand->SetGuidance(" 2 : comment l 34 verboseCommand->SetGuidance(" 2 : comment lines are also shown (default).");
117 verboseCommand->SetParameterName("switch", t << 35 verboseCommand->SetParameterName("switch",true);
118 verboseCommand->SetRange("switch >= 0 && swi 36 verboseCommand->SetRange("switch >= 0 && switch <=2");
119 verboseCommand->SetDefaultValue(2); 37 verboseCommand->SetDefaultValue(2);
120 << 38
121 doublePrecCommand = new G4UIcmdWithABool("/c << 39 historyCommand = new G4UIcmdWithAString("/control/saveHistory",this);
122 doublePrecCommand->SetGuidance( <<
123 "Use double precision for printing out the <<
124 doublePrecCommand->SetParameterName("useDoub <<
125 doublePrecCommand->SetDefaultValue(true); <<
126 <<
127 historyCommand = new G4UIcmdWithAString("/co <<
128 historyCommand->SetGuidance("Store command h 40 historyCommand->SetGuidance("Store command history to a file.");
129 historyCommand->SetGuidance("Defaul file nam 41 historyCommand->SetGuidance("Defaul file name is G4history.macro.");
130 historyCommand->SetParameterName("fileName", << 42 historyCommand->SetParameterName("fileName",true);
131 historyCommand->SetDefaultValue("G4History.m 43 historyCommand->SetDefaultValue("G4History.macro");
132 historyCommand->SetToBeBroadcasted(false); << 44
133 << 45 stopStoreHistoryCommand
134 stopStoreHistoryCommand = new G4UIcmdWithout << 46 = new G4UIcmdWithoutParameter("/control/stopSavingHistory",this);
135 stopStoreHistoryCommand->SetGuidance("Stop s 47 stopStoreHistoryCommand->SetGuidance("Stop saving history file.");
136 stopStoreHistoryCommand->SetToBeBroadcasted( <<
137 <<
138 aliasCommand = new G4UIcommand("/control/ali <<
139 aliasCommand->SetGuidance("Set an alias."); <<
140 aliasCommand->SetGuidance("String can be ali <<
141 aliasCommand->SetGuidance("The string may co <<
142 aliasCommand->SetGuidance("the string must b <<
143 aliasCommand->SetGuidance("To use an alias, <<
144 aliasCommand->SetGuidance("parenthesis \"{\" <<
145 auto* aliasNameParam = new G4UIparameter("al <<
146 aliasCommand->SetParameter(aliasNameParam); <<
147 auto* aliasValueParam = new G4UIparameter("a <<
148 aliasCommand->SetParameter(aliasValueParam); <<
149 <<
150 unaliasCommand = new G4UIcmdWithAString("/co <<
151 unaliasCommand->SetGuidance("Remove an alias <<
152 unaliasCommand->SetParameterName("aliasName" <<
153 <<
154 listAliasCommand = new G4UIcmdWithoutParamet <<
155 listAliasCommand->SetGuidance("List aliases. <<
156 <<
157 getEnvCmd = new G4UIcmdWithAString("/control <<
158 getEnvCmd->SetGuidance("Get a shell environm <<
159 getEnvCmd->SetToBeBroadcasted(false); <<
160 <<
161 getValCmd = new G4UIcommand("/control/getVal <<
162 getValCmd->SetGuidance("Get the current valu <<
163 getValCmd->SetGuidance( <<
164 "Command is ignored if the UI command does <<
165 getValCmd->SetGuidance(" Syntax : <alias_nam <<
166 auto* aliName = new G4UIparameter("alias_nam <<
167 getValCmd->SetParameter(aliName); <<
168 auto* comName = new G4UIparameter("UI_comman <<
169 getValCmd->SetParameter(comName); <<
170 auto* iIdxParam = new G4UIparameter("iIdx", <<
171 iIdxParam->SetDefaultValue(0); <<
172 getValCmd->SetParameter(iIdxParam); <<
173 getValCmd->SetToBeBroadcasted(false); <<
174 <<
175 echoCmd = new G4UIcmdWithAString("/control/e <<
176 echoCmd->SetGuidance("Display the valueramet <<
177 echoCmd->SetGuidance("If alias is contained, <<
178 48
179 shellCommand = new G4UIcmdWithAString("/cont << 49 ManualCommand = new G4UIcmdWithAString("/control/manual",this);
180 shellCommand->SetGuidance("Execute a (Unix) <<
181 shellCommand->SetToBeBroadcasted(false); <<
182 <<
183 ManualCommand = new G4UIcmdWithAString("/con <<
184 ManualCommand->SetGuidance("Display all of s 50 ManualCommand->SetGuidance("Display all of sub-directories and commands.");
185 ManualCommand->SetGuidance("Directory path s 51 ManualCommand->SetGuidance("Directory path should be given by FULL-PATH.");
186 ManualCommand->SetParameterName("dirPath", t << 52 ManualCommand->SetParameterName("dirPath",true);
187 ManualCommand->SetDefaultValue("/"); 53 ManualCommand->SetDefaultValue("/");
188 ManualCommand->SetToBeBroadcasted(false); <<
189 <<
190 HTMLCommand = new G4UIcmdWithAString("/contr <<
191 HTMLCommand->SetGuidance("Generate HTML file <<
192 HTMLCommand->SetGuidance("Directory path sho <<
193 HTMLCommand->SetParameterName("dirPath", tru <<
194 HTMLCommand->SetDefaultValue("/"); <<
195 HTMLCommand->SetToBeBroadcasted(false); <<
196 <<
197 maxStoredHistCommand = new G4UIcmdWithAnInte <<
198 maxStoredHistCommand->SetGuidance("Set maxim <<
199 maxStoredHistCommand->SetParameterName("max" <<
200 maxStoredHistCommand->SetDefaultValue(20); <<
201 <<
202 ifCommand = new G4UIcommand("/control/if", t <<
203 ifCommand->SetGuidance("Execute a macro file <<
204 ifCommand->SetGuidance(" Syntax : <double> < <<
205 auto* leftParam = new G4UIparameter("left", <<
206 ifCommand->SetParameter(leftParam); <<
207 auto* compParam = new G4UIparameter("comp", <<
208 compParam->SetParameterCandidates("> >= < <= <<
209 ifCommand->SetParameter(compParam); <<
210 auto* rightParam = new G4UIparameter("right" <<
211 ifCommand->SetParameter(rightParam); <<
212 auto* macroFileParam = new G4UIparameter("ma <<
213 ifCommand->SetParameter(macroFileParam); <<
214 ifCommand->SetToBeBroadcasted(false); <<
215 <<
216 doifCommand = new G4UIcommand("/control/doif <<
217 doifCommand->SetGuidance("Execute a UI comma <<
218 doifCommand->SetGuidance(" Syntax : <double> <<
219 auto* doleftParam = new G4UIparameter("left" <<
220 doifCommand->SetParameter(doleftParam); <<
221 auto* docompParam = new G4UIparameter("comp" <<
222 docompParam->SetParameterCandidates("> >= < <<
223 doifCommand->SetParameter(docompParam); <<
224 auto* dorightParam = new G4UIparameter("righ <<
225 doifCommand->SetParameter(dorightParam); <<
226 auto* comParam = new G4UIparameter("UI_comma <<
227 doifCommand->SetParameter(comParam); <<
228 doifCommand->SetToBeBroadcasted(false); <<
229 <<
230 addCommand = new G4UIcommand("/control/add", <<
231 addCommand->SetGuidance("Define a new alias <<
232 addCommand->SetGuidance(" Syntax : <new_alia <<
233 addCommand->SetGuidance(" <new_alias> may be <<
234 addCommand->SetGuidance(" aliased value is a <<
235 auto* newAlias1 = new G4UIparameter("new_ali <<
236 addCommand->SetParameter(newAlias1); <<
237 auto* val1a = new G4UIparameter("value1", 'd <<
238 addCommand->SetParameter(val1a); <<
239 auto* val1b = new G4UIparameter("value2", 'd <<
240 addCommand->SetParameter(val1b); <<
241 addCommand->SetToBeBroadcasted(false); <<
242 <<
243 subtractCommand = new G4UIcommand("/control/ <<
244 subtractCommand->SetGuidance("Define a new a <<
245 subtractCommand->SetGuidance(" Syntax : <new <<
246 subtractCommand->SetGuidance(" <new_alias> m <<
247 subtractCommand->SetGuidance(" aliased value <<
248 auto* newAlias2 = new G4UIparameter("new_ali <<
249 subtractCommand->SetParameter(newAlias2); <<
250 auto* val2a = new G4UIparameter("value1", 'd <<
251 subtractCommand->SetParameter(val2a); <<
252 auto* val2b = new G4UIparameter("value2", 'd <<
253 subtractCommand->SetParameter(val2b); <<
254 subtractCommand->SetToBeBroadcasted(false); <<
255 <<
256 multiplyCommand = new G4UIcommand("/control/ <<
257 multiplyCommand->SetGuidance("Define a new a <<
258 multiplyCommand->SetGuidance(" Syntax : <new <<
259 multiplyCommand->SetGuidance(" <new_alias> m <<
260 multiplyCommand->SetGuidance(" aliased value <<
261 auto* newAlias3 = new G4UIparameter("new_ali <<
262 multiplyCommand->SetParameter(newAlias3); <<
263 auto* val3a = new G4UIparameter("value1", 'd <<
264 multiplyCommand->SetParameter(val3a); <<
265 auto* val3b = new G4UIparameter("value2", 'd <<
266 multiplyCommand->SetParameter(val3b); <<
267 multiplyCommand->SetToBeBroadcasted(false); <<
268 <<
269 divideCommand = new G4UIcommand("/control/di <<
270 divideCommand->SetGuidance("Define a new ali <<
271 divideCommand->SetGuidance(" Syntax : <new_a <<
272 divideCommand->SetGuidance(" <new_alias> may <<
273 divideCommand->SetGuidance(" aliased value i <<
274 auto* newAlias4 = new G4UIparameter("new_ali <<
275 divideCommand->SetParameter(newAlias4); <<
276 auto* val4a = new G4UIparameter("value1", 'd <<
277 divideCommand->SetParameter(val4a); <<
278 auto* val4b = new G4UIparameter("value2", 'd <<
279 val4b->SetParameterRange("value2 != 0."); <<
280 divideCommand->SetParameter(val4b); <<
281 divideCommand->SetToBeBroadcasted(false); <<
282 <<
283 remainderCommand = new G4UIcommand("/control <<
284 remainderCommand->SetGuidance("Define a new <<
285 remainderCommand->SetGuidance(" Syntax : <ne <<
286 remainderCommand->SetGuidance( <<
287 " <new_alias> may be an already existing a <<
288 remainderCommand->SetGuidance(" aliased valu <<
289 auto* newAlias5 = new G4UIparameter("new_ali <<
290 remainderCommand->SetParameter(newAlias5); <<
291 auto* val5a = new G4UIparameter("value1", 'i <<
292 remainderCommand->SetParameter(val5a); <<
293 auto* val5b = new G4UIparameter("value2", 'i <<
294 val4b->SetParameterRange("value2 != 0"); <<
295 remainderCommand->SetParameter(val5b); <<
296 remainderCommand->SetToBeBroadcasted(false); <<
297 <<
298 strifCommand = new G4UIcommand("/control/str <<
299 strifCommand->SetGuidance("Execute a macro f <<
300 strifCommand->SetGuidance(" Syntax : <string <<
301 auto* strleftParam = new G4UIparameter("left <<
302 strifCommand->SetParameter(strleftParam); <<
303 auto* strcompParam = new G4UIparameter("comp <<
304 strcompParam->SetParameterCandidates("== !=" <<
305 strifCommand->SetParameter(strcompParam); <<
306 auto* strrightParam = new G4UIparameter("rig <<
307 strifCommand->SetParameter(strrightParam); <<
308 auto* strmacroFileParam = new G4UIparameter( <<
309 strifCommand->SetParameter(strmacroFileParam <<
310 strifCommand->SetToBeBroadcasted(false); <<
311 <<
312 strdoifCommand = new G4UIcommand("/control/s <<
313 strdoifCommand->SetGuidance("Execute a UI co <<
314 strdoifCommand->SetGuidance(" Syntax : <stri <<
315 auto* strdoleftParam = new G4UIparameter("le <<
316 strdoifCommand->SetParameter(strdoleftParam) <<
317 auto* strdocompParam = new G4UIparameter("co <<
318 strdocompParam->SetParameterCandidates("== ! <<
319 strdoifCommand->SetParameter(strdocompParam) <<
320 auto* strdorightParam = new G4UIparameter("r <<
321 strdoifCommand->SetParameter(strdorightParam <<
322 auto* strdomacroFileParam = new G4UIparamete <<
323 strdoifCommand->SetParameter(strdomacroFileP <<
324 strdoifCommand->SetToBeBroadcasted(false); <<
325 <<
326 ifBatchCommand = new G4UIcmdWithAString("/co <<
327 ifBatchCommand->SetGuidance("Execute a macro <<
328 ifBatchCommand->SetParameterName("macroFile" <<
329 ifBatchCommand->SetToBeBroadcasted(false); <<
330 <<
331 ifInteractiveCommand = new G4UIcmdWithAStrin <<
332 ifInteractiveCommand->SetGuidance( <<
333 "Execute a macro file if program is runnin <<
334 ifInteractiveCommand->SetParameterName("macr <<
335 ifInteractiveCommand->SetToBeBroadcasted(fal <<
336 <<
337 doifBatchCommand = new G4UIcmdWithAString("/ <<
338 doifBatchCommand->SetGuidance("Execute a UI <<
339 doifBatchCommand->SetParameterName("UIcomman <<
340 doifBatchCommand->SetToBeBroadcasted(false); <<
341 <<
342 doifInteractiveCommand = new G4UIcmdWithAStr <<
343 doifInteractiveCommand->SetGuidance( <<
344 "Execute a UI command if program is runnin <<
345 doifInteractiveCommand->SetParameterName("UI <<
346 doifInteractiveCommand->SetToBeBroadcasted(f <<
347 } 54 }
348 55
349 // ------------------------------------------- <<
350 G4UIcontrolMessenger::~G4UIcontrolMessenger() 56 G4UIcontrolMessenger::~G4UIcontrolMessenger()
351 { 57 {
352 delete macroPathCommand; <<
353 delete ExecuteCommand; 58 delete ExecuteCommand;
354 delete suppressAbortionCommand; <<
355 delete verboseCommand; 59 delete verboseCommand;
356 delete doublePrecCommand; <<
357 delete historyCommand; 60 delete historyCommand;
358 delete stopStoreHistoryCommand; 61 delete stopStoreHistoryCommand;
359 delete ManualCommand; 62 delete ManualCommand;
360 delete aliasCommand; << 63
361 delete unaliasCommand; <<
362 delete listAliasCommand; <<
363 delete getEnvCmd; <<
364 delete getValCmd; <<
365 delete echoCmd; <<
366 delete shellCommand; <<
367 delete loopCommand; <<
368 delete foreachCommand; <<
369 delete HTMLCommand; <<
370 delete maxStoredHistCommand; <<
371 delete ifCommand; <<
372 delete doifCommand; <<
373 delete addCommand; <<
374 delete subtractCommand; <<
375 delete multiplyCommand; <<
376 delete divideCommand; <<
377 delete remainderCommand; <<
378 delete strifCommand; <<
379 delete strdoifCommand; <<
380 delete ifBatchCommand; <<
381 delete ifInteractiveCommand; <<
382 delete doifBatchCommand; <<
383 delete doifInteractiveCommand; <<
384 delete controlDirectory; 64 delete controlDirectory;
385 } 65 }
386 66
387 // ------------------------------------------- << 67 void G4UIcontrolMessenger::SetNewValue(G4UIcommand * command,G4String newValue)
388 void G4UIcontrolMessenger::SetNewValue(G4UIcom <<
389 { 68 {
390 G4UImanager* UI = G4UImanager::GetUIpointer( << 69 G4UImanager * UI = G4UImanager::GetUIpointer();
391 << 70
392 if (command == macroPathCommand) { << 71 if(command==ExecuteCommand)
393 UI->SetMacroSearchPath(newValue); << 72 {
394 UI->ParseMacroSearchPath(); << 73 UI->ExecuteMacroFile(newValue);
395 } <<
396 if (command == ExecuteCommand) { <<
397 command->ResetFailure(); <<
398 UI->ExecuteMacroFile(UI->FindMacroPath(new <<
399 if (UI->GetLastReturnCode() != 0) { <<
400 G4ExceptionDescription ed; <<
401 ed << "Command aborted (" << UI->GetLast <<
402 command->CommandFailed(UI->GetLastReturn <<
403 } <<
404 } <<
405 if (command == suppressAbortionCommand) { <<
406 G4StateManager::GetStateManager()->SetSupp <<
407 suppressAbortionCommand->GetNewIntValue( <<
408 } 74 }
409 if (command == verboseCommand) { << 75 if(command==verboseCommand)
>> 76 {
410 UI->SetVerboseLevel(verboseCommand->GetNew 77 UI->SetVerboseLevel(verboseCommand->GetNewIntValue(newValue));
411 } 78 }
412 if (command == doublePrecCommand) { << 79 if(command==historyCommand)
413 G4UImanager::UseDoublePrecisionStr(doubleP << 80 {
>> 81 UI->StoreHistory(newValue);
>> 82 }
>> 83 if(command==stopStoreHistoryCommand)
>> 84 {
>> 85 UI->StoreHistory(false);
414 } 86 }
415 if (command == historyCommand) { << 87 if(command==ManualCommand)
416 UI->StoreHistory(newValue); << 88 {
417 } <<
418 if (command == stopStoreHistoryCommand) { <<
419 UI->StoreHistory(false); <<
420 } <<
421 if (command == ManualCommand) { <<
422 UI->ListCommands(newValue); 89 UI->ListCommands(newValue);
423 } 90 }
424 if (command == aliasCommand) { <<
425 UI->SetAlias(newValue); <<
426 } <<
427 if (command == unaliasCommand) { <<
428 UI->RemoveAlias(newValue); <<
429 } <<
430 if (command == listAliasCommand) { <<
431 UI->ListAlias(); <<
432 } <<
433 if (command == getEnvCmd) { <<
434 command->ResetFailure(); <<
435 if (std::getenv(newValue) != nullptr) { <<
436 G4String st = newValue; <<
437 st += " "; <<
438 st += std::getenv(newValue); <<
439 UI->SetAlias(st.c_str()); <<
440 } <<
441 else { <<
442 G4ExceptionDescription ed; <<
443 ed << "<" << newValue << "> is not defin <<
444 command->CommandFailed(ed); <<
445 } <<
446 } <<
447 if (command == getValCmd) { <<
448 G4Tokenizer next(newValue); <<
449 const G4String& aliName = next(); <<
450 const G4String& com = next(); <<
451 const G4String& curVal = UI->GetCurrentVal <<
452 if (!(curVal.empty())) { <<
453 G4String theValue = curVal; <<
454 G4String iIdx = next(); <<
455 if (!(iIdx.empty())) { <<
456 G4int idx = StoI(iIdx); <<
457 G4Tokenizer nextVal(curVal); <<
458 for (G4int i = 0; i <= idx; i++) { <<
459 theValue = nextVal(); <<
460 } <<
461 } <<
462 G4String st = "/control/alias "; <<
463 st += aliName + " " + theValue; <<
464 UI->ApplyCommand(st); <<
465 } <<
466 } <<
467 if (command == echoCmd) { <<
468 G4cout << UI->SolveAlias(newValue) << G4en <<
469 } <<
470 if (command == shellCommand) { <<
471 command->ResetFailure(); <<
472 G4int rc = system(newValue); <<
473 if (rc < 0) { <<
474 G4ExceptionDescription ed; <<
475 ed << "<" << newValue << "> is not a val <<
476 command->CommandFailed(ed); <<
477 } <<
478 } <<
479 if (command == loopCommand) { <<
480 command->ResetFailure(); <<
481 UI->LoopS(newValue); <<
482 if (UI->GetLastReturnCode() != 0) { <<
483 G4ExceptionDescription ed; <<
484 ed << "Command aborted (" << UI->GetLast <<
485 command->CommandFailed(UI->GetLastReturn <<
486 } <<
487 } <<
488 if (command == foreachCommand) { <<
489 command->ResetFailure(); <<
490 UI->ForeachS(newValue); <<
491 if (UI->GetLastReturnCode() != 0) { <<
492 G4ExceptionDescription ed; <<
493 ed << "Command aborted (" << UI->GetLast <<
494 command->CommandFailed(UI->GetLastReturn <<
495 } <<
496 } <<
497 if (command == HTMLCommand) { <<
498 UI->CreateHTML(newValue); <<
499 } <<
500 if (command == maxStoredHistCommand) { <<
501 UI->SetMaxHistSize(maxStoredHistCommand->G <<
502 } <<
503 if (command == ifCommand) { <<
504 G4Tokenizer next(newValue); <<
505 G4double l = StoD(next()); <<
506 const G4String& comp = next(); <<
507 G4double r = StoD(next()); <<
508 const G4String& mac = next(); <<
509 G4bool x = false; <<
510 if (comp == ">") { <<
511 x = (l > r); <<
512 } <<
513 else if (comp == ">=") { <<
514 x = (l >= r); <<
515 } <<
516 else if (comp == "<") { <<
517 x = (l < r); <<
518 } <<
519 else if (comp == "<=") { <<
520 x = (l <= r); <<
521 } <<
522 else if (comp == "==") { <<
523 x = (l == r); <<
524 } <<
525 else if (comp == "!=") { <<
526 x = (l != r); <<
527 } <<
528 if (x) { <<
529 UI->ExecuteMacroFile(UI->FindMacroPath(m <<
530 } <<
531 } <<
532 if (command == doifCommand) { <<
533 G4Tokenizer next(newValue); <<
534 G4double l = StoD(next()); <<
535 const G4String& comp = next(); <<
536 G4double r = StoD(next()); <<
537 <<
538 G4String c1 = next(); <<
539 G4String ca; <<
540 while (!((ca = next()).empty())) { <<
541 c1 += " "; <<
542 c1 += ca; <<
543 } <<
544 if (c1[0] == '"') { <<
545 G4String strippedValue; <<
546 if (c1.back() == '"') { <<
547 strippedValue = c1.substr(1, c1.length <<
548 } <<
549 else { <<
550 strippedValue = c1.substr(1, c1.length <<
551 } <<
552 c1 = std::move(strippedValue); <<
553 } <<
554 <<
555 G4bool x = false; <<
556 if (comp == ">") { <<
557 x = (l > r); <<
558 } <<
559 else if (comp == ">=") { <<
560 x = (l >= r); <<
561 } <<
562 else if (comp == "<") { <<
563 x = (l < r); <<
564 } <<
565 else if (comp == "<=") { <<
566 x = (l <= r); <<
567 } <<
568 else if (comp == "==") { <<
569 x = (l == r); <<
570 } <<
571 else if (comp == "!=") { <<
572 x = (l != r); <<
573 } <<
574 if (x) { <<
575 UI->ApplyCommand(c1); <<
576 } <<
577 } <<
578 if (command == addCommand) { <<
579 G4Tokenizer next(newValue); <<
580 const G4String& newA = next(); <<
581 G4double l = StoD(next()); <<
582 G4double r = StoD(next()); <<
583 G4String st = "/control/alias "; <<
584 st += newA; <<
585 st += " "; <<
586 st += DtoS(l + r); <<
587 UI->ApplyCommand(st); <<
588 } <<
589 if (command == subtractCommand) { <<
590 G4Tokenizer next(newValue); <<
591 const G4String& newA = next(); <<
592 G4double l = StoD(next()); <<
593 G4double r = StoD(next()); <<
594 G4String st = "/control/alias "; <<
595 st += newA; <<
596 st += " "; <<
597 st += DtoS(l - r); <<
598 UI->ApplyCommand(st); <<
599 } <<
600 if (command == multiplyCommand) { <<
601 G4Tokenizer next(newValue); <<
602 const G4String& newA = next(); <<
603 G4double l = StoD(next()); <<
604 G4double r = StoD(next()); <<
605 G4String st = "/control/alias "; <<
606 st += newA; <<
607 st += " "; <<
608 st += DtoS(l * r); <<
609 UI->ApplyCommand(st); <<
610 } <<
611 if (command == divideCommand) { <<
612 G4Tokenizer next(newValue); <<
613 const G4String& newA = next(); <<
614 G4double l = StoD(next()); <<
615 G4double r = StoD(next()); <<
616 G4String st = "/control/alias "; <<
617 st += newA; <<
618 st += " "; <<
619 st += DtoS(l / r); <<
620 UI->ApplyCommand(st); <<
621 } <<
622 if (command == remainderCommand) { <<
623 G4Tokenizer next(newValue); <<
624 const G4String& newA = next(); <<
625 G4int l = StoI(next()); <<
626 G4int r = StoI(next()); <<
627 G4String st = "/control/alias "; <<
628 st += newA; <<
629 st += " "; <<
630 st += DtoS(l % r); <<
631 UI->ApplyCommand(st); <<
632 } <<
633 if (command == strifCommand) { <<
634 G4Tokenizer next(newValue); <<
635 const G4String& l = next(); <<
636 const G4String& comp = next(); <<
637 const G4String& r = next(); <<
638 const G4String& mac = next(); <<
639 G4bool x = false; <<
640 if (comp == "==") { <<
641 x = (l == r); <<
642 } <<
643 else if (comp == "!=") { <<
644 x = (l != r); <<
645 } <<
646 if (x) { <<
647 UI->ExecuteMacroFile(UI->FindMacroPath(m <<
648 } <<
649 } <<
650 if (command == strdoifCommand) { <<
651 G4Tokenizer next(newValue); <<
652 const G4String& l = next(); <<
653 const G4String& comp = next(); <<
654 const G4String& r = next(); <<
655 <<
656 G4String c1 = next(); <<
657 G4String ca; <<
658 while (!((ca = next()).empty())) { <<
659 c1 += " "; <<
660 c1 += ca; <<
661 } <<
662 if (c1[0] == '"') { <<
663 G4String strippedValue; <<
664 if (c1.back() == '"') { <<
665 strippedValue = c1.substr(1, c1.length <<
666 } <<
667 else { <<
668 strippedValue = c1.substr(1, c1.length <<
669 } <<
670 c1 = std::move(strippedValue); <<
671 } <<
672 <<
673 G4bool x = false; <<
674 if (comp == "==") { <<
675 x = (l == r); <<
676 } <<
677 else if (comp == "!=") { <<
678 x = (l != r); <<
679 } <<
680 if (x) { <<
681 UI->ApplyCommand(c1); <<
682 } <<
683 } <<
684 if (command == ifBatchCommand) { <<
685 if (G4UIsession::InSession() == 0) { <<
686 UI->ExecuteMacroFile(UI->FindMacroPath(n <<
687 } <<
688 } <<
689 if (command == ifInteractiveCommand) { <<
690 if (G4UIsession::InSession() > 0) { <<
691 UI->ExecuteMacroFile(UI->FindMacroPath(n <<
692 } <<
693 } <<
694 if (command == doifBatchCommand) { <<
695 if (G4UIsession::InSession() == 0) { <<
696 UI->ApplyCommand(newValue); <<
697 } <<
698 } <<
699 if (command == doifInteractiveCommand) { <<
700 if (G4UIsession::InSession() > 0) { <<
701 UI->ApplyCommand(newValue); <<
702 } <<
703 } <<
704 } 91 }
705 92
706 // ------------------------------------------- << 93 G4String G4UIcontrolMessenger::GetCurrentValue(G4UIcommand * command)
707 G4String G4UIcontrolMessenger::GetCurrentValue <<
708 { 94 {
709 G4UImanager* UI = G4UImanager::GetUIpointer( << 95 G4UImanager * UI = G4UImanager::GetUIpointer();
710 G4String currentValue; 96 G4String currentValue;
711 << 97
712 if (command == macroPathCommand) { << 98 if(command==verboseCommand)
713 currentValue = UI->GetMacroSearchPath(); << 99 {
714 } <<
715 if (command == verboseCommand) { <<
716 currentValue = verboseCommand->ConvertToSt 100 currentValue = verboseCommand->ConvertToString(UI->GetVerboseLevel());
717 } 101 }
718 if (command == doublePrecCommand) { << 102
719 currentValue = doublePrecCommand->ConvertT <<
720 } <<
721 if (command == suppressAbortionCommand) { <<
722 currentValue = suppressAbortionCommand->Co <<
723 G4StateManager::GetStateManager()->GetSu <<
724 } <<
725 if (command == maxStoredHistCommand) { <<
726 currentValue = maxStoredHistCommand->Conve <<
727 } <<
728 <<
729 return currentValue; 103 return currentValue;
730 } 104 }
>> 105
>> 106
731 107