#include <G4UIQt.hh>

Inheritance diagram for G4UIQt:

Data Structures
struct	G4UIQtStyle

Public Types
using	Transformer = std::function< G4bool(G4String &)>

Public Member Functions
void	AddButton (const char , const char , const char *)

void	AddCerrTransformer (const Transformer &t)

void	AddCerrTransformer (Transformer &&t)

void	AddCoutTransformer (const Transformer &t)

void	AddCoutTransformer (Transformer &&t)

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

void	AddInteractor (G4String, G4Interactor)

void	AddMenu (const char , const char )

bool	AddTabWidget (QWidget *, QString)

bool	AddViewerTab (QWidget *w, std::string title)

bool	AddViewerTabFromFile (std::string fileName, std::string title)

void	ClearMenu ()

void	DefaultIcons (bool aVal)

	G4UIQt (int, char **)

QPixmap *	getClearIcon ()

G4UIDockWidget *	GetCoutDockWidget ()

QWidget *	GetCoutWidget ()

QWidget *	GetHelpWidget ()

QWidget *	GetHistoryWidget ()

G4Interactor	GetInteractor (G4String)

G4int	GetLastReturnCode () const

QMainWindow *	GetMainWindow ()

QWidget *	GetPickInfosWidget ()

QWidget *	GetSceneTreeWidget ()

QPixmap *	getSearchIcon ()

QTabWidget *	GetUITabWidget ()

G4UIDockWidget *	GetUserInterfaceWidget ()

QWidget *	GetViewerPropertiesWidget ()

QTabWidget *	GetViewerTabWidget ()

bool	IsIconMoveSelected ()

bool	IsIconPickSelected ()

bool	IsIconRotateSelected ()

bool	IsIconZoomInSelected ()

bool	IsIconZoomOutSelected ()

bool	IsSplitterReleased ()

void	NativeMenu (bool aVal)

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

virtual void	PauseSessionStart (const G4String &)

void	Prompt (G4String)

virtual G4int	ReceiveG4cerr (const G4String &)

G4int	ReceiveG4cerr_ (const G4String &msg)

virtual G4int	ReceiveG4cout (const G4String &)

G4int	ReceiveG4cout_ (const G4String &msg)

virtual void	ResetTransformers ()

G4UIsession *	SessionStart ()

void	SessionTerminate ()

void	SetIconHLHSRSelected ()

void	SetIconHLRSelected ()

void	SetIconMoveSelected ()

void	SetIconOrthoSelected ()

void	SetIconPerspectiveSelected ()

void	SetIconPickSelected ()

void	SetIconRotateSelected ()

void	SetIconSolidSelected ()

void	SetIconWireframeSelected ()

void	SetIconZoomInSelected ()

void	SetIconZoomOutSelected ()

void	SetStartPage (const std::string &)

	~G4UIQt ()

Static Public Member Functions
static G4int	InSession ()

Protected Member Functions
void	ApplyShellCommand (const G4String &, G4bool &, G4bool &)

G4bool	ChangeDirectory (const char *newDir)

void	ChangeDirectoryCommand (const G4String &)

G4String	Complete (const G4String &)

virtual void	ExecuteCommand (const G4String &)

G4UIcommand *	FindCommand (const char *commandName) const

G4UIcommandTree *	FindDirectory (const char *dirName) const

G4String	FindMatchingPath (G4UIcommandTree *, const G4String &)

G4String	GetCurrentWorkingDirectory () const

void	ListDirectory (const G4String &) const

G4String	ModifyToFullPathCommand (const char *aCommandLine) const

void	ShowCurrent (const G4String &) const

void	TerminalHelp (const G4String &)

Protected Attributes
G4int	ifBatch = 0

G4int	lastRC = 0

std::vector< Transformer >	transformersCerr

std::vector< Transformer >	transformersCout

Static Protected Attributes
static G4ICOMS_DLL G4int	inSession = 0

static G4MTGLOB_DLL G4coutDestination *	masterG4coutDestination = nullptr

Private Types
typedef std::map< G4String, G4Interactor, std::less< G4String > >	G4interactor_map

Private Slots
void	ButtonCallback (const QString &)

void	ChangeColorCallback (QWidget *)

void	ChangeCursorAction (const QString &)

void	ChangePerspectiveOrtho (const QString &)

void	ChangeSurfaceStyle (const QString &)

void	ClearButtonCallback ()

void	CommandEditedCallback (const QString &text)

void	CommandEnteredCallback ()

void	CommandHistoryCallback ()

void	CoutFilterCallback (const QString &)

void	ExitSession ()

void	HelpTreeClicCallback ()

void	HelpTreeDoubleClicCallback ()

void	LookForHelpStringCallback ()

void	OpenIconCallback (const QString &)

void	ResizeTabWidget (QResizeEvent *)

void	SaveIconCallback (const QString &)

void	SaveOutputCallback ()

void	ShowHelpCallback ()

void	TabCloseCallback (int)

void	ThreadComboBoxCallback (int)

void	ToolBoxActivated (int)

void	UpdateTabWidget (int)

void	ViewerPropertiesIconCallback (int)

void	VisParameterCallback (QWidget *)

Private Member Functions
void	ActivateCommand (G4String)

bool	CheckG4EnvironmentVariable (char txt, char version)

bool	CreateCommandWidget (G4UIcommand command, QWidget parent, bool isDialog)

QStandardItemModel *	CreateCompleterModel (G4String aCmd)

G4UIDockWidget *	CreateCoutTBWidget ()

void	CreateEmptyPickInfosWidget ()

void	CreateEmptyViewerPropertiesWidget ()

QWidget *	CreateHelpTBWidget ()

void	CreateHelpTree (QTreeWidgetItem , G4UIcommandTree )

void	CreateHelpWidget ()

QWidget *	CreateHistoryTBWidget ()

void	CreateIcons ()

void	CreatePickInfosDialog ()

QWidget *	CreateSceneTreeWidget ()

G4UIDockWidget *	CreateUITabWidget ()

void	CreateViewerPropertiesDialog ()

void	CreateViewerWidget ()

bool	CreateVisCommandGroupAndToolBox (G4UIcommand , QWidget , int, bool isDialog)

QWidget *	CreateVisParametersTBWidget ()

bool	eventFilter (QObject , QEvent )

virtual void	ExitHelp () const

void	FillHelpTree ()

void	FilterAllOutputTextArea ()

QString	FilterOutput (const G4UIOutputString &, const QString &, const QString &)

QTreeWidgetItem *	FindTreeItem (QTreeWidgetItem *, const QString &)

QString	GetCommandList (const G4UIcommand *)

virtual G4bool	GetHelpChoice (G4int &)

QString	GetLongCommandPath (QTreeWidgetItem *)

QString	GetShortCommandPath (QString)

G4String	GetThreadPrefix ()

void	InitHelpTreeAndVisParametersWidget ()

G4bool	IsGUICommand (const G4UIcommand *)

QMap< int, QString >	LookForHelpStringInChildTree (G4UIcommandTree *, const QString &)

G4String	ModifyPath (const G4String &tempPath) const

void	OpenHelpTreeOnCommand (const QString &)

void	SecondaryLoop (G4String)

void	SetDefaultIconsToolbar ()

void	UpdateCommandCompleter ()

void	updateHelpArea (const G4UIcommand *)

Private Attributes
G4String	currentDirectory

QPixmap *	fClearIcon

QLineEdit *	fCommandArea

QPixmap *	fCommandIcon

QLabel *	fCommandLabel

QCompleter *	fCompleter

G4UIDockWidget *	fCoutDockWidget

QLineEdit *	fCoutFilter

QTextEdit *	fCoutTBTextArea

QString	fCoutText

bool	fDefaultIcons

std::string	fDefaultViewerFirstPageHTMLText

QPixmap *	fDirIcon

QPixmap *	fExitIcon

std::vector< G4UIOutputString >	fG4OutputString

QLineEdit *	fHelpLine

QWidget *	fHelpTBWidget

QTreeWidget *	fHelpTreeWidget

QSplitter *	fHelpVSplitter

QPixmap *	fHiddenLineAndSurfaceRemovalIcon

QPixmap *	fHiddenLineRemovalIcon

QListWidget *	fHistoryTBTableList

QWidget *	fHistoryTBWidget

QString	fLastCompleteCommand

G4String	fLastErrMessage

QString	fLastOpenPath

QMainWindow *	fMainWindow

QPixmap *	fMoveIcon

bool	fMoveSelected

QPixmap *	fOpenIcon

QPixmap *	fOrthoIcon

std::map< G4String, G4UIQtStyle >	fOutputStyles

QTextEdit *	fParameterHelpLabel

QTableWidget *	fParameterHelpTable

QPixmap *	fParamIcon

QPixmap *	fPerspectiveIcon

QPixmap *	fPickIcon

QDialog *	fPickInfosDialog

QWidget *	fPickInfosWidget

bool	fPickSelected

QPixmap *	fPickTargetIcon

QPixmap *	fRotateIcon

bool	fRotateSelected

QPixmap *	fRunIcon

QPixmap *	fSaveIcon

QWidget *	fSceneTreeWidget

QPixmap *	fSearchIcon

QPixmap *	fSolidIcon

QTextBrowser *	fStartPage

QString	fStringSeparator

QToolButton *	fSurfaceModePopupButton

QToolBar *	fToolbarApp

QToolBar *	fToolbarUser

G4UIDockWidget *	fUIDockWidget

QTabWidget *	fUITabWidget

QDialog *	fViewerPropertiesDialog

QWidget *	fViewerPropertiesWidget

G4QTabWidget *	fViewerTabWidget

QToolButton *	fViewModePopupButton

QPixmap *	fWireframeIcon

QPixmap *	fZoomInIcon

bool	fZoomInSelected

QPixmap *	fZoomOutIcon

bool	fZoomOutSelected

G4interactor_map	interactors

G4UImessenger *	messenger

Detailed Description

Definition at line 123 of file G4UIQt.hh.

Member Typedef Documentation

◆ G4interactor_map

typedef std::map<G4String,G4Interactor, std::less<G4String> > G4VInteractiveSession::G4interactor_map

privateinherited

Definition at line 63 of file G4VInteractiveSession.hh.

◆ Transformer

using G4coutDestination::Transformer = std::function<G4bool(G4String&)>

inherited

Definition at line 61 of file G4coutDestination.hh.

Constructor & Destructor Documentation

◆ G4UIQt()

G4UIQt::G4UIQt	(	int	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
  bool 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
}

References AddTabWidget(), CreateCoutTBWidget(), CreateIcons(), CreateUITabWidget(), CreateViewerWidget(), fCommandArea, fCoutDockWidget, G4UIQt::G4UIQtStyle::fixed, fMainWindow, fOutputStyles, fStartPage, fUIDockWidget, G4cout, G4endl, G4Qt::getInstance(), G4VInteractorManager::GetMainInteractor(), G4UImanager::GetUIpointer(), G4UImanager::GetVerboseLevel(), G4UIQt::G4UIQtStyle::highlight, G4coutDestination::masterG4coutDestination, G4UImanager::SetCoutDestination(), SetDefaultIconsToolbar(), G4UImanager::SetG4UIWindow(), and G4UImanager::SetSession().

◆ ~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
  }
}

References G4UImanager::GetUIpointer(), G4coutDestination::masterG4coutDestination, G4UImanager::SetCoutDestination(), G4UImanager::SetG4UIWindow(), and G4UImanager::SetSession().

Member Function Documentation

◆ ActivateCommand()

void G4UIQt::ActivateCommand ( G4String newCommand )

private

Definition at line 2700 of file G4UIQt.cc.

{
  if (!fHelpTreeWidget) {
    return;
  }
  // Look for the choosen command "newCommand"
  size_t i = newCommand.find(" ");
  G4String targetCom ="";
  if( i != std::string::npos )
    {
      G4String newValue = newCommand.substr(i+1,newCommand.length()-(i+1));
      G4StrUtil::strip(newValue);
      targetCom = ModifyToFullPathCommand( newValue );
    }
  if (targetCom != "") {
    OpenHelpTreeOnCommand(targetCom.data());
  }
 
  fUITabWidget->setCurrentWidget(fHelpTBWidget);
}

References fHelpTBWidget, fHelpTreeWidget, fUITabWidget, G4VBasicShell::ModifyToFullPathCommand(), OpenHelpTreeOnCommand(), and G4StrUtil::strip().

Referenced by CommandEnteredCallback().

◆ 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;
  G4int cmdEndPos = cmd.find_first_of(" \t");
  if(cmdEndPos!=G4int(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
}

References geant4_check_module_cycles::action, ButtonCallback(), g4zmq::connect(), G4UIcommandTree::FindPath(), G4cout, G4endl, G4VInteractiveSession::GetInteractor(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), G4UImanager::GetVerboseLevel(), and anonymous_namespace{G4QuasiElRatios.cc}::map.

◆ AddCerrTransformer() [1/2]

void G4coutDestination::AddCerrTransformer ( const Transformer & t )

inlineinherited

Definition at line 67 of file G4coutDestination.hh.

  {
    transformersCerr.push_back(t);
  }

References G4coutDestination::transformersCerr.

Referenced by G4MTcoutDestination::HandleFileCerr().

◆ AddCerrTransformer() [2/2]

void G4coutDestination::AddCerrTransformer ( Transformer && t )

inlineinherited

Definition at line 71 of file G4coutDestination.hh.

71{ transformersCerr.push_back(t); }

References G4coutDestination::transformersCerr.

◆ AddCoutTransformer() [1/2]

void G4coutDestination::AddCoutTransformer ( const Transformer & t )

inlineinherited

Definition at line 62 of file G4coutDestination.hh.

  {
    transformersCout.push_back(t);
  }

References G4coutDestination::transformersCout.

Referenced by G4MTcoutDestination::AddMasterOutput(), G4MTcoutDestination::HandleFileCout(), and G4MTcoutDestination::SetDefaultOutput().

◆ AddCoutTransformer() [2/2]

void G4coutDestination::AddCoutTransformer ( Transformer && t )

inlineinherited

Definition at line 66 of file G4coutDestination.hh.

66{ transformersCout.push_back(t); }

References G4coutDestination::transformersCout.

◆ 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;
  bool 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 (int 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
  }
}

References geant4_check_module_cycles::action, ButtonCallback(), ChangeCursorAction(), ChangePerspectiveOrtho(), ChangeSurfaceStyle(), g4zmq::connect(), fDefaultIcons, fExitIcon, fHiddenLineAndSurfaceRemovalIcon, fHiddenLineRemovalIcon, G4UImanager::FindMacroPath(), G4UIcommandTree::FindPath(), fMainWindow, fMoveIcon, fOpenIcon, fOrthoIcon, fPerspectiveIcon, fPickIcon, fRotateIcon, fRunIcon, fSaveIcon, fSolidIcon, fStringSeparator, fToolbarApp, fToolbarUser, fWireframeIcon, fZoomInIcon, fZoomOutIcon, G4cout, G4endl, G4UImanager::GetTree(), G4UImanager::GetUIpointer(), G4UImanager::GetVerboseLevel(), anonymous_namespace{G4QuasiElRatios.cc}::map, OpenIconCallback(), pos, SaveIconCallback(), SetIconHLHSRSelected(), SetIconHLRSelected(), SetIconMoveSelected(), SetIconOrthoSelected(), SetIconPerspectiveSelected(), SetIconPickSelected(), SetIconRotateSelected(), SetIconSolidSelected(), SetIconWireframeSelected(), SetIconZoomInSelected(), SetIconZoomOutSelected(), and TRUE.

Referenced by SetDefaultIconsToolbar().

◆ AddInteractor()

void G4VInteractiveSession::AddInteractor	(	G4String	a_name,
		G4Interactor	a_interactor
	)

inherited

Definition at line 80 of file G4VInteractiveSession.cc.

{
  interactors[a_name] = a_interactor;
}

References G4VInteractiveSession::interactors.

Referenced by AddMenu(), G4UIXm::AddMenu(), G4UIWin32::AddMenu(), and G4UIWin32::G4UIWin32().

◆ 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);
}

References G4VInteractiveSession::AddInteractor(), and fMainWindow.

◆ AddTabWidget()

bool 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;
}

References CreateViewerWidget(), FillHelpTree(), fMainWindow, fViewerTabWidget, G4InuclParticleNames::name(), and G4QTabWidget::setLastTabCreated().

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

◆ AddViewerTab()

bool 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;
}

References fViewerTabWidget.

◆ AddViewerTabFromFile()

bool 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;
}

References geant4_check_module_cycles::file, G4UImanager::FindMacroPath(), fViewerTabWidget, and G4UImanager::GetUIpointer().

◆ ApplyShellCommand()

void G4VBasicShell::ApplyShellCommand	(	const G4String &	a_string,
		G4bool &	exitSession,
		G4bool &	exitPause
	)

protectedinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Definition at line 232 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
 
  G4String command = G4StrUtil::lstrip_copy(a_string);
 
  if( command[0] == '#' ) {
 
    G4cout << command << G4endl;
 
  } else if( command == "ls" || command.substr(0,3) == "ls " ) {
 
    ListDirectory( command );
 
  } else if( command == "pwd" ) {
 
    G4cout << "Current Working Directory : "
       << GetCurrentWorkingDirectory() << G4endl;
 
  } else if( command == "cd" || command.substr(0,3) == "cd ") {
 
    ChangeDirectoryCommand ( command );
 
  } else if( command == "help" || command.substr(0,5) == "help ") {
 
    TerminalHelp( command );
 
  } else if( command[0] == '?' ) {
 
    ShowCurrent( command );
 
  } else if( command == "hist" || command == "history") {
 
    G4int nh = UI->GetNumberOfHistory();
    for(G4int i=0;i<nh;i++) {
      G4cout << i << ": " << UI->GetPreviousCommand(i) << G4endl;
    }
 
  } else if( command[0] == '!' ) {
 
    G4String ss = command.substr(1,command.length()-1);
    G4int vl;
    const char* tt = ss;
    std::istringstream is(tt);
    is >> vl;
    G4int nh = UI->GetNumberOfHistory();
    if(vl>=0 && vl<nh) {
      G4String prev = UI->GetPreviousCommand(vl);
      G4cout << prev << G4endl;
      ExecuteCommand (ModifyToFullPathCommand(prev));
    } else {
      G4cerr << "history " << vl << " is not found." << G4endl;
    }
 
  } else if( command == "exit" ) {
 
    if( exitPause == false) { //In a secondary loop.
      G4cout << "You are now processing RUN." << G4endl;
      G4cout << "Please abort it using \"/run/abort\" command first" << G4endl;
      G4cout << " and use \"continue\" command until the application" << G4endl;
      G4cout << " becomes to Idle." << G4endl;
    } else {
      exitSession = true;
    }
 
  } else if( command == "cont" || command == "continue"){
 
    exitPause = true;
 
  } else {
 
    ExecuteCommand(ModifyToFullPathCommand(a_string));
 
  }
}

References G4VBasicShell::ChangeDirectoryCommand(), G4VBasicShell::ExecuteCommand(), exitPause, exitSession, G4cerr, G4cout, G4endl, G4VBasicShell::GetCurrentWorkingDirectory(), G4UImanager::GetNumberOfHistory(), G4UImanager::GetPreviousCommand(), G4UImanager::GetUIpointer(), G4VBasicShell::ListDirectory(), G4StrUtil::lstrip_copy(), G4VBasicShell::ModifyToFullPathCommand(), G4VBasicShell::ShowCurrent(), and G4VBasicShell::TerminalHelp().

Referenced by ButtonCallback(), G4UIXm::ButtonCallback(), CommandEnteredCallback(), G4UIXm::CommandEnteredCallback(), G4UIWin32::DoOpenMacro(), G4UIWin32::DoSaveViewer(), G4UIWin32::ProcessDefaultCommands(), and G4UIWin32::ProcessEnterKey().

◆ ButtonCallback

void G4UIQt::ButtonCallback ( const QString & aCommand )

privateslot

Callback call when "enter" clicked on the command zone.
If command has no parameters :send the command to geant4 Else, open a dialog for parameters input

Parameters

aCommand

Definition at line 4046 of file G4UIQt.cc.

{
  G4String ss = G4StrUtil::lstrip_copy(G4String(aCommand.toStdString().c_str()));
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4UIcommandTree * treeTop = UI->GetTree();
 
  G4UIcommand* command = treeTop->FindPath(ss);
 
  if (command) {
    // if is GUI, then open a dialog
    if (IsGUICommand(command)) {
      QDialog* menuParameterDialog = new QDialog();
 
      if (CreateVisCommandGroupAndToolBox(command,menuParameterDialog,1,true)) {
        menuParameterDialog->setWindowTitle (aCommand);
        menuParameterDialog->setSizePolicy (QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum));
 
        // exec this dialog, apply the command automaticaly, and return
        menuParameterDialog->exec();
        return;
      }
      delete menuParameterDialog;
    }
  }
 
  ApplyShellCommand(ss,exitSession,exitPause);
 
  // Rebuild help tree
  FillHelpTree();
 
  if(exitSession==true)
    SessionTerminate();
}

References G4VBasicShell::ApplyShellCommand(), CreateVisCommandGroupAndToolBox(), exitPause, exitSession, FillHelpTree(), G4UIcommandTree::FindPath(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), IsGUICommand(), G4StrUtil::lstrip_copy(), and SessionTerminate().

Referenced by AddButton(), and AddIcon().

◆ ChangeColorCallback

void G4UIQt::ChangeColorCallback ( QWidget * widget )

privateslot

Definition at line 4525 of file G4UIQt.cc.

                                                {
  if (widget == NULL) {
    return;
  }
 
  QPushButton* button = dynamic_cast<QPushButton*>(widget);
  if (button == 0) {
    return;
  }
  QString value = button->accessibleName();
 
  QColor old;
  old.setRgbF(value.section(" ",0,1).toDouble(),
              value.section(" ",1,2).toDouble(),
              value.section(" ",2,3).toDouble());
#if QT_VERSION < 0x040500
  bool a;
  QColor color = QColor(QColorDialog::getRgba (old.rgba(),&a,fUITabWidget));
#else
  QColor color = QColorDialog::getColor(old,
                                        fUITabWidget,
                                        "Change color",
                    QColorDialog::ShowAlphaChannel);
#endif
 
 
  if (color.isValid()) {
    // rebuild the widget icon
    QPixmap pixmap = QPixmap(QSize(16, 16));
    pixmap.fill (color);
    QPainter painter(&pixmap);
    painter.setPen(Qt::black);
    painter.drawRect(0,0,15,15); // Draw contour
 
    button->setAccessibleName(QString::number(color.redF())+" "+
                              QString::number(color.greenF())+" "+
                              QString::number(color.blueF())+" "
                              );
    button->setIcon(pixmap);
 
 
  }
}

References fUITabWidget.

Referenced by CreateCommandWidget().

◆ ChangeCursorAction

void G4UIQt::ChangeCursorAction ( const QString & action )

privateslot

Definition at line 4570 of file G4UIQt.cc.

                                                     {
 
  // Theses actions should be in the app toolbar
 
  fMoveSelected = true;
  fPickSelected = true;
  fRotateSelected = true;
  fZoomInSelected = true;
  fZoomOutSelected = true;
 
  if (fToolbarApp == NULL) return;
  QList<QAction *> list = fToolbarApp->actions ();
  for (int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == action) {
      list.at(i)->setChecked(TRUE);
      if (list.at(i)->data().toString () == "pick") {
        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/picking true");
        CreatePickInfosDialog();
 
        fPickInfosDialog->show();
        fPickInfosDialog->raise();
        fPickInfosDialog->activateWindow();
      }
    } else if (list.at(i)->data().toString () == "move") {
      fMoveSelected = false;
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "pick") {
      fPickSelected = false;
      list.at(i)->setChecked(FALSE);
      G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/picking false");
      if (fPickInfosDialog) {
        fPickInfosDialog->hide();
      }
    } else if (list.at(i)->data().toString () == "rotate") {
      fRotateSelected = false;
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "zoom_in") {
      fZoomInSelected = false;
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "zoom_out") {
      fZoomOutSelected = false;
      list.at(i)->setChecked(FALSE);
    }
  }
  // FIXME : Should connect this to Vis
}

References geant4_check_module_cycles::action, G4UImanager::ApplyCommand(), CreatePickInfosDialog(), FALSE, fMoveSelected, fPickInfosDialog, fPickSelected, fRotateSelected, fToolbarApp, fZoomInSelected, fZoomOutSelected, G4UImanager::GetUIpointer(), and TRUE.

Referenced by AddIcon().

◆ ChangeDirectory()

G4bool G4VBasicShell::ChangeDirectory ( const char * newDir )

protectedinherited

Definition at line 74 of file G4VBasicShell.cc.

{
  G4String newPrefix = G4StrUtil::strip_copy(newDir);
 
  G4String newDirectory = ModifyPath( newPrefix );
  if( newDirectory.back() != '/' )
  { newDirectory += "/"; }
  if( FindDirectory( newDirectory.c_str() ) == NULL )
  { return false; }
  currentDirectory = newDirectory;
  return true;
}

