G4UIQt Class Reference

#include <G4UIQt.hh>

Inheritance diagram for G4UIQt:

Public Member Functions
	G4UIQt (G4int, char **)
G4UIsession *	SessionStart () override
void	AddMenu (const char *, const char *) override
void	AddButton (const char *, const char *, const char *) override
void	AddIcon (const char *userLabel, const char *iconFile, const char *command, const char *file_name="") override
void	SetOutputStyle (const char *destination, const char *style) override
void	NativeMenu (G4bool aVal) override
void	ClearMenu () override
void	DefaultIcons (G4bool aVal) override
G4bool	AddTabWidget (QWidget *, QString)
QTabWidget *	GetViewerTabWidget ()
QWidget *	GetSceneTreeWidget ()
QWidget *	GetViewerPropertiesWidget ()
QWidget *	GetPickInfosWidget ()
G4bool	IsSplitterReleased ()
G4bool	IsIconMoveSelected ()
G4bool	IsIconRotateSelected ()
G4bool	IsIconPickSelected ()
G4bool	IsIconZoomInSelected ()
G4bool	IsIconZoomOutSelected ()
void	SetIconMoveSelected ()
void	SetIconRotateSelected ()
void	SetIconPickSelected ()
void	SetIconZoomInSelected ()
void	SetIconZoomOutSelected ()
void	SetIconHLHSRSelected ()
void	SetIconHLRSelected ()
void	SetIconSolidSelected ()
void	SetIconWireframeSelected ()
void	SetIconPerspectiveSelected ()
void	SetIconOrthoSelected ()
QMainWindow *	GetMainWindow ()
QPixmap *	getSearchIcon ()
QPixmap *	getClearIcon ()
void	SetStartPage (const std::string &)
QWidget *	GetCoutWidget ()
G4UIDockWidget *	GetCoutDockWidget ()
G4UIDockWidget *	GetUserInterfaceWidget ()
QTabWidget *	GetUITabWidget ()
QWidget *	GetHistoryWidget ()
QWidget *	GetHelpWidget ()
G4bool	AddViewerTab (QWidget *w, std::string title)
G4bool	AddViewerTabFromFile (std::string fileName, std::string title)
void	UpdateSceneTree (const G4SceneTreeItem &) override
	~G4UIQt () override
void	Prompt (G4String)
void	SessionTerminate ()
void	PauseSessionStart (const G4String &) override
G4int	ReceiveG4debug (const G4String &) override
G4int	ReceiveG4cout (const G4String &) override
G4int	ReceiveG4cerr (const G4String &) override
Public Member Functions inherited from G4VBasicShell
	G4VBasicShell ()
	~G4VBasicShell () override
Public Member Functions inherited from G4UIsession
	G4UIsession ()
	G4UIsession (G4int iBatch)
	~G4UIsession () override
G4int	ReceiveG4debug (const G4String &debugString) override
G4int	ReceiveG4cout (const G4String &coutString) override
G4int	ReceiveG4cerr (const G4String &cerrString) override
G4int	GetLastReturnCode () const
Public Member Functions inherited from G4coutDestination
	G4coutDestination ()=default
virtual	~G4coutDestination ()=default
void	AddDebugTransformer (const Transformer &t)
void	AddDebugTransformer (Transformer &&t)
void	AddCoutTransformer (const Transformer &t)
void	AddCoutTransformer (Transformer &&t)
void	AddCerrTransformer (const Transformer &t)
void	AddCerrTransformer (Transformer &&t)
virtual void	ResetTransformers ()
G4int	ReceiveG4debug_ (const G4String &msg)
G4int	ReceiveG4cout_ (const G4String &msg)
G4int	ReceiveG4cerr_ (const G4String &msg)
Public Member Functions inherited from G4VInteractiveSession
	G4VInteractiveSession ()
virtual	~G4VInteractiveSession ()
void	AddInteractor (G4String, G4Interactor)
G4Interactor	GetInteractor (G4String)
const std::map< G4String, OutputStyle > &	GetOutputStyles () const

Additional Inherited Members
Public Types inherited from G4coutDestination
using	Transformer = std::function<G4bool(G4String&)>
Static Public Member Functions inherited from G4UIsession
static G4int	InSession ()
Protected Member Functions inherited from G4VBasicShell
G4String	ModifyToFullPathCommand (const char *aCommandLine) const
G4String	GetCurrentWorkingDirectory () const
G4bool	ChangeDirectory (const char *newDir)
G4UIcommandTree *	FindDirectory (const char *dirName) const
G4UIcommand *	FindCommand (const char *commandName) const
G4String	Complete (const G4String &)
G4String	FindMatchingPath (G4UIcommandTree *, const G4String &)
virtual void	ExecuteCommand (const G4String &)
void	ApplyShellCommand (const G4String &, G4bool &, G4bool &)
void	ShowCurrent (const G4String &) const
void	ChangeDirectoryCommand (const G4String &)
void	ListDirectory (const G4String &) const
void	TerminalHelp (const G4String &)
Protected Member Functions inherited from G4VInteractiveSession
void	SetStyleUtility (const G4String &destination, const G4String &style)
Protected Attributes inherited from G4UIsession
G4int	ifBatch = 0
G4int	lastRC = 0
Protected Attributes inherited from G4coutDestination
std::vector< Transformer >	transformersDebug
std::vector< Transformer >	transformersCout
std::vector< Transformer >	transformersCerr
Protected Attributes inherited from G4VInteractiveSession
std::map< G4String, OutputStyle >	fOutputStyles
Static Protected Attributes inherited from G4UIsession
static G4ICOMS_DLL G4int	inSession = 0
Static Protected Attributes inherited from G4coutDestination
static G4MTGLOB_DLL G4coutDestination *	masterG4coutDestination = nullptr

Detailed Description

Definition at line 120 of file G4UIQt.hh.

Constructor & Destructor Documentation

G4UIQt()

G4UIQt::G4UIQt	(	G4int	argc,
		char **	argv )

Build a Qt window with a menubar, output area and promt area

   +-----------------------+
   |exit menu|             |
   |                       |
   | +-------------------+ |
   | |                   | |
   | |  Output area      | |
   | |                   | |
   | +-------------------+ |
   |      | clear |        |
   | +-------------------+ |
   | |  promt history    | |
   | +-------------------+ |
   | +-------------------+ |
   | |> promt area       | |
   | +-------------------+ |
   +-----------------------+

