void UserFiltersModel::WriteSettings () const
{
QSettings settings (QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_CleanWeb_Subscr");
settings.clear ();
auto writeItems = [&settings] (const QString& name, const QList<FilterItem_ptr>& from) -> void
{
QList<FilterItem> saved;
saved.reserve (from.size ());
for (const auto& item : from)
saved << *item;
settings.setValue (name, QVariant::fromValue (saved));
};
writeItems ("ExceptionItems", Filter_.Exceptions_);
writeItems ("FilterItems", Filter_.Filters_);
}
int main(int argc, char **argv)
{
#ifndef DEBUG
qInstallMsgHandler(debugMessagesFilter);
#endif
QtSingleApplication a(argc, argv);
a.setApplicationName("ImageShack Uploader");
a.setOrganizationName("ImageShack");
a.setOrganizationDomain("imageshack.us");
a.setApplicationVersion(VERSION);
QStringList filelist;
for (int i=1; i< argc; i++)
filelist << QString::fromLocal8Bit(argv[i]);
if ((argc==2) && (QString(argv[1]) == "-unregister"))
{
qDebug() << "unregistering...";
#ifdef Q_OS_WIN
WindowsExplorerIntegrator().deintegrate();
#endif
QSettings sets;
sets.clear();
return 0;
}
if (a.isRunning() && argc>1)
{
a.sendMessage(filelist.join("\r\n"), 5000);
return 0;
}
MainWindow w;
if (filelist.size()) w.commandLineAddFile(filelist.join("\r\n"));
QObject::connect(&a,
SIGNAL(messageReceived(const QString&)),
&w,
SLOT(commandLineAddFile(const QString&)));
#ifdef Q_OS_WIN
WindowsExplorerIntegrator().integrate();
#endif
w.show();
return a.exec();
}
void OptionsModel::Reset()
{
QSettings settings;
// Remove all entries in this QSettings object
settings.clear();
// default setting for OptionsModel::StartAtStartup - disabled
if (GUIUtil::GetStartOnSystemStartup())
GUIUtil::SetStartOnSystemStartup(false);
// Re-Init to get default values
Init();
// Ensure Upgrade() is not running again by setting the bImportFinished flag
settings.setValue("bImportFinished", true);
}
void MainWindow::on_menu_save_settings_clicked()
{
QString integer;
QString s=QFileDialog::getSaveFileName(0,tr("Сохранить настройки"),QString(),tr("Файл настроек (*.uso)") );
if(s.length()<4)
return;
QSettings *settings = new QSettings(/*"settings.conf"*/s,QSettings::IniFormat);
settings->clear();
// settings->setValue("device/name",ui->lineEdit_2->text()); //устанавливаем значение
// settings->setValue("device/version",ui->lineEdit_4->text()); //устанавливаем значение
// settings->setValue("device/description",ui->lineEdit_3->text()); //устанавливаем значение
// settings->setValue("device/address",ui->spinBox_2->value()); //устанавливаем значение
settings->setValue("device/name",d_info->get_dev_name_text()); //устанавливаем значение
settings->setValue("device/version",d_info->get_dev_ver_text()); //устанавливаем значение
settings->setValue("device/description",d_info->get_dev_descr_text()); //устанавливаем значение
settings->setValue("device/address",d_info->get_dev_addr()); //устанавливаем значение
for(quint8 i=0;i<ui->tableWidget->rowCount();i++)
{
if(ui->tableWidget->item(i,1)->text()==tr("Аналоговый")/*i<8*/)
{
QComboBox *cmb=qobject_cast<QComboBox *>(ui->tableWidget->cellWidget(i, 2));
settings->setValue("channel_"+integer.setNum(i)+"/diapason",cmb->currentIndex());
QSpinBox *spin=qobject_cast<QSpinBox *>(ui->tableWidget->cellWidget(i, 3));
settings->setValue("channel_"+integer.setNum(i)+"/filter",spin->text());
cmb=qobject_cast<QComboBox *>(ui->tableWidget->cellWidget(i, 11));
settings->setValue("channel_"+integer.setNum(i)+"/n_bit",cmb->currentIndex());
settings->setValue("channel_"+integer.setNum(i)+"/calibrated",chnl[i]->calibrated);
settings->setValue("channel_"+integer.setNum(i)+"/K",chnl[i]->K);
settings->setValue("channel_"+integer.setNum(i)+"/C",chnl[i]->C);
}
}
settings->sync(); //записываем настройки
qDebug() << "SETTINGS SAVED"<<s;
}
void OptionsModel::Reset()
{
QSettings settings;
// Save the strDataDir setting
QString dataDir = Intro::getDefaultDataDirectory();
dataDir = settings.value("strDataDir", dataDir).toString();
// Remove all entries from our QSettings object
settings.clear();
// Set strDataDir
settings.setValue("strDataDir", dataDir);
// Set that this was reset
settings.setValue("fReset", true);
// default setting for OptionsModel::StartAtStartup - disabled
if (GUIUtil::GetStartOnSystemStartup())
GUIUtil::SetStartOnSystemStartup(false);
}
void deleteRegByQt()
{
//自动加载注册表的删除
QSettings *reg = new QSettings("HKEY_LOCAL_MACHINE\\Software\\Autodesk\\AutoCAD\\R18.0\\ACAD-8001:804\\Applications\\test",
QSettings::NativeFormat);
if (reg->allKeys().isEmpty())
{
return;
}
reg->clear();
delete reg;
//标题搜索栏的恢复
QSettings *regFind = new QSettings("HKEY_CURRENT_USER\\Software\\Autodesk\\AutoCAD\\R18.0\\ACAD-8001:804\\InfoCenter",
QSettings::NativeFormat);
if(regFind->contains("InfoCenterOn"))
{
regFind->setValue("InfoCenterOn",1);
}
delete regFind;
}
static void overrideSettings(QSettings &settings, int argc, char **argv){
QMap<QString, QString> settingOptions;
// Options like -DMy/setting=test
QRegExp rx("([^=]+)=(.*)");
for(int i = 0; i < argc; ++i ){
if ( QString(CONFIG_OPTION).compare(QString(argv[i])) == 0 ){
if ( rx.indexIn(argv[++i]) > -1 ){
settingOptions.insert(rx.cap(1), rx.cap(2));
}
}
if ( QString(CLEAN_CONFIG_OPTION).compare(QString(argv[i])) == 0 ){
settings.clear();
}
}
QList<QString> keys = settingOptions.keys();
foreach ( QString key, keys ){
settings.setValue(key, settingOptions.value(key));
}
int main(int argc, char *argv[])
{
Application a(argc, argv);
a.setAttribute(Qt::AA_DontShowIconsInMenus, true);
a.setApplicationName("psnewmodel");
a.setOrganizationName("LB Productions");
a.setOrganizationDomain("lbproductions.github.com");
a.setApplicationVersion(APP_VERSION);
#ifdef Q_OS_MAC
CocoaInitializer cocoaInitializer;
Q_UNUSED(cocoaInitializer);
CrashReporter::init();
#endif
Updater *updater = Updater::instanceForPlatform();
if(updater)
updater->checkForUpdatesInBackground();
if(a.arguments().contains("-C")) {
QSettings s;
s.clear();
}
ChooseLibraryWidget *mainWindow = new ChooseLibraryWidget;
if(a.fileToOpen().isEmpty()) {
mainWindow->showOrOpenLibrary();
}
else {
mainWindow->openLibrary(a.fileToOpen()+"/database/database.sqlite");
}
int ret = a.exec();
Library::instance()->close();
delete updater;
return ret;
}
void OptionsModel::Reset()
{
QSettings settings;
// Backup old settings to chain-specific datadir for troubleshooting
BackupSettings(GetDataDir(true) / "guisettings.ini.bak", settings);
// Save the strDataDir setting
QString dataDir = Intro::getDefaultDataDirectory();
dataDir = settings.value("strDataDir", dataDir).toString();
// Remove all entries from our QSettings object
settings.clear();
// Set strDataDir
settings.setValue("strDataDir", dataDir);
// Set that this was reset
settings.setValue("fReset", true);
// default setting for OptionsModel::StartAtStartup - disabled
if (GUIUtil::GetStartOnSystemStartup())
GUIUtil::SetStartOnSystemStartup(false);
}
void SettingsManager::saveConfig()
{
QSettings sett;
sett.clear();
sett.beginGroup("PigsAccount");
QString user(_settings.value(QString("pUsername")).toString());
QString pass(_settings.value(QString("pPassword")).toString());
if (!user.isEmpty() && !pass.isEmpty())
{
sett.setValue(QString("pUsername"), user);
sett.setValue(QString("pPassword"), pass);
sett.setValue(QString("pInterval"), _settings.value(QString("pInterval")));
sett.setValue(QString("pGroups"), _settings.value(QString("pGroups")));
}
sett.endGroup();
sett.beginGroup("HostopAccount");
user = _settings.value(QString("hUsername")).toString();
pass = _settings.value(QString("hPassword")).toString();
if (!user.isEmpty() && !pass.isEmpty())
{
sett.setValue(QString("hUsername"), user);
sett.setValue(QString("hPassword"), pass);
}
sett.endGroup();
sett.beginGroup("Gui");
sett.setValue(QString("mwState"), _settings.value(QString("mwState")));
sett.setValue(QString("tIcon"), _settings.value(QString("tIcon")));
sett.setValue(QString("tMess"), _settings.value(QString("tMess")));
if (_settings.value(QString("iLang")).toString() == QString("RU"))
sett.setValue(QString("iLang"), _settings.value(QString("iLang")));
sett.setValue("mDebug", _settings.value("mDebug"));
sett.endGroup();
}
int main(int argc, char *argv[])
{
//ifstream_unicode in ("/home/ciobi/cpp/Mp3Utils/mp3diags/trunk/mp3diags/src/2/testä.txt");
/*ifstream_unicode in ("/home/ciobi/cpp/Mp3Utils/mp3diags/trunk/mp3diags/src/2/test_.txt");
string s;
getline(in, s);
cout << s;
return 4;//*/
//char *argv[] = {"aa", "-s", "support", "pppqqq"}; argc = 4;
//char *argv[] = {"aa", "pppqqq"}; argc = 2;
//char *argv[] = {"aa", "/d/test_mp3/1/tmp2/c pic/vbri assertion.mp3"}; argc = 2;
//char *argv1[] = {"aa", "--directory", "/test_mp3/1/tmp2/c pic" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--temp-session", "/d/test_mp3/1/tmp2/c pic" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--input-file", "/test_mp3/1/tmp2/c pic" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--hidden-folder-session", "/d/test_mp3/1/tmp2/c pic" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--hidden-folder-session", "/d/test_mp3/1/tmp2/text frames" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--loaded-folder-session", "/d/test_mp3/1/tmp2/c pic" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--loaded-folder-session", "/d/test_mp3/1/tmp2/text frames" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--folder-session", "/usr" }; argc = 3; argv = argv1;
//char *argv1[] = {"aa", "--hidden-session", "Q:\\" }; argc = 3; argv = argv1;
//DEFINE_PROF_ROOT("mp3diags");
//PROF("root");
/*
//locale::global(locale(""));
ostringstream o;
o << 12345.78;
cout << o.str() << endl;
printf("%f\n", 12345.78);//*/
void (*nh)() = set_new_handler(newHandler);
if (0 != nh) { cerr << "previous new handler: " << (void*)nh << endl; }
//for (int i = 0; i < 200; ++i) { new char[1000000]; }
#ifdef MSVC_QMAKE
qInstallMsgHandler(visStudioMessageOutput);
// see http://lists.trolltech.com/qt-interest/2006-10/msg00829.html
//OutputDebugStringA("\n\ntest output\n\n\n"); // !!! this only works if actually debugging (started with F5);
#endif
po::options_description genericDesc ("General options");
genericDesc.add_options()
(s_helpOpt.m_szFullOpt, s_helpOpt.m_szDescr)
(s_uninstOpt.m_szFullOpt, s_uninstOpt.m_szDescr)
(s_sessionOpt.m_szFullOpt, po::value<string>(), s_sessionOpt.m_szDescr)
;
po::options_description cmdlineDesc ("Commandline mode");
cmdlineDesc.add_options()
//("input-file", po::value<vector<string> >(), "input file")
//("severity,s", po::value<Note::Severity>()->default_value(Note::WARNING), "minimum severity to show (one of error, warning, support); default: warning") //ttt1 see if this can be made to work; it sort of does, but when invoked with "--help" it prints "arg (=1)" rather than "arg (=warning)"
(s_severityOpt.m_szFullOpt, po::value<Note::Severity>(), s_severityOpt.m_szDescr)
//("severity,s", "minimum severity to show (one of error, warning, support")
(s_transfListOpt.m_szFullOpt, po::value<int>(), s_transfListOpt.m_szDescr)
;
po::options_description folderSessDesc ("New, per-folder, session mode");
folderSessDesc.add_options()
(s_hiddenFolderSessOpt.m_szFullOpt, po::value<string>(), s_hiddenFolderSessOpt.m_szDescr)
(s_loadedFolderSessOpt.m_szFullOpt, po::value<string>(), s_loadedFolderSessOpt.m_szDescr)
(s_tempSessOpt.m_szFullOpt, po::value<string>(), s_tempSessOpt.m_szDescr)
;
po::options_description hiddenDesc("Hidden options");
hiddenDesc.add_options()
(s_inputFileOpt.m_szFullOpt, po::value<vector<string> >(), s_inputFileOpt.m_szDescr)
;
po::positional_options_description positionalDesc;
positionalDesc.add(s_inputFileOpt.m_szLongOpt, -1);
po::options_description fullDesc;
fullDesc.add(genericDesc).add(cmdlineDesc).add(hiddenDesc).add(folderSessDesc);
po::options_description visibleDesc;
visibleDesc.add(genericDesc).add(cmdlineDesc).add(folderSessDesc);
po::variables_map options;
bool err (false);
try
{
po::command_line_style::style_t style ((po::command_line_style::style_t)(
po::command_line_style::unix_style
// | po::command_line_style::case_insensitive
// | po::command_line_style::allow_long_disguise
#ifdef WIN32
| po::command_line_style::allow_slash_for_short
#endif
));
//po::store(po::command_line_parser(argc, argv).options(fullDesc).positional(positionalDesc).run(), options);
po::store(po::command_line_parser(argc, argv).style(style).options(fullDesc).positional(positionalDesc).run(), options);
po::notify(options);
}
catch (const exception& ex)
{
cerr << ex.what() << endl;
err = true;
}
catch (...)//const po::unknown_option&)
{
cerr << "unknown exception" << endl;
err = true;
}
if (err || options.count(s_helpOpt.m_szLongOpt) > 0) //ttt1 options "u" and "s" are incompatible; "s" without a file is wrong as well; these should trigger the "usage" message, then exit as well;
{
cout << "Usage: " << argv[0] << " [OPTION]... [FILE]...\n";
cout << visibleDesc << endl;
return 1;
}
if (options.count(s_uninstOpt.m_szLongOpt) > 0)
{
QSettings s (getOrganization(), getSettingsAppName());
s.clear(); //ttt2 see if this can actually remove everything, including the getOrganization() dir if it's empty;
ShellIntegration::enableHiddenSession(false);
ShellIntegration::enableVisibleSession(false);
ShellIntegration::enableTempSession(false);
return 0;
}
if (options.count(s_inputFileOpt.m_szLongOpt) > 0)
{
Q_INIT_RESOURCE(Mp3Diags); // base name of the ".qrc" file
QCoreApplication app (argc, argv); // !!! without this Qt file functions don't work correctly, e.g. QFileInfo has problems with file names that contain accents
//TranslatorHandler::getGlobalTranslator();
return cmdlineMain(options);
}
else
{
//QTranslator translator;
//translator.load("mp3diags_cs");
Q_INIT_RESOURCE(Mp3Diags); // base name of the ".qrc" file
QMp3DiagsApplication app (argc, argv);
TranslatorHandler::getGlobalTranslator();
/*qDebug("lang %s", TranslatorHandler::getGlobalTranslator().getLanguageInfo("ww/mp3diags_cs.qm").c_str());
qDebug("lang %s", TranslatorHandler::getGlobalTranslator().getLanguageInfo("ww/mp3diags_en_US.qm").c_str());
qDebug("lang %s", TranslatorHandler::getGlobalTranslator().getLanguageInfo("ww/mp3diags_ro.qm").c_str());
qDebug("lang %s", TranslatorHandler::getGlobalTranslator().getLanguageInfo("mp3diags_ro.qm").c_str());
qDebug("lang %s", TranslatorHandler::getGlobalTranslator().getLanguageInfo("mp3diags_ro_RO.qm").c_str());
qDebug("lang %s", TranslatorHandler::getGlobalTranslator().getLanguageInfo("_mp3diags_ro_RO.qm").c_str());
qDebug("lang %s", TranslatorHandler::getGlobalTranslator().getLanguageInfo("/qweqw/_mp3diags_ro_RO.qm").c_str());*/
//app.installTranslator(&translator);
return guiMain(options);
}
}
// ----------------------------------------------------------------------------
void ctkMessageBoxDontShowAgainTester::cleanup()
{
QSettings settings;
settings.clear();
}
int main(int pArgC, char *pArgV[])
{
// Initialise Qt's message pattern
OpenCOR::initQtMessagePattern();
// Determine whether we should try the CLI version of OpenCOR:
// - Windows: we never try the CLI version of OpenCOR. We go straight for
// its GUI version.
// - Linux: we always try the CLI version of OpenCOR and then go for its
// GUI version, if needed.
// - OS X: we try the CLI version of OpenCOR unless the user double clicks
// on the OpenCOR bundle or opens it from the command line by
// entering something like:
// open OpenCOR.app
// in which case we go for its GUI version.
// Note #1: on Windows, we have two binaries (.com and .exe that are for the
// CLI and GUI versions of OpenCOR, respectively). This means that
// when a console window is open, to enter something like:
// C:\>OpenCOR
// will effectively call OpenCOR.com. From there, should there be
// no argument that requires CLI treatment, then the GUI version of
// OpenCOR will be run. This is, unfortunately, the only way to
// have OpenCOR to behave as both a CLI and a GUI application on
// Windows, hence the [OpenCOR]/windows/main.cpp file, which is
// used to generate the CLI version of OpenCOR...
// Note #2: on OS X, if we were to try to open the OpenCOR bundle from the
// command line, then we would get an error message similar to:
// LSOpenURLsWithRole() failed with error -10810 for the file [SomePath]/OpenCOR.app.
// Fortunately, when double clicking on the OpenCOR bundle or
// opening it from the command line, a special argument in the form
// of -psn_0_1234567 is passed to OpenCOR, so we can use that to
// determine whether we need to force OpenCOR to be run in GUI mode
// or whether we first try the CLI version of OpenCOR, and then its
// GUI version, if needed...
#if defined(Q_OS_WIN)
bool tryCliVersion = false;
#elif defined(Q_OS_LINUX)
bool tryCliVersion = true;
#elif defined(Q_OS_MAC)
bool tryCliVersion = (pArgC == 1) || memcmp(pArgV[1], "-psn_", 5);
#else
#error Unsupported platform
#endif
// Run the CLI version of OpenCOR, if possible/needed
if (tryCliVersion) {
// Initialise the plugins path
OpenCOR::initPluginsPath(pArgV[0]);
// Create and initialise the CLI version of OpenCOR
OpenCOR::CliApplication *cliApp = new OpenCOR::CliApplication(pArgC, pArgV);
OpenCOR::initApplication();
// Try to run the CLI version of OpenCOR
int res;
bool runCliApplication = cliApp->run(&res);
delete cliApp;
if (runCliApplication) {
// OpenCOR was run as a CLI application, so leave
return res;
}
// Note: at this stage, we tried the CLI version of OpenCOR, but in the
// end we need to go for its GUI version, so start over but with
// the GUI version of OpenCOR this time...
}
// Make sure that we always use indirect rendering on Linux
// Note: indeed, depending on which plugins are selected, OpenCOR may need
// LLVM. If that's the case, and in case the user's video card uses a
// driver that relies on LLVM (e.g. Gallium3D and Mesa 3D), then there
// may be a conflict between the version of LLVM used by OpenCOR and
// the one used by the video card. One way to address this issue is by
// using indirect rendering...
#ifdef Q_OS_LINUX
qputenv("LIBGL_ALWAYS_INDIRECT", "1");
#endif
// Initialise the plugins path
OpenCOR::initPluginsPath(pArgV[0]);
// Create the GUI version of OpenCOR
OpenCOR::GuiApplication *guiApp = new OpenCOR::GuiApplication(QFileInfo(pArgV[0]).baseName(),
pArgC, pArgV);
// Send a message (containing the arguments that were passed to this
// instance of OpenCOR minus the first one since it corresponds to the full
// path to our executable, which we are not interested in) to our 'official'
// instance of OpenCOR, should there be one (if there is none, then just
// carry on as normal, otherwise exit since we want only one instance of
// OpenCOR at any given time)
QStringList appArguments = guiApp->arguments();
appArguments.removeFirst();
QString arguments = appArguments.join("|");
if (guiApp->isRunning()) {
guiApp->sendMessage(arguments);
delete guiApp;
return 0;
}
// Initialise the GUI version of OpenCOR
QString appDate = QString();
OpenCOR::initApplication(&appDate);
// Check whether we want to check for new versions at startup and, if so,
// whether a new version of OpenCOR is available
QSettings settings;
#ifndef QT_DEBUG
settings.beginGroup("CheckForUpdatesWindow");
bool checkForUpdatesAtStartup = settings.value(OpenCOR::SettingsCheckForUpdatesAtStartup, true).toBool();
bool includeSnapshots = settings.value(OpenCOR::SettingsIncludeSnapshots, false).toBool();
settings.endGroup();
if (checkForUpdatesAtStartup) {
OpenCOR::CheckForUpdatesEngine *checkForUpdatesEngine = new OpenCOR::CheckForUpdatesEngine(appDate);
checkForUpdatesEngine->check();
if ( ( includeSnapshots && checkForUpdatesEngine->hasNewerVersion())
|| (!includeSnapshots && checkForUpdatesEngine->hasNewerOfficialVersion())) {
// Retrieve the language to be used to show the check for updates
// window
QString locale = OpenCOR::locale();
QLocale::setDefault(QLocale(locale));
QTranslator qtTranslator;
QTranslator appTranslator;
qtTranslator.load(":qt_"+locale);
guiApp->installTranslator(&qtTranslator);
appTranslator.load(":app_"+locale);
guiApp->installTranslator(&appTranslator);
// Show the check for updates window
// Note: checkForUpdatesEngine gets deleted by
// checkForUpdatesWindow...
OpenCOR::CheckForUpdatesWindow checkForUpdatesWindow(checkForUpdatesEngine);
settings.beginGroup(checkForUpdatesWindow.objectName());
checkForUpdatesWindow.loadSettings(&settings);
settings.endGroup();
checkForUpdatesWindow.exec();
settings.beginGroup(checkForUpdatesWindow.objectName());
checkForUpdatesWindow.saveSettings(&settings);
settings.endGroup();
} else {
delete checkForUpdatesEngine;
}
}
#endif
// Create and show our splash screen, if we are not in debug mode
#ifndef QT_DEBUG
OpenCOR::SplashScreenWindow *splashScreen = new OpenCOR::SplashScreenWindow();
splashScreen->show();
#endif
// Create our main window
OpenCOR::MainWindow *win = new OpenCOR::MainWindow(appDate);
// Keep track of our main window (required by QtSingleApplication so that it
// can do what it's supposed to be doing)
guiApp->setActivationWindow(win);
// Handle our arguments
win->handleArguments(appArguments);
// Show our main window
win->show();
// By default, we can and should execute our application
bool canExecuteAplication = true;
// Close and delete our splash screen once our main window is visible, if we
// are not in debug mode
#ifndef QT_DEBUG
splashScreen->closeAndDeleteAfter(win);
// Make sure that our main window is in the foreground, unless the user
// decided to close our main window while we were showing our splash screen
// Note: indeed, on Linux, to show our splash screen may result in our main
// window being shown in the background...
if (!win->shuttingDown())
win->showSelf();
else
canExecuteAplication = false;
#endif
// Execute our application, if possible
int res;
if (canExecuteAplication)
res = guiApp->exec();
else
res = 0;
// Keep track of our application file and directory paths (in case we need
// to restart OpenCOR)
QString appFilePath = guiApp->applicationFilePath();
QString appDirPath = guiApp->applicationDirPath();
// Delete our main window
delete win;
// We use QtWebKit, and QWebPage in particular, which results in some leak
// messages being generated on Windows when leaving OpenCOR. This is because
// an object cache is shared between all QWebPage instances. So to destroy a
// QWebPage instance doesn't clear the cache, hence the leak messages.
// However, those messages are 'only' warnings, so we can safely live with
// them. Still, it doesn't look 'good', so we clear the memory caches, thus
// avoiding those leak messages...
// Note: the below must absolutely be done after calling guiApp->exec() and
// before deleting guiApp...
#ifdef Q_OS_WIN
QWebSettings::clearMemoryCaches();
#endif
// Delete our application
delete guiApp;
// We are done with the execution of our application, so now the question is
// whether we need to restart
// Note: we do this here rather than 'within' the GUI because once we have
// launched a new instance of OpenCOR, we want this instance of
// OpenCOR to finish as soon as possible, which will be the case here
// since all that remains to be done is to return the result of the
// execution of our application...
if ((res == OpenCOR::CleanRestart) || (res == OpenCOR::NormalRestart)) {
// We want to restart, so the question is whether we want a normal
// restart or a clean one
if (res == OpenCOR::CleanRestart) {
// We want a clean restart, so clear all the user settings (indeed,
// this will ensure that the various windows are, for instance,
// properly reset with regards to their dimensions)
settings.clear();
}
// Restart OpenCOR, but without providing any of the arguments that were
// originally passed to us since we want to reset everything
QProcess::startDetached(appFilePath, QStringList(), appDirPath);
}
// We are done running the GUI version of OpenCOR, so leave
return res;
}
int ctkCommandLineParserTest1(int, char*[])
{
// Test1 - Check if unparsedArguments() worked as expected
QStringList arguments1;
arguments1 << "ctkCommandLineParserTest1";
arguments1 << "--test-bool";
arguments1 << "--test-string";
arguments1 << "ctkrocks";
ctkCommandLineParser parser1;
bool ok = false;
parser1.parseArguments(arguments1, &ok);
if (!ok)
{
qCritical() << "Test1 - Failed to parse arguments";
return EXIT_FAILURE;
}
QStringList expectedUnparsedArguments1;
expectedUnparsedArguments1 << "--test-bool" << "--test-string" << "ctkrocks";
if (parser1.unparsedArguments() != expectedUnparsedArguments1)
{
qCritical() << "unparsedArguments:" << parser1.unparsedArguments();
qCritical() << "expectedUnparsedArguments1:" << expectedUnparsedArguments1;
return EXIT_FAILURE;
}
// Test2 - Check if addArgument() for a boolean workes as expected
QStringList arguments2;
arguments2 << "ctkCommandLineParserTest1";
arguments2 << "--test-bool";
arguments2 << "--test-string";
arguments2 << "ctkrocks";
ctkCommandLineParser parser2;
parser2.addArgument("--test-bool", "", QVariant::Bool, "This is a test bool", false);
ok = false;
QHash<QString, QVariant> parsedArgs = parser2.parseArguments(arguments2, &ok);
if (!ok)
{
qCritical() << "Test2 - Failed to parse arguments";
return EXIT_FAILURE;
}
QStringList expectedUnparsedArguments2;
expectedUnparsedArguments2 << "--test-string" << "ctkrocks";
if (parser2.unparsedArguments() != expectedUnparsedArguments2)
{
qCritical() << "Test2 - Failed - unparsedArguments:" << parser2.unparsedArguments()
<< ", expectedUnparsedArguments2:" << expectedUnparsedArguments2;
return EXIT_FAILURE;
}
if (parsedArgs["--test-bool"].isNull() || !parsedArgs["--test-bool"].toBool())
{
qCritical() << "Test2 - Failed to parse --test-bool";
return EXIT_FAILURE;
}
// Test3 - check if adding QString, int, and QStringList arguments works
QStringList arguments3;
arguments3 << "ctkCommandLineParserTest1";
arguments3 << "--test-string" << "TestingIsGood";
arguments3 << "--test-string2"<< "CTKSuperRocks";
arguments3 << "--test-integer"<< "-3";
arguments3 << "--test-stringlist"<< "item1" << "item2" << "item3";
ctkCommandLineParser parser3;
parser3.addArgument("--test-string", "", QVariant::String, "This is a test string");
parser3.addArgument("--test-string2", "", QVariant::String, "This is a test string2", "CTKGood");
parser3.addArgument("--test-integer", "", QVariant::Int, "This is a test integer");
parser3.addArgument("--test-stringlist", "", QVariant::StringList,
"This is a test stringlist");
ok = false;
parsedArgs = parser3.parseArguments(arguments3, &ok);
if (!ok)
{
qCritical() << "Test3 - Failed to parse arguments";
return EXIT_FAILURE;
}
QString expectedTestString = "TestingIsGood";
if (parsedArgs["--test-string"].toString() != expectedTestString)
{
qCritical() << "Test3 - Failed - testString" << parsedArgs["--test-string"].toString()
<< ", expectedTestString" << expectedTestString;
return EXIT_FAILURE;
}
QString expectedTestString2 = "CTKSuperRocks";
if (parsedArgs["--test-string2"].toString() != expectedTestString2)
{
qCritical() << "Test3 - Failed - testString2" << parsedArgs["--test-string2"].toString()
<< ", expectedTestString2" << expectedTestString2;
return EXIT_FAILURE;
}
int expectedTestInteger = -3;
if (parsedArgs["--test-integer"].toInt() != expectedTestInteger)
{
qCritical() << "Test3 - Failed - testInteger" << parsedArgs["--test-integer"].toInt()
<< ", expectedTestInteger" << expectedTestInteger;
return EXIT_FAILURE;
}
QStringList expectedTestStringlist;
expectedTestStringlist << "item1" << "item2" << "item3";
if (parsedArgs["--test-stringlist"].toStringList() != expectedTestStringlist)
{
qCritical() << "Test3 - Failed - testStringlist" << parsedArgs["--test-stringlist"].toStringList()
<< ", expectedTestStringlist" << expectedTestStringlist;
return EXIT_FAILURE;
}
// Test4 - check if helpText() works as expected
ctkCommandLineParser parser4;
parser4.addArgument("--help-string", "", QVariant::String, "This is an help string");
parser4.addArgument("--help-string-med", "", QVariant::String, "");
parser4.addArgument("--help-string-long", "-hs2", QVariant::String, "This is an help string too !");
parser4.addArgument("", "-hs3", QVariant::String, "This is an help string too for sure !?");
QString expectedHelpString;
QTextStream streamExpectedHelpString(&expectedHelpString);
streamExpectedHelpString << " --help-string..............This is an help string\n"
<< " --help-string-med\n"
<< " -hs2, --help-string-long...This is an help string too !\n"
<< " -hs3.......................This is an help string too for sure !?\n";
if (expectedHelpString != parser4.helpText('.'))
{
qCritical() << "Test4 - Problem with helpText('.') - helpText:\n" << parser4.helpText('.')
<< ", expectedHelpString:\n" << expectedHelpString;
return EXIT_FAILURE;
}
QString expectedHelpString2;
QTextStream streamExpectedHelpString2(&expectedHelpString2);
streamExpectedHelpString2 << " --help-string This is an help string\n"
<< " --help-string-med\n"
<< " -hs2, --help-string-long This is an help string too !\n"
<< " -hs3 This is an help string too for sure !?\n";
if (expectedHelpString2 != parser4.helpText())
{
qCritical() << "Test4 - Problem with helpText() - helpText:\n" << parser4.helpText()
<< ", expectedHelpString2:\n" << expectedHelpString2;
return EXIT_FAILURE;
}
// Test5 - check if setExactMatchRegularExpression() works as expected
ctkCommandLineParser parser5;
if (parser5.setExactMatchRegularExpression("--unknown",".*", "invalid"))
{
qCritical() << "Test5 - Problem with setExactMatchRegularExpression(shortOrLongArg) - "
"The function should return false if an invalid argument is passed";
return EXIT_FAILURE;
}
parser5.addArgument("--list", "", QVariant::StringList, "Test5 list");
if (!parser5.setExactMatchRegularExpression("--list","item[0-9]",
"Element of the form item[0-9] are expected."))
{
qCritical() << "Test5 - Problem with setExactMatchRegularExpression(StringListArg)";
return EXIT_FAILURE;
}
parser5.addArgument("--string", "", QVariant::String, "Test5 string");
if (!parser5.setExactMatchRegularExpression("--string","ctkStop|ctkStart",
"ctkStop or ctkStart is expected."))
{
qCritical() << "Test5 - Problem with setExactMatchRegularExpression(StringArg)";
return EXIT_FAILURE;
}
parser5.addArgument("--bool", "", QVariant::Bool, "Test5 bool");
if (parser5.setExactMatchRegularExpression("--bool",".*", "invalid"))
{
qCritical() << "Test5 - Problem with setExactMatchRegularExpression(BooleanArg) - "
"The function should return false if a boolean argument is passed";
return EXIT_FAILURE;
}
parser5.addArgument("--int", "", QVariant::Int, "Test5 int");
if (!parser5.setExactMatchRegularExpression("--int","[1-3]",
"Value 1, 2 or 3 is expected."))
{
qCritical() << "Test5 - Problem with setExactMatchRegularExpression(IntegerArg)";
return EXIT_FAILURE;
}
QStringList arguments5;
arguments5 << "ctkCommandLineParserTest1";
arguments5 << "--string"<< "ctkStop";
arguments5 << "--int"<< "2";
arguments5 << "--list"<< "item2" << "item3";
ok = false;
parser5.parseArguments(arguments5, &ok);
if (!ok)
{
qCritical() << "Test5 - Failed to parse arguments";
return EXIT_FAILURE;
}
arguments5.clear();
arguments5 << "ctkCommandLineParserTest1";
arguments5 << "--string"<< "ctkStopp";
arguments5 << "--int"<< "2";
arguments5 << "--list"<< "item2" << "item3";
ok = false;
parser5.parseArguments(arguments5, &ok);
if (ok)
{
qCritical() << "Test5 - parseArguments() should return False - 'ctkStopp' isn't a valid string";
return EXIT_FAILURE;
}
QString expectedErrorString =
"Value(s) associated with argument --string are incorrect."
" ctkStop or ctkStart is expected.";
if(expectedErrorString != parser5.errorString())
{
qCritical() << "Test5 - Failed - expectedErrorString" << expectedErrorString
<< ", parser5.errorString()" << parser5.errorString();
return EXIT_FAILURE;
}
arguments5.clear();
arguments5 << "ctkCommandLineParserTest1";
arguments5 << "--string"<< "ctkStop";
arguments5 << "--int"<< "4";
arguments5 << "--list"<< "item2" << "item3";
ok = false;
parser5.parseArguments(arguments5, &ok);
if (ok)
{
qCritical() << "Test5 - parseArguments() should return False - '4' isn't a valid int";
return EXIT_FAILURE;
}
QString expectedErrorString2 =
"Value(s) associated with argument --int are incorrect."
" Value 1, 2 or 3 is expected.";
if(expectedErrorString2 != parser5.errorString())
{
qCritical() << "Test5 - Failed - expectedErrorString2" << expectedErrorString2
<< ", parser5.errorString()" << parser5.errorString();
return EXIT_FAILURE;
}
arguments5.clear();
arguments5 << "ctkCommandLineParserTest1";
arguments5 << "--string"<< "ctkStop";
arguments5 << "--int"<< "2";
arguments5 << "--list"<< "item2" << "item10";
ok = false;
parser5.parseArguments(arguments5, &ok);
if (ok)
{
qCritical() << "Test5 - parseArguments() should return False "
"- 'item10' isn't a valid list element";
return EXIT_FAILURE;
}
QString expectedErrorString3 =
"Value(s) associated with argument --list are incorrect."
" Element of the form item[0-9] are expected.";
if(expectedErrorString3 != parser5.errorString())
{
qCritical() << "Test5 - Failed - expectedErrorString3" << expectedErrorString3
<< ", parser5.errorString()" << parser5.errorString();
return EXIT_FAILURE;
}
// Test6 - Check if the parser handle the case when value of parameter is omitted
ctkCommandLineParser parser6;
parser6.addArgument("--string", "", QVariant::String, "This is a string");
parser6.addArgument("--bool", "", QVariant::Bool, "This is a bool");
QStringList arguments6;
arguments6 << "ctkCommandLineParserTest1"
<< "--string";
// since --string is missing a parameter, parseArgument is expected to fail
ok = false;
parser6.parseArguments(arguments6, &ok);
if (ok)
{
qCritical() << "Test6 - Problem with parseArguments()";
return EXIT_FAILURE;
}
// Expected ignore argument for Test7, 8. 9 and 10
QStringList expectedUnparsedArguments;
expectedUnparsedArguments << "--ignoreint"<< "2" << "--ignorelist"<< "item1" << "item2";
// Test7 - Check if addBooleanArgument and ignore_rest=true works as expected
ctkCommandLineParser parser7;
bool test7Bool = false;
parser7.addArgument("--bool", "", QVariant::Bool, "This is a boolean",
false /*defaultValue*/, true /* ignoreRest*/);
QStringList arguments7;
arguments7 << "ctkCommandLineParserTest1";
arguments7 << "--bool";
arguments7 << expectedUnparsedArguments;
ok = false;
parsedArgs = parser7.parseArguments(arguments7, &ok);
if (!ok)
{
qCritical() << "Test7 - Failed to parse arguments";
return EXIT_FAILURE;
}
bool expectedTest7Bool = true;
if (parsedArgs["--bool"].toBool() != expectedTest7Bool)
{
qCritical() << "Test7 - Failed - test7Bool" << test7Bool
<< ", expectedTest7Bool" << expectedTest7Bool;
return EXIT_FAILURE;
}
if (parser7.unparsedArguments() != expectedUnparsedArguments)
{
qCritical() << "Test7 - Failed - expectedUnparsedArguments " << expectedUnparsedArguments
<< ", parser7.unparsedArguments" << parser7.unparsedArguments();
return EXIT_FAILURE;
}
// Test7b - Same as Test7 using
ctkCommandLineParser parser7b;
parser7b.setArgumentPrefix("--", "-");
parser7b.addArgument("--bool", "-", QVariant::Bool, "This is a boolean",
false /*defaultValue*/, true /* ignoreRest*/);
QStringList arguments7b;
arguments7b << "ctkCommandLineParserTest1";
arguments7b << "--";
arguments7b << expectedUnparsedArguments;
ok = false;
parsedArgs = parser7b.parseArguments(arguments7b, &ok);
if (!ok)
{
qCritical() << "Test7b - Failed to parse arguments";
return EXIT_FAILURE;
}
bool expectedTest7bBool = true;
bool test7bBool = parsedArgs["--bool"].toBool();
if (test7bBool != expectedTest7bBool)
{
qCritical() << "Test7b - Failed - test7bBool" << test7bBool
<< ", expectedTest7bBool" << expectedTest7bBool;
return EXIT_FAILURE;
}
if (parser7b.unparsedArguments() != expectedUnparsedArguments)
{
qCritical() << "Test7b - Failed - expectedUnparsedArguments " << expectedUnparsedArguments
<< ", parser7b.unparsedArguments" << parser7b.unparsedArguments();
return EXIT_FAILURE;
}
// Test8 - Check if addStringArgument and ignore_rest=true works as expected
ctkCommandLineParser parser8;
parser8.addArgument("--string", "", QVariant::String, "This is a string",
QString() /*defaultValue*/, true /* ignoreRest*/);
QStringList arguments8;
arguments8 << "ctkCommandLineParserTest1";
arguments8 << "--string" << "ctk";
arguments8 << expectedUnparsedArguments;
ok = false;
parsedArgs = parser8.parseArguments(arguments8, &ok);
if (!ok)
{
qCritical() << "Test8 - Failed to parse arguments";
return EXIT_FAILURE;
}
QString expectedTest8String = "ctk";
if (parsedArgs["--string"].toString() != expectedTest8String)
{
qCritical() << "Test8 - Failed - test8String" << parsedArgs["--string"].toString()
<< ", expectedTest8String" << expectedTest8String;
return EXIT_FAILURE;
}
if (parser8.unparsedArguments() != expectedUnparsedArguments)
{
qCritical() << "Test8 - Failed - expectedUnparsedArguments " << expectedUnparsedArguments
<< ", parser8.unparsedArguments" << parser8.unparsedArguments();
return EXIT_FAILURE;
}
// Test9 - Check if addArgument for int and ignore_rest=true works as expected
ctkCommandLineParser parser9;
parser9.addArgument("--integer", "", QVariant::Int, "This is an integer",
0 /*defaultValue*/, true /* ignoreRest*/);
QStringList arguments9;
arguments9 << "ctkCommandLineParserTest1";
arguments9 << "--integer" << "74";
arguments9 << expectedUnparsedArguments;
ok = false;
parsedArgs = parser9.parseArguments(arguments9, &ok);
if (!ok)
{
qCritical() << "Test9 - Failed to parse arguments";
return EXIT_FAILURE;
}
int expectedTest9Int = 74;
if (parsedArgs["--integer"].toInt() != expectedTest9Int)
{
qCritical() << "Test9 - Failed - test9Int" << parsedArgs["--integer"].toInt()
<< ", expectedTest9Int" << expectedTest9Int;
return EXIT_FAILURE;
}
if (parser9.unparsedArguments() != expectedUnparsedArguments)
{
qCritical() << "Test9 - Failed - expectedUnparsedArguments " << expectedUnparsedArguments
<< ", parser9.unparsedArguments" << parser9.unparsedArguments();
return EXIT_FAILURE;
}
// Test10 - Check if argumentParsed works as expected
ctkCommandLineParser parser10;
parser10.addArgument("--bool", "", QVariant::Bool, "This is a boolean");
// Since parseArguments hasn't been called, argumentParsed should return False
if(parser10.argumentParsed("--bool"))
{
qCritical() << "Test10 - Problem with argumentParsed() - Should return False";
return EXIT_FAILURE;
}
QStringList arguments10;
arguments10 << "ctkCommandLineParserTest1";
arguments10 << "--bool";
ok = false;
parser10.parseArguments(arguments10, &ok);
if (!ok)
{
qCritical() << "Test10 - Failed to parse arguments.";
return EXIT_FAILURE;
}
if(parser10.argumentParsed("--bool-notadded"))
{
qCritical() << "Test10 - Problem with argumentParsed() - "
"Should return False since argument '--bool-notadded' hasn't been added.";
return EXIT_FAILURE;
}
if(!parser10.argumentParsed("--bool"))
{
qCritical() << "Test10 - Problem with argumentParsed() - Should return True";
return EXIT_FAILURE;
}
// Test11 - Check if setArgumentPrefix works as expected
ctkCommandLineParser parser11;
parser11.setArgumentPrefix("--", "/");
parser11.addArgument("test-string", "", QVariant::String);
parser11.addArgument("", "i", QVariant::Int);
QStringList arguments11;
arguments11 << "ctkCommandLineParserTest1";
arguments11 << "--test-string" << "Unix-style";
arguments11 << "test-string"; // unknown argument
arguments11 << "/i" << "5";
ok = false;
parsedArgs = parser11.parseArguments(arguments11, &ok);
if (!ok)
{
qCritical() << "Test11 - Failed to parse arguments: " << parser11.errorString();
return EXIT_FAILURE;
}
if (!parser11.unparsedArguments().contains("test-string"))
{
qCritical() << "Test11 - argument test-string should be unknown.";
return EXIT_FAILURE;
}
if (!parser11.argumentParsed("test-string") || !parser11.argumentParsed("i"))
{
qCritical() << "Test11 - Problem with argumentParsed().";
return EXIT_FAILURE;
}
if (parsedArgs["test-string"].toString() != "Unix-style")
{
qCritical() << "Test11 - Failed argument: test-string, got: " << parsedArgs["test-string"].toString()
<< ", expected: " << "Unix-style";
return EXIT_FAILURE;
}
if (parsedArgs["i"].toInt() != 5)
{
qCritical() << "Test11 - Failed argument: i, got: " << parsedArgs["i"].toInt()
<< ", expected: " << 5;
return EXIT_FAILURE;
}
// Test12 - Check if the returned hash map contains the correct entries
ctkCommandLineParser parser12;
parser12.addArgument("--test-list", "-l", QVariant::StringList);
QStringList arguments12;
arguments12 << "ctkCommandLineParserTest1";
parsedArgs = parser12.parseArguments(arguments12);
if (!parsedArgs.isEmpty())
{
qCritical() << "Test12 - Returned hash map should be empty.";
return EXIT_FAILURE;
}
arguments12 << "--test-list" << "--test-list2";
parsedArgs = parser12.parseArguments(arguments12);
if (parsedArgs.size() != 1 || !parsedArgs.contains("--test-list"))
{
qCritical() << "Test12 - Returned hash map contains wrong elements.";
return EXIT_FAILURE;
}
// Test13 - Check that supplying a default value works
ctkCommandLineParser parser13;
parser13.addArgument("", "-d", QVariant::Int, "Argument with default value", 3);
parsedArgs = parser13.parseArguments(QStringList(), &ok);
if (!parsedArgs.contains("-d"))
{
qCritical() << "Test13 - Returned hash map does not contain argument with default value.";
return EXIT_FAILURE;
}
if (parsedArgs["-d"].toInt() != 3)
{
qCritical() << "Test13 - Returned hash map contains wrong argument parameter.";
return EXIT_FAILURE;
}
// ==================== QSettings tests ====================
QSettings settings;
settings.setValue("long-settings-argument", 5);
settings.setValue("s", "settings-short");
settings.setValue("invalid", QVariant());
// Test14 - Check that QSettings are used
ctkCommandLineParser parser14(&settings);
parser14.setArgumentPrefix("--", "-");
parser14.addArgument("long-settings-argument", "", QVariant::Int);
parser14.addArgument("", "s", QVariant::String, "A short argument", "my-short");
QStringList arguments14;
arguments14 << "ctkCommandLineParserTest1";
arguments14 << "-s" << "short";
arguments14 << "unknown";
parsedArgs = parser14.parseArguments(arguments14);
// Check that QSettings are ignored
if (parsedArgs.size() != 1 || parsedArgs["s"] != "short")
{
qCritical() << "Test14 - Parsed arguments must only contain -s short.";
return EXIT_FAILURE;
}
// Now use QSettings
parser14.enableSettings("disable-settings");
parser14.addArgument("disable-settings", "", QVariant::Bool);
parsedArgs = parser14.parseArguments(arguments14);
if (!parser14.settingsEnabled())
{
qCritical() << "Test14 - Disabling settings failed.";
return EXIT_FAILURE;
}
if (parser14.unparsedArguments().size() != 1 ||
!parser14.unparsedArguments().contains("unknown"))
{
qCritical() << "Test14 - Parsing unknown arguments failed.";
return EXIT_FAILURE;
}
if (parsedArgs.contains("invalid"))
{
qCritical() << "Test14 - Invalid QSettings value found.";
return EXIT_FAILURE;
}
if (parsedArgs.size() != 2)
{
qCritical() << "Test14 - Wrong number of parsed arguments.";
return EXIT_FAILURE;
}
if (parsedArgs["s"] != "short")
{
qCritical() << "Test14 - QSettings values must not overwrite user values.";
return EXIT_FAILURE;
}
if (parsedArgs["long-settings-argument"].toInt() != 5)
{
qCritical() << "Test14 - Missing value from QSettings.";
return EXIT_FAILURE;
}
arguments14.clear();
arguments14 << "ctkCommandLineParserTest1";
parsedArgs = parser14.parseArguments(arguments14);
if (parsedArgs.size() != 2)
{
qCritical() << "Test14 - Only QSettings values corresponding to arguments must be included.";
return EXIT_FAILURE;
}
if (parsedArgs["s"] != "settings-short")
{
qCritical() << "Test14 - QSettings value should be used as default parameter.";
return EXIT_FAILURE;
}
// Disable QSettings via command line argument
arguments14.clear();
arguments14 << "ctkCommandLineParserTest1";
arguments14 << "--disable-settings";
arguments14 << "--long-settings-argument" << "12";
parsedArgs = parser14.parseArguments(arguments14);
if (parsedArgs["long-settings-argument"].toInt() != 12)
{
qCritical() << "Test14 - Wrong parameter for argument: long-settings-argument.";
return EXIT_FAILURE;
}
if (parsedArgs["s"] != "my-short")
{
qCritical() << parsedArgs;
qCritical() << "Test14 - Default value for argument -s not used.";
return EXIT_FAILURE;
}
// Test15 - Check that merging with QSettings works
settings.clear();
settings.setValue("--list-argument", "z");
ctkCommandLineParser parser15(&settings);
parser15.enableSettings();
parser15.addArgument("--list-argument", "", QVariant::StringList);
QStringList arguments15;
arguments15 << "ctkCommandLineParserTest1";
arguments15 << "--list-argument" << "a" << "b";
// Test with enabled merging
ok = false;
parsedArgs = parser15.parseArguments(arguments15, &ok);
if (!ok)
{
qCritical() << "Test15 - parsing arguments failed.";
return EXIT_FAILURE;
}
if (parsedArgs.contains("--list-argument"))
{
QStringList list = parsedArgs["--list-argument"].toStringList();
if (list.size() != 3)
{
qCritical() << "Test15 - Parameter merging failed.";
return EXIT_FAILURE;
}
if (!list.contains("a") || !list.contains("b") || !list.contains("z"))
{
qCritical() << "Test15 - Merged list contains wrong elements.";
return EXIT_FAILURE;
}
}
else
{
qCritical() << "Test15 - --list-argument was not parsed.";
return EXIT_FAILURE;
}
// Test with disabled merging
parser15.mergeSettings(false);
ok = false;
parsedArgs = parser15.parseArguments(arguments15, &ok);
if (!ok)
{
qCritical() << "Test15 - parsing arguments failed.";
return EXIT_FAILURE;
}
if (parsedArgs.contains("--list-argument"))
{
QStringList list = parsedArgs["--list-argument"].toStringList();
if (list.size() != 2)
{
qCritical() << "Test15 - Disabling merging failed.";
return EXIT_FAILURE;
}
if (!list.contains("a") || !list.contains("b"))
{
qCritical() << "Test15 - List contains wrong elements.";
return EXIT_FAILURE;
}
}
else
{
qCritical() << "Test15 - --list-argument was not parsed.";
return EXIT_FAILURE;
}
// Test16 - Check if strictMode works
settings.clear();
ctkCommandLineParser parser16(&settings);
parser16.enableSettings();
parser16.addArgument("--test-bool", "", QVariant::Bool);
parser16.setStrictModeEnabled(true);
QStringList arguments16;
arguments16 << "ctkCommandLineParserTest1";
arguments16 << "--test-bool";
// parseArguments should NOT fail
ok = false;
parsedArgs = parser16.parseArguments(arguments16, &ok);
if (!ok)
{
qCritical() << "Test16-1 - parsing arguments failed.";
return EXIT_FAILURE;
}
// Since two identical arguments are provided, parseArguments should fail
arguments16.clear();
arguments16 << "ctkCommandLineParserTest1";
arguments16 << "--test-bool";
arguments16 << "--test-bool";
ok = false;
parsedArgs = parser16.parseArguments(arguments16, &ok);
if (ok)
{
qCritical() << "Test16-2 - parsing arguments should fail.";
return EXIT_FAILURE;
}
// Since an unknown argument is provided, parseArguments should fail
arguments16.clear();
arguments16 << "ctkCommandLineParserTest1";
arguments16 << "--test-bool";
arguments16 << "test-bool";
ok = false;
parsedArgs = parser16.parseArguments(arguments16, &ok);
if (ok)
{
qCritical() << "Test16-3 - parsing arguments should fail.";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void Plugin::Migrate (IPluginsManager *manager)
{
QSettings settings
{
QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Azoth_LastSeen"
};
if (settings.allKeys ().isEmpty ())
return;
const auto& reporter = manager->CreateLoadProgressReporter (this);
qDebug () << Q_FUNC_INFO
<< "gonna migrate";
const auto& avail = settings.value ("LastAvailable").value<LastHash_t> ();
const auto& online = settings.value ("LastOnline").value<LastHash_t> ();
const auto& status = settings.value ("LastStatusChange").value<LastHash_t> ();
qDebug () << "done reading";
QHash<QString, EntryStats> stats;
{
const auto& proc = reporter->InitiateProcess (tr ("Uniting keys"), 0, 3);
for (const auto& pair : Util::Stlize (avail))
stats [pair.first].Available_ = pair.second;
++*proc;
for (const auto& pair : Util::Stlize (online))
stats [pair.first].Online_ = pair.second;
++*proc;
for (const auto& pair : Util::Stlize (status))
stats [pair.first].StatusChange_ = pair.second;
++*proc;
}
qDebug () << "done uniting";
{
auto lock = Storage_->BeginTransaction ();
const auto& proc = reporter->InitiateProcess (tr ("Writing the database"), 0, stats.size ());
for (const auto& pair : Util::Stlize (stats))
{
Storage_->SetEntryStats (pair.first, pair.second);
++*proc;
}
qDebug () << "done writing";
lock.Good ();
qDebug () << "done committing";
}
settings.clear ();
qDebug () << "done clearing";
}
void MainWindow::on_actionClear_triggered()
{
QSettings settings;
settings.clear();
QCoreApplication::quit();
}
void SettingsTest::cleanupTestCase()
{
QSettings settings;
settings.clear();
settings.sync();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QApplication::setOrganizationName(_S("Majister"));
QApplication::setApplicationName(_S("jPos"));
qRegisterMetaType<SyncState>("SyncState");
// Имя файла логов
logFileName.clear();
// Настройки базы - SQLite
QString mainBase = _S("db.sqlite3");
QString dbDriver = _S("QSQLITE");
QString dbUser;
QString dbPass;
QString dbOptions;
QString executeModule;
QString executeParams;
QString styleFileName;
bool stylefree = false;
// Уровни лога, 1- только ошибки, 2 - основные действия, 3 - отладка каждого чиха
int loglevel = 1;
// Обнулить файл логов
bool newlog = false;
bool resetSettings = false;
bool showHelp = false;
bool saveSources = false;
QStringList args = QCoreApplication::arguments();
for (int i = 1; i < args.count(); ++i)
{
QString value = args.at(i);
if (value == _S("--logfile") && i < args.count())
{
logFileName = args.at(++i);
continue;
}
if (value == _S("--loglevel") && i < args.count())
{
loglevel = args.at(++i).toInt();
continue;
}
if (value == _S("--newlog"))
{
newlog = true;
continue;
}
if (value == _S("--driver") && i < args.count())
{
dbDriver = args.at(++i);
continue;
}
if (value == _S("--user") && i < args.count())
{
dbUser = args.at(++i);
continue;
}
if (value == _S("--password") && i < args.count())
{
dbPass = args.at(++i);
continue;
}
if (value == _S("--resetsettings"))
{
resetSettings = true;
continue;
}
if (value == _S("--stylefree"))
{
stylefree = true;
continue;
}
if (value == _S("--istyle") && i < args.count())
{
styleFileName = args.at(++i);
continue;
}
if (value == _S("--version"))
{
qDebug() << _T("jPOS версия от %1 %2").arg(BUILDDATE).arg(BUILDTIME);
return 0;
}
if (value == _S("--help"))
{
showHelp = true;
break; // all other params not matter
}
if (value == _S("--sources"))
{
saveSources = true;
break; // all other params not matter
}
if (value == _S("--execute") && i+1 < args.count())
{
executeModule = args.at(++i);
executeParams = args.at(++i);
continue;
}
// если не параметров - значит название базы
mainBase = value;
}
if (saveSources)
{
QFile sourcesFile(_S(":/sources/sources/sources.7z"));
if(!sourcesFile.open(QFile::ReadOnly))
{
qDebug() << _T("%1 Ошибка доступа к исходникам: %2")
.arg(posForLog)
.arg(sourcesFile.errorString());
return 1;
}
QFile resultFile(_S("sources.7z"));
if(!resultFile.open(QFile::WriteOnly))
{
qDebug() << _T("%1 Ошибка создания файла для сохранения: %2")
.arg(posForLog)
.arg(resultFile.errorString());
return 1;
}
resultFile.write(sourcesFile.readAll());
resultFile.close();
sourcesFile.close();
qDebug()<<"Исходники сохранены в файле sources.7z";
return 0;
}
if (showHelp)
{
QFile helpFile(_S(":/texts/texts/help.txt"));
helpFile.open(QFile::ReadOnly);
QString helpText = helpFile.readAll();
qDebug() << _T("jPOS версия от %1 %2").arg(BUILDDATE).arg(BUILDTIME)<<endl;
qDebug() << helpText;
return 0;
}
if (newlog)
{
QFile::remove(logFileName);
}
if (!logFileName.isEmpty())
qInstallMessageHandler(fileMessageHandler);
//else
// qInstallMessageHandler(outputMessageHandler);
if(!stylefree)
{
QFile styleFile;
if(!styleFileName.isEmpty())
styleFile.setFileName(styleFileName);
else
styleFile.setFileName(":/qss/qss/black-n-orange.qss");
styleFile.open(QFile::ReadOnly);
QString styleSheet = QString::fromLatin1(styleFile.readAll());
qApp->setStyleSheet(styleSheet);
}
Datapipe * data = new Datapipe();
QMap<QString, QVariant>* vars = data->getVariables();
if (loglevel > 0)
qDebug() << _T("%1 Уровень лога: %2").arg(posForLog).arg(loglevel);
vars->insert(_S("loglevel"), loglevel);
QSettings *settings = data->getSettings();
if (resetSettings)
settings->clear();
QStringList settingsKeys = settings->allKeys();
QSettings *defaults = new QSettings(_S(":/defaults/defaults/globalsettings.ini"), QSettings::IniFormat);
defaults->setIniCodec(QTextCodec::codecForName("UTF-8"));
QStringList defaultKeys = defaults->allKeys();
for (int i = 0; i < defaultKeys.count(); i++)
{
QString key = defaultKeys.at(i);
QVariant value = defaults->value(key);
if (!settingsKeys.contains(key))
settings->setValue(key, value);
}
delete defaults;
QFont font;
font.setFamily(settings->value("global/default_font","DejaVu Sans").toString());
font.setPixelSize(settings->value("global/default_font_size",14).toInt());
font.setBold(settings->value("global/defalut_font_bold",true).toBool());
qApp->setFont(font);
// Финт - зададим дефолты для некоторых баз
if((dbDriver=="QIBASE" || dbDriver=="QFIREBIRD") && dbUser.isEmpty())
dbUser="******";
if((dbDriver=="QIBASE" || dbDriver=="QFIREBIRD") && dbPass.isEmpty())
dbPass="******";
QSqlDatabase db = QSqlDatabase::addDatabase(dbDriver);
db.setDatabaseName(mainBase);
db.setUserName(dbUser);
db.setPassword(dbPass);
db.setConnectOptions(dbOptions);
if (!db.open())
{
qCritical()<<_T("%1 Ошибка подключения: %2").arg(posForLog).arg(db.lastError().text());
return 2;
}
if (loglevel > 0)
{
qDebug() << _T("%1 База данных: %2").arg(posForLog).arg(mainBase);
qDebug() << _T("%1 Драйвер: %2").arg(posForLog).arg(dbDriver);
qDebug() << _T("%1 Пользователь: %2").arg(posForLog).arg(dbUser);
qDebug() << _T("%1 Пароль: %2").arg(posForLog).arg(dbPass);
qDebug() << _T("%1 Настройки: %2").arg(posForLog).arg(dbOptions);
}
vars->insert(_S("database"), mainBase);
vars->insert(_S("database_driver"), dbDriver);
vars->insert(_S("database_user"), dbUser);
vars->insert(_S("database_password"), dbPass);
vars->insert(_S("database_settings"), dbOptions);
QSqlQuery query;
query.prepare(settings->value(_S("global/queries/settings")).toString());
if (query.exec())
{
while (query.next())
{
vars->insert(query.value(0).toString(), query.value(1));
if(loglevel > 0)
qDebug() << _T("%1 Переменные: %2 = %3").arg(posForLog).arg(query.value(0).toString()).arg(query.value(1).toString());
}
}
else
{
bool solved = false;
if(dbDriver=="QSQLITE")
{
QMessageBox::StandardButton reply;
reply = QMessageBox::question(0,
_T("Не обнаружена база данных"),
_T("Не обнаружена база данных\nСоздать новую?"),
QMessageBox::Yes|QMessageBox::No);
if (reply == QMessageBox::Yes)
{
QFile file(":/defaults/defaults/database_sqlite.sql");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
qCritical() << _T("%1 Ошибка создания новой базы данных\n%2").arg(posForLog).arg(file.errorString());
return 0;
}
QStringList queryPartsList = QString::fromUtf8(file.readAll()).split(QRegExp("\\s"), QString::SkipEmptyParts);
int triggerDepth=0;
int stringDepth=0;
bool skipOneBegin=false;
QString queryFromParts;
for(int i=0; i<queryPartsList.count();++i)
{
QString part = queryPartsList.at(i).trimmed();
if(part.isEmpty())
continue;
if(part.toUpper() == "CREATE" && i+1 < queryPartsList.count())
if(queryPartsList.at(i+1)=="TRIGGER")
{
triggerDepth++;
skipOneBegin=true;
}
if(triggerDepth > 0 && part.toUpper()=="BEGIN")
{
if(skipOneBegin)
skipOneBegin=false;
else
triggerDepth++;
}
if(triggerDepth > 0 && part.toUpper()=="CASE")
triggerDepth++;
if(triggerDepth > 0 && part.toUpper().startsWith("END"))
triggerDepth--;
queryFromParts += _S(" %1").arg(part);
//qDebug()<<part<<triggerDepth<<stringDepth;
if(part.contains(";") && triggerDepth==0 && stringDepth==0)
{
bool skipQuery = false;
if(queryFromParts.contains("CREATE TABLE sqlite_sequence"))
skipQuery=true;
if(queryFromParts.trimmed().isEmpty())
skipQuery=true;
if(queryFromParts.trimmed()==";")
skipQuery=true;
if(!skipQuery)
{
if (!query.exec(queryFromParts))
{
qCritical() << _T("%1 Ошибка создания новой базы данных\n%2\n%3").arg(posForLog, query.lastError().text(), query.lastQuery());
return 1;
}
// qDebug()<<queryFromParts;
}
queryFromParts.clear();
}
}
QDialog dlg;
QFormLayout layout;
dlg.setLayout(&layout);
QLineEdit posID;
layout.addRow(_T("Код ПОС-а"), &posID);
QLineEdit generatorMin;
layout.addRow(_T("Генератор мин"), &generatorMin);
QLineEdit generatorMax;
layout.addRow(_T("Генератор макс"), &generatorMax);
QPushButton bt;
bt.setText("OK");
layout.addRow(0, &bt);
dlg.connect(&bt, SIGNAL(clicked()), &dlg, SLOT(accept()));
if(dlg.exec()==QDialog::Accepted)
{
query.prepare(settings->value(_S("global/queries/set_pos_id")).toString());
query.bindValue(":val", posID.text().toInt());
if(!query.exec())
{
qCritical() << _T("%1 Ошибка создания новой базы данных\n%2\n%3").arg(posForLog, query.lastError().text(), query.lastQuery());
return 1;
}
query.prepare(settings->value(_S("global/queries/set_generator_min")).toString());
query.bindValue(":val", generatorMin.text().toInt());
if(!query.exec())
{
qCritical() << _T("%1 Ошибка создания новой базы данных\n%2\n%3").arg(posForLog, query.lastError().text(), query.lastQuery());
return 1;
}
query.prepare(settings->value(_S("global/queries/set_generator_min1_sqlite")).toString());
query.bindValue(":val", generatorMin.text().toInt());
if(!query.exec())
{
qCritical() << _T("%1 Ошибка создания новой базы данных\n%2\n%3").arg(posForLog, query.lastError().text(), query.lastQuery());
return 1;
}
query.prepare(settings->value(_S("global/queries/set_generator_min2_sqlite")).toString());
query.bindValue(":val", generatorMin.text().toInt());
if(!query.exec())
{
qCritical() << _T("%1 Ошибка создания новой базы данных\n%2\n%3").arg(posForLog, query.lastError().text(), query.lastQuery());
return 1;
}
query.prepare(settings->value(_S("global/queries/set_generator_max")).toString());
query.bindValue(":val", generatorMax.text().toInt());
if(!query.exec())
{
qCritical() << _T("%1 Ошибка создания новой базы данных\n%2\n%3").arg(posForLog, query.lastError().text(), query.lastQuery());
return 1;
}
}
else
{
QMessageBox message;
message.setText(_T("Создание новой базы данных отменено"));
message.exec();
return 1;
}
solved = true;
}
}
if(!solved){
qCritical() << _T("%1 Ошибка чтения настроек\n%2\n%3").arg(posForLog, query.lastError().text(), query.lastQuery());
return 1;
}
}
int width = 0;
int height = 0;
if (QApplication::desktop()->screenGeometry().width() > QApplication::desktop()->screenGeometry().height())
{
width = QApplication::desktop()->screenGeometry().width();
height = QApplication::desktop()->screenGeometry().height();
}
else
{
width = QApplication::desktop()->screenGeometry().height();
height = QApplication::desktop()->screenGeometry().width();
}
double scale = settings->value("global/button_scale", 1).toDouble();
vars->insert(_S("standart_button_width"), (int) width / 12 * scale);
vars->insert(_S("standart_button_height"), (int) height / 12 * scale);
vars->insert(_S("standart_text_height"), (int) height / 18 * scale);
vars->insert(_S("standart_margins"), (int) vars->value(_S("standart_button_width")).toInt() * 0.1 * scale);
// заполняем тут, чтобы не тянуть в плагины все файлы
data->setPrinter(new ChequePrinter(data->getSettings(), data->getVariables()));
if (loglevel > 0)
{
QStringList keys = settings->allKeys();
for (int i = 0; i < keys.count(); i++)
qDebug() << _T("%1 Настройки: %2 %3").arg(posForLog).arg(keys.at(i)).arg(settings->value(keys.at(i)).toString());
}
if (loglevel > 0)
qDebug() << _T("%1 Запуск ").arg(posForLog);
MainWindow window(data);
window.showFullScreen();
// проверка 3
return a.exec();
}
void SettingsTest::init()
{
QSettings settings;
settings.clear();
settings.sync();
}
void ConfigWindow::save_settings()
{
QSettings settings;
// Check if we have to update the pony windows with new always-on-top/bypass-wm value
bool change_ontop = (getSetting<bool>("general/always-on-top", settings) != ui->alwaysontop->isChecked());
bool change_bypass_wm = (getSetting<bool>("general/bypass-wm", settings) != ui->x11_bypass_wm->isChecked());
bool reload_ponies = (getSetting<QString>("general/pony-directory", settings) != ui->ponydata_directory->text());
// Write the program settings
settings.clear();
// General settings
settings.beginGroup("general");
settings.setValue("always-on-top", ui->alwaysontop->isChecked());
settings.setValue("bypass-wm", ui->x11_bypass_wm->isChecked());
settings.setValue("pony-directory", ui->ponydata_directory->text());
settings.setValue("interactions-enabled", ui->interactions_enabled->isChecked());
settings.setValue("debug", ui->debug_enabled->isChecked());
settings.setValue("show-advanced", ui->show_advanced->isChecked());
debug = getSetting<bool>("debug", settings);
settings.endGroup();
// Speech settings
settings.beginGroup("speech");
settings.setValue("enabled", ui->speechenabled->isChecked());
settings.setValue("duration", ui->textdelay->value());
settings.setValue("probability", ui->speechprobability->value());
settings.endGroup();
// Sound settings
settings.beginGroup("sound");
settings.setValue("enabled", ui->playsounds->isChecked());
settings.endGroup();
// Write the active ponies list
settings.beginWriteArray("loaded-ponies");
int i=0;
for(const auto &pony : ponies) {
if(change_ontop) {
pony->set_on_top(ui->alwaysontop->isChecked());
}
if(change_bypass_wm) {
pony->set_bypass_wm(ui->x11_bypass_wm->isChecked());
}
settings.setArrayIndex(i);
settings.setValue("name", pony->directory);
i++;
}
settings.endArray();
if(reload_ponies) {
reload_available_ponies();
}
// Make sure we write our changes to disk
settings.sync();
}
