1224 lines
42 KiB
C++
1224 lines
42 KiB
C++
/****************************************************************************
|
|
|
|
PAdmin.cpp
|
|
|
|
Author: Andreas Suter
|
|
e-mail: andreas.suter@psi.ch
|
|
|
|
*****************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* Copyright (C) 2010-2025 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 <cstdlib>
|
|
#include <iostream>
|
|
|
|
#include <QMessageBox>
|
|
#include <QString>
|
|
#include <QStringView>
|
|
#include <QLatin1String>
|
|
#include <QFile>
|
|
#include <QTextStream>
|
|
#include <QVector>
|
|
#include <QDir>
|
|
#include <QProcessEnvironment>
|
|
#include <QSysInfo>
|
|
#include <QIODevice>
|
|
|
|
#include "musrfit-info.h"
|
|
#include "PAdmin.h"
|
|
|
|
//--------------------------------------------------------------------------
|
|
// implementation of PAdminXMLParser class
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>XML Parser class for the musredit administration file.
|
|
*
|
|
* \param fln file name of the musredit startup xml-file
|
|
* \param admin pointer to an admin class instance.
|
|
*/
|
|
PAdminXMLParser::PAdminXMLParser(const QString& fln, PAdmin *admin) : fAdmin(admin)
|
|
{
|
|
fValid = false;
|
|
fKeyWord = eEmpty;
|
|
fFunc = false;
|
|
|
|
QFile file(fln);
|
|
if (!file.open(QFile::ReadOnly | QFile::Text) || (file.size()==0)) {
|
|
// warning and create default
|
|
QMessageBox::StandardButton ret = QMessageBox::warning(nullptr, "WARNING", "The musredit_startup.xml is corrupted. Create a default one?", QMessageBox::Yes | QMessageBox::No);
|
|
if (ret == QMessageBox::Yes) {
|
|
fAdmin->createMusreditStartupFile();
|
|
}
|
|
}
|
|
|
|
fValid = parse(&file);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>parse the musredit startup xml-file.
|
|
*
|
|
* \param device QFile object of the musredit startup xml-file
|
|
*
|
|
* @return true on success, false otherwise
|
|
*/
|
|
bool PAdminXMLParser::parse(QIODevice *device)
|
|
{
|
|
fXml.setDevice(device);
|
|
|
|
bool expectChars = false;
|
|
while (!fXml.atEnd()) {
|
|
fXml.readNext();
|
|
if (fXml.isStartDocument()) {
|
|
startDocument();
|
|
} else if (fXml.isStartElement()) {
|
|
startElement();
|
|
expectChars = true;
|
|
} else if (fXml.isCharacters() && expectChars) {
|
|
characters();
|
|
} else if (fXml.isEndElement()) {
|
|
endElement();
|
|
expectChars = false;
|
|
} else if (fXml.isEndDocument()) {
|
|
endDocument();
|
|
}
|
|
}
|
|
if (fXml.hasError()) {
|
|
QString msg;
|
|
msg = QString("%1 Line %2, column %3").arg(fXml.errorString()).arg(fXml.lineNumber()).arg(fXml.columnNumber());
|
|
QMessageBox::critical(nullptr, "ERROR", msg, QMessageBox::Ok, QMessageBox::NoButton);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Routine called at the beginning of the XML parsing process.
|
|
*/
|
|
bool PAdminXMLParser::startDocument()
|
|
{
|
|
// nothing to be done here for now
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Routine called when a new XML tag is found. Here it is used
|
|
* to set a tag for filtering afterwards the content.
|
|
*/
|
|
bool PAdminXMLParser::startElement()
|
|
{
|
|
QString qName = fXml.name().toString();
|
|
|
|
if (qName == "timeout") {
|
|
fKeyWord = eTimeout;
|
|
} else if (qName == "font_name") {
|
|
fKeyWord = eFontName;
|
|
} else if (qName == "font_size") {
|
|
fKeyWord = eFontSize;
|
|
} else if (qName == "exec_path") {
|
|
fKeyWord = eExecPath;
|
|
} else if (qName == "default_save_path") {
|
|
fKeyWord = eDefaultSavePath;
|
|
} else if (qName == "title_from_data_file") {
|
|
fKeyWord = eTitleFromDataFile;
|
|
} else if (qName == "musrview_show_fourier") {
|
|
fKeyWord = eMusrviewShowFourier;
|
|
} else if (qName == "musrview_show_avg") {
|
|
fKeyWord = eMusrviewShowAvg;
|
|
} else if (qName == "musrview_show_one_to_one") {
|
|
fKeyWord = eMusrviewShowOneToOne;
|
|
} else if (qName == "enable_musrt0") {
|
|
fKeyWord = eEnableMusrT0;
|
|
} else if (qName == "ignore_theme_auto_detection") {
|
|
fKeyWord = eIgnoreThemeAutoDetection;
|
|
} else if (qName == "dark_theme_icons_menu") {
|
|
fKeyWord = eDarkThemeIconsMenu;
|
|
} else if (qName == "dark_theme_icons_toolbar") {
|
|
fKeyWord = eDarkThemeIconsToolbar;
|
|
} else if (qName == "edit_w") {
|
|
fKeyWord = eEditW;
|
|
} else if (qName == "edit_h") {
|
|
fKeyWord = eEditH;
|
|
} else if (qName == "keep_minuit2_output") {
|
|
fKeyWord = eKeepMinuit2Output;
|
|
} else if (qName == "dump_ascii") {
|
|
fKeyWord = eDumpAscii;
|
|
} else if (qName == "dump_root") {
|
|
fKeyWord = eDumpRoot;
|
|
} else if (qName == "estimate_n0") {
|
|
fKeyWord = eEstimateN0;
|
|
} else if (qName == "yaml_out") {
|
|
fKeyWord = eYamlOut;
|
|
} else if (qName == "chisq_per_run_block") {
|
|
fKeyWord = eChisqPreRunBlock;
|
|
} else if (qName == "path_file_name") {
|
|
fKeyWord = eRecentFile;
|
|
} else if (qName == "beamline") {
|
|
fKeyWord = eBeamline;
|
|
} else if (qName == "institute") {
|
|
fKeyWord = eInstitute;
|
|
} else if (qName == "file_format") {
|
|
fKeyWord = eFileFormat;
|
|
} else if (qName == "lifetime_correction") {
|
|
fKeyWord = eLifetimeCorrection;
|
|
} else if (qName == "musr_web_main") {
|
|
fKeyWord = eHelpMain;
|
|
} else if (qName == "musr_web_title") {
|
|
fKeyWord = eHelpTitle;
|
|
} else if (qName == "musr_web_parameters") {
|
|
fKeyWord = eHelpParameters;
|
|
} else if (qName == "musr_web_theory") {
|
|
fKeyWord = eHelpTheory;
|
|
} else if (qName == "musr_web_functions") {
|
|
fKeyWord = eHelpFunctions;
|
|
} else if (qName == "musr_web_run") {
|
|
fKeyWord = eHelpRun;
|
|
} else if (qName == "musr_web_command") {
|
|
fKeyWord = eHelpCommand;
|
|
} else if (qName == "musr_web_fourier") {
|
|
fKeyWord = eHelpFourier;
|
|
} else if (qName == "musr_web_plot") {
|
|
fKeyWord = eHelpPlot;
|
|
} else if (qName == "musr_web_statistic") {
|
|
fKeyWord = eHelpStatistic;
|
|
} else if (qName == "musr_web_msr2data") {
|
|
fKeyWord = eHelpMsr2Data;
|
|
} else if (qName == "musr_web_musrFT") {
|
|
fKeyWord = eHelpMusrFT;
|
|
} else if (qName == "chain_fit") {
|
|
fKeyWord = eChainFit;
|
|
} else if (qName == "write_data_header") {
|
|
fKeyWord = eWriteDataHeader;
|
|
} else if (qName == "ignore_data_header_info") {
|
|
fKeyWord = eIgnoreDataHeaderInfo;
|
|
} else if (qName == "keep_minuit2_output") {
|
|
fKeyWord = eKeepMinuit2Output;
|
|
} else if (qName == "write_column_data") {
|
|
fKeyWord = eWriteColumnData;
|
|
} else if (qName == "recreate_data_file") {
|
|
fKeyWord = eRecreateDataFile;
|
|
} else if (qName == "open_file_after_fitting") {
|
|
fKeyWord = eOpenFileAfterFitting;
|
|
} else if (qName == "create_msr_file_only") {
|
|
fKeyWord = eCreateMsrFileOnly;
|
|
} else if (qName == "fit_only") {
|
|
fKeyWord = eFitOnly;
|
|
} else if (qName == "global") {
|
|
fKeyWord = eGlobal;
|
|
} else if (qName == "global_plus") {
|
|
fKeyWord = eGlobalPlus;
|
|
} else if (qName == "func_pixmap_path") {
|
|
fKeyWord = eTheoFuncPixmapPath;
|
|
} else if (qName == "func") {
|
|
fKeyWord = eFunc;
|
|
fFunc = true;
|
|
// init theory item
|
|
fTheoryItem.name = "";
|
|
fTheoryItem.comment = "";
|
|
fTheoryItem.label = "";
|
|
fTheoryItem.pixmapName = "";
|
|
fTheoryItem.pixmap = QPixmap();
|
|
fTheoryItem.params = -1;
|
|
} else if (qName == "name") {
|
|
fKeyWord = eFuncName;
|
|
} else if (qName == "comment") {
|
|
fKeyWord = eFuncComment;
|
|
} else if (qName == "label") {
|
|
fKeyWord = eFuncLabel;
|
|
} else if (qName == "pixmap") {
|
|
fKeyWord = eFuncPixmap;
|
|
} else if (qName == "params") {
|
|
fKeyWord = eFuncParams;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Routine called when the end XML tag is found. It is used to
|
|
* put the filtering tag to 'empty'. It also resets the fFunc flag in case
|
|
* the entry was a theory function.
|
|
*/
|
|
bool PAdminXMLParser::endElement()
|
|
{
|
|
fKeyWord = eEmpty;
|
|
|
|
QString qName = fXml.name().toString();
|
|
|
|
if (qName == "func") {
|
|
fFunc = false;
|
|
fAdmin->addTheoryItem(fTheoryItem);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>This routine delivers the content of an XML tag. It fills the
|
|
* content into the load data structure.
|
|
*/
|
|
bool PAdminXMLParser::characters()
|
|
{
|
|
QString str = fXml.text().toString();
|
|
if (str.isEmpty())
|
|
return true;
|
|
|
|
QString help;
|
|
bool flag, ok;
|
|
int ival;
|
|
|
|
switch (fKeyWord) {
|
|
case eTimeout:
|
|
ival = QString(str.toLatin1()).trimmed().toInt(&ok);
|
|
if (ok)
|
|
fAdmin->setTimeout(ival);
|
|
break;
|
|
case eFontName:
|
|
fAdmin->setFontName(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
case eFontSize:
|
|
ival = QString(str.toLatin1()).trimmed().toInt(&ok);
|
|
if (ok)
|
|
fAdmin->setFontSize(ival);
|
|
break;
|
|
case eExecPath:
|
|
fAdmin->setExecPath(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
case eDefaultSavePath:
|
|
fAdmin->setDefaultSavePath(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
case eTitleFromDataFile:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setTitleFromDataFileFlag(flag);
|
|
break;
|
|
case eMusrviewShowFourier:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setMusrviewShowFourierFlag(flag);
|
|
break;
|
|
case eMusrviewShowAvg:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setMusrviewShowAvgFlag(flag);
|
|
break;
|
|
case eMusrviewShowOneToOne:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setMusrviewShowOneToOneFlag(flag);
|
|
break;
|
|
case eEnableMusrT0:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setEnableMusrT0Flag(flag);
|
|
break;
|
|
case eIgnoreThemeAutoDetection:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setIgnoreThemeAutoDetection(flag);
|
|
break;
|
|
case eDarkThemeIconsMenu:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setDarkThemeIconsMenuFlag(flag);
|
|
break;
|
|
case eDarkThemeIconsToolbar:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setDarkThemeIconsToolbarFlag(flag);
|
|
break;
|
|
case eEditW:
|
|
ival = QString(str.toLatin1()).trimmed().toInt(&ok);
|
|
if (ok)
|
|
fAdmin->setEditWidth(ival);
|
|
break;
|
|
case eEditH:
|
|
ival = QString(str.toLatin1()).trimmed().toInt(&ok);
|
|
if (ok)
|
|
fAdmin->setEditHeight(ival);
|
|
break;
|
|
case eKeepMinuit2Output:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.keepMinuit2Output = flag;
|
|
fAdmin->setKeepMinuit2OutputFlag(flag);
|
|
break;
|
|
case eDumpAscii:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setDumpAsciiFlag(flag);
|
|
break;
|
|
case eDumpRoot:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setDumpRootFlag(flag);
|
|
break;
|
|
case eEstimateN0:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.estimateN0 = flag;
|
|
fAdmin->setEstimateN0Flag(flag);
|
|
break;
|
|
case eYamlOut:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.yamlOut = flag;
|
|
fAdmin->setYamlOutFlag(flag);
|
|
break;
|
|
case eChisqPreRunBlock:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.perRunBlockChisq = flag;
|
|
fAdmin->setChisqPerRunBlockFlag(flag);
|
|
break;
|
|
case eRecentFile:
|
|
fAdmin->addRecentFile(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
case eBeamline:
|
|
fAdmin->setBeamline(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
case eInstitute:
|
|
fAdmin->setInstitute(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
case eFileFormat:
|
|
fAdmin->setFileFormat(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
case eLifetimeCorrection:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->setLifetimeCorrectionFlag(flag);
|
|
break;
|
|
case eHelpMain:
|
|
fAdmin->setHelpUrl("main", str);
|
|
break;
|
|
case eHelpTitle:
|
|
fAdmin->setHelpUrl("title", str);
|
|
break;
|
|
case eHelpParameters:
|
|
fAdmin->setHelpUrl("parameters", str);
|
|
break;
|
|
case eHelpTheory:
|
|
fAdmin->setHelpUrl("theory", str);
|
|
break;
|
|
case eHelpFunctions:
|
|
fAdmin->setHelpUrl("functions", str);
|
|
break;
|
|
case eHelpRun:
|
|
fAdmin->setHelpUrl("run", str);
|
|
break;
|
|
case eHelpCommand:
|
|
fAdmin->setHelpUrl("command", str);
|
|
break;
|
|
case eHelpFourier:
|
|
fAdmin->setHelpUrl("fourier", str);
|
|
break;
|
|
case eHelpPlot:
|
|
fAdmin->setHelpUrl("plot", str);
|
|
break;
|
|
case eHelpStatistic:
|
|
fAdmin->setHelpUrl("statistic", str);
|
|
break;
|
|
case eHelpMsr2Data:
|
|
fAdmin->setHelpUrl("msr2data", str);
|
|
break;
|
|
case eHelpMusrFT:
|
|
fAdmin->setHelpUrl("musrFT", str);
|
|
break;
|
|
case eChainFit:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.chainFit = flag;
|
|
break;
|
|
case eWriteDataHeader:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.writeDbHeader = flag;
|
|
break;
|
|
case eIgnoreDataHeaderInfo:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.ignoreDataHeaderInfo = flag;
|
|
break;
|
|
case eWriteColumnData:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.writeColumnData = flag;
|
|
break;
|
|
case eRecreateDataFile:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.recreateDbFile = flag;
|
|
break;
|
|
case eOpenFileAfterFitting:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.openFilesAfterFitting = flag;
|
|
break;
|
|
case eCreateMsrFileOnly:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.createMsrFileOnly = flag;
|
|
break;
|
|
case eFitOnly:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.fitOnly = flag;
|
|
break;
|
|
case eGlobal:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.global = flag;
|
|
break;
|
|
case eGlobalPlus:
|
|
if (str == "y")
|
|
flag = true;
|
|
else
|
|
flag = false;
|
|
fAdmin->fMsr2DataParam.globalPlus = flag;
|
|
break;
|
|
case eTheoFuncPixmapPath:
|
|
fAdmin->setTheoFuncPixmapPath(QString(str.toLatin1()).trimmed());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (fFunc) {
|
|
bool ok;
|
|
switch (fKeyWord) {
|
|
case eFuncName:
|
|
fTheoryItem.name = QString(str.toLatin1()).trimmed();
|
|
break;
|
|
case eFuncComment:
|
|
fTheoryItem.comment = QString(str.toLatin1()).trimmed();
|
|
break;
|
|
case eFuncLabel:
|
|
fTheoryItem.label = QString(str.toLatin1()).trimmed();
|
|
break;
|
|
case eFuncPixmap:
|
|
fTheoryItem.pixmapName = QString(str.toLatin1()).trimmed();
|
|
break;
|
|
case eFuncParams:
|
|
fTheoryItem.params = str.toInt(&ok);
|
|
if (!ok)
|
|
return false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Called at the end of the XML parse process. It checks if default paths
|
|
* contain system variables, and if so expand them for the further use.
|
|
*/
|
|
bool PAdminXMLParser::endDocument()
|
|
{
|
|
// check if all necessary items are found
|
|
QString str;
|
|
|
|
if (fAdmin->getExecPath().indexOf('$') >= 0) {
|
|
str = expandPath(fAdmin->getExecPath());
|
|
if (!str.isEmpty())
|
|
fAdmin->setExecPath(str);
|
|
}
|
|
|
|
if (fAdmin->getDefaultSavePath().indexOf('$') >= 0) {
|
|
str = expandPath(fAdmin->getDefaultSavePath());
|
|
if (!str.isEmpty())
|
|
fAdmin->setDefaultSavePath(str);
|
|
}
|
|
|
|
if (fAdmin->getTheoFuncPixmapPath().indexOf('$') >=0) {
|
|
str = expandPath(fAdmin->getTheoFuncPixmapPath());
|
|
if (!str.isEmpty())
|
|
fAdmin->setTheoFuncPixmapPath(str);
|
|
}
|
|
|
|
//as35 dump admin - only for debugging
|
|
//as35 dump();
|
|
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Dumps the content of the admin class. For debugging purposes only.
|
|
*/
|
|
void PAdminXMLParser::dump()
|
|
{
|
|
std::cout << "debug> +++++++++++++++++++++++" << std::endl;
|
|
std::cout << "debug> general:" << std::endl;
|
|
std::cout << "debug> exec_path : " << fAdmin->getExecPath().toLatin1().data() << std::endl;
|
|
std::cout << "debug> default_save_path : " << fAdmin->getDefaultSavePath().toLatin1().data() << std::endl;
|
|
std::cout << "debug> timeout : " << fAdmin->getTimeout() << std::endl;
|
|
std::cout << "debug> keep_minuit2_output : " << fAdmin->getKeepMinuit2OutputFlag() << std::endl;
|
|
std::cout << "debug> dump_ascii : " << fAdmin->getDumpAsciiFlag() << std::endl;
|
|
std::cout << "debug> dump_root : " << fAdmin->getDumpRootFlag() << std::endl;
|
|
std::cout << "debug> title_from_data_file : " << fAdmin->getTitleFromDataFileFlag() << std::endl;
|
|
std::cout << "debug> chisq_per_run_block : " << fAdmin->getChisqPerRunBlockFlag() << std::endl;
|
|
std::cout << "debug> estimate_n0 : " << fAdmin->getEstimateN0Flag() << std::endl;
|
|
std::cout << "debug> yaml_out : " << fAdmin->getYamlOutFlag() << std::endl;
|
|
std::cout << "debug> musrview_show_fourier : " << fAdmin->getMusrviewShowFourierFlag() << std::endl;
|
|
std::cout << "debug> musrview_show_avg : " << fAdmin->getMusrviewShowAvgFlag() << std::endl;
|
|
std::cout << "debug> enable_musrt0 : " << fAdmin->getEnableMusrT0Flag() << std::endl;
|
|
std::cout << "debug> ignore_theme_auto_detection : " << fAdmin->getIgnoreThemeAutoDetection() << std::endl;
|
|
std::cout << "debug> dark_theme_icons_menu : " << fAdmin->getDarkThemeIconsMenuFlag() << std::endl;
|
|
std::cout << "debug> dark_theme_icons_toolbar : " << fAdmin->getDarkThemeIconsToolbarFlag() << std::endl;
|
|
std::cout << "debug> edit_w : " << fAdmin->getEditWidth() << std::endl;
|
|
std::cout << "debug> edit_h : " << fAdmin->getEditHeight() << std::endl;
|
|
std::cout << "debug> +++++++++++++++++++++++" << std::endl;
|
|
std::cout << "debug> recent_files:" << std::endl;
|
|
for (int i=0; i<fAdmin->getNumRecentFiles(); i++) {
|
|
std::cout << "debug> recent_file " << i << ":" << fAdmin->getRecentFile(i).toLatin1().data() << std::endl;
|
|
}
|
|
std::cout << "debug> +++++++++++++++++++++++" << std::endl;
|
|
std::cout << "debug> help_section:" << std::endl;
|
|
std::cout << "debug> musr_web_main : " << fAdmin->getHelpUrl("main").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_title : " << fAdmin->getHelpUrl("title").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_parameters : " << fAdmin->getHelpUrl("parameters").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_theory : " << fAdmin->getHelpUrl("theory").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_functions : " << fAdmin->getHelpUrl("functions").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_run : " << fAdmin->getHelpUrl("run").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_command : " << fAdmin->getHelpUrl("command").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_fourier : " << fAdmin->getHelpUrl("fourier").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_plot : " << fAdmin->getHelpUrl("plot").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_statistic : " << fAdmin->getHelpUrl("statistic").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_msr2data : " << fAdmin->getHelpUrl("msr2data").toLatin1().data() << std::endl;
|
|
std::cout << "debug> musr_web_musrFT : " << fAdmin->getHelpUrl("musrFT").toLatin1().data() << std::endl;
|
|
std::cout << "debug> +++++++++++++++++++++++" << std::endl;
|
|
std::cout << "debug> font_section:" << std::endl;
|
|
std::cout << "debug> font_name : " << fAdmin->getFontName().toLatin1().data() << std::endl;
|
|
std::cout << "debug> font_size : " << fAdmin->getFontSize() << std::endl;
|
|
std::cout << "debug> +++++++++++++++++++++++" << std::endl;
|
|
std::cout << "debug> msr_file_defaults:" << std::endl;
|
|
std::cout << "debug> beamline : " << fAdmin->getBeamline().toLatin1().data() << std::endl;
|
|
std::cout << "debug> institute : " << fAdmin->getInstitute().toLatin1().data() << std::endl;
|
|
std::cout << "debug> file_format : " << fAdmin->getFileFormat().toLatin1().data() << std::endl;
|
|
std::cout << "debug> lifetime_correction : " << fAdmin->getLifetimeCorrectionFlag() << std::endl;
|
|
std::cout << "debug> +++++++++++++++++++++++" << std::endl;
|
|
std::cout << "debug> msr2data_defaults:" << std::endl;
|
|
std::cout << "debug> chain_fit : " << fAdmin->getMsr2DataParam().chainFit << std::endl;
|
|
std::cout << "debug> write_data_header : " << fAdmin->getMsr2DataParam().writeDbHeader << std::endl;
|
|
std::cout << "debug> ignore_data_header_info : " << fAdmin->getMsr2DataParam().ignoreDataHeaderInfo << std::endl;
|
|
std::cout << "debug> keep_minuit2_output : " << fAdmin->getMsr2DataParam().keepMinuit2Output << std::endl;
|
|
std::cout << "debug> write_column_data : " << fAdmin->getMsr2DataParam().writeColumnData << std::endl;
|
|
std::cout << "debug> recreate_data_file : " << fAdmin->getMsr2DataParam().recreateDbFile << std::endl;
|
|
std::cout << "debug> open_file_after_fitting : " << fAdmin->getMsr2DataParam().openFilesAfterFitting << std::endl;
|
|
std::cout << "debug> create_msr_file_only : " << fAdmin->getMsr2DataParam().createMsrFileOnly << std::endl;
|
|
std::cout << "debug> fit_only : " << fAdmin->getMsr2DataParam().fitOnly << std::endl;
|
|
std::cout << "debug> global : " << fAdmin->getMsr2DataParam().global << std::endl;
|
|
std::cout << "debug> global_plus : " << fAdmin->getMsr2DataParam().globalPlus << std::endl;
|
|
std::cout << "debug> +++++++++++++++++++++++" << std::endl;
|
|
std::cout << "debug> theory_functions:" << std::endl;
|
|
std::cout << "debug> func_pixmap_path : " << fAdmin->getTheoFuncPixmapPath().toLatin1().data() << std::endl;
|
|
std::cout << "debug> #theory : " << fAdmin->getTheoryCounts() << std::endl;
|
|
PTheory *theo;
|
|
for (unsigned int i=0; i<fAdmin->getTheoryCounts(); i++) {
|
|
theo = fAdmin->getTheoryItem(i);
|
|
std::cout << "debug> -------" << std::endl;
|
|
std::cout << "debug> name : " << theo->name.toLatin1().data() << std::endl;
|
|
std::cout << "debug> comment : " << theo->comment.toLatin1().data() << std::endl;
|
|
std::cout << "debug> label : " << theo->label.toLatin1().data() << std::endl;
|
|
std::cout << "debug> pixmapName : " << theo->pixmapName.toLatin1().data() << std::endl;
|
|
std::cout << "debug> params : " << theo->params << std::endl;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Expands system variables to full path, e.g. <tt>$HOME -> \home\user</tt>
|
|
*
|
|
* \param str path string with none expanded system variables.
|
|
*/
|
|
QString PAdminXMLParser::expandPath(const QString &str)
|
|
{
|
|
QString token;
|
|
QString path;
|
|
QString msg;
|
|
QString newStr="";
|
|
|
|
QProcessEnvironment procEnv = QProcessEnvironment::systemEnvironment();
|
|
|
|
QStringList list = str.split("/");
|
|
|
|
for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
|
|
token = *it;
|
|
if (token.contains("$")) {
|
|
token.remove('$');
|
|
if (!procEnv.contains(token)) {
|
|
msg = QString("Couldn't find '%1'. Some things might not work properly").arg(token);
|
|
QMessageBox::warning(nullptr, "WARNING", msg, QMessageBox::Ok, QMessageBox::NoButton);
|
|
newStr = "";
|
|
break;
|
|
}
|
|
path = procEnv.value(token, "");
|
|
if (path.isEmpty()) {
|
|
msg = QString("Couldn't expand '%1'. Some things might not work properly").arg(token);
|
|
QMessageBox::warning(nullptr, "WARNING", msg, QMessageBox::Ok, QMessageBox::NoButton);
|
|
newStr = "";
|
|
break;
|
|
}
|
|
newStr += path;
|
|
} else {
|
|
newStr += "/" + token;
|
|
}
|
|
}
|
|
|
|
return newStr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// implementation of PAdmin class
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Initializes that PAdmin object, and calls the XML parser which feeds
|
|
* the object variables.
|
|
*/
|
|
PAdmin::PAdmin() : QObject()
|
|
{
|
|
fMsr2DataParam.runList = QString("");
|
|
fMsr2DataParam.runListFileName = QString("");
|
|
fMsr2DataParam.msrFileExtension = QString("");
|
|
fMsr2DataParam.templateRunNo = -1;
|
|
fMsr2DataParam.dbOutputFileName = QString("");
|
|
fMsr2DataParam.writeDbHeader = true;
|
|
fMsr2DataParam.ignoreDataHeaderInfo = false;
|
|
fMsr2DataParam.keepMinuit2Output = false;
|
|
fMsr2DataParam.estimateN0 = fEstimateN0;
|
|
fMsr2DataParam.yamlOut = false;
|
|
fMsr2DataParam.writeColumnData = false;
|
|
fMsr2DataParam.recreateDbFile = false;
|
|
fMsr2DataParam.chainFit = true;
|
|
fMsr2DataParam.openFilesAfterFitting = true;
|
|
fMsr2DataParam.perRunBlockChisq = fChisqPreRunBlock;
|
|
fMsr2DataParam.titleFromDataFile = true;
|
|
fMsr2DataParam.createMsrFileOnly = false;
|
|
fMsr2DataParam.fitOnly = false;
|
|
fMsr2DataParam.global = false;
|
|
fMsr2DataParam.globalPlus = false;
|
|
|
|
// XML Parser part
|
|
// 1st: check local directory
|
|
QString path = QString("./");
|
|
QString fln = QString("musredit_startup.xml");
|
|
QString pathFln = path + fln;
|
|
QProcessEnvironment procEnv = QProcessEnvironment::systemEnvironment();
|
|
if (!QFile::exists(pathFln)) {
|
|
// 2nd: check $HOME/.musrfit/musredit/musredit_startup.xml
|
|
path = procEnv.value("HOME", "");
|
|
pathFln = path + "/.musrfit/musredit/" + fln;
|
|
if (!QFile::exists(pathFln)) {
|
|
// 3rd: check $MUSRFITPATH/musredit_startup.xml
|
|
path = procEnv.value("MUSRFITPATH", "");
|
|
pathFln = path + "/" + fln;
|
|
if (!QFile::exists(pathFln)) {
|
|
// 4th: check $ROOTSYS/bin/musredit_startup.xml
|
|
path = procEnv.value("ROOTSYS", "");
|
|
pathFln = path + "/bin/" + fln;
|
|
if (!QFile::exists(pathFln)) {
|
|
// 5th: not found anywhere hence create it
|
|
path = procEnv.value("HOME", "");
|
|
pathFln = path + "/.musrfit/musredit/" + fln;
|
|
createMusreditStartupFile();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fPrefPathName = pathFln;
|
|
|
|
loadPrefs(fPrefPathName);
|
|
|
|
// make sure that musrfit, musrview, etc are found under the fExecPath provided
|
|
QString str = fExecPath + "/musrfit";
|
|
QFileInfo info(str);
|
|
if (info.exists()) {
|
|
if (!info.isExecutable())
|
|
QMessageBox::critical(nullptr, "ERROR", "musrfit found but not recognized as executable.\nPlease check!");
|
|
} else {
|
|
QMessageBox::critical(nullptr, "ERROR", "musrfit not found.\nHave you set the necessary system variables properly?\nPlease check the manual.\nBefore you can use musrfit, this needs to be fixed.");
|
|
}
|
|
|
|
// check if system variables are set properly
|
|
bool sysVarMissing = false;
|
|
QString msg("Missing System Variables:\n");
|
|
path = procEnv.value("ROOTSYS", "");
|
|
if (path.isEmpty()) {
|
|
msg += "> ROOTSYS\n";
|
|
sysVarMissing = true;
|
|
}
|
|
path = procEnv.value("MUSRFITPATH", "");
|
|
if (path.isEmpty()) {
|
|
msg += "> MUSRFITPATH\n";
|
|
sysVarMissing = true;
|
|
}
|
|
if (sysVarMissing) {
|
|
msg += "Please set this/these system variables.";
|
|
QMessageBox::warning(nullptr, "WARNING", msg);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Destructor
|
|
*/
|
|
PAdmin::~PAdmin()
|
|
{
|
|
saveRecentFiles();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>returns the help url corresponding the the tag.
|
|
*
|
|
* \param tag to map the help url. At the moment the following tags should be present:
|
|
* main, title, parameters, theory, functions, run, command, fourier, plot, statistic
|
|
*/
|
|
QString PAdmin::getHelpUrl(QString tag)
|
|
{
|
|
return fHelpUrl[tag];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>returns a theory item from position idx. If idx is out of the range, a null pointer is returned.
|
|
*
|
|
* \param idx position of the theory item.
|
|
*/
|
|
PTheory* PAdmin::getTheoryItem(const unsigned int idx)
|
|
{
|
|
if (idx > (unsigned int)fTheory.size())
|
|
return 0;
|
|
else
|
|
return &fTheory[idx];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>returns the recent path-file name at position idx. If idx is out of scope,
|
|
* an empty string is returned.
|
|
*
|
|
* \param idx index of the recent path-file name to be retrieved.
|
|
*/
|
|
QString PAdmin::getRecentFile(int idx)
|
|
{
|
|
if (idx >= fRecentFile.size())
|
|
return QString("");
|
|
|
|
return fRecentFile[idx];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>set the help url, addressed via a tag. At the moment the following tags should be present:
|
|
* main, title, parameters, theory, functions, run, command, fourier, plot, statistic, msr2data
|
|
*
|
|
* \param tag to address the help url
|
|
* \param url help url corresponding to the tag.
|
|
*/
|
|
void PAdmin::setHelpUrl(const QString tag, const QString url)
|
|
{
|
|
fHelpUrl[tag] = url;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Loads the preference file fln.
|
|
*
|
|
* <b>return:</b> 1 on success, 0 otherwise
|
|
*
|
|
* \param fln path-file name of the preference file to be loaded.
|
|
*/
|
|
int PAdmin::loadPrefs(QString fln)
|
|
{
|
|
if (QFile::exists(fln)) { // administration file present
|
|
PAdminXMLParser handler(fln, this);
|
|
if (!handler.isValid()) {
|
|
QMessageBox::critical(nullptr, "ERROR",
|
|
"Error parsing musredit_startup.xml settings file.\nProbably a few things will not work porperly.\nPlease fix this first.",
|
|
QMessageBox::Ok, QMessageBox::NoButton);
|
|
return 0;
|
|
}
|
|
} else {
|
|
QMessageBox::critical(nullptr, "ERROR",
|
|
"Couldn't find the musredit_startup.xml settings file.\nProbably a few things will not work porperly.\nPlease fix this first.",
|
|
QMessageBox::Ok, QMessageBox::NoButton);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Save the preference file pref_fln.
|
|
*
|
|
* <b>return:</b> 1 on success, 0 otherwise
|
|
*
|
|
* \param pref_fln preference path-file name
|
|
*/
|
|
int PAdmin::savePrefs(QString pref_fln)
|
|
{
|
|
// check if musredit_startup.xml is present in the current directory, and if yes, use this file to
|
|
// save the recent file names otherwise use the "master" musredit_startup.xml
|
|
QString fln = QString("./musredit_startup.xml");
|
|
if (!QFile::exists(fln))
|
|
fln = fPrefPathName;
|
|
|
|
if (QFile::exists(fln)) { // administration file present
|
|
QVector<QString> data;
|
|
QFile file(fln);
|
|
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
std::cerr << std::endl << ">> PAdmin::savePrefs: **ERROR** Cannot open " << fln.toLatin1().data() << " for reading." << std::endl;
|
|
return 1;
|
|
}
|
|
QTextStream fin(&file);
|
|
while (!fin.atEnd()) {
|
|
data.push_back(fin.readLine());
|
|
}
|
|
file.close();
|
|
|
|
// replace all the prefs
|
|
for (int i=0; i<data.size(); i++) {
|
|
if (data[i].contains("<timeout>") && data[i].contains("</timeout>")) {
|
|
data[i] = " <timeout>" + QString("%1").arg(fTimeout) + "</timeout>";
|
|
}
|
|
if (data[i].contains("<keep_minuit2_output>") && data[i].contains("</keep_minuit2_output>")) {
|
|
if (fKeepMinuit2Output)
|
|
data[i] = " <keep_minuit2_output>y</keep_minuit2_output>";
|
|
else
|
|
data[i] = " <keep_minuit2_output>n</keep_minuit2_output>";
|
|
}
|
|
if (data[i].contains("<dump_ascii>") && data[i].contains("</dump_ascii>")) {
|
|
if (fDumpAscii)
|
|
data[i] = " <dump_ascii>y</dump_ascii>";
|
|
else
|
|
data[i] = " <dump_ascii>n</dump_ascii>";
|
|
}
|
|
if (data[i].contains("<dump_root>") && data[i].contains("</dump_root>")) {
|
|
if (fDumpRoot)
|
|
data[i] = " <dump_root>y</dump_root>";
|
|
else
|
|
data[i] = " <dump_root>n</dump_root>";
|
|
}
|
|
if (data[i].contains("<title_from_data_file>") && data[i].contains("</title_from_data_file>")) {
|
|
if (fTitleFromDataFile)
|
|
data[i] = " <title_from_data_file>y</title_from_data_file>";
|
|
else
|
|
data[i] = " <title_from_data_file>n</title_from_data_file>";
|
|
}
|
|
if (data[i].contains("<chisq_per_run_block>") && data[i].contains("</chisq_per_run_block>")) {
|
|
if (fChisqPreRunBlock)
|
|
data[i] = " <chisq_per_run_block>y</chisq_per_run_block>";
|
|
else
|
|
data[i] = " <chisq_per_run_block>n</chisq_per_run_block>";
|
|
}
|
|
if (data[i].contains("<estimate_n0>") && data[i].contains("</estimate_n0>")) {
|
|
if (fEstimateN0)
|
|
data[i] = " <estimate_n0>y</estimate_n0>";
|
|
else
|
|
data[i] = " <estimate_n0>n</estimate_n0>";
|
|
}
|
|
if (data[i].contains("<yaml_out>") && data[i].contains("</yaml_out>")) {
|
|
if (fYamlOut)
|
|
data[i] = " <yaml_out>y</yaml_out>";
|
|
else
|
|
data[i] = " <yaml_out>n</yaml_out>";
|
|
}
|
|
if (data[i].contains("<musrview_show_fourier>") && data[i].contains("</musrview_show_fourier>")) {
|
|
if (fMusrviewShowFourier)
|
|
data[i] = " <musrview_show_fourier>y</musrview_show_fourier>";
|
|
else
|
|
data[i] = " <musrview_show_fourier>n</musrview_show_fourier>";
|
|
}
|
|
if (data[i].contains("<musrview_show_avg>") && data[i].contains("</musrview_show_avg>")) {
|
|
if (fMusrviewShowAvg)
|
|
data[i] = " <musrview_show_avg>y</musrview_show_avg>";
|
|
else
|
|
data[i] = " <musrview_show_avg>n</musrview_show_avg>";
|
|
}
|
|
if (data[i].contains("<enable_musrt0>") && data[i].contains("</enable_musrt0>")) {
|
|
if (fEnableMusrT0)
|
|
data[i] = " <enable_musrt0>y</enable_musrt0>";
|
|
else
|
|
data[i] = " <enable_musrt0>n</enable_musrt0>";
|
|
}
|
|
if (data[i].contains("<ignore_theme_auto_detection>")) {
|
|
if (fIgnoreThemeAutoDetection)
|
|
data[i] = " <ignore_theme_auto_detection>y</ignore_theme_auto_detection>";
|
|
else
|
|
data[i] = " <ignore_theme_auto_detection>n</ignore_theme_auto_detection>";
|
|
}
|
|
if (data[i].contains("<dark_theme_icons_menu>") && data[i].contains("</dark_theme_icons_menu>")) {
|
|
if (fDarkThemeIconsMenu)
|
|
data[i] = " <dark_theme_icons_menu>y</dark_theme_icons_menu>";
|
|
else
|
|
data[i] = " <dark_theme_icons_menu>n</dark_theme_icons_menu>";
|
|
}
|
|
if (data[i].contains("<dark_theme_icons_toolbar>") && data[i].contains("</dark_theme_icons_toolbar>")) {
|
|
if (fDarkThemeIconsToolbar)
|
|
data[i] = " <dark_theme_icons_toolbar>y</dark_theme_icons_toolbar>";
|
|
else
|
|
data[i] = " <dark_theme_icons_toolbar>n</dark_theme_icons_toolbar>";
|
|
}
|
|
if (data[i].contains("<font_name>") && data[i].contains("</font_name>")) {
|
|
data[i] = QString(" <font_name>%1</font_name>").arg(fFontName);
|
|
}
|
|
if (data[i].contains("<font_size>") && data[i].contains("</font_size>")) {
|
|
data[i] = QString(" <font_size>%1</font_size>").arg(fFontSize);
|
|
}
|
|
}
|
|
|
|
// write prefs
|
|
file.setFileName(pref_fln);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
std::cerr << std::endl << ">> PAdmin::savePrefs: **ERROR** Cannot open " << pref_fln.toLatin1().data() << " for writing." << std::endl;
|
|
return 0;
|
|
}
|
|
fin.setDevice(&file);
|
|
for (int i=0; i<data.size(); i++) {
|
|
fin << data[i] << Qt::endl;
|
|
}
|
|
file.close();
|
|
} else {
|
|
QString msg("Failed to write musredit_startup.xml. Neither a local nor a global copy found.");
|
|
QMessageBox::warning(nullptr, "WARNING", msg, QMessageBox::Ok, QMessageBox::NoButton);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Add recent path-file name to the internal ring-buffer.
|
|
*
|
|
* \param str recent path-file name to be added
|
|
*/
|
|
void PAdmin::addRecentFile(const QString str)
|
|
{
|
|
// check if file name is not already present
|
|
for (int i=0; i<fRecentFile.size(); i++) {
|
|
if (str == fRecentFile[i])
|
|
return;
|
|
}
|
|
|
|
fRecentFile.push_front(str);
|
|
if (fRecentFile.size() > MAX_RECENT_FILES)
|
|
fRecentFile.resize(MAX_RECENT_FILES);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Merges the recent file ring buffer into musredit_startup.xml and saves it.
|
|
* If a local copy is present it will be saved there, otherwise the master file
|
|
* will be used.
|
|
*/
|
|
void PAdmin::saveRecentFiles()
|
|
{
|
|
// check if musredit_startup.xml is present in the current directory, and if yes, use this file to
|
|
// save the recent file names otherwise use the "master" musredit_startup.xml
|
|
|
|
QString str("");
|
|
QString fln = QString("./musredit_startup.xml");
|
|
if (!QFile::exists(fln))
|
|
fln = fPrefPathName;
|
|
|
|
if (QFile::exists(fln)) { // administration file present
|
|
QVector<QString> data;
|
|
QFile file(fln);
|
|
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
std::cerr << std::endl << ">> PAdmin::saveRecentFile: **ERROR** Cannot open " << fln.toLatin1().data() << " for reading." << std::endl;
|
|
return;
|
|
}
|
|
QTextStream fin(&file);
|
|
while (!fin.atEnd()) {
|
|
data.push_back(fin.readLine());
|
|
}
|
|
file.close();
|
|
|
|
// remove <path_file_name> from data
|
|
for (QVector<QString>::iterator it = data.begin(); it != data.end(); ++it) {
|
|
if (it->contains("<path_file_name>")) {
|
|
it = data.erase(it);
|
|
--it;
|
|
}
|
|
}
|
|
|
|
// add recent files
|
|
int i;
|
|
for (i=0; i<data.size(); i++) {
|
|
if (data[i].contains("<recent_files>"))
|
|
break;
|
|
}
|
|
|
|
if (i == data.size()) {
|
|
std::cerr << std::endl << ">> PAdmin::saveRecentFile: **ERROR** " << fln.toLatin1().data() << " seems to be corrupt." << std::endl;
|
|
return;
|
|
}
|
|
i++;
|
|
for (int j=fRecentFile.size()-1; j>=0; j--) {
|
|
str = " <path_file_name>" + fRecentFile[j] + "</path_file_name>";
|
|
data.insert(i++, str);
|
|
}
|
|
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
std::cerr << std::endl << ">> PAdmin::saveRecentFile: **ERROR** Cannot open " << fln.toLatin1().data() << " for reading." << std::endl;
|
|
return;
|
|
}
|
|
fin.setDevice(&file);
|
|
for (int i=0; i<data.size(); i++) {
|
|
fin << data[i] << Qt::endl;
|
|
}
|
|
file.close();
|
|
} else {
|
|
QString msg("Failed to write musredit_startup.xml. Neither a local nor a global copy found.");
|
|
QMessageBox::warning(nullptr, "WARNING", msg, QMessageBox::Ok, QMessageBox::NoButton);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief PAdmin::createMusreditStartupFile
|
|
*/
|
|
void PAdmin::createMusreditStartupFile()
|
|
{
|
|
// get $HOME
|
|
QProcessEnvironment procEnv = QProcessEnvironment::systemEnvironment();
|
|
QString pathName = procEnv.value("HOME", "");
|
|
pathName += "/.musrfit/musredit";
|
|
|
|
// check if the directory $HOME/.musrfit/musredit exists if not create it
|
|
QDir dir(pathName);
|
|
if (!dir.exists()) {
|
|
// directory $HOME/.musrfit/musredit does not exist hence create it
|
|
dir.mkpath(pathName);
|
|
}
|
|
|
|
// create default musredit_startup.xml file in $HOME/.musrfit/musredit
|
|
pathName += "/musredit_startup.xml";
|
|
|
|
// get the default musredit_startup.xml.in from the internal resources
|
|
QFile fres(":/musredit_startup.xml.in");
|
|
if (!fres.exists()) {
|
|
QString msg = QString("Neither couldn't find nor create musredit_startup.xml. Things are likely not to work.");
|
|
QMessageBox::critical(nullptr, "ERROR", msg);
|
|
return;
|
|
}
|
|
|
|
if (!fres.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
QString msg = QString("Couldn't open internal resource file musredit_startup.xml.in. Things are likely not to work.");
|
|
QMessageBox::critical(nullptr, "ERROR", msg);
|
|
return;
|
|
}
|
|
// text stream for fres
|
|
QTextStream fin(&fres);
|
|
|
|
// musredit_startup.xml default file
|
|
QFile file(pathName);
|
|
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
|
|
// text stream for file
|
|
QTextStream fout(&file);
|
|
|
|
QString line;
|
|
while (!fin.atEnd()) {
|
|
line = fin.readLine();
|
|
line.replace("@prefix@", MUSRFIT_PREFIX);
|
|
line.replace("@DOCDIR@", MUSRFIT_DOC_DIR);
|
|
if (line.contains("<font_name>")) { // defaults: linux: Monospace, macOS: Courier New
|
|
if (QSysInfo::productType().contains("osx")) {
|
|
line.replace("Monospace", "Courier New");
|
|
}
|
|
}
|
|
if (line.contains("<font_size>")) { // defaults: linux: 12, macOS: 16
|
|
if (QSysInfo::productType().contains("osx")) {
|
|
line.replace("12", "16");
|
|
}
|
|
}
|
|
fout << line << Qt::endl;
|
|
}
|
|
|
|
file.close();
|
|
fres.close();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// END
|
|
//--------------------------------------------------------------------------
|