References G4VBasicShell::currentDirectory, G4VBasicShell::FindDirectory(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ChangeDirectoryCommand().

◆ ChangeDirectoryCommand()

void G4VBasicShell::ChangeDirectoryCommand ( const G4String & newCommand )

protectedinherited

Definition at line 325 of file G4VBasicShell.cc.

{
  G4String prefix;
  if( newCommand.length() <= 3 ) {
    prefix = "/";
  } else {
    G4String aNewPrefix = newCommand.substr(3, newCommand.length()-3);
    prefix = G4StrUtil::strip_copy(aNewPrefix);
  }
  if(!ChangeDirectory(prefix)) {
    G4cout << "directory <" << prefix << "> not found." << G4endl;
  }
}

References G4VBasicShell::ChangeDirectory(), G4cout, G4endl, and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ApplyShellCommand(), G4UIterminal::GetCommand(), and G4ZMQServer::GetCommand().

◆ ChangePerspectiveOrtho

void G4UIQt::ChangePerspectiveOrtho ( const QString & action )

privateslot

Definition at line 4789 of file G4UIQt.cc.

                                                         {
 
  // Theses actions should be in the app toolbar
 
  if (fToolbarApp == NULL) return;
  QList<QAction *> list = fToolbarApp->actions ();
  QString checked = "";
  for (int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == action) {
      list.at(i)->setChecked(TRUE);
      checked = list.at(i)->data().toString ();
    } else if (list.at(i)->data().toString () == "perspective") {
      list.at(i)->setChecked(FALSE);
    } else if (list.at(i)->data().toString () == "ortho") {
      list.at(i)->setChecked(FALSE);
    }
  }
 
  if ((action == "ortho") && (checked == "ortho")) {
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/projection o");
  } else if ((action == "perspective") && (checked == "perspective")) {
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/projection p");
  }
}

References geant4_check_module_cycles::action, G4UImanager::ApplyCommand(), FALSE, fToolbarApp, G4UImanager::GetUIpointer(), and TRUE.

Referenced by AddIcon().

◆ ChangeSurfaceStyle

void G4UIQt::ChangeSurfaceStyle ( const QString & action )

privateslot

Definition at line 4624 of file G4UIQt.cc.

                                                     {
 
  // Theses actions should be in the app toolbar
 
  if (fToolbarApp == NULL) return;
  QList<QAction *> list = fToolbarApp->actions ();
  for (int i = 0; i < list.size(); ++i) {
    if (list.at(i)->data().toString () == action) {
      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);
    } else if (list.at(i)->data().toString () == "wireframe") {
      list.at(i)->setChecked(FALSE);
    }
  }
  // FIXME : Should connect this to Vis
 
  if (action == "hidden_line_removal") {
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/style w");
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/hiddenEdge 1");
 
  } else if (action == "hidden_line_and_surface_removal") {
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/style s");
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/hiddenEdge 1");
 
  } else if (action == "solid") {
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/style s");
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/hiddenEdge 0");
 
  } else if (action == "wireframe") {
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/style w");
    G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/set/hiddenEdge 0");
  }
}

References geant4_check_module_cycles::action, G4UImanager::ApplyCommand(), FALSE, fToolbarApp, G4UImanager::GetUIpointer(), and TRUE.

Referenced by AddIcon().

◆ CheckG4EnvironmentVariable()

bool G4UIQt::CheckG4EnvironmentVariable	(	char *	txt,
		char *	version
	)

private

◆ ClearButtonCallback

void G4UIQt::ClearButtonCallback ( )

privateslot

Called when user click on clear button. Clear the text Output area

Definition at line 3877 of file G4UIQt.cc.

{
  fCoutTBTextArea->clear();
  fG4OutputString.clear();
}

References fCoutTBTextArea, and fG4OutputString.

Referenced by CreateCoutTBWidget().

◆ ClearMenu()

void G4UIQt::ClearMenu ( )

virtual

Reimplemented from G4VInteractiveSession.

Definition at line 2695 of file G4UIQt.cc.

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

References fMainWindow.

◆ CommandEditedCallback

void G4UIQt::CommandEditedCallback ( const QString & text )

privateslot

Callback when the text in the line edit is changed. When a newline is inserted, trigger the Activate Command on this text end set unchanged the end of the line after the newline.

Definition at line 3952 of file G4UIQt.cc.

{
#if QT_VERSION < 0x050F00
  // Before Qt5.15
  QStringList list = fCommandArea->text().split(QRegExp("[\r\n]"),QString::SkipEmptyParts);
#else
  // Qt5.15 and beyond
  QStringList list = fCommandArea->text().split(QRegExp("[\r\n]"),Qt::SkipEmptyParts);
#endif
 
  if (list.size() > 1) { // trigger ActivateCommand
    for (int a=0; a<list.size()-1; a++) {
      // set only the first part
      fCommandArea->setText(list[a]);
      // trigger callback
      CommandEnteredCallback();
    }
    // reset unfinished command
    fCommandArea->setText(list[list.size()-1]);
  }
}

References CommandEnteredCallback(), and fCommandArea.

Referenced by CreateCoutTBWidget().

◆ CommandEnteredCallback

void G4UIQt::CommandEnteredCallback ( )

privateslot

Callback call when "click on a menu entry.
Send the associated command to geant4

Definition at line 3900 of file G4UIQt.cc.

{
  // split by any new line character
  fCommandArea->setText(fCommandArea->text().trimmed());
#if QT_VERSION < 0x050F00
  // Before Qt5.15
  QStringList list = fCommandArea->text().split(QRegExp("[\r\n]"),QString::SkipEmptyParts);
#else
  // Qt5.15 and beyond
  QStringList list = fCommandArea->text().split(QRegExp("[\r\n]"),Qt::SkipEmptyParts);
#endif
 
  // Apply for all commands
  for (int a=0; a< list.size(); a++) {
    QString txt (list[a].trimmed());
    if (txt != "") {
      fHistoryTBTableList->addItem(txt);
      fHistoryTBTableList->clearSelection();
      fHistoryTBTableList->setCurrentItem(NULL);
      fCommandArea->setText("");
      G4Qt* interactorManager = G4Qt::getInstance ();
      if (interactorManager) {
        interactorManager->FlushAndWaitExecution();
      }
 
      G4String command = txt.toStdString().c_str();
      if (command.substr(0,4) != "help") {
        ApplyShellCommand (command,exitSession,exitPause);
      } else {
        ActivateCommand(command);
      }
    }
  }
  // set the focus to the command line
  fCommandArea->setFocus();
 
  // Rebuild help tree
  FillHelpTree();
 
  // Rebuild command completion
  UpdateCommandCompleter();
 
  if(exitSession==true)
    SessionTerminate();
}

References ActivateCommand(), G4VBasicShell::ApplyShellCommand(), exitPause, exitSession, fCommandArea, fHistoryTBTableList, FillHelpTree(), G4Qt::FlushAndWaitExecution(), G4Qt::getInstance(), SessionTerminate(), and UpdateCommandCompleter().

Referenced by CommandEditedCallback(), and CreateCoutTBWidget().

◆ CommandHistoryCallback

void G4UIQt::CommandHistoryCallback ( )

privateslot

Callback called when user select an old command in the command history
Give it to the command area.

Definition at line 4154 of file G4UIQt.cc.

{
  QListWidgetItem* item =  NULL;
  if (!fHistoryTBTableList)
    return ;
 
 
  QList<QListWidgetItem *> list =fHistoryTBTableList->selectedItems();
  if (list.isEmpty())
    return;
  item = list.first();
  if (!item)
    return;
  fCommandArea->setText(item->text());
}

References fCommandArea, and fHistoryTBTableList.

Referenced by CreateHistoryTBWidget().

◆ Complete()

G4String G4VBasicShell::Complete ( const G4String & commandName )

protectedinherited

Definition at line 180 of file G4VBasicShell.cc.

{
  G4String rawCommandLine = commandName;
  G4String commandLine = G4StrUtil::strip_copy(rawCommandLine);
  
  size_t i = commandLine.find(" ");
  if( i != std::string::npos ) return rawCommandLine; // Already entering parameters,
                                            // assume command path is correct.
  G4String commandString = commandLine;
  G4String targetCom = ModifyPath(commandString);
  G4UIcommandTree* tree = G4UImanager::GetUIpointer()->GetTree();
  G4String value = FindMatchingPath(tree,targetCom);
  if(value=="") return rawCommandLine;
  return value;
}

References G4VBasicShell::FindMatchingPath(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by eventFilter(), G4UIXm::keyHandler(), and G4UIWin32::ProcessTabKey().

◆ CoutFilterCallback

void G4UIQt::CoutFilterCallback ( const QString & )

privateslot

Definition at line 4177 of file G4UIQt.cc.

                 {
 
  FilterAllOutputTextArea();
 
  fCoutTBTextArea->repaint();
  fCoutTBTextArea->verticalScrollBar()->setSliderPosition(fCoutTBTextArea->verticalScrollBar()->maximum());
 
 }

References fCoutTBTextArea, and FilterAllOutputTextArea().

Referenced by CreateCoutTBWidget(), and ThreadComboBoxCallback().

◆ CreateCommandWidget()

bool G4UIQt::CreateCommandWidget	(	G4UIcommand *	aCommand,
		QWidget *	aParent,
		bool	isDialog
	)

private

Create a widget with the command parameters inside

Parameters

command command line @parent : parent widget @isDialog : true if we want apply/cancel button and close at end, false if we want only apply

Definition at line 3005 of file G4UIQt.cc.

                                                                                       {
 
  if (aCommand == NULL) {
    return false;
  }
 
 
  // parameters
  G4int n_parameterEntry = aCommand->GetParameterEntries();
  if( n_parameterEntry > 0 ) {
    G4UIparameter *param;
 
    // Re-implementation of G4UIparameter.cc
    QWidget* paramWidget = new QWidget();
    QGridLayout* gridLayout = new QGridLayout();
    paramWidget->setLayout(gridLayout);
 
    // Special case for colour, try to display a color chooser if we found red/green/blue parameter
    unsigned int nbColorParameter = 0;
    bool isStillColorParameter = false;
    bool isColorDialogAdded = false;
    QLabel* redLabel = NULL;
    QLabel* greenLabel = NULL;
    QString redDefaultStr = "";
    QString greenDefaultStr = "";
    QString blueDefaultStr = "";
    QWidget* redInput = NULL;
    QWidget* greenInput = NULL;
 
    for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ ) {
      QString txt;
      param = aCommand->GetParameter(i_thParameter);
      QLabel* label = new QLabel(QString((char*)(param->GetParameterName()).data()));
 
      if ((label->text() == "red") || (label->text() == "red_or_string")){
        nbColorParameter ++;
        isStillColorParameter = true;
      } else if ((label->text() == "green") && isStillColorParameter) {
        nbColorParameter ++;
      } else if ((label->text() == "blue") && isStillColorParameter) {
        nbColorParameter ++;
      } else if (!isColorDialogAdded) {
 
        // not following red/green/blue parameters ?
        if (nbColorParameter == 1) {
          gridLayout->addWidget(redLabel,i_thParameter-1,0);
          gridLayout->addWidget(redInput,i_thParameter-1,1);
        } else if (nbColorParameter == 2) {
          gridLayout->addWidget(redLabel,i_thParameter-2,0);
          gridLayout->addWidget(redInput,i_thParameter-2,1);
          gridLayout->addWidget(greenLabel,i_thParameter-1,0);
          gridLayout->addWidget(greenInput,i_thParameter-1,1);
        }
        nbColorParameter = 0;
      }
      // Check parameter type, could be NULL if not found
      QWidget* input = NULL;
      if ((QString(QChar(param->GetParameterType())) == "d") || (QString(QChar(param->GetParameterType())) == "i")) {
        input = new QLineEdit();
        // set default value
        dynamic_cast<QLineEdit*>(input)->setText(QString((char*)(param->GetDefaultValue()).data()));
 
        if (((label->text() == "red") || (label->text() == "red_or_string")) && isStillColorParameter) {
          redDefaultStr = QString((char*)(param->GetDefaultValue()).data());
        } else if ((label->text() == "green") && isStillColorParameter) {
          greenDefaultStr = QString((char*)(param->GetDefaultValue()).data());
        } else if ((label->text() == "green") && isStillColorParameter) {
          blueDefaultStr = QString((char*)(param->GetDefaultValue()).data());
        }
 
      } else if (QString(QChar(param->GetParameterType())) == "b") {
        input = new QWidget();
        QHBoxLayout* layout = new QHBoxLayout();
        input->setLayout(layout);
 
        QButtonGroup* buttons = new QButtonGroup();
        QRadioButton* radioOff = new QRadioButton("0");
        QRadioButton* radioOn = new QRadioButton("1");
        buttons->addButton(radioOn);
        buttons->addButton(radioOff);
        layout->addWidget(radioOn);
        layout->addWidget(radioOff);
 
        // set default value
        QString defaultValue = QString((char*)(param->GetDefaultValue()).data());
        if (defaultValue == "0") {
          radioOff->setChecked(true);
        } else if (defaultValue == "1") {
          radioOn->setChecked(true);
        }
      } else if ((QString(QChar(param->GetParameterType())) == "s") && (!param->GetParameterCandidates().empty())) {
        input = new QComboBox();
        QString candidates = QString((char*)(param->GetParameterCandidates()).data());
        QStringList list = candidates.split (" ");
 
        // add all candidates to widget
        QString defaultValue = QString((char*)(param->GetDefaultValue()).data());
        for (int a=0; a<list.size(); a++) {
          dynamic_cast<QComboBox*>(input)->addItem(list.at(a));
          if (list.at(a) == defaultValue) {
            dynamic_cast<QComboBox*>(input)->setCurrentIndex(a);
          }
        }
 
      } else if ((QString(QChar(param->GetParameterType())) == "s")) {  // string
        input = new QLineEdit();
        // set default value
        dynamic_cast<QLineEdit*>(input)->setText(QString((char*)(param->GetDefaultValue()).data()));
 
      } else if ((QString(QChar(param->GetParameterType())) == "c")) {  // on/off
        input = new QWidget();
        QHBoxLayout* layout = new QHBoxLayout();
        input->setLayout(layout);
 
        QButtonGroup* buttons = new QButtonGroup();
        QRadioButton* radioOff = new QRadioButton("off");
        QRadioButton* radioOn = new QRadioButton("on");
        buttons->addButton(radioOn);
        buttons->addButton(radioOff);
        layout->addWidget(radioOn);
        layout->addWidget(radioOff);
 
        // set default value
        QString defaultValue = QString((char*)(param->GetDefaultValue()).data());
        if (defaultValue == "off") {
          radioOff->setChecked(true);
        } else if (defaultValue == "on") {
          radioOn->setChecked(true);
        }
 
      } else {
        input = new QLineEdit();
        dynamic_cast<QLineEdit*>(input)->setText(QString((char*)(param->GetDefaultValue()).data()));
      }
 
      txt += "\nParameter : " + QString((char*)(param->GetParameterName()).data()) + "\n";
      if( ! param->GetParameterGuidance().empty() )
        txt += QString((char*)(param->GetParameterGuidance()).data())+ "\n" ;
 
      txt += " Parameter type  : " + QString(QChar(param->GetParameterType())) + "\n";
      if(param->IsOmittable()){
        txt += " Omittable       : True\n";
      } else {
        txt += " Omittable       : False\n";
      }
      if( param->GetCurrentAsDefault() ) {
        txt += " Default value   : taken from the current value\n";
      } else if( ! param->GetDefaultValue().empty() ) {
        txt += " Default value   : " + QString((char*)(param->GetDefaultValue()).data())+ "\n";
      }
      if( ! param->GetParameterRange().empty() ) {
        txt += " Parameter range : " + QString((char*)(param->GetParameterRange()).data())+ "\n";
      }
      if( ! param->GetParameterCandidates().empty() ) {
        txt += " Candidates      : " + QString((char*)(param->GetParameterCandidates()).data())+ "\n";
      }
 
      if (isStillColorParameter && (nbColorParameter != 0)) {
        if ((label->text() == "red") || (label->text() == "red_or_string")) {
          redLabel = label;
          redInput = input;
        } else if (label->text() == "green") {
          greenLabel = label;
          greenInput = input;
        } else if (label->text() == "blue") {
 
          // we have all, then add a color chooser
 
          // Create a pixmap with the default color
          QColor qc;
          if ((redDefaultStr != "") && (redDefaultStr != "") && (redDefaultStr != "")) {
            qc.setRgbF(redDefaultStr.toDouble(),
                       greenDefaultStr.toDouble(),
                       blueDefaultStr.toDouble());
          }
          QPixmap pixmap = QPixmap(QSize(16, 16));
          pixmap.fill (qc);
          QPainter painter(&pixmap);
          painter.setPen(Qt::black);
          painter.drawRect(0,0,15,15); // Draw contour
 
          input = new QPushButton("Change color");
          dynamic_cast<QPushButton*>(input)->setIcon(pixmap);
          dynamic_cast<QPushButton*>(input)->setAccessibleName(redDefaultStr+" "+greenDefaultStr+" "+blueDefaultStr);
          label = new QLabel("Choose color");
 
          // less 1 because we have to add one to the row number
          nbColorParameter--;
          gridLayout->addWidget(label,i_thParameter-nbColorParameter,0);
          input->setToolTip("Select the current color");
          gridLayout->addWidget(input,i_thParameter-nbColorParameter,1);
 
          // Connect pushButton to ColorDialog in callback
#if QT_VERSION < 0x050600
          QSignalMapper* signalMapper = new QSignalMapper(this);
          signalMapper->setMapping(input,input);
          connect(input, SIGNAL(clicked()), signalMapper, SLOT(map()));
          connect(signalMapper, SIGNAL(mapped(QWidget*)),this, SLOT(ChangeColorCallback(QWidget*)));
#else
          connect(dynamic_cast<QPushButton*>(input), &QPushButton::clicked , [this, input](){ this->ChangeColorCallback(input);});
#endif
          isColorDialogAdded = true;
          isStillColorParameter = false;
        }
      } else {
        gridLayout->addWidget(label,i_thParameter-nbColorParameter,0);
        input->setToolTip(txt);
        gridLayout->addWidget(input,i_thParameter-nbColorParameter,1);
      }
    }
    // add command name in hidden value at last line position 0
    QLabel* name = new QLabel(QString((char*)(aCommand->GetCommandPath().data())));
    name->hide();
    gridLayout->addWidget(name,n_parameterEntry-nbColorParameter,0);
 
    QPushButton* applyButton = new QPushButton("Apply");
    if (!isDialog) {
 
      gridLayout->addWidget(applyButton,n_parameterEntry-nbColorParameter,1);
 
#if QT_VERSION < 0x050600
      QSignalMapper* signalMapper = new QSignalMapper(this);
      signalMapper->setMapping(applyButton, paramWidget);
      connect(applyButton, SIGNAL(clicked()), signalMapper, SLOT(map()));
      connect(signalMapper, SIGNAL(mapped(QWidget*)),this, SLOT(VisParameterCallback(QWidget*)));
#else
      connect(applyButton, &QPushButton::clicked , [this, paramWidget](){ this->VisParameterCallback(paramWidget);});
#endif
    } else {
      // Apply/Cancel buttons
 
      applyButton->setAutoDefault( TRUE );
      applyButton->setDefault( TRUE );
 
      QPushButton* cancelButton = new QPushButton( tr( "&Cancel" ));
      cancelButton->setAutoDefault( TRUE );
      gridLayout->addWidget(cancelButton,n_parameterEntry-nbColorParameter,1);
      gridLayout->addWidget(applyButton,n_parameterEntry-nbColorParameter,0);
 
#if QT_VERSION < 0x050600
      QSignalMapper* signalMapper = new QSignalMapper(this);
      signalMapper->setMapping(applyButton, paramWidget);
      connect(applyButton, SIGNAL(clicked()), signalMapper, SLOT(map()));
      connect(signalMapper, SIGNAL(mapped(QWidget*)),this, SLOT(VisParameterCallback(QWidget*)));
#else
      connect(applyButton, &QPushButton::clicked , [this, paramWidget](){ this->VisParameterCallback(paramWidget);});
#endif
 
      QWidget * parentCheck = aParent;
      QDialog* parentDialog = NULL;
      bool found = false;
      while ((parentCheck->parentWidget()) != NULL) {
        parentCheck = parentCheck->parentWidget();
        parentDialog = dynamic_cast<QDialog*>(parentCheck);
        if (parentDialog) {
          connect( applyButton, SIGNAL( clicked() ), parentDialog, SLOT( accept() ) );
          connect( cancelButton, SIGNAL( clicked() ), parentDialog, SLOT( reject() ) );
          found = true;
        }
      }
      if (!found) {
        return false;
      }
    }
 
    if (!aParent->layout()) {
      aParent->setLayout(new QVBoxLayout());
    }
    aParent->layout()->addWidget(paramWidget);
  }
 
  return true;
}

References ChangeColorCallback(), g4zmq::connect(), G4UIcommand::GetCommandPath(), G4UIparameter::GetCurrentAsDefault(), G4UIparameter::GetDefaultValue(), G4UIcommand::GetParameter(), G4UIparameter::GetParameterCandidates(), G4UIcommand::GetParameterEntries(), G4UIparameter::GetParameterGuidance(), G4UIparameter::GetParameterName(), G4UIparameter::GetParameterRange(), G4UIparameter::GetParameterType(), G4UIparameter::IsOmittable(), anonymous_namespace{G4QuasiElRatios.cc}::map, G4InuclParticleNames::name(), TRUE, and VisParameterCallback().

Referenced by CreateVisCommandGroupAndToolBox().

◆ CreateCompleterModel()

QStandardItemModel * G4UIQt::CreateCompleterModel ( G4String aCmd )

private

Definition at line 3712 of file G4UIQt.cc.

                                                              {
 
  QList< QStandardItem*> dirModelList;
  QList< QStandardItem*> commandModelList;
  QList< QStandardItem*> subDirModelList;
  QList< QStandardItem*> subCommandModelList;
 
  G4String strtmp;
  G4int nMatch= 0;
 
  G4String pName = aCmd;
  G4String remainingPath = aCmd;
  G4String empty = "";
  G4String matchingPath = empty;
 
  // find the tree
  auto jpre= pName.rfind('/');
  if(jpre != G4String::npos) pName.erase(jpre+1);
  G4UImanager* UI = G4UImanager::GetUIpointer();
  G4UIcommandTree * commandTreeTop = UI->GetTree();
  G4UIcommandTree* aTree = commandTreeTop->FindCommandTree(pName);
  if (aTree) {
    int Ndir= aTree-> GetTreeEntry();
    int Ncmd= aTree-> GetCommandEntry();
 
    // directory ...
    for(G4int idir=1; idir<=Ndir; idir++) {
      G4String fpdir= aTree-> GetTree(idir)-> GetPathName();
      // matching test
      if( fpdir.find(remainingPath, 0) == 0) {
        if(nMatch==0) {
          matchingPath = fpdir;
        } else {
          matchingPath = aTree->GetFirstMatchedString(fpdir,matchingPath);
        }
        nMatch++;
 
        // append to dir model list
        QStandardItem* item1 = new QStandardItem(fpdir.data());
        QIcon i = QIcon(*fDirIcon);
        item1->setData(1); // dir
        item1->setIcon(QIcon(*fDirIcon));
        dirModelList.append(item1);
 
        // Go recursively
        QStandardItemModel* subModel = CreateCompleterModel(fpdir.data());
        for (int a=0; a< subModel->rowCount(); a++) {
 
          // copy item (an item could only be part of one model
          QStandardItem* tempItem = new QStandardItem(subModel->item(a)->text());
          tempItem->setIcon(subModel->item(a)->icon());
          tempItem->setToolTip(subModel->item(a)->toolTip());
          tempItem->setData(subModel->item(a)->data());
 
          // dir
          if (tempItem->data() == 1) {
            subModel->item(a);
            subDirModelList.append(tempItem);
          }
          // command
          else if (tempItem->data() == 0) {
            subCommandModelList.append(tempItem);
          }
        }
      }
    }
 
    // command ...
    G4int n_parameterEntry;
    G4String rangeString;
    G4int n_guidanceEntry;
    G4UIcommand * command;
    G4UIparameter *param;
    std::string tooltip;
    G4String params;
 
    for(G4int icmd=1; icmd<=Ncmd; icmd++){
      tooltip = "";
      params = " ";
      command = aTree-> GetCommand(icmd);
      G4String longCommandName= aTree-> GetPathName() +
      command -> GetCommandName();
      rangeString = command->GetRange();
      n_guidanceEntry = command->GetGuidanceEntries();
      n_parameterEntry = command->GetParameterEntries();
 
 
      // matching test
      if( longCommandName.find(remainingPath, 0) ==0) {
        if(nMatch==0) {
          matchingPath= longCommandName + " ";
        } else {
          strtmp= longCommandName + " ";
          matchingPath= aTree->GetFirstMatchedString(matchingPath, strtmp);
        }
 
        // guidance
        for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
          tooltip += std::string((command->GetGuidanceLine(i_thGuidance)).data());
          if (i_thGuidance < n_guidanceEntry-1 ) {
           tooltip += "\n";
          }
        }
 
        // parameters
        for( G4int a=0; a<n_parameterEntry; a++ ) {
          param = command->GetParameter(a);
            if (param->IsOmittable()) {
                params += "[<" + param->GetParameterName()+">] ";
            } else {
                params += "<" + param->GetParameterName()+"> ";
            }
        }
        nMatch++;
 
        // Append to command model list
        QStandardItem* item = new QStandardItem(G4String(longCommandName + params).data());
        item->setData(0); // command
        item->setIcon(QIcon(*fCommandIcon));
        item->setToolTip(tooltip.c_str());
 
        commandModelList.append(item);
      }
    }
  }
 
  QStandardItemModel* model = new QStandardItemModel();
  // initialize the model
  model->setColumnCount(1);
 
  // concat models
  for (int a= 0; a< dirModelList.size(); a++) {
    model->appendRow(dirModelList.at(a));
  }
  for (int a= 0; a< subDirModelList.size(); a++) {
    model->appendRow(subDirModelList.at(a));
  }
  for (int a= 0; a< commandModelList.size(); a++) {
    model->appendRow(commandModelList.at(a));
  }
  for (int a= 0; a< subCommandModelList.size(); a++) {
    model->appendRow(subCommandModelList.at(a));
  }
 
  return model;
}

