#include <G4UIQt.hh>

Inheritance diagram for G4UIQt:

Public Member Functions
	G4UIQt (G4int, char **)

G4UIsession *	SessionStart ()

void	AddMenu (const char , const char )

void	AddButton (const char , const char , const char *)

void	AddIcon (const char userLabel, const char iconFile, const char command, const char file_name="")

void	OutputStyle (const char , const char , const char *)

void	NativeMenu (G4bool aVal)

void	ClearMenu ()

void	DefaultIcons (G4bool aVal)

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)

	~G4UIQt ()

void	Prompt (G4String)

void	SessionTerminate ()

virtual void	PauseSessionStart (const G4String &)

virtual G4int	ReceiveG4cout (const G4String &)

virtual G4int	ReceiveG4cerr (const G4String &)

Public Member Functions inherited from G4VBasicShell
	G4VBasicShell ()

virtual	~G4VBasicShell ()

virtual G4UIsession *	SessionStart ()=0

virtual void	PauseSessionStart (const G4String &Prompt)=0

Public Member Functions inherited from G4UIsession
	G4UIsession ()

	G4UIsession (G4int iBatch)

	~G4UIsession () override

virtual G4UIsession *	SessionStart ()

virtual void	PauseSessionStart (const G4String &Prompt)

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	AddCoutTransformer (const Transformer &t)

void	AddCoutTransformer (Transformer &&t)

void	AddCerrTransformer (const Transformer &t)

void	AddCerrTransformer (Transformer &&t)

virtual void	ResetTransformers ()

virtual G4int	ReceiveG4cout (const G4String &msg)

virtual G4int	ReceiveG4cerr (const G4String &msg)

G4int	ReceiveG4cout_ (const G4String &msg)

G4int	ReceiveG4cerr_ (const G4String &msg)

Public Member Functions inherited from G4VInteractiveSession
	G4VInteractiveSession ()

virtual	~G4VInteractiveSession ()

virtual void	AddMenu (const char , const char )

virtual void	AddButton (const char , const char , const char *)

virtual void	AddIcon (const char , const char , const char , const char )

virtual void	DefaultIcons (bool)

virtual void	OutputStyle (const char , const char , const char *)

virtual void	NativeMenu (bool)

virtual void	ClearMenu ()

void	AddInteractor (G4String, G4Interactor)

G4Interactor	GetInteractor (G4String)

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 &)

virtual G4bool	GetHelpChoice (G4int &)=0

virtual void	ExitHelp () const =0

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 Attributes inherited from G4UIsession
G4int	ifBatch = 0

G4int	lastRC = 0

Protected Attributes inherited from G4coutDestination
std::vector< Transformer >	transformersCout

std::vector< Transformer >	transformersCerr

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 123 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 115 of file G4UIQt.cc.

