| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // G4UIcontrolMessenger
27 //
28 // Author: Makoto Asai, SLAC - 2001
29 // --------------------------------------------------------------------
30
31 #include "G4UIcontrolMessenger.hh"
32
33 #include "G4StateManager.hh"
34 #include "G4Tokenizer.hh"
35 #include "G4UIaliasList.hh"
36 #include "G4UIcmdWithABool.hh"
37 #include "G4UIcmdWithAString.hh"
38 #include "G4UIcmdWithAnInteger.hh"
39 #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"
46
47 #include <cstdlib>
48
49 // --------------------------------------------------------------------
50 G4UIcontrolMessenger::G4UIcontrolMessenger()
51 {
52 controlDirectory = new G4UIdirectory("/control/");
53 controlDirectory->SetGuidance("UI control commands.");
54
55 macroPathCommand = new G4UIcmdWithAString("/control/macroPath", this);
56 macroPathCommand->SetGuidance(
57 "Set macro search path"
58 " with colon-separated list.");
59 macroPathCommand->SetParameterName("path", false);
60
61 ExecuteCommand = new G4UIcmdWithAString("/control/execute", this);
62 ExecuteCommand->SetGuidance("Execute a macro file.");
63 ExecuteCommand->SetParameterName("fileName", false);
64 ExecuteCommand->SetToBeBroadcasted(false);
65
66 loopCommand = new G4UIcommand("/control/loop", this);
67 loopCommand->SetGuidance("Execute a macro file more than once.");
68 loopCommand->SetGuidance("Loop counter can be used as an aliased variable.");
69 auto* param1 = new G4UIparameter("macroFile", 's', false);
70 loopCommand->SetParameter(param1);
71 auto* param2 = new G4UIparameter("counterName", 's', false);
72 loopCommand->SetParameter(param2);
73 auto* param3 = new G4UIparameter("initialValue", 'd', false);
74 loopCommand->SetParameter(param3);
75 auto* param4 = new G4UIparameter("finalValue", 'd', false);
76 loopCommand->SetParameter(param4);
77 auto* param5 = new G4UIparameter("stepSize", 'd', true);
78 param5->SetDefaultValue(1.0);
79 loopCommand->SetParameter(param5);
80 loopCommand->SetToBeBroadcasted(false);
81
82 foreachCommand = new G4UIcommand("/control/foreach", this);
83 foreachCommand->SetGuidance("Execute a macro file more than once.");
84 foreachCommand->SetGuidance("Loop counter can be used as an aliased variable.");
85 foreachCommand->SetGuidance("Values must be separated by a space.");
86 auto* param6 = new G4UIparameter("macroFile", 's', false);
87 foreachCommand->SetParameter(param6);
88 auto* param7 = new G4UIparameter("counterName", 's', false);
89 foreachCommand->SetParameter(param7);
90 auto* param8 = new G4UIparameter("valueList", 's', false);
91 foreachCommand->SetParameter(param8);
92 foreachCommand->SetToBeBroadcasted(false);
93
94 suppressAbortionCommand = new G4UIcmdWithAnInteger("/control/suppressAbortion", this);
95 suppressAbortionCommand->SetGuidance("Suppress the program abortion caused by G4Exception.");
96 suppressAbortionCommand->SetGuidance("Suppression level = 0 : no suppression");
97 suppressAbortionCommand->SetGuidance(" = 1 : suppress during EventProc state");
98 suppressAbortionCommand->SetGuidance(
99 " = 2 : full suppression, i.e. no abortion by "
100 "G4Exception");
101 suppressAbortionCommand->SetGuidance(
102 "When abortion is suppressed, you will get error messages issued by "
103 "G4Exception,");
104 suppressAbortionCommand->SetGuidance(
105 "and there is NO guarantee for the correct result after the G4Exception "
106 "error message.");
107 suppressAbortionCommand->SetParameterName("level", true);
108 suppressAbortionCommand->SetRange("level >= 0 && level <= 2");
109 suppressAbortionCommand->SetDefaultValue(0);
110
111 verboseCommand = new G4UIcmdWithAnInteger("/control/verbose", this);
112 verboseCommand->SetGuidance("Applied command will also be shown on screen.");
113 verboseCommand->SetGuidance("This command is useful with MACRO file.");
114 verboseCommand->SetGuidance(" 0 : silent");
115 verboseCommand->SetGuidance(" 1 : only the valid commands are shown.");
116 verboseCommand->SetGuidance(" 2 : comment lines are also shown (default).");
117 verboseCommand->SetParameterName("switch", true);
118 verboseCommand->SetRange("switch >= 0 && switch <=2");
119 verboseCommand->SetDefaultValue(2);
120
121 doublePrecCommand = new G4UIcmdWithABool("/control/useDoublePrecision", this);
122 doublePrecCommand->SetGuidance(
123 "Use double precision for printing out the current parameter value(s).");
124 doublePrecCommand->SetParameterName("useDoublePrecision", true);
125 doublePrecCommand->SetDefaultValue(true);
126
127 historyCommand = new G4UIcmdWithAString("/control/saveHistory", this);
128 historyCommand->SetGuidance("Store command history to a file.");
129 historyCommand->SetGuidance("Defaul file name is G4history.macro.");
130 historyCommand->SetParameterName("fileName", true);
131 historyCommand->SetDefaultValue("G4History.macro");
132 historyCommand->SetToBeBroadcasted(false);
133
134 stopStoreHistoryCommand = new G4UIcmdWithoutParameter("/control/stopSavingHistory", this);
135 stopStoreHistoryCommand->SetGuidance("Stop saving history file.");
136 stopStoreHistoryCommand->SetToBeBroadcasted(false);
137
138 aliasCommand = new G4UIcommand("/control/alias", this);
139 aliasCommand->SetGuidance("Set an alias.");
140 aliasCommand->SetGuidance("String can be aliased by this command.");
141 aliasCommand->SetGuidance("The string may contain one or more spaces,");
142 aliasCommand->SetGuidance("the string must be enclosed by double quotes (\").");
143 aliasCommand->SetGuidance("To use an alias, enclose the alias name with");
144 aliasCommand->SetGuidance("parenthesis \"{\" and \"}\".");
145 auto* aliasNameParam = new G4UIparameter("aliasName", 's', false);
146 aliasCommand->SetParameter(aliasNameParam);
147 auto* aliasValueParam = new G4UIparameter("aliasValue", 's', false);
148 aliasCommand->SetParameter(aliasValueParam);
149
150 unaliasCommand = new G4UIcmdWithAString("/control/unalias", this);
151 unaliasCommand->SetGuidance("Remove an alias.");
152 unaliasCommand->SetParameterName("aliasName", false);
153
154 listAliasCommand = new G4UIcmdWithoutParameter("/control/listAlias", this);
155 listAliasCommand->SetGuidance("List aliases.");
156
157 getEnvCmd = new G4UIcmdWithAString("/control/getEnv", this);
158 getEnvCmd->SetGuidance("Get a shell environment variable and define it as an alias.");
159 getEnvCmd->SetToBeBroadcasted(false);
160
161 getValCmd = new G4UIcommand("/control/getVal", this);
162 getValCmd->SetGuidance("Get the current value of the UI command and define it as an alias.");
163 getValCmd->SetGuidance(
164 "Command is ignored if the UI command does not support GetCurrentValue().");
165 getValCmd->SetGuidance(" Syntax : <alias_name> <UI_command> <iIdx>");
166 auto* aliName = new G4UIparameter("alias_name", 's', false);
167 getValCmd->SetParameter(aliName);
168 auto* comName = new G4UIparameter("UI_command", 's', false);
169 getValCmd->SetParameter(comName);
170 auto* iIdxParam = new G4UIparameter("iIdx", 'i', true);
171 iIdxParam->SetDefaultValue(0);
172 getValCmd->SetParameter(iIdxParam);
173 getValCmd->SetToBeBroadcasted(false);
174
175 echoCmd = new G4UIcmdWithAString("/control/echo", this);
176 echoCmd->SetGuidance("Display the valuerameter string.");
177 echoCmd->SetGuidance("If alias is contained, it is converted to the aliased value.");
178
179 shellCommand = new G4UIcmdWithAString("/control/shell", this);
180 shellCommand->SetGuidance("Execute a (Unix) SHELL command.");
181 shellCommand->SetToBeBroadcasted(false);
182
183 ManualCommand = new G4UIcmdWithAString("/control/manual", this);
184 ManualCommand->SetGuidance("Display all of sub-directories and commands.");
185 ManualCommand->SetGuidance("Directory path should be given by FULL-PATH.");
186 ManualCommand->SetParameterName("dirPath", true);
187 ManualCommand->SetDefaultValue("/");
188 ManualCommand->SetToBeBroadcasted(false);
189
190 HTMLCommand = new G4UIcmdWithAString("/control/createHTML", this);
191 HTMLCommand->SetGuidance("Generate HTML files for all of sub-directories and commands.");
192 HTMLCommand->SetGuidance("Directory path should be given by FULL-PATH.");
193 HTMLCommand->SetParameterName("dirPath", true);
194 HTMLCommand->SetDefaultValue("/");
195 HTMLCommand->SetToBeBroadcasted(false);
196
197 maxStoredHistCommand = new G4UIcmdWithAnInteger("/control/maximumStoredHistory", this);
198 maxStoredHistCommand->SetGuidance("Set maximum number of stored UI commands.");
199 maxStoredHistCommand->SetParameterName("max", true);
200 maxStoredHistCommand->SetDefaultValue(20);
201
202 ifCommand = new G4UIcommand("/control/if", this);
203 ifCommand->SetGuidance("Execute a macro file if the expression is true.");
204 ifCommand->SetGuidance(" Syntax : <double> <comp> <double> <macro_file>");
205 auto* leftParam = new G4UIparameter("left", 'd', false);
206 ifCommand->SetParameter(leftParam);
207 auto* compParam = new G4UIparameter("comp", 's', false);
208 compParam->SetParameterCandidates("> >= < <= == !=");
209 ifCommand->SetParameter(compParam);
210 auto* rightParam = new G4UIparameter("right", 'd', false);
211 ifCommand->SetParameter(rightParam);
212 auto* macroFileParam = new G4UIparameter("macroFile", 's', false);
213 ifCommand->SetParameter(macroFileParam);
214 ifCommand->SetToBeBroadcasted(false);
215
216 doifCommand = new G4UIcommand("/control/doif", this);
217 doifCommand->SetGuidance("Execute a UI command if the expression is true.");
218 doifCommand->SetGuidance(" Syntax : <double> <comp> <double> <UI_command>");
219 auto* doleftParam = new G4UIparameter("left", 'd', false);
220 doifCommand->SetParameter(doleftParam);
221 auto* docompParam = new G4UIparameter("comp", 's', false);
222 docompParam->SetParameterCandidates("> >= < <= == !=");
223 doifCommand->SetParameter(docompParam);
224 auto* dorightParam = new G4UIparameter("right", 'd', false);
225 doifCommand->SetParameter(dorightParam);
226 auto* comParam = new G4UIparameter("UI_command", 's', false);
227 doifCommand->SetParameter(comParam);
228 doifCommand->SetToBeBroadcasted(false);
229
230 addCommand = new G4UIcommand("/control/add", this);
231 addCommand->SetGuidance("Define a new alias as the sum of two values.");
232 addCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
233 addCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
234 addCommand->SetGuidance(" aliased value is alternated.");
235 auto* newAlias1 = new G4UIparameter("new_alias", 's', false);
236 addCommand->SetParameter(newAlias1);
237 auto* val1a = new G4UIparameter("value1", 'd', false);
238 addCommand->SetParameter(val1a);
239 auto* val1b = new G4UIparameter("value2", 'd', false);
240 addCommand->SetParameter(val1b);
241 addCommand->SetToBeBroadcasted(false);
242
243 subtractCommand = new G4UIcommand("/control/subtract", this);
244 subtractCommand->SetGuidance("Define a new alias as the subtraction of two values.");
245 subtractCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
246 subtractCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
247 subtractCommand->SetGuidance(" aliased value is alternated.");
248 auto* newAlias2 = new G4UIparameter("new_alias", 's', false);
249 subtractCommand->SetParameter(newAlias2);
250 auto* val2a = new G4UIparameter("value1", 'd', false);
251 subtractCommand->SetParameter(val2a);
252 auto* val2b = new G4UIparameter("value2", 'd', false);
253 subtractCommand->SetParameter(val2b);
254 subtractCommand->SetToBeBroadcasted(false);
255
256 multiplyCommand = new G4UIcommand("/control/multiply", this);
257 multiplyCommand->SetGuidance("Define a new alias as the multiplication of two values.");
258 multiplyCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
259 multiplyCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
260 multiplyCommand->SetGuidance(" aliased value is alternated.");
261 auto* newAlias3 = new G4UIparameter("new_alias", 's', false);
262 multiplyCommand->SetParameter(newAlias3);
263 auto* val3a = new G4UIparameter("value1", 'd', false);
264 multiplyCommand->SetParameter(val3a);
265 auto* val3b = new G4UIparameter("value2", 'd', false);
266 multiplyCommand->SetParameter(val3b);
267 multiplyCommand->SetToBeBroadcasted(false);
268
269 divideCommand = new G4UIcommand("/control/divide", this);
270 divideCommand->SetGuidance("Define a new alias as the division of two values.");
271 divideCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
272 divideCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
273 divideCommand->SetGuidance(" aliased value is alternated.");
274 auto* newAlias4 = new G4UIparameter("new_alias", 's', false);
275 divideCommand->SetParameter(newAlias4);
276 auto* val4a = new G4UIparameter("value1", 'd', false);
277 divideCommand->SetParameter(val4a);
278 auto* val4b = new G4UIparameter("value2", 'd', false);
279 val4b->SetParameterRange("value2 != 0.");
280 divideCommand->SetParameter(val4b);
281 divideCommand->SetToBeBroadcasted(false);
282
283 remainderCommand = new G4UIcommand("/control/remainder", this);
284 remainderCommand->SetGuidance("Define a new alias as the remainder of two values.");
285 remainderCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
286 remainderCommand->SetGuidance(
287 " <new_alias> may be an already existing alias. If it is the case,");
288 remainderCommand->SetGuidance(" aliased value is alternated.");
289 auto* newAlias5 = new G4UIparameter("new_alias", 's', false);
290 remainderCommand->SetParameter(newAlias5);
291 auto* val5a = new G4UIparameter("value1", 'i', false);
292 remainderCommand->SetParameter(val5a);
293 auto* val5b = new G4UIparameter("value2", 'i', false);
294 val4b->SetParameterRange("value2 != 0");
295 remainderCommand->SetParameter(val5b);
296 remainderCommand->SetToBeBroadcasted(false);
297
298 strifCommand = new G4UIcommand("/control/strif", this);
299 strifCommand->SetGuidance("Execute a macro file if the expression is true.");
300 strifCommand->SetGuidance(" Syntax : <string> <comp> <string> <macro_file>");
301 auto* strleftParam = new G4UIparameter("left", 's', false);
302 strifCommand->SetParameter(strleftParam);
303 auto* strcompParam = new G4UIparameter("comp", 's', false);
304 strcompParam->SetParameterCandidates("== !=");
305 strifCommand->SetParameter(strcompParam);
306 auto* strrightParam = new G4UIparameter("right", 's', false);
307 strifCommand->SetParameter(strrightParam);
308 auto* strmacroFileParam = new G4UIparameter("macroFile", 's', false);
309 strifCommand->SetParameter(strmacroFileParam);
310 strifCommand->SetToBeBroadcasted(false);
311
312 strdoifCommand = new G4UIcommand("/control/strdoif", this);
313 strdoifCommand->SetGuidance("Execute a UI command if the expression is true.");
314 strdoifCommand->SetGuidance(" Syntax : <string> <comp> <string> <UI_command>");
315 auto* strdoleftParam = new G4UIparameter("left", 's', false);
316 strdoifCommand->SetParameter(strdoleftParam);
317 auto* strdocompParam = new G4UIparameter("comp", 's', false);
318 strdocompParam->SetParameterCandidates("== !=");
319 strdoifCommand->SetParameter(strdocompParam);
320 auto* strdorightParam = new G4UIparameter("right", 's', false);
321 strdoifCommand->SetParameter(strdorightParam);
322 auto* strdomacroFileParam = new G4UIparameter("UI_command", 's', false);
323 strdoifCommand->SetParameter(strdomacroFileParam);
324 strdoifCommand->SetToBeBroadcasted(false);
325
326 ifBatchCommand = new G4UIcmdWithAString("/control/ifBatch", this);
327 ifBatchCommand->SetGuidance("Execute a macro file if program is running in batch mode.");
328 ifBatchCommand->SetParameterName("macroFile", false);
329 ifBatchCommand->SetToBeBroadcasted(false);
330
331 ifInteractiveCommand = new G4UIcmdWithAString("/control/ifInteractive", this);
332 ifInteractiveCommand->SetGuidance(
333 "Execute a macro file if program is running in interactive mode.");
334 ifInteractiveCommand->SetParameterName("macroFile", false);
335 ifInteractiveCommand->SetToBeBroadcasted(false);
336
337 doifBatchCommand = new G4UIcmdWithAString("/control/doifBatch", this);
338 doifBatchCommand->SetGuidance("Execute a UI command if program is running in batch mode.");
339 doifBatchCommand->SetParameterName("UIcommand", false);
340 doifBatchCommand->SetToBeBroadcasted(false);
341
342 doifInteractiveCommand = new G4UIcmdWithAString("/control/doifInteractive", this);
343 doifInteractiveCommand->SetGuidance(
344 "Execute a UI command if program is running in interactive mode.");
345 doifInteractiveCommand->SetParameterName("UIcommand", false);
346 doifInteractiveCommand->SetToBeBroadcasted(false);
347 }
348
349 // --------------------------------------------------------------------
350 G4UIcontrolMessenger::~G4UIcontrolMessenger()
351 {
352 delete macroPathCommand;
353 delete ExecuteCommand;
354 delete suppressAbortionCommand;
355 delete verboseCommand;
356 delete doublePrecCommand;
357 delete historyCommand;
358 delete stopStoreHistoryCommand;
359 delete ManualCommand;
360 delete aliasCommand;
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;
385 }
386
387 // --------------------------------------------------------------------
388 void G4UIcontrolMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
389 {
390 G4UImanager* UI = G4UImanager::GetUIpointer();
391
392 if (command == macroPathCommand) {
393 UI->SetMacroSearchPath(newValue);
394 UI->ParseMacroSearchPath();
395 }
396 if (command == ExecuteCommand) {
397 command->ResetFailure();
398 UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
399 if (UI->GetLastReturnCode() != 0) {
400 G4ExceptionDescription ed;
401 ed << "Command aborted (" << UI->GetLastReturnCode() << ")";
402 command->CommandFailed(UI->GetLastReturnCode(), ed);
403 }
404 }
405 if (command == suppressAbortionCommand) {
406 G4StateManager::GetStateManager()->SetSuppressAbortion(
407 suppressAbortionCommand->GetNewIntValue(newValue));
408 }
409 if (command == verboseCommand) {
410 UI->SetVerboseLevel(verboseCommand->GetNewIntValue(newValue));
411 }
412 if (command == doublePrecCommand) {
413 G4UImanager::UseDoublePrecisionStr(doublePrecCommand->GetNewBoolValue(newValue));
414 }
415 if (command == historyCommand) {
416 UI->StoreHistory(newValue);
417 }
418 if (command == stopStoreHistoryCommand) {
419 UI->StoreHistory(false);
420 }
421 if (command == ManualCommand) {
422 UI->ListCommands(newValue);
423 }
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 defined as a shell variable. Command ignored.";
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->GetCurrentValues(com);
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) << G4endl;
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 valid shell command. Command ignored.";
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->GetLastReturnCode() << ")";
485 command->CommandFailed(UI->GetLastReturnCode(), ed);
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->GetLastReturnCode() << ")";
494 command->CommandFailed(UI->GetLastReturnCode(), ed);
495 }
496 }
497 if (command == HTMLCommand) {
498 UI->CreateHTML(newValue);
499 }
500 if (command == maxStoredHistCommand) {
501 UI->SetMaxHistSize(maxStoredHistCommand->GetNewIntValue(newValue));
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(mac));
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() - 2);
548 }
549 else {
550 strippedValue = c1.substr(1, c1.length() - 1);
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(mac));
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() - 2);
666 }
667 else {
668 strippedValue = c1.substr(1, c1.length() - 1);
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(newValue));
687 }
688 }
689 if (command == ifInteractiveCommand) {
690 if (G4UIsession::InSession() > 0) {
691 UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
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 }
705
706 // --------------------------------------------------------------------
707 G4String G4UIcontrolMessenger::GetCurrentValue(G4UIcommand* command)
708 {
709 G4UImanager* UI = G4UImanager::GetUIpointer();
710 G4String currentValue;
711
712 if (command == macroPathCommand) {
713 currentValue = UI->GetMacroSearchPath();
714 }
715 if (command == verboseCommand) {
716 currentValue = verboseCommand->ConvertToString(UI->GetVerboseLevel());
717 }
718 if (command == doublePrecCommand) {
719 currentValue = doublePrecCommand->ConvertToString(G4UImanager::DoublePrecisionStr());
720 }
721 if (command == suppressAbortionCommand) {
722 currentValue = suppressAbortionCommand->ConvertToString(
723 G4StateManager::GetStateManager()->GetSuppressAbortion());
724 }
725 if (command == maxStoredHistCommand) {
726 currentValue = maxStoredHistCommand->ConvertToString(UI->GetMaxHistSize());
727 }
728
729 return currentValue;
730 }
731