G4UIcontrolMessenger Class Reference

#include <G4UIcontrolMessenger.hh>

Inheritance diagram for G4UIcontrolMessenger:

Public Member Functions
	G4UIcontrolMessenger ()
	~G4UIcontrolMessenger () override
void	SetNewValue (G4UIcommand *command, G4String newValue) override
G4String	GetCurrentValue (G4UIcommand *command) override
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	LtoS (G4long l)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (const G4String &s)
G4long	StoL (const G4String &s)
G4double	StoD (const G4String &s)
G4bool	StoB (const G4String &s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T>
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false

Detailed Description

Definition at line 80 of file G4UIcontrolMessenger.hh.

Constructor & Destructor Documentation

G4UIcontrolMessenger()

G4UIcontrolMessenger::G4UIcontrolMessenger

(

)

Definition at line 50 of file G4UIcontrolMessenger.cc.

{
  controlDirectory = new G4UIdirectory("/control/");
  controlDirectory->SetGuidance("UI control commands.");
 
  macroPathCommand = new G4UIcmdWithAString("/control/macroPath", this);
  macroPathCommand->SetGuidance(
    "Set macro search path"
    " with colon-separated list.");
  macroPathCommand->SetParameterName("path", false);
 
  ExecuteCommand = new G4UIcmdWithAString("/control/execute", this);
  ExecuteCommand->SetGuidance("Execute a macro file.");
  ExecuteCommand->SetParameterName("fileName", false);
  ExecuteCommand->SetToBeBroadcasted(false);
 
  loopCommand = new G4UIcommand("/control/loop", this);
  loopCommand->SetGuidance("Execute a macro file more than once.");
  loopCommand->SetGuidance("Loop counter can be used as an aliased variable.");
  auto* param1 = new G4UIparameter("macroFile", 's', false);
  loopCommand->SetParameter(param1);
  auto* param2 = new G4UIparameter("counterName", 's', false);
  loopCommand->SetParameter(param2);
  auto* param3 = new G4UIparameter("initialValue", 'd', false);
  loopCommand->SetParameter(param3);
  auto* param4 = new G4UIparameter("finalValue", 'd', false);
  loopCommand->SetParameter(param4);
  auto* param5 = new G4UIparameter("stepSize", 'd', true);
  param5->SetDefaultValue(1.0);
  loopCommand->SetParameter(param5);
  loopCommand->SetToBeBroadcasted(false);
 
  foreachCommand = new G4UIcommand("/control/foreach", this);
  foreachCommand->SetGuidance("Execute a macro file more than once.");
  foreachCommand->SetGuidance("Loop counter can be used as an aliased variable.");
  foreachCommand->SetGuidance("Values must be separated by a space.");
  auto* param6 = new G4UIparameter("macroFile", 's', false);
  foreachCommand->SetParameter(param6);
  auto* param7 = new G4UIparameter("counterName", 's', false);
  foreachCommand->SetParameter(param7);
  auto* param8 = new G4UIparameter("valueList", 's', false);
  foreachCommand->SetParameter(param8);
  foreachCommand->SetToBeBroadcasted(false);
 
  suppressAbortionCommand = new G4UIcmdWithAnInteger("/control/suppressAbortion", this);
  suppressAbortionCommand->SetGuidance("Suppress the program abortion caused by G4Exception.");
  suppressAbortionCommand->SetGuidance("Suppression level = 0 : no suppression");
  suppressAbortionCommand->SetGuidance("                  = 1 : suppress during EventProc state");
  suppressAbortionCommand->SetGuidance(
    "                  = 2 : full suppression, i.e. no abortion by "
    "G4Exception");
  suppressAbortionCommand->SetGuidance(
    "When abortion is suppressed, you will get error messages issued by "
    "G4Exception,");
  suppressAbortionCommand->SetGuidance(
    "and there is NO guarantee for the correct result after the G4Exception "
    "error message.");
  suppressAbortionCommand->SetParameterName("level", true);
  suppressAbortionCommand->SetRange("level >= 0 && level <= 2");
  suppressAbortionCommand->SetDefaultValue(0);
 
  verboseCommand = new G4UIcmdWithAnInteger("/control/verbose", this);
  verboseCommand->SetGuidance("Applied command will also be shown on screen.");
  verboseCommand->SetGuidance("This command is useful with MACRO file.");
  verboseCommand->SetGuidance("  0 : silent");
  verboseCommand->SetGuidance("  1 : only the valid commands are shown.");
  verboseCommand->SetGuidance("  2 : comment lines are also shown (default).");
  verboseCommand->SetParameterName("switch", true);
  verboseCommand->SetRange("switch >= 0 && switch <=2");
  verboseCommand->SetDefaultValue(2);
 
  doublePrecCommand = new G4UIcmdWithABool("/control/useDoublePrecision", this);
  doublePrecCommand->SetGuidance(
    "Use double precision for printing out the current parameter value(s).");
  doublePrecCommand->SetParameterName("useDoublePrecision", true);
  doublePrecCommand->SetDefaultValue(true);
 
  historyCommand = new G4UIcmdWithAString("/control/saveHistory", this);
  historyCommand->SetGuidance("Store command history to a file.");
  historyCommand->SetGuidance("Defaul file name is G4history.macro.");
  historyCommand->SetParameterName("fileName", true);
  historyCommand->SetDefaultValue("G4History.macro");
  historyCommand->SetToBeBroadcasted(false);
 
  stopStoreHistoryCommand = new G4UIcmdWithoutParameter("/control/stopSavingHistory", this);
  stopStoreHistoryCommand->SetGuidance("Stop saving history file.");
  stopStoreHistoryCommand->SetToBeBroadcasted(false);
 
  aliasCommand = new G4UIcommand("/control/alias", this);
  aliasCommand->SetGuidance("Set an alias.");
  aliasCommand->SetGuidance("String can be aliased by this command.");
  aliasCommand->SetGuidance("The string may contain one or more spaces,");
  aliasCommand->SetGuidance("the string must be enclosed by double quotes (\").");
  aliasCommand->SetGuidance("To use an alias, enclose the alias name with");
  aliasCommand->SetGuidance("parenthesis \"{\" and \"}\".");
  auto* aliasNameParam = new G4UIparameter("aliasName", 's', false);
  aliasCommand->SetParameter(aliasNameParam);
  auto* aliasValueParam = new G4UIparameter("aliasValue", 's', false);
  aliasCommand->SetParameter(aliasValueParam);
 
  unaliasCommand = new G4UIcmdWithAString("/control/unalias", this);
  unaliasCommand->SetGuidance("Remove an alias.");
  unaliasCommand->SetParameterName("aliasName", false);
 
  listAliasCommand = new G4UIcmdWithoutParameter("/control/listAlias", this);
  listAliasCommand->SetGuidance("List aliases.");
 
  getEnvCmd = new G4UIcmdWithAString("/control/getEnv", this);
  getEnvCmd->SetGuidance("Get a shell environment variable and define it as an alias.");
  getEnvCmd->SetToBeBroadcasted(false);
 
  getValCmd = new G4UIcommand("/control/getVal", this);
  getValCmd->SetGuidance("Get the current value of the UI command and define it as an alias.");
  getValCmd->SetGuidance(
    "Command is ignored if the UI command does not support GetCurrentValue().");
  getValCmd->SetGuidance(" Syntax : <alias_name> <UI_command> <iIdx>");
  auto* aliName = new G4UIparameter("alias_name", 's', false);
  getValCmd->SetParameter(aliName);
  auto* comName = new G4UIparameter("UI_command", 's', false);
  getValCmd->SetParameter(comName);
  auto* iIdxParam = new G4UIparameter("iIdx", 'i', true);
  iIdxParam->SetDefaultValue(0);
  getValCmd->SetParameter(iIdxParam);
  getValCmd->SetToBeBroadcasted(false);
 
  echoCmd = new G4UIcmdWithAString("/control/echo", this);
  echoCmd->SetGuidance("Display the valuerameter string.");
  echoCmd->SetGuidance("If alias is contained, it is converted to the aliased value.");
 
  shellCommand = new G4UIcmdWithAString("/control/shell", this);
  shellCommand->SetGuidance("Execute a (Unix) SHELL command.");
  shellCommand->SetToBeBroadcasted(false);
 
  ManualCommand = new G4UIcmdWithAString("/control/manual", this);
  ManualCommand->SetGuidance("Display all of sub-directories and commands.");
  ManualCommand->SetGuidance("Directory path should be given by FULL-PATH.");
  ManualCommand->SetParameterName("dirPath", true);
  ManualCommand->SetDefaultValue("/");
  ManualCommand->SetToBeBroadcasted(false);
 
  HTMLCommand = new G4UIcmdWithAString("/control/createHTML", this);
  HTMLCommand->SetGuidance("Generate HTML files for all of sub-directories and commands.");
  HTMLCommand->SetGuidance("Directory path should be given by FULL-PATH.");
  HTMLCommand->SetParameterName("dirPath", true);
  HTMLCommand->SetDefaultValue("/");
  HTMLCommand->SetToBeBroadcasted(false);
 
  maxStoredHistCommand = new G4UIcmdWithAnInteger("/control/maximumStoredHistory", this);
  maxStoredHistCommand->SetGuidance("Set maximum number of stored UI commands.");
  maxStoredHistCommand->SetParameterName("max", true);
  maxStoredHistCommand->SetDefaultValue(20);
 
  ifCommand = new G4UIcommand("/control/if", this);
  ifCommand->SetGuidance("Execute a macro file if the expression is true.");
  ifCommand->SetGuidance(" Syntax : <double> <comp> <double> <macro_file>");
  auto* leftParam = new G4UIparameter("left", 'd', false);
  ifCommand->SetParameter(leftParam);
  auto* compParam = new G4UIparameter("comp", 's', false);
  compParam->SetParameterCandidates("> >= < <= == !=");
  ifCommand->SetParameter(compParam);
  auto* rightParam = new G4UIparameter("right", 'd', false);
  ifCommand->SetParameter(rightParam);
  auto* macroFileParam = new G4UIparameter("macroFile", 's', false);
  ifCommand->SetParameter(macroFileParam);
  ifCommand->SetToBeBroadcasted(false);
 
  doifCommand = new G4UIcommand("/control/doif", this);
  doifCommand->SetGuidance("Execute a UI command if the expression is true.");
  doifCommand->SetGuidance(" Syntax : <double> <comp> <double> <UI_command>");
  auto* doleftParam = new G4UIparameter("left", 'd', false);
  doifCommand->SetParameter(doleftParam);
  auto* docompParam = new G4UIparameter("comp", 's', false);
  docompParam->SetParameterCandidates("> >= < <= == !=");
  doifCommand->SetParameter(docompParam);
  auto* dorightParam = new G4UIparameter("right", 'd', false);
  doifCommand->SetParameter(dorightParam);
  auto* comParam = new G4UIparameter("UI_command", 's', false);
  doifCommand->SetParameter(comParam);
  doifCommand->SetToBeBroadcasted(false);
 
  addCommand = new G4UIcommand("/control/add", this);
  addCommand->SetGuidance("Define a new alias as the sum of two values.");
  addCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  addCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
  addCommand->SetGuidance(" aliased value is alternated.");
  auto* newAlias1 = new G4UIparameter("new_alias", 's', false);
  addCommand->SetParameter(newAlias1);
  auto* val1a = new G4UIparameter("value1", 'd', false);
  addCommand->SetParameter(val1a);
  auto* val1b = new G4UIparameter("value2", 'd', false);
  addCommand->SetParameter(val1b);
  addCommand->SetToBeBroadcasted(false);
 
  subtractCommand = new G4UIcommand("/control/subtract", this);
  subtractCommand->SetGuidance("Define a new alias as the subtraction of two values.");
  subtractCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  subtractCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
  subtractCommand->SetGuidance(" aliased value is alternated.");
  auto* newAlias2 = new G4UIparameter("new_alias", 's', false);
  subtractCommand->SetParameter(newAlias2);
  auto* val2a = new G4UIparameter("value1", 'd', false);
  subtractCommand->SetParameter(val2a);
  auto* val2b = new G4UIparameter("value2", 'd', false);
  subtractCommand->SetParameter(val2b);
  subtractCommand->SetToBeBroadcasted(false);
 
  multiplyCommand = new G4UIcommand("/control/multiply", this);
  multiplyCommand->SetGuidance("Define a new alias as the multiplication of two values.");
  multiplyCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  multiplyCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
  multiplyCommand->SetGuidance(" aliased value is alternated.");
  auto* newAlias3 = new G4UIparameter("new_alias", 's', false);
  multiplyCommand->SetParameter(newAlias3);
  auto* val3a = new G4UIparameter("value1", 'd', false);
  multiplyCommand->SetParameter(val3a);
  auto* val3b = new G4UIparameter("value2", 'd', false);
  multiplyCommand->SetParameter(val3b);
  multiplyCommand->SetToBeBroadcasted(false);
 
  divideCommand = new G4UIcommand("/control/divide", this);
  divideCommand->SetGuidance("Define a new alias as the division of two values.");
  divideCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  divideCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
  divideCommand->SetGuidance(" aliased value is alternated.");
  auto* newAlias4 = new G4UIparameter("new_alias", 's', false);
  divideCommand->SetParameter(newAlias4);
  auto* val4a = new G4UIparameter("value1", 'd', false);
  divideCommand->SetParameter(val4a);
  auto* val4b = new G4UIparameter("value2", 'd', false);
  val4b->SetParameterRange("value2 != 0.");
  divideCommand->SetParameter(val4b);
  divideCommand->SetToBeBroadcasted(false);
 
  remainderCommand = new G4UIcommand("/control/remainder", this);
  remainderCommand->SetGuidance("Define a new alias as the remainder of two values.");
  remainderCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  remainderCommand->SetGuidance(
    " <new_alias> may be an already existing alias. If it is the case,");
  remainderCommand->SetGuidance(" aliased value is alternated.");
  auto* newAlias5 = new G4UIparameter("new_alias", 's', false);
  remainderCommand->SetParameter(newAlias5);
  auto* val5a = new G4UIparameter("value1", 'i', false);
  remainderCommand->SetParameter(val5a);
  auto* val5b = new G4UIparameter("value2", 'i', false);
  val4b->SetParameterRange("value2 != 0");
  remainderCommand->SetParameter(val5b);
  remainderCommand->SetToBeBroadcasted(false);
 
  strifCommand = new G4UIcommand("/control/strif", this);
  strifCommand->SetGuidance("Execute a macro file if the expression is true.");
  strifCommand->SetGuidance(" Syntax : <string> <comp> <string> <macro_file>");
  auto* strleftParam = new G4UIparameter("left", 's', false);
  strifCommand->SetParameter(strleftParam);
  auto* strcompParam = new G4UIparameter("comp", 's', false);
  strcompParam->SetParameterCandidates("== !=");
  strifCommand->SetParameter(strcompParam);
  auto* strrightParam = new G4UIparameter("right", 's', false);
  strifCommand->SetParameter(strrightParam);
  auto* strmacroFileParam = new G4UIparameter("macroFile", 's', false);
  strifCommand->SetParameter(strmacroFileParam);
  strifCommand->SetToBeBroadcasted(false);
 
  strdoifCommand = new G4UIcommand("/control/strdoif", this);
  strdoifCommand->SetGuidance("Execute a UI command if the expression is true.");
  strdoifCommand->SetGuidance(" Syntax : <string> <comp> <string> <UI_command>");
  auto* strdoleftParam = new G4UIparameter("left", 's', false);
  strdoifCommand->SetParameter(strdoleftParam);
  auto* strdocompParam = new G4UIparameter("comp", 's', false);
  strdocompParam->SetParameterCandidates("== !=");
  strdoifCommand->SetParameter(strdocompParam);
  auto* strdorightParam = new G4UIparameter("right", 's', false);
  strdoifCommand->SetParameter(strdorightParam);
  auto* strdomacroFileParam = new G4UIparameter("UI_command", 's', false);
  strdoifCommand->SetParameter(strdomacroFileParam);
  strdoifCommand->SetToBeBroadcasted(false);
 
  ifBatchCommand = new G4UIcmdWithAString("/control/ifBatch", this);
  ifBatchCommand->SetGuidance("Execute a macro file if program is running in batch mode.");
  ifBatchCommand->SetParameterName("macroFile", false);
  ifBatchCommand->SetToBeBroadcasted(false);
 
  ifInteractiveCommand = new G4UIcmdWithAString("/control/ifInteractive", this);
  ifInteractiveCommand->SetGuidance(
    "Execute a macro file if program is running in interactive mode.");
  ifInteractiveCommand->SetParameterName("macroFile", false);
  ifInteractiveCommand->SetToBeBroadcasted(false);
 
  doifBatchCommand = new G4UIcmdWithAString("/control/doifBatch", this);
  doifBatchCommand->SetGuidance("Execute a UI command if program is running in batch mode.");
  doifBatchCommand->SetParameterName("UIcommand", false);
  doifBatchCommand->SetToBeBroadcasted(false);
 
  doifInteractiveCommand = new G4UIcmdWithAString("/control/doifInteractive", this);
  doifInteractiveCommand->SetGuidance(
    "Execute a UI command if program is running in interactive mode.");
  doifInteractiveCommand->SetParameterName("UIcommand", false);
  doifInteractiveCommand->SetToBeBroadcasted(false);
}

~G4UIcontrolMessenger()

G4UIcontrolMessenger::~G4UIcontrolMessenger ( )

override

Definition at line 350 of file G4UIcontrolMessenger.cc.

{
  delete macroPathCommand;
  delete ExecuteCommand;
  delete suppressAbortionCommand;
  delete verboseCommand;
  delete doublePrecCommand;
  delete historyCommand;
  delete stopStoreHistoryCommand;
  delete ManualCommand;
  delete aliasCommand;
  delete unaliasCommand;
  delete listAliasCommand;
  delete getEnvCmd;
  delete getValCmd;
  delete echoCmd;
  delete shellCommand;
  delete loopCommand;
  delete foreachCommand;
  delete HTMLCommand;
  delete maxStoredHistCommand;
  delete ifCommand;
  delete doifCommand;
  delete addCommand;
  delete subtractCommand;
  delete multiplyCommand;
  delete divideCommand;
  delete remainderCommand;
  delete strifCommand;
  delete strdoifCommand;
  delete ifBatchCommand;
  delete ifInteractiveCommand;
  delete doifBatchCommand;
  delete doifInteractiveCommand;
  delete controlDirectory;
}

Member Function Documentation

GetCurrentValue()

G4String G4UIcontrolMessenger::GetCurrentValue ( G4UIcommand * command )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 707 of file G4UIcontrolMessenger.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  G4String currentValue;
 
  if (command == macroPathCommand) {
    currentValue = UI->GetMacroSearchPath();
  }
  if (command == verboseCommand) {
    currentValue = verboseCommand->ConvertToString(UI->GetVerboseLevel());
  }
  if (command == doublePrecCommand) {
    currentValue = doublePrecCommand->ConvertToString(G4UImanager::DoublePrecisionStr());
  }
  if (command == suppressAbortionCommand) {
    currentValue = suppressAbortionCommand->ConvertToString(
      G4StateManager::GetStateManager()->GetSuppressAbortion());
  }
  if (command == maxStoredHistCommand) {
    currentValue = maxStoredHistCommand->ConvertToString(UI->GetMaxHistSize());
  }
 
  return currentValue;
}

