G4UIcommandTree Class Reference

#include <G4UIcommandTree.hh>

Public Member Functions
void	AddNewCommand (G4UIcommand *newCommand, G4bool workerThreadOnly=false)
G4String	CompleteCommandPath (const G4String &commandPath)
void	CreateHTML (G4String="")
G4UIcommandTree *	FindCommandTree (const char *commandPath)
G4UIcommand *	FindPath (const char *commandPath) const
	G4UIcommandTree ()
	G4UIcommandTree (const char *thePathName)
G4UIcommand *	GetCommand (G4int i)
G4int	GetCommandEntry () const
G4String	GetFirstMatchedString (const G4String &, const G4String &) const
const G4UIcommand *	GetGuidance () const
const G4String &	GetPathName () const
const G4String	GetTitle () const
G4UIcommandTree *	GetTree (const char *comNameC)
G4UIcommandTree *	GetTree (G4int i)
G4int	GetTreeEntry () const
void	List () const
void	ListCurrent () const
void	ListCurrentWithNum () const
G4bool	operator!= (const G4UIcommandTree &right) const
G4bool	operator== (const G4UIcommandTree &right) const
void	RemoveCommand (G4UIcommand *aCommand, G4bool workerThreadOnly=false)
	~G4UIcommandTree ()

Private Member Functions
G4String	CreateFileName (const char *pName)
G4String	ModStr (const char *strS)

Private Attributes
G4bool	broadcastCommands = true
std::vector< G4UIcommand * >	command
G4int	createHTMLTreeLevel = 0
G4UIcommand *	guidance = nullptr
G4bool	ifSort = false
G4String	pathName
std::vector< G4UIcommandTree * >	tree

Detailed Description

Definition at line 44 of file G4UIcommandTree.hh.

Constructor & Destructor Documentation

G4UIcommandTree() [1/2]

G4UIcommandTree::G4UIcommandTree

(

)

Definition at line 41 of file G4UIcommandTree.cc.

{
}

Referenced by AddNewCommand().

G4UIcommandTree() [2/2]

G4UIcommandTree::G4UIcommandTree

(

const char *

thePathName

)

Definition at line 46 of file G4UIcommandTree.cc.

{
  pathName = thePathName;
}

References pathName.

~G4UIcommandTree()

G4UIcommandTree::~G4UIcommandTree

(

)

Definition at line 52 of file G4UIcommandTree.cc.

{
  G4int i;
  G4int n_treeEntry = tree.size();
  for(i = 0; i < n_treeEntry; ++i)
  {
    delete tree[i];
  }
}

References tree.

Member Function Documentation

AddNewCommand()

void G4UIcommandTree::AddNewCommand	(	G4UIcommand *	newCommand,
		G4bool	workerThreadOnly = false
	)

Definition at line 75 of file G4UIcommandTree.cc.

{
  G4String commandPath   = newCommand->GetCommandPath();
  G4String remainingPath = commandPath;
  remainingPath.erase(0, pathName.length());
  if(remainingPath.empty())
  {
    if(!guidance)
    {
      guidance = newCommand;
      if(!(newCommand->ToBeBroadcasted()))
      { broadcastCommands = false; }
      if(workerThreadOnly)
      { newCommand->SetWorkerThreadOnly(); }
    }
    return;
  }
 
  if(guidance)
  {
    G4UIdirectory* dir = static_cast<G4UIdirectory*>(guidance);
    ifSort = dir->IfSort();
  }
  G4int i = remainingPath.find('/');
  if(i == G4int(std::string::npos))
  {
    // Adding a new command to this directory
    G4int n_commandEntry = command.size();
    for(G4int i_thCommand = 0; i_thCommand < n_commandEntry; ++i_thCommand)
    {
      if(remainingPath == command[i_thCommand]->GetCommandName())
      {
        // a command of same name has already defined. do nothing and return.
        if(G4UImanager::GetUIpointer()->GetVerboseLevel() > 8)
        {
          G4ExceptionDescription ed;
          ed << "Command <" << commandPath << "> already exist. New command is not added.";
          G4Exception("G4UIcommandTree::AddNewCommand","UI_ComTree_001",
                     //FatalException,
                     JustWarning,
                     ed);
        }
        return;
      }
    }
    if(!broadcastCommands)
    { newCommand->SetToBeBroadcasted(false); }
    if(workerThreadOnly)
    { newCommand->SetWorkerThreadOnly(); }
    if(ifSort)
    {
      auto j = command.begin();
      for(; j != command.end(); ++j) {
        if (newCommand->GetCommandPath() < (*j)->GetCommandPath()) { break; }
      }
      command.insert(j,newCommand);
    }
    else
    { command.push_back(newCommand); }
    return;
  }
  else
  {
    // Adding a new command to a sub-directory
    G4String nextPath = pathName;
    nextPath.append(remainingPath.substr(0, i + 1));
    G4int n_treeEntry = tree.size();
    for(G4int i_thTree = 0; i_thTree < n_treeEntry; ++i_thTree)
    {
      if(nextPath == tree[i_thTree]->GetPathName())
      {
        if(!broadcastCommands)
          newCommand->SetToBeBroadcasted(false);
        tree[i_thTree]->AddNewCommand(newCommand, workerThreadOnly);
        return;
      }
    }
    // Creating a new sub-directory
    G4UIcommandTree* newTree = new G4UIcommandTree(nextPath);
    if(ifSort)
    {
      auto j = tree.begin();
      for(; j != tree.end(); ++j) {
        if (newTree->GetPathName() < (*j)->GetPathName()) { break; }
      }
      tree.insert(j,newTree);
    }
    else
    { tree.push_back(newTree); }
    if(!broadcastCommands)
    { newCommand->SetToBeBroadcasted(false); }
    // In case a new sub-directry is created with a new G4UIdirectory
    // (most-likely this is the case), inherit the sort flag
    newCommand->SetDefaultSortFlag(ifSort);
    newTree->AddNewCommand(newCommand, workerThreadOnly);
    return;
  }
}

