G4UIcontrolMessenger Class Reference

#include <G4UIcontrolMessenger.hh>

Inheritance diagram for G4UIcontrolMessenger:

Collaboration diagram for G4UIcontrolMessenger:

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

Private Attributes
G4UIdirectory *	controlDirectory
G4UIcmdWithAString *	macroPathCommand
G4UIcmdWithAString *	ExecuteCommand
G4UIcmdWithAnInteger *	suppressAbortionCommand
G4UIcmdWithAnInteger *	verboseCommand
G4UIcmdWithAString *	historyCommand
G4UIcmdWithoutParameter *	stopStoreHistoryCommand
G4UIcommand *	aliasCommand
G4UIcmdWithAString *	unaliasCommand
G4UIcmdWithoutParameter *	listAliasCommand
G4UIcmdWithAString *	getEnvCmd
G4UIcommand *	getValCmd
G4UIcmdWithAString *	echoCmd
G4UIcmdWithAString *	shellCommand
G4UIcommand *	loopCommand
G4UIcommand *	foreachCommand
G4UIcmdWithAString *	ManualCommand
G4UIcmdWithAString *	HTMLCommand
G4UIcmdWithAnInteger *	maxStoredHistCommand
G4UIcommand *	ifCommand
G4UIcommand *	doifCommand
G4UIcommand *	addCommand
G4UIcommand *	subtractCommand
G4UIcommand *	multiplyCommand
G4UIcommand *	divideCommand
G4UIcommand *	remainderCommand

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (G4String s)
G4double	StoD (G4String s)
G4bool	StoB (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
G4String	baseDirName
G4bool	commandsShouldBeInMaster

Detailed Description

Definition at line 71 of file G4UIcontrolMessenger.hh.

Constructor & Destructor Documentation

G4UIcontrolMessenger()

G4UIcontrolMessenger::G4UIcontrolMessenger

(

)

Definition at line 45 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.");
  G4UIparameter* param1 = new G4UIparameter("macroFile",'s',false);
  loopCommand->SetParameter(param1);
  G4UIparameter* param2 = new G4UIparameter("counterName",'s',false);
  loopCommand->SetParameter(param2);
  G4UIparameter* param3 = new G4UIparameter("initialValue",'d',false);
  loopCommand->SetParameter(param3);
  G4UIparameter* param4 = new G4UIparameter("finalValue",'d',false);
  loopCommand->SetParameter(param4);
  G4UIparameter* 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.");
  G4UIparameter* param6 = new G4UIparameter("macroFile",'s',false);
  foreachCommand->SetParameter(param6);
  G4UIparameter* param7 = new G4UIparameter("counterName",'s',false);
  foreachCommand->SetParameter(param7);
  G4UIparameter* 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);
  
  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");
  
  stopStoreHistoryCommand 
    = new G4UIcmdWithoutParameter("/control/stopSavingHistory",this);
  stopStoreHistoryCommand->SetGuidance("Stop saving history file.");

  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("parenthis \"{\" and \"}\".");
  G4UIparameter* aliasNameParam = new G4UIparameter("aliasName",'s',false);
  aliasCommand->SetParameter(aliasNameParam);
  G4UIparameter* 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.");

  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>");
  G4UIparameter* aliName = new G4UIparameter("alias_name",'s',false);
  getValCmd->SetParameter(aliName);
  G4UIparameter* comName = new G4UIparameter("UI_command",'s',false);
  getValCmd->SetParameter(comName);

  echoCmd = new G4UIcmdWithAString("/control/echo",this);
  echoCmd->SetGuidance("Display the aliased value.");

  shellCommand = new G4UIcmdWithAString("/control/shell",this);
  shellCommand->SetGuidance("Execute a (Unix) SHELL command.");

  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>");
  G4UIparameter* leftParam = new G4UIparameter("left",'d',false);
  ifCommand->SetParameter(leftParam);
  G4UIparameter* compParam = new G4UIparameter("comp",'s',false);
  compParam->SetParameterCandidates("> >= < <= == !=");
  ifCommand->SetParameter(compParam);
  G4UIparameter* rightParam = new G4UIparameter("right",'d',false);
  ifCommand->SetParameter(rightParam);
  G4UIparameter* macroFileParam = new G4UIparameter("aliasValue",'s',false);
  ifCommand->SetParameter(macroFileParam);
  ifCommand->SetToBeBroadcasted(false);

  doifCommand = new G4UIcommand("/control/doif",this);
  doifCommand->SetGuidance("Execute a macro file if the expression is true.");
  doifCommand->SetGuidance(" Syntax : <double> <comp> <double> <UI_command>");
  G4UIparameter* doleftParam = new G4UIparameter("left",'d',false);
  doifCommand->SetParameter(doleftParam);
  G4UIparameter* docompParam = new G4UIparameter("comp",'s',false);
  docompParam->SetParameterCandidates("> >= < <= == !=");
  doifCommand->SetParameter(docompParam);
  G4UIparameter* dorightParam = new G4UIparameter("right",'d',false);
  doifCommand->SetParameter(dorightParam);
  G4UIparameter* 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.");
  G4UIparameter* newAlias1 = new G4UIparameter("new_alias",'s',false);
  addCommand->SetParameter(newAlias1);
  G4UIparameter* val1a = new G4UIparameter("value1",'d',false);
  addCommand->SetParameter(val1a);
  G4UIparameter* 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.");
  G4UIparameter* newAlias2 = new G4UIparameter("new_alias",'s',false);
  subtractCommand->SetParameter(newAlias2);
  G4UIparameter* val2a = new G4UIparameter("value1",'d',false);
  subtractCommand->SetParameter(val2a);
  G4UIparameter* 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 multiplification 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.");
  G4UIparameter* newAlias3 = new G4UIparameter("new_alias",'s',false);
  multiplyCommand->SetParameter(newAlias3);
  G4UIparameter* val3a = new G4UIparameter("value1",'d',false);
  multiplyCommand->SetParameter(val3a);
  G4UIparameter* 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.");
  G4UIparameter* newAlias4 = new G4UIparameter("new_alias",'s',false);
  divideCommand->SetParameter(newAlias4);
  G4UIparameter* val4a = new G4UIparameter("value1",'d',false);
  divideCommand->SetParameter(val4a);
  G4UIparameter* 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.");
  G4UIparameter* newAlias5 = new G4UIparameter("new_alias",'s',false);
  remainderCommand->SetParameter(newAlias5);
  G4UIparameter* val5a = new G4UIparameter("value1",'i',false);
  remainderCommand->SetParameter(val5a);
  G4UIparameter* val5b = new G4UIparameter("value2",'i',false);
  val4b->SetParameterRange("value2 != 0");
  remainderCommand->SetParameter(val5b);
  remainderCommand->SetToBeBroadcasted(false);

}