Definition at line 118 of file G4UIQt.cc.

  : fMainWindow(nullptr),
    fCommandLabel(nullptr),
    fCommandArea(nullptr),
    fCoutTBTextArea(nullptr),
    fUITabWidget(nullptr),
    fCoutFilter(nullptr),
    fCompleter(nullptr),
    fDefaultIcons(true),
    fHistoryTBTableList(nullptr),
    fHelpTreeWidget(nullptr),
    fHelpTBWidget(nullptr),
    fHistoryTBWidget(nullptr),
    fCoutDockWidget(nullptr),
    fUIDockWidget(nullptr),
    fSceneTreeWidget(nullptr),
    fNewSceneTreeWidget(nullptr),
    fNewSceneTreeItemTreeWidget(nullptr),
    fViewerPropertiesWidget(nullptr),
    fPickInfosWidget(nullptr),
    fHelpLine(nullptr),
    fViewerTabWidget(nullptr),
    fCoutText("Output"),
    fStartPage(nullptr),
    fHelpVSplitter(nullptr),
    fParameterHelpLabel(nullptr),
    fParameterHelpTable(nullptr),
    fToolbarApp(nullptr),
    fToolbarUser(nullptr),
    fStringSeparator("__$$$@%%###__"),
    fLastOpenPath(""),
    fSearchIcon(nullptr),
    fClearIcon(nullptr),
    fSaveIcon(nullptr),
    fOpenIcon(nullptr),
    fMoveIcon(nullptr),
    fRotateIcon(nullptr),
    fPickIcon(nullptr),
    fZoomInIcon(nullptr),
    fZoomOutIcon(nullptr),
    fWireframeIcon(nullptr),
    fSolidIcon(nullptr),
    fHiddenLineRemovalIcon(nullptr),
    fHiddenLineAndSurfaceRemovalIcon(nullptr),
    fPerspectiveIcon(nullptr),
    fOrthoIcon(nullptr),
    fCommandIcon(nullptr),
    fDirIcon(nullptr),
    fRunIcon(nullptr),
    fParamIcon(nullptr),
    fPickTargetIcon(nullptr),
    fExitIcon(nullptr)
#ifdef G4MULTITHREADED
    ,
    fThreadsFilterComboBox(nullptr)
#endif
    ,
    fDefaultViewerFirstPageHTMLText(""),
    fViewerPropertiesDialog(nullptr),
    fPickInfosDialog(nullptr),
    fLastCompleteCommand(""),
    fMoveSelected(false),
    fRotateSelected(true),
    fPickSelected(false),
    fZoomInSelected(false),
    fZoomOutSelected(false)
{
  G4Qt* interactorManager = G4Qt::getInstance(argc, argv, (char*)"Qt");
  if ((QApplication*)interactorManager->GetMainInteractor() == nullptr) {
    G4UImanager* UImanager = G4UImanager::GetUIpointer();
    G4int verbose = UImanager->GetVerboseLevel();
 
    if (verbose >= 2) {
      G4cout << "G4UIQt : Unable to init Qt. Aborted" << G4endl;
    }
  }
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI != nullptr) UI->SetSession(this);
  if (UI != nullptr) UI->SetG4UIWindow(this);
 
  // Check if already define in external app QMainWindow
  G4bool found = false;
  Q_FOREACH (QWidget* widget, QApplication::allWidgets()) {
    if ((!found) && (widget->inherits("QMainWindow"))) {
      found = true;
    }
  }
 
  if (found) {
    G4UImanager* UImanager = G4UImanager::GetUIpointer();
    G4int verbose = UImanager->GetVerboseLevel();
 
    if (verbose >= 2) {
      G4cout << "G4UIQt : Found an external App with a QMainWindow already defined. Aborted"
             << G4endl;
    }
    return;
  }
  CreateIcons();
 
  fMainWindow = new QMainWindow();
  fMainWindow->setAttribute(Qt::WA_DeleteOnClose);
 
  fMainWindow->setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
  fMainWindow->setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
  fMainWindow->setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
  fMainWindow->setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
 
  CreateViewerWidget();
  fMainWindow->addDockWidget(Qt::LeftDockWidgetArea, CreateUITabWidget());
  fMainWindow->addDockWidget(Qt::BottomDockWidgetArea, CreateCoutTBWidget());
 
  // Create the new scene tree stuff
  fNewSceneTreeWidget = new QWidget;
  fNewSceneTreeWidget->setStyleSheet ("padding: 0px ");
  fNewSceneTreeWidget->setLayout(new QVBoxLayout);
  fNewSceneTreeWidget->layout()->setContentsMargins(5,5,5,5);
  fNewSceneTreeWidget->setWindowTitle("some name"/*QString(GetName().data())*/);
  // Add it to the "old" fSceneTreeWidget
  fSceneTreeWidget->layout()->addWidget(fNewSceneTreeWidget);
  CreateNewSceneTreeWidget();
 
  // add defaults icons
  SetDefaultIconsToolbar();
 
  if (UI != nullptr) UI->SetCoutDestination(this);  // TO KEEP
 
#ifdef G4MULTITHREADED
  // explicitly request that cout/cerr messages from threads are ALSO propagated to the master.
  masterG4coutDestination = this;
#endif
 
  fMainWindow->setWindowTitle(QFileInfo(QCoreApplication::applicationFilePath()).fileName());
  fMainWindow->move(QPoint(50, 50));
 
  // force the size at be correct at the beggining
  // because the widget is not realized yet, the size of the main window is not up to date. But
  // we need it in order to add some viewer inside
  fMainWindow->resize(fUIDockWidget->width() + fCoutDockWidget->width() + 20,
    fUIDockWidget->height() + fCoutDockWidget->height() + 20);
 
  // set last focus on command line
  fCommandArea->setFocus(Qt::TabFocusReason);
 
  // Allow QTextCursor to be called by another thread :
  // http://qt-project.org/doc/qt-4.8/qmetatype.html#qRegisterMetaType
  qRegisterMetaType<QTextCursor>("QTextCursor");
 
  // add some tips
  AddTabWidget(fStartPage, "Useful tips");
 
  // Set not visible until session start
  fMainWindow->setVisible(false);
}

~G4UIQt()

G4UIQt::~G4UIQt ( )

override

Definition at line 274 of file G4UIQt.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();  // TO KEEP
  if (UI != nullptr) {  // TO KEEP
    UI->SetSession(nullptr);  // TO KEEP
    UI->SetG4UIWindow(nullptr);
    UI->SetCoutDestination(nullptr);  // TO KEEP
#ifdef G4MULTITHREADED
    masterG4coutDestination = nullptr;  // set to cout when UI is deleted
#endif
  }
}

Member Function Documentation

AddButton()