References CreateCompleterModel(), anonymous_namespace{G4MTcoutDestination.cc}::empty, fCommandIcon, fDirIcon, G4UIcommandTree::FindCommandTree(), G4UIcommandTree::GetFirstMatchedString(), G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), G4UIcommand::GetParameter(), G4UIcommand::GetParameterEntries(), G4UIparameter::GetParameterName(), G4UIcommand::GetRange(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), and G4UIparameter::IsOmittable().

Referenced by CreateCompleterModel(), and UpdateCommandCompleter().

◆ CreateCoutTBWidget()

G4UIDockWidget * G4UIQt::CreateCoutTBWidget ( )

private

Create the Cout ToolBox Widget

Definition at line 1557 of file G4UIQt.cc.

{
  QWidget* coutTBWidget = new QWidget();
 
  QVBoxLayout *layoutCoutTB = new QVBoxLayout();
 
  fCoutTBTextArea = new QTextEdit();
 
  fCoutFilter = new QLineEdit();
  fCoutFilter->setToolTip("Filter output by...");
 
#if QT_VERSION > 0x050100
  fCoutFilter->addAction(*fSearchIcon,QLineEdit::TrailingPosition);
  fCoutFilter->setStyleSheet ("border-radius:7px;");
#else
  QPushButton *coutTBFilterButton = new QPushButton();
  coutTBFilterButton->setIcon(QIcon(*fSearchIcon));
  coutTBFilterButton->setStyleSheet ("padding-left: 0px; border:0px;");
  fCoutFilter->setStyleSheet ("padding-right: 0px;");
#endif
 
  QPushButton *coutTBClearButton = new QPushButton();
  coutTBClearButton->setIcon(*fClearIcon);
  coutTBClearButton->setToolTip("Clear console output");
  coutTBClearButton->setStyleSheet ("border-radius:7px;");
  connect(coutTBClearButton, SIGNAL(clicked()), SLOT(ClearButtonCallback()));
  connect(fCoutFilter, SIGNAL(textEdited ( const QString &)), SLOT(CoutFilterCallback( const QString &)));
 
  QPushButton *coutTBSaveOutputButton = new QPushButton();
  coutTBSaveOutputButton->setIcon(*fSaveIcon);
  coutTBSaveOutputButton->setToolTip("Save console output");
  coutTBSaveOutputButton->setStyleSheet ("border-radius:7px;");
  connect(coutTBSaveOutputButton, SIGNAL(clicked()), SLOT(SaveOutputCallback()));
 
  fCoutTBTextArea->setReadOnly(true);
 
  QWidget* coutButtonWidget = new QWidget();
  QHBoxLayout* layoutCoutTBButtons = new QHBoxLayout();
 
#ifdef G4MULTITHREADED
  // add all candidates to widget
  fThreadsFilterComboBox = new QComboBox();
  fThreadsFilterComboBox->setInsertPolicy(QComboBox::InsertAlphabetically);
  connect(fThreadsFilterComboBox, SIGNAL(activated(int)), this, SLOT(ThreadComboBoxCallback(int)));
 
  UpdateCoutThreadFilter();
 
  fThreadsFilterComboBox->setToolTip("Thread selection in output");
  layoutCoutTBButtons->addWidget(new QLabel(" Threads:"));
  layoutCoutTBButtons->addWidget(fThreadsFilterComboBox);
#endif
 
  layoutCoutTBButtons->addWidget(fCoutFilter);
#if QT_VERSION <= 0x050100
  layoutCoutTBButtons->addWidget(coutTBFilterButton);
#endif
  layoutCoutTBButtons->addWidget(coutTBClearButton);
  layoutCoutTBButtons->addWidget(coutTBSaveOutputButton);
  coutButtonWidget->setLayout(layoutCoutTBButtons);
 
  // reduce margins
  layoutCoutTBButtons->setContentsMargins(3,3,3,0);
 
  layoutCoutTB->addWidget(coutButtonWidget);
  layoutCoutTB->addWidget(fCoutTBTextArea);
 
  coutTBWidget->setLayout(layoutCoutTB);
 
  fCoutTBTextArea->setMinimumSize(100,100);
 
  // Command line :
  QWidget* commandLineWidget = new QWidget();
  QHBoxLayout *layoutCommandLine = new QHBoxLayout();
 
  // fill them
 
  fCommandLabel = new QLabel("");
  fCommandArea = new QLineEdit();
 
  // The QCompleter will be append at SessionStart()
 
  fCommandArea->activateWindow();
 
  fCommandArea->setFocusPolicy ( Qt::StrongFocus );
  fCommandArea->setFocus(Qt::TabFocusReason);
  fCommandArea->setToolTip("Apply command");
 
 
  layoutCommandLine->addWidget(fCommandLabel);
  layoutCommandLine->addWidget(fCommandArea);
 
  // Connect signal
  connect(fCommandArea, SIGNAL(returnPressed()), SLOT(CommandEnteredCallback()));
  connect(fCommandArea, SIGNAL(textEdited(const QString &)), SLOT(CommandEditedCallback(const QString &)));
 
 
  commandLineWidget->setLayout(layoutCommandLine);
  commandLineWidget->setMinimumSize(50,50);
 
  layoutCoutTB->addWidget(commandLineWidget);
 
  fCoutDockWidget = new G4UIDockWidget ("Output");
  fCoutDockWidget->setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea);
 
  fCoutDockWidget->setWidget(coutTBWidget);
  return fCoutDockWidget;
}

References ClearButtonCallback(), CommandEditedCallback(), CommandEnteredCallback(), g4zmq::connect(), CoutFilterCallback(), fClearIcon, fCommandArea, fCommandLabel, fCoutDockWidget, fCoutFilter, fCoutTBTextArea, fSaveIcon, fSearchIcon, SaveOutputCallback(), and ThreadComboBoxCallback().

Referenced by G4UIQt().

◆ CreateEmptyPickInfosWidget()

void G4UIQt::CreateEmptyPickInfosWidget ( )

private

Definition at line 4764 of file G4UIQt.cc.

                                        {
  QLayoutItem * wItem;
  if (fPickInfosWidget->layout()->count()) {
    while ((wItem = fPickInfosWidget->layout()->takeAt(0)) != 0) {
      delete wItem->widget();
      delete wItem;
    }
  }
  // Add empty one
  QLabel* label = new QLabel("Click on the object you want to pick");
  fPickInfosWidget->layout()->addWidget(label);
  fPickInfosDialog->setWindowTitle("Nothing to pick");
}

References fPickInfosDialog, and fPickInfosWidget.

Referenced by CreatePickInfosDialog().

◆ CreateEmptyViewerPropertiesWidget()

void G4UIQt::CreateEmptyViewerPropertiesWidget ( )

private

Definition at line 4746 of file G4UIQt.cc.

                                               {
  if(!fViewerPropertiesWidget) return;
  if(!fViewerPropertiesWidget->layout()) return;
  QLayoutItem * wItem;
  if (fViewerPropertiesWidget->layout()->count()) {
    while ((wItem = fViewerPropertiesWidget->layout()->takeAt(0)) != 0) {
      delete wItem->widget();
      delete wItem;
    }
  }
  // Add empty one
  QLabel* label = new QLabel("No viewer - Please open a viewer first");
  fViewerPropertiesWidget->layout()->addWidget(label);
  fViewerPropertiesDialog->setWindowTitle("No viewer");
  fViewerPropertiesDialog->setVisible(false);
}

References fViewerPropertiesDialog, and fViewerPropertiesWidget.

Referenced by CreateViewerPropertiesDialog(), and TabCloseCallback().

◆ CreateHelpTBWidget()

QWidget * G4UIQt::CreateHelpTBWidget ( )

private

Create the Help ToolBox Widget

Definition at line 1503 of file G4UIQt.cc.

{
  fHelpTBWidget = new QWidget();
 
  QWidget *helpWidget = new QWidget();
  QHBoxLayout *helpLayout = new QHBoxLayout();
  QVBoxLayout *vLayout = new QVBoxLayout();
  fHelpVSplitter = new QSplitter(Qt::Vertical);
  fHelpLine = new QLineEdit();
  helpLayout->addWidget(new QLabel("Search :"));
  helpLayout->addWidget(fHelpLine);
  connect( fHelpLine, SIGNAL( editingFinished () ), this, SLOT( LookForHelpStringCallback() ) );
 
  // Create Help tree
  FillHelpTree();
 
  fParameterHelpLabel = new QTextEdit();
  fParameterHelpLabel->setReadOnly(true);
  fParameterHelpTable = new QTableWidget();
 
  // Set layouts
 
  if (fHelpTreeWidget) {
    fHelpVSplitter->addWidget(fHelpTreeWidget);
  }
  fHelpVSplitter->addWidget(fParameterHelpLabel);
  fHelpVSplitter->addWidget(fParameterHelpTable);
 
  fParameterHelpLabel->setVisible(false);
  fParameterHelpTable->setVisible(false);
  QSizePolicy policy = QSizePolicy(QSizePolicy::Maximum,QSizePolicy::Maximum);
  policy.setVerticalStretch(4);
  if (fHelpTreeWidget) {
    fHelpTreeWidget->setSizePolicy(policy);
  }
  policy = QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Preferred);
  policy.setVerticalStretch(1);
  fParameterHelpLabel->setSizePolicy(policy);
  fParameterHelpTable->setSizePolicy(policy);
 
  vLayout->addWidget(helpWidget);
  vLayout->addWidget(fHelpVSplitter,1);
  vLayout->setContentsMargins(5,5,5,5);
 
  helpWidget->setLayout(helpLayout);
  fHelpTBWidget->setLayout(vLayout);
 
  return fHelpTBWidget;
}

References g4zmq::connect(), fHelpLine, fHelpTBWidget, fHelpTreeWidget, fHelpVSplitter, FillHelpTree(), fParameterHelpLabel, fParameterHelpTable, and LookForHelpStringCallback().

Referenced by CreateUITabWidget().

◆ CreateHelpTree()

void G4UIQt::CreateHelpTree	(	QTreeWidgetItem *	aParent,
		G4UIcommandTree *	aCommandTree
	)

private

Fill the Help Tree Widget

Parameters

aParent	: parent item to fill
aCommandTree	: commandTree node associate with this part of the Tree

Definition at line 2821 of file G4UIQt.cc.

{
  if (aParent == NULL) return;
  if (aCommandTree == NULL) return;
 
 
  // Creating new item
  QTreeWidgetItem * newItem;
 
  QString commandText = "";
  // Get the Sub directories
  for (int a=0;a<aCommandTree->GetTreeEntry();a++) {
 
    commandText = QString((char*)(aCommandTree->GetTree(a+1)->GetPathName()).data()).trimmed();
 
    // if already exist, don't create it !
    newItem = FindTreeItem(aParent,commandText);
    if (newItem == NULL) {
      newItem = new QTreeWidgetItem();
      newItem->setText(0,GetShortCommandPath(commandText));
      aParent->addChild(newItem);
    }
    CreateHelpTree(newItem,aCommandTree->GetTree(a+1));
  }
 
  // Get the Commands
 
  for (int a=0;a<aCommandTree->GetCommandEntry();a++) {
 
    QStringList stringList;
    commandText = QString((char*)(aCommandTree->GetCommand(a+1)->GetCommandPath()).data()).trimmed();
 
    // if already exist, don't create it !
    newItem = FindTreeItem(aParent,commandText);
    if (newItem == NULL) {
      newItem = new QTreeWidgetItem();
      newItem->setText(0,GetShortCommandPath(commandText));
      aParent->addChild(newItem);
 
#if QT_VERSION < 0x040202
      fHelpTreeWidget->setItemExpanded(newItem,false);
#else
      newItem->setExpanded(false);
#endif
    }
  }
}

References CreateHelpTree(), fHelpTreeWidget, FindTreeItem(), G4UIcommandTree::GetCommand(), G4UIcommandTree::GetCommandEntry(), G4UIcommand::GetCommandPath(), G4UIcommandTree::GetPathName(), GetShortCommandPath(), G4UIcommandTree::GetTree(), and G4UIcommandTree::GetTreeEntry().

Referenced by CreateHelpTree(), and FillHelpTree().

◆ CreateHelpWidget()

void G4UIQt::CreateHelpWidget ( )

private

◆ CreateHistoryTBWidget()

QWidget * G4UIQt::CreateHistoryTBWidget ( )

private

Create the History ToolBox Widget

Definition at line 1484 of file G4UIQt.cc.

{
  fHistoryTBWidget = new QWidget();
 
  QVBoxLayout *layoutHistoryTB = new QVBoxLayout();
  fHistoryTBTableList = new QListWidget();
  fHistoryTBTableList->setSelectionMode(QAbstractItemView::SingleSelection);
  connect(fHistoryTBTableList, SIGNAL(itemSelectionChanged()), SLOT(CommandHistoryCallback()));
 
  layoutHistoryTB->addWidget(fHistoryTBTableList);
 
  fHistoryTBWidget->setLayout(layoutHistoryTB);
  return fHistoryTBWidget;
}

References CommandHistoryCallback(), g4zmq::connect(), fHistoryTBTableList, and fHistoryTBWidget.

Referenced by CreateUITabWidget().

◆ CreateIcons()

void G4UIQt::CreateIcons ( )

private

Definition at line 367 of file G4UIQt.cc.