:fMainWindow(NULL)
,fCommandLabel(NULL)
,fCommandArea(NULL)
,fCoutTBTextArea(NULL)
,fUITabWidget(NULL)
,fCoutFilter(NULL)
,fCompleter(NULL)
,fDefaultIcons(true)
,fHistoryTBTableList(NULL)
,fHelpTreeWidget(NULL)
,fHelpTBWidget(NULL)
,fHistoryTBWidget(NULL)
,fCoutDockWidget(NULL)
,fUIDockWidget(NULL)
,fSceneTreeWidget(NULL)
,fViewerPropertiesWidget(NULL)
,fPickInfosWidget(NULL)
,fHelpLine(NULL)
,fViewerTabWidget(NULL)
,fCoutText("Output")
,fStartPage(NULL)
,fHelpVSplitter(NULL)
,fParameterHelpLabel(NULL)
,fParameterHelpTable(NULL)
,fToolbarApp(NULL)
,fToolbarUser(NULL)
,fStringSeparator("__$$$@%%###__")
,fLastOpenPath("")
,fSearchIcon(NULL)
,fClearIcon(NULL)
,fSaveIcon(NULL)
,fOpenIcon(NULL)
,fMoveIcon(NULL)
,fRotateIcon(NULL)
,fPickIcon(NULL)
,fZoomInIcon(NULL)
,fZoomOutIcon(NULL)
,fWireframeIcon(NULL)
,fSolidIcon(NULL)
,fHiddenLineRemovalIcon(NULL)
,fHiddenLineAndSurfaceRemovalIcon(NULL)
,fPerspectiveIcon(NULL)
,fOrthoIcon(NULL)
,fCommandIcon(NULL)
,fDirIcon(NULL)
,fRunIcon(NULL)
,fParamIcon(NULL)
,fPickTargetIcon(NULL)
#ifdef G4MULTITHREADED
,fThreadsFilterComboBox(NULL)
#endif
,fDefaultViewerFirstPageHTMLText("")
,fViewerPropertiesDialog(NULL)
,fPickInfosDialog(NULL)
,fLastCompleteCommand("")
,fMoveSelected(false)
,fRotateSelected(true)
,fPickSelected(false)
,fZoomInSelected(false)
,fZoomOutSelected(false)
{
 
  G4Qt* interactorManager = G4Qt::getInstance (argc,argv,(char*)"Qt");
  if (!(QApplication*)interactorManager->GetMainInteractor()) {
    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!=NULL) UI->SetSession(this);
  if(UI!=NULL) UI->SetG4UIWindow(this);
 
  // Check if already define in external app QMainWindow
  G4bool found = false;
  Q_FOREACH (QWidget *widget, QApplication::allWidgets()) {
    if ((found== false) && (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();
 
  // Set default output styles
  for (const auto& destination: {"cout","cerr","warnings","errors"}) {
    G4UIQtStyle defaultStyle;
    defaultStyle.fixed = true;
    defaultStyle.highlight = true;
    fOutputStyles[destination] = defaultStyle;
  }
 
  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());
 
 
  // add defaults icons
  SetDefaultIconsToolbar();
 
  if(UI!=NULL) 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
 #if QT_VERSION < 0x040200
  fMainWindow->hide();
 #else
  fMainWindow->setVisible(false);
 #endif
}

◆ ~G4UIQt()

G4UIQt::~G4UIQt ( )

Definition at line 274 of file G4UIQt.cc.

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

Member Function Documentation

◆ AddButton()

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

virtual

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 2354 of file G4UIQt.cc.

{
  if(aMenu==NULL) return; // TO KEEP
  if(aLabel==NULL) return; // TO KEEP
  if(aCommand==NULL) return; // TO KEEP
 
  QMenu *parentTmp = (QMenu*)GetInteractor(aMenu);
 
  if(parentTmp==NULL) {
    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==NULL) 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) == NULL) {
    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;
      }
    }
  }
 
#if QT_VERSION < 0x050600
  QSignalMapper *signalMapper = new QSignalMapper(this);
  QAction *action = parentTmp->addAction(aLabel, signalMapper, SLOT(map()));
 
  connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(ButtonCallback(const QString&)));
  signalMapper->setMapping(action, QString(aCommand));
#else
  QString cmd_tmp = QString(aCommand);
  parentTmp->addAction(aLabel, this, [this, cmd_tmp](){ this->ButtonCallback(cmd_tmp); });
#endif
}

◆ AddIcon()

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