void G4UIQt::AddButton ( const char * aMenu, const char * aLabel, const char * aCommand )

overridevirtual

Add a new button to a menu

Parameters

aMenu	: parent menu
aLabel	: label to display
aCommand	: command to execute as a callback

Reimplemented from G4VInteractiveSession.

Definition at line 2810 of file G4UIQt.cc.

{
  if (aMenu == nullptr) return;  // TO KEEP
  if (aLabel == nullptr) return;  // TO KEEP
  if (aCommand == nullptr) return;  // TO KEEP
 
  QMenu* parentTmp = (QMenu*)GetInteractor(aMenu);
 
  if (parentTmp == nullptr) {
    G4UImanager* UImanager = G4UImanager::GetUIpointer();
    G4int verbose = UImanager->GetVerboseLevel();
 
    if (verbose >= 2) {
      G4cout << "Menu name " << aMenu << " does not exist, please define it before using it."
             << G4endl;
    }
    return;
  }
 
  // Find the command in the command tree
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI == nullptr) return;
  G4UIcommandTree* treeTop = UI->GetTree();
 
  G4String cmd = aCommand;
  std::size_t cmdEndPos = cmd.find_first_of(" \t");
  if (cmdEndPos != std::string::npos) {
    cmd.erase(cmdEndPos);
  }
 
  if (treeTop->FindPath(cmd) == nullptr) {
    if (cmd != "ls" && cmd.substr(0, 3) != "ls " && cmd != "pwd" && cmd != "cd" &&
        cmd.substr(0, 3) != "cd " && cmd != "help" && cmd.substr(0, 5) != "help " &&
        cmd[0] != '?' && cmd != "hist" && cmd != "history" && cmd[0] != '!' && cmd != "exit" &&
        cmd != "cont" && cmd != "continue")
    {
      G4UImanager* UImanager = G4UImanager::GetUIpointer();
      G4int verbose = UImanager->GetVerboseLevel();
 
      if (verbose >= 2) {
        G4cout << "Warning: command '" << cmd
               << "' does not exist, please define it before using it." << G4endl;
      }
    }
  }
 
  QString cmd_tmp = QString(aCommand);
  parentTmp->addAction(aLabel, this, [this, cmd_tmp]() { this->ButtonCallback(cmd_tmp); });
}

AddIcon()

void G4UIQt::AddIcon ( const char * aLabel, const char * aIconFile, const char * aCommand, const char * aFileName = "" )

overridevirtual

special case for the "open" icon. It will open a file selector and map the return file to the given command.

Reimplemented from G4VInteractiveSession.

Definition at line 2864 of file G4UIQt.cc.