References AddNewCommand(), broadcastCommands, command, G4Exception(), G4UIcommandTree(), G4UIcommand::GetCommandPath(), GetPathName(), G4UImanager::GetUIpointer(), G4UImanager::GetVerboseLevel(), guidance, ifSort, G4UIdirectory::IfSort(), JustWarning, pathName, G4UIcommand::SetDefaultSortFlag(), G4UIcommand::SetToBeBroadcasted(), G4UIcommand::SetWorkerThreadOnly(), G4UIcommand::ToBeBroadcasted(), and tree.

Referenced by G4UImanager::AddNewCommand(), AddNewCommand(), and G4UImanager::AddWorkerCommand().

CompleteCommandPath()

G4String G4UIcommandTree::CompleteCommandPath

(

const G4String &

commandPath

)

Definition at line 311 of file G4UIcommandTree.cc.

{
  G4String pName         = aCommandPath;
  G4String remainingPath = aCommandPath;
  G4String empty         = "";
  G4String matchingPath  = empty;
 
  // find the tree
  auto jpre = pName.rfind('/');
  if(jpre != G4String::npos)
    pName.erase(jpre + 1);
  G4UIcommandTree* aTree = FindCommandTree(pName);
 
  if(!aTree)
  {
    return empty;
  }
 
  if(pName.find(pName) == std::string::npos)
    return empty;
 
  std::vector<G4String> paths;
 
  // list matched directories/commands
  G4String strtmp;
  G4int nMatch = 0;
 
  G4int Ndir = aTree->GetTreeEntry();
  G4int Ncmd = aTree->GetCommandEntry();
 
  // directory ...
  for(G4int idir = 1; idir <= Ndir; ++idir)
  {
    G4String fpdir = aTree->GetTree(idir)->GetPathName();
    // matching test
    if(fpdir.find(remainingPath, 0) == 0)
    {
      if(nMatch == 0)
      {
        matchingPath = fpdir;
      }
      else
      {
        matchingPath = GetFirstMatchedString(fpdir, matchingPath);
      }
      ++nMatch;
      paths.push_back(fpdir);
    }
  }
 
  if(paths.size() >= 2)
  {
    G4cout << "Matching directories :" << G4endl;
    for(unsigned int i_thCommand = 0; i_thCommand < paths.size(); ++i_thCommand)
    {
      G4cout << paths[i_thCommand] << G4endl;
    }
  }
 
  // command ...
  std::vector<G4String> commands;
 
  for(G4int icmd = 1; icmd <= Ncmd; ++icmd)
  {
    G4String fpcmd =
      aTree->GetPathName() + aTree->GetCommand(icmd)->GetCommandName();
    // matching test
    if(fpcmd.find(remainingPath, 0) == 0)
    {
      if(nMatch == 0)
      {
        matchingPath = fpcmd + " ";
      }
      else
      {
        strtmp       = fpcmd + " ";
        matchingPath = GetFirstMatchedString(matchingPath, strtmp);
      }
      nMatch++;
      commands.push_back(fpcmd + " ");
    }
  }
 
  if(commands.size() >= 2)
  {
    G4cout << "Matching commands :" << G4endl;
    for(unsigned int i_thCommand = 0; i_thCommand < commands.size();
        ++i_thCommand)
    {
      G4cout << commands[i_thCommand] << G4endl;
    }
  }
 
  return matchingPath;
}