{
  const char * const save[]={
    "32 32 24 1",
    "       c None",
    "+      c #000200",
    "@      c #141E43",
    "#      c #000C56",
    "$      c #494A47",
    "%      c #636662",
    "&      c #312F2A",
    "*      c #191B19",
    "=      c #002992",
    "-      c #003DFF",
    ";      c #041DA5",
    ">      c #A8A9A3",
    ",      c #FDFFFC",
    "'      c #DDE0DD",
    ")      c #818783",
    "!      c #C9CBC8",
    "~      c #0116C3",
    "{      c #C5C8FA",
    "]      c #6596FC",
    "^      c #A0B4F9",
    "/      c #0B2AFD",
    "(      c #799BE3",
    "_      c #5F4826",
    ":      c #D5D8D5",
    "                                ",
    "                                ",
    "   +++++++++++++++++++++++++    ",
    "  +@##+$%%%%%%%%%%%%%%%&*$%&+   ",
    "  +=-;@>,,''',,,,,,,',,)&!,)+   ",
    "  +;-~@>,,,,,,,,,,,,,,,>$!,)+   ",
    "  +=-~@>,,,,,{]]]]]^,,,>*&$&+   ",
    "  +=-~@>,,,,,'{^{^^{,,,>*#=#+   ",
    "  +=-~@>,,,,,,,,,,,,,,,>@~/=+   ",
    "  +=-~@>,,,{{{''''{',,,>@~-=+   ",
    "  +=-~@>,,'^]]]]]]({,,,>@~-=+   ",
    "  +=-~@>,,,{{{{{{{{{,,,>@~-=+   ",
    "  +=-~@>,,,,,'{^{{^{,,,>@~-=+   ",
    "  +=-~@>,,,,,]]]]]]],,,>@~-=+   ",
    "  +=-~*>,,,,,,,,,,,,,,,>@~-=+   ",
    "  +=-~@>,,,,,,,,,,,,,,,>@~-=+   ",
    "  +=-/=$%%%%%%%%%%%%%%%$=/-=+   ",
    "  +=---;###############;---=+   ",
    "  +=---////////////////----=+   ",
    "  +=----------------///----=+   ",
    "  +=---=@##############@#--=+   ",
    "  +=---@+++++++++++*%))_+~-=+   ",
    "  +=---#+++++++++++&:,,>@~-=+   ",
    "  +=---#+++++++++++$',,>@~-=+   ",
    "  +=---#+++++++++++&!,,>@~-=+   ",
    "  +=/--#+++++++++++&',,>@~-=+   ",
    "   @;--#+++++++++++$',,>@~-=+   ",
    "    @;;@+++++++++++*)!>%@=;#+   ",
    "     @++++++++++++++*&**++@++   ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fSaveIcon = new QPixmap(save);
 
  const char * const search[]  = {
    /* columns rows colors chars-per-pixel */
    "19 19 8 1",
    "  c #5C5C5C",
    ". c #7D7D7D",
    "X c #9B9B9B",
    "o c #C3C3C3",
    "O c None",
    "+ c #000000",
    "@ c #000000",
    "# c None",
    /* pixels */
    "OOOOOOOOOOOOOOOOOOO",
    "OOOOOOOOOOOOOOOOOOO",
    "OOOOOOOo.  .oOOOOOO",
    "OOOOOOX      XOOOOO",
    "OOOOOo  XOOX  oOOOO",
    "OOOOO. XOOOOX .OOOO",
    "OOOOO  OOOOOO  OOOO",
    "OOOOO  OOOOOO  OOOO",
    "OOOOO. XOOOOo .OOOO",
    "OOOOOo  oOOo  oOOOO",
    "OOOOOOX       XOOOO",
    "OOOOOOOo.  .   XOOO",
    "OOOOOOOOOOOOO.  XOO",
    "OOOOOOOOOOOOOO. XOO",
    "OOOOOOOOOOOOOOOoOOO",
    "OOOOOOOOOOOOOOOOOOO",
    "OOOOOOOOOOOOOOOOOOO",
    "OOOOOOOOOOOOOOOOOOO",
    "OOOOOOOOOOOOOOOOOOO"
  };
  fSearchIcon = new QPixmap(search);
 
  const char * const clear[]  = {
    /* columns rows colors chars-per-pixel */
    "20 20 8 1",
    "  c #020202",
    ". c #202020",
    "X c #2C2C2C",
    "o c #797979",
    "O c None",
    "+ c #797979",
    "@ c #797979",
    "# c #797979",
    /* pixels */
    "OOOOOOOOOOOOOOOOOOOO",
    "OOOOOOOo    oOOOOOOO",
    "OOOOOXX      XXOOOOO",
    "OOOOOOOOOOOOOOOOOOOO",
    "OOOOOOOOOOOOOOOOOOOO",
    "OOOO XXXXXXXXXX OOOO",
    "OOO XOOOOOOOOOO  OOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOooOooOooO OOOO",
    "OOOOXOOOOOOOOOO OOOO",
    "OOOOOooooooooooOOOOO",
    "OOOOOO........OOOOOO"
  };
 
  fClearIcon = new QPixmap(clear);
 
 
  const char * const open[]={
    "32 32 33 1",
    "       c None",
    "+      c #09091E",
    "@      c #191B18",
    "#      c #5F615F",
    "$      c #777977",
    "%      c #AEB1AF",
    "&      c #929491",
    "*      c #515250",
    "=      c #858784",
    "-      c #333533",
    ";      c #000100",
    ">      c #272926",
    ",      c #424341",
    "'      c #696C6A",
    ")      c #5F4927",
    "!      c #583D18",
    "~      c #6E6A5B",
    "{      c #47351D",
    "]      c #E0A554",
    "^      c #FFD67B",
    "/      c #EFB465",
    "(      c #FDBF6C",
    "_      c #FFCD76",
    ":      c #806238",
    "<      c #362611",
    "[      c #0B0D0A",
    "}      c #68471B",
    "|      c #523E22",
    "1      c #B78A51",
    "2      c #A17B44",
    "3      c #D6A45E",
    "4      c #C29354",
    "5      c #A1A3A0",
    "                                ",
    "                                ",
    "                     +@@@#      ",
    "                    $%   +&   * ",
    "                   #=     $  -; ",
    "                           %>;+ ",
    "                           ,;;+ ",
    "  &#$''#'                 >;;;+ ",
    " =)!)!!!!~                *#$'' ",
    " {]^/((_({-  %%%%%%%%%%%        ",
    " {(^_^^^^:<{{{{{{{{{{{{{[&      ",
    " {/_/(((((/]]]]]]]]]]]/]!#      ",
    " {/^(((((_^^^^^^^^^^^^^^:#      ",
    " {/^(((_^^____________^^}$      ",
    " {/^(((((/////////////((!#      ",
    " {/^/^_:<|||||||||||||||@@****1 ",
    " {/^/^(<[)||||||||||||||))!!}<; ",
    " {/^_(:|234444444444444444432)1 ",
    " {/_^/<)34444444444444444443},  ",
    " {/^(2{:41111111111111111142|5  ",
    " {3^3<:31111111111111111143}-   ",
    " {/^2<:31111111111111111441|'   ",
    " {_/<:41111111111111111143},    ",
    " {(4<:31111111111111111144!#    ",
    " )4))44111111111111111144},     ",
    " )2<:31111111111111111144{#     ",
    " @|:14444444444444444444}*      ",
    " ;@434444444444444444434<#      ",
    " ;[))))))))))))))))))))!~       ",
    " ++++++++++++++++++++++;%       ",
    "                                ",
    "                                "}
  ;
  fOpenIcon = new QPixmap(open);
 
 
  const char * const move[]={
    "32 32 16 1",
    "       c None",
    ".      c #F1F1F1",
    "+      c #939393",
    "@      c #282828",
    "#      c #787878",
    "$      c #000000",
    "%      c #CCCCCC",
    "&      c #1A1A1A",
    "*      c #0D0D0D",
    "=      c #5D5D5D",
    "-      c #AEAEAE",
    ";      c #BBBBBB",
    ">      c #C9C9C9",
    ",      c #D6D6D6",
    "'      c #FFFFFF",
    ")      c #999999",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "               ..               ",
    "               ++               ",
    "              .@@.              ",
    "              #$$#              ",
    "             %&$$*%             ",
    "             =$$$$=             ",
    "            -**$$**-            ",
    "            %;%&*>;%            ",
    "          -%   @&   %-          ",
    "        ,=*;   @&   ;*=,        ",
    "      .#*$$>        >$$*#.      ",
    "    ')&$$$$*@@    @@*$$$$&)'    ",
    "    ')&$$$$*@@    @@*$$$$&+'    ",
    "      .#*$$>        >$$*#.      ",
    "        ,=*;   @&   ;*=,        ",
    "          -%   @&   %-          ",
    "            %;%&*>>%            ",
    "            -**$$**-            ",
    "             =$$$$=             ",
    "             %&$$*%             ",
    "              #$$#              ",
    "              .@@.              ",
    "               ++               ",
    "               ..               ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fMoveIcon = new QPixmap(move);
 
  const char * const rotate[]={
    "32 32 27 1",
    "       c None",
    ".      c #003333",
    "+      c #000066",
    "@      c #1A1A1A",
    "#      c #003399",
    "$      c #3333CC",
    "%      c #000033",
    "&      c #353535",
    "*      c #434343",
    "=      c #336699",
    "-      c #3399FF",
    ";      c #003366",
    ">      c #5D5D5D",
    ",      c #282828",
    "'      c #3399CC",
    ")      c #333333",
    "!      c #3366CC",
    "~      c #333399",
    "{      c #505050",
    "]      c #666666",
    "^      c #333366",
    "/      c #0033CC",
    "(      c #3366FF",
    "_      c #336666",
    ":      c #787878",
    "<      c #868686",
    "[      c #6B6B6B",
    "                   .++@         ",
    "                  #$$%&*        ",
    "                 =--; *>,       ",
    "                 '-=  )>&       ",
    "                !-',  ,>*       ",
    "             !!=--=    >*       ",
    "            =------!!~@&)@      ",
    "             --------!*{{{*&,   ",
    "             -------=){*{{{>>{) ",
    "            ,!-----=  ){&  ,&{{@",
    "          ,*>!----=   &>&     )@",
    "         ){>)~---=    *])      @",
    "        @*>,  --!     ,&@       ",
    "        @{*   '!      ,-!=~^,@  ",
    "        @&    ==      {/(----!^ ",
    "         _           ]:;(----'  ",
    "         ==_         >{+(----~  ",
    "          !-!!======!!(((---!   ",
    "           ='--------------!    ",
    "             =!!!!'!!=; !-!     ",
    "                   &<*  !~      ",
    "              @.  *[*   ;       ",
    "               ;+)>*            ",
    "                 @@             ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fRotateIcon = new QPixmap(rotate);
 
  const char * const pick[]={
    /* columns rows colors chars-per-pixel */
    "20 20 12 1 ",
    "  c #050804",
    ". c #222321",
    "X c #3B3C3A",
    "o c #4C4E4B",
    "O c #616360",
    "+ c #747673",
    "@ c #8A8C89",
    "# c #9FA19E",
    "$ c #BABCB9",
    "% c #CED0CD",
    "& c #E4E6E3",
    "* c None",
    /* pixels */
    "*********oo*********",
    "*********oo*********",
    "******$O.  .O%******",
    "****&o .O..O  O*****",
    "***&X @**oo**@ X****",
    "***o $***oo***$ O***",
    "**% @**********@ %**",
    "**O.***********& +**",
    "**.O*****@@*****o.**",
    "oo .oo**@  #*&XX. oo",
    "oo .oo**@  #*&oo. oO",
    "**.O*****##*****oX**",
    "**O ***********& +**",
    "**% @****&&****+ &**",
    "***O $***Xo***# +***",
    "****X @&*Xo*&+ o****",
    "*****O  o..o  +*****",
    "******%+.  X+&******",
    "*********oo*********",
    "*********oO*********"
  };
  fPickIcon = new QPixmap(pick);
 
  const char * const zoom_in[]={
    "32 32 11 1",
    "       c None",
    ".      c #C9CBC8",
    "+      c #A8A9A3",
    "@      c #818783",
    "#      c #D5D8D5",
    "$      c #9BCCCC",
    "%      c #5FC7F4",
    "&      c #FDFFFC",
    "*      c #636662",
    "=      c #9599CE",
    "-      c #DDE0DD",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "          .++@@++.              ",
    "         +++..#.+++             ",
    "       .@+...++++#+@.           ",
    "       @$.%%+&&&@%..@           ",
    "      ++.%%%+&&&*%%.++          ",
    "     .+#%%%%+&&&*%%.#+          ",
    "     ++..%%%+&&&*%%%.++         ",
    "     +#.+++++&&&*++++.+         ",
    "     @.+&&&&&&&&&&&&&+@         ",
    "     @#+&&&&&&&&&&&&&+@         ",
    "     @.+&&&&&&&&&&&&&+.         ",
    "     +++@***+&&&****@+.         ",
    "     ....++++&&&*++++..         ",
    "      ++.===+&&&*%=.++          ",
    "       @..==+&&&*=..@#&         ",
    "       .@+#.+&&&@-+@@*@         ",
    "         +++.++++++ *+@*        ",
    "          .+@@@++.  @**+*       ",
    "                    .*@*+*      ",
    "                     .*@*+*     ",
    "                      +*@@*     ",
    "                       .**+     ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fZoomInIcon = new QPixmap(zoom_in);
 
  const char * const zoom_out[]={
    "32 32 11 1",
    "       c None",
    ".      c #C9CBC8",
    "+      c #A8A9A3",
    "@      c #818783",
    "#      c #D5D8D5",
    "$      c #5FC7F4",
    "%      c #9BCCCC",
    "&      c #FDFFFC",
    "*      c #636662",
    "=      c #9599CE",
    "-      c #DDE0DD",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "          .++@@++.              ",
    "         +++..#.+++             ",
    "       .@+..$$$$.#+@.           ",
    "       @%.$$$$$$$$..@           ",
    "      ++.$$$$$$$$$$.++          ",
    "     .+#$$$$$$$$$$$.#+          ",
    "     ++..$$$$$$$$$$$.++         ",
    "     +#.+++++++++++++.+         ",
    "     @.+&&&&&&&&&&&&&+@         ",
    "     @#+&&&&&&&&&&&&&+@         ",
    "     @.+&&&&&&&&&&&&&+.         ",
    "     +++@***********@+.         ",
    "     ....++++++++++++..         ",
    "      ++.===$$$$$$=.++          ",
    "       @..===$$$$=..@#&         ",
    "       .@+#.$$$..-+@@*@         ",
    "         +++#--.+++ *+@*        ",
    "          .+@@@++.  @**+*       ",
    "                    .*@*+*      ",
    "                     .*@*+*     ",
    "                      +*@@*     ",
    "                       .**+     ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fZoomOutIcon = new QPixmap(zoom_out);
 
  const char * const wireframe[]={
    "32 32 24 1",
    "       c None",
    "+      c #E4E4E4",
    "@      c #D5D5D5",
    "#      c #E1E1E1",
    "$      c #E7E7E7",
    "%      c #D8D8D8",
    "&      c #A7A7A7",
    "*      c #000000",
    "=      c #989898",
    "-      c #8A8A8A",
    ";      c #B5B5B5",
    ">      c #1B1B1B",
    ",      c #676767",
    "'      c #959595",
    ")      c #4A4A4A",
    "!      c #878787",
    "~      c #D3D3D3",
    "{      c #C4C4C4",
    "]      c #A4A4A4",
    "^      c #5B5B5B",
    "/      c #B3B3B3",
    "(      c #787878",
    "_      c #C7C7C7",
    ":      c #585858",
    "                                ",
    "                  +@@#          ",
    "          $%@@@@@&****=+        ",
    "        +&********&@-***;       ",
    "   +@@@&**&@@@@@@$  @*-&>&+     ",
    "  +*****&+          %*@ ,**'#   ",
    "  @***)!~           @*{&*****+  ",
    "  @*!]***&+        +-*^**'~!*@  ",
    "  @*~ +@&**&@@@@@@&****&+  ~*@  ",
    "  @*@    +&********&-*=    @*@  ",
    "  @*@      $%@-*-@$ @*@    @*@  ",
    "  @*@         @*@   %*%    @*@  ",
    "  @*@         %*%   %*%    @*@  ",
    "  @*@         %*%   %*%    @*@  ",
    "  @*@         %*%   %*%    @*@  ",
    "  @*@         %*%   %*%    @*@  ",
    "  @*@         %*%   %*%    @*@  ",
    "  @*@         @*@   %*%    @*@  ",
    "  @*@         =*-+  @*@    @*@  ",
    "  @*@    $%@@&****&@-*-+   @*@  ",
    "  @*@ $@&*****&@@&******&~~!*@  ",
    "  @*{/***&@@%$    $@-*-&*****+  ",
    "  @*)*)(-~          @*@ ~)**]   ",
    "  +*******&@@@@+    %*_+]**]    ",
    "   +@@@@@&******&@%+_*^**]#     ",
    "          $%@@@&****:**&+       ",
    "                +%@&**&         ",
    "                    ++          ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fWireframeIcon = new QPixmap(wireframe);
 
  const char * const solid[]={
    "32 32 33 1",
    "       c None",
    "+      c #C2DEDE",
    "@      c #B5D7DF",
    "#      c #ACD6E6",
    "$      c #60C0EC",
    "%      c #4EB7EE",
    "&      c #53B9ED",
    "*      c #82CEEA",
    "=      c #CFDDDA",
    "-      c #94C9E8",
    ";      c #0960FF",
    ">      c #0943FF",
    ",      c #0949FF",
    "'      c #3CB3F0",
    ")      c #71C7EB",
    "!      c #73CBE5",
    "~      c #D3DDDB",
    "{      c #C4DDDE",
    "]      c #B7D5DF",
    "^      c #2DACF5",
    "/      c #59C1ED",
    "(      c #5FC0ED",
    "_      c #85CEE9",
    ":      c #096BFF",
    "<      c #2AACF6",
    "[      c #5CBEEC",
    "}      c #7ACAE4",
    "|      c #73CAEB",
    "1      c #71C8E5",
    "2      c #D1DDDA",
    "3      c #CBDDD9",
    "4      c #67C1EB",
    "5      c #80CDEA",
    "                                ",
    "                                ",
    "          +@@@@@@#$%&*=         ",
    "        +-;>>>>>>>>>,')!~       ",
    "   {]@@-;>>>>>>>>>>>>^/(_=      ",
    "  {:>>>>>>>>>>>>>>>>><//[)!=    ",
    "  ]>>>>>>>>>>>>>>>>>><////[)}   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>><//////|   ",
    "  @>>>>>>>>>>>>>>>>>></////[1   ",
    "  @>>>>>>>>>>>>>>>>>><////[*2   ",
    "  {:>>>>>>>>>>>>>>>>><//[)12    ",
    "   +@@@@@-;>>>>>>>>>><[)13      ",
    "          {]@@@-;>>>,'*3        ",
    "                +@@#452         ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fSolidIcon = new QPixmap(solid);
 
  const char * const hidden_line_removal[]={
    "32 32 15 1",
    "       c None",
    "+      c #D5D5D5",
    "@      c #C7C7C7",
    "#      c #9C9C9C",
    "$      c #000000",
    "%      c #8E8E8E",
    "&      c #808080",
    "*      c #A9A9A9",
    "=      c #D8D8D8",
    "-      c #CACACA",
    ";      c #181818",
    ">      c #9F9F9F",
    ",      c #ACACAC",
    "'      c #B9B9B9",
    ")      c #555555",
    "                                ",
    "                  +@@+          ",
    "          +@@@@@@#$$$$%+        ",
    "        +#$$$$$$$$#@&$$$*       ",
    "   =-@@#$$#@@@@@-=  @$&#;>=     ",
    "  =$$$$$#+          -$@ *$$%+   ",
    "  -$&@-=            -$-  #$$$=  ",
    "  -$@               -$-   +&$-  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    @$@  ",
    "  @$@               @$@    #$=  ",
    "  -$&@@@-=          -$-  =>;,   ",
    "  =$$$$$$$#@@@-=    -$'+#$$,    ",
    "   =-@@@@#$$$$$$#@-+'$)$$#+     ",
    "          =-@@@#$$$$)$$#+       ",
    "                +@@#$$#         ",
    "                    ++          ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fHiddenLineRemovalIcon = new QPixmap(hidden_line_removal);
 
  const char * const hidden_line_and_surface_removal[]={
    "32 32 40 1",
    "       c None",
    "+      c #FFFFFF",
    "@      c #89A2E9",
    "#      c #5378E3",
    "$      c #A2B5ED",
    "%      c #5379E3",
    "&      c #5076E3",
    "*      c #3E69E4",
    "=      c #0C43F8",
    "-      c #043FFE",
    ";      c #CDD9ED",
    ">      c #BDCDE9",
    ",      c #FBFCFC",
    "'      c #406AE4",
    ")      c #0439FE",
    "!      c #0137FF",
    "~      c #4F75E3",
    "{      c #9EB5E3",
    "]      c #829FE0",
    "^      c #B6C6E7",
    "/      c #9DB4E3",
    "(      c #7E9CE0",
    "_      c #B2C3E9",
    ":      c #7E9AE0",
    "<      c #86A2E1",
    "[      c #CAD6ED",
    "}      c #5177E3",
    "|      c #829CE0",
    "1      c #BCCCE9",
    "2      c #3A67E6",
    "3      c #0A43FA",
    "4      c #95ACE1",
    "5      c #BBCBE9",
    "6      c #A9BBE5",
    "7      c #96AFE1",
    "8      c #BDCBE9",
    "9      c #4067E4",
    "0      c #6485E5",
    "a      c #E3EAF3",
    "b      c #CAD6F3",
    "                                ",
    "                                ",
    "                  ++++          ",
    "          ++++++++@#$+++        ",
    "        ++@%####&*=-#+;>,       ",
    "   +++++@'=)))))))!)~+{]^++     ",
    "   +$%&*=)!!!!!!!!!)~+/(]_+++   ",
    "   +#-))!!!!!!!!!!!)~+/(::<[+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/::::{+   ",
    "   +#)!!!!!!!!!!!!!!}+/:::|1+   ",
    "   +$#}}~23!!!!!!!!)~+/(]45,    ",
    "   +++++++@#}}~23!!)~+678++     ",
    "          ++++++@#~90+a++       ",
    "                ++++b++         ",
    "                    ++          ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fHiddenLineAndSurfaceRemovalIcon = new QPixmap(hidden_line_and_surface_removal);
 
  const char * const perspective[]={
    "32 32 3 1",
    "       c None",
    ".      c #D5D8D5",
    "+      c #000000",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "                                ",
    "           ................     ",
    "       ....+++++++++++++++.     ",
    "    ...++++..+.........+++.     ",
    "   ..++..............++..+.     ",
    "   .+++++++++++++++++.. .+.     ",
    "   .+...............+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+.    .+.  .+.     ",
    "   .+.      .+......+....+.     ",
    "   .+.     ..++++++.+.++++.     ",
    "   .+.    .++.......+...+..     ",
    "   .+.   .++.      .+..++.      ",
    "   .+. ..+..       .+..+.       ",
    "   .+..++.         .+.+.        ",
    "   .+.++.          .+++.        ",
    "   .+++.............++.         ",
    "   .+++++++++++++++++.          ",
    "   ...................          ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fPerspectiveIcon = new QPixmap(perspective);
 
  const char * const ortho[]={
    "32 32 3 1",
    "       c None",
    ".      c #D5D8D5",
    "@      c #000000",
    "                                ",
    "                                ",
    "                                ",
    "          ...................   ",
    "         ..@@@@@@@@@@@@@@@@@.   ",
    "       ..@@@.............@@@.   ",
    "      ..@@.@.         ..@..@.   ",
    "    ..@@ ..@.        .@@...@.   ",
    "   ..@@..............@@.. .@.   ",
    "   .@@@@@@@@@@@@@@@@@..   .@.   ",
    "   .@...............@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@.      .@.    .@.   ",
    "   .@.    .@........@......@.   ",
    "   .@.   .@@@@@@@@@.@.@@@@@@.   ",
    "   .@.  .@@+........@....@@..   ",
    "   .@...@.         .@...@...    ",
    "   .@.@@.          .@.@@ .      ",
    "   .@@@.............@@@..       ",
    "   .@@@@@@@@@@@@@@@@@...        ",
    "   ...................          ",
    "                                ",
    "                                ",
    "                                "}
  ;
  fOrthoIcon = new QPixmap(ortho);
 
  const char * const commandIcon[]={
    "20 20 25 1 ",
    "  c #4ED17F",
    ". c #4FD280",
    "X c #50D381",
    "o c #5BD181",
    "O c #5DD382",
    "+ c #59D48A",
    "@ c #66D68C",
    "# c #6FD895",
    "$ c #85DEA4",
    "% c #8CE0AC",
    "& c #96E4B8",
    "* c #9EE3B8",
    "= c #A8E5BB",
    "- c #A7E8C4",
    "; c #B2EAC8",
    ": c #B9ECD1",
    "> c #C2EDD3",
    ", c #CBF1DF",
    "< c #D4F3E3",
    "1 c #DDF4E5",
    "2 c #DBF5EC",
    "3 c #E5F7F0",
    "4 c #EDFAFB",
    "5 c #F6FBFE",
    "6 c #FEFFFC",
    /* pixels */
    "66666666666666666666",
    "66%++++++++++++++&56",
    "6$ o..o......o..o *6",
    "6+o...o*<441;@.o..+6",
    "6+..o@1553<354$..o+6",
    "6+..o<5<@  .*54#o.+6",
    "6+o.*52X     :5-..@6",
    "6+..15%      o$+o.+6",
    "6+.+55@        .o.+6",
    "6O.#54         .X.+6",
    "6O #54         .X.+6",
    "6O.+55@        .o.+6",
    "6+..25%      @,*o.@6",
    "6+o.*52X     :5>.o+6",
    "6+..O25<@  X=54#o.+6",
    "6+.o.@1553<354$...@6",
    "6+o..oo*<44<;@o..o+6",
    "6$ .o..o.....o..o *6",
    "66%+++++OOOO+++++*66",
    "66666666666666666666"
  };
  fCommandIcon = new QPixmap(commandIcon);
 
  const char * const dirIcon[]={
    "20 20 25 1 ",
    "  c #DF5959",
    ". c #DD5F5F",
    "X c #DE7370",
    "o c #E06360",
    "O c #E06467",
    "+ c #E06C6C",
    "@ c #E57979",
    "# c #E08886",
    "$ c #E18D91",
    "% c #E19D9B",
    "& c #E99B9D",
    "* c #E8A2A2",
    "= c #EEB2B0",
    "- c #EDBBBC",
    "; c #EDCBC7",
    ": c #E9CDD1",
    "> c #F1D5D6",
    ", c #F9DFE2",
    "< c #EFE8E7",
    "1 c #F3E3E4",
    "2 c #F8EEEC",
    "3 c #FCF6F4",
    "4 c #F6F3F9",
    "5 c #F2F8FC",
    "6 c #FEFFFD",
    /* pixels */
    "66666666666666666666",
    "66$oOOOOOOOOOOOOo%66",
    "6#                %6",
    "6o  +,666663:+    o6",
    "6o  =635533666$   o6",
    "6o  -65:+  +165X  o6",
    "6o  >6<.     36;  O6",
    "6o  26-      &6>. o6",
    "6. o56*      @63. o6",
    "6. X56&      o66. o6",
    "6. X56&      +63. o6",
    "6. o56*      @62. o6",
    "6o  26-      =61  O6",
    "6o  >6<.    o36:  o6",
    "6o  -65:+  @265X  o6",
    "6o  =635543665#   O6",
    "6o  +1666662;+    o6",
    "6#                %6",
    "66$OOOoo....OOOOo%66",
    "66666666666666666666"}
  ;
  fDirIcon = new QPixmap(dirIcon);
 
 
  const char * const runIcon[]={
    /* columns rows colors chars-per-pixel */
    "20 20 33 1 ",
    "  c #5CA323",
    ". c #5EA03F",
    "X c #6DB620",
    "o c #66AD3F",
    "O c #70B73C",
    "+ c #7CC13F",
    "@ c #569B41",
    "# c #61A14E",
    "$ c #70A95D",
    "% c #7EB55C",
    "& c #85B94E",
    "* c #90BE49",
    "= c #81B669",
    "- c #81B370",
    "; c #95CA46",
    ": c #A1CD40",
    "> c #AED045",
    ", c #B3D558",
    "< c #9BC87E",
    "1 c #AED668",
    "2 c #A2D075",
    "3 c #C2DC73",
    "4 c #A5C98F",
    "5 c #C1DC9F",
    "6 c #CAE18E",
    "7 c #CCE39A",
    "8 c #C4DCB6",
    "9 c #E3ECBA",
    "0 c #EEF3D3",
    "q c #F0F7DE",
    "w c #F8FAE9",
    "e c #FCFFFB",
    "r c None",
    /* pixels */
    "rrrrrrrr%<<2rrrrrrrr",
    "rrrrr5=$$$$===rrrrrr",
    "rrrr<##$$$$$---&rrrr",
    "rrr=###$$$$-----%rrr",
    "rr=####$$$$------&rr",
    "r2@####7##$-------rr",
    "r.@####048$-------Or",
    "r.@####q4ee=----$@.r",
    " .@@###w4eee5%$#@@@X",
    " .@@@..w4eeeeqo..@@X",
    " .@..ooe<eeee7Oooo@X",
    " ..oooOe2eee6OOOooo ",
    "rOooOO+e2ew2+++++O+r",
    "r:oO+++e30,;;;;;++Or",
    "r :++;:9,>,,>>:;;1rr",
    "rr*1;:>,333333,>32rr",
    "rrr66,1367777637<rrr",
    "rrrr509799999905rrrr",
    "rrrrr=8wqwwww8-rrrrr",
    "rrrrrrrr4444rrrrrrrr"
  };
  fRunIcon = new QPixmap(runIcon);
 
  const char * const paramIcon[]={
    /* columns rows colors chars-per-pixel */
    "20 20 35 1 ",
    "  c #2E2525",
    ". c #403737",
    "X c #423A3A",
    "o c #443C3C",
    "O c #473F3F",
    "+ c #4C4444",
    "@ c #4F4848",
    "# c #514949",
    "$ c #544D4D",
    "% c #595252",
    "& c #625B5B",
    "* c #696262",
    "= c #6D6666",
    "- c #716B6B",
    "; c #726C6C",
    ": c #767171",
    "> c #7E7878",
    ", c #8B8787",
    "< c #8C8787",
    "1 c #8D8888",
    "2 c #918D8D",
    "3 c #928E8E",
    "4 c #948F8F",
    "5 c #9C9898",
    "6 c #9D9999",
    "7 c #D5D4D4",
    "8 c #D8D6D6",
    "9 c #DDDBDB",
    "0 c #EFEFEF",
    "q c #F6F6F6",
    "w c None",
    "e c None",
    "r c None",
    "t c gray99",
    "y c None",
    /* pixels */
    "wwwwwwww5  5wwwwwwww",
    "wwwwwwww,  ,wwwwwwww",
    "www&;ww7+  +9ww=-www",
    "ww&  O#      OX  *ww",
    "ww;              >ww",
    "wwwO    .%%X    +www",
    "www#   3wwww3   Owww",
    "ww7   3wwwwww3   7ww",
    "5<+  .wwwwwww0.  +<5",
    "     %wwwwwwww$     ",
    "     %wwwwwwww$     ",
    "5<+  .wwwwwww0X  +<5",
    "ww9   4wwwwww1   9ww",
    "wwwO   30ww03   Owww",
    "wwwX    X#$X    @www",
    "ww=              =ww",
    "ww-  +O      ++  :ww",
    "www*>ww7+  +7ww=:www",
    "wwwwwwww1  1wwwwwwww",
    "wwwwwwww5  5wwwwwwww"
  };
  fParamIcon = new QPixmap(paramIcon);
 
  const char * const exitIcon[]={
    /* columns rows colors chars-per-pixel */
    "23 28 55 1 ",
    "  c None",
    ". c #350505",
    "X c #3A0505",
    "o c #3C0605",
    "O c #3D0605",
    "+ c #430606",
    "@ c #440606",
    "# c #470706",
    "$ c #500707",
    "% c #510807",
    "& c #520807",
    "* c #530807",
    "= c #550808",
    "- c #570808",
    "; c #5C0908",
    ": c #5D0908",
    "> c #5F0908",
    ", c #630A08",
    "< c #640A09",
    "1 c #6B0A09",
    "2 c #6C0A09",
    "3 c #720B0A",
    "4 c #760B0A",
    "5 c #770B0A",
    "6 c #7A0B0B",
    "7 c #7D0C0B",
    "8 c #7F0C0B",
    "9 c #840D0B",
    "0 c #850D0C",
    "q c #880D0C",
    "w c #8D0E0C",
    "e c #900E0C",
    "r c #940E0D",
    "t c #950E0D",
    "y c #9C0F0E",
    "u c #9E100E",
    "i c #AA100E",
    "p c #AC100F",
    "a c #AD100F",
    "s c #AE110F",
    "d c #B31110",
    "f c #B51210",
    "g c #B61210",
    "h c #B71210",
    "j c #B91210",
    "k c #C01311",
    "l c #C21311",
    "z c #C81311",
    "x c #C91312",
    "c c #CC1412",
    "v c #CE1412",
    "b c #D01412",
    "n c #D11412",
    "m c #D31412",
    "M c #D51513",
    /* pixels */
    "                       ",
    "          O=           ",
    "         :MMh          ",
    "         hMMM          ",
    "         jMMM          ",
    "    <x1  jMMM  %xw     ",
    "   rMMM  jMMM  MMMk    ",
    "  rMMMM# jMMM  MMMMx   ",
    " OMMMMk  jMMM  8MMMM9  ",
    " xMMMM   jMMM   pMMMM  ",
    " MMMM    jMMM    xMMM8 ",
    "rMMM3    jMMM     MMMM ",
    "MMMM     hMMM     MMMM ",
    "MMMM     :MMh     hMMM ",
    "MMMM      O%      8MMM ",
    "MMMM              pMMM ",
    "MMMM              MMMM ",
    "wMMM3             MMMM ",
    ".MMMM            xMMM9 ",
    " hMMMk          wMMMM  ",
    "  MMMMMO       hMMMM=  ",
    "  <MMMMMp:  $rMMMMMp   ",
    "   yMMMMMMMMMMMMMMk    ",
    "    #MMMMMMMMMMMM3     ",
    "      uMMMMMMMMk       ",
    "        #1wr3%         ",
    "                       ",
    "                       "
  };
  fExitIcon= new QPixmap(exitIcon);
}

References fClearIcon, fCommandIcon, fDirIcon, fExitIcon, fHiddenLineAndSurfaceRemovalIcon, fHiddenLineRemovalIcon, fMoveIcon, fOpenIcon, fOrthoIcon, fParamIcon, fPerspectiveIcon, fPickIcon, fRotateIcon, fRunIcon, fSaveIcon, fSearchIcon, fSolidIcon, fWireframeIcon, fZoomInIcon, and fZoomOutIcon.

Referenced by G4UIQt().

◆ CreatePickInfosDialog()

void G4UIQt::CreatePickInfosDialog ( )

private

Definition at line 4718 of file G4UIQt.cc.

                                   {
 
  if (fPickInfosDialog != NULL) {
    return;
  }
  fPickInfosDialog = new QDialog();
 
  fPickInfosDialog->setWindowTitle("Pick infos");
  fPickInfosDialog->setSizePolicy (QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding));
 
  if (!fPickInfosWidget) {
    fPickInfosWidget = new QWidget();
    QVBoxLayout* layoutPickInfos = new QVBoxLayout();
    fPickInfosWidget->setLayout(layoutPickInfos);
 
    CreateEmptyPickInfosWidget();
  }
 
  QVBoxLayout* layoutDialog = new QVBoxLayout();
 
  layoutDialog->addWidget(fPickInfosWidget);
  layoutDialog->setContentsMargins(0,0,0,0);
  fPickInfosDialog->setLayout(layoutDialog);
  fPickInfosDialog->setWindowFlags(Qt::WindowStaysOnTopHint);
 
}

References CreateEmptyPickInfosWidget(), fPickInfosDialog, and fPickInfosWidget.

Referenced by ChangeCursorAction(), and GetPickInfosWidget().

◆ CreateSceneTreeWidget()

QWidget * G4UIQt::CreateSceneTreeWidget ( )

private

Definition at line 1703 of file G4UIQt.cc.

                                      {
 
  fSceneTreeWidget = new QWidget();
  QVBoxLayout* layout = new QVBoxLayout();
  fSceneTreeWidget->setLayout(layout);
 
#if QT_VERSION < 0x040200
  fSceneTreeWidget->hide();
#else
  fSceneTreeWidget->setVisible(false);
#endif
 
  return fSceneTreeWidget;
}

References fSceneTreeWidget.

Referenced by CreateUITabWidget().

◆ CreateUITabWidget()

G4UIDockWidget * G4UIQt::CreateUITabWidget ( )

private

Create the VisParameters ToolBox Widget

Definition at line 1678 of file G4UIQt.cc.

{
  fUITabWidget = new QTabWidget();
 
  // the left dock
  fUITabWidget->addTab(CreateSceneTreeWidget(),"Scene tree");
  fUITabWidget->addTab(CreateHelpTBWidget(),"Help");
  fUITabWidget->addTab(CreateHistoryTBWidget(),"History");
  fUITabWidget->setCurrentWidget(fHelpTBWidget);
 
  fUITabWidget->setTabToolTip (0,"Scene component tree. Only available in Stored mode");
  fUITabWidget->setTabToolTip (1,"Help widget");
  fUITabWidget->setTabToolTip (2,"All commands history");
  connect(fUITabWidget, SIGNAL(currentChanged(int)), SLOT(ToolBoxActivated(int)));
 
  fUIDockWidget = new G4UIDockWidget ("Scene tree, Help, History");
  fUIDockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
 
  fUIDockWidget->setWidget(fUITabWidget);
 
  return fUIDockWidget;
}

References g4zmq::connect(), CreateHelpTBWidget(), CreateHistoryTBWidget(), CreateSceneTreeWidget(), fHelpTBWidget, fUIDockWidget, fUITabWidget, and ToolBoxActivated().

Referenced by G4UIQt().

◆ CreateViewerPropertiesDialog()

void G4UIQt::CreateViewerPropertiesDialog ( )

private

Definition at line 4692 of file G4UIQt.cc.

                                          {
 
  if (fViewerPropertiesDialog != NULL) {
    return;
  }
  fViewerPropertiesDialog = new QDialog();
 
  fViewerPropertiesDialog->setWindowTitle("Viewer properties");
  fViewerPropertiesDialog->setSizePolicy (QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding));
 
  if (!fViewerPropertiesWidget) {
    fViewerPropertiesWidget = new QWidget();
    QVBoxLayout* layoutPropertiesWidget = new QVBoxLayout();
    fViewerPropertiesWidget->setLayout(layoutPropertiesWidget);
 
    CreateEmptyViewerPropertiesWidget();
  }
 
  QVBoxLayout* layoutDialog = new QVBoxLayout();
 
  layoutDialog->addWidget(fViewerPropertiesWidget);
  layoutDialog->setContentsMargins(0,0,0,0);
  fViewerPropertiesDialog->setLayout(layoutDialog);
}

References CreateEmptyViewerPropertiesWidget(), fViewerPropertiesDialog, and fViewerPropertiesWidget.

Referenced by GetViewerPropertiesWidget(), and ViewerPropertiesIconCallback().

◆ CreateViewerWidget()

void G4UIQt::CreateViewerWidget ( )

private

Definition at line 1719 of file G4UIQt.cc.

                               {
 
  // Set layouts
 
  SetStartPage(std::string("<table width='100%'><tr><td width='30%'></td><td><div ")+
                             "style='color: rgb(140, 31, 31); font-size: xx-large; font-family: Garamond, serif; padding-bottom: 0px; font-weight: normal'>Geant4: "+
                             QApplication::applicationName ().toStdString()+
                             "</div></td><td width='40%'>&nbsp;<br/><i>http://cern.ch/geant4/</i></td></tr></table>"+
                             "<p>&nbsp;</p>"+
                             "<div style='background:#EEEEEE;'><b>Tooltips :</b><ul>"+
                             "<li><b>Start a new viewer :</b><br />"+
                             "<i>'/vis/open/...'<br />"+
                             "For example '/vis/open OGL'</i></li>"+
                             "<li><b>Execute a macro file :</b><br />"+
                             "<i>'/control/execute my_macro_file'</i></li>"+
                             "</ul></div>"+
 
                             "<div style='background:#EEEEEE;'><b>Documentation :</b><ul>"+
                             "<li><b>Visualisation publication :</b><br />"+
                             "<i><a href='http://www.worldscientific.com/doi/abs/10.1142/S1793962313400011'>The Geant4 Visualization System - A Multi-Driver Graphics System</b><br />,  Allison, J. et al., International Journal of Modeling, Simulation, and Scientific Computing, Vol. 4, Suppl. 1 (2013) 1340001</a>:<br/> http://www.worldscientific.com/doi/abs/10.1142/S1793962313400011</i></li>"+
                             "</ul></div>"+
 
                             "<div style='background:#EEEEEE;'><b>Getting Help :</b><ul>"+
                             "<li><b>If problems arise, try <a href='https://cern.ch/geant4-forum'>browsing the user forum</a> to see whether or not your problem has already been encountered.<br /> If it hasn't, you can post it and Geant4 developers will do their best to find a solution. This is also a good place to<br /> discuss Geant4 topics in general.</b> https://cern.ch/geant4-forum"+
                             "<li><b>Get a look at <a href='http://cern.ch/geant4/support'>Geant4 User support pages</a>: <i>http://cern.ch/geant4/support</i></b></li>"+
                             "</ul></div>"
                             );
 
 
  // fill right splitter
  if (fViewerTabWidget == NULL) {
    fViewerTabWidget = new G4QTabWidget();
    fMainWindow->setCentralWidget(fViewerTabWidget);
#if QT_VERSION < 0x040500
#else
    fViewerTabWidget->setTabsClosable (true);
#endif
 
#if QT_VERSION < 0x040200
#else
    fViewerTabWidget->setUsesScrollButtons (true);
#endif
 
#if QT_VERSION < 0x040500
#else
    connect(fViewerTabWidget,   SIGNAL(tabCloseRequested(int)), this, SLOT(TabCloseCallback(int)));
#endif
    connect(fViewerTabWidget, SIGNAL(currentChanged ( int ) ), SLOT(UpdateTabWidget(int)));
  }
 
// set the QGLWidget size policy
  QSizePolicy policy = QSizePolicy(QSizePolicy::Preferred,QSizePolicy::Preferred);
  policy.setVerticalStretch(4);
  fViewerTabWidget->setSizePolicy(policy);
 
  fViewerTabWidget->setMinimumSize(40,40);
}

References g4zmq::connect(), fMainWindow, fViewerTabWidget, SetStartPage(), TabCloseCallback(), and UpdateTabWidget().

Referenced by AddTabWidget(), and G4UIQt().

◆ CreateVisCommandGroupAndToolBox()

bool G4UIQt::CreateVisCommandGroupAndToolBox	(	G4UIcommand *	aCommand,
		QWidget *	aParent,
		int	aDepthLevel,
		bool	isDialog
	)

private

Add the following command to the corresponding groupbox If depthLevel is 1 : create ToolBox If depthLevel is 2 or more : create GroupBox

Definition at line 2880 of file G4UIQt.cc.

{
  QString commandText = QString((char*)(aCommand->GetCommandPath().data())).section("/",-aDepthLevel);
 
  if (commandText == NULL) {
    return false;
  }
 
  // Look if groupBox is create
  //  QGroupBox* gBoxCommandWidget;
  QWidget* newParentWidget = NULL;
  bool found = false;
  QString commandSection = commandText.left(commandText.indexOf("/"));
 
  if (aDepthLevel == 1) {
    QToolBox* currentParent = dynamic_cast<QToolBox*>(aParent);
    if (currentParent != 0){
 
      // already exists ?
      for (int a=0; a<currentParent->count(); a++) {
        if (currentParent->itemText(a) == commandSection) {
          found = true;
          newParentWidget = currentParent->widget(a);
        }
      }
    }
    // Not found ? create it
    if (!found) {
      newParentWidget = new QGroupBox();
      newParentWidget->setLayout(new QVBoxLayout());
      if (currentParent != 0){
        currentParent->addItem(newParentWidget,commandSection);
      } else {
        if (!aParent->layout()) {
          aParent->setLayout(new QVBoxLayout());
        }
        aParent->layout()->addWidget(newParentWidget);
      }
 
      if (commandText.indexOf("/") == -1) {
 
        // Guidance
        QString guidance;
        G4int n_guidanceEntry = aCommand->GetGuidanceEntries();
        for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
          guidance += QString((char*)(aCommand->GetGuidanceLine(i_thGuidance)).data()) + "\n";
        }
        newParentWidget->setToolTip(guidance);
      }
 
      QScrollArea* sc = dynamic_cast<QScrollArea*>(newParentWidget->parent()->parent());
      if (sc != 0) {
        sc->ensureWidgetVisible(newParentWidget);
 
      }
    }
  } else {
 
    // try to know if this level is already there
    QGroupBox* currentParent = dynamic_cast<QGroupBox*>(aParent);
    if (currentParent != 0){
 
      // if depth==2, then we add a [more parameters inside] to the toolBoxItem parent
      // QGroupBox > QWidget > QScrollArea > QToolBox
      if (aDepthLevel == 2){
        QToolBox* parentToolBox = dynamic_cast<QToolBox*>(currentParent->parent()->parent()->parent());
        if (parentToolBox != 0) {
          //          parentToolBox->setItemText(parentToolBox->indexOf(currentParent),"[more parameters inside]");
        }
      }
      for (int a=0; a<aParent->layout()->count(); a++) {
        QGroupBox* gb = dynamic_cast<QGroupBox*>(aParent->layout()->itemAt(a)->widget());
        if (gb != 0) {
          if (gb->title() == commandSection) {
            found = true;
            newParentWidget = gb;
          }
        }
      }
    }
 
    // Not found ? create it
    if (!found) {
      newParentWidget = new QGroupBox();
      newParentWidget->setLayout(new QVBoxLayout());
      if (!aParent->layout()) {
        aParent->setLayout(new QVBoxLayout());
      }
      aParent->layout()->addWidget(newParentWidget);
 
      // set toolTip
      // Guidance
      QString guidance;
      G4int n_guidanceEntry = aCommand->GetGuidanceEntries();
      for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
        guidance += QString((char*)(aCommand->GetGuidanceLine(i_thGuidance)).data()) + "\n";
      }
      newParentWidget->setToolTip(guidance);
    }
  }
 
  // fill command groupbox
  if (commandText.indexOf("/") == -1) {
    if (CreateCommandWidget(aCommand, newParentWidget,isDialog)) {
      return true;
    }
  } else {
    CreateVisCommandGroupAndToolBox(aCommand,newParentWidget, aDepthLevel-1,isDialog);
  }
 
  return true;
}

References CreateCommandWidget(), CreateVisCommandGroupAndToolBox(), G4UIcommand::GetCommandPath(), G4UIcommand::GetGuidanceEntries(), and G4UIcommand::GetGuidanceLine().

Referenced by ButtonCallback(), and CreateVisCommandGroupAndToolBox().

◆ CreateVisParametersTBWidget()

QWidget * G4UIQt::CreateVisParametersTBWidget ( )

private

Create the VisParameters ToolBox Widget

Definition at line 1669 of file G4UIQt.cc.

{
  return NULL;
}

◆ DefaultIcons()

void G4UIQt::DefaultIcons ( bool 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
    }
  }
}

References fDefaultIcons, fMainWindow, and fToolbarApp.

◆ eventFilter()

bool G4UIQt::eventFilter	(	QObject *	aObj,
		QEvent *	aEvent
	)

private

Event filter method. Every event from QtApplication goes here.
We apply a filter only for the Up and Down Arrow press when the QLineEdit
is active. If this filter match, Up arrow we give the previous command
and Down arrow will give the next if exist.

Parameters

obj	Emitter of the event
event	Kind of event

Definition at line 3584 of file G4UIQt.cc.

{
  bool tabKeyPress = false;
  bool moveCommandCursor = false;
  if (aObj == NULL) return false;
  if (aEvent == NULL) return false;
 
  if (aObj == fHistoryTBTableList) {
    if (aEvent->type() == QEvent::KeyPress) {
      fCommandArea->setFocus();
    }
  }
 
  if (aObj == fCompleter->popup()) {
    if (aEvent->type() == QEvent::KeyPress) {
      QKeyEvent *e = static_cast<QKeyEvent*>(aEvent);
      if (e->key() == (Qt::Key_Tab)) {
        tabKeyPress = true;
      }
    } else if ( aEvent->type() == QEvent::Hide ) {
        // Store this value
        QString c = fCommandArea->text();
        fLastCompleteCommand = c.left(c.indexOf("<"));
    }
  }
 
  if (aObj == fCommandArea) {
    if (aEvent->type() == QEvent::KeyPress) {
      QKeyEvent *e = static_cast<QKeyEvent*>(aEvent);
      if ((e->key() == (Qt::Key_Down)) ||
          (e->key() == (Qt::Key_PageDown)) ||
          (e->key() == (Qt::Key_Up)) ||
          (e->key() == (Qt::Key_PageUp))) {
        int selection = fHistoryTBTableList->currentRow();
        if (fHistoryTBTableList->count()) {
          if (selection == -1) {
            selection = fHistoryTBTableList->count()-1;
          } else {
            if (e->key() == (Qt::Key_Down)) {
              if (selection <(fHistoryTBTableList->count()-1))
                selection++;
            } else if (e->key() == (Qt::Key_PageDown)) {
              selection = fHistoryTBTableList->count()-1;
            } else if (e->key() == (Qt::Key_Up)) {
              if (selection >0)
                selection --;
            } else if (e->key() == (Qt::Key_PageUp)) {
              selection = 0;
            }
          }
          fHistoryTBTableList->clearSelection();
#if QT_VERSION < 0x040202
          fHistoryTBTableList->setItemSelected(fHistoryTBTableList->item(selection),true);
#else
          fHistoryTBTableList->item(selection)->setSelected(true);
#endif
          fHistoryTBTableList->setCurrentItem(fHistoryTBTableList->item(selection));
        }
        moveCommandCursor = true;
      } else if (e->key() == (Qt::Key_Tab)) {
        tabKeyPress = true;
      } else if (((e->modifiers () == Qt::ControlModifier) || (e->modifiers () == Qt::MetaModifier)) && (e->key() == Qt::Key_A)) {
       fCommandArea->home(false);
       return true;
      } else if (((e->modifiers () == Qt::ControlModifier) || (e->modifiers () == Qt::MetaModifier)) && (e->key() == Qt::Key_E)) {
       fCommandArea->end(false);
       return true;
      }
    } else if (aEvent->type() == QEvent::Paint) {
        if (fLastCompleteCommand != "") {
            fCommandArea->setText(fLastCompleteCommand);
            fLastCompleteCommand = "";
        }
    }
  }
  if (tabKeyPress == true) {
    G4String ss = Complete(fCommandArea->text().toStdString().c_str());
    fCommandArea->setText((char*)(ss.data()));
    fCommandArea->setFocus();
    // do not pass by parent, it will disable widget tab focus !
    return true;
    // L.Garnier : MetaModifier is CTRL for MAC, but I don't want to put a MAC
    // specific #ifdef
  }
 
  bool res= false;
  // change cursor position if needed
  if (moveCommandCursor == true) {
    fCommandArea->setCursorPosition ( fCommandArea->text().length() );
    fCommandArea->setCursorPosition (4);
  } else {
    // pass the event on to the parent class
    res = QObject::eventFilter(aObj, aEvent);
  }
  return res;
}

References G4VBasicShell::Complete(), fCommandArea, fCompleter, fHistoryTBTableList, and fLastCompleteCommand.

◆ ExecuteCommand()

void G4VBasicShell::ExecuteCommand ( const G4String & aCommand )

protectedvirtualinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Reimplemented in G4UIterminal, and G4ZMQServer.

Definition at line 206 of file G4VBasicShell.cc.

{
  if(aCommand.length()<2) return;
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4int commandStatus = UI->ApplyCommand(aCommand);
  switch(commandStatus) {
  case fCommandSucceeded:
    break;
  case fCommandNotFound:
    G4cerr << "command not found: " << "\"" << aCommand << "\"" << G4endl;
    break;
  case fIllegalApplicationState:
    G4cerr << "illegal application state -- command refused:" << "\"" << aCommand << "\"" << G4endl;
    break;
  case fParameterOutOfRange:
  case fParameterUnreadable:
  case fParameterOutOfCandidates:
  default:
    G4cerr << "command refused (" << commandStatus << "):" << "\"" << aCommand << "\"" << G4endl;
  }
}

References G4UImanager::ApplyCommand(), fCommandNotFound, fCommandSucceeded, fIllegalApplicationState, fParameterOutOfCandidates, fParameterOutOfRange, fParameterUnreadable, G4cerr, G4endl, and G4UImanager::GetUIpointer().

Referenced by G4VBasicShell::ApplyShellCommand().

◆ ExitHelp()

void G4UIQt::ExitHelp ( ) const

privatevirtual

Implements G4VBasicShell.

Definition at line 3892 of file G4UIQt.cc.

3894{

3895}

◆ ExitSession

void G4UIQt::ExitSession ( )

privateslot

Called when user exit session

Definition at line 3886 of file G4UIQt.cc.

{
  SessionTerminate();
}

References SessionTerminate().

◆ FillHelpTree()

void G4UIQt::FillHelpTree ( )

private

Create the help tree widget

Parameters

parent : parent of tree widget

Returns: the widget containing the tree or NULL if it could not have beeen created

Definition at line 2755 of file G4UIQt.cc.

{
  if (! fHelpTreeWidget ) {
    InitHelpTreeAndVisParametersWidget();
  }
 
  QString searchText = fHelpLine->text();
 
  if (searchText =="") {
    // clear old help tree
    //    fHelpTreeWidget->clear();
  } else {
    return;
  }
 
  if (fParameterHelpLabel) {
    fParameterHelpLabel->setText("Choose a command in the command tree");
    fParameterHelpTable->setVisible(false);
  }
 
  if (fHelpLine) {
#if QT_VERSION < 0x040200
    fHelpLine->clear();
#else
    fHelpLine->setText("");
#endif
  }
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4UIcommandTree * treeTop = UI->GetTree();
 
  G4int treeSize = treeTop->GetTreeEntry();
  QTreeWidgetItem * newItem = NULL;
  QString commandText = "";
  for (int a=0;a<treeSize;a++) {
    // Creating new item
    newItem = NULL;
 
    commandText = QString((char*)(treeTop->GetTree(a+1)->GetPathName()).data()).trimmed();
 
    // if already exist, don't create it !
    for (int b=0;b<fHelpTreeWidget->topLevelItemCount();b++) {
      if (!newItem)
        newItem = FindTreeItem(fHelpTreeWidget->topLevelItem(b),commandText);
    }
 
    if (newItem == NULL) {
 
      newItem = new QTreeWidgetItem();
      newItem->setText(0,GetShortCommandPath(commandText));
      fHelpTreeWidget->addTopLevelItem(newItem);
    }
 
    // look for childs
    CreateHelpTree(newItem,treeTop->GetTree(a+1));
  }
 
}

References CreateHelpTree(), fHelpLine, fHelpTreeWidget, FindTreeItem(), fParameterHelpLabel, fParameterHelpTable, G4UIcommandTree::GetPathName(), GetShortCommandPath(), G4UImanager::GetTree(), G4UIcommandTree::GetTree(), G4UIcommandTree::GetTreeEntry(), G4UImanager::GetUIpointer(), and InitHelpTreeAndVisParametersWidget().

Referenced by AddTabWidget(), ButtonCallback(), CommandEnteredCallback(), CreateHelpTBWidget(), LookForHelpStringCallback(), SessionStart(), and ToolBoxActivated().

◆ FilterAllOutputTextArea()

void G4UIQt::FilterAllOutputTextArea ( )

private

Definition at line 4223 of file G4UIQt.cc.

                                     {
 
  QString currentThread = "";
#ifdef G4MULTITHREADED
  currentThread = fThreadsFilterComboBox->currentText();
  if (currentThread == "Master") {
    currentThread = "";
  }
#endif
  QString filter = fCoutFilter->text();
  G4String previousOutputStream = "";
 
  QString pref = "";
  QString post = "";
 
  fCoutTBTextArea->clear();
 
  for (unsigned int a=0; a<fG4OutputString.size(); a++) {
    G4UIOutputString out = fG4OutputString[a];
    if (FilterOutput(out,currentThread,filter) != "") {
 
      // changing color ?
      if (out.fOutputStream != previousOutputStream) {
        previousOutputStream = out.fOutputStream;
    if (out.fOutputStream == "info") {
      pref = "";
      post = "";
    } else if (out.fOutputStream == "warning") {
      pref = "<font color=\"DarkYellow\">";
      post = "</font>";
    } else {
      pref = "<font color=\"Red\">";
      post = "</font>";
        }
      }
      fCoutTBTextArea->append(pref + out.fText + post);
    }
  }
}

References fCoutFilter, fCoutTBTextArea, fG4OutputString, FilterOutput(), G4UIOutputString::fOutputStream, and G4UIOutputString::fText.

Referenced by CoutFilterCallback().

◆ FilterOutput()

QString G4UIQt::FilterOutput	(	const G4UIOutputString &	output,
		const QString &	currentThread,
		const QString &	filter
	)

private

Definition at line 4203 of file G4UIQt.cc.

  {
 
#ifdef G4MULTITHREADED
  if ((currentThread == "All") ||
      (currentThread == output.fThread)) {
#else
    if (currentThread == "") {
#endif
    if (output.fText.contains(QRegExp(filter))) {
      return output.fText;
    }
  }
  return "";
}

References G4UIOutputString::fText, and G4UIOutputString::fThread.

Referenced by FilterAllOutputTextArea(), ReceiveG4cerr(), and ReceiveG4cout().

◆ FindCommand()

G4UIcommand * G4VBasicShell::FindCommand ( const char * commandName ) const

protectedinherited

Definition at line 109 of file G4VBasicShell.cc.

{
  G4String commandLine = G4StrUtil::strip_copy(commandName);
 
  G4String commandString;
  size_t i = commandLine.find(" ");
  if( i != std::string::npos )
  { commandString = commandLine.substr(0,i); }
  else
  { commandString = commandLine; }
 
  G4String targetCom = ModifyPath(commandString);
  return G4UImanager::GetUIpointer()->GetTree()->FindPath(targetCom);
}

References G4UIcommandTree::FindPath(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by G4UIterminal::ExecuteCommand(), and G4ZMQServer::ExecuteCommand().

◆ FindDirectory()

G4UIcommandTree * G4VBasicShell::FindDirectory ( const char * dirName ) const

protectedinherited

Definition at line 87 of file G4VBasicShell.cc.

{
  G4String theDir = G4StrUtil::strip_copy(dirName);
 
  G4String targetDir = ModifyPath( theDir );
  if( targetDir.back() != '/' )
  { targetDir += "/"; }
  G4UIcommandTree* comTree = G4UImanager::GetUIpointer()->GetTree();
  if( targetDir == "/" )
  { return comTree; }
  size_t idx = 1;
  while( idx < targetDir.length()-1 )
  {
    size_t i = targetDir.find("/",idx);
    comTree = comTree->GetTree(targetDir.substr(0,i+1).c_str());
    if( comTree == NULL )
    { return NULL; }
    idx = i+1;
  }
  return comTree;
}

References G4UImanager::GetTree(), G4UIcommandTree::GetTree(), G4UImanager::GetUIpointer(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ChangeDirectory(), G4VBasicShell::ListDirectory(), and G4ZMQServer::SessionStart().

◆ FindMatchingPath()

G4String G4VBasicShell::FindMatchingPath	(	G4UIcommandTree *	aTree,
		const G4String &	aCommandPath
	)

protectedinherited

Definition at line 196 of file G4VBasicShell.cc.

{
  return aTree-> CompleteCommandPath(aCommandPath);
}

Referenced by G4VBasicShell::Complete().

◆ FindTreeItem()

QTreeWidgetItem * G4UIQt::FindTreeItem	(	QTreeWidgetItem *	aParent,
		const QString &	aCommand
	)

private

Find a treeItemWidget in the help tree

Parameters

aCommand item's String to look for

Returns: item if found, NULL if not

Definition at line 3284 of file G4UIQt.cc.

{
  if (aParent == NULL) return NULL;
 
  // Suppress last "/"
  QString myCommand = aCommand;
 
  if (myCommand.lastIndexOf("/") == (myCommand.size()-1)) {
    myCommand = myCommand.left(myCommand.size()-1);
  }
 
  if (GetLongCommandPath(aParent) == myCommand)
    return aParent;
 
  QTreeWidgetItem * tmp = NULL;
  for (int a=0;a<aParent->childCount();a++) {
    if (!tmp)
      tmp = FindTreeItem(aParent->child(a),myCommand);
  }
  return tmp;
}

References FindTreeItem(), and GetLongCommandPath().

Referenced by CreateHelpTree(), FillHelpTree(), and FindTreeItem().

◆ getClearIcon()

QPixmap * G4UIQt::getClearIcon ( )

inline

Definition at line 217 of file G4UIQt.hh.

217{ return fClearIcon;};

References fClearIcon.

◆ GetCommandList()

QString G4UIQt::GetCommandList ( const G4UIcommand * aCommand )

private

Build the command list parameters in a QString
Reimplement partialy the G4UIparameter.cc

Parameters

aCommand : command to list parameters

See also: G4UIparameter::List(); G4UIcommand::List()

Returns: the command list parameters, or "" if nothing

Definition at line 3318 of file G4UIQt.cc.

{
 
  QString txt ="";
  if (aCommand == NULL)
    return txt;
 
  G4String commandPath = aCommand->GetCommandPath();
  G4String rangeString = aCommand->GetRange();
  G4int n_guidanceEntry = aCommand->GetGuidanceEntries();
  G4int n_parameterEntry = aCommand->GetParameterEntries();
 
  if ((commandPath == "") &&
      (rangeString == "") &&
      (n_guidanceEntry == 0) &&
      (n_parameterEntry == 0)) {
    return txt;
  }
 
  if((commandPath.length()-1)!='/') {
    txt += "Command " + QString((char*)(commandPath).data()) + "\n";
  }
  txt += "Guidance :\n";
 
  for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
    txt += QString((char*)(aCommand->GetGuidanceLine(i_thGuidance)).data()) + "\n";
  }
  if( ! rangeString.empty() ) {
    txt += " Range of parameters : " + QString((char*)(rangeString).data()) + "\n";
  }
  if( n_parameterEntry > 0 ) {
    G4UIparameter *param;
 
    // Re-implementation of G4UIparameter.cc
 
    for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ ) {
      param = aCommand->GetParameter(i_thParameter);
      txt += "\nParameter : " + QString((char*)(param->GetParameterName()).data()) + "\n";
      if( ! param->GetParameterGuidance().empty() )
        txt += QString((char*)(param->GetParameterGuidance()).data())+ "\n" ;
      txt += " Parameter type  : " + QString(QChar(param->GetParameterType())) + "\n";
      if(param->IsOmittable()){
        txt += " Omittable       : True\n";
      } else {
        txt += " Omittable       : False\n";
      }
      if( param->GetCurrentAsDefault() ) {
        txt += " Default value   : taken from the current value\n";
      } else if( ! param->GetDefaultValue().empty() ) {
        txt += " Default value   : " + QString((char*)(param->GetDefaultValue()).data())+ "\n";
      }
      if( ! param->GetParameterRange().empty() ) {
        txt += " Parameter range : " + QString((char*)(param->GetParameterRange()).data())+ "\n";
      }
      if( ! param->GetParameterCandidates().empty() ) {
        txt += " Candidates      : " + QString((char*)(param->GetParameterCandidates()).data())+ "\n";
      }
    }
  }
  return txt;
}

References G4UIcommand::GetCommandPath(), G4UIparameter::GetCurrentAsDefault(), G4UIparameter::GetDefaultValue(), G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), G4UIcommand::GetParameter(), G4UIparameter::GetParameterCandidates(), G4UIcommand::GetParameterEntries(), G4UIparameter::GetParameterGuidance(), G4UIparameter::GetParameterName(), G4UIparameter::GetParameterRange(), G4UIparameter::GetParameterType(), G4UIcommand::GetRange(), and G4UIparameter::IsOmittable().

Referenced by LookForHelpStringInChildTree(), and OpenHelpTreeOnCommand().

◆ GetCoutDockWidget()

G4UIDockWidget * G4UIQt::GetCoutDockWidget ( )

inline

Definition at line 230 of file G4UIQt.hh.

                                             {
    return fCoutDockWidget;
  };

References fCoutDockWidget.

◆ GetCoutWidget()

QWidget * G4UIQt::GetCoutWidget ( )

inline

Definition at line 225 of file G4UIQt.hh.

                                  {
    return fCoutDockWidget->widget();
  };

References fCoutDockWidget.

◆ GetCurrentWorkingDirectory()

G4String G4VBasicShell::GetCurrentWorkingDirectory ( ) const

protectedinherited

Definition at line 69 of file G4VBasicShell.cc.

{
  return currentDirectory;
}

References G4VBasicShell::currentDirectory.

Referenced by G4VBasicShell::ApplyShellCommand(), G4UIterminal::GetCommand(), G4ZMQServer::GetCommand(), G4VBasicShell::ListDirectory(), G4ZMQServer::SessionStart(), and G4VBasicShell::TerminalHelp().

◆ GetHelpChoice()

G4bool G4UIQt::GetHelpChoice ( G4int & )

privatevirtual

Implement G4VBasicShell vurtual function

Implements G4VBasicShell.

Definition at line 3569 of file G4UIQt.cc.

{
  return true;
}

◆ GetHelpWidget()

QWidget * G4UIQt::GetHelpWidget ( )

inline

Definition at line 250 of file G4UIQt.hh.

                                  {
    return fHelpTBWidget;
  }

References fHelpTBWidget.

◆ GetHistoryWidget()

QWidget * G4UIQt::GetHistoryWidget ( )

inline

Definition at line 245 of file G4UIQt.hh.

                                     {
    return fHistoryTBWidget;
  }

References fHistoryTBWidget.

◆ GetInteractor()

G4Interactor G4VInteractiveSession::GetInteractor ( G4String a_name )

inherited

Definition at line 87 of file G4VInteractiveSession.cc.

{
  G4interactor_map::iterator it;
  if((it=interactors.find(a_name))==interactors.end()) return NULL;
  return (*it).second;  
}

References G4VInteractiveSession::interactors.

Referenced by AddButton(), G4UIXm::AddButton(), and G4UIWin32::AddButton().

◆ GetLastReturnCode()

G4int G4UIsession::GetLastReturnCode ( ) const

inlineinherited

Definition at line 63 of file G4UIsession.hh.

63{ return lastRC; }

G4UIsession::lastRC

G4int lastRC

Definition: G4UIsession.hh:69

References G4UIsession::lastRC.

◆ GetLongCommandPath()

QString G4UIQt::GetLongCommandPath ( QTreeWidgetItem * item )

private

Definition at line 4505 of file G4UIQt.cc.

{
  if (item == NULL) return "";
 
  // rebuild path:
  QString itemText = "";
  itemText = item->text(0);
 
  while (item->parent() != NULL) {
    itemText = item->parent()->text(0)+"/"+itemText;
    item = item->parent();
  }
  itemText = "/"+itemText;
 
  return itemText;
}

Referenced by FindTreeItem(), HelpTreeClicCallback(), and HelpTreeDoubleClicCallback().

◆ GetMainWindow()

QMainWindow * G4UIQt::GetMainWindow ( )

inline

Definition at line 210 of file G4UIQt.hh.

                                       {
    return fMainWindow;
  };

References 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;
}

References CreatePickInfosDialog(), fPickInfosDialog, and fPickInfosWidget.

Referenced by G4OpenGLQtViewer::createPickInfosWidget().

◆ GetSceneTreeWidget()

QWidget * G4UIQt::GetSceneTreeWidget ( )

Get the ViewerComponents ToolBox Widget

Definition at line 1780 of file G4UIQt.cc.

{
  return fSceneTreeWidget;
}

References fSceneTreeWidget.

Referenced by G4OpenGLQtViewer::createSceneTreeWidget().

◆ getSearchIcon()

QPixmap * G4UIQt::getSearchIcon ( )

inline

Definition at line 215 of file G4UIQt.hh.

215{ return fSearchIcon;};

References fSearchIcon.

Referenced by G4OpenGLQtViewer::createSceneTreeComponent().

◆ GetShortCommandPath()

QString G4UIQt::GetShortCommandPath ( QString commandPath )

private

Definition at line 4487 of file G4UIQt.cc.

{
  if (commandPath.indexOf("/") == 0) {
    commandPath = commandPath.right(commandPath.size()-1);
  }
 
  commandPath = commandPath.right(commandPath.size()-commandPath.lastIndexOf("/",-2)-1);
 
 if (commandPath.lastIndexOf("/") == (commandPath.size()-1)) {
    commandPath = commandPath.left(commandPath.size()-1);
 }
 
 return commandPath;
}

Referenced by CreateHelpTree(), and FillHelpTree().

◆ GetThreadPrefix()

G4String G4UIQt::GetThreadPrefix ( )

private

Definition at line 2285 of file G4UIQt.cc.

                                 {
  G4String threadPrefix = "";
#ifdef G4MULTITHREADED
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return "";
  if (UI->GetThreadCout() != NULL) {
    threadPrefix = UI->GetThreadCout()->GetFullPrefixString().data();
    if (UI->GetThreadCout()->GetPrefixString() == G4String("G4VIS")) {
      return "G4VIS";
    }
  }
#endif
  return threadPrefix;
}

References G4MTcoutDestination::GetFullPrefixString(), G4MTcoutDestination::GetPrefixString(), G4UImanager::GetThreadCout(), and G4UImanager::GetUIpointer().

Referenced by ReceiveG4cerr(), and ReceiveG4cout().

◆ GetUITabWidget()

QTabWidget * G4UIQt::GetUITabWidget ( )

inline

Definition at line 240 of file G4UIQt.hh.

                                      {
    return fUITabWidget;
  }

References fUITabWidget.

◆ GetUserInterfaceWidget()

G4UIDockWidget * G4UIQt::GetUserInterfaceWidget ( )

inline

Definition at line 235 of file G4UIQt.hh.

                                                  {
    return fUIDockWidget;
  };

References fUIDockWidget.

◆ GetViewerPropertiesWidget()

QWidget * G4UIQt::GetViewerPropertiesWidget ( )

Get the Viewer properties Widget

Definition at line 1788 of file G4UIQt.cc.

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

References CreateViewerPropertiesDialog(), fViewerPropertiesDialog, and fViewerPropertiesWidget.

Referenced by G4OpenGLQtViewer::createViewerPropertiesWidget().

◆ GetViewerTabWidget()

QTabWidget * G4UIQt::GetViewerTabWidget ( )

inline

Definition at line 167 of file G4UIQt.hh.

                                          {
    return fViewerTabWidget;
  };

References fViewerTabWidget.

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

◆ HelpTreeClicCallback

void G4UIQt::HelpTreeClicCallback ( )

privateslot

This callback is activated when user selected a item in the help tree

Definition at line 4088 of file G4UIQt.cc.

{
  QTreeWidgetItem* item =  NULL;
  if (!fHelpTreeWidget)
    return ;
 
  QList<QTreeWidgetItem *> list =fHelpTreeWidget->selectedItems();
  if (list.isEmpty())
    return;
  item = list.first();
  if (!item)
    return;
 
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4UIcommandTree * treeTop = UI->GetTree();
 
  std::string itemText = GetLongCommandPath(item).toStdString();
 
  // check if it is a command path
  if (item->childCount() > 0) {
    itemText +="/";
  }
  G4UIcommand* command = treeTop->FindPath(itemText.c_str());
 
  if (command) {
    updateHelpArea(command);
  } else {  // this is a command
    G4UIcommandTree* path = treeTop->FindCommandTree(itemText.c_str());
    if ( path) {
      // this is not a command, this is a sub directory
      // We display the Title
      fParameterHelpLabel->setVisible(true);
      fParameterHelpLabel->setText(path->GetTitle().data());
      fParameterHelpTable->setVisible(false);
    }
  }
}

References fHelpTreeWidget, G4UIcommandTree::FindCommandTree(), G4UIcommandTree::FindPath(), fParameterHelpLabel, fParameterHelpTable, GetLongCommandPath(), G4UIcommandTree::GetTitle(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), and updateHelpArea().

Referenced by HelpTreeDoubleClicCallback(), and InitHelpTreeAndVisParametersWidget().

◆ HelpTreeDoubleClicCallback

void G4UIQt::HelpTreeDoubleClicCallback ( )

privateslot

This callback is activated when user double clic on a item in the help tree

Definition at line 4130 of file G4UIQt.cc.

{
  HelpTreeClicCallback();
 
  QTreeWidgetItem* item =  NULL;
  if (!fHelpTreeWidget)
    return ;
 
  QList<QTreeWidgetItem *> list =fHelpTreeWidget->selectedItems();
  if (list.isEmpty())
    return;
  item = list.first();
  if (!item)
    return;
 
  fCommandArea->clear();
  fCommandArea->setText(GetLongCommandPath(item));
}

References fCommandArea, fHelpTreeWidget, GetLongCommandPath(), and HelpTreeClicCallback().

Referenced by InitHelpTreeAndVisParametersWidget().

◆ InitHelpTreeAndVisParametersWidget()

void G4UIQt::InitHelpTreeAndVisParametersWidget ( )

private

Create the help tree widget

Parameters

parent : parent of tree widget

Returns: the widget containing the tree or NULL if it could not have beeen created

Definition at line 2731 of file G4UIQt.cc.

{
 
  if (! fHelpTreeWidget ) {
    fHelpTreeWidget = new QTreeWidget();
  }
 
  // build widget
  fHelpTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
  QStringList labels;
  labels << QString("Command");
  fHelpTreeWidget->setHeaderLabels(labels);
 
 
  connect(fHelpTreeWidget, SIGNAL(itemSelectionChanged ()),this, SLOT(HelpTreeClicCallback()));
  connect(fHelpTreeWidget, SIGNAL(itemDoubleClicked (QTreeWidgetItem*,int)),this, SLOT(HelpTreeDoubleClicCallback()));
 
}

References g4zmq::connect(), fHelpTreeWidget, HelpTreeClicCallback(), and HelpTreeDoubleClicCallback().

Referenced by FillHelpTree().

◆ InSession()

G4int G4UIsession::InSession ( )

staticinherited

Definition at line 68 of file G4UIsession.cc.

{
  return inSession;
}

References G4UIsession::inSession.

Referenced by G4UIcontrolMessenger::SetNewValue().

◆ IsGUICommand()

G4bool G4UIQt::IsGUICommand ( const G4UIcommand * aCommand )

private

Return true if this command takes almost a number (int, double, bool, string) as an input or a string with a candidate list

Definition at line 3533 of file G4UIQt.cc.

{
  if (aCommand == NULL)
    return false;
 
  G4int n_parameterEntry = aCommand->GetParameterEntries();
 
  if( n_parameterEntry > 0 ) {
    G4UIparameter *param;
 
    // Re-implementation of G4UIparameter.cc
 
    for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ ) {
      param = aCommand->GetParameter(i_thParameter);
      if (QString(QChar(param->GetParameterType())) == "d") {
        return true;
      }
      if (QString(QChar(param->GetParameterType())) == "b") {
        return true;
      }
      if (QString(QChar(param->GetParameterType())) == "i") {
        return true;
      }
      if (QString(QChar(param->GetParameterType())) == "s") {
        return true;
      }
    }
  }
  return false;
}

References G4UIcommand::GetParameter(), G4UIcommand::GetParameterEntries(), and G4UIparameter::GetParameterType().

Referenced by ButtonCallback().

◆ IsIconMoveSelected()

bool G4UIQt::IsIconMoveSelected ( )

inline

Definition at line 182 of file G4UIQt.hh.

                                   {
    return fMoveSelected;
  };

References fMoveSelected.

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

◆ IsIconPickSelected()

bool G4UIQt::IsIconPickSelected ( )

inline

Definition at line 188 of file G4UIQt.hh.

                                   {
    return fPickSelected;
  };

References fPickSelected.

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

◆ IsIconRotateSelected()

bool G4UIQt::IsIconRotateSelected ( )

inline

Definition at line 185 of file G4UIQt.hh.

                                     {
    return fRotateSelected;
  };

References fRotateSelected.

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

◆ IsIconZoomInSelected()

bool G4UIQt::IsIconZoomInSelected ( )

inline

Definition at line 191 of file G4UIQt.hh.

                                     {
    return fZoomInSelected;
  };

References fZoomInSelected.

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

◆ IsIconZoomOutSelected()

bool G4UIQt::IsIconZoomOutSelected ( )

inline

Definition at line 194 of file G4UIQt.hh.

                                      {
    return fZoomOutSelected;
  };

References fZoomOutSelected.

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

◆ IsSplitterReleased()

bool G4UIQt::IsSplitterReleased ( )

◆ ListDirectory()

void G4VBasicShell::ListDirectory ( const G4String & newCommand ) const

protectedinherited

Definition at line 339 of file G4VBasicShell.cc.

{
  G4String targetDir;
  if( newCommand.length() <= 3 ) {
    targetDir = GetCurrentWorkingDirectory();
  } else {
    G4String newPrefix = newCommand.substr(3, newCommand.length()-3);
    targetDir = G4StrUtil::strip_copy(newPrefix);
  }
  G4UIcommandTree* commandTree = FindDirectory( targetDir );
  if( commandTree == NULL ) {
    G4cout << "Directory <" << targetDir << "> is not found." << G4endl;
  } else {
    commandTree->ListCurrent();
  }
}

References G4VBasicShell::FindDirectory(), G4cout, G4endl, G4VBasicShell::GetCurrentWorkingDirectory(), G4UIcommandTree::ListCurrent(), and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ApplyShellCommand(), G4UIterminal::GetCommand(), and G4ZMQServer::GetCommand().

◆ LookForHelpStringCallback

void G4UIQt::LookForHelpStringCallback ( )

privateslot

Callback called when user give a new string to look for
Display a list of matching commands descriptions. If no string is set, will display the complete help tree

Definition at line 4268 of file G4UIQt.cc.

{
  fHelpLine->setText(fHelpLine->text().trimmed());
  QString searchText = fHelpLine->text();
 
  fParameterHelpLabel->setText("");
  fParameterHelpTable->setVisible(false);
  if (searchText =="") {
    // clear old help tree
    fHelpTreeWidget->clear();
 
    FillHelpTree();
 
    return;
  } else {
    OpenHelpTreeOnCommand(searchText);
  }
}

References fHelpLine, fHelpTreeWidget, FillHelpTree(), fParameterHelpLabel, fParameterHelpTable, and OpenHelpTreeOnCommand().

Referenced by CreateHelpTBWidget().

◆ LookForHelpStringInChildTree()

QMap< int, QString > G4UIQt::LookForHelpStringInChildTree	(	G4UIcommandTree *	aCommandTree,
		const QString &	text
	)

private

Definition at line 4406 of file G4UIQt.cc.

{
  QMap<int,QString> commandResultMap;
  if (aCommandTree == NULL) return commandResultMap;
  // Get the Sub directories
  int tmp = 0;
  QMap<int,QString> commandChildResultMap;
  for (int a=0;a<aCommandTree->GetTreeEntry();a++) {
    const G4UIcommand* command = aCommandTree->GetGuidance();
    tmp = GetCommandList (command).count(text,Qt::CaseInsensitive);
    if (tmp >0) {
      commandResultMap.insertMulti(tmp,QString((char*)(aCommandTree->GetTree(a+1)->GetPathName()).data()));
    }
    // look for childs
    commandChildResultMap = LookForHelpStringInChildTree(aCommandTree->GetTree(a+1),text);
    if (!commandChildResultMap.empty()) {
      // insert new childs
      QMap<int,QString>::const_iterator i = commandChildResultMap.constBegin();
      while (i != commandChildResultMap.constEnd()) {
        commandResultMap.insertMulti(i.key(),i.value());
        i++;
      }
      commandChildResultMap.clear();
    }
  }
  // Get the Commands
  for (int a=0;a<aCommandTree->GetCommandEntry();a++) {
    const G4UIcommand* command = aCommandTree->GetCommand(a+1);
    tmp = GetCommandList (command).count(text,Qt::CaseInsensitive);
    if (tmp >0) {
      commandResultMap.insertMulti(tmp,QString((char*)(aCommandTree->GetCommand(a+1)->GetCommandPath()).data()));
    }
  }
  return commandResultMap;
}

References G4UIcommandTree::GetCommand(), G4UIcommandTree::GetCommandEntry(), GetCommandList(), G4UIcommand::GetCommandPath(), G4UIcommandTree::GetGuidance(), G4UIcommandTree::GetPathName(), G4UIcommandTree::GetTree(), G4UIcommandTree::GetTreeEntry(), and LookForHelpStringInChildTree().

Referenced by LookForHelpStringInChildTree(), and OpenHelpTreeOnCommand().

◆ ModifyPath()

G4String G4VBasicShell::ModifyPath ( const G4String & tempPath ) const

privateinherited

Definition at line 124 of file G4VBasicShell.cc.

{
  if( tempPath.length() == 0 ) return tempPath;
 
  G4String newPath = "";
 
  // temporal full path
  if( tempPath[0] == '/') newPath = tempPath;
  else newPath = currentDirectory + tempPath;
 
  // body of path...
  while(1){
    size_t idx = newPath.find("/./");
    if( idx == G4String::npos) break;
    newPath.erase(idx,2);
  }
 
  while(1) {
    size_t idx = newPath.find("/../");
    if( idx == G4String::npos) break;
    if( idx == 0) {
      newPath.erase(1,3);
      continue;
    }
    size_t idx2 = newPath.find_last_of('/', idx-1);
    if(idx2 != G4String::npos) newPath.erase(idx2, idx-idx2+3);
  }
 
  // end of path...
  if ( newPath.size() >= 3 ) {
    if(newPath.substr(newPath.size()-3,3) == "/..") {
      if( newPath.size() == 3) {
        newPath = "/";
      } else {
        size_t idx = newPath.find_last_of('/', newPath.size()-4);
        if(idx != G4String::npos) newPath.erase(idx+1);
      }
    }
  }
 
  if ( newPath.size() >= 2 ) {
    if(newPath.substr(newPath.size()-2,2) == "/.") newPath.erase(newPath.size()-1,1);
  }
 
  // truncate "/////" to "/"
  while(1) {
    size_t idx = newPath.find("//");
    if( idx == G4String::npos) break;
    newPath.erase(idx,1);
  }
 
  return newPath;
}

References G4VBasicShell::currentDirectory.

Referenced by G4VBasicShell::ChangeDirectory(), G4VBasicShell::Complete(), G4VBasicShell::FindCommand(), G4VBasicShell::FindDirectory(), and G4VBasicShell::ModifyToFullPathCommand().

◆ ModifyToFullPathCommand()

G4String G4VBasicShell::ModifyToFullPathCommand ( const char * aCommandLine ) const

protectedinherited

Definition at line 47 of file G4VBasicShell.cc.

{
  G4String rawCommandLine = aCommandLine;
  if(rawCommandLine.empty()||rawCommandLine[0]=='\0') return rawCommandLine;
  G4String commandLine = G4StrUtil::strip_copy(rawCommandLine);
  G4String commandString;
  G4String parameterString;
  size_t i = commandLine.find(" ");
  if( i != std::string::npos )
  {
    commandString = commandLine.substr(0,i);
    parameterString = " ";
    parameterString += commandLine.substr(i+1,commandLine.length()-(i+1));
  }
  else
  { commandString = commandLine; }
 
  G4String fullPathCommandLine
    = ModifyPath( commandString )+parameterString;
  return fullPathCommandLine;
}

References G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by ActivateCommand(), G4VBasicShell::ApplyShellCommand(), G4UIterminal::GetCommand(), G4ZMQServer::GetCommand(), G4VBasicShell::ShowCurrent(), and G4VBasicShell::TerminalHelp().

◆ NativeMenu()

void G4UIQt::NativeMenu ( bool 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);
}

References fMainWindow.

◆ OpenHelpTreeOnCommand()

void G4UIQt::OpenHelpTreeOnCommand ( const QString & searchText )

private

Definition at line 4289 of file G4UIQt.cc.

{
  // the help tree
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4UIcommandTree * treeTop = UI->GetTree();
 
  G4int treeSize = treeTop->GetTreeEntry();
 
  // clear old help tree
  fHelpTreeWidget->clear();
 
  // look for new items
 
  int tmp = 0;
 
#if QT_VERSION < 0x050F00
  // Before Qt5.15
  QMap<int,QString> commandResultMap;
  QMap<int,QString> commandChildResultMap;
  for (int a=0;a<treeSize;a++) {
    G4UIcommand* command = treeTop->FindPath(treeTop->GetTree(a+1)->GetPathName().data());
    tmp = GetCommandList (command).count(searchText,Qt::CaseInsensitive);
    if (tmp >0) {
      commandResultMap.insertMulti(tmp,QString((char*)(treeTop->GetTree(a+1)->GetPathName()).data()));
    }
    // look for childs
    commandChildResultMap = LookForHelpStringInChildTree(treeTop->GetTree(a+1),searchText);
    // insert new childs
    if (!commandChildResultMap.empty()) {
      QMap<int,QString>::const_iterator i = commandChildResultMap.constBegin();
      while (i != commandChildResultMap.constEnd()) {
        commandResultMap.insertMulti(i.key(),i.value());
        i++;
      }
      commandChildResultMap.clear();
    }
  }
#else
  // Qt5.15 and beyond
  QMultiMap<int,QString> commandResultMap;
  QMultiMap<int,QString> commandChildResultMap;
  for (int a=0;a<treeSize;a++) {
    G4UIcommand* command = treeTop->FindPath(treeTop->GetTree(a+1)->GetPathName().data());
    tmp = GetCommandList (command).count(searchText,Qt::CaseInsensitive);
    if (tmp >0) {
      commandResultMap.insert(tmp,QString((char*)(treeTop->GetTree(a+1)->GetPathName()).data()));
    }
    // look for childs
    commandChildResultMap = LookForHelpStringInChildTree(treeTop->GetTree(a+1),searchText);
    // insert new childs
    if (!commandChildResultMap.empty()) {
      QMap<int,QString>::const_iterator i = commandChildResultMap.constBegin();
      while (i != commandChildResultMap.constEnd()) {
        commandResultMap.insert(i.key(),i.value());
        i++;
      }
      commandChildResultMap.clear();
    }
  }
#endif
 
  // build new help tree
  fHelpTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
  fHelpTreeWidget->setColumnCount(2);
  QStringList labels;
  labels << QString("Command") << QString("Match");
  fHelpTreeWidget->setHeaderLabels(labels);
 
  if (commandResultMap.empty()) {
    fParameterHelpLabel->setText("No match found");
    fParameterHelpTable->setVisible(false);
    return;
  }
 
  QMap<int,QString>::const_iterator i = commandResultMap.constEnd();
  i--;
  // 10 maximum progress values
  float multValue = 10.0/(float)(i.key());
  QString progressChar = "|";
  QString progressStr = "|";
 
  QTreeWidgetItem * newItem;
  bool end = false;
  while (!end) {
    if (i == commandResultMap.constBegin()) {
      end = true;
    }
    for(int a=0;a<int(i.key()*multValue);a++) {
      progressStr += progressChar;
    }
    newItem = new QTreeWidgetItem();
    QString commandStr = i.value().trimmed();
 
    if (commandStr.indexOf("/") == 0) {
      commandStr = commandStr.right(commandStr.size()-1);
    }
 
    newItem->setText(0,commandStr);
    newItem->setText(1,progressStr);
    fHelpTreeWidget->addTopLevelItem(newItem);
#if QT_VERSION < 0x040200
#else
    newItem->setForeground ( 1, QBrush(Qt::blue) );
#endif
    progressStr = "|";
    i--;
  }
  fHelpTreeWidget->resizeColumnToContents (0);
  fHelpTreeWidget->sortItems(1,Qt::DescendingOrder);
  //  fHelpTreeWidget->setColumnWidth(1,10);//resizeColumnToContents (1);
}

References fHelpTreeWidget, G4UIcommandTree::FindPath(), fParameterHelpLabel, fParameterHelpTable, GetCommandList(), G4UIcommandTree::GetPathName(), G4UImanager::GetTree(), G4UIcommandTree::GetTree(), G4UIcommandTree::GetTreeEntry(), G4UImanager::GetUIpointer(), and LookForHelpStringInChildTree().

Referenced by ActivateCommand(), and LookForHelpStringCallback().

◆ OpenIconCallback

void G4UIQt::OpenIconCallback ( const QString & aParam )

privateslot

Definition at line 4664 of file G4UIQt.cc.

                                                   {
 
  QString aCommand = aParam.left(aParam.indexOf(fStringSeparator));
  QString aLabel = aParam.mid(aParam.indexOf(fStringSeparator)+fStringSeparator.length());
 
  QString nomFich = QFileDialog::getOpenFileName(fMainWindow, aLabel, fLastOpenPath, "Macro files (*.mac);;Geant4 files( *.mac *.g4* *.in);;All (*.*)");
  if (nomFich != "") {
    G4UImanager::GetUIpointer()->ApplyCommand((QString(aCommand)+ QString(" ")+ nomFich).toStdString().c_str());
    QDir dir;
    fLastOpenPath = dir.absoluteFilePath(nomFich);
  }
}

References G4UImanager::ApplyCommand(), fLastOpenPath, fMainWindow, fStringSeparator, and G4UImanager::GetUIpointer().

Referenced by AddIcon().

◆ 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;
  }
}