{
  if (aLabel == nullptr) return;  // TO KEEP
  // special case, aCommand could be NULL if aIconFile is not user_icon
  if (aCommand == nullptr) {
    if (std::string(aIconFile) == "user_icon") {
      return;  // TO KEEP
    }
  }
  QPixmap* pix;
  G4bool userToolBar = false;
 
  if (! fDefaultIcons) {
    userToolBar = true;
  }
  if (std::string(aIconFile) == "user_icon") {
    // try to open a file
    G4UImanager* UImanager = G4UImanager::GetUIpointer();
    pix = new QPixmap(UImanager->FindMacroPath(aFileName).data());
    if (pix->isNull()) {
      G4int verbose = UImanager->GetVerboseLevel();
 
      if (verbose >= 2) {
        G4cout << "Warning: file '" << aFileName
               << "' is incorrect or does not exist, this command will not be build" << G4endl;
      }
      return;
    }
  }
  else if (std::string(aIconFile) == "open") {
    pix = fOpenIcon;
  }
  else if (std::string(aIconFile) == "save") {
    pix = fSaveIcon;
  }
  else if (std::string(aIconFile) == "move") {
    pix = fMoveIcon;
  }
  else if (std::string(aIconFile) == "rotate") {
    pix = fRotateIcon;
  }
  else if (std::string(aIconFile) == "pick") {
    pix = fPickIcon;
  }
  else if (std::string(aIconFile) == "zoom_in") {
    pix = fZoomInIcon;
  }
  else if (std::string(aIconFile) == "zoom_out") {
    pix = fZoomOutIcon;
  }
  else if (std::string(aIconFile) == "wireframe") {
    pix = fWireframeIcon;
  }
  else if (std::string(aIconFile) == "solid") {
    pix = fSolidIcon;
  }
  else if (std::string(aIconFile) == "hidden_line_removal") {
    pix = fHiddenLineRemovalIcon;
  }
  else if (std::string(aIconFile) == "hidden_line_and_surface_removal") {
    pix = fHiddenLineAndSurfaceRemovalIcon;
  }
  else if (std::string(aIconFile) == "perspective") {
    pix = fPerspectiveIcon;
  }
  else if (std::string(aIconFile) == "ortho") {
    pix = fOrthoIcon;
  }
  else if (std::string(aIconFile) == "runBeamOn") {
    pix = fRunIcon;
  }
  else if (std::string(aIconFile) == "exit") {
    pix = fExitIcon;
  }
  else {
    G4UImanager* UImanager = G4UImanager::GetUIpointer();
    G4int verbose = UImanager->GetVerboseLevel();
 
    if (verbose >= 2) {
      G4cout << "Parameter" << aIconFile << " not defined" << G4endl;
    }
    return;
  }
  QToolBar* currentToolbar = nullptr;
  if (userToolBar) {
    if (fToolbarUser == nullptr) {
      fToolbarUser = new QToolBar();
      fToolbarUser->setIconSize(QSize(20, 20));
      fMainWindow->addToolBar(Qt::TopToolBarArea, fToolbarUser);
    }
    currentToolbar = fToolbarUser;
  }
  else {
    if (fToolbarApp == nullptr) {
      fToolbarApp = new QToolBar();
      fToolbarApp->setIconSize(QSize(20, 20));
      fMainWindow->addToolBar(Qt::TopToolBarArea, fToolbarApp);
    }
    currentToolbar = fToolbarApp;
  }
 
  // Check if already present
 
  QList<QAction*> list = currentToolbar->actions();
 
  for (auto i : list) {
    if (i->text() == QString(aLabel)) {
      G4UImanager* UI = G4UImanager::GetUIpointer();
      if (UI == nullptr) return;
      G4int verbose = UI->GetVerboseLevel();
      if (verbose >= 2) {
        G4cout << "Warning: A toolBar icon \"" << aLabel << "\" already exists with the same name!"
               << G4endl;
      }
    }
  }
 
  // special cases :"open"
  if (std::string(aIconFile) == "open") {
    QString txt = aCommand + fStringSeparator + aLabel;
    currentToolbar->addAction(
      QIcon(*pix), aIconFile, this, [this, txt]() { this->OpenIconCallback(txt); });
 
    // special cases :"save"
  }
  else if (std::string(aIconFile) == "save") {
    QString txt = aCommand + fStringSeparator + aLabel;
    currentToolbar->addAction(
      QIcon(*pix), aIconFile, this, [this, txt]() { this->SaveIconCallback(txt); });
    // special cases : cursor style
  }
  else if ((std::string(aIconFile) == "move") || (std::string(aIconFile) == "rotate") ||
           (std::string(aIconFile) == "pick") || (std::string(aIconFile) == "zoom_out") ||
           (std::string(aIconFile) == "zoom_in"))
  {
    QString txt = QString(aIconFile);
    QAction* action = currentToolbar->addAction(
      QIcon(*pix), aIconFile, this, [this, txt]() { this->ChangeCursorAction(txt); });
    action->setCheckable(true);
    action->setChecked(true);
    action->setData(aIconFile);
 
    if (std::string(aIconFile) == "move") {
      SetIconMoveSelected();
    }
    if (std::string(aIconFile) == "rotate") {
      SetIconRotateSelected();
    }
    if (std::string(aIconFile) == "pick") {
      SetIconPickSelected();
    }
    if (std::string(aIconFile) == "zoom_in") {
      SetIconZoomInSelected();
    }
    if (std::string(aIconFile) == "zoom_out") {
      SetIconZoomOutSelected();
    }
 
    // special case : surface style
  }
  else if ((std::string(aIconFile) == "hidden_line_removal") ||
           (std::string(aIconFile) == "hidden_line_and_surface_removal") ||
           (std::string(aIconFile) == "solid") || (std::string(aIconFile) == "wireframe"))
  {
    QString txt = QString(aIconFile);
    QAction* action = currentToolbar->addAction(
      QIcon(*pix), aIconFile, this, [this, txt]() { this->ChangeSurfaceStyle(txt); });
    action->setCheckable(true);
    action->setChecked(true);
    action->setData(aIconFile);
 
    if (std::string(aIconFile) == "hidden_line_removal") {
      SetIconHLRSelected();
    }
    if (std::string(aIconFile) == "hidden_line_and_surface_removal") {
      SetIconHLHSRSelected();
    }
    if (std::string(aIconFile) == "solid") {
      SetIconSolidSelected();
    }
    if (std::string(aIconFile) == "wireframe") {
      SetIconWireframeSelected();
    }
 
    // special case : perspective/ortho
  }
  else if ((std::string(aIconFile) == "perspective") || (std::string(aIconFile) == "ortho")) {
    QString txt = QString(aIconFile);
    QAction* action = currentToolbar->addAction(
      QIcon(*pix), aIconFile, this, [this, txt]() { this->ChangePerspectiveOrtho(txt); });
    action->setCheckable(true);
    action->setChecked(true);
    action->setData(aIconFile);
 
    if (std::string(aIconFile) == "perspective") {
      SetIconPerspectiveSelected();
    }
    if (std::string(aIconFile) == "ortho") {
      SetIconOrthoSelected();
    }
  }
  else {
    // Find the command in the command tree
    G4UImanager* UI = G4UImanager::GetUIpointer();
    if (UI == nullptr) return;
    G4UIcommandTree* treeTop = UI->GetTree();
    if (aCommand != nullptr) {
      std::string str = aCommand;
      std::string::size_type pos = str.find(' ');
      if (pos != std::string::npos) {
        str = str.substr(0, pos).c_str();
      }
      if (treeTop->FindPath(str.c_str()) == nullptr) {
        G4UImanager* UImanager = G4UImanager::GetUIpointer();
        G4int verbose = UImanager->GetVerboseLevel();
 
        if (verbose >= 2) {
          G4cout << "Warning: command '" << aCommand
                 << "' does not exist, please define it before using it." << G4endl;
        }
      }
    }
    QString txt = QString(aCommand);
    currentToolbar->addAction(
      QIcon(*pix), aCommand, this, [this, txt]() { this->ButtonCallback(txt); });
  }
}

AddMenu()

void G4UIQt::AddMenu ( const char * aName, const char * aLabel )

overridevirtual

Add a new menu to the menu bar

Parameters

aName	name of menu
aLabel	label to display

Reimplemented from G4VInteractiveSession.

Definition at line 2793 of file G4UIQt.cc.

{
  if (aName == nullptr) return;
  if (aLabel == nullptr) return;
 
  auto fileMenu = new QMenu(aLabel);
  fMainWindow->menuBar()->addMenu(fileMenu);
 
  AddInteractor(aName, (G4Interactor)fileMenu);
}

AddTabWidget()

G4bool G4UIQt::AddTabWidget	(	QWidget *	aWidget,
		QString	name )

Add a new tab widget. Create the tab if it was not done

Definition at line 2283 of file G4UIQt.cc.

{
  if (fViewerTabWidget == nullptr) {
    CreateViewerWidget();
  }
 
  if (aWidget == nullptr) {
    return false;
  }
  // Has to be added before we put it into the fViewerTabWidget widget
  aWidget->setParent(fViewerTabWidget);  // Will create in some cases widget outside
  // of UI for a really short moment
 
  fViewerTabWidget->addTab(aWidget, name);
 
  fViewerTabWidget->setCurrentIndex(fViewerTabWidget->count() - 1);
 
  // Set visible
  fViewerTabWidget->setLastTabCreated(fViewerTabWidget->currentIndex());
 
  // Not the good solution, but ensure that the help tree is correctly build when launching a viewer
  // It should be done by a notification when adding a command, but that's nit done yet
  // (Geant4.10.1)
  FillHelpTree();
 
  return true;
}

Referenced by G4OpenInventorQtExaminerViewer::afterRealizeHook(), G4OpenGLQtViewer::CreateMainWindow(), G4VtkQtViewer::CreateMainWindow(), G4UIQt(), G4ToolsSGQtGLESViewer::Initialise(), and G4ToolsSGQtZBViewer::Initialise().

AddViewerTab()

G4bool G4UIQt::AddViewerTab	(	QWidget *	aWidget,
		std::string	title )

Add a new tab in the viewer

Definition at line 2243 of file G4UIQt.cc.

{
  if (fViewerTabWidget == nullptr) {
    return false;
  }
  fViewerTabWidget->addTab(aWidget, title.c_str());
 
  return true;
}

AddViewerTabFromFile()