virtual

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 2429 of file G4UIQt.cc.

                                                                                                          {
  if(aLabel==NULL) return; // TO KEEP
  // special case, aCommand could be NULL if aIconFile is not user_icon
  if (aCommand==NULL) {
    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 = NULL;
  if (userToolBar) {
    if (fToolbarUser == NULL) {
      fToolbarUser = new QToolBar();
      fToolbarUser->setIconSize (QSize(20,20));
      fMainWindow->addToolBar(Qt::TopToolBarArea, fToolbarUser);
    }
    currentToolbar = fToolbarUser;
  } else {
    if (fToolbarApp == NULL) {
      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 (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->text() == QString(aLabel)) {
      G4UImanager* UI = G4UImanager::GetUIpointer();
      if(UI==NULL) return;
      G4int verbose =  UI->GetVerboseLevel();
      if (verbose >= 2) {
        G4cout << "Warning: A toolBar icon \""<< aLabel<< "\" already exists with the same name!" << G4endl;
      }
    }
  }
 
#if QT_VERSION < 0x050600
  QSignalMapper *signalMapper = new QSignalMapper(this);
  QAction *action = currentToolbar->addAction(QIcon(*pix),aLabel, signalMapper, SLOT(map()));
#endif
  // special cases :"open"
  if (std::string(aIconFile) == "open") {
    QString txt = aCommand + fStringSeparator + aLabel;
#if QT_VERSION < 0x050600
    connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(OpenIconCallback(const QString &)));
    signalMapper->setMapping(action, QString(txt));
#else
    currentToolbar->addAction(QIcon(*pix), aIconFile, this, [this, txt](){ this->OpenIconCallback(txt); });
#endif
 
  // special cases :"save"
  } else if (std::string(aIconFile) == "save") {
    QString txt = aCommand + fStringSeparator + aLabel;
#if QT_VERSION < 0x050600
    connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(SaveIconCallback(const QString&)));
    signalMapper->setMapping(action, QString(txt));
#else
    currentToolbar->addAction(QIcon(*pix), aIconFile, this, [this, txt](){ this->SaveIconCallback(txt); });
#endif
 
  // 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")) {
#if QT_VERSION < 0x050600
    connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(ChangeCursorAction(const QString&)));
    signalMapper->setMapping(action, QString(aIconFile));
#else
    QString txt = QString(aIconFile);
    QAction* action = currentToolbar->addAction(QIcon(*pix), aIconFile, this, [this, txt](){ this->ChangeCursorAction(txt); });
#endif
    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")) {
#if QT_VERSION < 0x050600
    connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(ChangeSurfaceStyle(const QString&)));
    signalMapper->setMapping(action, QString(aIconFile));
#else
    QString txt = QString(aIconFile);
    QAction* action = currentToolbar->addAction(QIcon(*pix), aIconFile, this, [this, txt](){ this->ChangeSurfaceStyle(txt); });
#endif
    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")) {
#if QT_VERSION < 0x050600
    connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(ChangePerspectiveOrtho(const QString&)));
    signalMapper->setMapping(action, QString(aIconFile));
#else
    QString txt = QString(aIconFile);
    QAction* action = currentToolbar->addAction(QIcon(*pix), aIconFile, this, [this, txt](){ this->ChangePerspectiveOrtho(txt); });
#endif
    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==NULL) return;
    G4UIcommandTree * treeTop = UI->GetTree();
    if (aCommand != NULL) {
      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()) == NULL) {
        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;
        }
      }
    }
 
#if QT_VERSION < 0x050600
    connect(signalMapper, SIGNAL(mapped(const QString &)),this, SLOT(ButtonCallback(const QString&)));
    signalMapper->setMapping(action, QString(aCommand));
#else
    QString txt = QString(aCommand);
    currentToolbar->addAction(QIcon(*pix), aCommand, this, [this, txt](){ this->ButtonCallback(txt); });
#endif
  }
}

Referenced by DefaultIcons().

◆ AddMenu()

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

virtual

Add a new menu to the menu bar

Parameters

aName	name of menu
aLabel	label to display

Reimplemented from G4VInteractiveSession.

Definition at line 2333 of file G4UIQt.cc.