References G4UIQt::G4UIQtStyle::fixed, fOutputStyles, and G4UIQt::G4UIQtStyle::highlight.

◆ 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
}

References SecondaryLoop().

◆ 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());
}

References fCommandLabel.

Referenced by SecondaryLoop(), and 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 (size_t i = 0; i < 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;
}

References G4INCL::DeuteronDensity::anonymous_namespace{G4INCLDeuteronDensity.cc}::al, fCoutFilter, fCoutTBTextArea, fG4OutputString, FilterOutput(), fLastErrMessage, fMainWindow, fOutputStyles, G4State_Abort, G4State_Quit, G4StateManager::GetStateManager(), GetThreadPrefix(), and G4Threading::IsMasterThread().

Referenced by ReceiveG4cout().

◆ ReceiveG4cerr_()

G4int G4coutDestination::ReceiveG4cerr_ ( const G4String & msg )

inherited

Definition at line 84 of file G4coutDestination.cc.

{
  if(transformersCout.size() > 0)
  {
    G4String m = msg;
    std::for_each(transformersCerr.begin(), transformersCerr.end(),
                  [&m](const Transformer& t) { t(m); }
                  // Call transforming function on message
    );
    return ReceiveG4cerr(m);
  }
  else
  {
    return ReceiveG4cerr(msg);
  }
}