G4bool G4UIQt::AddViewerTabFromFile	(	std::string	fileName,
		std::string	title )

Add a new tab in the viewer

Definition at line 2255 of file G4UIQt.cc.

{
  if (fViewerTabWidget == nullptr) {
    return false;
  }
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI == nullptr) return false;
  std::ifstream file(UI->FindMacroPath(fileName.c_str()).data());
  if (file) {
    std::string content((std::istreambuf_iterator<char>(file)), (std::istreambuf_iterator<char>()));
 
    auto text = new QTextEdit();
    text->setAcceptRichText(true);
    text->setContentsMargins(5, 5, 5, 5);
    text->setText(QString("<pre>") + content.c_str() + "</pre>");
    text->setReadOnly(true);
    fViewerTabWidget->addTab(text, title.c_str());
  }
  else {
    return false;
  }
  return true;
}

ClearMenu()

void G4UIQt::ClearMenu ( )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 3110 of file G4UIQt.cc.

{ fMainWindow->menuBar()->clear(); }

DefaultIcons()

void G4UIQt::DefaultIcons ( G4bool aVal )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 287 of file G4UIQt.cc.

{
  fDefaultIcons = aVal;
 
  if (! fMainWindow->isVisible()) {
    return;
  }
 
  if (fToolbarApp != nullptr) {
    if (aVal) {
      fToolbarApp->setVisible(true);
    }
    else {
      // Set not visible until session start
      fToolbarApp->setVisible(false);
    }
  }
}

getClearIcon()

QPixmap * G4UIQt::getClearIcon ( )

inline

Definition at line 209 of file G4UIQt.hh.

{ return fClearIcon; };

GetCoutDockWidget()

G4UIDockWidget * G4UIQt::GetCoutDockWidget ( )

inline

Definition at line 220 of file G4UIQt.hh.

{ return fCoutDockWidget; };

GetCoutWidget()

QWidget * G4UIQt::GetCoutWidget ( )

inline

Definition at line 217 of file G4UIQt.hh.

{ return fCoutDockWidget->widget(); };

GetHelpWidget()

QWidget * G4UIQt::GetHelpWidget ( )

inline

Definition at line 232 of file G4UIQt.hh.

{ return fHelpTBWidget; }

GetHistoryWidget()

QWidget * G4UIQt::GetHistoryWidget ( )

inline

Definition at line 229 of file G4UIQt.hh.

{ return fHistoryTBWidget; }

GetMainWindow()

QMainWindow * G4UIQt::GetMainWindow ( )

inline

Definition at line 203 of file G4UIQt.hh.

{ return fMainWindow; };

Referenced by G4ToolsSGQtGLESViewer::Initialise(), and G4ToolsSGQtZBViewer::Initialise().

GetPickInfosWidget()

QWidget * G4UIQt::GetPickInfosWidget

(

)

Get the Pick Widget

Definition at line 2233 of file G4UIQt.cc.

{
  if (fPickInfosDialog == nullptr) {
    CreatePickInfosDialog();
  }
  return fPickInfosWidget;
}

GetSceneTreeWidget()

QWidget * G4UIQt::GetSceneTreeWidget

(

)

Get the ViewerComponents ToolBox Widget

Definition at line 2219 of file G4UIQt.cc.

{ return fSceneTreeWidget; }

getSearchIcon()

QPixmap * G4UIQt::getSearchIcon ( )

inline

Definition at line 206 of file G4UIQt.hh.

{ return fSearchIcon; };

GetUITabWidget()

QTabWidget * G4UIQt::GetUITabWidget ( )

inline

Definition at line 226 of file G4UIQt.hh.

{ return fUITabWidget; }

GetUserInterfaceWidget()

G4UIDockWidget * G4UIQt::GetUserInterfaceWidget ( )

inline

Definition at line 223 of file G4UIQt.hh.

{ return fUIDockWidget; };

GetViewerPropertiesWidget()

QWidget * G4UIQt::GetViewerPropertiesWidget

(

)

Get the Viewer properties Widget

Definition at line 2223 of file G4UIQt.cc.

{
  if (fViewerPropertiesDialog == nullptr) {
    CreateViewerPropertiesDialog();
  }
  return fViewerPropertiesWidget;
}

GetViewerTabWidget()

QTabWidget * G4UIQt::GetViewerTabWidget ( )

inline

Definition at line 171 of file G4UIQt.hh.

{ return fViewerTabWidget; };

Referenced by G4OpenInventorQtExaminerViewer::afterRealizeHook(), G4OpenGLQtViewer::CreateMainWindow(), and G4OpenGLQtViewer::isCurrentWidget().

IsIconMoveSelected()

G4bool G4UIQt::IsIconMoveSelected ( )

inline

Definition at line 184 of file G4UIQt.hh.

{ return fMoveSelected; };

Referenced by G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

IsIconPickSelected()

G4bool G4UIQt::IsIconPickSelected ( )

inline

Definition at line 186 of file G4UIQt.hh.

{ return fPickSelected; };

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

IsIconRotateSelected()

G4bool G4UIQt::IsIconRotateSelected ( )

inline

Definition at line 185 of file G4UIQt.hh.