Here is the call graph for this function:

~G4UIcontrolMessenger()

G4UIcontrolMessenger::~G4UIcontrolMessenger

(

)

Definition at line 272 of file G4UIcontrolMessenger.cc.

{
  delete macroPathCommand;
  delete ExecuteCommand;
  delete suppressAbortionCommand;
  delete verboseCommand;
  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 controlDirectory;
}

Member Function Documentation

GetCurrentValue()

G4String G4UIcontrolMessenger::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 506 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==suppressAbortionCommand)
  {
    currentValue = suppressAbortionCommand->ConvertToString(G4StateManager::GetStateManager()->GetSuppressAbortion());
  }
  if(command==maxStoredHistCommand)
  {
    currentValue = maxStoredHistCommand->ConvertToString(UI->GetMaxHistSize());
  }
  
  return currentValue;
}

Here is the call graph for this function:

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 303 of file G4UIcontrolMessenger.cc.

{
  G4UImanager * UI = G4UImanager::GetUIpointer();

  if( command == macroPathCommand) {
    UI-> SetMacroSearchPath(newValue);
    UI-> ParseMacroSearchPath();
  }  
  if(command==ExecuteCommand)
  {
    UI-> ExecuteMacroFile(UI-> FindMacroPath(newValue));
  }
  if(command==suppressAbortionCommand)
  {
    G4StateManager::GetStateManager()->SetSuppressAbortion(suppressAbortionCommand->GetNewIntValue(newValue));
  }
  if(command==verboseCommand)
  {
    UI->SetVerboseLevel(verboseCommand->GetNewIntValue(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)
  {
    if(getenv(newValue))
    { 
      G4String st = "/control/alias ";
      st += newValue;
      st += " ";
      st += getenv(newValue);
      UI->ApplyCommand(st);
    }
    else
    { G4cerr << "<" << newValue << "> is not defined as a shell variable. Command ignored." << G4endl; }
  }
  if(command==getValCmd)
  {
    G4Tokenizer next(newValue);
    G4String aliName = next();
    G4String com = next();
    G4String curVal = UI->GetCurrentValues(com);
    if(!(curVal.isNull()))
    { 
      G4String st = "/control/alias ";
      st += aliName + " " + curVal;
      UI->ApplyCommand(st);
    }
  }
  if(command==echoCmd)
  { G4cout << UI->SolveAlias(newValue) << G4endl; }
  if(command==shellCommand)
  {
    system(newValue);
  }
  if(command==loopCommand)
  {
    UI->LoopS(newValue);
  }
  if(command==foreachCommand)
  {
    UI->ForeachS(newValue);
  }
  if(command==HTMLCommand)
  {
    UI->CreateHTML(newValue);
  }
  if(command==maxStoredHistCommand)
  {
    UI->SetMaxHistSize(maxStoredHistCommand->GetNewIntValue(newValue));
  }
  if(command==ifCommand)
  {
    G4Tokenizer next(newValue);
    G4double l = StoD(next());
    G4String comp = next();
    G4double r = StoD(next());
    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(mac);
  }
  if(command==doifCommand)
  {
    G4Tokenizer next(newValue);
    G4double l = StoD(next());
    G4String comp = next();
    G4double r = StoD(next());

    G4String c1 = next();
    G4String ca;
    while(!((ca=next()).isNull()))
    {
      c1 += " ";
      c1 += ca;
    }
    if(c1(0)=='"')
    {
      G4String strippedValue;
      if(c1(c1.length()-1)=='"')
      { strippedValue = c1(1,c1.length()-2); }
      else
      { strippedValue = c1(1,c1.length()-1); }
      c1 = 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);
    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);
    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);
    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);
    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);
    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);
  }
}