References m, G4coutDestination::ReceiveG4cerr(), G4coutDestination::transformersCerr, and G4coutDestination::transformersCout.

Referenced by G4MasterForwardcoutDestination::ReceiveG4cerr().

◆ 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 (size_t i = 0; i < 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;
}

References G4INCL::DeuteronDensity::anonymous_namespace{G4INCLDeuteronDensity.cc}::al, G4StrUtil::contains(), fCoutFilter, fCoutTBTextArea, fG4OutputString, FilterOutput(), fLastErrMessage, fOutputStyles, GetThreadPrefix(), G4UImanager::GetUIpointer(), G4UImanager::IsLastCommandOutputTreated(), G4Threading::IsMasterThread(), ReceiveG4cerr(), and G4UImanager::SetLastCommandOutputTreated().

◆ ReceiveG4cout_()

G4int G4coutDestination::ReceiveG4cout_ ( const G4String & msg )

inherited

Definition at line 62 of file G4coutDestination.cc.

{
  // Avoid copy of string if not necessary
  if(transformersCout.size() > 0)
  {
    G4String m    = msg;
    G4bool result = true;
    for(const auto& el : transformersCout)
    {
      result &= el(m);
      if(!result)
        break;
    }
    return (result ? ReceiveG4cout(m) : 0);
  }
  else
  {
    return ReceiveG4cout(msg);
  }
}