{ return fRotateSelected; };

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::G4MouseReleaseEvent(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

IsIconZoomInSelected()

G4bool G4UIQt::IsIconZoomInSelected ( )

inline

Definition at line 187 of file G4UIQt.hh.

{ return fZoomInSelected; };

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

IsIconZoomOutSelected()

G4bool G4UIQt::IsIconZoomOutSelected ( )

inline

Definition at line 188 of file G4UIQt.hh.

{ return fZoomOutSelected; };

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

IsSplitterReleased()

G4bool G4UIQt::IsSplitterReleased

(

)

NativeMenu()

void G4UIQt::NativeMenu ( G4bool aVal )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 3102 of file G4UIQt.cc.

{
  if (fMainWindow->menuBar()->isNativeMenuBar() == aVal) return;  // already in this state
 
  // Menu become empty when goin from Qt to Native Bar
  fMainWindow->menuBar()->setNativeMenuBar(aVal);
}

PauseSessionStart()

void G4UIQt::PauseSessionStart ( const G4String & aState )

overridevirtual

Called by intercoms/src/G4UImanager.cc
Called by visualization/management/src/G4VisCommands.cc with "EndOfEvent" argument
It have to pause the session command terminal.
Call SecondaryLoop to wait for exit event

Parameters

aState

See also

: G4VisCommandReviewKeptEvents::SetNewValue

Implements G4VBasicShell.

Definition at line 2418 of file G4UIQt.cc.

{
  if (aState == nullptr) return;
 
  if (aState == "G4_pause> ") {  // TO KEEP
    SecondaryLoop("Pause, type continue to exit this state");  // TO KEEP
  }  // TO KEEP
 
  if (aState == "EndOfEvent") {  // TO KEEP
    // Picking with feed back in event data Done here !!!
    SecondaryLoop("End of event, type continue to exit this state");  // TO KEEP
  }  // TO KEEP
}

Prompt()

void G4UIQt::Prompt

(

G4String

aPrompt

)

Display the prompt in the prompt area

Parameters

aPrompt

: string to display as the promt label

Definition at line 2396 of file G4UIQt.cc.

{
  if (aPrompt == nullptr) return;
 
  fCommandLabel->setText((char*)aPrompt.data());
}

Referenced by SessionStart().

ReceiveG4cerr()

G4int G4UIQt::ReceiveG4cerr ( const G4String & aString )

overridevirtual

Receive a cerr from Geant4. We have to display it in the cout zone

Parameters

aString

: label to add in the display area

Returns

0

Reimplemented from G4coutDestination.

Definition at line 2654 of file G4UIQt.cc.

{
  if (aString.empty()) return 0;
 
#ifdef G4MULTITHREADED
  G4AutoLock al(&ReceiveMutex);
#endif
 
  // A workaround so that output is not lost after crash or G4Exception.
  // The "workaround" is to make sure all flushed output appears on
  // the terminal after a crash, because even flushed output can
  // get lost in the Qt UI system.
  // But...it seems workers write to std::cout/cerr anyway (is that a bug?),
  // so limit this to the master thread
#ifdef G4MULTITHREADED
  if (G4Threading::IsMasterThread())
#endif
    std::cerr << aString << std::flush;
 
  G4String aStringWithStyle;
  // aString has a \n on the end (maybe it comes from G4endl or from the
  // Enter key on the command line) - ignore it. That’s why
  // i < aString.length() - 1
  // But other \n need to be translated to an HTML newline.
  // Similarly, spaces need to be translated to an HTML "non-breaking space".
  // Tabs (\t) are more tricky since the number of equivalent spaces depends
  // on how many characters precede it. Probably needs an HTML table. For now
  // we replace \t with four spaces.
  for (G4int i = 0; i < (G4int)aString.length() - 1; ++i) {
    if (aString[i] == '\n') {
      aStringWithStyle += "<br>";
    }
    else if (aString[i] == ' ') {
      aStringWithStyle += "&nbsp;";
    }
    else if (aString[i] == '\t') {
      aStringWithStyle += "&nbsp;&nbsp;&nbsp;&nbsp;";
    }
    else if (aString[i] == '<') {
      aStringWithStyle += "&lt;";
    }
    else {
      aStringWithStyle += aString[i];
    }
  }
  if (fOutputStyles["cerr"].fixed) {
    aStringWithStyle = "<span style='font-family:courier;'>" + aStringWithStyle + "</span>";
  }
  else {
    aStringWithStyle = "<span>" + aStringWithStyle + "</span>";
  }
 
  // Add to string
 
  G4UIOutputString txt =
    G4UIOutputString(QString((char*)aStringWithStyle.data()).trimmed(), GetThreadPrefix(), "error");
  fG4OutputString.push_back(txt);
 
#ifdef G4MULTITHREADED
  QString result = FilterOutput(txt, fThreadsFilterComboBox->currentText(), fCoutFilter->text());
#else
  QString result = FilterOutput(txt, "", fCoutFilter->text());
#endif
  if (result.isEmpty()) {
    return 0;
  }
 
  // Suppress space, \n,\t,\r...
  if (QString(aString.data()).trimmed() != "") {
    if ((G4StateManager::GetStateManager()->GetCurrentState() == G4State_Abort) ||
        (G4StateManager::GetStateManager()->GetCurrentState() == G4State_Quit))
    {
      // In case of Abort or Quit, the useful error message should be in the last error message !
      fLastErrMessage += "\n" + aString;
      QString criticalMessage = fLastErrMessage.data();
      criticalMessage = criticalMessage.toHtmlEscaped();
      QMessageBox::critical(fMainWindow, "Error", QString(fLastErrMessage));
    }
  }
  fCoutTBTextArea->append(QString("<font color=\"Red\">") + result + QString("</font>"));
  fCoutTBTextArea->ensureCursorVisible();
 
  if (QString(aString.data()).trimmed() != "") {
    fLastErrMessage += aString;
  }
#ifdef G4MULTITHREADED
  UpdateCoutThreadFilter();
#endif
  return 0;
}

Referenced by ReceiveG4cout().

ReceiveG4cout()

G4int G4UIQt::ReceiveG4cout ( const G4String & aString )

overridevirtual

Receive a cout from Geant4. We have to display it in the cout zone

Parameters

aString

: label to add in the display area

Returns

0

Reimplemented from G4coutDestination.

Definition at line 2553 of file G4UIQt.cc.

{
  if (aString.empty()) return 0;
 
  // Try to be smart :
  // "*** This is just a warning message. ***"
  if (G4StrUtil::contains(aString, "*** This is just a warning message. ***")) {
    return ReceiveG4cerr(aString);
  }
 
#ifdef G4MULTITHREADED
  G4AutoLock al(&ReceiveMutex);
#endif
 
  // A workaround so that output is not lost after crash or G4Exception.
  // The "workaround" is to make sure all flushed output appears on
  // the terminal after a crash, because even flushed output can
  // get lost in the Qt UI system.
  // But...it seems workers write to std::cout/cerr anyway (is that a bug?),
  // so limit this to the master thread
#ifdef G4MULTITHREADED
  if (G4Threading::IsMasterThread())
#endif
    std::cout << aString << std::flush;
 
  G4String aStringWithStyle;
  // aString has a \n on the end (maybe it comes from G4endl or from the
  // Enter key on the command line) - ignore it. That’s why
  // i < aString.length() - 1
  // But other \n need to be translated to an HTML newline.
  // Similarly, spaces need to be translated to an HTML "non-breaking space".
  // Tabs (\t) are more tricky since the number of equivalent spaces depends
  // on how many characters precede it. Probably needs an HTML table. For now
  // we replace \t with four spaces.
  for (G4int i = 0; i < (G4int)aString.length() - 1; ++i) {
    if (aString[i] == '\n') {
      aStringWithStyle += "<br>";
    }
    else if (aString[i] == ' ') {
      aStringWithStyle += "&nbsp;";
    }
    else if (aString[i] == '\t') {
      aStringWithStyle += "&nbsp;&nbsp;&nbsp;&nbsp;";
    }
    else if (aString[i] == '<') {
      aStringWithStyle += "&lt;";
    }
    else {
      aStringWithStyle += aString[i];
    }
  }
  if (fOutputStyles["cout"].fixed) {
    aStringWithStyle = "<span style='font-family:courier;'>" + aStringWithStyle + "</span>";
  }
  else {
    aStringWithStyle = "<span>" + aStringWithStyle + "</span>";
  }
 
  // Add to string
  G4UIOutputString txt =
    G4UIOutputString(QString((char*)aStringWithStyle.data()), GetThreadPrefix());
  fG4OutputString.push_back(txt);
 
#ifdef G4MULTITHREADED
  QString result = FilterOutput(txt, fThreadsFilterComboBox->currentText(), fCoutFilter->text());
#else
  QString result = FilterOutput(txt, "", fCoutFilter->text());
#endif
 
  if (result.isEmpty()) {
    return 0;
  }
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (fOutputStyles["cout"].highlight) {
    if (! UI->IsLastCommandOutputTreated()) {
      QPalette pal;
      result = QString("<span style='background:") + pal.link().color().name() +
               ";'>&nbsp;</span>" + "<span style='background:" + pal.highlight().color().name() +
               ";'> " + result + "</span>";
    }
  }
  UI->SetLastCommandOutputTreated();
 
  fCoutTBTextArea->append(result);
  fCoutTBTextArea->ensureCursorVisible();
 
#ifdef G4MULTITHREADED
  UpdateCoutThreadFilter();
#endif
 
  // reset error stack
  fLastErrMessage = aString;
  return 0;
}

ReceiveG4debug()

G4int G4UIQt::ReceiveG4debug ( const G4String & aString )

overridevirtual

Receive a debug log message from Geant4. We have to display it in the cout zone

Parameters

aString

: label to add in the display area

Returns

0

Reimplemented from G4coutDestination.

Definition at line 2464 of file G4UIQt.cc.

{
  if (aString.empty()) return 0;
 
#ifdef G4MULTITHREADED
  G4AutoLock al(&ReceiveMutex);
#endif
 
  // A workaround so that output is not lost after crash or G4Exception.
  // The "workaround" is to make sure all flushed output appears on
  // the terminal after a crash, because even flushed output can
  // get lost in the Qt UI system.
  // But...it seems workers write to std::cout/cerr anyway (is that a bug?),
  // so limit this to the master thread
#ifdef G4MULTITHREADED
  if (G4Threading::IsMasterThread())
#endif
    std::cout << aString << std::flush;
 
  G4String aStringWithStyle;
  // aString has a \n on the end (maybe it comes from G4endl or from the
  // Enter key on the command line) - ignore it. That’s why
  // i < aString.length() - 1
  // But other \n need to be translated to an HTML newline.
  // Similarly, spaces need to be translated to an HTML "non-breaking space".
  // Tabs (\t) are more tricky since the number of equivalent spaces depends
  // on how many characters precede it. Probably needs an HTML table. For now
  // we replace \t with four spaces.
  for (G4int i = 0; i < (G4int)aString.length() - 1; ++i) {
    if (aString[i] == '\n') {
      aStringWithStyle += "<br>";
    }
    else if (aString[i] == ' ') {
      aStringWithStyle += "&nbsp;";
    }
    else if (aString[i] == '\t') {
      aStringWithStyle += "&nbsp;&nbsp;&nbsp;&nbsp;";
    }
    else if (aString[i] == '<') {
      aStringWithStyle += "&lt;";
    }
    else {
      aStringWithStyle += aString[i];
    }
  }
  if (fOutputStyles["debug"].fixed) {
    aStringWithStyle = "<span style='font-family:courier;'>" + aStringWithStyle + "</span>";
  }
  else {
    aStringWithStyle = "<span>" + aStringWithStyle + "</span>";
  }
 
  // Add to string
  G4UIOutputString txt =
    G4UIOutputString(QString((char*)aStringWithStyle.data()), GetThreadPrefix());
  fG4OutputString.push_back(txt);
 
#ifdef G4MULTITHREADED
  QString result = FilterOutput(txt, fThreadsFilterComboBox->currentText(), fCoutFilter->text());
#else
  QString result = FilterOutput(txt, "", fCoutFilter->text());
#endif
 
  if (result.isEmpty()) {
    return 0;
  }
 
  if (fOutputStyles["debug"].highlight) {
    QPalette pal;
    result = QString("<span style='background:") + pal.link().color().name() + ";'>&nbsp;</span>" +
             "<span style='background: Pink;'> " + result + "</span>";
  }
  result = QString("<font color=\"Green\">") + result + QString("</font>");
 
  fCoutTBTextArea->append(result);
  fCoutTBTextArea->ensureCursorVisible();
 
#ifdef G4MULTITHREADED
  UpdateCoutThreadFilter();
#endif
 
  return 0;
}

SessionStart()

G4UIsession * G4UIQt::SessionStart ( )

overridevirtual

Start the Qt main loop

Implements G4VBasicShell.

Definition at line 2355 of file G4UIQt.cc.

{
  G4Qt* interactorManager = G4Qt::getInstance();
  Prompt("Session :");
  exitSession = false;
 
  QCoreApplication::sendPostedEvents();
 
  fMainWindow->setVisible(true);
 
  if (fDefaultIcons) {
    fToolbarApp->setVisible(true);
  }
  else {
    // Set not visible until session start
    fToolbarApp->setVisible(false);
  }
  // Rebuild help tree (new command could be registered)
  FillHelpTree();
 
  // Rebuild command completion (new command could be registered)
  UpdateCommandCompleter();
 
  // Set event filters
  fHistoryTBTableList->installEventFilter(this);
  fCommandArea->installEventFilter(this);
 
  // Focus on command line
  fCommandArea->setFocus();
 
  interactorManager->DisableSecondaryLoop();  // TO KEEP
  if ((QApplication*)interactorManager->GetMainInteractor() != nullptr)
    ((QApplication*)interactorManager->GetMainInteractor())->exec();
 
  interactorManager->EnableSecondaryLoop();
  return this;
}

SessionTerminate()

void G4UIQt::SessionTerminate

(

)

Definition at line 2403 of file G4UIQt.cc.

{
  G4Qt* interactorManager = G4Qt::getInstance();
  fMainWindow->close();
  ((QApplication*)interactorManager->GetMainInteractor())->exit();
}

SetIconHLHSRSelected()

void G4UIQt::SetIconHLHSRSelected

(

)

Definition at line 5335 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
 
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "hidden_line_and_surface_removal") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "solid") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "hidden_line_removal") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "wireframe") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

