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	TogglePickSelection ()
void	SetIconZoomInSelected ()
void	SetIconZoomOutSelected ()
void	SetIconHLHSRSelected ()
void	SetIconHLRSelected ()
void	SetIconSolidSelected ()
void	SetIconWireframeSelected ()
void	SetIconCoudPointSelected ()
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
void	UpdateDrawingStyle (G4int style) override
void	UpdateProjectionStyle (G4int style) override
void	UpdateTransparencySlider (G4double depth, G4int option) override
	~G4UIQt () override
void	Prompt (const 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 (const 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 124 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 125 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),
    fTimeWindowWidget(nullptr),
    fHistoryTBWidget(nullptr),
    fCoutDockWidget(nullptr),
    fUIDockWidget(nullptr),
    fSceneTreeWidget(nullptr),
    fNewSceneTreeWidget(nullptr),
    fNewSceneTreeItemTreeWidget(nullptr),
    fMaxPVDepth(0),
    fNewSceneTreeSlider(nullptr),
    fUnwrapButtonWidget(nullptr),
    fFadeButtonWidget(nullptr),
    fXrayButtonWidget(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),
    fPointCloudIcon(nullptr),
    fHiddenLineRemovalIcon(nullptr),
    fHiddenLineAndSurfaceRemovalIcon(nullptr),
    fPerspectiveIcon(nullptr),
    fOrthoIcon(nullptr),
    fCommandIcon(nullptr),
    fDirIcon(nullptr),
    fRunIcon(nullptr),
    fParamIcon(nullptr),
    fPickTargetIcon(nullptr),
    fExitIcon(nullptr),
    fResetCameraIcon(nullptr),
    fResetTargetPointIcon(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());
 
  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());
 
  // 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
  int width = QGuiApplication::primaryScreen()->geometry().size().width() * 0.9;
  int height = QGuiApplication::primaryScreen()->geometry().size().height() * 0.9;
  fMainWindow->resize(width, height);
  fMainWindow->move((QGuiApplication::primaryScreen()->geometry().size().width() - width) / 2,
                    (QGuiApplication::primaryScreen()->geometry().size().height() - height) / 4);
 
  // 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 284 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 3772 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 3826 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) == "point_cloud") {
    pix = fPointCloudIcon;
  }
  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 if (std::string(aIconFile) == "reset_camera") {
    pix = fResetCameraIcon;
  }
  else if (std::string(aIconFile) == "resetTargetPoint") {
    pix = fResetTargetPointIcon;
  }
  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(false);
    action->setData(aIconFile);
 
    if (std::string(aIconFile) == "rotate") {
      SetIconRotateSelected();
    }
 
    // 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") ||
           (std::string(aIconFile) == "point_cloud"))
  {
    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();
    }
    if (std::string(aIconFile) == "point_cloud") {
      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();
    }
    // special cases :"resetCamera"
  }
  else if (std::string(aIconFile) == "reset_camera") {
    currentToolbar->addAction(QIcon(*pix), aIconFile, this, [this]() { this->ResetCameraCallback(); });
  }
  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 3755 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 3215 of file G4UIQt.cc.