References anonymous_namespace{G4MTcoutDestination.cc}::empty, FindCommandTree(), G4cout, G4endl, GetCommand(), GetCommandEntry(), G4UIcommand::GetCommandName(), GetFirstMatchedString(), GetPathName(), GetTree(), and GetTreeEntry().

CreateFileName()

G4String G4UIcommandTree::CreateFileName ( const char *  pName )

private

Definition at line 513 of file G4UIcommandTree.cc.

{
  G4String fn = pName;
  G4int idxs;
  while((idxs = fn.find("/")) != G4int(std::string::npos))
  {
    fn[idxs] = '_';
  }
  fn += ".html";
  return fn;
}

Referenced by CreateHTML().

CreateHTML()

void G4UIcommandTree::CreateHTML

(

G4String

sideBar = ""

)

Definition at line 552 of file G4UIcommandTree.cc.

{
  G4String ofileName = CreateFileName(pathName);
  std::ofstream oF(ofileName, std::ios::out);
 
  oF << "<html><head><title>Commands in " << ModStr(pathName)
     << "</title></head>" << G4endl;
    oF << "<style> \
    table,table td,table th { \
       border:1px solid #eee \
    } \
    table td,table th { \
      padding:5px 20px; \
      line-height:1.3; \
      text-align:inherit \
    } \
    a { \
      color:#17a81a; \
      text-decoration:none; \
      transition-duration:0.3s \
    } \
      a:hover { \
      color:#17a81a \
    } \
    table { \
      border-collapse:collapse; \
      border-spacing:0; \
      margin-bottom:5px; \
    } \
    h1 { \
      font-size:2.25em; \
      font-weight:300; \
      letter-spacing:-1px; \
      line-height:1.15em; \
      margin-bottom:0.5em; \
      word-wrap:break-word \
    } \
    h2 { \
      font-size:1.5em; \
      font-weight:300; \
      letter-spacing:-1px; \
      line-height:1.15em; \
      margin-bottom:0.5em; \
      word-wrap:break-word \
    } \
    h3 { \
      color:#26282a; \
      font-weight:300; \
      font-size:1.3em; \
      padding:15px 0 15px 0; \
      border-bottom:2px #eee solid; \
      word-wrap:break-word \
    } \
    .sidebar { \
      display:block; \
      position:relative; \
      position:sticky; \
      float:left; \
      -webkit-box-sizing:border-box; \
      -moz-box-sizing:border-box; \
      -ms-box-sizing:border-box; \
      box-sizing:border-box; \
      width:20%; \
      padding-right:20px \
    } \
    .context { \
    width:80%; \
    display:inline-block; \
    background-color:#fff; \
    padding: 25px 35px 20px 30px; \
    -webkit-box-sizing:border-box; \
    -moz-box-sizing:border-box; \
    -ms-box-sizing:border-box; \
    box-sizing:border-box \
  } \
    </style>"<< G4endl;
  oF << "<body bgcolor=\"#ffffff\">" << G4endl;
 
    // Left Panel
  if (createHTMLTreeLevel == 0 ) {
    oF << "<div class=\"sidebar\">" << sideBar << "</div>" << G4endl;
  }
  // Right Panel
  oF << "<div class=\"context\">";
  oF <<  "<h1>" << ModStr(pathName) << "</h1>" << G4endl;
 
  if(guidance != nullptr)
  {
    for(std::size_t i = 0; i < guidance->GetGuidanceEntries(); ++i)
    {
      oF << ModStr(guidance->GetGuidanceLine(i)) << "<br>" << G4endl;
    }
  }
  if (tree.size() >0 ){
    G4String menu = "";
    G4String newSideBar = "";
    menu += "<h2>Sub-directories </h2><table>";
      newSideBar += "<h2><a href=\"" + ofileName + "\">Top level </a></h2><table>";
    // Build menu short version
    for(std::size_t i_thTree = 0; i_thTree < tree.size(); ++i_thTree)
    {
        newSideBar += "<tr><td><a href=\""
         + CreateFileName(tree[i_thTree]->GetPathName()) + "\">"
         + ModStr(tree[i_thTree]->GetPathName()) + "</a>";
    }
    // Build menu
      for(std::size_t i_thTree = 0; i_thTree < tree.size(); ++i_thTree)
    {
      menu += "<tr><td><a href=\""
         + CreateFileName(tree[i_thTree]->GetPathName()) + "\">"
         + ModStr(tree[i_thTree]->GetPathName()) + "</a>";
      menu += "</td><td>" + ModStr(tree[i_thTree]->GetTitle()) + "</tr>";
    }
    menu += "</table>";
      newSideBar += "</table>";
    for(std::size_t i_thTree = 0; i_thTree < tree.size(); ++i_thTree)
    {
        createHTMLTreeLevel ++;
        tree[i_thTree]->CreateHTML(newSideBar);
        createHTMLTreeLevel --;
    }
    oF << menu << G4endl;
  }
 
  if (command.size() >0 ){
    oF << "<h2>Commands </h2>" << G4endl;
      
    // resume
    oF << "<table>" << G4endl;
    for(std::size_t i_thCommand = 0; i_thCommand < command.size(); ++i_thCommand)
    {
      G4UIcommand* cmd = command[i_thCommand];
      oF << "<tr><td><a href=\"#c"<< i_thCommand << "\">"<< ModStr(cmd->GetCommandName());
      oF << "</a></td></tr>" << G4endl;
    }
    oF << "</table>" << G4endl;
    for(std::size_t i_thCommand = 0; i_thCommand < command.size(); ++i_thCommand)
    {
      G4UIcommand* cmd = command[i_thCommand];
      oF << "<h3 id=\"c" << i_thCommand << "\">" << ModStr(cmd->GetCommandName());
      if(cmd->GetParameterEntries() > 0)
      {
        for(std::size_t i_thParam = 0; i_thParam < cmd->GetParameterEntries();
            ++i_thParam)
        {
          oF << " [<i>"
             << ModStr(cmd->GetParameter(i_thParam)->GetParameterName())
             << "</i>]";
        }
      }
      oF << "</h3>" << G4endl;
      oF << "<p>" << G4endl;
      for(std::size_t i = 0; i < cmd->GetGuidanceEntries(); ++i)
      {
        oF << ModStr(cmd->GetGuidanceLine(i)) << "<br>" << G4endl;
      }
      if(!(cmd->GetRange()).empty())
      {
        oF << "<p>Range : " << ModStr(cmd->GetRange()) << G4endl;
      }
      std::vector<G4ApplicationState>* availabelStateList = cmd->GetStateList();
      if(availabelStateList->size() == 6)
      {
        oF << "<p>Available at all Geant4 states." << G4endl;
      }
      else
      {
        oF << "<p>Available Geant4 state(s) : ";
        for(std::size_t ias = 0; ias < availabelStateList->size(); ++ias)
        {
          oF << G4StateManager::GetStateManager()->GetStateString(
                  (*availabelStateList)[ias])
             << " " << G4endl;
        }
      }
      if(cmd->GetParameterEntries() > 0)
      {
        oF << "<p>Parameters<table border=1>" << G4endl;
        for(std::size_t i_thParam = 0; i_thParam < cmd->GetParameterEntries();
            ++i_thParam)
        {
          G4UIparameter* prm = cmd->GetParameter(i_thParam);
          oF << "<tr><td>" << ModStr(prm->GetParameterName()) << G4endl;
          oF << "<td>type " << prm->GetParameterType() << G4endl;
          oF << "<td>";
          if(prm->IsOmittable())
          {
            oF << "Omittable : ";
            if(prm->GetCurrentAsDefault())
            {
              oF << "current value is used as the default value." << G4endl;
            }
            else
            {
              oF << "default value = " << prm->GetDefaultValue() << G4endl;
            }
          }
          oF << "<td>";
          if(!(prm->GetParameterRange()).empty())
          {
            oF << "Parameter range : " << ModStr(prm->GetParameterRange())
               << G4endl;
          }
          else if(!(prm->GetParameterCandidates()).empty())
          {
            oF << "Parameter candidates : "
               << ModStr(prm->GetParameterCandidates()) << G4endl;
          }
        }
        oF << "</table>" << G4endl;
      }
    }
  }
  oF << "</div></body></html>" << G4endl;
  oF.close();
}