{
  if (aName == NULL) return;
  if (aLabel == NULL) return;
 
  QMenu *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 1860 of file G4UIQt.cc.

{
  // Special case for Qt version between 5.0 and 5.1 on Mac OSX
  // Due to a bug in this Qt version, we can't put a OpenGL Widget inside the QTabWidget.
  // A work around is to put it outside. Returning false will fore the wiewer to put the QGLWidget
  // inside a new QWindow.
 
#ifdef Q_OS_MAC
  #if QT_VERSION < 0x050100
   #if QT_VERSION >= 0x050000
  QString message = QString(
                            "This Qt version [")+qVersion ()+"] has some issues with the OpenGL viewer.\n"+
  "To prevent problems, you are not allowed to open a Stored nor Immediate viewer.\n" +
  "\n" +
  "Please upgrade to Qt version >= 5.1\n";
 
  QMessageBox::warning(fMainWindow, tr("Warning"),
                       tr(message.toStdString().c_str()),
                       QMessageBox::Ok);
  return false;
  #endif
  #endif
#endif
 
  if (fViewerTabWidget == NULL) {
    CreateViewerWidget();
  }
 
  if (!aWidget) {
    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
 #if QT_VERSION < 0x040200
   fViewerTabWidget->setLastTabCreated(fViewerTabWidget->currentIndex());
 #else
   fViewerTabWidget->setLastTabCreated(fViewerTabWidget->currentIndex());
 #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 G4OpenInventorQtExaminerViewer::afterRealizeHook(), G4OpenGLQtViewer::CreateMainWindow(), G4VtkQtViewer::CreateMainWindow(), G4UIQt(), and G4ToolsSGQtViewer::Initialise().

◆ AddViewerTab()

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

Add a new tab in the viewer

Definition at line 1811 of file G4UIQt.cc.

{
  if (fViewerTabWidget == NULL) {
    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 1827 of file G4UIQt.cc.

{
  if (fViewerTabWidget == NULL) {
    return false;
  }
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return 0;
  std::ifstream file(UI->FindMacroPath(fileName.c_str()).data());
  if (file) {
 
    std::string content( (std::istreambuf_iterator<char>(file) ),
                        (std::istreambuf_iterator<char>()    ) );
 
    QTextEdit* 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 ( )

virtual

Reimplemented from G4VInteractiveSession.

Definition at line 2695 of file G4UIQt.cc.

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

◆ DefaultIcons()

void G4UIQt::DefaultIcons ( G4bool aVal )

virtual

Reimplemented from G4VInteractiveSession.

Definition at line 289 of file G4UIQt.cc.

{
  fDefaultIcons = aVal;
 
#if QT_VERSION < 0x040200
  if (!fMainWindow->isHidden()) {
#else
  if (!fMainWindow->isVisible()) {
#endif
    return;
  }
 
      if (fToolbarApp) {
    if (aVal) {
#if QT_VERSION < 0x040200
      fToolbarApp->show();
#else
      fToolbarApp->setVisible(true);
#endif
    } else {
      // Set not visible until session start
#if QT_VERSION < 0x040200
      fToolbarApp->hide();
#else
    fToolbarApp->setVisible(false);
#endif
    }
  }
}

◆ getClearIcon()

QPixmap * G4UIQt::getClearIcon ( )

inline

Definition at line 217 of file G4UIQt.hh.

217{ return fClearIcon;};

◆ GetCoutDockWidget()

G4UIDockWidget * G4UIQt::GetCoutDockWidget ( )

inline

Definition at line 230 of file G4UIQt.hh.

                                             {
    return fCoutDockWidget;
  };

◆ GetCoutWidget()

QWidget * G4UIQt::GetCoutWidget ( )

inline

Definition at line 225 of file G4UIQt.hh.

                                  {
    return fCoutDockWidget->widget();
  };

◆ GetHelpWidget()

QWidget * G4UIQt::GetHelpWidget ( )

inline

Definition at line 250 of file G4UIQt.hh.

                                  {
    return fHelpTBWidget;
  }

◆ GetHistoryWidget()

QWidget * G4UIQt::GetHistoryWidget ( )

inline

Definition at line 245 of file G4UIQt.hh.

                                     {
    return fHistoryTBWidget;
  }

◆ GetMainWindow()

QMainWindow * G4UIQt::GetMainWindow ( )

inline

Definition at line 210 of file G4UIQt.hh.

                                       {
    return fMainWindow;
  };

Referenced by G4ToolsSGQtViewer::Initialise().

◆ GetPickInfosWidget()

QWidget * G4UIQt::GetPickInfosWidget ( )

Get the Pick Widget

Definition at line 1799 of file G4UIQt.cc.

{
  if (!fPickInfosDialog) {
    CreatePickInfosDialog();
  }
  return fPickInfosWidget;
}

◆ GetSceneTreeWidget()

QWidget * G4UIQt::GetSceneTreeWidget ( )

Get the ViewerComponents ToolBox Widget

Definition at line 1780 of file G4UIQt.cc.

{
  return fSceneTreeWidget;
}

◆ getSearchIcon()

QPixmap * G4UIQt::getSearchIcon ( )

inline

Definition at line 215 of file G4UIQt.hh.

215{ return fSearchIcon;};

◆ GetUITabWidget()

QTabWidget * G4UIQt::GetUITabWidget ( )

inline

Definition at line 240 of file G4UIQt.hh.

                                      {
    return fUITabWidget;
  }

◆ GetUserInterfaceWidget()

G4UIDockWidget * G4UIQt::GetUserInterfaceWidget ( )

inline

Definition at line 235 of file G4UIQt.hh.

                                                  {
    return fUIDockWidget;
  };

◆ GetViewerPropertiesWidget()

QWidget * G4UIQt::GetViewerPropertiesWidget ( )

Get the Viewer properties Widget

Definition at line 1788 of file G4UIQt.cc.

{
  if (!fViewerPropertiesDialog) {
    CreateViewerPropertiesDialog();
  }
  return fViewerPropertiesWidget;
}

◆ GetViewerTabWidget()

QTabWidget * G4UIQt::GetViewerTabWidget ( )

inline

Definition at line 167 of file G4UIQt.hh.

                                          {
    return fViewerTabWidget;
  };

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

◆ IsIconMoveSelected()

G4bool G4UIQt::IsIconMoveSelected ( )

inline

Definition at line 182 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 188 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 191 of file G4UIQt.hh.

                                       {
    return fZoomInSelected;
  };

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

◆ IsIconZoomOutSelected()

G4bool G4UIQt::IsIconZoomOutSelected ( )

inline

Definition at line 194 of file G4UIQt.hh.

                                        {
    return fZoomOutSelected;
  };

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

◆ IsSplitterReleased()

G4bool G4UIQt::IsSplitterReleased ( )

◆ NativeMenu()

void G4UIQt::NativeMenu ( G4bool aVal )

virtual

Reimplemented from G4VInteractiveSession.

Definition at line 2686 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);
}

◆ OutputStyle()

void G4UIQt::OutputStyle	(	const char *	destination,
		const char *	style,
		const char *	highlight
	)

virtual

Reimplemented from G4VInteractiveSession.

Definition at line 2667 of file G4UIQt.cc.

{
  // Specify an output style
  // First argument destination (cout cerr warnings errors all)
  // Second argument is the style (fixed proportional)
  // Third argument highlights commands if "highlight" (and if /control/verbose > 0)
  G4String uiQtDestination(destination);
  G4UIQtStyle uiQtStyle;
  if (G4String(style) == "fixed") uiQtStyle.fixed = true; else uiQtStyle.fixed = false;
  if (G4String(highlight) == "highlight") uiQtStyle.highlight = true; else uiQtStyle.highlight = false;
  if (uiQtDestination == "all") {
    for (auto& i: fOutputStyles) {
      i.second = uiQtStyle;
    }
  } else {
    fOutputStyles[uiQtDestination] = uiQtStyle;
  }
}

◆ PauseSessionStart()

void G4UIQt::PauseSessionStart ( const G4String & aState )

virtual

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 2050 of file G4UIQt.cc.

{
  if (!aState) 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 2021 of file G4UIQt.cc.

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

Referenced by SessionStart().

◆ ReceiveG4cerr()

G4int G4UIQt::ReceiveG4cerr ( const G4String & aString )

virtual

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 G4UIsession.

Definition at line 2195 of file G4UIQt.cc.

{
  if (aString.empty()) return 0;
 
#ifdef G4MULTITHREADED
  G4AutoLock al(&ReceiveG4cerrMutex);
#endif
 
  // Workaround so that output is not lost after crash or G4Exception
  // It seems workers write to std::cerr anyway, so limit this to the master
#ifdef G4MULTITHREADED
  if (G4Threading::IsMasterThread())
#endif
    std::cerr << aString;
 
  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();
#if QT_VERSION < 0x050000
        criticalMessage = Qt::escape(criticalMessage);
#else
        criticalMessage = criticalMessage.toHtmlEscaped();
#endif
      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 )

virtual

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 G4UIsession.

Definition at line 2102 of file G4UIQt.cc.

{
  if(aString.empty()) return  0;
 
#ifdef G4MULTITHREADED
  G4AutoLock al(&ReceiveG4coutMutex);
#endif
 
  // Try to be smart :
  // "*** This is just a warning message. ***"
  if (G4StrUtil::contains(aString, "*** This is just a warning message. ***")) {
    return ReceiveG4cerr(aString);
  }
 
  // Workaround so that output is not lost after crash or G4Exception
  // It seems workers write to std::cout anyway, so limit this to the master
#ifdef G4MULTITHREADED
  if (G4Threading::IsMasterThread())
#endif
    std::cout << aString;
 
  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;
}

◆ SessionStart()

G4UIsession * G4UIQt::SessionStart ( )

virtual

Start the Qt main loop

Implements G4VBasicShell.

Definition at line 1967 of file G4UIQt.cc.

{
  G4Qt* interactorManager = G4Qt::getInstance ();
  Prompt("Session :");
  exitSession = false;
 
  QCoreApplication::sendPostedEvents () ;
 
  #if QT_VERSION < 0x040200
      fMainWindow->show();
  #else
      fMainWindow->setVisible(true);
  #endif
 
  if (fDefaultIcons) {
#if QT_VERSION < 0x040200
      fToolbarApp->show();
#else
      fToolbarApp->setVisible(true);
#endif
  } else {
    // Set not visible until session start
#if QT_VERSION < 0x040200
    fToolbarApp->hide();
#else
    fToolbarApp->setVisible(false);
#endif
  }
  // 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())
    ((QApplication*)interactorManager->GetMainInteractor())->exec();
 
  interactorManager->EnableSecondaryLoop ();
  return this;
}

◆ SessionTerminate()

void G4UIQt::SessionTerminate ( )

Definition at line 2032 of file G4UIQt.cc.

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

◆ SetIconHLHSRSelected()

void G4UIQt::SetIconHLHSRSelected ( )

Definition at line 5034 of file G4UIQt.cc.

                                  {
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (!fDefaultIcons) {
    bar = fToolbarUser;
  }
 
  if (!bar) return;
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "hidden_line_and_surface_removal") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "solid") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "hidden_line_removal") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "wireframe") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

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

◆ SetIconHLRSelected()

void G4UIQt::SetIconHLRSelected ( )

Definition at line 5009 of file G4UIQt.cc.

                                {
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (!fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (!bar) return;
 
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "hidden_line_removal") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "solid") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "hidden_line_and_surface_removal") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "wireframe") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

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

◆ SetIconMoveSelected()

void G4UIQt::SetIconMoveSelected ( )

Definition at line 4816 of file G4UIQt.cc.

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

Referenced by AddIcon().

◆ SetIconOrthoSelected()

void G4UIQt::SetIconOrthoSelected ( )

Definition at line 5081 of file G4UIQt.cc.

                                  {
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (!fDefaultIcons) {
    bar = fToolbarUser;
  }
 
  if (!bar) return;
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "ortho") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "perspective") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

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

◆ SetIconPerspectiveSelected()

void G4UIQt::SetIconPerspectiveSelected ( )

Definition at line 5059 of file G4UIQt.cc.

                                        {
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (!fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (!bar) return;
 
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "perspective") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "ortho") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

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

◆ SetIconPickSelected()

void G4UIQt::SetIconPickSelected ( )

Definition at line 4868 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) return;
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "pick") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "move") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "rotate") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "zoom_in") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "zoom_out") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