{
#if QT_VERSION < 0x060000
  if (fViewerTabWidget == nullptr) {
    CreateViewerWidget();
  }
#endif
 
  if (aWidget == nullptr) {
    return false;
  }
#if QT_VERSION < 0x060000
  // 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());
#else
  //G.Barrand: disconnect temporarily the signal/slot on UpdateTabWidget(), else
  //           if adding a viewer, the UpdateTabWidget/Apply("vis/viewer/select") will
  //           issue an ERROR message since the viewer is not yet declared to the G4VisManager
  //           at this moment (see the logic in G4VisManager::CreateViewer()).
  QObject::disconnect(fViewerTabWidget, SIGNAL(currentChanged(int)), this, SLOT(UpdateTabWidget(int)));
  fViewerTabWidget->addTab(aWidget, name);
  fViewerTabWidget->setCurrentIndex(fViewerTabWidget->count() - 1);
  QObject::connect(fViewerTabWidget, SIGNAL(currentChanged(int)), this, SLOT(UpdateTabWidget(int)));
#endif
 
  // 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 G4VtkQtViewer::CreateMainWindow(), G4UIQt(), and G4RTQtScanner::GetQtWindow().

AddViewerTab()

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

Add a new tab in the viewer

Definition at line 3175 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 3187 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 4078 of file G4UIQt.cc.

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

DefaultIcons()

void G4UIQt::DefaultIcons ( G4bool aVal )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 297 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 214 of file G4UIQt.hh.

{ return fClearIcon; };

GetCoutDockWidget()

G4UIDockWidget * G4UIQt::GetCoutDockWidget ( )

inline

Definition at line 225 of file G4UIQt.hh.

{ return fCoutDockWidget; };

GetCoutWidget()

QWidget * G4UIQt::GetCoutWidget ( )

inline

Definition at line 222 of file G4UIQt.hh.

{ return fCoutDockWidget->widget(); };

GetHelpWidget()

QWidget * G4UIQt::GetHelpWidget ( )

inline

Definition at line 237 of file G4UIQt.hh.

{ return fHelpTBWidget; }

GetHistoryWidget()

QWidget * G4UIQt::GetHistoryWidget ( )

inline

Definition at line 234 of file G4UIQt.hh.

{ return fHistoryTBWidget; }

GetMainWindow()

QMainWindow * G4UIQt::GetMainWindow ( )

inline

Definition at line 208 of file G4UIQt.hh.

{ return fMainWindow; };

GetPickInfosWidget()

QWidget * G4UIQt::GetPickInfosWidget

(

)

Get the Pick Widget

Definition at line 3165 of file G4UIQt.cc.

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

GetSceneTreeWidget()

QWidget * G4UIQt::GetSceneTreeWidget

(

)

Get the ViewerComponents ToolBox Widget

Definition at line 3151 of file G4UIQt.cc.

{ return fSceneTreeWidget; }

getSearchIcon()

QPixmap * G4UIQt::getSearchIcon ( )

inline

Definition at line 211 of file G4UIQt.hh.

{ return fSearchIcon; };

GetUITabWidget()

QTabWidget * G4UIQt::GetUITabWidget ( )

inline

Definition at line 231 of file G4UIQt.hh.

{ return fUITabWidget; }

GetUserInterfaceWidget()

G4UIDockWidget * G4UIQt::GetUserInterfaceWidget ( )

inline

Definition at line 228 of file G4UIQt.hh.

{ return fUIDockWidget; };

GetViewerPropertiesWidget()

QWidget * G4UIQt::GetViewerPropertiesWidget

(

)

Get the Viewer properties Widget

Definition at line 3155 of file G4UIQt.cc.

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

GetViewerTabWidget()

QTabWidget * G4UIQt::GetViewerTabWidget ( )

inline

Definition at line 175 of file G4UIQt.hh.

{ return fViewerTabWidget; };

IsIconMoveSelected()

G4bool G4UIQt::IsIconMoveSelected ( )

inline

Definition at line 188 of file G4UIQt.hh.

{ return fMoveSelected; };

IsIconPickSelected()

G4bool G4UIQt::IsIconPickSelected ( )

inline

Definition at line 190 of file G4UIQt.hh.

{ return fPickSelected; };

IsIconRotateSelected()

G4bool G4UIQt::IsIconRotateSelected ( )

inline

Definition at line 189 of file G4UIQt.hh.

{ return fRotateSelected; };

IsIconZoomInSelected()

G4bool G4UIQt::IsIconZoomInSelected ( )

inline

Definition at line 191 of file G4UIQt.hh.

{ return fZoomInSelected; };

IsIconZoomOutSelected()

G4bool G4UIQt::IsIconZoomOutSelected ( )

inline

Definition at line 192 of file G4UIQt.hh.

{ return fZoomOutSelected; };

IsSplitterReleased()

G4bool G4UIQt::IsSplitterReleased

(

)

NativeMenu()

void G4UIQt::NativeMenu ( G4bool aVal )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 4070 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 3380 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

(

const G4String &

aPrompt

)

Display the prompt in the prompt area

Parameters

aPrompt

: string to display as the promt label

Definition at line 3358 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 3616 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 3515 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 3426 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 3317 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 3365 of file G4UIQt.cc.

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

SetIconCoudPointSelected()

void G4UIQt::SetIconCoudPointSelected

(

)

Definition at line 6334 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* toolbar = fToolbarApp;
  if (!fDefaultIcons) {
    toolbar = fToolbarUser;
  }
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->actions();
  for (auto i : list) {
    if (i->data().toString() == "point_cloud") {
      i->setChecked(true);
    }
    else if (i->data().toString() == "wireframe") {
      i->setChecked(false);
    }
    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 UpdateDrawingStyle().

SetIconHLHSRSelected()

void G4UIQt::SetIconHLHSRSelected

(

)

Definition at line 6303 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
 
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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);
    }
    else if (i->data().toString() == "point_cloud") {
      i->setChecked(false);
    }
  }
}

Referenced by UpdateDrawingStyle().

SetIconHLRSelected()

void G4UIQt::SetIconHLRSelected

(

)

Definition at line 6273 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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);
    }
    else if (i->data().toString() == "point_cloud") {
      i->setChecked(false);
    }
  }
}

Referenced by UpdateDrawingStyle().

SetIconMoveSelected()

void G4UIQt::SetIconMoveSelected

(

)

Definition at line 6080 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fMoveSelected = true;
  fRotateSelected = 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() == "zoom_in") {
      i->setChecked(false);
    }
    else if (i->data().toString() == "zoom_out") {
      i->setChecked(false);
    }
  }
}