References command, CreateFileName(), createHTMLTreeLevel, G4endl, G4UIcommand::GetCommandName(), G4UIparameter::GetCurrentAsDefault(), G4UIparameter::GetDefaultValue(), G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), G4UIcommand::GetParameter(), G4UIparameter::GetParameterCandidates(), G4UIcommand::GetParameterEntries(), G4UIparameter::GetParameterName(), G4UIparameter::GetParameterRange(), G4UIparameter::GetParameterType(), GetPathName(), G4UIcommand::GetRange(), G4UIcommand::GetStateList(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), GetTitle(), guidance, G4UIparameter::IsOmittable(), ModStr(), pathName, and tree.

Referenced by G4UImanager::CreateHTML(), and export_G4UIcommandTree().

FindCommandTree()

G4UIcommandTree * G4UIcommandTree::FindCommandTree

(

const char *

commandPath

)

Definition at line 272 of file G4UIcommandTree.cc.

{
  // Try to match a command or a path with the one given.
  // @commandPath : command or path to match
  // @return the commandTree found or nullptr if not
 
  G4String remainingPath = commandPath;
  if(remainingPath.find(pathName) == std::string::npos)
  {
    return nullptr;
  }
  remainingPath.erase(0, pathName.length());
  G4int i = remainingPath.find('/');
  if(i != G4int(std::string::npos))
  {
    // Find path
    G4String nextPath = pathName;
    nextPath.append(remainingPath.substr(0, i + 1));
    G4int n_treeEntry = tree.size();
    for(G4int i_thTree = 0; i_thTree < n_treeEntry; ++i_thTree)
    {
      if(tree[i_thTree]->GetPathName() == commandPath)
      {
        return tree[i_thTree];
      }
      else if(nextPath == tree[i_thTree]->GetPathName())
      {
        return tree[i_thTree]->FindCommandTree(commandPath);
      }
    }
  }
  else
  {
    return this;
  }
  return nullptr;
}

