Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/intercoms/src/G4UIcontrolMessenger.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /intercoms/src/G4UIcontrolMessenger.cc (Version 11.3.0) and /intercoms/src/G4UIcontrolMessenger.cc (Version 10.3)


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