SetIconHLRSelected()

void G4UIQt::SetIconHLRSelected

(

)

Definition at line 5308 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "hidden_line_removal") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "solid") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "hidden_line_and_surface_removal") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "wireframe") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

SetIconMoveSelected()

void G4UIQt::SetIconMoveSelected

(

)

Definition at line 5089 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fMoveSelected = true;
  fRotateSelected = false;
  fPickSelected = false;
  fZoomInSelected = false;
  fZoomOutSelected = false;
 
  if (fToolbarApp == nullptr) return;
  QList<QAction*> list = fToolbarApp->actions();
  for (auto i : list) {
    if (i->data().toString() == "move") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "rotate") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "pick") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_in") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_out") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon().

SetIconOrthoSelected()

void G4UIQt::SetIconOrthoSelected

(

)

Definition at line 5384 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
 
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "ortho") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "perspective") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

SetIconPerspectiveSelected()

void G4UIQt::SetIconPerspectiveSelected

(

)

Definition at line 5363 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "perspective") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "ortho") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

SetIconPickSelected()

void G4UIQt::SetIconPickSelected

(

)

Definition at line 5149 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fPickSelected = true;
  fMoveSelected = false;
  fRotateSelected = false;
  fZoomInSelected = false;
  fZoomOutSelected = false;
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "pick") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "move") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "rotate") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_in") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_out") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon().

