829 lines
28 KiB
C++
829 lines
28 KiB
C++
/************************************************************************
|
|
**
|
|
** @file mapplication.cpp
|
|
** @author Roman Telezhynskyi <dismine(at)gmail.com>
|
|
** @date 8 7, 2015
|
|
**
|
|
** @brief
|
|
** @copyright
|
|
** This source code is part of the Valentina project, a pattern making
|
|
** program, whose allow create and modeling patterns of clothing.
|
|
** Copyright (C) 2015 Valentina project
|
|
** <https://gitlab.com/smart-pattern/valentina> All Rights Reserved.
|
|
**
|
|
** Valentina 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 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** Valentina 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 Valentina. If not, see <http://www.gnu.org/licenses/>.
|
|
**
|
|
*************************************************************************/
|
|
|
|
#include "mapplication.h"
|
|
#include "version.h"
|
|
#include "tmainwindow.h"
|
|
#include "../ifc/exception/vexceptionobjecterror.h"
|
|
#include "../ifc/exception/vexceptionbadid.h"
|
|
#include "../ifc/exception/vexceptionconversionerror.h"
|
|
#include "../ifc/exception/vexceptionemptyparameter.h"
|
|
#include "../ifc/exception/vexceptionwrongid.h"
|
|
#include "../vmisc/vsysexits.h"
|
|
#include "../vmisc/diagnostic.h"
|
|
#include "../vmisc/qt_dispatch/qt_dispatch.h"
|
|
#include "../qmuparser/qmuparsererror.h"
|
|
#include "../vpatterndb/variables/vmeasurement.h"
|
|
|
|
#include <QDir>
|
|
#include <QFileOpenEvent>
|
|
#include <QLocalSocket>
|
|
#include <QResource>
|
|
#include <QTranslator>
|
|
#include <QPointer>
|
|
#include <QLocalServer>
|
|
#include <QMessageBox>
|
|
#include <iostream>
|
|
#include <QGridLayout>
|
|
#include <QSpacerItem>
|
|
#include <QThread>
|
|
|
|
QT_WARNING_PUSH
|
|
QT_WARNING_DISABLE_CLANG("-Wmissing-prototypes")
|
|
QT_WARNING_DISABLE_INTEL(1418)
|
|
|
|
Q_LOGGING_CATEGORY(mApp, "m.application")
|
|
|
|
QT_WARNING_POP
|
|
|
|
#include <QCommandLineParser>
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
inline void noisyFailureMsgHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
|
|
{
|
|
// only the GUI thread should display message boxes. If you are
|
|
// writing a multithreaded application and the error happens on
|
|
// a non-GUI thread, you'll have to queue the message to the GUI
|
|
QCoreApplication *instance = QCoreApplication::instance();
|
|
const bool isGuiThread = instance && (QThread::currentThread() == instance->thread());
|
|
|
|
if (not isGuiThread)
|
|
{
|
|
auto Handler = [](QtMsgType type, const QMessageLogContext &context, const QString &msg)
|
|
{
|
|
noisyFailureMsgHandler(type, context, msg);
|
|
};
|
|
|
|
q_dispatch_async_main(Handler, type, context, msg);
|
|
return;
|
|
}
|
|
|
|
// Why on earth didn't Qt want to make failed signal/slot connections qWarning?
|
|
if ((type == QtDebugMsg) && msg.contains(QStringLiteral("::connect")))
|
|
{
|
|
type = QtWarningMsg;
|
|
}
|
|
|
|
#if defined(V_NO_ASSERT)
|
|
// I have decided to hide this annoing message for release builds.
|
|
if ((type == QtWarningMsg) && msg.contains(QStringLiteral("QSslSocket: cannot resolve")))
|
|
{
|
|
type = QtDebugMsg;
|
|
}
|
|
|
|
if ((type == QtWarningMsg) && msg.contains(QStringLiteral("setGeometry: Unable to set geometry")))
|
|
{
|
|
type = QtDebugMsg;
|
|
}
|
|
#endif //defined(V_NO_ASSERT)
|
|
|
|
#if defined(Q_OS_MAC)
|
|
# if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0) && QT_VERSION < QT_VERSION_CHECK(5, 7, 0)
|
|
// Try hide very annoying, Qt related, warnings in Mac OS X
|
|
// QNSView mouseDragged: Internal mouse button tracking invalid (missing Qt::LeftButton)
|
|
// https://bugreports.qt.io/browse/QTBUG-42846
|
|
if ((type == QtWarningMsg) && msg.contains(QStringLiteral("QNSView")))
|
|
{
|
|
type = QtDebugMsg;
|
|
}
|
|
# endif
|
|
|
|
// Hide Qt bug 'Assertion when reading an icns file'
|
|
// https://bugreports.qt.io/browse/QTBUG-45537
|
|
// Remove after Qt fix will be released
|
|
if ((type == QtWarningMsg) && msg.contains(QStringLiteral("QICNSHandler::read()")))
|
|
{
|
|
type = QtDebugMsg;
|
|
}
|
|
|
|
// See issue #568
|
|
if (msg.contains(QStringLiteral("Error receiving trust for a CA certificate")))
|
|
{
|
|
type = QtDebugMsg;
|
|
}
|
|
#endif
|
|
|
|
// this is another one that doesn't make sense as just a debug message. pretty serious
|
|
// sign of a problem
|
|
// http://www.developer.nokia.com/Community/Wiki/QPainter::begin:Paint_device_returned_engine_%3D%3D_0_(Known_Issue)
|
|
if ((type == QtDebugMsg) && msg.contains(QStringLiteral("QPainter::begin"))
|
|
&& msg.contains(QStringLiteral("Paint device returned engine")))
|
|
{
|
|
type = QtWarningMsg;
|
|
}
|
|
|
|
// This qWarning about "Cowardly refusing to send clipboard message to hung application..."
|
|
// is something that can easily happen if you are debugging and the application is paused.
|
|
// As it is so common, not worth popping up a dialog.
|
|
if ((type == QtWarningMsg) && msg.contains(QStringLiteral("QClipboard::event"))
|
|
&& msg.contains(QStringLiteral("Cowardly refusing")))
|
|
{
|
|
type = QtDebugMsg;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case QtDebugMsg:
|
|
vStdOut() << QApplication::translate("mNoisyHandler", "DEBUG:") << msg << "\n";
|
|
return;
|
|
case QtWarningMsg:
|
|
vStdErr() << QApplication::translate("mNoisyHandler", "WARNING:") << msg << "\n";
|
|
break;
|
|
case QtCriticalMsg:
|
|
vStdErr() << QApplication::translate("mNoisyHandler", "CRITICAL:") << msg << "\n";
|
|
break;
|
|
case QtFatalMsg:
|
|
vStdErr() << QApplication::translate("mNoisyHandler", "FATAL:") << msg << "\n";
|
|
break;
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
|
|
case QtInfoMsg:
|
|
vStdOut() << QApplication::translate("mNoisyHandler", "INFO:") << msg << "\n";
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
|
|
vStdOut().flush();
|
|
vStdErr().flush();
|
|
|
|
if (isGuiThread)
|
|
{
|
|
//fixme: trying to make sure there are no save/load dialogs are opened, because error message during them will
|
|
//lead to crash
|
|
const bool topWinAllowsPop = (QApplication::activeModalWidget() == nullptr) ||
|
|
!QApplication::activeModalWidget()->inherits("QFileDialog");
|
|
QMessageBox messageBox;
|
|
switch (type)
|
|
{
|
|
case QtWarningMsg:
|
|
messageBox.setWindowTitle(QApplication::translate("mNoisyHandler", "Warning"));
|
|
messageBox.setIcon(QMessageBox::Warning);
|
|
break;
|
|
case QtCriticalMsg:
|
|
messageBox.setWindowTitle(QApplication::translate("mNoisyHandler", "Critical error"));
|
|
messageBox.setIcon(QMessageBox::Critical);
|
|
break;
|
|
case QtFatalMsg:
|
|
messageBox.setWindowTitle(QApplication::translate("mNoisyHandler", "Fatal error"));
|
|
messageBox.setIcon(QMessageBox::Critical);
|
|
break;
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
|
|
case QtInfoMsg:
|
|
messageBox.setWindowTitle(QApplication::translate("mNoisyHandler", "Information"));
|
|
messageBox.setIcon(QMessageBox::Information);
|
|
break;
|
|
#endif
|
|
case QtDebugMsg:
|
|
Q_UNREACHABLE(); //-V501
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (type == QtWarningMsg || type == QtCriticalMsg || type == QtFatalMsg)
|
|
{
|
|
if (not qApp->IsTestMode())
|
|
{
|
|
if (topWinAllowsPop)
|
|
{
|
|
messageBox.setText(VAbstractApplication::ClearMessage(msg));
|
|
messageBox.setStandardButtons(QMessageBox::Ok);
|
|
messageBox.setWindowModality(Qt::ApplicationModal);
|
|
messageBox.setModal(true);
|
|
#ifndef QT_NO_CURSOR
|
|
QGuiApplication::setOverrideCursor(Qt::ArrowCursor);
|
|
#endif
|
|
messageBox.exec();
|
|
#ifndef QT_NO_CURSOR
|
|
QGuiApplication::restoreOverrideCursor();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
if (QtFatalMsg == type)
|
|
{
|
|
abort();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (type != QtDebugMsg)
|
|
{
|
|
abort(); // be NOISY unless overridden!
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
MApplication::MApplication(int &argc, char **argv)
|
|
:VAbstractApplication(argc, argv),
|
|
mainWindows(),
|
|
localServer(nullptr),
|
|
trVars(nullptr),
|
|
dataBase(QPointer<DialogMDataBase>()),
|
|
testMode(false)
|
|
{
|
|
setApplicationDisplayName(VER_PRODUCTNAME_STR);
|
|
setApplicationName(VER_INTERNALNAME_STR);
|
|
setOrganizationName(VER_COMPANYNAME_STR);
|
|
setOrganizationDomain(VER_COMPANYDOMAIN_STR);
|
|
// Setting the Application version
|
|
setApplicationVersion(APP_VERSION_STR);
|
|
// We have been running Tape in two different cases.
|
|
// The first inside own bundle where info.plist is works fine, but the second,
|
|
// when we run inside Valentina's bundle, require direct setting the icon.
|
|
setWindowIcon(QIcon(":/tapeicon/64x64/logo.png"));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
MApplication::~MApplication()
|
|
{
|
|
qDeleteAll(mainWindows);
|
|
|
|
delete trVars;
|
|
if (not dataBase.isNull())
|
|
{
|
|
delete dataBase;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief notify Reimplemented from QApplication::notify().
|
|
* @param receiver receiver.
|
|
* @param event event.
|
|
* @return value that is returned from the receiver's event handler.
|
|
*/
|
|
// reimplemented from QApplication so we can throw exceptions in slots
|
|
bool MApplication::notify(QObject *receiver, QEvent *event)
|
|
{
|
|
try
|
|
{
|
|
return QApplication::notify(receiver, event);
|
|
}
|
|
catch (const VExceptionObjectError &e)
|
|
{
|
|
qCCritical(mApp, "%s\n\n%s\n\n%s", qUtf8Printable(tr("Error parsing file. Program will be terminated.")), //-V807
|
|
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
|
|
exit(V_EX_DATAERR);
|
|
}
|
|
catch (const VExceptionBadId &e)
|
|
{
|
|
qCCritical(mApp, "%s\n\n%s\n\n%s", qUtf8Printable(tr("Error bad id. Program will be terminated.")),
|
|
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
|
|
exit(V_EX_DATAERR);
|
|
}
|
|
catch (const VExceptionConversionError &e)
|
|
{
|
|
qCCritical(mApp, "%s\n\n%s\n\n%s", qUtf8Printable(tr("Error can't convert value. Program will be terminated.")),
|
|
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
|
|
exit(V_EX_DATAERR);
|
|
}
|
|
catch (const VExceptionEmptyParameter &e)
|
|
{
|
|
qCCritical(mApp, "%s\n\n%s\n\n%s", qUtf8Printable(tr("Error empty parameter. Program will be terminated.")),
|
|
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
|
|
exit(V_EX_DATAERR);
|
|
}
|
|
catch (const VExceptionWrongId &e)
|
|
{
|
|
qCCritical(mApp, "%s\n\n%s\n\n%s", qUtf8Printable(tr("Error wrong id. Program will be terminated.")),
|
|
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
|
|
exit(V_EX_DATAERR);
|
|
}
|
|
catch (const VExceptionToolWasDeleted &e)
|
|
{
|
|
qCCritical(mApp, "%s\n\n%s\n\n%s",
|
|
qUtf8Printable("Unhadled deleting tool. Continue use object after deleting!"),
|
|
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
|
|
exit(V_EX_DATAERR);
|
|
}
|
|
catch (const VException &e)
|
|
{
|
|
qCCritical(mApp, "%s\n\n%s\n\n%s", qUtf8Printable(tr("Something's wrong!!")),
|
|
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
|
|
return true;
|
|
}
|
|
// These last two cases special. I found that we can't show here modal dialog with error message.
|
|
// Somehow program doesn't waite untile an error dialog will be closed. But if ignore this program will hang.
|
|
catch (const qmu::QmuParserError &e)
|
|
{
|
|
qCCritical(mApp, "%s", qUtf8Printable(tr("Parser error: %1. Program will be terminated.").arg(e.GetMsg())));
|
|
exit(V_EX_DATAERR);
|
|
}
|
|
catch (std::exception &e)
|
|
{
|
|
qCCritical(mApp, "%s", qUtf8Printable(tr("Exception thrown: %1. Program will be terminated.").arg(e.what())));
|
|
exit(V_EX_SOFTWARE);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool MApplication::IsTestMode() const
|
|
{
|
|
return testMode;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief IsAppInGUIMode little hack that allow to have access to application state from VAbstractApplication class.
|
|
*/
|
|
bool MApplication::IsAppInGUIMode() const
|
|
{
|
|
return IsTestMode();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
TMainWindow *MApplication::MainWindow()
|
|
{
|
|
Clean();
|
|
if (mainWindows.isEmpty())
|
|
{
|
|
NewMainWindow();
|
|
}
|
|
return mainWindows[0];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
QList<TMainWindow *> MApplication::MainWindows()
|
|
{
|
|
Clean();
|
|
QList<TMainWindow*> list;
|
|
for (auto &w : mainWindows)
|
|
{
|
|
list.append(w);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::InitOptions()
|
|
{
|
|
qInstallMessageHandler(noisyFailureMsgHandler);
|
|
|
|
OpenSettings();
|
|
|
|
qCDebug(mApp, "Version: %s", qUtf8Printable(APP_VERSION_STR));
|
|
qCDebug(mApp, "Build revision: %s", BUILD_REVISION);
|
|
qCDebug(mApp, "%s", qUtf8Printable(buildCompatibilityString()));
|
|
qCDebug(mApp, "Built on %s at %s", __DATE__, __TIME__);
|
|
qCDebug(mApp, "Command-line arguments: %s", qUtf8Printable(arguments().join(", ")));
|
|
qCDebug(mApp, "Process ID: %s", qUtf8Printable(QString().setNum(applicationPid())));
|
|
|
|
LoadTranslation(QLocale().name());// By default the console version uses system locale
|
|
|
|
static const char * GENERIC_ICON_TO_CHECK = "document-open";
|
|
if (QIcon::hasThemeIcon(GENERIC_ICON_TO_CHECK) == false)
|
|
{
|
|
//If there is no default working icon theme then we should
|
|
//use an icon theme that we provide via a .qrc file
|
|
//This case happens under Windows and Mac OS X
|
|
//This does not happen under GNOME or KDE
|
|
QIcon::setThemeName("win.icon.theme");
|
|
}
|
|
ActivateDarkMode();
|
|
QResource::registerResource(diagramsPath());
|
|
}
|
|
// Dark mode
|
|
|
|
void MApplication::ActivateDarkMode()
|
|
{
|
|
VTapeSettings *settings = qApp->TapeSettings();
|
|
if (settings->GetDarkMode())
|
|
{
|
|
QFile f(":qdarkstyle/style.qss");
|
|
if (!f.exists())
|
|
{
|
|
qDebug()<<"Unable to set stylesheet, file not found\n";
|
|
}
|
|
else
|
|
{
|
|
f.open(QFile::ReadOnly | QFile::Text);
|
|
QTextStream ts(&f);
|
|
qApp->setStyleSheet(ts.readAll());
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::InitTrVars()
|
|
{
|
|
if (trVars != nullptr)
|
|
{
|
|
trVars->Retranslate();
|
|
}
|
|
else
|
|
{
|
|
trVars = new VTranslateVars();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool MApplication::event(QEvent *e)
|
|
{
|
|
switch(e->type())
|
|
{
|
|
// In Mac OS X the QFileOpenEvent event is generated when user perform "Open With" from Finder (this event is
|
|
// Mac specific).
|
|
case QEvent::FileOpen:
|
|
{
|
|
QFileOpenEvent *fileOpenEvent = static_cast<QFileOpenEvent *>(e);
|
|
const QString macFileOpen = fileOpenEvent->file();
|
|
if(not macFileOpen.isEmpty())
|
|
{
|
|
TMainWindow *mw = MainWindow();
|
|
if (mw)
|
|
{
|
|
mw->LoadFile(macFileOpen); // open file in existing window
|
|
}
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
#if defined(Q_OS_MAC)
|
|
case QEvent::ApplicationActivate:
|
|
{
|
|
Clean();
|
|
TMainWindow *mw = MainWindow();
|
|
if (mw && not mw->isMinimized())
|
|
{
|
|
mw->show();
|
|
}
|
|
return true;
|
|
}
|
|
#endif //defined(Q_OS_MAC)
|
|
default:
|
|
return VAbstractApplication::event(e);
|
|
}
|
|
return VAbstractApplication::event(e);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::AboutToQuit()
|
|
{
|
|
// If try to use the method QApplication::exit program can't sync settings and show warning about QApplication
|
|
// instance. Solution is to call sync() before quit.
|
|
// Connect this slot with VApplication::aboutToQuit.
|
|
Settings()->sync();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::OpenSettings()
|
|
{
|
|
settings = new VTapeSettings(QSettings::IniFormat, QSettings::UserScope, QCoreApplication::organizationName(),
|
|
QCoreApplication::applicationName(), this);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
VTapeSettings *MApplication::TapeSettings()
|
|
{
|
|
SCASSERT(settings != nullptr)
|
|
return qobject_cast<VTapeSettings *>(settings);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
QString MApplication::diagramsPath() const
|
|
{
|
|
const QString dPath = QStringLiteral("/diagrams.rcc");
|
|
#ifdef Q_OS_WIN
|
|
return QCoreApplication::applicationDirPath() + dPath;
|
|
#elif defined(Q_OS_MAC)
|
|
QFileInfo fileBundle(QCoreApplication::applicationDirPath() + QStringLiteral("/../Resources") + dPath);
|
|
if (fileBundle.exists())
|
|
{
|
|
return fileBundle.absoluteFilePath();
|
|
}
|
|
else
|
|
{
|
|
QFileInfo file(QCoreApplication::applicationDirPath() + dPath);
|
|
if (file.exists())
|
|
{
|
|
return file.absoluteFilePath();
|
|
}
|
|
else
|
|
{
|
|
return QStringLiteral("/usr/share/valentina") + dPath;
|
|
}
|
|
}
|
|
#else // Unix
|
|
QFileInfo file(QCoreApplication::applicationDirPath() + dPath);
|
|
if (file.exists())
|
|
{
|
|
return file.absoluteFilePath();
|
|
}
|
|
else
|
|
{
|
|
return QStringLiteral("/usr/share/valentina") + dPath;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::ShowDataBase()
|
|
{
|
|
if (dataBase.isNull())
|
|
{
|
|
dataBase = new DialogMDataBase();
|
|
dataBase->setAttribute(Qt::WA_DeleteOnClose, true);
|
|
dataBase->setModal(false);
|
|
dataBase->show();
|
|
}
|
|
else
|
|
{
|
|
dataBase->activateWindow();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::RetranslateGroups()
|
|
{
|
|
if (not dataBase.isNull())
|
|
{
|
|
dataBase->RetranslateGroups();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::RetranslateTables()
|
|
{
|
|
const QList<TMainWindow*> list = MainWindows();
|
|
for (auto w : list)
|
|
{
|
|
w->RetranslateTable();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::ParseCommandLine(const SocketConnection &connection, const QStringList &arguments)
|
|
{
|
|
QCommandLineParser parser;
|
|
parser.setApplicationDescription(tr("Valentina's measurements editor."));
|
|
parser.addHelpOption();
|
|
parser.addVersionOption();
|
|
parser.addPositionalArgument("filename", tr("The measurement file."));
|
|
//-----
|
|
QCommandLineOption heightOption(QStringList() << "e" << "height",
|
|
tr("Open with the base height. Valid values: %1cm.")
|
|
.arg(VMeasurement::WholeListHeights(Unit::Cm).join(", ")),
|
|
tr("The base height"));
|
|
parser.addOption(heightOption);
|
|
//-----
|
|
QCommandLineOption sizeOption(QStringList() << "s" << "size",
|
|
tr("Open with the base size. Valid values: %1cm.").arg(VMeasurement::WholeListSizes(Unit::Cm).join(", ")),
|
|
tr("The base size"));
|
|
parser.addOption(sizeOption);
|
|
//-----
|
|
QCommandLineOption unitOption(QStringList() << "u" << "unit",
|
|
tr("Set pattern file unit: cm, mm, inch."),
|
|
tr("The pattern unit"));
|
|
parser.addOption(unitOption);
|
|
//-----
|
|
QCommandLineOption testOption(QStringList() << "test",
|
|
tr("Use for unit testing. Run the program and open a file without showing the main window."));
|
|
parser.addOption(testOption);
|
|
//-----
|
|
QCommandLineOption scalingOption(QStringList() << LONG_OPTION_NO_HDPI_SCALING,
|
|
tr("Disable high dpi scaling. Call this option if has problem with scaling (by default scaling enabled). "
|
|
"Alternatively you can use the %1 environment variable.").arg("QT_AUTO_SCREEN_SCALE_FACTOR=0"));
|
|
parser.addOption(scalingOption);
|
|
//-----
|
|
parser.process(arguments);
|
|
|
|
bool flagHeight = false;
|
|
bool flagSize = false;
|
|
bool flagUnit = false;
|
|
|
|
int size = 0;
|
|
int height = 0;
|
|
Unit unit = Unit::Cm;
|
|
|
|
if (parser.isSet(heightOption))
|
|
{
|
|
const QString heightValue = parser.value(heightOption);
|
|
if (VMeasurement::IsGradationHeightValid(heightValue))
|
|
{
|
|
flagHeight = true;
|
|
height = heightValue.toInt();
|
|
}
|
|
else
|
|
{
|
|
qCCritical(mApp, "%s\n",
|
|
qPrintable(tr("Invalid base height argument. Must be %1cm.")
|
|
.arg(VMeasurement::WholeListHeights(Unit::Cm).join(", "))));
|
|
parser.showHelp(V_EX_USAGE);
|
|
}
|
|
}
|
|
|
|
if (parser.isSet(sizeOption))
|
|
{
|
|
const QString sizeValue = parser.value(sizeOption);
|
|
if (VMeasurement::IsGradationSizeValid(sizeValue))
|
|
{
|
|
flagSize = true;
|
|
size = sizeValue.toInt();
|
|
}
|
|
else
|
|
{
|
|
qCCritical(mApp, "%s\n",
|
|
qPrintable(tr("Invalid base size argument. Must be %1cm.")
|
|
.arg(VMeasurement::WholeListSizes(Unit::Cm).join(", "))));
|
|
parser.showHelp(V_EX_USAGE);
|
|
}
|
|
}
|
|
|
|
{
|
|
const QString unitValue = parser.value(unitOption);
|
|
if (not unitValue.isEmpty())
|
|
{
|
|
|
|
const QStringList units = QStringList() << unitMM << unitCM << unitINCH;
|
|
if (units.contains(unitValue))
|
|
{
|
|
flagUnit = true;
|
|
unit = StrToUnits(unitValue);
|
|
}
|
|
else
|
|
{
|
|
qCCritical(mApp, "%s\n", qPrintable(tr("Invalid base size argument. Must be cm, mm or inch.")));
|
|
parser.showHelp(V_EX_USAGE);
|
|
}
|
|
}
|
|
}
|
|
|
|
testMode = parser.isSet(testOption);
|
|
|
|
if (not testMode && connection == SocketConnection::Client)
|
|
{
|
|
const QString serverName = QCoreApplication::applicationName();
|
|
QLocalSocket socket;
|
|
socket.connectToServer(serverName);
|
|
if (socket.waitForConnected(1000))
|
|
{
|
|
qCDebug(mApp, "Connected to the server '%s'", qUtf8Printable(serverName));
|
|
QTextStream stream(&socket);
|
|
stream << QCoreApplication::arguments().join(";;");
|
|
stream.flush();
|
|
socket.waitForBytesWritten();
|
|
qApp->exit(V_EX_OK);
|
|
return;
|
|
}
|
|
|
|
qCDebug(mApp, "Can't establish connection to the server '%s'", qUtf8Printable(serverName));
|
|
|
|
localServer = new QLocalServer(this);
|
|
connect(localServer, &QLocalServer::newConnection, this, &MApplication::NewLocalSocketConnection);
|
|
if (not localServer->listen(serverName))
|
|
{
|
|
qCDebug(mApp, "Can't begin to listen for incoming connections on name '%s'",
|
|
qUtf8Printable(serverName));
|
|
if (localServer->serverError() == QAbstractSocket::AddressInUseError)
|
|
{
|
|
QLocalServer::removeServer(serverName);
|
|
if (not localServer->listen(serverName))
|
|
{
|
|
qCWarning(mApp, "%s",
|
|
qUtf8Printable(tr("Can't begin to listen for incoming connections on name '%1'").arg(serverName)));
|
|
}
|
|
}
|
|
}
|
|
|
|
LoadTranslation(TapeSettings()->GetLocale());
|
|
}
|
|
|
|
const QStringList args = parser.positionalArguments();
|
|
if (args.count() > 0)
|
|
{
|
|
if (testMode && args.count() > 1)
|
|
{
|
|
qCCritical(mApp, "%s\n", qPrintable(tr("Test mode doesn't support openning several files.")));
|
|
parser.showHelp(V_EX_USAGE);
|
|
}
|
|
|
|
for (auto &arg : args)
|
|
{
|
|
NewMainWindow();
|
|
if (not MainWindow()->LoadFile(arg))
|
|
{
|
|
if (testMode)
|
|
{
|
|
return; // process only one input file
|
|
}
|
|
delete MainWindow();
|
|
continue;
|
|
}
|
|
|
|
if (flagSize)
|
|
{
|
|
MainWindow()->SetBaseMSize(size);
|
|
}
|
|
|
|
if (flagHeight)
|
|
{
|
|
MainWindow()->SetBaseMHeight(height);
|
|
}
|
|
|
|
if (flagUnit)
|
|
{
|
|
MainWindow()->SetPUnit(unit);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (not testMode)
|
|
{
|
|
NewMainWindow();
|
|
}
|
|
else
|
|
{
|
|
qCCritical(mApp, "%s\n", qPrintable(tr("Please, provide one input file.")));
|
|
parser.showHelp(V_EX_USAGE);
|
|
}
|
|
}
|
|
|
|
if (testMode)
|
|
{
|
|
qApp->exit(V_EX_OK); // close program after processing in console mode
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
TMainWindow *MApplication::NewMainWindow()
|
|
{
|
|
TMainWindow *tape = new TMainWindow();
|
|
mainWindows.prepend(tape);
|
|
if (not qApp->IsTestMode())
|
|
{
|
|
tape->show();
|
|
}
|
|
return tape;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::ProcessCMD()
|
|
{
|
|
ParseCommandLine(SocketConnection::Client, arguments());
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::NewLocalSocketConnection()
|
|
{
|
|
QLocalSocket *socket = localServer->nextPendingConnection();
|
|
if (not socket)
|
|
{
|
|
return;
|
|
}
|
|
socket->waitForReadyRead(1000);
|
|
QTextStream stream(socket);
|
|
const QString arg = stream.readAll();
|
|
if (not arg.isEmpty())
|
|
{
|
|
ParseCommandLine(SocketConnection::Server, arg.split(";;"));
|
|
}
|
|
delete socket;
|
|
MainWindow()->raise();
|
|
MainWindow()->activateWindow();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void MApplication::Clean()
|
|
{
|
|
// cleanup any deleted main windows first
|
|
for (int i = mainWindows.count() - 1; i >= 0; --i)
|
|
{
|
|
if (mainWindows.at(i).isNull())
|
|
{
|
|
mainWindows.removeAt(i);
|
|
}
|
|
}
|
|
}
|