References GetPathName(), pathName, and tree.

Referenced by CompleteCommandPath(), G4UIQt::CreateCompleterModel(), G4UImessenger::CreateDirectory(), G4UIWin32::GetHelpTreeToolTips(), G4UIQt::HelpTreeClicCallback(), G4UIQt::UpdateCommandCompleter(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

FindPath()

G4UIcommand * G4UIcommandTree::FindPath

(

const char *

commandPath

)

const

Definition at line 231 of file G4UIcommandTree.cc.

{
  // This function tries to match a command name
 
  G4String remainingPath = commandPath;
  if(remainingPath.find(pathName) == std::string::npos)
  {
    return nullptr;
  }
  remainingPath.erase(0, pathName.length());
  G4int i = remainingPath.find('/');
  if(i == G4int(std::string::npos))
  {
    // Find command
    G4int n_commandEntry = command.size();
    for(G4int i_thCommand = 0; i_thCommand < n_commandEntry; ++i_thCommand)
    {
      if(remainingPath == command[i_thCommand]->GetCommandName())
      {
        return command[i_thCommand];
      }
    }
  }
  else
  {
    // Find path
    G4String nextPath = pathName;
    nextPath.append(remainingPath.substr(0, i + 1));
    G4int n_treeEntry = tree.size();
    for(G4int i_thTree = 0; i_thTree < n_treeEntry; ++i_thTree)
    {
      if(nextPath == tree[i_thTree]->GetPathName())
      {
        return tree[i_thTree]->FindPath(commandPath);
      }
    }
  }
  return nullptr;
}

References command, GetPathName(), pathName, and tree.

Referenced by G4UIQt::AddButton(), G4UIQt::AddIcon(), G4UImanager::ApplyCommand(), G4UIQt::ButtonCallback(), G4CascadeParamMessenger::CreateDirectory(), export_G4UIcommandTree(), G4UImanager::FindCommand(), G4VBasicShell::FindCommand(), G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume(), G4VisCommandDrawVolume::G4VisCommandDrawVolume(), G4VisCommandSceneAddMagneticField::G4VisCommandSceneAddMagneticField(), G4UImanager::GetCurrentValues(), G4UIWin32::GetHelpTreeToolTips(), G4UIQt::HelpTreeClicCallback(), G4UIQt::OpenHelpTreeOnCommand(), and G4VBasicShell::TerminalHelp().

GetCommand()

G4UIcommand * G4UIcommandTree::GetCommand ( G4int  i )

inline

Definition at line 77 of file G4UIcommandTree.hh.

{ return command[i - 1]; }

References command.

Referenced by CompleteCommandPath(), G4UIWin32::CreateHelpTree(), G4UIQt::CreateHelpTree(), export_G4UIcommandTree(), G4UIQt::LookForHelpStringInChildTree(), G4VBasicShell::TerminalHelp(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

GetCommandEntry()

G4int G4UIcommandTree::GetCommandEntry ( ) const

inline

Definition at line 74 of file G4UIcommandTree.hh.

{ return G4int(command.size()); }

References command.

Referenced by CompleteCommandPath(), G4UIWin32::CreateHelpTree(), G4UIQt::CreateHelpTree(), export_G4UIcommandTree(), G4UIQt::LookForHelpStringInChildTree(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

GetFirstMatchedString()

G4String G4UIcommandTree::GetFirstMatchedString	(	const G4String &	str1,
		const G4String &	str2
	)		const

Definition at line 408 of file G4UIcommandTree.cc.

{
  G4int nlen1 = str1.length();
  G4int nlen2 = str2.length();
 
  G4int nmin = nlen1 < nlen2 ? nlen1 : nlen2;
 
  G4String strMatched;
  for(size_t i = 0; G4int(i) < nmin; ++i)
  {
    if(str1[i] == str2[i])
    {
      strMatched += str1[i];
    }
    else
    {
      break;
    }
  }
 
  return strMatched;
}

Referenced by CompleteCommandPath(), and G4UIQt::CreateCompleterModel().

GetGuidance()

const G4UIcommand * G4UIcommandTree::GetGuidance ( ) const

inline

Definition at line 71 of file G4UIcommandTree.hh.

{ return guidance; }

References guidance.

Referenced by export_G4UIcommandTree(), ListCurrent(), and G4UIQt::LookForHelpStringInChildTree().

GetPathName()

const G4String & G4UIcommandTree::GetPathName ( ) const

inline

Definition at line 72 of file G4UIcommandTree.hh.

{ return pathName; }

References pathName.

Referenced by AddNewCommand(), CompleteCommandPath(), G4UImessenger::CreateDirectory(), G4UIWin32::CreateHelpTree(), G4UIQt::CreateHelpTree(), CreateHTML(), export_G4UIcommandTree(), G4UIQt::FillHelpTree(), FindCommandTree(), FindPath(), GetTree(), G4UIWin32::InitHelpTreeItems(), G4UIQt::LookForHelpStringInChildTree(), G4UIQt::OpenHelpTreeOnCommand(), operator!=(), operator==(), and RemoveCommand().

GetTitle()

const G4String G4UIcommandTree::GetTitle ( ) const

inline

Definition at line 78 of file G4UIcommandTree.hh.

    {
      return (guidance == nullptr) ? G4String("...Title not available...")
                                   : guidance->GetTitle();
    }

References G4UIcommand::GetTitle(), and guidance.

Referenced by CreateHTML(), export_G4UIcommandTree(), G4UIWin32::GetHelpTreeToolTips(), and G4UIQt::HelpTreeClicCallback().

GetTree() [1/2]

G4UIcommandTree * G4UIcommandTree::GetTree

(

const char *

comNameC

)

Definition at line 770 of file G4UIcommandTree.cc.

{
  G4String comName = comNameC;
  for(std::size_t i = 0; i < tree.size(); ++i)
  {
    if(comName == tree[i]->GetPathName())
    {
      return tree[i];
    }
  }
  return nullptr;
}

References GetPathName(), and tree.

GetTree() [2/2]

G4UIcommandTree * G4UIcommandTree::GetTree ( G4int  i )

inline

Definition at line 75 of file G4UIcommandTree.hh.

{ return tree[i - 1]; }

References tree.

Referenced by CompleteCommandPath(), G4UIWin32::CreateHelpTree(), G4UIQt::CreateHelpTree(), G4UIQt::FillHelpTree(), G4UImanager::FindDirectory(), G4VBasicShell::FindDirectory(), G4UIWin32::InitHelpTreeItems(), G4UIQt::LookForHelpStringInChildTree(), G4UIQt::OpenHelpTreeOnCommand(), and G4VBasicShell::TerminalHelp().

GetTreeEntry()

G4int G4UIcommandTree::GetTreeEntry ( ) const

inline

Definition at line 73 of file G4UIcommandTree.hh.

{ return G4int(tree.size()); }

References tree.

Referenced by CompleteCommandPath(), G4UIWin32::CreateHelpTree(), G4UIQt::CreateHelpTree(), export_G4UIcommandTree(), G4UIQt::FillHelpTree(), G4UIWin32::InitHelpTreeItems(), G4UIQt::LookForHelpStringInChildTree(), G4UIQt::OpenHelpTreeOnCommand(), and G4VBasicShell::TerminalHelp().

List()

void G4UIcommandTree::List

(

)

const

Definition at line 497 of file G4UIcommandTree.cc.

{
  ListCurrent();
  G4int n_commandEntry = command.size();
  for(G4int i_thCommand = 0; i_thCommand < n_commandEntry; ++i_thCommand)
  {
    command[i_thCommand]->List();
  }
  G4int n_treeEntry = tree.size();
  for(G4int i_thTree = 0; i_thTree < n_treeEntry; ++i_thTree)
  {
    tree[i_thTree]->List();
  }
}

References command, ListCurrent(), and tree.

Referenced by export_G4UIcommandTree(), and G4UImanager::ListCommands().

ListCurrent()

void G4UIcommandTree::ListCurrent

(

)

const

Definition at line 433 of file G4UIcommandTree.cc.

{
  G4cout << "Command directory path : " << pathName << G4endl;
  if(guidance != nullptr)
    guidance->List();
  G4cout << " Sub-directories : " << G4endl;
  G4int n_treeEntry = tree.size();
  for(G4int i_thTree = 0; i_thTree < n_treeEntry; ++i_thTree)
  {
    G4cout << "   " << tree[i_thTree]->GetPathName();
    if(tree[i_thTree]->GetGuidance() &&
       tree[i_thTree]->GetGuidance()->IsWorkerThreadOnly())
    {
      G4cout << " @ ";
    }
    else
    {
      G4cout << "   ";
    }
    G4cout << tree[i_thTree]->GetTitle() << G4endl;
  }
  G4cout << " Commands : " << G4endl;
  G4int n_commandEntry = command.size();
  for(G4int i_thCommand = 0; i_thCommand < n_commandEntry; ++i_thCommand)
  {
    G4cout << "   " << command[i_thCommand]->GetCommandName();
    if(command[i_thCommand]->IsWorkerThreadOnly())
    {
      G4cout << " @ ";
    }
    else
    {
      G4cout << " * ";
    }
    G4cout << command[i_thCommand]->GetTitle() << G4endl;
  }
}

References command, G4cout, G4endl, GetGuidance(), guidance, G4UIcommand::List(), pathName, and tree.

Referenced by export_G4UIcommandTree(), List(), and G4VBasicShell::ListDirectory().

ListCurrentWithNum()

void G4UIcommandTree::ListCurrentWithNum

(

)

const

Definition at line 472 of file G4UIcommandTree.cc.

{
  G4cout << "Command directory path : " << pathName << G4endl;
  if(guidance != nullptr)
    guidance->List();
  G4int i = 0;
  G4cout << " Sub-directories : " << G4endl;
  G4int n_treeEntry = tree.size();
  for(G4int i_thTree = 0; i_thTree < n_treeEntry; ++i_thTree)
  {
    ++i;
    G4cout << " " << i << ") " << tree[i_thTree]->GetPathName() << "   "
           << tree[i_thTree]->GetTitle() << G4endl;
  }
  G4cout << " Commands : " << G4endl;
  G4int n_commandEntry = command.size();
  for(G4int i_thCommand = 0; i_thCommand < n_commandEntry; ++i_thCommand)
  {
    ++i;
    G4cout << " " << i << ") " << command[i_thCommand]->GetCommandName()
           << " * " << command[i_thCommand]->GetTitle() << G4endl;
  }
}

References command, G4cout, G4endl, guidance, G4UIcommand::List(), pathName, and tree.

Referenced by export_G4UIcommandTree(), and G4VBasicShell::TerminalHelp().

ModStr()

G4String G4UIcommandTree::ModStr ( const char *  strS )

private

Definition at line 526 of file G4UIcommandTree.cc.

{
  G4String sx;
  G4String str = strS;
  for(G4int i = 0; i < G4int(str.length()); ++i)
  {
    char c = str[i];
    switch(c)
    {
      case '<':
        sx += "&lt;";
        break;
      case '>':
        sx += "&gt;";
        break;
      case '&':
        sx += "&amp;";
        break;
      default:
        sx += c;
    }
  }
  return sx;
}

Referenced by CreateHTML().

operator!=()

G4bool G4UIcommandTree::operator!=

(

const G4UIcommandTree &

right

)

const

Definition at line 69 of file G4UIcommandTree.cc.

{
  return (pathName != right.GetPathName());
}

References GetPathName(), and pathName.

operator==()

G4bool G4UIcommandTree::operator==

(

const G4UIcommandTree &

right

)

const

Definition at line 63 of file G4UIcommandTree.cc.

{
  return (pathName == right.GetPathName());
}

References GetPathName(), and pathName.

RemoveCommand()

void G4UIcommandTree::RemoveCommand	(	G4UIcommand *	aCommand,
		G4bool	workerThreadOnly = false
	)

Definition at line 176 of file G4UIcommandTree.cc.

{
  if(workerThreadOnly && !(aCommand->IsWorkerThreadOnly()))
    return;
  G4String commandPath   = aCommand->GetCommandPath();
  G4String remainingPath = commandPath;
  remainingPath.erase(0, pathName.length());
  if(remainingPath.empty())
  {
    guidance = nullptr;
  }
  else
  {
    G4int i = remainingPath.find('/');
    if(i == G4int(std::string::npos))
    {
      // Find command
      G4int n_commandEntry = command.size();
      for(G4int i_thCommand = 0; i_thCommand < n_commandEntry; ++i_thCommand)
      {
        if(remainingPath == command[i_thCommand]->GetCommandName())
        {
          command.erase(command.begin() + i_thCommand);
          break;
        }
      }
    }
    else
    {
      // Find path
      G4String nextPath = pathName;
      nextPath.append(remainingPath.substr(0, i + 1));
      G4int n_treeEntry = tree.size();
      for(G4int i_thTree = 0; i_thTree < n_treeEntry; ++i_thTree)
      {
        if(nextPath == tree[i_thTree]->GetPathName())
        {
          tree[i_thTree]->RemoveCommand(aCommand);
          G4int n_commandRemain = tree[i_thTree]->GetCommandEntry();
          G4int n_treeRemain    = tree[i_thTree]->GetTreeEntry();
          if(n_commandRemain == 0 && n_treeRemain == 0)
          {
            G4UIcommandTree* emptyTree = tree[i_thTree];
            tree.erase(tree.begin() + i_thTree);
            delete emptyTree;
          }
          break;
        }
      }
    }
  }
}

References command, G4UIcommand::GetCommandPath(), GetPathName(), guidance, G4UIcommand::IsWorkerThreadOnly(), pathName, and tree.

Referenced by G4UImanager::RemoveCommand(), and G4UImanager::RemoveWorkerCommand().

Field Documentation

broadcastCommands

G4bool G4UIcommandTree::broadcastCommands = true

private

Definition at line 93 of file G4UIcommandTree.hh.

Referenced by AddNewCommand().

command

std::vector<G4UIcommand*> G4UIcommandTree::command

private

Definition at line 89 of file G4UIcommandTree.hh.

Referenced by AddNewCommand(), CreateHTML(), FindPath(), GetCommand(), GetCommandEntry(), List(), ListCurrent(), ListCurrentWithNum(), and RemoveCommand().

createHTMLTreeLevel

G4int G4UIcommandTree::createHTMLTreeLevel = 0

private

Definition at line 95 of file G4UIcommandTree.hh.

Referenced by CreateHTML().

guidance

G4UIcommand* G4UIcommandTree::guidance = nullptr

private

Definition at line 91 of file G4UIcommandTree.hh.

Referenced by AddNewCommand(), CreateHTML(), GetGuidance(), GetTitle(), ListCurrent(), ListCurrentWithNum(), and RemoveCommand().

ifSort

G4bool G4UIcommandTree::ifSort = false

private

Definition at line 94 of file G4UIcommandTree.hh.

Referenced by AddNewCommand().

pathName

G4String G4UIcommandTree::pathName

private

Definition at line 92 of file G4UIcommandTree.hh.

Referenced by AddNewCommand(), CreateHTML(), FindCommandTree(), FindPath(), G4UIcommandTree(), GetPathName(), ListCurrent(), ListCurrentWithNum(), operator!=(), operator==(), and RemoveCommand().

tree

std::vector<G4UIcommandTree*> G4UIcommandTree::tree

private

Definition at line 90 of file G4UIcommandTree.hh.

Referenced by AddNewCommand(), CreateHTML(), FindCommandTree(), FindPath(), GetTree(), GetTreeEntry(), List(), ListCurrent(), ListCurrentWithNum(), RemoveCommand(), and ~G4UIcommandTree().

---

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

• source/intercoms/include/G4UIcommandTree.hh
• source/intercoms/src/G4UIcommandTree.cc