References m, G4coutDestination::ReceiveG4cout(), and G4coutDestination::transformersCout.

Referenced by G4MasterForwardcoutDestination::ReceiveG4cout().

◆ ResetTransformers()

void G4coutDestination::ResetTransformers ( )

virtualinherited

Definition at line 41 of file G4coutDestination.cc.

{
  transformersCout.clear();
  transformersCerr.clear();
}

References G4coutDestination::transformersCerr, and G4coutDestination::transformersCout.

◆ ResizeTabWidget

void G4UIQt::ResizeTabWidget ( QResizeEvent * e )

privateslot

Send resize event to all tabs

Definition at line 1956 of file G4UIQt.cc.

                                             {
  if ( fViewerTabWidget) {
    for (G4int a=0;a<fViewerTabWidget->count() ;a++) {
      fViewerTabWidget->widget(a)->resize(e->size());
    }
  }
}

References fViewerTabWidget.

◆ SaveIconCallback

void G4UIQt::SaveIconCallback ( const QString & aParam )

privateslot

Definition at line 4678 of file G4UIQt.cc.

                                                   {
 
  QString aCommand = aParam.left(aParam.indexOf(fStringSeparator));
  QString aLabel = aParam.mid(aParam.indexOf(fStringSeparator)+fStringSeparator.length());
 
  QString nomFich = QFileDialog::getSaveFileName(fMainWindow, aLabel, fLastOpenPath, "Macro files (*.mac)");
  if (nomFich != "") {
    G4UImanager::GetUIpointer()->ApplyCommand((QString(aCommand)+ QString(" ")+nomFich).toStdString().c_str());
    QDir dir;
    fLastOpenPath = dir.absoluteFilePath(nomFich);
  }
}

References G4UImanager::ApplyCommand(), fLastOpenPath, fMainWindow, fStringSeparator, and G4UImanager::GetUIpointer().

Referenced by AddIcon().

◆ SaveOutputCallback

void G4UIQt::SaveOutputCallback ( )

privateslot

Definition at line 4188 of file G4UIQt.cc.

                               {
  QString fileName = QFileDialog::getSaveFileName(fMainWindow, "Save console output as...", fLastOpenPath, "Save output as...");
  if (fileName != "") {
 
    QFile data(fileName);
    if (data.open(QFile::WriteOnly | QFile::Truncate)) {
      QTextStream out(&data);
      out << fCoutTBTextArea->toPlainText();
      out.flush();
    }
    data.close();
  }
}

References fCoutTBTextArea, fLastOpenPath, and fMainWindow.

Referenced by CreateCoutTBWidget().

◆ SecondaryLoop()

void G4UIQt::SecondaryLoop ( G4String aPrompt )

private

Begin the secondary loop

Parameters

a_prompt : label to display as the prompt label

Definition at line 2072 of file G4UIQt.cc.

{
  if (!aPrompt) return;
 
  G4Qt* interactorManager = G4Qt::getInstance (); // TO KEEP ?
  Prompt(aPrompt); // TO KEEP
  exitPause = false; // TO KEEP
  while(1) {
    ((QApplication*)interactorManager)->processEvents(QEventLoop::WaitForMoreEvents);
    if(exitPause==true) break; // TO KEEP
  } // TO KEEP
  Prompt("Session :"); // TO KEEP
}

References exitPause, G4Qt::getInstance(), and Prompt().

Referenced by PauseSessionStart().

◆ 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;
}

References G4VInteractorManager::DisableSecondaryLoop(), G4VInteractorManager::EnableSecondaryLoop(), exitSession, fCommandArea, fDefaultIcons, fHistoryTBTableList, FillHelpTree(), fMainWindow, fToolbarApp, G4Qt::getInstance(), G4VInteractorManager::GetMainInteractor(), Prompt(), and UpdateCommandCompleter().

◆ SessionTerminate()

void G4UIQt::SessionTerminate ( )

Definition at line 2032 of file G4UIQt.cc.

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

References g4zmq::exit(), fMainWindow, G4Qt::getInstance(), and G4VInteractorManager::GetMainInteractor().

Referenced by ButtonCallback(), CommandEnteredCallback(), and ExitSession().

◆ SetDefaultIconsToolbar()

void G4UIQt::SetDefaultIconsToolbar ( )

private

Definition at line 320 of file G4UIQt.cc.

  {
 
  if (fDefaultIcons) {
    if (fToolbarApp == NULL) {
      fToolbarApp = new QToolBar();
      fToolbarApp->setIconSize (QSize(20,20));
      fMainWindow->addToolBar(Qt::TopToolBarArea, fToolbarApp);
    }
 
    // Open/Save Icons
    AddIcon("Open macro file","open", "/control/execute");
    AddIcon("Save viewer state", "save", "/vis/viewer/save");
 
    // View parameters
#if QT_VERSION < 0x050600
    QSignalMapper *signalMapperViewerProperties = new QSignalMapper(this);
    QAction *actionViewerProperties = fToolbarApp->addAction(QIcon(*fParamIcon),"Viewer properties", signalMapperViewerProperties, SLOT(map()));
    connect(signalMapperViewerProperties, SIGNAL(mapped(int)),this, SLOT(ViewerPropertiesIconCallback(int)));
    int intVP = 0;
    signalMapperViewerProperties->setMapping(actionViewerProperties, intVP);
#else
    fToolbarApp->addAction(QIcon(*fParamIcon),"Viewer properties", this, [this](){ this->ViewerPropertiesIconCallback(0); });
#endif
 
    // Cursors style icons
    AddIcon("Move", "move", "");
    AddIcon("Pick", "pick", "");
    AddIcon("Zoom out", "zoom_out", "");
    AddIcon("Zoom in", "zoom_in", "");
    AddIcon("Rotate", "rotate", "");
 
    // Surface Style icons
    AddIcon("Hidden line removal", "hidden_line_removal", "");
    AddIcon("Hidden line and hidden surface removal", "hidden_line_and_surface_removal", "");
    AddIcon("Surfaces", "solid", "");
    AddIcon("Wireframe", "wireframe", "");
 
            // Perspective/Ortho icons
    AddIcon("Perspective", "perspective","");
    AddIcon("Orthographic", "ortho","");
    AddIcon("Run beam on", "runBeamOn","/run/beamOn 1");
    AddIcon("Exit Application", "exit","exit");
  }
}

References AddIcon(), g4zmq::connect(), fDefaultIcons, fMainWindow, fParamIcon, fToolbarApp, anonymous_namespace{G4QuasiElRatios.cc}::map, and ViewerPropertiesIconCallback().

Referenced by G4UIQt().

◆ 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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fToolbarApp, fToolbarUser, and TRUE.

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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fToolbarApp, fToolbarUser, and TRUE.

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 (int 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);
    }
  }
}

References FALSE, fMoveSelected, fPickSelected, fRotateSelected, fToolbarApp, fZoomInSelected, fZoomOutSelected, and TRUE.

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

◆ 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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fToolbarApp, fToolbarUser, and TRUE.

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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fToolbarApp, fToolbarUser, and TRUE.

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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fMoveSelected, fPickSelected, fRotateSelected, fToolbarApp, fToolbarUser, fZoomInSelected, fZoomOutSelected, and TRUE.

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

◆ 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 (int 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);
    }
  }
}

References FALSE, fMoveSelected, fPickSelected, fRotateSelected, fToolbarApp, fZoomInSelected, fZoomOutSelected, and TRUE.

Referenced by AddIcon(), G4OpenGLQtViewer::toggleMouseAction(), and G4OpenGLQtViewer::togglePicking().

◆ 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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fToolbarApp, fToolbarUser, and TRUE.

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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fToolbarApp, fToolbarUser, and TRUE.

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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fMoveSelected, fPickSelected, fRotateSelected, fToolbarApp, fToolbarUser, fZoomInSelected, fZoomOutSelected, and TRUE.

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

◆ 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 (int 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);
    }
  }
}

References bar, FALSE, fDefaultIcons, fMoveSelected, fPickSelected, fRotateSelected, fToolbarApp, fToolbarUser, fZoomInSelected, fZoomOutSelected, and TRUE.

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

◆ 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());
}

References fDefaultViewerFirstPageHTMLText, and fStartPage.

Referenced by CreateViewerWidget().

◆ ShowCurrent()

void G4VBasicShell::ShowCurrent ( const G4String & newCommand ) const

protectedinherited

Definition at line 313 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4String comString = newCommand.substr(1,newCommand.length()-1);
  G4String theCommand = ModifyToFullPathCommand(comString);
  G4String curV = UI->GetCurrentValues(theCommand);
  if( ! curV.empty() ) {
    G4cout << "Current value(s) of the parameter(s) : " << curV << G4endl;
  }
}

References G4cout, G4endl, G4UImanager::GetCurrentValues(), G4UImanager::GetUIpointer(), and G4VBasicShell::ModifyToFullPathCommand().

Referenced by G4VBasicShell::ApplyShellCommand(), G4UIterminal::GetCommand(), and G4ZMQServer::GetCommand().

◆ ShowHelpCallback

void G4UIQt::ShowHelpCallback ( )

privateslot

Called when user give "help" command.

Definition at line 3868 of file G4UIQt.cc.

{
  TerminalHelp("");
}

References G4VBasicShell::TerminalHelp().

◆ TabCloseCallback

void G4UIQt::TabCloseCallback ( int )

privateslot

Definition at line 5145 of file G4UIQt.cc.

                                {
#else
void G4UIQt::TabCloseCallback(int a){
#endif
#if QT_VERSION < 0x040500
#else
  if (fViewerTabWidget == NULL) return;
 
  // get the address of the widget
  QWidget* temp = fViewerTabWidget->widget(a);
  // remove the tab
  fViewerTabWidget->removeTab (a);
 
  // if last QWidget : Add empty string
  bool lastTab = true;
  for (int c=0; c<fViewerTabWidget->count(); c++) {
    if (fViewerTabWidget->tabText(c).contains("viewer")) {
      lastTab = false;
    }
  }
 
  if (lastTab) {
    CreateEmptyViewerPropertiesWidget();
  }
  // delete the widget
  delete temp;
#endif
}

References CreateEmptyViewerPropertiesWidget(), fViewerTabWidget, and TabCloseCallback().

Referenced by CreateViewerWidget(), and TabCloseCallback().

◆ TerminalHelp()

void G4VBasicShell::TerminalHelp ( const G4String & newCommand )

protectedinherited

Definition at line 355 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4UIcommandTree * treeTop = UI->GetTree();
  size_t i = newCommand.find(" ");
  if( i != std::string::npos )
  {
    G4String newValue = newCommand.substr(i+1, newCommand.length()-(i+1));
    G4StrUtil::strip(newValue);
    G4String targetCom = ModifyToFullPathCommand(newValue);
    G4UIcommand* theCommand = treeTop->FindPath(targetCom);
    if( theCommand != NULL )
    {
      theCommand->List();
      return;
    }
    else
    {
      G4cout << "Command <" << newValue << " is not found." << G4endl;
      return;
    }
  }
 
  G4UIcommandTree * floor[10];
  floor[0] = treeTop;
  size_t iFloor = 0;
  size_t prefixIndex = 1;
  G4String prefix = GetCurrentWorkingDirectory();
  while( prefixIndex < prefix.length()-1 )
  {
    size_t ii = prefix.find("/",prefixIndex);
    floor[iFloor+1] =
      floor[iFloor]->GetTree(G4String(prefix.substr(0,ii+1)));
    prefixIndex = ii+1;
    iFloor++;
  }
  floor[iFloor]->ListCurrentWithNum();
  // 1998 Oct 2 non-number input
  while(1){
   //G4cout << G4endl << "Type the number ( 0:end, -n:n level back ) : "<<std::flush;
    G4cout << G4endl << "Type the number ( 0:end, -n:n level back ) : "<<G4endl;
    G4int j;
    if(!GetHelpChoice(j)){
      G4cout << G4endl << "Not a number, once more" << G4endl;
      continue;
    } else if( j < 0 ){
      if( iFloor < (size_t)-j ) iFloor = 0;
      else iFloor += j;
      //iFloor += j;
      //if( iFloor < 0 ) iFloor = 0;
      floor[iFloor]->ListCurrentWithNum();
      continue;
    } else if(j == 0) {
      break;
    } else if( j > 0 ) {
      G4int n_tree = floor[iFloor]->GetTreeEntry();
      if( j > n_tree )
      {
        if( j <= n_tree + floor[iFloor]->GetCommandEntry() )
        {
          floor[iFloor]->GetCommand(j-n_tree)->List();
        }
      }
      else
      {
        floor[iFloor+1] = floor[iFloor]->GetTree(j);
        iFloor++;
        floor[iFloor]->ListCurrentWithNum();
      }
    }
  }
  G4cout << "Exit from HELP." << G4endl << G4endl;
  //G4cout << G4endl;
  ExitHelp();
}

References G4VBasicShell::ExitHelp(), G4UIcommandTree::FindPath(), G4cout, G4endl, G4UIcommandTree::GetCommand(), G4VBasicShell::GetCurrentWorkingDirectory(), G4VBasicShell::GetHelpChoice(), G4UImanager::GetTree(), G4UIcommandTree::GetTree(), G4UIcommandTree::GetTreeEntry(), G4UImanager::GetUIpointer(), G4UIcommand::List(), G4UIcommandTree::ListCurrentWithNum(), G4VBasicShell::ModifyToFullPathCommand(), and G4StrUtil::strip().

Referenced by G4VBasicShell::ApplyShellCommand(), G4UIterminal::GetCommand(), G4ZMQServer::GetCommand(), and ShowHelpCallback().

◆ ThreadComboBoxCallback

void G4UIQt::ThreadComboBoxCallback ( int )

privateslot

Definition at line 4172 of file G4UIQt.cc.

                                       {
  CoutFilterCallback("");
}

References CoutFilterCallback().

Referenced by CreateCoutTBWidget().

◆ ToolBoxActivated

void G4UIQt::ToolBoxActivated ( int a )

privateslot

Definition at line 5175 of file G4UIQt.cc.

                                  {
 
  if (fUITabWidget->widget(a) == fHelpTBWidget) {
    // Rebuild the help tree
    FillHelpTree();
  } else if (fUITabWidget->widget(a) == fSceneTreeWidget) {
#if QT_VERSION < 0x040200
    fSceneTreeWidget->show();
#else
    fSceneTreeWidget->setVisible(true);
#endif
  }
}

References fHelpTBWidget, FillHelpTree(), fSceneTreeWidget, and fUITabWidget.

Referenced by CreateUITabWidget().

◆ UpdateCommandCompleter()

void G4UIQt::UpdateCommandCompleter ( )

private

Definition at line 3685 of file G4UIQt.cc.

                                    {
  if (!fCommandArea) return;
 
  // remove previous one
  fCommandArea->setCompleter(NULL);
  if (fCompleter) {
    if (fCompleter->popup()) {
      fCompleter->popup()->removeEventFilter(this);
    }
  }
 
  QStandardItemModel* model = CreateCompleterModel("/");
  fCompleter = new QCompleter(model);
 
  // set all dir visibles in completion
  G4UImanager* UI = G4UImanager::GetUIpointer();
  G4UIcommandTree * commandTreeTop = UI->GetTree();
  G4UIcommandTree* aTree = commandTreeTop->FindCommandTree("/");
  if (aTree) {
    int Ndir= aTree-> GetTreeEntry();
    fCompleter->setMaxVisibleItems(Ndir);
  }
  fCommandArea->setCompleter(fCompleter);
  fCompleter->popup()->installEventFilter(this);
}

References CreateCompleterModel(), fCommandArea, fCompleter, G4UIcommandTree::FindCommandTree(), G4UImanager::GetTree(), and G4UImanager::GetUIpointer().

Referenced by CommandEnteredCallback(), and SessionStart().

◆ updateHelpArea()

void G4UIQt::updateHelpArea ( const G4UIcommand * aCommand )

private

Build the command list parameters in a QString with HTML
Reimplement partialy the G4UIparameter.cc

Parameters

aCommand : command to list parameters

See also: G4UIparameter::List(); G4UIcommand::List()

Returns: the command list parameters, or "" if nothing

Definition at line 3390 of file G4UIQt.cc.

{
  if (!fParameterHelpLabel)
    return;
  if (!fParameterHelpTable)
    return;
 
  fParameterHelpLabel->setTextInteractionFlags(Qt::NoTextInteraction);
  QString txt;
  if (aCommand == NULL)
    return;
 
  G4String commandPath = aCommand->GetCommandPath();
  G4String rangeString = aCommand->GetRange();
  G4int n_guidanceEntry = aCommand->GetGuidanceEntries();
  G4int n_parameterEntry = aCommand->GetParameterEntries();
 
  if ((commandPath == "") &&
      (rangeString == "") &&
      (n_guidanceEntry == 0) &&
      (n_parameterEntry == 0)) {
    return;
  }
 
  if((commandPath.length()-1)!='/') {
    txt += "<b>Command </b> " + QString((char*)(commandPath).data()) + "<br />";
  }
  txt += "<b>Guidance :</b> ";
  QString tmpGuidance = "";
  for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ ) {
    tmpGuidance = QString((char*)(aCommand->GetGuidanceLine(i_thGuidance)).data());
#if QT_VERSION < 0x050000
      tmpGuidance = Qt::escape(tmpGuidance);
#else
      tmpGuidance = tmpGuidance.toHtmlEscaped();
#endif
      tmpGuidance.replace("\n","<br />");
    txt += tmpGuidance + "<br />";
  }
  if( ! rangeString.empty() ) {
      QString range = QString((char*)(rangeString).data());
#if QT_VERSION < 0x050000
      range = Qt::escape(range);
#else
      range = range.toHtmlEscaped();
#endif
 
      txt += "<b>Range of parameters : </b> " + range + "<br />";
  } else {
    txt += "<br />";
  }
  fParameterHelpLabel->setHtml(txt);
 
  if( n_parameterEntry > 0 ) {
    G4UIparameter *param;
 
    // Re-implementation of G4UIparameter.cc
 
    fParameterHelpTable->clear();
    fParameterHelpTable->setRowCount(n_parameterEntry);
    fParameterHelpTable->setColumnCount(8);
    fParameterHelpTable->setHorizontalHeaderLabels(QStringList() <<
                                                   tr("") <<
                                                   tr("Parameter") <<
                                                   tr("Guidance") <<
                                                   tr("Type") <<
                                                   tr("Ommitable") <<
                                                   tr("Default") <<
                                                   tr("Range") <<
                                                   tr("Candidate"));
    fParameterHelpTable->setColumnWidth(2,60);
 
    fParameterHelpTable->verticalHeader()->setVisible(false);
    fParameterHelpTable->setAlternatingRowColors (true);
#if QT_VERSION < 0x050000
    fParameterHelpTable->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
    fParameterHelpTable->horizontalHeader()->setResizeMode(2, QHeaderView::Stretch);
#else
    fParameterHelpTable->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    fParameterHelpTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Stretch);
#endif
    fParameterHelpTable->setWordWrap(true);
 
    QTableWidgetItem* t = fParameterHelpTable->horizontalHeaderItem(1);
    QFont fnt = t->font();
    int size = fnt.pointSize();
    fnt.setPointSize(size-2);
 
    for( G4int a=0; a<n_parameterEntry; a++ ) {
      param = aCommand->GetParameter(a);
      fParameterHelpTable->setItem(a, 0, new QTableWidgetItem(QString::number(a+1)));
 
      fParameterHelpTable->setItem(a, 1, new QTableWidgetItem(QString((char*)(param->GetParameterName()).data())));
      if( ! param->GetParameterGuidance().empty() ) {
        fParameterHelpTable->setItem(a, 2, new QTableWidgetItem(QString((char*)(param->GetParameterGuidance()).data())));
      }
      fParameterHelpTable->setItem(a, 3, new QTableWidgetItem(QString(QChar(param->GetParameterType()))));
 
      if(param->IsOmittable()){
        fParameterHelpTable->setItem(a, 4, new QTableWidgetItem(QString("True")));
      } else {
        fParameterHelpTable->setItem(a, 4, new QTableWidgetItem(QString("False")));
      }
      if( param->GetCurrentAsDefault() ) {
        fParameterHelpTable->setItem(a, 5, new QTableWidgetItem(QString("taken from the current value")));
      } else if( ! param->GetDefaultValue().empty() ) {
        fParameterHelpTable->setItem(a, 5, new QTableWidgetItem(QString((char*)(param->GetDefaultValue()).data())));
      }
      if( ! param->GetParameterRange().empty() ) {
        fParameterHelpTable->setItem(a, 6, new QTableWidgetItem(QString((char*)(param->GetParameterRange()).data())));
      }
      if( ! param->GetParameterCandidates().empty() ) {
        fParameterHelpTable->setItem(a, 7, new QTableWidgetItem(QString((char*)(param->GetParameterCandidates()).data())));
      }
      // tooltips
      for (int b=0; b<8; b++) {
        QTableWidgetItem* tmp = fParameterHelpTable->item(a,b);
        if (tmp) {
          tmp->setToolTip(tmp->text());
          tmp->setFlags(Qt::NoItemFlags);
        }
      }
      fParameterHelpTable->resizeRowToContents(a);
    }
    for (int c=0; c<8; c++) {
      if (c !=2) {
        fParameterHelpTable->resizeColumnToContents(c);
      }
    }
    fParameterHelpLabel->setVisible(true);
    fParameterHelpTable->setVisible(true);
 
  }
}

