gcommands.cc

Go to the documentation of this file.

// G4Dialog
#include "gcommands.h"
 
G4Commands::G4Commands(QWidget* parent) : QWidget(parent) {
    // Summary: Build the overall UI layout (search, commands tree + help, history, command prompt).
 
    //  + +-------------------+ +
    //  | |    > Search       | |
    //  + +-------------------+ +
    //  | |         |         | |
    //  | |  Tree   |  Help   | |
    //  | |         |         | |
    //  | +-------------------+ |
    //  | +-------------------+ |
    //  | |                   | |
    //  | |      History      | |
    //  | |                   | |
    //  | +-------------------+ |
    //  | +-------------------+ |
    //  | |    > Prompt       | |
    //  | +-------------------+ |
    //  +-----------------------+
 
    // Search entry: used to filter the tree model in real time.
    w_search = new QLineEdit();
    w_search->installEventFilter(this);
    w_search->activateWindow();
    w_search->setFocusPolicy(Qt::StrongFocus);
    w_search->setFocus(Qt::TabFocusReason);
 
    // Every time w_search is changed, filter the tree.
    connect(w_search, &QLineEdit::textChanged, this, &G4Commands::filterTreeItems);
 
    // Commands tree and help are placed side-by-side.
    QSplitter*   commands_help_splitter = new QSplitter(Qt::Horizontal);
    QVBoxLayout* commands_help_layout   = new QVBoxLayout(commands_help_splitter);
 
    // Left: the commands tree (built from Geant4 UI command tree).
    create_geant4_commands_widget();
    commands_help_layout->addWidget(w_commands);
 
    // Right: the help on individual commands or command directories.
    w_help = new QTextEdit(commands_help_splitter);
    w_help->setReadOnly(true);
 
    // History area: executed commands (deduplicated).
    w_history = new QListWidget();
    w_history->setSelectionMode(QAbstractItemView::SingleSelection);
    w_history->installEventFilter(this);
    connect(w_history, &QListWidget::itemDoubleClicked, this, &G4Commands::recall_history_item_on_double_click);
 
    // Command entry: pressing Enter triggers execution.
    w_command = new QLineEdit();
    w_command->installEventFilter(this);
    w_command->activateWindow();
    w_command->setFocusPolicy(Qt::StrongFocus);
    w_command->setFocus(Qt::TabFocusReason);
    connect(w_command, &QLineEdit::returnPressed, this, &G4Commands::execute_command);
 
    // Allocate more horizontal space to the help pane by default.
    commands_help_splitter->setSizes(QList<int>() << 300 << 800);
 
    // Putting all together into a vertical layout.
    QVBoxLayout* v_layout = new QVBoxLayout(this);
    v_layout->addWidget(new QLabel(tr("Search Commands")));
    v_layout->addWidget(w_search);
    v_layout->addWidget(commands_help_splitter, /* stretch factor */ 2);
    v_layout->addWidget(new QLabel(tr("History")));
    v_layout->addWidget(w_history);
    v_layout->addWidget(new QLabel(tr("Enter Command")));
    v_layout->addWidget(w_command);
}
 
void G4Commands::create_geant4_commands_widget() {
    // Summary: Build the QTreeView model by walking the Geant4 UI command tree.
 
    // Read current search text (used by filterTreeItems()).
    QString search_text = w_search->text();
    (void)search_text; // Not used immediately here; kept as a convenient debug hook.
 
    G4UImanager*     ui_manager       = G4UImanager::GetUIpointer();
    G4UIcommandTree* g4_commands_tree = ui_manager->GetTree();
 
    // Create model for QTreeView.
    QStandardItemModel* model = new QStandardItemModel();
    w_commands                = new QTreeView();
    w_commands->setModel(model);
    w_commands->setSelectionMode(QAbstractItemView::SingleSelection);
 
    // Set header label for the QTreeView model.
    model->setHorizontalHeaderLabels(QStringList() << tr("Commands"));
    // Add top-level command directories to the model.
    G4int g4_commands_tree_size = g4_commands_tree->GetTreeEntry();
    for (int a = 0; a < g4_commands_tree_size; a++) {
        // Each top-level entry is a command directory node; children are populated recursively.
        QStandardItem* newItem = new QStandardItem(
            QString((char*)g4_commands_tree->GetTree(a + 1)->GetPathName().data()).trimmed());
        model->appendRow(newItem);
 
        // Add child directories and commands.
        create_child_help_tree(newItem, g4_commands_tree->GetTree(a + 1));
    }
 
    // Read-only: prevent accidental edits to the command path strings.
    w_commands->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
    // Selection drives help display; double-click pastes selection into the command prompt.
    connect(w_commands->selectionModel(), &QItemSelectionModel::selectionChanged, this,
            &G4Commands::display_help_from_selection);
    connect(w_commands, &QTreeView::doubleClicked, this, &G4Commands::paste_help_selection_item);
}
 