Referenced by AddIcon().

◆ SetIconRotateSelected()

void G4UIQt::SetIconRotateSelected ( )

Definition at line 4842 of file G4UIQt.cc.

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

Referenced by AddIcon().

◆ SetIconSolidSelected()

void G4UIQt::SetIconSolidSelected ( )

Definition at line 4961 of file G4UIQt.cc.

                                  {
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (!fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (!bar) return;
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "solid") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "hidden_line_removal") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "hidden_line_and_surface_removal") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "wireframe") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

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

◆ SetIconWireframeSelected()

void G4UIQt::SetIconWireframeSelected ( )

Definition at line 4985 of file G4UIQt.cc.

                                      {
  // Theses actions should be in the app toolbar
 
  QToolBar* bar = fToolbarApp;
  if (!fDefaultIcons) {
    bar = fToolbarUser;
  }
  if (!bar) return;
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "wireframe") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "hidden_line_removal") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "hidden_line_and_surface_removal") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "solid") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

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

◆ SetIconZoomInSelected()

void G4UIQt::SetIconZoomInSelected ( )

Definition at line 4899 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) return;
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "zoom_in") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "move") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "rotate") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "pick") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "zoom_out") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

Referenced by AddIcon().

◆ SetIconZoomOutSelected()

void G4UIQt::SetIconZoomOutSelected ( )

