PTextEdit.cpp

Go to the documentation of this file.

/****************************************************************************
 
  PTextEdit.cpp
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
*****************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2010-2026 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

 
#include <iostream>
#include <fstream>
 
#include <QString>
#include <QStringList>
#include <QTextEdit>
#include <QStatusBar>
#include <QAction>
#include <QMenuBar>
#include <QMenu>
#include <QToolBar>
#include <QTabWidget>
#include <QApplication>
#include <QFontDatabase>
#include <QComboBox>
#include <QLineEdit>
#include <QFileInfo>
#include <QFile>
#include <QFileDialog>
#include <QtPrintSupport/QPrinter>
#include <QtPrintSupport/QPrintDialog>
#include <QColorDialog>
#include <QPainter>
#include <QMessageBox>
#include <QDialog>
#include <QTextCursor>
#include <QTextBlock>
#include <QTextDocumentFragment>
#include <QTextList>
#include <QProcess>
#include <QFileSystemWatcher>
#include <QDesktopServices>
#include <QUrl>
#include <QRegularExpression>
#include <QElapsedTimer>
#include <QThread>
 
#include <QtDebug>
 
#include "PTextEdit.h"
#include "PSubTextEdit.h"
#include "PAdmin.h"
#include "PFindDialog.h"
#include "PReplaceDialog.h"
#include "PReplaceConfirmationDialog.h"
#include "PFitOutputHandler.h"
#include "PDumpOutputHandler.h"
#include "PPrefsDialog.h"
#include "PGetMusrFTOptionsDialog.h"
#include "PMusrEditAbout.h"
#include "PMsr2DataDialog.h"
 
//----------------------------------------------------------------------------------------------------
PTextEdit::PTextEdit( QWidget *parent )
    : QMainWindow( parent )
{
  // reads and manages the conents of the xml-startup (musredit_startup.xml) file
  fAdmin = std::make_unique<PAdmin>();
 
  bool gotTheme = getTheme();
 
  // set default setting of the fDarkMenuIconIcons only if a theme has been recognized, otherwise take the
  // one from the xml startup file.
  if (gotTheme) {
    fAdmin->setDarkThemeIconsMenuFlag(fDarkMenuIcon);
    fAdmin->setDarkThemeIconsToolbarFlag(fDarkToolBarIcon);
  } else {
    fDarkMenuIcon = fAdmin->getDarkThemeIconsMenuFlag();
    fDarkToolBarIcon = fAdmin->getDarkThemeIconsToolbarFlag();
  }
 
  // keep the default editor width/height
  fEditW = fAdmin->getEditWidth();
  fEditH = fAdmin->getEditHeight();
 
  // enable file system watcher. Needed to get notification if the msr-file is changed outside of musrfit at runtime
  fFileSystemWatcherActive = true;
  fFileSystemWatcher = std::make_unique<QFileSystemWatcher>();
  if (fFileSystemWatcher == nullptr) {
    QMessageBox::information(this, "ERROR", "Couldn't invoke QFileSystemWatcher!");
  } else {
    connect( fFileSystemWatcher.get(), SIGNAL(fileChanged(const QString&)), this, SLOT(fileChanged(const QString&)));
  }
 
  // initialize stuff
  fMsr2DataParam = nullptr;
  fFindReplaceData = nullptr;
 
  // setup menus
  setupFileActions();
  setupEditActions();
  setupTextActions();
  setupMusrActions();
  setupJumpToBlock();
  setupHelpActions();
 
  fTabWidget = std::make_unique<QTabWidget>( this );
  fTabWidget->setMovable(true); // allows to shuffle around tabs
  setCentralWidget( fTabWidget.get() );
 
  textFamily(fAdmin->getFontName());
  textSize(QString("%1").arg(fAdmin->getFontSize()));
 
  QString iconName("");
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrfit-dark.svg");
  else
    iconName = QString(":/icons/musrfit-plain.svg");
  setWindowIcon( QIcon( iconName ) );
 
  // if arguments are give, try to load those files, otherwise create an empty new file
  if ( qApp->arguments().size() != 1 ) {
    for ( int i = 1; i < qApp->arguments().size(); ++i )
      load( qApp->arguments()[ i ] );
  } else {
    fileNew();
  }
 
  connect( fTabWidget.get(), SIGNAL( currentChanged(int) ), this, SLOT( applyFontSettings(int) ));
 
  fLastDirInUse = fAdmin->getDefaultSavePath();
 
  fStatusBar = this->statusBar();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::aboutToQuit()
{
  if (fMsr2DataParam) {
    delete fMsr2DataParam;
    fMsr2DataParam = nullptr;
  }
  if (fFindReplaceData) {
    delete fFindReplaceData;
    fFindReplaceData = nullptr;
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::setupFileActions()
{
  QToolBar *tb = new QToolBar( this );
  tb->setWindowTitle( "File Actions" );
  addToolBar( tb );
 
  QMenu *menu = new QMenu( tr( "F&ile" ), this );
  menuBar()->addMenu( menu );
 
  QAction *a;
  QString iconName("");
 
  // New
  if (fDarkMenuIcon)
    iconName = QString(":/icons/document-new-dark.svg");
  else
    iconName = QString(":/icons/document-new-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&New..." ), this );
  a->setShortcut( tr("Ctrl+N") );
  a->setStatusTip( tr("Create a new msr-file") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileNew() ) );
  menu->addAction(a);
  fActions["New"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/document-new-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&New..." ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( fileNew() ) );
  }
  tb->addAction(a);
  fActions["New-tb"] = a;
 
  // Open
  if (fDarkMenuIcon)
    iconName = QString(":/icons/document-open-dark.svg");
  else
    iconName = QString(":/icons/document-open-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Open..." ), this );
  a->setShortcut( tr("Ctrl+O") );
  a->setStatusTip( tr("Opens a msr-file") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileOpen() ) );
  menu->addAction(a);
  fActions["Open"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/document-open-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Open..." ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( fileOpen() ) );
  }
  tb->addAction(a);
  fActions["Open-tb"] = a;
 
  // Recent Files
  fRecentFilesMenu = menu->addMenu( tr("Recent Files") );
  for (int i=0; i<MAX_RECENT_FILES; i++) {
    fRecentFilesAction[i] = new QAction(fRecentFilesMenu);
    fRecentFilesAction[i]->setVisible(false);
    connect( fRecentFilesAction[i], SIGNAL(triggered()), this, SLOT(fileOpenRecent()));
    fRecentFilesMenu->addAction(fRecentFilesAction[i]);
  }
  fillRecentFiles();
 
  // Reload
  if (fDarkMenuIcon)
    iconName = QString(":/icons/view-refresh-dark.svg");
  else
    iconName = QString(":/icons/view-refresh-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "Reload..." ), this );
  a->setShortcut( tr("F5") );
  a->setStatusTip( tr("Reload msr-file") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileReload() ) );
  menu->addAction(a);
  fActions["Reload"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/view-refresh-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "Reload..." ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( fileReload() ) );
  }
  tb->addAction(a);
  fActions["Reload-tb"] = a;
 
  a = new QAction( tr( "Open Prefs..." ), this);
  connect( a, SIGNAL( triggered() ), this, SLOT( fileOpenPrefs() ) );
  menu->addAction(a);
 
  menu->addSeparator();
 
  // Save
  if (fDarkMenuIcon)
    iconName = QString(":/icons/document-save-dark.svg");
  else
    iconName = QString(":/icons/document-save-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Save..." ), this );
  a->setShortcut( tr("Ctrl+S") );
  a->setStatusTip( tr("Save msr-file") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileSave() ) );
  menu->addAction(a);
  fActions["Save"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/document-save-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Save..." ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( fileSave() ) );
  }
  tb->addAction(a);
  fActions["Save-tb"] = a;
 
  // Save As
  a = new QAction( tr( "Save &As..." ), this );
  a->setStatusTip( tr("Save msr-file As") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileSaveAs() ) );
  menu->addAction(a);
 
  // Save Prefs
  a = new QAction( tr( "Save Prefs..." ), this );
  a->setStatusTip( tr("Save the preferences") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileSavePrefs() ) );
  menu->addAction(a);
 
  menu->addSeparator();
 
  // Print
  if (fDarkMenuIcon)
    iconName = QString(":/icons/document-print-dark.svg");
  else
    iconName = QString(":/icons/document-print-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Print..." ), this );
  a->setShortcut( tr("Ctrl+P") );
  a->setStatusTip( tr("Print msr-file") );
  connect( a, SIGNAL( triggered() ), this, SLOT( filePrint() ) );
  menu->addAction(a);
  fActions["Print"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/document-print-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Print..." ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( filePrint() ) );
  }
  tb->addAction(a);
  fActions["Print-tb"] = a;
 
  menu->addSeparator();
 
  // Close
  a = new QAction( tr( "&Close" ), this );
  a->setShortcut( tr("Ctrl+W") );
  a->setStatusTip( tr("Close msr-file") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileClose() ) );
  menu->addAction(a);
 
  // Close All
  a = new QAction( tr( "Close &All" ), this );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileCloseAll() ) );
  menu->addAction(a);
 
  // Close All Others
  a = new QAction( tr( "Clo&se All Others" ), this );
  a->setShortcut( tr("Ctrl+Shift+W") );
  a->setStatusTip( tr("Close All Other Tabs") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileCloseAllOthers() ) );
  menu->addAction(a);
 
  menu->addSeparator();
 
  // Exit
  a = new QAction( tr( "E&xit" ), this );
  a->setShortcut( tr("Ctrl+Q") );
  a->setStatusTip( tr("Exit Program") );
  connect( a, SIGNAL( triggered() ), this, SLOT( fileExit() ) );
  menu->addAction(a);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::setupEditActions()
{
  QToolBar *tb = new QToolBar( this );
  tb->setWindowTitle( "Edit Actions" );
  addToolBar( tb );
 
  QMenu *menu = new QMenu( tr( "&Edit" ), this );
  menuBar()->addMenu( menu );
 
  QAction *a;
  QString iconName("");
 
  // Undo
  if (fDarkMenuIcon)
    iconName = QString(":/icons/edit-undo-dark.svg");
  else
    iconName = QString(":/icons/edit-undo-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Undo" ), this );
  a->setShortcut( tr("Ctrl+Z") );
  a->setStatusTip( tr("Edit Undo") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editUndo() ) );
  menu->addAction(a);
  fActions["Undo"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/edit-undo-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Undo" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editUndo() ) );
  }
  tb->addAction(a);
  fActions["Undo-tb"] = a;
 
  // Redo
  if (fDarkMenuIcon)
    iconName = QString(":/icons/edit-redo-dark.svg");
  else
    iconName = QString(":/icons/edit-redo-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Redo" ), this );
  a->setShortcut( tr("Ctrl+Y") );
  a->setStatusTip( tr("Edit Redo") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editRedo() ) );
  menu->addAction(a);
  fActions["Redo"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/edit-redo-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Redo" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editRedo() ) );
  }
  tb->addAction(a);
  fActions["Redo-tb"] = a;
 
  menu->addSeparator();
 
  // Select All
  a = new QAction( tr( "Select &All" ), this );
  a->setShortcut( tr("Ctrl+A") );
  a->setStatusTip( tr("Edit Select All") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editSelectAll() ) );
  menu->addAction(a);
 
  menu->addSeparator();
  tb->addSeparator();
 
  // Copy
  if (fDarkMenuIcon)
    iconName = QString(":/icons/edit-copy-dark.svg");
  else
    iconName = QString(":/icons/edit-copy-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Copy" ), this );
  a->setShortcut( tr("Ctrl+C") );
  a->setStatusTip( tr("Edit Copy") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editCopy() ) );
  menu->addAction(a);
  fActions["Copy"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/edit-copy-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Copy" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editCopy() ) );
  }
  tb->addAction(a);
  fActions["Copy-tb"] = a;
 
  // Cut
  if (fDarkMenuIcon)
    iconName = QString(":/icons/edit-cut-dark.svg");
  else
    iconName = QString(":/icons/edit-cut-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "Cu&t" ), this );
  a->setShortcut( tr("Ctrl+X") );
  a->setStatusTip( tr("Edit Cut") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editCut() ) );
  menu->addAction(a);
  fActions["Cut"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/edit-cut-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "Cu&t" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editCut() ) );
  }
  tb->addAction(a);
  fActions["Cut-tb"] = a;
 
  // Paste
  if (fDarkMenuIcon)
    iconName = QString(":/icons/edit-paste-dark.svg");
  else
    iconName = QString(":/icons/edit-paste-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Paste" ), this );
  a->setShortcut( tr("Ctrl+V") );
  a->setStatusTip( tr("Edit Paste") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editPaste() ) );
  menu->addAction(a);
  fActions["Paste"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/edit-paste-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Paste" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editPaste() ) );
  }
  tb->addAction(a);
  fActions["Paste-tb"] = a;
 
  menu->addSeparator();
  tb->addSeparator();
 
  // Find
  if (fDarkMenuIcon)
    iconName = QString(":/icons/edit-find-dark.svg");
  else
    iconName = QString(":/icons/edit-find-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Find" ), this );
  a->setShortcut( tr("Ctrl+F") );
  a->setStatusTip( tr("Edit Find") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editFind() ) );
  menu->addAction(a);
  fActions["Find"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/edit-find-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Find" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editFind() ) );
  }
  tb->addAction(a);
  fActions["Find-tb"] = a;
 
  // Find Next
  if (fDarkMenuIcon)
    iconName = QString(":/icons/go-next-use-dark.svg");
  else
    iconName = QString(":/icons/go-next-use-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "Find &Next" ), this );
  a->setShortcut( tr("F3") );
  a->setStatusTip( tr("Edit Find Next") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editFindNext() ) );
  menu->addAction(a);
  fActions["Find Next"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/go-next-use-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "Find &Next" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editFindNext() ) );
  }
  tb->addAction(a);
  fActions["Find Next-tb"] = a;
 
  // Find Previous
  if (fDarkMenuIcon)
    iconName = QString(":/icons/go-previous-use-dark.svg");
  else
    iconName = QString(":/icons/go-previous-use-plain.svg");
  a = new QAction( QIcon( iconName ) , tr( "Find Pre&vious" ), this );
  a->setShortcut( tr("Shift+F4") );
  a->setStatusTip( tr("Edit Find Previous") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editFindPrevious() ) );
  menu->addAction(a);
  fActions["Find Previous"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/go-previous-use-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "Find Pre&vious" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( editFindPrevious() ) );
  }
  tb->addAction(a);
  fActions["Find Previous-tb"] = a;
 
  // Replace
  a = new QAction( tr( "Replace..." ), this );
  a->setShortcut( tr("Ctrl+R") );
  a->setStatusTip( tr("Edit Replace") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editFindAndReplace() ) );
  menu->addAction(a);
  menu->addSeparator();
 
  QMenu *addSubMenu = new QMenu( tr ("Add Block"), this);
 
  a = new QAction( tr("Title Block"), this );
  a->setStatusTip( tr("Invokes MSR Title Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertTitle() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Parameter Block"), this );
  a->setStatusTip( tr("Invokes MSR Parameter Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertParameterBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Theory Block"), this );
  a->setStatusTip( tr("Invokes MSR Theory Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertTheoryBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Function Block"), this );
  a->setStatusTip( tr("Invokes MSR Function Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertFunctionBlock() ));
  addSubMenu->addAction(a);
 
  // feed the theoryFunctions popup menu
  QMenu *theoryFunctions = new QMenu( tr("Add Theory Function"), this );  
  for (unsigned int i=0; i<fAdmin->getTheoryCounts(); i++) {
    PTheory *theoryItem = fAdmin->getTheoryItem(i);
    a = new QAction( theoryItem->label, this);
    theoryFunctions->addAction(a);
  }
  connect( theoryFunctions, SIGNAL( triggered(QAction*)), this, SLOT( insertTheoryFunction(QAction*) ) );
 
  a = new QAction( tr("Asymmetry Run Block"), this );
  a->setStatusTip( tr("Invokes MSR Asymmetry Run Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertAsymRunBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Single Histo Run Block"), this );
  a->setStatusTip( tr("Invokes MSR Single Histo Run Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertSingleHistRunBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("NonMuSR Run Block"), this );
  a->setStatusTip( tr("Invokes MSR NonMuSR Run Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertNonMusrRunBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Command Block"), this );
  a->setStatusTip( tr("Invokes MSR Command Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertCommandBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Fourier Block"), this );
  a->setStatusTip( tr("Invokes MSR Fourier Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertFourierBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Plot Block"), this );
  a->setStatusTip( tr("Invokes MSR Plot Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertPlotBlock() ));
  addSubMenu->addAction(a);
 
  a = new QAction( tr("Statistic Block"), this );
  a->setStatusTip( tr("Invokes MSR Statistic Block Dialog") );
  connect( a, SIGNAL( triggered() ), this, SLOT( insertStatisticBlock() ));
  addSubMenu->addAction(a);
 
  menu->addMenu(addSubMenu);
  menu->addMenu(theoryFunctions);
  menu->addSeparator();
 
  a = new QAction( tr( "Co&mment" ), this );
  a->setShortcut( tr("Ctrl+M") );
  a->setStatusTip( tr("Edit Comment Selected Lines") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editComment() ) );
  menu->addAction(a);
 
  a = new QAction( tr( "Unco&mment" ), this );
  a->setShortcut( tr("Ctrl+Shift+M") );
  a->setStatusTip( tr("Edit Uncomment Selected Lines") );
  connect( a, SIGNAL( triggered() ), this, SLOT( editUncomment() ) );
  menu->addAction(a);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::setupTextActions()
{
  QToolBar *tb = new QToolBar( this );
  tb->setWindowTitle( "Format Actions" );
  addToolBar( tb );
 
  fComboFont = std::make_unique<QComboBox>();
  fComboFont->setEditable(true);
  fComboFont->addItems( QFontDatabase::families() );
  connect( fComboFont.get(), SIGNAL( currentTextChanged( const QString & ) ),
           this, SLOT( textFamily( const QString & ) ) );
  QLineEdit *edit = fComboFont->lineEdit();
  if (edit == nullptr) {
    return;
  }
  edit->setText( fAdmin->getFontName() );
  tb->addWidget(fComboFont.get());
 
  fComboSize = std::make_unique<QComboBox>( tb );
  fComboSize->setEditable(true);
  QList<int> sizes = QFontDatabase::standardSizes();
  QList<int>::Iterator it = sizes.begin();
  for ( ; it != sizes.end(); ++it )
    fComboSize->addItem( QString::number( *it ) );
  connect( fComboSize.get(), SIGNAL( currentTextChanged( const QString & ) ),
           this, SLOT( textSize( const QString & ) ) );
  edit = fComboSize->lineEdit();
  if (edit == nullptr) {
    return;
  }
  edit->setText( QString("%1").arg(fAdmin->getFontSize()) );
  tb->addWidget(fComboSize.get());
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::setupMusrActions()
{
  addToolBarBreak();
 
  QToolBar *tb = new QToolBar( this );
  tb->setWindowTitle( "Musr Actions" );
  addToolBar( tb );
 
  QMenu *menu = new QMenu( tr( "&MusrFit" ), this );
  menuBar()->addMenu( menu );
 
  QAction *a;
  QString iconName("");
 
  // musrWiz
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrWiz-32x32-dark.svg");
  else
    iconName = QString(":/icons/musrWiz-32x32.svg");
  a = new QAction( QIcon( iconName ), tr( "musr&Wiz" ), this );
  a->setShortcut( tr("Alt+W") );
  a->setStatusTip( tr("Call musrWiz which helps to create msr-files - currently still very limited") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrWiz() ) );
  menu->addAction(a);
  fActions["musrWiz"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrWiz-32x32.svg");
    a = new QAction( QIcon( iconName ), tr( "musr&Wiz" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrWiz() ) );
  }
  tb->addAction(a);
  fActions["musrWiz-tb"] = a;
 
  menu->addSeparator();
  tb->addSeparator();
 
  // Calculate Chisq
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrchisq-dark.svg");
  else
    iconName = QString(":/icons/musrchisq-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "Calculate &Chisq" ), this );
  a->setShortcut( tr("Alt+C") );
  a->setStatusTip( tr("Calculate Chi Square (Log Max Likelihood)") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrCalcChisq() ) );
  menu->addAction(a);
  fActions["calcChisq"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrchisq-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "Calculate &Chisq" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrCalcChisq() ) );
  }
  tb->addAction(a);
  fActions["calcChisq-tb"] = a;
 
  // musrfit
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrfit-dark.svg");
  else
    iconName = QString(":/icons/musrfit-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Fit" ), this );
  a->setShortcut( tr("Alt+F") );
  a->setStatusTip( tr("Fit") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrFit() ) );
  menu->addAction(a);
  fActions["musrfit"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrfit-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Fit" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrFit() ) );
  }
  tb->addAction(a);
  fActions["musrfit-tb"] = a;
 
  // Swap Msr/Mlog
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrswap-dark.svg");
  else
    iconName = QString(":/icons/musrswap-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Swap Msr <-> Mlog" ), this );
  a->setShortcut( tr("Alt+S") );
  a->setStatusTip( tr("Swap msr-file <-> mlog-file") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrSwapMsrMlog() ) );
  menu->addAction(a);
  fActions["Swap Msr/Mlog"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrswap-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Swap Msr <-> Mlog" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrSwapMsrMlog() ) );
  }
  tb->addAction(a);
  fActions["Swap Msr/Mlog-tb"] = a;
 
  // musrStep
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrStep-32x32-dark.svg");
  else
    iconName = QString(":/icons/musrStep-32x32.svg");
  a = new QAction( QIcon( iconName ), tr( "Set Ste&ps" ), this );
  a->setShortcut( tr("Alt+P") );
  a->setStatusTip( tr("Set Steps") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrSetSteps() ) );
  menu->addAction(a);
  fActions["musrStep"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrStep-32x32.svg");
    a = new QAction( QIcon( iconName ), tr( "Set Ste&ps" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrSetSteps() ) );
  }
  tb->addAction(a);
  fActions["musrStep-tb"] = a;
 
  // msr2data
  if (fDarkMenuIcon)
    iconName = QString(":/icons/msr2data-dark.svg");
  else
    iconName = QString(":/icons/msr2data-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "Msr&2Data" ), this );
  a->setShortcut( tr("Alt+2") );
  a->setStatusTip( tr("Start msr2data interface") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrMsr2Data() ) );
  menu->addAction(a);
  fActions["msr2data"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/msr2data-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Msr2Data" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrMsr2Data() ) );
  }
  tb->addAction(a);
  fActions["msr2data-tb"] = a;
 
  // mupp
  if (fDarkMenuIcon)
    iconName = QString(":/icons/mupp-dark.svg");
  else
    iconName = QString(":/icons/mupp-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "m&upp" ), this );
  a->setShortcut( tr("Alt+U") );
  a->setStatusTip( tr("Start mupp, the muSR parameter plotter") );
  connect( a, SIGNAL( triggered() ), this, SLOT( mupp() ) );
  menu->addAction(a);
  fActions["mupp"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/mupp-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "m&upp" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( mupp() ) );
  }
  tb->addAction(a);
  fActions["mupp-tb"] = a;
 
  // musrView2dat
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrview2dat-dark.svg");
  else
    iconName = QString(":/icons/musrview2dat-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "View2Dat" ), this );
  a->setStatusTip( tr("Export musrview data from a collection of msr-files.") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrView2Dat() ) );
  menu->addAction(a);
  fActions["musrview2dat"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrview2dat-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "View2Dat" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrView2Dat() ) );
  }
  tb->addAction(a);
  fActions["musrview2dat-tb"] = a;
 
  menu->addSeparator();
  tb->addSeparator();
 
  // musrview
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrview-dark.svg");
  else
    iconName = QString(":/icons/musrview-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&View" ), this );
  a->setShortcut( tr("Alt+V") );
  a->setStatusTip( tr("Start musrview") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrView() ) );
  menu->addAction(a);
  fActions["musrview"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrview-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&View" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrView() ) );
  }
  tb->addAction(a);
  fActions["musrview-tb"] = a;
 
  // musrt0
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrt0-dark.svg");
  else
    iconName = QString(":/icons/musrt0-plain.svg");
  fMusrT0Action = std::make_unique<QAction>( QIcon( iconName ), tr( "&T0" ), this );
  fMusrT0Action->setStatusTip( tr("Start musrt0") );
  connect( fMusrT0Action.get(), SIGNAL( triggered() ), this, SLOT( musrT0() ) );
  menu->addAction(fMusrT0Action.get());
  fActions["musrt0"] = fMusrT0Action.get();
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrt0-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&T0" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrT0() ) );
  }
  tb->addAction(fMusrT0Action.get());
  fMusrT0Action->setEnabled(fAdmin->getEnableMusrT0Flag());
  fActions["musrt0-tb"] = fMusrT0Action.get();
 
  // musrFT
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrFT-dark.svg");
  else
    iconName = QString(":/icons/musrFT-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "Raw Fourier" ), this );
  a->setStatusTip( tr("Start musrFT") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrFT() ) );
  menu->addAction(a);
  fActions["musrFT"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrFT-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "Raw Fourier" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrFT() ) );
  }
  tb->addAction(a);
  fActions["musrFT-tb"] = a;
 
  // musrprefs
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrprefs-dark.svg");
  else
    iconName = QString(":/icons/musrprefs-plain.svg");
  a = new QAction( QIcon( iconName ), tr( "&Preferences" ), this );
  a->setStatusTip( tr("Show Preferences") );
  connect( a, SIGNAL( triggered() ), this, SLOT( musrPrefs() ) );
  menu->addAction(a);
  fActions["musrprefs"] = a;
 
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrprefs-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Preferences" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrPrefs() ) );
  }
  tb->addAction(a);
  fActions["musrprefs-tb"] = a;
 
  menu->addSeparator();
  tb->addSeparator();
 
  // musrdump
  if (fDarkMenuIcon)
    iconName = QString(":/icons/musrdump-dark.svg");
  else
    iconName = QString(":/icons/musrdump-plain.svg");
  a = new QAction( QIcon( iconName), tr( "&Dump Header"), this);
  a->setStatusTip( tr("Dumps muSR File Header Information") );
  connect( a, SIGNAL(triggered()), this, SLOT(musrDump()));
  menu->addAction(a);
  fActions["musrdump"] = a;
  if (!fDarkToolBarIcon) { // tool bar icon is not dark, even though the theme is (ubuntu)
    iconName = QString(":/icons/musrdump-plain.svg");
    a = new QAction( QIcon( iconName ), tr( "&Dump Header" ), this );
    connect( a, SIGNAL( triggered() ), this, SLOT( musrDump() ) );
  }
  tb->addAction(a);
  fActions["musrdump-tb"] = a;
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::setupHelpActions()
{
  QMenu *menu = new QMenu( tr( "&Help" ), this );
  menuBar()->addMenu( menu);
 
  QAction *a;
  a = new QAction(tr( "Contents ..." ), this );
  a->setStatusTip( tr("Help Contents") );
  connect( a, SIGNAL( triggered() ), this, SLOT( helpContents() ));
  menu->addAction(a);
 
  a = new QAction(tr( "Author(s) ..." ), this );
  a->setStatusTip( tr("Help About") );
  connect( a, SIGNAL( triggered() ), this, SLOT( helpAbout() ));
  menu->addAction(a);
 
  a = new QAction(tr( "About Qt..." ), this );
  a->setStatusTip( tr("Help About Qt") );
  connect( a, SIGNAL( triggered() ), this, SLOT( helpAboutQt() ));
  menu->addAction(a);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::setupJumpToBlock()
{
  QToolBar *tb = new QToolBar( this );
  tb->setWindowTitle( "JumpToBlock Actions" );
  addToolBar( tb );
 
  QStringList jumpToBlockStr = {"FITPARAMETER", "THEORY", "FUNCTIONS", "GLOBAL", "RUN", "COMMANDS", "PLOT", "FOURIER", "STATISTIC"};
  fJumpToBlock = std::make_unique<QComboBox>();
  if (fJumpToBlock == nullptr)
    return;
  fJumpToBlock->addItems(jumpToBlockStr);
  fJumpToBlock->setEditable(false);
 
  connect( fJumpToBlock.get(), SIGNAL( activated(int) ), this, SLOT( jumpToBlock(int) ));
 
  QLabel *jstr = new QLabel("  Jump to block: ");
 
  tb->addWidget(jstr);
  tb->addWidget(fJumpToBlock.get());
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::load( const QString &f, const int index )
{
  // check if the file exists
  if ( !QFile::exists( f ) )
    return;
 
  // create a new text edit object
  PSubTextEdit *edit = new PSubTextEdit( fAdmin.get() );
  edit->setFont(QFont(fAdmin->getFontName(), fAdmin->getFontSize()));
  edit->setCenterOnScroll(true);
 
  // place the text edit object at the appropriate tab position
  if (index == -1)
    fTabWidget->addTab( edit, QFileInfo( f ).fileName() );
  else
    fTabWidget->insertTab( index, edit, QFileInfo( f ).fileName() );
  QFile file( f );
  if ( !file.open( QIODevice::ReadOnly ) )
    return;
 
  // add file name to recent file names
  fAdmin->addRecentFile(QFileInfo(f).absoluteFilePath()); // keep it in admin
  fillRecentFiles();        // update menu
 
  // add the msr-file to the file system watchersssss
  fFileSystemWatcher->addPath(f);
 
  // read the file
  QTextStream ts( &file );
  QString txt = ts.readAll();
  edit->setPlainText( txt );
  doConnections( edit ); // add all necessary signal/slot connections
 
  // set the tab widget to the current tab
  fTabWidget->setCurrentIndex(fTabWidget->indexOf(edit));
  edit->viewport()->setFocus();
 
  // update the filename mapper
  fFilenames.remove( edit );
  fFilenames.insert( edit, f );
}
 
//----------------------------------------------------------------------------------------------------
PSubTextEdit *PTextEdit::currentEditor() const
{
  if (fTabWidget == nullptr)
    return nullptr;
 
  if ( fTabWidget->currentWidget() ) {
    if (fTabWidget->currentWidget()->inherits( "PSubTextEdit" )) {
      return dynamic_cast<PSubTextEdit*>(fTabWidget->currentWidget());
    }
  }
 
  return nullptr;
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::doConnections( PSubTextEdit *e )
{
//  connect( e, SIGNAL( currentFontChanged( const QFont & ) ),
//           this, SLOT( fontChanged( const QFont & ) ) );
 
  connect( e, SIGNAL( textChanged() ), this, SLOT( textChanged() ));
 
  connect( e, SIGNAL( cursorPositionChanged() ), this, SLOT( currentCursorPosition() ));
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertTitle()
{
  currentEditor()->insertTitle();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertParameterBlock()
{
  currentEditor()->insertParameterBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertTheoryBlock()
{
  currentEditor()->insertTheoryBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertTheoryFunction(QAction *a)
{
  currentEditor()->insertTheoryFunction(a->text());
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertFunctionBlock()
{
  currentEditor()->insertFunctionBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertAsymRunBlock()
{
  currentEditor()->insertAsymRunBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertSingleHistRunBlock()
{
  currentEditor()->insertSingleHistRunBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertNonMusrRunBlock()
{
  currentEditor()->insertNonMusrRunBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertCommandBlock()
{
  currentEditor()->insertCommandBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertFourierBlock()
{
  currentEditor()->insertFourierBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertPlotBlock()
{
  currentEditor()->insertPlotBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::insertStatisticBlock()
{
  currentEditor()->insertStatisticBlock();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileNew()
{
  PSubTextEdit *edit = new PSubTextEdit( fAdmin.get() );
  edit->setFont(QFont(fAdmin->getFontName(), fAdmin->getFontSize()));
  edit->setCenterOnScroll(true);
  doConnections( edit );
  fTabWidget->addTab( edit, tr( "noname" ) );
  fTabWidget->setCurrentIndex(fTabWidget->indexOf(edit));
  fFilenames.insert(edit, tr("noname"));
  edit->viewport()->setFocus();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileOpen()
{
  QStringList flns = QFileDialog::getOpenFileNames( this, tr("Open msr-/mlog-File"),
                        fLastDirInUse,
                        tr( "msr-Files (*.msr);;msr-Files (*.msr *.mlog);;All Files (*)" ));
 
  QStringList::Iterator it = flns.begin();
  QFileInfo finfo1;
  bool alreadyOpen = false;
  int idx;
 
  // if flns are present, keep the corresponding directory
  if (flns.size() > 0) {
    finfo1.setFile(flns.at(0));
    fLastDirInUse = finfo1.absoluteFilePath();
  }
 
  while( it != flns.end() ) {    
    // check if the file is not already open
    finfo1.setFile(*it);
    alreadyOpen = fileAlreadyOpen(finfo1, idx);
 
    if (!alreadyOpen) {
      load(*it);
    } else {
      fTabWidget->setCurrentIndex(idx);
      fileReload();
    }
 
    ++it;
  }
 
  // in case there is a 1st empty tab "noname", remove it
  QString tabStr = fTabWidget->tabText(0);
  tabStr.remove('&'); // this is needed since the QTabWidget adds short-cut info as '&' to the tab name
  if (tabStr == "noname") { // has to be the first, otherwise do nothing
    fFileSystemWatcher->removePath("noname");
 
    delete fTabWidget->widget(0);
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileOpenRecent()
{
  QAction *action = qobject_cast<QAction *>(sender());
 
  if (action) {
    // check if this file is already open and if so, switch the tab
    QFileInfo finfo1, finfo2;
    QString tabFln;
    bool alreadyOpen = false;
    QString fln = action->text();
    fln.remove('&');
    finfo1.setFile(fln);
 
    for (int i=0; i<fTabWidget->count(); i++) {
      tabFln = *fFilenames.find( dynamic_cast<PSubTextEdit*>(fTabWidget->widget(i)));
      finfo2.setFile(tabFln);
      if (finfo1.absoluteFilePath() == finfo2.absoluteFilePath()) {
        alreadyOpen = true;
        fTabWidget->setCurrentIndex(i);
        break;
      }
    }
 
    if (!alreadyOpen) {
      // make sure the file exists
      if (!finfo1.exists()) {
        QMessageBox::critical(this, "ERROR", QString("File '%1' does not exist.\nWill not do anything.").arg(fln));
        return;
      }
      load(fln);
    } else {
      fileReload();
    }
 
    // in case there is a 1st empty tab "noname", remove it
    fln = fTabWidget->tabText(0);
    fln.remove("&");
    if (fln == "noname") { // has to be the first, otherwise do nothing
      fFileSystemWatcher->removePath("noname");
 
      delete fTabWidget->widget(0);
    }
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileReload()
{
  if ( fFilenames.find( currentEditor() ) == fFilenames.end() ) {
    QMessageBox::critical(this, "ERROR", "Cannot reload a file not previously saved ;-)");
  } else {
    int index = fTabWidget->currentIndex();
    QString fln = *fFilenames.find( currentEditor() );
    fileClose(false);
    load(fln, index);
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileOpenPrefs()
{
  QString fln("");
  QString msg("");
  QMessageBox msgBox;
  msgBox.setText("Which Preferences do you want to open?");
  msgBox.addButton("Default", QMessageBox::AcceptRole);
  msgBox.addButton("Custom", QMessageBox::AcceptRole);
  msgBox.setStandardButtons(QMessageBox::Cancel);
  int result = msgBox.exec();
  if (result == QMessageBox::Cancel) {
    return;
  } else if (result == 0) { // default dir
    fln = fAdmin->getDefaultPrefPathName();
    msg = QString("Current Default Preferences Path-Name:\n") + fln;
    if (QMessageBox::information(this, "INFO", msg, QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Cancel)
      return;
  } else if (result == 1) { // custom dir
    fln = QFileDialog::getOpenFileName( this, tr("Open Prefs"),
                        fLastDirInUse,
                        tr( "xml-Files (*.xml);; All Files (*)" ));
  }
 
  if (fAdmin->loadPrefs(fln)) {
    msg = QString("Prefs from '") + fln + QString("' loaded.");
    QMessageBox::information(nullptr, "INFO", msg);
  }
 
  // make sure that dark/plain icon scheme is properly loaded
  if (getTheme()) {
    switchMenuIcons();
    switchToolbarIcons();
  }
 
  if (fAdmin->getDarkThemeIconsMenuFlag() != fDarkMenuIcon) {
    fDarkMenuIcon = !fDarkMenuIcon;
    switchMenuIcons();
  }
 
  if (fAdmin->getDarkThemeIconsToolbarFlag() != fDarkToolBarIcon) {
    fDarkToolBarIcon = !fDarkToolBarIcon;
    switchToolbarIcons();
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileSave()
{
  if ( !currentEditor() )
    return;
 
  fFileSystemWatcherActive = false;
 
  if ( *fFilenames.find( currentEditor() ) == QString("noname") ) {
    fileSaveAs();
  } else {
    QFile file( *fFilenames.find( currentEditor() ) );
    if ( !file.open( QIODevice::WriteOnly ) ) {
      QMessageBox::critical(this, "ERROR", "Couldn't save the file!\nDisk full?\nNo write access?");
      return;
    }
    QTextStream ts( &file );
    ts << currentEditor()->toPlainText();
 
    // remove trailing '*' modification indicators
    QString fln = *fFilenames.find( currentEditor() );
    fTabWidget->setTabText(fTabWidget->indexOf( currentEditor() ), QFileInfo(fln).fileName());
  }
 
  fileSystemWatcherActivation(); // delayed activation of fFileSystemWatcherActive
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileSaveAs()
{
  if ( !currentEditor() )
    return;
 
  fFileSystemWatcherActive = false;
 
  QString fn = QFileDialog::getSaveFileName( this,
                    tr( "Save msr-/mlog-file As" ), *fFilenames.find( currentEditor() ),
                    tr( "msr-Files (*.msr *.mlog);;All Files (*)" ) );
  if ( !fn.isEmpty() ) {
    fFilenames.remove( currentEditor() );
    fFilenames.insert( currentEditor(), fn );
    fileSave();
  }
 
  fileSystemWatcherActivation(); // delayed activation of fFileSystemWatcherActive
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileSavePrefs()
{
  QString fln("");
  QString msg("");
  QMessageBox msgBox;
  msgBox.setText("Which Preferences do you want to open?");
  QAbstractButton *def = msgBox.addButton("Default", QMessageBox::AcceptRole);
  QAbstractButton *cust = msgBox.addButton("Custom", QMessageBox::AcceptRole);
  msgBox.setStandardButtons(QMessageBox::Cancel);
  int result = msgBox.exec();
  if (result == QMessageBox::Cancel) {
    return;
  } else if (msgBox.clickedButton() == def) { // default dir
    fln = fAdmin->getDefaultPrefPathName();
    msg = QString("Current Default Preferences Path-Name:\n") + fln;
    if (QMessageBox::information(this, "INFO", msg, QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Cancel)
      return;
  } else if (msgBox.clickedButton() == cust) { // custom dir
    fln = QFileDialog::getSaveFileName( this,
                    tr( "Save Prefs As" ), "musredit_startup.xml",
                    tr( "xml-Files (*.xml);;All Files (*)" ) );
  }
 
  if ( !fln.isEmpty() ) {
    fAdmin->savePrefs(fln);
    msg = QString("Prefs to '") + fln + QString("' saved.");
    QMessageBox::information(nullptr, "INFO", msg);
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::filePrint()
{
  if ( !currentEditor() )
    return;
#ifndef QT_NO_PRINTER
  QPrinter printer( QPrinter::HighResolution );
  printer.setFullPage(true);
  QPrintDialog dialog(&printer, this);
  if (dialog.exec()) { // printer dialog
    statusBar()->showMessage( "Printing..." );
 
    QPainter p( &printer );
    // Check that there is a valid device to print to.
    if ( !p.device() )
      return;
 
    QFont font( currentEditor()->QWidget::font() );
    font.setPointSize( 10 ); // we define 10pt to be a nice base size for printing
    p.setFont( font );
 
    int yPos        = 0;                  // y-position for each line
    QFontMetrics fm = p.fontMetrics();
    int dpiy = printer.logicalDpiY();
    int margin = static_cast<int>( (2/2.54)*dpiy ); // 2 cm margins
 
    // print msr-file
    QString fln = *fFilenames.find(currentEditor());
    QString header1(fln);
    QFileInfo flnInfo(fln);
    QString header2 = QString("last modified: ") + flnInfo.lastModified().toString("dd.MM.yyyy - hh:mm:ss");
    QString line("-------------------------------------");
    QStringList strList = currentEditor()->toPlainText().split("\n");
    for (QStringList::Iterator it = strList.begin(); it != strList.end(); ++it) {
      // new page needed?
      if ( margin + yPos > printer.height() - margin ) {
        printer.newPage();             // no more room on this page
        yPos = 0;                      // back to top of page
      }
 
      if (yPos == 0) { // print header
        font.setPointSize( 8 );
        p.setFont( font );
 
        p.drawText(margin, margin+yPos, printer.width(), fm.lineSpacing(),
                   Qt::TextExpandTabs | Qt::TextDontClip, header1);
        yPos += fm.lineSpacing();
        p.drawText(margin, margin+yPos, printer.width(), fm.lineSpacing(),
                   Qt::TextExpandTabs | Qt::TextDontClip, header2);
        yPos += fm.lineSpacing();
        p.drawText(margin, margin+yPos, printer.width(), fm.lineSpacing(),
                   Qt::TextExpandTabs | Qt::TextDontClip, line);
        yPos += 1.5*fm.lineSpacing();
 
        font.setPointSize( 10 );
        p.setFont( font );
      }
 
      // print data
      p.drawText(margin, margin+yPos, printer.width(), fm.lineSpacing(),
                 Qt::TextExpandTabs | Qt::TextDontClip, *it);
      yPos += fm.lineSpacing();
    }
 
    p.end();
  }
#endif
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileClose(const bool check)
{
  // first check if there is any tab present
  if (fTabWidget->count()==0) // no tabs present
    return;
 
  // check if the has modification
  int idx = fTabWidget->currentIndex();
 
  if ((fTabWidget->tabText(idx).indexOf("*")>0) && check) {
    int result = QMessageBox::warning(this, "WARNING",
                   "Do you really want to close this file.\nChanges will be lost",
                   QMessageBox::Close, QMessageBox::Cancel);
    if (result == QMessageBox::Cancel)
      return;
  }
 
  QString str = *fFilenames.find(currentEditor());
  fFileSystemWatcher->removePath(str);
 
  delete currentEditor();
 
  if ( currentEditor() )
    currentEditor()->viewport()->setFocus();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileCloseAll()
{
  // check if any editor tab is present, if not: get out of here
  if ( !currentEditor() )
    return;
 
  // check if there are any unsaved tabs
  for (int i=0; i<fTabWidget->count(); i++) {
    if (fTabWidget->tabText(i).indexOf("*") > 0) {
      int result = QMessageBox::warning(this, "WARNING",
                     "Do you really want to close all files.\nChanges of unsaved files will be lost",
                     QMessageBox::Close, QMessageBox::Cancel);
      if (result == QMessageBox::Cancel)
        return;
      break;
    }
  }
 
  // close all editor tabs
  QString str;
  do {
    // remove file from file system watcher
    str = *fFilenames.find(currentEditor());
    fFileSystemWatcher->removePath(str);
 
    delete currentEditor();
 
    if ( currentEditor() )
      currentEditor()->viewport()->setFocus();
  } while ( currentEditor() );
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileCloseAllOthers()
{
  // check if any editor tab is present, if not: get out of here
  if ( !currentEditor() )
    return;
 
  // check if there are any unsaved tabs
  for (int i=0; i<fTabWidget->count(); i++) {
    if (fTabWidget->tabText(i).indexOf("*") > 0) {
      int result = QMessageBox::warning(this, "WARNING",
                     "Do you really want to close all files.\nChanges of unsaved files will be lost",
                     QMessageBox::Close, QMessageBox::Cancel);
      if (result == QMessageBox::Cancel)
        return;
      break;
    }
  }
 
  // keep label of the current editor
  QString label = fTabWidget->tabText(fTabWidget->currentIndex());
 
  // check if only the current editor is present. If yes: nothing to be done
  if (fTabWidget->count() == 1)
    return;
 
  // close all editor tabs
  int i=0;
  QString str;
  do {
    if (fTabWidget->tabText(i) != label) {
      // remove file from file system watcher
      str = *fFilenames.find(dynamic_cast<PSubTextEdit*>(fTabWidget->widget(i)));
      fFileSystemWatcher->removePath(str);
 
      delete fTabWidget->widget(i);
    } else {
      i++;
    }
  } while ( fTabWidget->count() > 1 );
 
  currentEditor()->viewport()->setFocus();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileExit()
{
  // check if there are still some modified files open
  for (int i=0; i < fTabWidget->count(); i++) {
    if (fTabWidget->tabText(i).indexOf("*") > 0) {
      int result = QMessageBox::warning(this, "WARNING",
                     "Do you really want to exit from the applcation.\nChanges will be lost",
                     QMessageBox::Close, QMessageBox::Cancel);
      if (result == QMessageBox::Cancel)
        return;
      break;
    }
  }
 
  fAdmin->saveRecentFiles();
    
  qApp->quit();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editUndo()
{
  if ( !currentEditor() )
    return;
  currentEditor()->undo();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editRedo()
{
  if ( !currentEditor() )
    return;
  currentEditor()->redo();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editSelectAll()
{
  if ( !currentEditor() )
    return;
  currentEditor()->selectAll();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editCut()
{
  if ( !currentEditor() )
    return;
  currentEditor()->cut();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editCopy()
{
  if ( !currentEditor() )
    return;
  currentEditor()->copy();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editPaste()
{
  if ( !currentEditor() )
    return;
  currentEditor()->paste();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editFind()
{
  if ( !currentEditor() )
    return;
 
  // check if first time called, and if yes create find and replace data structure
  if (fFindReplaceData == nullptr) {
    fFindReplaceData = new PFindReplaceData();
    fFindReplaceData->findText = QString("");
    fFindReplaceData->replaceText = QString("");
    fFindReplaceData->caseSensitive = true;
    fFindReplaceData->wholeWordsOnly = false;
    fFindReplaceData->fromCursor = true;
    fFindReplaceData->findBackwards = false;
    fFindReplaceData->selectedText = false;
    fFindReplaceData->promptOnReplace = true;
  }
 
  if (fFindReplaceData == nullptr) {
    QMessageBox::critical(this, "ERROR", "Couldn't invoke find data structure, sorry :-(", QMessageBox::Ok, QMessageBox::NoButton);
    return;
  }
 
  PFindDialog *dlg = new PFindDialog(fFindReplaceData, currentEditor()->textCursor().hasSelection());
  if (dlg == nullptr) {
    QMessageBox::critical(this, "ERROR", "Couldn't invoke find dialog, sorry :-(", QMessageBox::Ok, QMessageBox::NoButton);
    return;
  }
 
  dlg->exec();
 
  if (dlg->result() != QDialog::Accepted) {
    delete dlg;
    return;
  }
 
  fFindReplaceData = dlg->getData();
 
  delete dlg;
  dlg = nullptr;
 
  // try to find the search text
  if (!fFindReplaceData->fromCursor)
    currentEditor()->textCursor().setPosition(0);
 
  QTextDocument::FindFlags flags;
  if (fFindReplaceData->caseSensitive)
    flags |= QTextDocument::FindCaseSensitively;
  else if (fFindReplaceData->findBackwards)
    flags |= QTextDocument::FindBackward;
  else if (fFindReplaceData->wholeWordsOnly)
    flags |= QTextDocument::FindWholeWords;
 
  currentEditor()->find(fFindReplaceData->findText, flags);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editFindNext()
{
  QTextDocument::FindFlags flags;
  if (fFindReplaceData->caseSensitive)
    flags |= QTextDocument::FindCaseSensitively;
  else if (fFindReplaceData->wholeWordsOnly)
    flags |= QTextDocument::FindWholeWords;
 
  currentEditor()->find(fFindReplaceData->findText, flags);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editFindPrevious()
{
  QTextDocument::FindFlags flags;
  if (fFindReplaceData->caseSensitive)
    flags |= QTextDocument::FindCaseSensitively;
  else if (fFindReplaceData->wholeWordsOnly)
    flags |= QTextDocument::FindWholeWords;
 
  flags |= QTextDocument::FindBackward;
 
  currentEditor()->find(fFindReplaceData->findText, flags);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editFindAndReplace()
{
  if ( !currentEditor() )
    return;
 
  // check if first time called, and if yes create find and replace data structure
  if (fFindReplaceData == nullptr) {
    fFindReplaceData = new PFindReplaceData();
    fFindReplaceData->findText = QString("");
    fFindReplaceData->replaceText = QString("");
    fFindReplaceData->caseSensitive = true;
    fFindReplaceData->wholeWordsOnly = false;
    fFindReplaceData->fromCursor = true;
    fFindReplaceData->findBackwards = false;
    fFindReplaceData->selectedText = false;
    fFindReplaceData->promptOnReplace = true;
  }
 
  if (fFindReplaceData == nullptr) {
    QMessageBox::critical(this, "ERROR", "Couldn't invoke find&replace data structure, sorry :-(", QMessageBox::Ok, QMessageBox::NoButton);
    return;
  }
 
  PReplaceDialog *dlg = new PReplaceDialog(fFindReplaceData, currentEditor()->textCursor().hasSelection());
  if (dlg == nullptr) {
    QMessageBox::critical(this, "ERROR", "Couldn't invoke find&replace dialog, sorry :-(", QMessageBox::Ok, QMessageBox::NoButton);
    return;
  }
 
  dlg->exec();
 
  if (dlg->result() != QDialog::Accepted) {
    delete dlg;
    return;
  }
 
  fFindReplaceData = dlg->getData();
 
  delete dlg;
  dlg = nullptr;
 
  if (fFindReplaceData->promptOnReplace)  {
    editFindNext();
 
    PReplaceConfirmationDialog confirmDlg(this);
 
    // connect all the necessary signals/slots
    QObject::connect(confirmDlg.fReplace_pushButton, SIGNAL(clicked()), this, SLOT(replace()));
    QObject::connect(confirmDlg.fReplaceAndClose_pushButton, SIGNAL(clicked()), this, SLOT(replaceAndClose()));
    QObject::connect(confirmDlg.fReplaceAll_pushButton, SIGNAL(clicked()), this, SLOT(replaceAll()));
    QObject::connect(confirmDlg.fFindNext_pushButton, SIGNAL(clicked()), this, SLOT(editFindNext()));
    QObject::connect(this, SIGNAL(close()), &confirmDlg, SLOT(accept()));
 
    confirmDlg.exec();
  } else {
    replaceAll();
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editComment()
{
  if ( !currentEditor() )
    return;
 
  
  QTextCursor curs = currentEditor()->textCursor();
  
  if (curs.hasComplexSelection()) { // multiple selections
    // multiple selections (STILL MISSING)
  } else if (curs.hasSelection()) { // simple selection
    int pos = curs.position();
    int secStart = curs.selectionStart(); // keep start position of the selection
    int secEnd = curs.selectionEnd();     // keep end position of the selection
    curs.clearSelection();
    curs.setPosition(secStart);           // set the anchor to the start of the selection
    curs.movePosition(QTextCursor::StartOfBlock);
    do {
      curs.insertText("#");
    } while (curs.movePosition(QTextCursor::NextBlock) && (curs.position() <= secEnd));
    curs.setPosition(pos+1);
  } else { // no selection
    int pos = curs.position();
    curs.clearSelection();
    curs.movePosition(QTextCursor::StartOfLine);
    curs.insertText("#");
    curs.setPosition(pos+1);
  }  
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::editUncomment()
{
  if ( !currentEditor() )
    return;
 
 
  QTextCursor curs = currentEditor()->textCursor();
 
  if (curs.hasComplexSelection()) {
    // multiple selections (STILL MISSING)
  } else if (curs.hasSelection()) {
    int pos = curs.position();
    int secStart = curs.selectionStart(); // keep start position of the selection
    int secEnd = curs.selectionEnd();     // keep end position of the selection
    curs.clearSelection();
    curs.setPosition(secStart);           // set the anchor to the start of the selection
    curs.movePosition(QTextCursor::StartOfBlock);
    while (curs.position() < secEnd) {
      QString line = curs.block().text();
      if (line.startsWith("#")) {
        line.remove(0, 1);
        curs.select(QTextCursor::BlockUnderCursor);
        curs.removeSelectedText();        
        curs.insertText("\n"+line);
        pos -= 1;
      }
      curs.movePosition(QTextCursor::NextBlock);
    }
    curs.setPosition(pos);
    currentEditor()->setTextCursor(curs); // needed to update document cursor
  } else { // no selection
    int pos = curs.position();
    curs.clearSelection();
    curs.movePosition(QTextCursor::StartOfLine, QTextCursor::MoveAnchor, 1);
    QString line = curs.block().text();
    if (line.startsWith("#")) {
      line.remove(0, 1);
      curs.select(QTextCursor::BlockUnderCursor);
      curs.removeSelectedText();
      if (currentEditor()->textCursor().columnNumber() == 0)
        curs.insertText(line);
      else
        curs.insertText("\n"+line);
      pos -= 1;
    }
    curs.setPosition(pos);
    currentEditor()->setTextCursor(curs); // needed to update document cursor
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::textFamily( const QString &f )
{
  fAdmin->setFontName(f);
 
  if ( currentEditor() == nullptr )
    return;
 
  currentEditor()->setFont(QFont(f,fAdmin->getFontSize()));
  currentEditor()->viewport()->setFocus();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::textSize( const QString &p )
{
  fAdmin->setFontSize(p.toInt());
 
  if ( currentEditor() == nullptr)
    return;
 
  currentEditor()->setFont(QFont(fAdmin->getFontName(), p.toInt()));
  currentEditor()->viewport()->setFocus();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrWiz()
{
  QString cmd = fAdmin->getExecPath() + "/musrWiz";
#if defined(Q_OS_DARWIN)
  cmd = QString("/Applications/musrWiz.app/Contents/MacOS/musrWiz");
#endif
  QString workDir = "./"; // think about it!!
  QStringList arg;
  arg << "--log";
 
  QProcess *proc = new QProcess(this);
  if (proc == nullptr) {
    QMessageBox::critical(nullptr, "ERROR", "Couldn't invoke QProcess!");
    return;
  }
 
  // handle return status of musrWiz
  connect(proc, static_cast<void(QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
          [=, this](int exitCode, QProcess::ExitStatus exitStatus){ exitStatusMusrWiz(exitCode, exitStatus); });
 
  // make sure that the system environment variables are properly set
  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#if defined(Q_OS_DARWIN)
  env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
#else
  env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
#endif
  proc->setProcessEnvironment(env);
  proc->setWorkingDirectory(workDir);
  proc->start(cmd, arg);
  if (!proc->waitForStarted()) {
    // error handling
    QString msg(tr("Could not execute the output command: ")+cmd[0]);
    QMessageBox::critical( nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close );
    return;
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrCalcChisq()
{
  if ( !currentEditor() )
    return;
 
  int result = 0;
  int fittype = currentEditor()->getFitType();
  if (fAdmin->getEstimateN0Flag() && ((fittype==0) || (fittype==4)))
    result = QMessageBox::question(this, "Estimate N0 active",
                           "Do you wish a chisq/mlh evaluation with an automatic N0 estimate?");
 
  QString tabLabel = fTabWidget->tabText(fTabWidget->currentIndex());
  if (tabLabel == "noname") {
    QMessageBox::critical(this, "ERROR", "For a fit a real msr-file is needed.");
    return;
  } else if (tabLabel == "noname*") {
    fileSaveAs();
  } else if (tabLabel.indexOf("*") > 0) {
    fileSave();
  }
 
  QVector<QString> cmd;
  QString str;
  str = fAdmin->getExecPath() + "/musrfit";
 
  cmd.append(str);
  cmd.append(QFileInfo(*fFilenames.find( currentEditor())).fileName() );
  cmd.append("--chisq-only");
  if (fAdmin->getEstimateN0Flag() && (result == QMessageBox::Yes) && ((fittype==0) || (fittype==4)))
    cmd.append("--estimateN0");
  PFitOutputHandler fitOutputHandler(QFileInfo(*fFilenames.find( currentEditor() )).absolutePath(), cmd);
  fitOutputHandler.setModal(true);
  fitOutputHandler.exec();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrFit()
{
  if ( !currentEditor() )
    return;
 
  QString tabLabel = fTabWidget->tabText(fTabWidget->currentIndex());
  if (tabLabel == "noname") {
    QMessageBox::critical(this, "ERROR", "For a fit a real msr-file is needed.");
    return;
  } else if (tabLabel == "noname*") {
    fileSaveAs();
  } else if (tabLabel.indexOf("*") > 0) {
    fileSave();
  }
 
  QVector<QString> cmd;
  QString str;
  str = fAdmin->getExecPath() + "/musrfit";
 
  cmd.append(str);
  cmd.append(QFileInfo(*fFilenames.find( currentEditor())).fileName() );
 
  // check if keep minuit2 output is wished
  if (fAdmin->getKeepMinuit2OutputFlag())
    cmd.append("--keep-mn2-output");
 
  // check if title of the data file should be used to replace the msr-file title
  if (fAdmin->getTitleFromDataFileFlag())
    cmd.append("--title-from-data-file");
 
  // check if dump files are wished
  if (fAdmin->getDumpAsciiFlag()) {
    cmd.append("--dump");
    cmd.append("ascii");
  }
  if (fAdmin->getDumpRootFlag()) {
    cmd.append("--dump");
    cmd.append("root");
  }
 
  // check estimate N0 flag
  if (fAdmin->getEstimateN0Flag()) {
    cmd.append("--estimateN0");
  }
 
  // check yamlOut flag
  if (fAdmin->getYamlOutFlag()) {
    cmd.append("--yaml");
  }
 
  // check how many threads to be used
  cmd.append("--use-no-of-threads");
  QString noThreads = QString("%1").arg(fAdmin->getNoOfThreadsToBeUsed());
  cmd.append(noThreads);
 
  // check per-run-block-chisq flag
  if (fAdmin->getChisqPerRunBlockFlag()) {
    cmd.append("--per-run-block-chisq");
  }
 
  // add timeout
  cmd.append("--timeout");
  QString numStr;
  numStr.setNum(fAdmin->getTimeout());
  cmd.append(numStr);
 
  PFitOutputHandler fitOutputHandler(QFileInfo(*fFilenames.find( currentEditor() )).absolutePath(), cmd);
  fitOutputHandler.setModal(true);
  fFileSystemWatcherActive = false;
  fitOutputHandler.exec();
 
  // handle the reloading of the files
 
  // get current file name
  QString currentFileName = *fFilenames.find( currentEditor() );
  QString complementFileName;
  // check if it is a msr-, mlog-, or another file
  int idx;
  if ((idx = currentFileName.indexOf(".msr")) > 0) { // msr-file
    complementFileName = currentFileName;
    complementFileName.replace(idx, 5, ".mlog");
  } else if ((idx = currentFileName.indexOf(".mlog")) > 0) { // mlog-file
    complementFileName = currentFileName;
    complementFileName.replace(idx, 5, ".msr ");
    complementFileName = complementFileName.trimmed();
  } else { // neither a msr- nor a mlog-file
    QMessageBox::information( this, "musrFit",
    "This is neither a msr- nor a mlog-file, hence no idea what to be done.\n",
    QMessageBox::Ok );
    return;
  }
 
  int currentIdx = fTabWidget->currentIndex();
 
  // reload current file
  fileClose();
  load(currentFileName, currentIdx);
 
  // check if swap file is open as well, and if yes, reload it
  idx = -1;
  for (int i=0; i<fTabWidget->count(); i++) {
    if (fTabWidget->tabText(i).indexOf(complementFileName) >= 0) {
      idx = i;
      break;
    }
  }
  if (idx >= 0) { // complement file is open
    fTabWidget->setCurrentIndex(idx);
    fileClose();
    load(complementFileName, idx);
    fTabWidget->setCurrentIndex(currentIdx);
  }
 
  fileSystemWatcherActivation();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrMsr2Data()
{
  if (fMsr2DataParam == nullptr) {
    fMsr2DataParam = new PMsr2DataParam();
    *fMsr2DataParam = fAdmin->getMsr2DataParam();
  }
 
  // init fMsr2DataParam
  fMsr2DataParam->keepMinuit2Output = fAdmin->getKeepMinuit2OutputFlag();
  fMsr2DataParam->titleFromDataFile = fAdmin->getTitleFromDataFileFlag();
  fMsr2DataParam->estimateN0 = fAdmin->getEstimateN0Flag();
  fMsr2DataParam->yamlOut = fAdmin->getYamlOutFlag();
  fMsr2DataParam->perRunBlockChisq = fAdmin->getChisqPerRunBlockFlag();
 
  PMsr2DataDialog *dlg = new PMsr2DataDialog(fMsr2DataParam, fAdmin->getHelpUrl("msr2data"));
 
  if (dlg == nullptr) {
    QMessageBox::critical(this, "ERROR", "Couldn't invoke msr2data dialog, sorry :-(", QMessageBox::Ok, QMessageBox::NoButton);
    return;
  }
 
  if (dlg->exec() == QDialog::Accepted) {
    QString runList;
    QString runListFileName;
    QFileInfo fi;
    QString str;
    int i, end;   
    QStringList list;
    bool ok;
 
    fMsr2DataParam = dlg->getMsr2DataParam();
    fAdmin->setKeepMinuit2OutputFlag(fMsr2DataParam->keepMinuit2Output);
    fAdmin->setTitleFromDataFileFlag(fMsr2DataParam->titleFromDataFile);
    fAdmin->setEstimateN0Flag(fMsr2DataParam->estimateN0);
    fAdmin->setYamlOutFlag(fMsr2DataParam->yamlOut);
    fAdmin->setChisqPerRunBlockFlag(fMsr2DataParam->perRunBlockChisq);
 
    // analyze parameters
    switch (dlg->getRunTag()) {
      case -1: // not valid
        QMessageBox::critical(this, "ERROR",
           "No valid run list input found :-(\nCannot do anything.",
           QMessageBox::Ok, QMessageBox::NoButton);
        return;
        break;
      case 0:  // run list
        runList = fMsr2DataParam->runList;
        break;
      case 1:  // run list file name
        runListFileName = fMsr2DataParam->runListFileName;
        fi.setFile(QFileInfo(*fFilenames.find( currentEditor() )).absolutePath() + "/" + runListFileName);
        if (!fi.exists()) {
          str = QString("Run List File '%1' doesn't exist.").arg(runListFileName);
          QMessageBox::critical(this, "ERROR",
                str, QMessageBox::Ok, QMessageBox::NoButton);
          return;
        }
        break;
      default: // never should reach this point
        QMessageBox::critical(this, "ERROR",
           "No idea how you could reach this point.\nPlease contact the developers.",
           QMessageBox::Ok, QMessageBox::NoButton);
        return;
        break;
    }
 
    // form command
    QVector<QString> cmd;
 
    str = fAdmin->getExecPath() + "/msr2data";
    cmd.append(str);
 
    // run list argument
    switch (dlg->getRunTag()) {
      case 0:
        end = 0;
        while (!runList.section(' ', end, end, QString::SectionSkipEmpty).isEmpty()) {
          end++;
        }
        // first element
        if (end == 1) {
          str = "[" + runList + "]";
          cmd.append(str);
        } else {
          str = "[" + runList.section(' ', 0, 0, QString::SectionSkipEmpty);
          cmd.append(str);
          // middle elements
          for (i=1; i<end-1; i++) {
            cmd.append(runList.section(' ', i, i, QString::SectionSkipEmpty));
          }
          // last element
          str = runList.section(' ', end-1, end-1, QString::SectionSkipEmpty) + "]";
          cmd.append(str);
        }
        break;
      case 1:
        cmd.append(runListFileName);
        break;
      default:
        break;
    }
 
    // file extension
    str = fMsr2DataParam->msrFileExtension;
    if (str.isEmpty())
      cmd.append("");
    else
      cmd.append(str);
 
    // options
 
    // parameter export list
    if (!fMsr2DataParam->paramList.isEmpty()) {
      cmd.append("paramList");
      QStringList list = fMsr2DataParam->paramList.split(QRegularExpression("[(\\s|,|;)]"), Qt::SkipEmptyParts);
      for (int i=0; i<list.size(); i++)
        cmd.append(list[i]);
    }
 
    // no header flag?
    if (!fMsr2DataParam->writeDbHeader)
      cmd.append("noheader");
 
    // ignore data header info flag present?
    if (fMsr2DataParam->ignoreDataHeaderInfo)
      cmd.append("nosummary");
 
    // template run no fitting but: (i) no fit only flag, (ii) no create msr-file only flag
    if ((fMsr2DataParam->templateRunNo != -1) && !fMsr2DataParam->fitOnly && !fMsr2DataParam->createMsrFileOnly) {
      str = QString("%1").arg(fMsr2DataParam->templateRunNo);
      str = "fit-" + str;
      if (!fMsr2DataParam->chainFit) {
        str += "!";
      }
      cmd.append(str);
    }
 
    // template run no AND create msr-file only flag
    if ((fMsr2DataParam->templateRunNo != -1) && fMsr2DataParam->createMsrFileOnly) {
      str = QString("%1").arg(fMsr2DataParam->templateRunNo);
      str = "msr-" + str;
      cmd.append(str);
    }
 
    // fit only
    if (fMsr2DataParam->fitOnly) {
      str = "fit";
      cmd.append(str);
    }
 
    // keep minuit2 output
    if (fMsr2DataParam->keepMinuit2Output) {
      cmd.append("-k");
    }
 
    // replace msr-file title by data file title. Add flag only if a fit is done
    if (fMsr2DataParam->titleFromDataFile && (fMsr2DataParam->fitOnly || fMsr2DataParam->templateRunNo != -1)) {
      cmd.append("-t");
    }
 
    // estimate N0 (makes sence for single histo and muMinus fits only). Add flag only if a fit is done
    if (fMsr2DataParam->estimateN0 && (fMsr2DataParam->fitOnly || fMsr2DataParam->templateRunNo != -1)) {
      cmd.append("-e");
    }
 
    // yaml out. Add flag only if a fit is done
    if (fMsr2DataParam->yamlOut && (fMsr2DataParam->fitOnly || fMsr2DataParam->templateRunNo != -1)) {
      cmd.append("-y");
    }
 
    // write per-run-block chisq. Add flag only if a fit is done
    if (fMsr2DataParam->perRunBlockChisq && (fMsr2DataParam->fitOnly || fMsr2DataParam->templateRunNo != -1)) {
      cmd.append("-p");
    }
 
    // DB output wished
    if (!fMsr2DataParam->dbOutputFileName.isEmpty()) {
      str = "-o" + fMsr2DataParam->dbOutputFileName;
      cmd.append(str);
    }
 
    // write column data
    if (fMsr2DataParam->writeColumnData) {
      cmd.append("data");
    }
 
    // global flag check
    if (fMsr2DataParam->global) {
      cmd.append("global");
    }
 
    // global+ flag check
    if (fMsr2DataParam->globalPlus) {
      if (fMsr2DataParam->chainFit) {
        cmd.append("global+");
      } else {
        cmd.append("global+!");
      }
    }
 
    // recreate db file
    if (fMsr2DataParam->recreateDbFile) {
      cmd.append("new");
    }
 
    // if NO tab is present use the local directory
    QString workDir = QString("./");
    if (fTabWidget->count() != 0) {
      workDir = QFileInfo(*fFilenames.find( currentEditor() )).absolutePath();
    }
    PFitOutputHandler fitOutputHandler(workDir, cmd);
    fitOutputHandler.setModal(true);
    fFileSystemWatcherActive = false;
    fitOutputHandler.exec();
 
    // check if it is necessary to load msr-files
    if (fMsr2DataParam->openFilesAfterFitting) {
      QString fln;
      QFile *file;
      QTextStream *stream;
      QFileInfo finfo;
      bool alreadOpen=false;
      int idx=0;
 
      if (!fMsr2DataParam->global) { // standard fits
        switch(dlg->getRunTag()) {
          case 0: // run list
            list = getRunList(runList, ok);
            if (!ok)
              return;
            for (int i=0; i<list.size(); i++) {
              fln = list[i];
              if (fMsr2DataParam->msrFileExtension.isEmpty())
                fln += ".msr";
              else
                fln += fMsr2DataParam->msrFileExtension + ".msr";
 
              workDir = QString("./");
              if (fTabWidget->count() != 0) {
                workDir = QFileInfo(*fFilenames.find( currentEditor() )).absolutePath();
              }
              finfo.setFile(workDir + "/" + fln);
              alreadOpen = fileAlreadyOpen(finfo, idx);
              if (!alreadOpen) {
                load(workDir + "/" + fln);
              } else {
                fTabWidget->setCurrentIndex(idx);
                fileReload();
              }
            }
            break;
          case 1: // run list file
            file = new QFile(QFileInfo(*fFilenames.find( currentEditor() )).absolutePath() + "/" + fMsr2DataParam->runListFileName);
            if (!file->open(QIODevice::ReadOnly)) {
              str = QString("Couldn't open run list file %1, sorry.").arg(fMsr2DataParam->runListFileName);
              QMessageBox::critical(this, "ERROR", str.toLatin1(), QMessageBox::Ok, QMessageBox::NoButton);
              return;
            }
 
            stream = new QTextStream(file);
            while ( !stream->atEnd() ) {
              str = stream->readLine(); // line of text excluding '\n'
              str = str.trimmed();
              if (!str.isEmpty() && !str.startsWith("#") && !str.startsWith("run", Qt::CaseInsensitive)) {
                fln = str.section(' ', 0, 0, QString::SectionSkipEmpty);
                if (fMsr2DataParam->msrFileExtension.isEmpty())
                  fln += ".msr";
                else
                  fln += fMsr2DataParam->msrFileExtension + ".msr";
 
                workDir = QString("./");
                if (fTabWidget->count() != 0) {
                  workDir = QFileInfo(*fFilenames.find( currentEditor() )).absolutePath();
                }
                finfo.setFile(workDir + "/" + fln);
                alreadOpen = fileAlreadyOpen(finfo, idx);
                if (!alreadOpen) {
                  load(workDir + "/" + fln);
                } else {
                  fTabWidget->setCurrentIndex(idx);
                  fileReload();
                }
              }
            }
 
            file->close();
 
            // clean up
            delete stream;
            delete file;
            break;
          default:
            break;
        }
      } else { // global tag set
        // get the first run number needed to build the global fit file name
        fln = QString("");
        switch(dlg->getRunTag()) {
          case 0: // run list
            fln = runList.section(" ", 0, 0, QString::SectionSkipEmpty) + QString("+global") + fMsr2DataParam->msrFileExtension + QString(".msr");
            break;
          case 1: // run list file name
            file = new QFile(QFileInfo(*fFilenames.find( currentEditor() )).absolutePath() + "/" + fMsr2DataParam->runListFileName);
            if (!file->open(QIODevice::ReadOnly)) {
              str = QString("Couldn't open run list file %1, sorry.").arg(fMsr2DataParam->runListFileName);
              QMessageBox::critical(this, "ERROR", str.toLatin1(), QMessageBox::Ok, QMessageBox::NoButton);
              return;
            }
 
            stream = new QTextStream(file);
            while ( !stream->atEnd() ) {
              str = stream->readLine(); // line of text excluding '\n'
              str = str.trimmed();
              if (!str.isEmpty() && !str.startsWith("#") && !str.startsWith("run", Qt::CaseInsensitive)) {
                fln = str.section(' ', 0, 0, QString::SectionSkipEmpty);
                break;
              }
            }
 
            file->close();
 
            fln += QString("+global") + fMsr2DataParam->msrFileExtension + QString(".msr");
 
            // clean up
            delete stream;
            delete file;
            break;
          default:
            break;
        }
 
        load(QFileInfo(*fFilenames.find( currentEditor() )).absolutePath() + "/" + fln);
      }
    }
  }
 
  delete dlg;
  dlg = nullptr;
 
  fileSystemWatcherActivation();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrView()
{
  if ( !currentEditor() )
    return;
 
  QString tabLabel = fTabWidget->tabText(fTabWidget->currentIndex());
  if (tabLabel == "noname") {
    QMessageBox::critical(this, "ERROR", "For a view a real mlog/msr-file is needed.");
    return;
  } else if (tabLabel == "noname*") {
    fileSaveAs();
  } else if (tabLabel.indexOf("*") > 0) {
    fileSave();
  }
 
  QString cmd = fAdmin->getExecPath() + "/musrview";
  QString fln="./";
  PSubTextEdit *ce = currentEditor();
  if (ce != nullptr)
    fln = *fFilenames.find(currentEditor());
  QString workDir = QFileInfo(fln).absolutePath();
  QStringList arg;
  QString str;
 
  // file name
  str = fln;
  int pos = str.lastIndexOf("/");
  if (pos != -1)
    str.remove(0, pos+1);
  arg << str;
 
  // timeout
  str.setNum(fAdmin->getTimeout());
  arg << "--timeout" << str;
 
  // start with Fourier?
  if (fAdmin->getMusrviewShowFourierFlag())
    arg << "-f";
 
  // start with averaged data/Fourier?
  if (fAdmin->getMusrviewShowAvgFlag())
    arg << "-a";
 
  // check if theory shall only be calculated at the data points
  if (fAdmin->getMusrviewShowOneToOneFlag())
    arg << "-1";
 
  // add error message box option
  arg << "-s";
 
  QProcess proc;
  // make sure that the system environment variables are properly set
  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#if defined(Q_OS_DARWIN)
  env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
#else
  env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
#endif
  proc.setProgram(cmd);
  proc.setProcessEnvironment(env);
  proc.setArguments(arg);
  proc.setWorkingDirectory(workDir);
  if (!proc.startDetached()) {
      QString msg = QString("musrview failed. Possible reasons:\n");
      msg += QString("* corrupted msr-file.\n");
      msg += QString("* cannot read data-file.\n");
      msg += QString("* many more things can go wrong.\n");
      msg += QString("Please check!");
      QMessageBox::critical(nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close);
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrView2Dat()
{
  QStringList flns = QFileDialog::getOpenFileNames( this, tr("Open msr-/mlog-File"),
                        fLastDirInUse,
                        tr( "msr-Files (*.msr)" ));
  if (flns.isEmpty())
    return;
 
  QString cmd = fAdmin->getExecPath() + "/musrview";
  QString fln="./";
  PSubTextEdit *ce = currentEditor();
  if (ce != nullptr)
    fln = *fFilenames.find(currentEditor());
  QString workDir = QFileInfo(fln).absolutePath();
  QStringList arg;
 
  for (auto it : flns) {
    std::cout << it.toLatin1().data() << std::endl;
    arg.clear();
    arg << it;
 
    // start with Fourier?
    if (fAdmin->getMusrviewShowFourierFlag())
      arg << "-f";
 
    // start with averaged data/Fourier?
    if (fAdmin->getMusrviewShowAvgFlag())
      arg << "-a";
 
    // check if theory shall only be calculated at the data points
    if (fAdmin->getMusrviewShowOneToOneFlag())
      arg << "-1";
 
    arg << "--ascii";
 
    QProcess proc;
    // make sure that the system environment variables are properly set
    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#if defined(Q_OS_DARWIN)
    env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
#else
    env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
#endif
    proc.setProgram(cmd);
    proc.setProcessEnvironment(env);
    proc.setArguments(arg);
    proc.setWorkingDirectory(workDir);
    if (!proc.startDetached()) {
      QString msg = QString("musrview failed. Possible reasons:\n");
      msg += QString("* corrupted msr-file.\n");
      msg += QString("* cannot read data-file.\n");
      msg += QString("* many more things can go wrong.\n");
      msg += QString("Please check!");
      QMessageBox::critical(nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close);
    }
  }
 
  QMessageBox::information(this, "INFO", "<b>In the pipeline</b>.\nIt might take a couple of seconds to complete everything.");
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrT0()
{
  if ( !currentEditor() )
    return;
 
  QString tabLabel = fTabWidget->tabText(fTabWidget->currentIndex());
  if (tabLabel == "noname") {
    QMessageBox::critical(this, "ERROR", "For a view a real mlog/msr-file is needed.");
    return;
  } else if (tabLabel == "noname*") {
    fileSaveAs();
  } else if (tabLabel.indexOf("*") > 0) {
    fileSave();
  }
 
  QString cmd = fAdmin->getExecPath() + "/musrt0";
  QString workDir = QFileInfo(*fFilenames.find(currentEditor())).absolutePath();
  QStringList arg;
  QString str;
 
  // file name
  str = *fFilenames.find(currentEditor());
  int pos = str.lastIndexOf("/");
  if (pos != -1)
    str.remove(0, pos+1);
  arg << str;
 
  // timeout
  str.setNum(fAdmin->getTimeout());
  arg << "--timeout" << str;
 
  QProcess *proc = new QProcess(this);
 
  // make sure that the system environment variables are properly set
  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#if defined(Q_OS_DARWIN)
  env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
#else
  env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
#endif
  proc->setProcessEnvironment(env);
  proc->setWorkingDirectory(workDir);
 
  connect(proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
                         [=, this](int exitCode, QProcess::ExitStatus exitStatus){ fileReload(); });
 
  proc->start(cmd, arg);
  if (!proc->waitForStarted()) {
    // error handling
    QString msg(tr("Could not execute the output command: ")+cmd[0]);
    QMessageBox::critical( nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close );
    return;
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrFT()
{
  PSubTextEdit *ce = currentEditor();
  if (ce == nullptr)
    return;
 
  PGetMusrFTOptionsDialog *dlg = new PGetMusrFTOptionsDialog(*fFilenames.find(currentEditor()), fMusrFTPrevCmd, fAdmin->getHelpUrl("musrFT"));
 
  if (dlg == nullptr) {
    QMessageBox::critical(this, "ERROR musrFT", "Couldn't invoke musrFT Options Dialog.");
    return;
  }
 
  if (dlg->exec() == QDialog::Accepted) {
    fMusrFTPrevCmd = dlg->getMusrFTOptions();
    QProcess *proc = new QProcess(this);
    proc->setStandardOutputFile("musrFT.log");
    proc->setStandardErrorFile("musrFT.log");
    QString cmd = fAdmin->getExecPath() + "/musrFT";
    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#if defined(Q_OS_DARWIN)
    env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
#else
    env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
#endif
    proc->setProcessEnvironment(env);
    proc->start(cmd, fMusrFTPrevCmd);
    if (!proc->waitForStarted()) {
      // error handling
      QString msg(tr("Could not execute the output command: ")+cmd[0]);
      QMessageBox::critical( nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close );
      return;
    }
  }
 
  delete dlg;
  dlg = nullptr;
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrPrefs()
{
  PPrefsDialog *dlg = new PPrefsDialog(fAdmin.get());
 
  if (dlg == nullptr) {
    QMessageBox::critical(this, "ERROR musrPrefs", "Couldn't invoke Preferences Dialog.");
    return;
  }
 
  if (dlg->exec() == QDialog::Accepted) {
    fAdmin->setIgnoreThemeAutoDetection(dlg->getIgnoreThemeAutoDetection());
    fAdmin->setDarkThemeIconsMenuFlag(dlg->getDarkThemeIconsMenuFlag());
    fAdmin->setDarkThemeIconsToolbarFlag(dlg->getDarkThemeIconsToolbarFlag());
    fAdmin->setMusrviewShowFourierFlag(dlg->getMusrviewShowFourierFlag());
    fAdmin->setMusrviewShowAvgFlag(dlg->getMusrviewShowAvgFlag());
    fAdmin->setMusrviewShowOneToOneFlag(dlg->getMusrviewShowOneToOneFlag());
    fAdmin->setKeepMinuit2OutputFlag(dlg->getKeepMinuit2OutputFlag());
    fAdmin->setTitleFromDataFileFlag(dlg->getTitleFromDataFileFlag());
    fAdmin->setEnableMusrT0Flag(dlg->getEnableMusrT0Flag());
    fMusrT0Action->setEnabled(fAdmin->getEnableMusrT0Flag());
    if (dlg->getDump() == 1) {
      fAdmin->setDumpAsciiFlag(true);
      fAdmin->setDumpRootFlag(false);
    } else if (dlg->getDump() == 2) {
      fAdmin->setDumpAsciiFlag(false);
      fAdmin->setDumpRootFlag(true);
    } else {
      fAdmin->setDumpAsciiFlag(false);
      fAdmin->setDumpRootFlag(false);
    }
    fAdmin->setTimeout(dlg->getTimeout());
    fAdmin->setChisqPerRunBlockFlag(dlg->getKeepRunPerBlockChisqFlag());
    fAdmin->setEstimateN0Flag(dlg->getEstimateN0Flag());
    fAdmin->setYamlOutFlag(dlg->getYamlOutFlag());
  }
 
  delete dlg;
  dlg = nullptr;
 
  // check if the dark theme menu icons flag has changed
  if (fAdmin->getDarkThemeIconsMenuFlag() != fDarkMenuIcon) {
    fDarkMenuIcon = !fDarkMenuIcon;
    switchMenuIcons();
  }
  // check if the dark theme toolbar icons flag has changed
  if (fAdmin->getDarkThemeIconsToolbarFlag() != fDarkToolBarIcon) {
    fDarkToolBarIcon = !fDarkToolBarIcon;
    switchToolbarIcons();
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrSetSteps()
{
  if ( !currentEditor() )
    return;
 
  // make sure I have a saved msr-file to work on
  QString tabLabel = fTabWidget->tabText(fTabWidget->currentIndex());
  if (tabLabel == "noname") {
    QMessageBox::critical(this, "ERROR", "For musrStep a real mlog/msr-file is needed.");
    return;
  } else if (tabLabel == "noname*") {
    fileSaveAs();
  } else if (tabLabel.indexOf("*") > 0) {
    fileSave();
  }
 
  // fill the command queue
  QString cmd = fAdmin->getExecPath() + "/musrStep";
#if defined(Q_OS_DARWIN)
  cmd = QString("/Applications/musrStep.app/Contents/MacOS/musrStep");
#endif
  QString workDir = QFileInfo(*fFilenames.find(currentEditor())).absolutePath();
  QStringList arg;
  QString str;
 
  // get file name and feed it to the command queue
  str = *fFilenames.find(currentEditor());
  int pos = str.lastIndexOf("/");
  if (pos != -1)
    str.remove(0, pos+1);
  arg << str;
 
  QProcess *proc = new QProcess(this);
  if (proc == nullptr) {
    QMessageBox::critical(nullptr, "ERROR", "Couldn't invoke QProcess!");
    return;
  }
 
  // handle return status of musrStep
  connect(proc, static_cast<void(QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
          [=, this](int exitCode, QProcess::ExitStatus exitStatus){ exitStatusMusrSetSteps(exitCode, exitStatus); });
 
  // make sure that the system environment variables are properly set
  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#if defined(Q_OS_DARWIN)
  env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
#else
  env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
#endif
  proc->setProcessEnvironment(env);
  proc->setWorkingDirectory(workDir);
  proc->start(cmd, arg);
  if (!proc->waitForStarted()) {
    // error handling
    QString msg(tr("Could not execute the output command: ")+cmd[0]);
    QMessageBox::critical( nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close );
    return;
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrSwapMsrMlog()
{
  if ( !currentEditor() )
    return;
 
  // get current file name
  QString currentFileName = *fFilenames.find( currentEditor() );
  QString swapFileName;
  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
  QString tempFileName = QString("%1/.musrfit/__swap__.msr").arg(env.value("HOME"));
 
  // check if it is a msr-, mlog-, or another file
  int idx;
  if ((idx = currentFileName.indexOf(".msr")) > 0) { // msr-file
    swapFileName = currentFileName;
    swapFileName.replace(idx, 5, ".mlog");
  } else if ((idx = currentFileName.indexOf(".mlog")) > 0) { // mlog-file
    swapFileName = currentFileName;
    swapFileName.replace(idx, 5, ".msr ");
    swapFileName = swapFileName.trimmed();
  } else { // neither a msr- nor a mlog-file
    QMessageBox::information( this, "musrSwapMsrMlog",
    "This is neither a msr- nor a mlog-file, hence nothing to be swapped.\n",
    QMessageBox::Ok );
    return;
  }
 
  // check if the swapFile exists
  if (!QFile::exists(swapFileName)) {
    QString msg = "swap file '" + swapFileName + "' doesn't exist.\nCannot swap anything.";
    QMessageBox::warning( this, "musrSwapMsrMlog",
                          msg, QMessageBox::Ok, QMessageBox::NoButton );
    return;
  }
 
  if (QMessageBox::information(this, "INFO",
                               QString("Will now swap files: %1 <-> %2").arg(currentFileName).arg(swapFileName),
                               QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Cancel)
    return;
 
  // check if the file needs to be saved
  if (fTabWidget->tabText(fTabWidget->currentIndex()).indexOf("*") > 0) { // needs to be saved first
    fileSave();
  }
 
  // swap files
 
  // copy currentFile -> tempFile
  if (QFile::exists(tempFileName)) {
    if (!QFile::remove(tempFileName)) {
      QMessageBox::critical(nullptr, "ERROR", QString("failed to remove %1").arg(tempFileName));
      return;
    }
  }
  if (!QFile::copy(currentFileName, tempFileName)) {
    QMessageBox::critical(nullptr, "ERROR", QString("failed to copy %1 -> %2").arg(currentFileName).arg(tempFileName));
    return;
  }
  // copy swapFile -> currentFile
  if (!QFile::remove(currentFileName)) {
    QMessageBox::critical(nullptr, "ERROR", QString("failed to remove %1").arg(currentFileName));
    return;
  }
  if (!QFile::copy(swapFileName, currentFileName)) {
    QMessageBox::critical(nullptr, "ERROR", QString("failed to copy %1 -> %2").arg(swapFileName).arg(currentFileName));
    return;
  }
  // copy tempFile -> swapFile
  if (!QFile::remove(swapFileName)) {
    QMessageBox::critical(nullptr, "ERROR", QString("failed to remove %1").arg(swapFileName));
    return;
  }
  if (!QFile::copy(tempFileName, swapFileName)) {
    QMessageBox::critical(nullptr, "ERROR", QString("failed to copy %1 -> %2").arg(tempFileName).arg(swapFileName));
    return;
  }
  // clean up
  if (!QFile::remove(tempFileName)) {
    QMessageBox::critical(nullptr, "ERROR", QString("failed to remove %1").arg(tempFileName));
    return;
  }
 
  int currentIdx = fTabWidget->currentIndex();
 
  // reload current file
  fileClose();
  load(currentFileName);
 
  // check if swap file is open as well, and if yes, reload it
  idx = -1;
  for (int i=0; i<fTabWidget->count(); i++) {
    if (fTabWidget->tabText(i).indexOf(swapFileName) >= 0) {
      idx = i;
      break;
    }
  }
  if (idx >= 0) { // swap file is open
    fTabWidget->setCurrentIndex(idx);
    fileClose();
    load(swapFileName);
    fTabWidget->setCurrentIndex(currentIdx);
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::musrDump()
{
  // select a muSR data filename
  QString fileName = QFileDialog::getOpenFileName(this, tr("Select muSR Data File"), "./", tr("muSR Data Files (*.root *.bin *.msr *.nxs)"));
  if (fileName.isEmpty())
    return;
 
  QVector<QString> cmd;
  QString str = fAdmin->getExecPath() + "/dump_header";
  cmd.append(str);
  cmd.append("-fn");
  cmd.append(fileName);
  cmd.append("-c");
 
  PDumpOutputHandler dumpOutputHandler(cmd);
  dumpOutputHandler.setModal(false);
  dumpOutputHandler.exec();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::mupp()
{
  QString cmd("");
  cmd = fAdmin->getExecPath() + "/mupp";
#if defined(Q_OS_DARWIN)
  cmd = QString("/Applications/mupp.app/Contents/MacOS/mupp");
#endif
 
  QStringList arg;
 
  QProcess *proc = new QProcess(this);
 
  QString fln="./";
  PSubTextEdit *ce = currentEditor();
  if (ce != nullptr)
    fln = *fFilenames.find(currentEditor());
  QString workDir = QFileInfo(fln).absolutePath();
 
  // make sure that the system environment variables are properly set
  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#if defined(Q_OS_DARWIN)
  env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
#else
  env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
#endif
  proc->setProcessEnvironment(env);
  proc->setWorkingDirectory(workDir);
  proc->start(cmd, arg);
  if (!proc->waitForStarted()) {
    // error handling
    QString msg(tr("Could not execute the output command: ")+cmd);
    QMessageBox::critical( nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close );
    return;
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::helpContents()
{
  bool ok = QDesktopServices::openUrl(QUrl(fAdmin->getHelpUrl("main"), QUrl::TolerantMode));
  if (!ok) {
    QString msg = QString("<p>Sorry: Couldn't open default web-browser for the help.<br>Please try: <a href=\"%1\">musrfit docu</a> in your web-browser.").arg(fAdmin->getHelpUrl("main"));
    QMessageBox::critical( nullptr, tr("FATAL ERROR"), msg, QMessageBox::Close );
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::helpAbout()
{
  PMusrEditAbout *about = new PMusrEditAbout();
  about->show();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::helpAboutQt()
{
  QMessageBox::aboutQt(this);
}
 
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::exitStatusMusrWiz(int exitCode, QProcess::ExitStatus exitStatus)
{
  if (exitStatus == QProcess::CrashExit) {
    QMessageBox::critical(nullptr, "FATAL ERROR", "musrWiz returned CrashExit.");
    return;
  }
 
  // dialog finished with reject
  if (exitCode == 0)
    return;
 
  // read .musrWiz.log
  QProcessEnvironment procEnv = QProcessEnvironment::systemEnvironment();
  QString pathName = procEnv.value("HOME", "");
  pathName += "/.musrfit/musredit/musrWiz.log";
  QString errMsg;
  std::ifstream fin(pathName.toLatin1().data(), std::ifstream::in);
  if (!fin.is_open()) {
    errMsg = QString("PTextEdit::exitStatusMusrWiz: couldn't read %1 file.").arg(pathName);
    QMessageBox::critical(nullptr, "ERROR", errMsg);
    return;
  }
  char line[128];
  bool musrT0tag = false;
  QString str, pathFileName("");
  while (fin.good()) {
    fin.getline(line, 128);
    str = line;
    if (str.startsWith("path-file-name:")) {
      pathFileName = str.mid(16);
    } else if (str.startsWith("musrt0-tag: yes")) {
      musrT0tag = true;
    }
  }
  fin.close();
 
  load(pathFileName);
 
  // in case there is a 1st empty tab "noname", remove it
  QString tabStr = fTabWidget->tabText(0);
  tabStr.remove('&'); // this is needed since the QTabWidget adds short-cut info as '&' to the tab name
  if (tabStr == "noname") { // has to be the first, otherwise do nothing
    fFileSystemWatcher->removePath("noname");
 
    delete fTabWidget->widget(0);
  }
 
  if (musrT0tag)
    musrT0();
  
  // remove musrWiz.log file
  QFile logFile(pathName);
  if (!logFile.remove()) {
    errMsg = QString("PTextEdit::exitStatusMusrWiz: couldn't delete %1 file.").arg(pathName);
    QMessageBox::critical(nullptr, "ERROR", errMsg);
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::exitStatusMusrSetSteps(int exitCode, QProcess::ExitStatus exitStatus)
{
  if (exitStatus == QProcess::CrashExit) {
    QMessageBox::critical(nullptr, "FATAL ERROR", "musrStep returned CrashExit.");
    return;
  }
 
  // dialog finished with reject
  if (exitCode == 0)
    return;
 
  // dialog finished with save and quite, i.e. accept, hence reload
  QString fln = *fFilenames.find( currentEditor() );
  int idx = fTabWidget->currentIndex();
 
  fileClose();
  load(fln, idx);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fontChanged( const QFont &f )
{
  fFontChanging = true;
  fComboFont->lineEdit()->setText( f.family() );
  fComboSize->lineEdit()->setText( QString::number( f.pointSize() ) );
 
  if (!currentEditor())
    return;
 
  currentEditor()->setFont(f);
  currentEditor()->setWindowModified(false);
  currentEditor()->viewport()->setFocus();
  fFontChanging = false;
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::textChanged(const bool forced)
{
 
  if (!currentEditor())
    return;
 
  if (fFontChanging)
    return;
 
  QString tabLabel = fTabWidget->tabText(fTabWidget->currentIndex());
 
  if ((fTabWidget->tabText(fTabWidget->currentIndex()).indexOf("*") > 0) &&
      !currentEditor()->document()->isModified()) {
    tabLabel.truncate(tabLabel.length()-1);
    fTabWidget->setTabText(fTabWidget->currentIndex(), tabLabel);
  }
 
  if ((fTabWidget->tabText(fTabWidget->currentIndex()).indexOf("*") < 0) &&
      currentEditor()->document()->isModified()) {
    fTabWidget->setTabText(fTabWidget->currentIndex(), tabLabel+"*");
  }
 
  if ((fTabWidget->tabText(fTabWidget->currentIndex()).indexOf("*") < 0) &&
      forced)
    fTabWidget->setTabText(fTabWidget->currentIndex(), tabLabel+"*");
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::currentCursorPosition()
{
  QString str;
  int line=0, pos=0;
  
  pos = currentEditor()->textCursor().columnNumber();
  line = currentEditor()->textCursor().blockNumber();
 
  str = QString("cursor pos: %1, %2").arg(line+1).arg(pos+1);
  statusBar()->showMessage(str);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::replace()
{
  currentEditor()->insertPlainText(fFindReplaceData->replaceText);
 
  editFindNext();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::replaceAndClose()
{
  currentEditor()->insertPlainText(fFindReplaceData->replaceText);
 
  emit close();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::replaceAll()
{
  // set the cursor to the start of the document
  currentEditor()->moveCursor(QTextCursor::Start);
 
  // construct search flags
  QTextDocument::FindFlags flags;
  if (fFindReplaceData->caseSensitive)
    flags |= QTextDocument::FindCaseSensitively;
  else if (fFindReplaceData->findBackwards)
    flags |= QTextDocument::FindBackward;
  else if (fFindReplaceData->wholeWordsOnly)
    flags |= QTextDocument::FindWholeWords;
 
  while (currentEditor()->find(fFindReplaceData->findText, flags)) {
    currentEditor()->insertPlainText(fFindReplaceData->replaceText);
  }
 
  emit close();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::applyFontSettings(int)
{
  QFont font(fAdmin->getFontName(), fAdmin->getFontSize());
  fontChanged(font);
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileChanged(const QString &fileName)
{
  if (!fFileSystemWatcherActive)
    return;
 
  fFileSystemWatcherActive = false;
 
  QString str = "File '" + fileName + "' changed on the system.\nDo you want to reload it?";
  int result = QMessageBox::question(this, "INFO", str, QMessageBox::Yes, QMessageBox::No);
  if (result == QMessageBox::Yes) {
    // find correct file
    int idx = -1;
    for (int i=0; i<fTabWidget->count(); i++) {
      if (fTabWidget->tabText(i) == QFileInfo(fileName).fileName()) {
        idx = i;
        break;
      }
    }
 
    if (idx == -1) {
      fileSystemWatcherActivation();
      return;
    }
 
    // remove file from file system watcher
    fFileSystemWatcher->removePath(fileName);
 
    // close tab
    fTabWidget->removeTab(idx);
    // load it
    load(fileName, idx);
  }
 
  fileSystemWatcherActivation();
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fileSystemWatcherActivation()
{
  if (fFileSystemWatcherTimeout.isActive())
    return;
 
  fFileSystemWatcherTimeout.singleShot(2000, this, SLOT(setFileSystemWatcherActive()));
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::setFileSystemWatcherActive()
{
  fFileSystemWatcherActive = true;
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::jumpToBlock(int idx)
{
  QString str = fJumpToBlock->itemText(idx);
 
  QTextDocument::FindFlags flags= QTextDocument::FindCaseSensitively | QTextDocument::FindWholeWords;
 
  bool found = currentEditor()->find(str, flags);
  if (found)
    return;
 
  // set cursor to start
  currentEditor()->moveCursor(QTextCursor::Start);
  currentEditor()->find(str, flags);
}
 
//----------------------------------------------------------------------------------------------------
bool PTextEdit::getTheme()
{
  if (fAdmin->getIgnoreThemeAutoDetection())
    return false;
 
  fDarkMenuIcon = false; // true if theme is dark
  fDarkToolBarIcon = false; // needed for ubuntu dark since there the menu icons are dark, however the toolbar icons are plain!
 
  QString str = QIcon::themeName();
 
  if (str.isEmpty()) { // this is ugly and eventually needs to be fixed in a more coherent way
    str = QProcessEnvironment::systemEnvironment().value("HOME", QString("??"));
    str += "/.kde4/share/config/kdeglobals";
    bool done = false;
    if (QFile::exists(str)) {
      QFile fln(str);
      if (!fln.open(QIODevice::ReadOnly | QIODevice::Text))
        return false;
      QTextStream fin(&fln);
      QString line("");
      while (!fin.atEnd() && !done) {
        line = fin.readLine();
        if (line.contains("ColorScheme")) {
          if (line.contains("dark", Qt::CaseInsensitive)) {
            fDarkMenuIcon = true;
            fDarkToolBarIcon = true;
          }
          done = true;
        }
      }
      fln.close();
    }
    return done;
  }
 
  if (str.contains("dark", Qt::CaseInsensitive)) {
    fDarkMenuIcon = true;
    if (str.contains("ubuntu", Qt::CaseInsensitive) ||
        str.contains("xfce", Qt::CaseInsensitive) ||
        str.contains("mx", Qt::CaseInsensitive)) {
      fDarkMenuIcon = false;
      fDarkToolBarIcon = false;
    } else {
      fDarkToolBarIcon = true;
    }
  }
  
  return true;
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::fillRecentFiles()
{
  for (int i=0; i<fAdmin->getNumRecentFiles(); i++) {
    fRecentFilesAction[i]->setText(fAdmin->getRecentFile(i));
    fRecentFilesAction[i]->setVisible(true);
  }
}
 
//----------------------------------------------------------------------------------------------------
QStringList PTextEdit::getRunList(QString runListStr, bool &ok)
{
  QStringList result;
  bool isInt;
  QString str;
 
  ok = true;
 
  // first split space separated parts
  QStringList tok = runListStr.split(' ', Qt::SkipEmptyParts);
  for (int i=0; i<tok.size(); i++) {
    if (tok[i].contains('-')) { // list given, hence need to expand
      QStringList runListTok = tok[i].split('-', Qt::SkipEmptyParts);
      if (runListTok.size() != 2) { // error
        ok = false;
        result.clear();
        return result;
      }
      int start=0, end=0;
      start = runListTok[0].toInt(&isInt);
      if (!isInt) {
        ok = false;
        result.clear();
        return result;
      }
      end = runListTok[1].toInt(&isInt);
      if (!isInt) {
        ok = false;
        result.clear();
        return result;
      }
      for (int i=start; i<=end; i++) {
        str = QString("%1").arg(i);
        result << str;
      }
    } else if (tok[i].contains(':')) { // list given, hence need to expand
      QStringList runListTok = tok[i].split(':', Qt::SkipEmptyParts);
      int start{0}, end{0}, step{0};
      if (runListTok.size() != 3) { // error
        ok = false;
        result.clear();
        return result;
      }
      start = runListTok[0].toInt(&isInt);
      if (!isInt) {
        ok = false;
        result.clear();
        return result;
      }
      end = runListTok[1].toInt(&isInt);
      if (!isInt) {
        ok = false;
        result.clear();
        return result;
      }
      step = runListTok[2].toInt(&isInt);
      if (!isInt) {
        ok = false;
        result.clear();
        return result;
      }
      do {
        str = QString("%1").arg(start);
        result << str;
        start += step;
      } while (start <= end);
    } else { // keep it
      result << tok[i];
    }
  }
 
  return result;
}
 
//----------------------------------------------------------------------------------------------------
bool PTextEdit::fileAlreadyOpen(QFileInfo &finfo, int &idx)
{
  bool result = false;
  QFileInfo finfo2;
  QString tabFln;
 
  for (int i=0; i<fTabWidget->count(); i++) {
    tabFln = *fFilenames.find( dynamic_cast<PSubTextEdit*>(fTabWidget->widget(i)));
    finfo2.setFile(tabFln);
    if (finfo.absoluteFilePath() == finfo2.absoluteFilePath()) {
      result = true;
      idx = i;
      break;
    }
  }
 
  return result;
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::switchMenuIcons()
{
  if (fAdmin->getDarkThemeIconsMenuFlag()) { // dark theme icons
    fActions["New"]->setIcon(QIcon(":/icons/document-new-dark.svg"));
    fActions["Open"]->setIcon(QIcon(":/icons/document-open-dark.svg"));
    fActions["Reload"]->setIcon(QIcon(":/icons/view-refresh-dark.svg"));
    fActions["Save"]->setIcon(QIcon(":/icons/document-save-dark.svg"));
    fActions["Print"]->setIcon(QIcon(":/icons/document-print-dark.svg"));
    fActions["Undo"]->setIcon(QIcon(":/icons/edit-undo-dark.svg"));
    fActions["Redo"]->setIcon(QIcon(":/icons/edit-redo-dark.svg"));
    fActions["Copy"]->setIcon(QIcon(":/icons/edit-copy-dark.svg"));
    fActions["Cut"]->setIcon(QIcon(":/icons/edit-cut-dark.svg"));
    fActions["Paste"]->setIcon(QIcon(":/icons/edit-paste-dark.svg"));
    fActions["Find"]->setIcon(QIcon(":/icons/edit-find-dark.svg"));
    fActions["Find Next"]->setIcon(QIcon(":/icons/go-next-use-dark.svg"));
    fActions["Find Previous"]->setIcon(QIcon(":/icons/go-previous-use-dark.svg"));
    fActions["musrWiz"]->setIcon(QIcon(":/icons/musrWiz-32x32-dark.svg"));
    fActions["calcChisq"]->setIcon(QIcon(":/icons/musrchisq-dark.svg"));
    fActions["musrfit"]->setIcon(QIcon(":/icons/musrfit-dark.svg"));
    fActions["Swap Msr/Mlog"]->setIcon(QIcon(":/icons/musrswap-dark.svg"));
    fActions["musrStep"]->setIcon(QIcon(":/icons/musrStep-32x32-dark.svg"));
    fActions["msr2data"]->setIcon(QIcon(":/icons/msr2data-dark.svg"));
    fActions["mupp"]->setIcon(QIcon(":/icons/mupp-dark.svg"));
    fActions["musrview2dat"]->setIcon(QIcon(":/icons/musrview2dat-dark.svg"));
    fActions["musrview"]->setIcon(QIcon(":/icons/musrview-dark.svg"));
    fActions["musrt0"]->setIcon(QIcon(":/icons/musrt0-dark.svg"));
    fActions["musrFT"]->setIcon(QIcon(":/icons/musrFT-dark.svg"));
    fActions["musrprefs"]->setIcon(QIcon(":/icons/musrprefs-dark.svg"));
    fActions["musrdump"]->setIcon(QIcon(":/icons/musrdump-dark.svg"));
  } else { // plain theme icons
    fActions["New"]->setIcon(QIcon(":/icons/document-new-plain.svg"));
    fActions["Open"]->setIcon(QIcon(":/icons/document-open-plain.svg"));
    fActions["Reload"]->setIcon(QIcon(":/icons/view-refresh-plain.svg"));
    fActions["Save"]->setIcon(QIcon(":/icons/document-save-plain.svg"));
    fActions["Print"]->setIcon(QIcon(":/icons/document-print-plain.svg"));
    fActions["Undo"]->setIcon(QIcon(":/icons/edit-undo-plain.svg"));
    fActions["Redo"]->setIcon(QIcon(":/icons/edit-redo-plain.svg"));
    fActions["Copy"]->setIcon(QIcon(":/icons/edit-copy-plain.svg"));
    fActions["Cut"]->setIcon(QIcon(":/icons/edit-cut-plain.svg"));
    fActions["Paste"]->setIcon(QIcon(":/icons/edit-paste-plain.svg"));
    fActions["Find"]->setIcon(QIcon(":/icons/edit-find-plain.svg"));
    fActions["Find Next"]->setIcon(QIcon(":/icons/go-next-use-plain.svg"));
    fActions["Find Previous"]->setIcon(QIcon(":/icons/go-previous-use-plain.svg"));
    fActions["musrWiz"]->setIcon(QIcon(":/icons/musrWiz-32x32.svg"));
    fActions["calcChisq"]->setIcon(QIcon(":/icons/musrchisq-plain.svg"));
    fActions["musrfit"]->setIcon(QIcon(":/icons/musrfit-plain.svg"));
    fActions["Swap Msr/Mlog"]->setIcon(QIcon(":/icons/musrswap-plain.svg"));
    fActions["musrStep"]->setIcon(QIcon(":/icons/musrStep-32x32.svg"));
    fActions["msr2data"]->setIcon(QIcon(":/icons/msr2data-plain.svg"));
    fActions["mupp"]->setIcon(QIcon(":/icons/mupp-plain.svg"));
    fActions["musrview2dat"]->setIcon(QIcon(":/icons/musrview2dat-plain.svg"));
    fActions["musrview"]->setIcon(QIcon(":/icons/musrview-plain.svg"));
    fActions["musrt0"]->setIcon(QIcon(":/icons/musrt0-plain.svg"));
    fActions["musrFT"]->setIcon(QIcon(":/icons/musrFT-plain.svg"));
    fActions["musrprefs"]->setIcon(QIcon(":/icons/musrprefs-plain.svg"));
    fActions["musrdump"]->setIcon(QIcon(":/icons/musrdump-plain.svg"));
  }
}
 
//----------------------------------------------------------------------------------------------------
void PTextEdit::switchToolbarIcons()
{
  if (fAdmin->getDarkThemeIconsToolbarFlag()) { // dark theme icons
    fActions["New-tb"]->setIcon(QIcon(":/icons/document-new-dark.svg"));
    fActions["Open-tb"]->setIcon(QIcon(":/icons/document-open-dark.svg"));
    fActions["Reload-tb"]->setIcon(QIcon(":/icons/view-refresh-dark.svg"));
    fActions["Save-tb"]->setIcon(QIcon(":/icons/document-save-dark.svg"));
    fActions["Print-tb"]->setIcon(QIcon(":/icons/document-print-dark.svg"));
    fActions["Undo-tb"]->setIcon(QIcon(":/icons/edit-undo-dark.svg"));
    fActions["Redo-tb"]->setIcon(QIcon(":/icons/edit-redo-dark.svg"));
    fActions["Copy-tb"]->setIcon(QIcon(":/icons/edit-copy-dark.svg"));
    fActions["Cut-tb"]->setIcon(QIcon(":/icons/edit-cut-dark.svg"));
    fActions["Paste-tb"]->setIcon(QIcon(":/icons/edit-paste-dark.svg"));
    fActions["Find-tb"]->setIcon(QIcon(":/icons/edit-find-dark.svg"));
    fActions["Find Next-tb"]->setIcon(QIcon(":/icons/go-next-use-dark.svg"));
    fActions["Find Previous-tb"]->setIcon(QIcon(":/icons/go-previous-use-dark.svg"));
    fActions["musrWiz-tb"]->setIcon(QIcon(":/icons/musrWiz-32x32-dark.svg"));
    fActions["calcChisq-tb"]->setIcon(QIcon(":/icons/musrchisq-dark.svg"));
    fActions["musrfit-tb"]->setIcon(QIcon(":/icons/musrfit-dark.svg"));
    fActions["Swap Msr/Mlog-tb"]->setIcon(QIcon(":/icons/musrswap-dark.svg"));
    fActions["musrStep-tb"]->setIcon(QIcon(":/icons/musrStep-32x32-dark.svg"));
    fActions["msr2data-tb"]->setIcon(QIcon(":/icons/msr2data-dark.svg"));
    fActions["mupp-tb"]->setIcon(QIcon(":/icons/mupp-dark.svg"));
    fActions["musrview2dat-tb"]->setIcon(QIcon(":/icons/musrview2dat-dark.svg"));
    fActions["musrview-tb"]->setIcon(QIcon(":/icons/musrview-dark.svg"));
    fActions["musrt0-tb"]->setIcon(QIcon(":/icons/musrt0-dark.svg"));
    fActions["musrFT-tb"]->setIcon(QIcon(":/icons/musrFT-dark.svg"));
    fActions["musrprefs-tb"]->setIcon(QIcon(":/icons/musrprefs-dark.svg"));
    fActions["musrdump-tb"]->setIcon(QIcon(":/icons/musrdump-dark.svg"));
  } else { // plain theme icons
    fActions["New-tb"]->setIcon(QIcon(":/icons/document-new-plain.svg"));
    fActions["Open-tb"]->setIcon(QIcon(":/icons/document-open-plain.svg"));
    fActions["Reload-tb"]->setIcon(QIcon(":/icons/view-refresh-plain.svg"));
    fActions["Save-tb"]->setIcon(QIcon(":/icons/document-save-plain.svg"));
    fActions["Print-tb"]->setIcon(QIcon(":/icons/document-print-plain.svg"));
    fActions["Undo-tb"]->setIcon(QIcon(":/icons/edit-undo-plain.svg"));
    fActions["Redo-tb"]->setIcon(QIcon(":/icons/edit-redo-plain.svg"));
    fActions["Copy-tb"]->setIcon(QIcon(":/icons/edit-copy-plain.svg"));
    fActions["Cut-tb"]->setIcon(QIcon(":/icons/edit-cut-plain.svg"));
    fActions["Paste-tb"]->setIcon(QIcon(":/icons/edit-paste-plain.svg"));
    fActions["Find-tb"]->setIcon(QIcon(":/icons/edit-find-plain.svg"));
    fActions["Find Next-tb"]->setIcon(QIcon(":/icons/go-next-use-plain.svg"));
    fActions["Find Previous-tb"]->setIcon(QIcon(":/icons/go-previous-use-plain.svg"));
    fActions["musrWiz-tb"]->setIcon(QIcon(":/icons/musrWiz-32x32.svg"));
    fActions["calcChisq-tb"]->setIcon(QIcon(":/icons/musrchisq-plain.svg"));
    fActions["musrfit-tb"]->setIcon(QIcon(":/icons/musrfit-plain.svg"));
    fActions["Swap Msr/Mlog-tb"]->setIcon(QIcon(":/icons/musrswap-plain.svg"));
    fActions["musrStep-tb"]->setIcon(QIcon(":/icons/musrStep-32x32.svg"));
    fActions["msr2data-tb"]->setIcon(QIcon(":/icons/msr2data-plain.svg"));
    fActions["mupp-tb"]->setIcon(QIcon(":/icons/mupp-plain.svg"));
    fActions["musrview2dat-tb"]->setIcon(QIcon(":/icons/musrview2dat-plain.svg"));
    fActions["musrview-tb"]->setIcon(QIcon(":/icons/musrview-plain.svg"));
    fActions["musrt0-tb"]->setIcon(QIcon(":/icons/musrt0-plain.svg"));
    fActions["musrFT-tb"]->setIcon(QIcon(":/icons/musrFT-plain.svg"));
    fActions["musrprefs-tb"]->setIcon(QIcon(":/icons/musrprefs-plain.svg"));
    fActions["musrdump-tb"]->setIcon(QIcon(":/icons/musrdump-plain.svg"));
  }
}
 
//----------------------------------------------------------------------------------------------------
// END
//----------------------------------------------------------------------------------------------------