void G4Commands::filterTreeItems() {
    // Summary: Hide/show top-level rows depending on whether they (or their descendants) match the search string.
 
    QString             search_text = w_search->text().trimmed();
    QStandardItemModel* model       = qobject_cast<QStandardItemModel*>(w_commands->model());
    if (!model) return;
 
    for (int i = 0; i < model->rowCount(); ++i) {
        QStandardItem* item     = model->item(i);
        bool           showItem = filterItem(item, search_text);
 
        // For top-level nodes we also explicitly hide the row at the root.
        w_commands->setRowHidden(i, QModelIndex(), !showItem);
    }
}
 
bool G4Commands::filterItem(QStandardItem* item, const QString& search_text) {
    // Summary: Recursively evaluate whether this item should be visible.
 
    // Direct match on this node.
    bool matches      = item->text().contains(search_text, Qt::CaseInsensitive);
    bool childMatches = false;
 
    // Check child items recursively (depth-first).
    for (int i = 0; i < item->rowCount(); ++i) {
        QStandardItem* childItem = item->child(i);
        if (filterItem(childItem, search_text)) { childMatches = true; }
    }
 
    // Show this item if it matches or has a matching child.
    bool showItem = matches || childMatches;
 
    // Apply visibility at this node's location in the tree.
    w_commands->setRowHidden(item->row(), item->index().parent(), !showItem);
 
    return showItem;
}
 
void G4Commands::create_child_help_tree(QStandardItem* parent, G4UIcommandTree* aCommandTree) {
    // Summary: Populate children for a given Geant4 tree node (sub-directories first, then leaf commands).
 
    if (parent == nullptr || aCommandTree == nullptr) return;
 
    // Add child directories (sub-trees).
    for (int a = 0; a < aCommandTree->GetTreeEntry(); a++) {
        QStandardItem* newItem = new QStandardItem(
            QString((char*)(aCommandTree->GetTree(a + 1)->GetPathName()).data()).trimmed());
        parent->appendRow(newItem);
        create_child_help_tree(newItem, aCommandTree->GetTree(a + 1));
    }
 
    // Add commands at this node (leaf entries).
    for (int a = 0; a < aCommandTree->GetCommandEntry(); a++) {
        QStandardItem* newItem = new QStandardItem(
            QString((char*)(aCommandTree->GetCommand(a + 1)->GetCommandPath()).data()).trimmed());
        parent->appendRow(newItem);
    }
}
 
void G4Commands::execute_command() {
    // Summary: Execute the typed command through Geant4 UI manager and update history.
 
    if (!w_command) return;
 
    QString command = w_command->text().trimmed();
    if (command.isEmpty()) return;
 
    G4UImanager* ui_manager = G4UImanager::GetUIpointer();
    ui_manager->ApplyCommand(command.toStdString().c_str());
 
    // Avoid duplicate history entries (simple linear scan, small list expected).
    bool exists = false;
    for (int i = 0; i < w_history->count(); ++i) {
        if (w_history->item(i)->text() == command) {
            exists = true;
            break;
        }
    }
 
    if (!exists) { w_history->addItem(command); }
 
    // Clear command field after execution to signal completion.
    w_command->clear();
}
 
void G4Commands::recall_history_item_on_double_click(QListWidgetItem* item) {
    // Summary: Load the selected history command into the input field.
 
    if (!item) return;
 
    // Set the command line input to the selected history item.
    w_command->setText(item->text());
}
 