References fParameterHelpLabel, fParameterHelpTable, G4UIcommand::GetCommandPath(), G4UIparameter::GetCurrentAsDefault(), G4UIparameter::GetDefaultValue(), G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), G4UIcommand::GetParameter(), G4UIparameter::GetParameterCandidates(), G4UIcommand::GetParameterEntries(), G4UIparameter::GetParameterGuidance(), G4UIparameter::GetParameterName(), G4UIparameter::GetParameterRange(), G4UIparameter::GetParameterType(), G4UIcommand::GetRange(), and G4UIparameter::IsOmittable().

Referenced by HelpTreeClicCallback().

◆ UpdateTabWidget

void G4UIQt::UpdateTabWidget ( int tabNumber )

privateslot

Definition at line 1933 of file G4UIQt.cc.

                                          {
  if ( fViewerTabWidget == NULL) {
    fViewerTabWidget = new G4QTabWidget;
  }
 
  fViewerTabWidget->setCurrentIndex(tabNumber);
 
  // Send this signal to unblock graphic updates !
  fViewerTabWidget->setTabSelected(false);
 
 #if QT_VERSION < 0x040200
  fViewerTabWidget->show();
 #else
  fViewerTabWidget->setVisible(true);
 #endif
 
  // This will send a paintEvent to OGL Viewers
  fViewerTabWidget->setTabSelected(true);
}

References fViewerTabWidget, and G4QTabWidget::setTabSelected().

Referenced by CreateViewerWidget().

◆ ViewerPropertiesIconCallback

void G4UIQt::ViewerPropertiesIconCallback ( int )

privateslot

Definition at line 4779 of file G4UIQt.cc.

                                             {
 
  CreateViewerPropertiesDialog();
 
  fViewerPropertiesDialog->show();
  fViewerPropertiesDialog->raise();
  fViewerPropertiesDialog->activateWindow();
}

References CreateViewerPropertiesDialog(), and fViewerPropertiesDialog.

Referenced by SetDefaultIconsToolbar().

◆ VisParameterCallback

void G4UIQt::VisParameterCallback ( QWidget * widget )

privateslot

Callback when one of the scene/vis parameters has changed

Definition at line 3977 of file G4UIQt.cc.

                                                {
  if (widget == NULL) {
    return;
  }
 
  // Look in all the Grid layout, but only column 1 (0 is the parameter name)
  QGridLayout* grid = dynamic_cast<QGridLayout*>(widget->layout());
  if (grid == 0) {
    return;
  }
  QString command;
#if QT_VERSION < 0x040400
  QWidget* name = grid->itemAt(grid->columnCount()*(grid->rowCount()-2))->widget();
#else
  QWidget* name = grid->itemAtPosition(grid->rowCount()-1,0)->widget();
#endif
  if (dynamic_cast<QLabel*>(name) == 0) {
    return;
  }
  command += (dynamic_cast<QLabel*>(name))->text()+" ";
 
  for (int a=0;a<grid->rowCount()-1; a++) {
#if QT_VERSION < 0x040400
    QWidget* widgetTmp = grid->itemAt(a*grid->columnCount()+1)->widget();
#else
    QWidget* widgetTmp = grid->itemAtPosition(a,1)->widget();
#endif
 
    // 4 kind of widgets : QLineEdit / QComboBox / radioButtonsGroup / QPushButton (color chooser)
    if (widgetTmp != NULL) {
 
      if (dynamic_cast<QLineEdit*>(widgetTmp) != 0) {
        command += (dynamic_cast<QLineEdit*>(widgetTmp))->text()+" ";
 
      } else if (dynamic_cast<QComboBox*>(widgetTmp) != 0){
        command += (dynamic_cast<QComboBox*>(widgetTmp))->itemText((dynamic_cast<QComboBox*>(widgetTmp))->currentIndex())+" ";
 
        // Color chooser
      } else if (dynamic_cast<QPushButton*>(widgetTmp) != 0){
        command += widgetTmp->accessibleName()+" ";
 
        // Check for Button group
      } else if (dynamic_cast<QWidget*>(widgetTmp) != 0){
        if (widgetTmp->layout()->count() > 0){
          if (dynamic_cast<QRadioButton*>(widgetTmp->layout()->itemAt(0)->widget()) != 0) {
            QAbstractButton * checked = (dynamic_cast<QRadioButton*>(widgetTmp->layout()->itemAt(0)->widget()))->group()->checkedButton();
            if (checked != 0) {
              command += (dynamic_cast<QRadioButton*>(widgetTmp->layout()->itemAt(0)->widget()))->group()->checkedButton()->text()+" ";
            }
          }
        }
 
      }
    }
  }
  if (command != "") {
    G4UImanager* UI = G4UImanager::GetUIpointer();
    if(UI != NULL)  {
      UI->ApplyCommand(command.toStdString().c_str());
    }
  }
}

References G4UImanager::ApplyCommand(), G4UImanager::GetUIpointer(), and G4InuclParticleNames::name().

Referenced by CreateCommandWidget().

Field Documentation

◆ currentDirectory

G4String G4VBasicShell::currentDirectory

privateinherited

Definition at line 101 of file G4VBasicShell.hh.

Referenced by G4VBasicShell::ChangeDirectory(), G4VBasicShell::GetCurrentWorkingDirectory(), and G4VBasicShell::ModifyPath().

◆ fClearIcon

QPixmap* G4UIQt::fClearIcon

private

Definition at line 356 of file G4UIQt.hh.

Referenced by CreateCoutTBWidget(), CreateIcons(), and getClearIcon().

◆ fCommandArea

QLineEdit* G4UIQt::fCommandArea

private

Definition at line 322 of file G4UIQt.hh.

Referenced by CommandEditedCallback(), CommandEnteredCallback(), CommandHistoryCallback(), CreateCoutTBWidget(), eventFilter(), G4UIQt(), HelpTreeDoubleClicCallback(), SessionStart(), and UpdateCommandCompleter().

◆ fCommandIcon

QPixmap* G4UIQt::fCommandIcon

private

Definition at line 370 of file G4UIQt.hh.

Referenced by CreateCompleterModel(), and CreateIcons().

◆ fCommandLabel

QLabel* G4UIQt::fCommandLabel

private

Definition at line 321 of file G4UIQt.hh.

Referenced by CreateCoutTBWidget(), and Prompt().

◆ fCompleter

QCompleter* G4UIQt::fCompleter

private

Definition at line 327 of file G4UIQt.hh.

Referenced by eventFilter(), and UpdateCommandCompleter().

◆ fCoutDockWidget

G4UIDockWidget* G4UIQt::fCoutDockWidget

private

Definition at line 334 of file G4UIQt.hh.

Referenced by CreateCoutTBWidget(), G4UIQt(), GetCoutDockWidget(), and GetCoutWidget().

◆ fCoutFilter

QLineEdit* G4UIQt::fCoutFilter

private

Definition at line 326 of file G4UIQt.hh.

Referenced by CreateCoutTBWidget(), FilterAllOutputTextArea(), ReceiveG4cerr(), and ReceiveG4cout().

◆ fCoutTBTextArea

QTextEdit* G4UIQt::fCoutTBTextArea

private

Definition at line 323 of file G4UIQt.hh.

Referenced by ClearButtonCallback(), CoutFilterCallback(), CreateCoutTBWidget(), FilterAllOutputTextArea(), ReceiveG4cerr(), ReceiveG4cout(), and SaveOutputCallback().

◆ fCoutText

QString G4UIQt::fCoutText

private

Definition at line 341 of file G4UIQt.hh.

◆ fDefaultIcons

bool G4UIQt::fDefaultIcons

private

Definition at line 328 of file G4UIQt.hh.

Referenced by AddIcon(), DefaultIcons(), SessionStart(), SetDefaultIconsToolbar(), SetIconHLHSRSelected(), SetIconHLRSelected(), SetIconOrthoSelected(), SetIconPerspectiveSelected(), SetIconPickSelected(), SetIconSolidSelected(), SetIconWireframeSelected(), SetIconZoomInSelected(), and SetIconZoomOutSelected().

◆ fDefaultViewerFirstPageHTMLText

std::string G4UIQt::fDefaultViewerFirstPageHTMLText

private

Definition at line 380 of file G4UIQt.hh.

Referenced by SetStartPage().

◆ fDirIcon

QPixmap* G4UIQt::fDirIcon

private

Definition at line 371 of file G4UIQt.hh.

Referenced by CreateCompleterModel(), and CreateIcons().

◆ fExitIcon

QPixmap* G4UIQt::fExitIcon

private

Definition at line 375 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fG4OutputString

std::vector<G4UIOutputString> G4UIQt::fG4OutputString

private

Definition at line 325 of file G4UIQt.hh.

Referenced by ClearButtonCallback(), FilterAllOutputTextArea(), ReceiveG4cerr(), and ReceiveG4cout().

◆ fHelpLine

QLineEdit* G4UIQt::fHelpLine

private

Definition at line 339 of file G4UIQt.hh.

Referenced by CreateHelpTBWidget(), FillHelpTree(), and LookForHelpStringCallback().

◆ fHelpTBWidget

QWidget* G4UIQt::fHelpTBWidget

private

Definition at line 332 of file G4UIQt.hh.

Referenced by ActivateCommand(), CreateHelpTBWidget(), CreateUITabWidget(), GetHelpWidget(), and ToolBoxActivated().

◆ fHelpTreeWidget

QTreeWidget* G4UIQt::fHelpTreeWidget

private

Definition at line 331 of file G4UIQt.hh.

Referenced by ActivateCommand(), CreateHelpTBWidget(), CreateHelpTree(), FillHelpTree(), HelpTreeClicCallback(), HelpTreeDoubleClicCallback(), InitHelpTreeAndVisParametersWidget(), LookForHelpStringCallback(), and OpenHelpTreeOnCommand().

◆ fHelpVSplitter

QSplitter* G4UIQt::fHelpVSplitter

private

Definition at line 343 of file G4UIQt.hh.

Referenced by CreateHelpTBWidget().

◆ fHiddenLineAndSurfaceRemovalIcon

QPixmap* G4UIQt::fHiddenLineAndSurfaceRemovalIcon

private

Definition at line 367 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fHiddenLineRemovalIcon

QPixmap* G4UIQt::fHiddenLineRemovalIcon

private

Definition at line 366 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fHistoryTBTableList

QListWidget* G4UIQt::fHistoryTBTableList

private

Definition at line 330 of file G4UIQt.hh.

Referenced by CommandEnteredCallback(), CommandHistoryCallback(), CreateHistoryTBWidget(), eventFilter(), and SessionStart().

◆ fHistoryTBWidget

QWidget* G4UIQt::fHistoryTBWidget

private

Definition at line 333 of file G4UIQt.hh.

Referenced by CreateHistoryTBWidget(), and GetHistoryWidget().

◆ fLastCompleteCommand

QString G4UIQt::fLastCompleteCommand

private

Definition at line 384 of file G4UIQt.hh.

Referenced by eventFilter().

◆ fLastErrMessage

G4String G4UIQt::fLastErrMessage

private

Definition at line 350 of file G4UIQt.hh.

Referenced by ReceiveG4cerr(), and ReceiveG4cout().

◆ fLastOpenPath

QString G4UIQt::fLastOpenPath

private

Definition at line 351 of file G4UIQt.hh.

Referenced by OpenIconCallback(), SaveIconCallback(), and SaveOutputCallback().

◆ fMainWindow

QMainWindow* G4UIQt::fMainWindow

private

Definition at line 320 of file G4UIQt.hh.

Referenced by AddIcon(), AddMenu(), AddTabWidget(), ClearMenu(), CreateViewerWidget(), DefaultIcons(), G4UIQt(), GetMainWindow(), NativeMenu(), OpenIconCallback(), ReceiveG4cerr(), SaveIconCallback(), SaveOutputCallback(), SessionStart(), SessionTerminate(), and SetDefaultIconsToolbar().

◆ fMoveIcon

QPixmap* G4UIQt::fMoveIcon

private

Definition at line 359 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fMoveSelected

bool G4UIQt::fMoveSelected

private

Definition at line 385 of file G4UIQt.hh.

Referenced by ChangeCursorAction(), IsIconMoveSelected(), SetIconMoveSelected(), SetIconPickSelected(), SetIconRotateSelected(), SetIconZoomInSelected(), and SetIconZoomOutSelected().

◆ fOpenIcon

QPixmap* G4UIQt::fOpenIcon

private

Definition at line 358 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fOrthoIcon

QPixmap* G4UIQt::fOrthoIcon

private

Definition at line 369 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fOutputStyles

std::map<G4String,G4UIQtStyle> G4UIQt::fOutputStyles

private

Definition at line 393 of file G4UIQt.hh.

Referenced by G4UIQt(), OutputStyle(), ReceiveG4cerr(), and ReceiveG4cout().

◆ fParameterHelpLabel

QTextEdit* G4UIQt::fParameterHelpLabel

private

Definition at line 344 of file G4UIQt.hh.

Referenced by CreateHelpTBWidget(), FillHelpTree(), HelpTreeClicCallback(), LookForHelpStringCallback(), OpenHelpTreeOnCommand(), and updateHelpArea().

◆ fParameterHelpTable

QTableWidget* G4UIQt::fParameterHelpTable

private

Definition at line 345 of file G4UIQt.hh.

Referenced by CreateHelpTBWidget(), FillHelpTree(), HelpTreeClicCallback(), LookForHelpStringCallback(), OpenHelpTreeOnCommand(), and updateHelpArea().

◆ fParamIcon

QPixmap* G4UIQt::fParamIcon

private

Definition at line 373 of file G4UIQt.hh.

Referenced by CreateIcons(), and SetDefaultIconsToolbar().

◆ fPerspectiveIcon

QPixmap* G4UIQt::fPerspectiveIcon

private

Definition at line 368 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fPickIcon

QPixmap* G4UIQt::fPickIcon

private

Definition at line 361 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fPickInfosDialog

QDialog* G4UIQt::fPickInfosDialog

private

Definition at line 383 of file G4UIQt.hh.

Referenced by ChangeCursorAction(), CreateEmptyPickInfosWidget(), CreatePickInfosDialog(), and GetPickInfosWidget().

◆ fPickInfosWidget

QWidget* G4UIQt::fPickInfosWidget

private

Definition at line 338 of file G4UIQt.hh.

Referenced by CreateEmptyPickInfosWidget(), CreatePickInfosDialog(), and GetPickInfosWidget().

◆ fPickSelected

bool G4UIQt::fPickSelected

private

Definition at line 387 of file G4UIQt.hh.

Referenced by ChangeCursorAction(), IsIconPickSelected(), SetIconMoveSelected(), SetIconPickSelected(), SetIconRotateSelected(), SetIconZoomInSelected(), and SetIconZoomOutSelected().

◆ fPickTargetIcon

QPixmap* G4UIQt::fPickTargetIcon

private

Definition at line 374 of file G4UIQt.hh.

◆ fRotateIcon

QPixmap* G4UIQt::fRotateIcon

private

Definition at line 360 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fRotateSelected

bool G4UIQt::fRotateSelected

private

Definition at line 386 of file G4UIQt.hh.

Referenced by ChangeCursorAction(), IsIconRotateSelected(), SetIconMoveSelected(), SetIconPickSelected(), SetIconRotateSelected(), SetIconZoomInSelected(), and SetIconZoomOutSelected().

◆ fRunIcon

QPixmap* G4UIQt::fRunIcon

private

Definition at line 372 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fSaveIcon

QPixmap* G4UIQt::fSaveIcon

private

Definition at line 357 of file G4UIQt.hh.

Referenced by AddIcon(), CreateCoutTBWidget(), and CreateIcons().

◆ fSceneTreeWidget

QWidget* G4UIQt::fSceneTreeWidget

private

Definition at line 336 of file G4UIQt.hh.

Referenced by CreateSceneTreeWidget(), GetSceneTreeWidget(), and ToolBoxActivated().

◆ fSearchIcon

QPixmap* G4UIQt::fSearchIcon

private

Definition at line 355 of file G4UIQt.hh.

Referenced by CreateCoutTBWidget(), CreateIcons(), and getSearchIcon().

◆ fSolidIcon

QPixmap* G4UIQt::fSolidIcon

private

Definition at line 365 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fStartPage

QTextBrowser* G4UIQt::fStartPage

private

Definition at line 342 of file G4UIQt.hh.

Referenced by G4UIQt(), and SetStartPage().

◆ fStringSeparator

QString G4UIQt::fStringSeparator

private

Definition at line 349 of file G4UIQt.hh.

Referenced by AddIcon(), OpenIconCallback(), and SaveIconCallback().

◆ fSurfaceModePopupButton

QToolButton* G4UIQt::fSurfaceModePopupButton

private

Definition at line 353 of file G4UIQt.hh.

◆ fToolbarApp

QToolBar* G4UIQt::fToolbarApp

private

◆ fToolbarUser

QToolBar* G4UIQt::fToolbarUser

private

Definition at line 348 of file G4UIQt.hh.

Referenced by AddIcon(), SetIconHLHSRSelected(), SetIconHLRSelected(), SetIconOrthoSelected(), SetIconPerspectiveSelected(), SetIconPickSelected(), SetIconSolidSelected(), SetIconWireframeSelected(), SetIconZoomInSelected(), and SetIconZoomOutSelected().

◆ fUIDockWidget

G4UIDockWidget* G4UIQt::fUIDockWidget

private

Definition at line 335 of file G4UIQt.hh.

Referenced by CreateUITabWidget(), G4UIQt(), and GetUserInterfaceWidget().

◆ fUITabWidget

QTabWidget* G4UIQt::fUITabWidget

private

Definition at line 324 of file G4UIQt.hh.

Referenced by ActivateCommand(), ChangeColorCallback(), CreateUITabWidget(), GetUITabWidget(), and ToolBoxActivated().

◆ fViewerPropertiesDialog

QDialog* G4UIQt::fViewerPropertiesDialog

private

Definition at line 382 of file G4UIQt.hh.

Referenced by CreateEmptyViewerPropertiesWidget(), CreateViewerPropertiesDialog(), GetViewerPropertiesWidget(), and ViewerPropertiesIconCallback().

◆ fViewerPropertiesWidget

QWidget* G4UIQt::fViewerPropertiesWidget

private

Definition at line 337 of file G4UIQt.hh.

Referenced by CreateEmptyViewerPropertiesWidget(), CreateViewerPropertiesDialog(), and GetViewerPropertiesWidget().

◆ fViewerTabWidget

G4QTabWidget* G4UIQt::fViewerTabWidget

private

Definition at line 340 of file G4UIQt.hh.

Referenced by AddTabWidget(), AddViewerTab(), AddViewerTabFromFile(), CreateViewerWidget(), GetViewerTabWidget(), ResizeTabWidget(), TabCloseCallback(), and UpdateTabWidget().

◆ fViewModePopupButton

QToolButton* G4UIQt::fViewModePopupButton

private

Definition at line 352 of file G4UIQt.hh.

◆ fWireframeIcon

QPixmap* G4UIQt::fWireframeIcon

private

Definition at line 364 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fZoomInIcon

QPixmap* G4UIQt::fZoomInIcon

private

Definition at line 362 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fZoomInSelected

bool G4UIQt::fZoomInSelected

private

Definition at line 388 of file G4UIQt.hh.

Referenced by ChangeCursorAction(), IsIconZoomInSelected(), SetIconMoveSelected(), SetIconPickSelected(), SetIconRotateSelected(), SetIconZoomInSelected(), and SetIconZoomOutSelected().

◆ fZoomOutIcon

QPixmap* G4UIQt::fZoomOutIcon

private

Definition at line 363 of file G4UIQt.hh.

Referenced by AddIcon(), and CreateIcons().

◆ fZoomOutSelected

bool G4UIQt::fZoomOutSelected

private

Definition at line 389 of file G4UIQt.hh.

Referenced by ChangeCursorAction(), IsIconZoomOutSelected(), SetIconMoveSelected(), SetIconPickSelected(), SetIconRotateSelected(), SetIconZoomInSelected(), and SetIconZoomOutSelected().

◆ ifBatch

G4int G4UIsession::ifBatch = 0

protectedinherited

Definition at line 68 of file G4UIsession.hh.

Referenced by G4UIsession::~G4UIsession().

◆ inSession

G4int G4UIsession::inSession = 0

staticprotectedinherited

Definition at line 67 of file G4UIsession.hh.

Referenced by G4UIsession::G4UIsession(), G4UIsession::InSession(), and G4UIsession::~G4UIsession().

◆ interactors

G4interactor_map G4VInteractiveSession::interactors

privateinherited

Definition at line 64 of file G4VInteractiveSession.hh.

Referenced by G4VInteractiveSession::AddInteractor(), and G4VInteractiveSession::GetInteractor().

◆ lastRC

G4int G4UIsession::lastRC = 0

protectedinherited

Definition at line 69 of file G4UIsession.hh.

Referenced by G4UIbatch::G4UIbatch(), G4UIsession::GetLastReturnCode(), and G4UIbatch::SessionStart().

◆ masterG4coutDestination

G4coutDestination * G4coutDestination::masterG4coutDestination = nullptr

staticprotectedinherited

Definition at line 88 of file G4coutDestination.hh.

Referenced by G4UIQt(), G4MasterForwardcoutDestination::ReceiveG4cerr(), G4MasterForwardcoutDestination::ReceiveG4cout(), and ~G4UIQt().

◆ messenger

G4UImessenger* G4VInteractiveSession::messenger

privateinherited

Definition at line 62 of file G4VInteractiveSession.hh.

Referenced by G4VInteractiveSession::G4VInteractiveSession(), and G4VInteractiveSession::~G4VInteractiveSession().

◆ transformersCerr

std::vector<Transformer> G4coutDestination::transformersCerr

protectedinherited

Definition at line 94 of file G4coutDestination.hh.

Referenced by G4coutDestination::AddCerrTransformer(), G4coutDestination::ReceiveG4cerr_(), and G4coutDestination::ResetTransformers().

◆ transformersCout

std::vector<Transformer> G4coutDestination::transformersCout

protectedinherited

Definition at line 93 of file G4coutDestination.hh.

Referenced by G4coutDestination::AddCoutTransformer(), G4coutDestination::ReceiveG4cerr_(), G4coutDestination::ReceiveG4cout_(), and G4coutDestination::ResetTransformers().

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

source/interfaces/basic/include/G4UIQt.hh
source/interfaces/basic/src/G4UIQt.cc

Data Structures

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Slots

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ G4interactor_map

◆ Transformer

Constructor & Destructor Documentation

◆ G4UIQt()

◆ ~G4UIQt()

Member Function Documentation

◆ ActivateCommand()

◆ AddButton()

◆ AddCerrTransformer() [1/2]

◆ AddCerrTransformer() [2/2]

◆ AddCoutTransformer() [1/2]

◆ AddCoutTransformer() [2/2]

◆ AddIcon()

◆ AddInteractor()

◆ AddMenu()

◆ AddTabWidget()

◆ AddViewerTab()

◆ AddViewerTabFromFile()

◆ ApplyShellCommand()

◆ ButtonCallback

◆ ChangeColorCallback

◆ ChangeCursorAction

◆ ChangeDirectory()

◆ ChangeDirectoryCommand()

◆ ChangePerspectiveOrtho

◆ ChangeSurfaceStyle

◆ CheckG4EnvironmentVariable()

◆ ClearButtonCallback

◆ ClearMenu()

◆ CommandEditedCallback

◆ CommandEnteredCallback

◆ CommandHistoryCallback

◆ Complete()

◆ CoutFilterCallback

◆ CreateCommandWidget()

◆ CreateCompleterModel()

◆ CreateCoutTBWidget()

◆ CreateEmptyPickInfosWidget()

◆ CreateEmptyViewerPropertiesWidget()

◆ CreateHelpTBWidget()

◆ CreateHelpTree()

◆ CreateHelpWidget()

◆ CreateHistoryTBWidget()

◆ CreateIcons()

◆ CreatePickInfosDialog()

◆ CreateSceneTreeWidget()

◆ CreateUITabWidget()

◆ CreateViewerPropertiesDialog()

◆ CreateViewerWidget()

◆ CreateVisCommandGroupAndToolBox()

◆ CreateVisParametersTBWidget()

◆ DefaultIcons()

◆ eventFilter()

◆ ExecuteCommand()

◆ ExitHelp()

◆ ExitSession

◆ FillHelpTree()

◆ FilterAllOutputTextArea()

◆ FilterOutput()

◆ FindCommand()

◆ FindDirectory()

◆ FindMatchingPath()

◆ FindTreeItem()

◆ getClearIcon()

◆ GetCommandList()

◆ GetCoutDockWidget()

◆ GetCoutWidget()