Definition at line 4930 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) return;
 
  QList<QAction *> list = bar->actions ();
  for (G4int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == "zoom_out") {
      list.at(i)->setChecked(TRUE);
    } else if (list.at(i)->data().toString () == "move") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "rotate") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "pick") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "zoom_in") {
      list.at(i)->setChecked(FALSE);
    }
  }
}

Referenced by AddIcon().

◆ SetStartPage()

void G4UIQt::SetStartPage ( const std::string & text )

Definition at line 1917 of file G4UIQt.cc.

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

Referenced by DefaultIcons().

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4UIQt()

◆ ~G4UIQt()

Member Function Documentation

◆ AddButton()

◆ AddIcon()

◆ AddMenu()

◆ AddTabWidget()

◆ AddViewerTab()

◆ AddViewerTabFromFile()

◆ ClearMenu()

◆ DefaultIcons()

◆ getClearIcon()

◆ GetCoutDockWidget()

◆ GetCoutWidget()

◆ GetHelpWidget()

◆ GetHistoryWidget()

◆ GetMainWindow()

◆ GetPickInfosWidget()

◆ GetSceneTreeWidget()

◆ getSearchIcon()

◆ GetUITabWidget()

◆ GetUserInterfaceWidget()

◆ GetViewerPropertiesWidget()

◆ GetViewerTabWidget()

◆ IsIconMoveSelected()

◆ IsIconPickSelected()

◆ IsIconRotateSelected()

◆ IsIconZoomInSelected()

◆ IsIconZoomOutSelected()

◆ IsSplitterReleased()

◆ NativeMenu()

◆ OutputStyle()

◆ PauseSessionStart()

◆ Prompt()

◆ ReceiveG4cerr()

◆ ReceiveG4cout()

◆ SessionStart()

◆ SessionTerminate()

◆ SetIconHLHSRSelected()

◆ SetIconHLRSelected()

◆ SetIconMoveSelected()

◆ SetIconOrthoSelected()

◆ SetIconPerspectiveSelected()

◆ SetIconPickSelected()

◆ SetIconRotateSelected()

◆ SetIconSolidSelected()

◆ SetIconWireframeSelected()

◆ SetIconZoomInSelected()

◆ SetIconZoomOutSelected()

◆ SetStartPage()