Here is the call graph for this function:

Member Data Documentation

addCommand

G4UIcommand* G4UIcontrolMessenger::addCommand

private

Definition at line 101 of file G4UIcontrolMessenger.hh.

aliasCommand

G4UIcommand* G4UIcontrolMessenger::aliasCommand

private

Definition at line 87 of file G4UIcontrolMessenger.hh.

controlDirectory

G4UIdirectory* G4UIcontrolMessenger::controlDirectory

private

Definition at line 80 of file G4UIcontrolMessenger.hh.

divideCommand

G4UIcommand* G4UIcontrolMessenger::divideCommand

private

Definition at line 104 of file G4UIcontrolMessenger.hh.

doifCommand

G4UIcommand* G4UIcontrolMessenger::doifCommand

private

Definition at line 100 of file G4UIcontrolMessenger.hh.

echoCmd

G4UIcmdWithAString* G4UIcontrolMessenger::echoCmd

private

Definition at line 92 of file G4UIcontrolMessenger.hh.

ExecuteCommand

G4UIcmdWithAString* G4UIcontrolMessenger::ExecuteCommand

private

Definition at line 82 of file G4UIcontrolMessenger.hh.

foreachCommand

G4UIcommand* G4UIcontrolMessenger::foreachCommand

private

Definition at line 95 of file G4UIcontrolMessenger.hh.

getEnvCmd

G4UIcmdWithAString* G4UIcontrolMessenger::getEnvCmd

private

Definition at line 90 of file G4UIcontrolMessenger.hh.

getValCmd

G4UIcommand* G4UIcontrolMessenger::getValCmd

private

Definition at line 91 of file G4UIcontrolMessenger.hh.

historyCommand

G4UIcmdWithAString* G4UIcontrolMessenger::historyCommand

private

Definition at line 85 of file G4UIcontrolMessenger.hh.

HTMLCommand

G4UIcmdWithAString* G4UIcontrolMessenger::HTMLCommand

private

Definition at line 97 of file G4UIcontrolMessenger.hh.

ifCommand

G4UIcommand* G4UIcontrolMessenger::ifCommand

private

Definition at line 99 of file G4UIcontrolMessenger.hh.

listAliasCommand

G4UIcmdWithoutParameter* G4UIcontrolMessenger::listAliasCommand

private

Definition at line 89 of file G4UIcontrolMessenger.hh.

loopCommand

G4UIcommand* G4UIcontrolMessenger::loopCommand

private

Definition at line 94 of file G4UIcontrolMessenger.hh.

macroPathCommand

G4UIcmdWithAString* G4UIcontrolMessenger::macroPathCommand

private

Definition at line 81 of file G4UIcontrolMessenger.hh.

ManualCommand

G4UIcmdWithAString* G4UIcontrolMessenger::ManualCommand

private

Definition at line 96 of file G4UIcontrolMessenger.hh.

maxStoredHistCommand

G4UIcmdWithAnInteger* G4UIcontrolMessenger::maxStoredHistCommand

private

Definition at line 98 of file G4UIcontrolMessenger.hh.

multiplyCommand

G4UIcommand* G4UIcontrolMessenger::multiplyCommand

private

Definition at line 103 of file G4UIcontrolMessenger.hh.

remainderCommand

G4UIcommand* G4UIcontrolMessenger::remainderCommand

private

Definition at line 105 of file G4UIcontrolMessenger.hh.

shellCommand

G4UIcmdWithAString* G4UIcontrolMessenger::shellCommand

private

Definition at line 93 of file G4UIcontrolMessenger.hh.

stopStoreHistoryCommand

G4UIcmdWithoutParameter* G4UIcontrolMessenger::stopStoreHistoryCommand

private

Definition at line 86 of file G4UIcontrolMessenger.hh.

subtractCommand

G4UIcommand* G4UIcontrolMessenger::subtractCommand

private

Definition at line 102 of file G4UIcontrolMessenger.hh.

suppressAbortionCommand

G4UIcmdWithAnInteger* G4UIcontrolMessenger::suppressAbortionCommand

private

Definition at line 83 of file G4UIcontrolMessenger.hh.

unaliasCommand

G4UIcmdWithAString* G4UIcontrolMessenger::unaliasCommand

private

Definition at line 88 of file G4UIcontrolMessenger.hh.

verboseCommand

G4UIcmdWithAnInteger* G4UIcontrolMessenger::verboseCommand

private

Definition at line 84 of file G4UIcontrolMessenger.hh.

---

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

• G4UIcontrolMessenger.hh
• G4UIcontrolMessenger.cc