SetNewValue()

void G4UIcontrolMessenger::SetNewValue ( G4UIcommand * command, G4String newValue )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 388 of file G4UIcontrolMessenger.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
 
  if (command == macroPathCommand) {
    UI->SetMacroSearchPath(newValue);
    UI->ParseMacroSearchPath();
  }
  if (command == ExecuteCommand) {
    command->ResetFailure();
    UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
    if (UI->GetLastReturnCode() != 0) {
      G4ExceptionDescription ed;
      ed << "Command aborted (" << UI->GetLastReturnCode() << ")";
      command->CommandFailed(UI->GetLastReturnCode(), ed);
    }
  }
  if (command == suppressAbortionCommand) {
    G4StateManager::GetStateManager()->SetSuppressAbortion(
      suppressAbortionCommand->GetNewIntValue(newValue));
  }
  if (command == verboseCommand) {
    UI->SetVerboseLevel(verboseCommand->GetNewIntValue(newValue));
  }
  if (command == doublePrecCommand) {
    G4UImanager::UseDoublePrecisionStr(doublePrecCommand->GetNewBoolValue(newValue));
  }
  if (command == historyCommand) {
    UI->StoreHistory(newValue);
  }
  if (command == stopStoreHistoryCommand) {
    UI->StoreHistory(false);
  }
  if (command == ManualCommand) {
    UI->ListCommands(newValue);
  }
  if (command == aliasCommand) {
    UI->SetAlias(newValue);
  }
  if (command == unaliasCommand) {
    UI->RemoveAlias(newValue);
  }
  if (command == listAliasCommand) {
    UI->ListAlias();
  }
  if (command == getEnvCmd) {
    command->ResetFailure();
    if (std::getenv(newValue) != nullptr) {
      G4String st = newValue;
      st += " ";
      st += std::getenv(newValue);
      UI->SetAlias(st.c_str());
    }
    else {
      G4ExceptionDescription ed;
      ed << "<" << newValue << "> is not defined as a shell variable. Command ignored.";
      command->CommandFailed(ed);
    }
  }
  if (command == getValCmd) {
    G4Tokenizer next(newValue);
    const G4String& aliName = next();
    const G4String& com = next();
    const G4String& curVal = UI->GetCurrentValues(com);
    if (!(curVal.empty())) {
      G4String theValue = curVal;
      G4String iIdx = next();
      if (!(iIdx.empty())) {
        G4int idx = StoI(iIdx);
        G4Tokenizer nextVal(curVal);
        for (G4int i = 0; i <= idx; i++) {
          theValue = nextVal();
        }
      }
      G4String st = "/control/alias ";
      st += aliName + " " + theValue;
      UI->ApplyCommand(st);
    }
  }
  if (command == echoCmd) {
    G4cout << UI->SolveAlias(newValue) << G4endl;
  }
  if (command == shellCommand) {
    command->ResetFailure();
    G4int rc = system(newValue);
    if (rc < 0) {
      G4ExceptionDescription ed;
      ed << "<" << newValue << "> is not a valid shell command. Command ignored.";
      command->CommandFailed(ed);
    }
  }
  if (command == loopCommand) {
    command->ResetFailure();
    UI->LoopS(newValue);
    if (UI->GetLastReturnCode() != 0) {
      G4ExceptionDescription ed;
      ed << "Command aborted (" << UI->GetLastReturnCode() << ")";
      command->CommandFailed(UI->GetLastReturnCode(), ed);
    }
  }
  if (command == foreachCommand) {
    command->ResetFailure();
    UI->ForeachS(newValue);
    if (UI->GetLastReturnCode() != 0) {
      G4ExceptionDescription ed;
      ed << "Command aborted (" << UI->GetLastReturnCode() << ")";
      command->CommandFailed(UI->GetLastReturnCode(), ed);
    }
  }
  if (command == HTMLCommand) {
    UI->CreateHTML(newValue);
  }
  if (command == maxStoredHistCommand) {
    UI->SetMaxHistSize(maxStoredHistCommand->GetNewIntValue(newValue));
  }
  if (command == ifCommand) {
    G4Tokenizer next(newValue);
    G4double l = StoD(next());
    const G4String& comp = next();
    G4double r = StoD(next());
    const G4String& mac = next();
    G4bool x = false;
    if (comp == ">") {
      x = (l > r);
    }
    else if (comp == ">=") {
      x = (l >= r);
    }
    else if (comp == "<") {
      x = (l < r);
    }
    else if (comp == "<=") {
      x = (l <= r);
    }
    else if (comp == "==") {
      x = (l == r);
    }
    else if (comp == "!=") {
      x = (l != r);
    }
    if (x) {
      UI->ExecuteMacroFile(UI->FindMacroPath(mac));
    }
  }
  if (command == doifCommand) {
    G4Tokenizer next(newValue);
    G4double l = StoD(next());
    const G4String& comp = next();
    G4double r = StoD(next());
 
    G4String c1 = next();
    G4String ca;
    while (!((ca = next()).empty())) {
      c1 += " ";
      c1 += ca;
    }
    if (c1[0] == '"') {
      G4String strippedValue;
      if (c1.back() == '"') {
        strippedValue = c1.substr(1, c1.length() - 2);
      }
      else {
        strippedValue = c1.substr(1, c1.length() - 1);
      }
      c1 = std::move(strippedValue);
    }
 
    G4bool x = false;
    if (comp == ">") {
      x = (l > r);
    }
    else if (comp == ">=") {
      x = (l >= r);
    }
    else if (comp == "<") {
      x = (l < r);
    }
    else if (comp == "<=") {
      x = (l <= r);
    }
    else if (comp == "==") {
      x = (l == r);
    }
    else if (comp == "!=") {
      x = (l != r);
    }
    if (x) {
      UI->ApplyCommand(c1);
    }
  }
  if (command == addCommand) {
    G4Tokenizer next(newValue);
    const G4String& newA = next();
    G4double l = StoD(next());
    G4double r = StoD(next());
    G4String st = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l + r);
    UI->ApplyCommand(st);
  }
  if (command == subtractCommand) {
    G4Tokenizer next(newValue);
    const G4String& newA = next();
    G4double l = StoD(next());
    G4double r = StoD(next());
    G4String st = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l - r);
    UI->ApplyCommand(st);
  }
  if (command == multiplyCommand) {
    G4Tokenizer next(newValue);
    const G4String& newA = next();
    G4double l = StoD(next());
    G4double r = StoD(next());
    G4String st = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l * r);
    UI->ApplyCommand(st);
  }
  if (command == divideCommand) {
    G4Tokenizer next(newValue);
    const G4String& newA = next();
    G4double l = StoD(next());
    G4double r = StoD(next());
    G4String st = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l / r);
    UI->ApplyCommand(st);
  }
  if (command == remainderCommand) {
    G4Tokenizer next(newValue);
    const G4String& newA = next();
    G4int l = StoI(next());
    G4int r = StoI(next());
    G4String st = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l % r);
    UI->ApplyCommand(st);
  }
  if (command == strifCommand) {
    G4Tokenizer next(newValue);
    const G4String& l = next();
    const G4String& comp = next();
    const G4String& r = next();
    const G4String& mac = next();
    G4bool x = false;
    if (comp == "==") {
      x = (l == r);
    }
    else if (comp == "!=") {
      x = (l != r);
    }
    if (x) {
      UI->ExecuteMacroFile(UI->FindMacroPath(mac));
    }
  }
  if (command == strdoifCommand) {
    G4Tokenizer next(newValue);
    const G4String& l = next();
    const G4String& comp = next();
    const G4String& r = next();
 
    G4String c1 = next();
    G4String ca;
    while (!((ca = next()).empty())) {
      c1 += " ";
      c1 += ca;
    }
    if (c1[0] == '"') {
      G4String strippedValue;
      if (c1.back() == '"') {
        strippedValue = c1.substr(1, c1.length() - 2);
      }
      else {
        strippedValue = c1.substr(1, c1.length() - 1);
      }
      c1 = std::move(strippedValue);
    }
 
    G4bool x = false;
    if (comp == "==") {
      x = (l == r);
    }
    else if (comp == "!=") {
      x = (l != r);
    }
    if (x) {
      UI->ApplyCommand(c1);
    }
  }
  if (command == ifBatchCommand) {
    if (G4UIsession::InSession() == 0) {
      UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
    }
  }
  if (command == ifInteractiveCommand) {
    if (G4UIsession::InSession() > 0) {
      UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
    }
  }
  if (command == doifBatchCommand) {
    if (G4UIsession::InSession() == 0) {
      UI->ApplyCommand(newValue);
    }
  }
  if (command == doifInteractiveCommand) {
    if (G4UIsession::InSession() > 0) {
      UI->ApplyCommand(newValue);
    }
  }
}

---

The documentation for this class was generated from the following files:

• G4UIcontrolMessenger.hh
• G4UIcontrolMessenger.cc