// paste history item onto command line
void G4Commands::display_help_from_selection() {
    // Summary: Determine whether selection is a command or a directory and show help/title accordingly.
 
    if (!w_commands || !w_help) return;
 
    QModelIndexList selectedIndexes = w_commands->selectionModel()->selectedIndexes();
    if (selectedIndexes.isEmpty()) return;
 
    QModelIndex         index = selectedIndexes.first();
    QStandardItemModel* model = qobject_cast<QStandardItemModel*>(w_commands->model());
    if (!model) return;
 
    QStandardItem* item = model->itemFromIndex(index);
    if (!item) return;
 
    std::string      itemText = item->text().toStdString();
    G4UIcommandTree* treeTop  = G4UImanager::GetUIpointer()->GetTree();
    G4UIcommand*     command  = treeTop->FindPath(itemText.c_str());
 
    if (command) {
        // Leaf command: show detailed guidance and parameter info.
        w_help->setText(get_command_g4help(command));
    }
    else {
        // Directory node: show the title (if found).
        G4UIcommandTree* path = treeTop->FindCommandTree(itemText.c_str());
        if (path) { w_help->setText(QString::fromStdString(path->GetTitle())); }
    }
}
 
// display help on selected item
void G4Commands::paste_help_selection_item() {
    // Summary: Refresh help and paste the selected command/directory text into the prompt.
 
    // Display help from the selection.
    display_help_from_selection();
 
    if (!w_commands || !w_help) { return; }
 
    // Get the selected items from the selection model of QTreeView.
    QModelIndexList selectedIndexes = w_commands->selectionModel()->selectedIndexes();
    if (selectedIndexes.isEmpty()) { return; }
 
    // Assuming the first selected item is the one to retrieve.
    QModelIndex         index = selectedIndexes.first();
    QStandardItemModel* model = qobject_cast<QStandardItemModel*>(w_commands->model());
    if (!model) { return; }
 
    // Retrieve the item at the given index.
    QStandardItem* item = model->itemFromIndex(index);
    if (!item) { return; }
 
    // Clear the command input field and set the selected item's text.
    w_command->clear();
    w_command->setText(item->text());
}
 
QString G4Commands::get_command_g4help(const G4UIcommand* aCommand) {
    // Summary: Format Geant4 UI command help into a human-readable text block.
 
    QString txt = "";
    if (aCommand == nullptr)
        return txt;
 
    G4String commandPath      = aCommand->GetCommandPath();
    G4String rangeString      = aCommand->GetRange();
    G4int    n_guidanceEntry  = aCommand->GetGuidanceEntries();
    G4int    n_parameterEntry = aCommand->GetParameterEntries();
 
    // If there is no meaningful content, return an empty string (keeps UI tidy).
    if ((commandPath == "") && (rangeString == "") && (n_guidanceEntry == 0) && (n_parameterEntry == 0)) { return txt; }
 
    // CommandPath ending with '/' denotes a directory in Geant4 UI; otherwise it's a concrete command.
    if ((commandPath.length() - 1) != '/') { txt += tr("Command %1\n").arg(QString::fromStdString(commandPath)); }
    txt += tr("Guidance :\n");
    for (G4int i_thGuidance = 0; i_thGuidance < n_guidanceEntry; i_thGuidance++) {
        txt += QString((char*)(aCommand->GetGuidanceLine(i_thGuidance)).data()) + "\n";
    }
    if (rangeString != "") { txt += tr(" Range of parameters : %1\n").arg(QString::fromStdString(rangeString)); }
    if (n_parameterEntry > 0) {
        G4UIparameter* param;
 
        // Re-implementation from G4UIparameter.cc (mirrors Geant4 formatting for consistency).
        for (G4int i_thParameter = 0; i_thParameter < n_parameterEntry; i_thParameter++) {
            param = aCommand->GetParameter(i_thParameter);
            txt   += tr("\nParameter : %1\n").arg(QString::fromStdString(param->GetParameterName()));
            if (param->GetParameterGuidance() != "") {
                txt += QString((char*)(param->GetParameterGuidance()).data()) + "\n";
            }
            txt += tr(" Parameter type  : %1\n").arg(QChar(param->GetParameterType()));
            if (param->IsOmittable()) { txt += tr(" Omittable       : True\n"); }
            else { txt += tr(" Omittable       : False\n"); }
            if (param->GetCurrentAsDefault()) { txt += tr(" Default value   : taken from the current value\n"); }
            else if (param->GetDefaultValue() != "") {
                txt += tr(" Default value   : %1\n").arg(QString::fromStdString(param->GetDefaultValue()));
            }
 
            if (param->GetParameterRange() != "") {
                txt += tr(" Parameter range : %1\n").arg(QString::fromStdString(param->GetParameterRange()));
            }
 
            if (param->GetParameterCandidates() != "") {
                txt += tr(" Candidates      : %1\n").arg(QString::fromStdString(param->GetParameterCandidates()));
            }
        }
    }
    return txt;
}