SetIconRotateSelected()

void G4UIQt::SetIconRotateSelected

(

)

Definition at line 5119 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fRotateSelected = true;
  fMoveSelected = false;
  fPickSelected = false;
  fZoomInSelected = false;
  fZoomOutSelected = false;
 
  if (fToolbarApp == nullptr) return;
  QList<QAction*> list = fToolbarApp->actions();
  for (auto i : list) {
    if (i->data().toString() == "rotate") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "move") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "pick") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_in") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_out") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon().

SetIconSolidSelected()

void G4UIQt::SetIconSolidSelected

(

)

Definition at line 5254 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "solid") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "hidden_line_removal") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "hidden_line_and_surface_removal") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "wireframe") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

SetIconWireframeSelected()

void G4UIQt::SetIconWireframeSelected

(

)

Definition at line 5281 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "wireframe") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "hidden_line_removal") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "hidden_line_and_surface_removal") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "solid") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon(), and G4OpenGLQtViewer::updateToolbarAndMouseContextMenu().

SetIconZoomInSelected()

void G4UIQt::SetIconZoomInSelected

(

)

Definition at line 5184 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fZoomInSelected = true;
  fMoveSelected = false;
  fRotateSelected = false;
  fPickSelected = false;
  fZoomOutSelected = false;
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "zoom_in") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "move") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "rotate") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "pick") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_out") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon().

SetIconZoomOutSelected()

void G4UIQt::SetIconZoomOutSelected

(

)

Definition at line 5219 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fZoomOutSelected = true;
  fMoveSelected = false;
  fRotateSelected = false;
  fPickSelected = false;
  fZoomInSelected = false;
 
  QToolBar* bar = fToolbarApp;
  if (! fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (bar == nullptr) return;
 
  QList<QAction*> list = bar->actions();
  for (auto i : list) {
    if (i->data().toString() == "zoom_out") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "move") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "rotate") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "pick") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_in") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon().

SetOutputStyle()

void G4UIQt::SetOutputStyle ( const char * destination, const char * style )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 3093 of file G4UIQt.cc.

{
  // Specify an output style
  // First argument destination ("cout" etc or "all")
  // Second argument is the required style - see guidance
 
  SetStyleUtility(destination, style);
}

SetStartPage()

void G4UIQt::SetStartPage

(

const std::string &

text

)

Definition at line 2311 of file G4UIQt.cc.

{
  if (! text.empty()) {
    fDefaultViewerFirstPageHTMLText = text;
  }
  if (fStartPage == nullptr) {
    fStartPage = new QTextBrowser();
    fStartPage->setContentsMargins(5, 5, 5, 5);
    fStartPage->setReadOnly(true);
  }
  fStartPage->setOpenExternalLinks(true);
  fStartPage->setHtml(fDefaultViewerFirstPageHTMLText.c_str());
}

UpdateSceneTree()

void G4UIQt::UpdateSceneTree ( const G4SceneTreeItem & root )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 1510 of file G4UIQt.cc.

{
  //  G4debug << "\nG4UIQt::UpdateSceneTree: scene tree summary\n";
  //  root.DumpTree(G4debug);  // Verbosity = 0 (one line per item)
  //  G4debug << "\nG4UIQt::UpdateSceneTree: scene tree dump\n";
  //  root.DumpTree(G4debug,1);  // Verbosity = 1 (higher levels available)
 
  // Clear the existing GUI-side tree
  fNewSceneTreeItemTreeWidget->clear();
  // (I think this deletes everything - the top level items and their children.)
 
  // Build a new GUI-side tree
  fNewSceneTreeItemTreeWidget->setHeaderLabel (root.GetDescription().c_str());
  for (const auto& model : root.GetChildren()) {
 
    auto item = new QTreeWidgetItem(fNewSceneTreeItemTreeWidget);
 
    // Add this GUI-side representation of the model as a child of the top widget
    fNewSceneTreeItemTreeWidget->insertTopLevelItem(0,item);
 
    // Add text that appears in the scene tree
    item->setText(0, model.GetModelType().c_str());
 
    // Load with info from model
    // There may be a way to add data as a QVariant, or a list of QVariants,
    // but let's try adding a G4SceneTreeItem pointer as a hex string. (There
    // does not seem to be a way of adding a pointer directly.)
    std::ostringstream oss; oss << std::hex << &model;
    auto data = QVariant(oss.str().c_str());
    item->setData(0, Qt::UserRole, data);
 
    // Load a tooltip
    item->setToolTip(0, model.GetModelDescription().c_str());
 
    // Set the check state
    item->setCheckState
    (0, model.GetVisAttributes().IsVisible()? Qt::Checked: Qt::Unchecked);
 
    // Set the expand state
    item->setExpanded(model.IsExpanded());
 
    if (model.GetType() == G4SceneTreeItem::pvmodel) {
      BuildPVQTree(model,item);
    }
  }
}

Referenced by G4ToolsSGQtGLESViewer::UpdateGUISceneTree(), and G4ToolsSGQtZBViewer::UpdateGUISceneTree().

---

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

• G4UIQt.hh
• G4UIQt.cc