SetIconOrthoSelected()

void G4UIQt::SetIconOrthoSelected

(

)

Definition at line 6386 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
 
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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 UpdateProjectionStyle().

SetIconPerspectiveSelected()

void G4UIQt::SetIconPerspectiveSelected

(

)

Definition at line 6365 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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 UpdateProjectionStyle().

SetIconRotateSelected()

void G4UIQt::SetIconRotateSelected

(

)

Definition at line 6106 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fRotateSelected = true;
  fMoveSelected = 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() == "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 6213 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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);
    }
    else if (i->data().toString() == "point_cloud") {
      i->setChecked(false);
    }
  }
}

Referenced by AddIcon(), and UpdateDrawingStyle().

SetIconWireframeSelected()

void G4UIQt::SetIconWireframeSelected

(

)

Definition at line 6243 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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);
    }
    else if (i->data().toString() == "point_cloud") {
      i->setChecked(false);
    }
  }
}

Referenced by UpdateDrawingStyle().

SetIconZoomInSelected()

void G4UIQt::SetIconZoomInSelected

(

)

Definition at line 6151 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fZoomInSelected = true;
  fMoveSelected = false;
  fRotateSelected = false;
  fZoomOutSelected = false;
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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() == "zoom_out") {
      i->setChecked(false);
    }
  }
}

SetIconZoomOutSelected()

void G4UIQt::SetIconZoomOutSelected

(

)

Definition at line 6182 of file G4UIQt.cc.

{
  // Theses actions should be in the app toolbar
  fZoomOutSelected = true;
  fMoveSelected = false;
  fRotateSelected = false;
  fZoomInSelected = false;
 
  QToolBar* toolbar = fToolbarApp;
  if (! fDefaultIcons) {
    toolbar = fToolbarUser;
  }
  if (toolbar == nullptr) return;
 
  QList<QAction*> list = toolbar->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() == "zoom_in") {
      i->setChecked(false);
    }
  }
}

SetOutputStyle()

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

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 4061 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 3256 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());
}

TogglePickSelection()

void G4UIQt::TogglePickSelection

(

)

Definition at line 6132 of file G4UIQt.cc.

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

UpdateDrawingStyle()

void G4UIQt::UpdateDrawingStyle ( G4int style )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 1761 of file G4UIQt.cc.

                                           {
  // Surface style
  switch (style) {
    case 0:
      this->SetIconWireframeSelected();
      break;
    case 1:
      this->SetIconHLRSelected();
      break;
    case 2:
      this->SetIconSolidSelected();
      break;
    case 3:
      this->SetIconHLHSRSelected();
      break;
    case 4:
      this->SetIconCoudPointSelected();
      break;
    default:
      return;
  }
}

UpdateProjectionStyle()

void G4UIQt::UpdateProjectionStyle ( G4int style )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 1784 of file G4UIQt.cc.

                                              {
  if (style == 0.) { // ortho
    this->SetIconOrthoSelected();
  } else {
    this->SetIconPerspectiveSelected();
  }
}

UpdateSceneTree()

void G4UIQt::UpdateSceneTree ( const G4SceneTreeItem & root )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 1707 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.)
  fMaxPVDepth = 0;
 
  // 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
    G4String toolTipMessage = model.GetModelDescription();
    if (!model.GetFurtherInfo().empty()) {
      toolTipMessage += "\n  " + model.GetFurtherInfo();
    }
    item->setToolTip(0, toolTipMessage.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) {
      thisSceneTreePVDepth = -1;  // First item is the model - touchables hang from it
      BuildPVQTree(model,item);
    }
  }
}

UpdateTransparencySlider()

void G4UIQt::UpdateTransparencySlider ( G4double depth, G4int option )

overridevirtual

Reimplemented from G4VInteractiveSession.

Definition at line 1792 of file G4UIQt.cc.

                                                                  {
  fNewSceneTreeSlider->blockSignals(true);
  fNewSceneTreeSlider->setValue(depth * maxInherentSliderValue / fMaxPVDepth);
  fNewSceneTreeSlider->blockSignals(false);
  if (option == 1) {
    fUnwrapButtonWidget->blockSignals(true);
    fUnwrapButtonWidget->setChecked(true);
    fUnwrapButtonWidget->blockSignals(false);
  }
  else if (option == 2) {
    fFadeButtonWidget->blockSignals(true);
    fFadeButtonWidget->setChecked(true);
    fFadeButtonWidget->blockSignals(false);
  }
  else if (option == 3) {
    fXrayButtonWidget->blockSignals(true);
    fXrayButtonWidget->setChecked(true);
    fXrayButtonWidget->blockSignals(false);
  }
}

---

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

• G4UIQt.hh
• G4UIQt.cc