mirror of
https://gitlab.com/smart-pattern/valentina.git
synced 2024-07-05 10:36:10 +02:00
719 lines
24 KiB
C++
719 lines
24 KiB
C++
/************************************************************************
|
|
**
|
|
** @file def.cpp
|
|
** @author Roman Telezhynskyi <dismine(at)gmail.com>
|
|
** @date 11 6, 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 "def.h"
|
|
|
|
#include <QApplication>
|
|
#include <QChar>
|
|
#include <QColor>
|
|
#include <QComboBox>
|
|
#include <QCursor>
|
|
#include <QDesktopServices>
|
|
#include <QDir>
|
|
#include <QDirIterator>
|
|
#include <QFileInfo>
|
|
#include <QGlobalStatic>
|
|
#include <QGraphicsItem>
|
|
#include <QGuiApplication>
|
|
#include <QImage>
|
|
#include <QLatin1Char>
|
|
#include <QList>
|
|
#include <QMap>
|
|
#include <QMessageLogger>
|
|
#include <QObject>
|
|
#include <QPixmap>
|
|
#include <QPixmapCache>
|
|
#include <QPrinterInfo>
|
|
#include <QProcess>
|
|
#include <QRgb>
|
|
#include <QUrl>
|
|
#include <QtDebug>
|
|
|
|
#include "../ifc/exception/vexception.h"
|
|
#include "compatibility.h"
|
|
#include "literals.h"
|
|
#include "vabstractapplication.h"
|
|
|
|
using namespace Qt::Literals::StringLiterals;
|
|
|
|
namespace
|
|
{
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto LocalList() -> QStringList
|
|
{
|
|
static QStringList fileNames;
|
|
|
|
// Check if file names have already been cached
|
|
if (!fileNames.isEmpty())
|
|
{
|
|
return fileNames;
|
|
}
|
|
|
|
QDirIterator it(VAbstractApplication::translationsPath(), QStringList("valentina_*.qm"), QDir::Files,
|
|
QDirIterator::Subdirectories);
|
|
while (it.hasNext())
|
|
{
|
|
it.next();
|
|
fileNames.append(it.fileName());
|
|
}
|
|
return fileNames;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void InitLanguageList(QComboBox *combobox)
|
|
{
|
|
SCASSERT(combobox != nullptr)
|
|
combobox->clear();
|
|
|
|
const QStringList fileNames = LocalList();
|
|
const QStringList supportedLocales = SupportedLocales();
|
|
|
|
for (auto locale : fileNames)
|
|
{
|
|
// get locale extracted by filename "valentina_de_De.qm"
|
|
locale.truncate(locale.lastIndexOf('.'_L1)); // "valentina_de_De"
|
|
locale.remove(0, locale.indexOf('_'_L1) + 1); // "de_De"
|
|
|
|
if (locale.startsWith("ru"_L1) || !supportedLocales.contains(locale))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
QLocale const loc = QLocale(locale);
|
|
QString const lang = loc.nativeLanguageName();
|
|
QString country = TerritoryToString(loc);
|
|
if (country == "Czechia"_L1)
|
|
{
|
|
country = "CzechRepublic"_L1;
|
|
}
|
|
QIcon const ico(u"://flags/%1.png"_s.arg(country));
|
|
|
|
combobox->addItem(ico, lang, locale);
|
|
}
|
|
|
|
// English language is internal and doesn't have own *.qm file.
|
|
// Since Qt 5.12 country names have spaces
|
|
QIcon const ico(u"://flags/%1.png"_s.arg(TerritoryToString(QLocale::UnitedStates)));
|
|
const QString en_US = QStringLiteral("en_US");
|
|
QString const lang = QLocale(en_US).nativeLanguageName();
|
|
combobox->addItem(ico, lang, en_US);
|
|
}
|
|
} // namespace
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto QPixmapFromCache(const QString &pixmapPath) -> QPixmap
|
|
{
|
|
QPixmap pixmap;
|
|
|
|
if (not QPixmapCache::find(pixmapPath, &pixmap))
|
|
{
|
|
pixmap = QPixmap(pixmapPath);
|
|
QPixmapCache::insert(pixmapPath, pixmap);
|
|
}
|
|
return pixmap;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void SetItemOverrideCursor(QGraphicsItem *item, const QString &pixmapPath, int hotX, int hotY)
|
|
{
|
|
#ifndef QT_NO_CURSOR
|
|
SCASSERT(item != nullptr)
|
|
item->setCursor(QCursor(QPixmapFromCache(pixmapPath), hotX, hotY));
|
|
#else
|
|
Q_UNUSED(item)
|
|
Q_UNUSED(pixmapPath)
|
|
Q_UNUSED(hotX)
|
|
Q_UNUSED(hotY)
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto SupportedLocales() -> QStringList
|
|
{
|
|
return QStringList{"uk_UA", "de_DE", "cs_CZ", "he_IL", "fr_FR", "it_IT", "nl_NL", "id_ID",
|
|
"es_ES", "fi_FI", "ro_RO", "zh_CN", "pt_BR", "el_GR", "pl_PL"};
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto RelativeMPath(const QString &patternPath, const QString &absoluteMPath) -> QString
|
|
{
|
|
if (patternPath.isEmpty() || absoluteMPath.isEmpty())
|
|
{
|
|
return absoluteMPath;
|
|
}
|
|
|
|
if (QFileInfo(absoluteMPath).isRelative())
|
|
{
|
|
return absoluteMPath;
|
|
}
|
|
|
|
return QFileInfo(patternPath).absoluteDir().relativeFilePath(absoluteMPath);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto AbsoluteMPath(const QString &patternPath, const QString &relativeMPath) -> QString
|
|
{
|
|
if (patternPath.isEmpty() || relativeMPath.isEmpty())
|
|
{
|
|
return relativeMPath;
|
|
}
|
|
|
|
if (QFileInfo(relativeMPath).isAbsolute())
|
|
{
|
|
return relativeMPath;
|
|
}
|
|
|
|
return QFileInfo(QFileInfo(patternPath).absoluteDir(), relativeMPath).absoluteFilePath();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto GetMinPrinterFields(const QSharedPointer<QPrinter> &printer) -> QMarginsF
|
|
{
|
|
QPageLayout layout = printer->pageLayout();
|
|
layout.setUnits(QPageLayout::Millimeter);
|
|
const QMarginsF minMargins = layout.minimumMargins();
|
|
|
|
QMarginsF min;
|
|
min.setLeft(UnitConvertor(minMargins.left(), Unit::Mm, Unit::Px));
|
|
min.setRight(UnitConvertor(minMargins.right(), Unit::Mm, Unit::Px));
|
|
min.setTop(UnitConvertor(minMargins.top(), Unit::Mm, Unit::Px));
|
|
min.setBottom(UnitConvertor(minMargins.bottom(), Unit::Mm, Unit::Px));
|
|
return min;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto GetPrinterFields(const QSharedPointer<QPrinter> &printer) -> QMarginsF
|
|
{
|
|
if (printer.isNull())
|
|
{
|
|
return {};
|
|
}
|
|
|
|
// We can't use Unit::Px because our dpi in most cases is different
|
|
const QMarginsF m = printer->pageLayout().margins(QPageLayout::Millimeter);
|
|
|
|
QMarginsF def;
|
|
def.setLeft(UnitConvertor(m.left(), Unit::Mm, Unit::Px));
|
|
def.setRight(UnitConvertor(m.right(), Unit::Mm, Unit::Px));
|
|
def.setTop(UnitConvertor(m.top(), Unit::Mm, Unit::Px));
|
|
def.setBottom(UnitConvertor(m.bottom(), Unit::Mm, Unit::Px));
|
|
return def;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto darkenPixmap(const QPixmap &pixmap) -> QPixmap
|
|
{
|
|
QImage img = pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
|
|
const int imgh = img.height();
|
|
const int imgw = img.width();
|
|
for (int y = 0; y < imgh; ++y)
|
|
{
|
|
for (int x = 0; x < imgw; ++x)
|
|
{
|
|
int h;
|
|
int s;
|
|
int v;
|
|
QRgb pixel = img.pixel(x, y);
|
|
const int a = qAlpha(pixel);
|
|
QColor hsvColor(pixel);
|
|
hsvColor.getHsv(&h, &s, &v);
|
|
s = qMin(100, s * 2);
|
|
v = v / 2;
|
|
hsvColor.setHsv(h, s, v);
|
|
pixel = hsvColor.rgb();
|
|
img.setPixel(x, y, qRgba(qRed(pixel), qGreen(pixel), qBlue(pixel), a));
|
|
}
|
|
}
|
|
return QPixmap::fromImage(img);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void ShowInGraphicalShell(const QString &filePath)
|
|
{
|
|
#ifdef Q_OS_MAC
|
|
QStringList args{"-e", "tell application \"Finder\"",
|
|
"-e", "activate",
|
|
"-e", "select POSIX file \"" + filePath + "\"",
|
|
"-e", "end tell"};
|
|
QProcess::startDetached(QStringLiteral("osascript"), args);
|
|
#elif defined(Q_OS_WIN)
|
|
QProcess::startDetached(QStringLiteral("explorer"), QStringList{"/select", QDir::toNativeSeparators(filePath)});
|
|
#else
|
|
const int timeout = 1000; // ms
|
|
QString const command = QStringLiteral("dbus-send --reply-timeout=%1 --session --dest=org.freedesktop.FileManager1 "
|
|
"--type=method_call /org/freedesktop/FileManager1 "
|
|
"org.freedesktop.FileManager1.ShowItems array:string:\"%2\" string:\"\"")
|
|
.arg(timeout)
|
|
.arg(QUrl::fromLocalFile(filePath).toString());
|
|
|
|
// Sending message through dbus will highlighting file
|
|
QProcess dbus;
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
// This approach works too.
|
|
dbus.start(command, QStringList()); // clazy:exclude=qt6-deprecated-api-fixes
|
|
#else
|
|
dbus.startCommand(command);
|
|
#endif
|
|
if (not dbus.waitForStarted(timeout))
|
|
{
|
|
// This way will open only window without highlighting file
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(QFileInfo(filePath).path()));
|
|
return;
|
|
}
|
|
|
|
if (not dbus.waitForFinished(timeout))
|
|
{
|
|
// This way will open only window without highlighting file
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(QFileInfo(filePath).path()));
|
|
return;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
#ifdef Q_OS_MAC
|
|
#if MACOS_LAYER_BACKING_AFFECTED
|
|
void MacosEnableLayerBacking()
|
|
{
|
|
QOperatingSystemVersion osVer = QOperatingSystemVersion::current();
|
|
const int majorVer = osVer.majorVersion();
|
|
const int minorVer = osVer.minorVersion();
|
|
if (((majorVer == 10 && minorVer >= 16) || majorVer >= 11) && qEnvironmentVariableIsEmpty("QT_MAC_WANTS_LAYER"))
|
|
{
|
|
qputenv("QT_MAC_WANTS_LAYER", "1");
|
|
}
|
|
}
|
|
#endif // MACOS_LAYER_BACKING_AFFECTED
|
|
#endif // Q_OS_MAC
|
|
|
|
QT_WARNING_PUSH
|
|
QT_WARNING_DISABLE_CLANG("-Wunused-member-function")
|
|
|
|
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strTMark, ("tMark"_L1)) // NOLINT
|
|
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strVMark, ("vMark"_L1)) // NOLINT
|
|
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strVMark2, ("vMark2"_L1)) // NOLINT
|
|
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strUMark, ("uMark"_L1)) // NOLINT
|
|
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strBoxMark, ("boxMark"_L1)) // NOLINT
|
|
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strCheckMark, ("checkMark"_L1)) // NOLINT
|
|
|
|
QT_WARNING_POP
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto PassmarkLineTypeToString(PassmarkLineType type) -> QString
|
|
{
|
|
switch (type)
|
|
{
|
|
case PassmarkLineType::OneLine:
|
|
return strOne;
|
|
case PassmarkLineType::TwoLines:
|
|
return strTwo;
|
|
case PassmarkLineType::ThreeLines:
|
|
return strThree;
|
|
case PassmarkLineType::TMark:
|
|
return *strTMark;
|
|
case PassmarkLineType::ExternalVMark:
|
|
return *strVMark;
|
|
case PassmarkLineType::InternalVMark:
|
|
return *strVMark2;
|
|
case PassmarkLineType::UMark:
|
|
return *strUMark;
|
|
case PassmarkLineType::BoxMark:
|
|
return *strBoxMark;
|
|
case PassmarkLineType::CheckMark:
|
|
return *strCheckMark;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return strOne;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto StringToPassmarkLineType(const QString &value) -> PassmarkLineType
|
|
{
|
|
const QStringList values{strOne, strTwo, strThree, *strTMark, *strVMark,
|
|
*strVMark2, *strUMark, *strBoxMark, *strCheckMark};
|
|
|
|
switch (values.indexOf(value))
|
|
{
|
|
case 0: // strOne
|
|
return PassmarkLineType::OneLine;
|
|
case 1: // strTwo
|
|
return PassmarkLineType::TwoLines;
|
|
case 2: // strThree
|
|
return PassmarkLineType::ThreeLines;
|
|
case 3: // strTMark
|
|
return PassmarkLineType::TMark;
|
|
case 4: // strVMark
|
|
return PassmarkLineType::ExternalVMark;
|
|
case 5: // strVMark2
|
|
return PassmarkLineType::InternalVMark;
|
|
case 6: // strUMark
|
|
return PassmarkLineType::UMark;
|
|
case 7: // strBoxMark
|
|
return PassmarkLineType::BoxMark;
|
|
case 8: // strCheckMark
|
|
return PassmarkLineType::CheckMark;
|
|
default:
|
|
break;
|
|
}
|
|
return PassmarkLineType::OneLine;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto PassmarkAngleTypeToString(PassmarkAngleType type) -> QString
|
|
{
|
|
switch (type)
|
|
{
|
|
case PassmarkAngleType::Straightforward:
|
|
return strStraightforward;
|
|
case PassmarkAngleType::Bisector:
|
|
return strBisector;
|
|
case PassmarkAngleType::Intersection:
|
|
return strIntersection;
|
|
case PassmarkAngleType::IntersectionOnlyLeft:
|
|
return strIntersectionOnlyLeft;
|
|
case PassmarkAngleType::IntersectionOnlyRight:
|
|
return strIntersectionOnlyRight;
|
|
case PassmarkAngleType::Intersection2:
|
|
return strIntersection2;
|
|
case PassmarkAngleType::Intersection2OnlyLeft:
|
|
return strIntersection2OnlyLeft;
|
|
case PassmarkAngleType::Intersection2OnlyRight:
|
|
return strIntersection2OnlyRight;
|
|
default:
|
|
return strStraightforward;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto StringToPassmarkAngleType(const QString &value) -> PassmarkAngleType
|
|
{
|
|
const QStringList values{
|
|
strStraightforward, strBisector, strIntersection, strIntersectionOnlyLeft,
|
|
strIntersectionOnlyRight, strIntersection2, strIntersection2OnlyLeft, strIntersection2OnlyRight};
|
|
|
|
switch (values.indexOf(value))
|
|
{
|
|
case 0:
|
|
return PassmarkAngleType::Straightforward;
|
|
case 1:
|
|
return PassmarkAngleType::Bisector;
|
|
case 2:
|
|
return PassmarkAngleType::Intersection;
|
|
case 3:
|
|
return PassmarkAngleType::IntersectionOnlyLeft;
|
|
case 4:
|
|
return PassmarkAngleType::IntersectionOnlyRight;
|
|
case 5:
|
|
return PassmarkAngleType::Intersection2;
|
|
case 6:
|
|
return PassmarkAngleType::Intersection2OnlyLeft;
|
|
case 7:
|
|
return PassmarkAngleType::Intersection2OnlyRight;
|
|
default:
|
|
return PassmarkAngleType::Straightforward;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto FoldLineTypeToString(FoldLineType type) -> QString
|
|
{
|
|
switch (type)
|
|
{
|
|
case FoldLineType::TwoArrowsTextUnder:
|
|
return strFoldTypeTwoArrowsTextUnder;
|
|
case FoldLineType::TwoArrows:
|
|
return strFoldTypeTwoArrows;
|
|
case FoldLineType::Text:
|
|
return strFoldTypeText;
|
|
case FoldLineType::ThreeDots:
|
|
return strFoldTypeThreeDots;
|
|
case FoldLineType::ThreeX:
|
|
return strFoldTypeThreeX;
|
|
case FoldLineType::None:
|
|
return strFoldTypeNone;
|
|
case FoldLineType::TwoArrowsTextAbove:
|
|
default:
|
|
return strFoldTypeTwoArrowsTextAbove;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto StringToFoldLineType(const QString &value) -> FoldLineType
|
|
{
|
|
const QStringList values{strFoldTypeTwoArrowsTextAbove, // 0
|
|
strFoldTypeTwoArrowsTextUnder, // 1
|
|
strFoldTypeTwoArrows, // 2
|
|
strFoldTypeText, // 3
|
|
strFoldTypeThreeDots, // 4
|
|
strFoldTypeThreeX, // 5
|
|
strFoldTypeNone}; // 6
|
|
|
|
switch (values.indexOf(value))
|
|
{
|
|
case 1:
|
|
return FoldLineType::TwoArrowsTextUnder;
|
|
case 2:
|
|
return FoldLineType::TwoArrows;
|
|
case 3:
|
|
return FoldLineType::Text;
|
|
case 4:
|
|
return FoldLineType::ThreeDots;
|
|
case 5:
|
|
return FoldLineType::ThreeX;
|
|
case 6:
|
|
return FoldLineType::None;
|
|
case 0:
|
|
default:
|
|
return FoldLineType::TwoArrowsTextAbove;
|
|
};
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto StrToUnits(const QString &unit) -> Unit
|
|
{
|
|
const QStringList units{unitMM, unitCM, unitINCH, unitPX};
|
|
switch (units.indexOf(unit))
|
|
{
|
|
case 0: // mm
|
|
return Unit::Mm;
|
|
case 2: // inch
|
|
return Unit::Inch;
|
|
case 3: // px
|
|
return Unit::Px;
|
|
case 1: // cm
|
|
default:
|
|
return Unit::Cm;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief UnitsToStr translate unit to string.
|
|
*
|
|
* This method used when need write unit in xml file and for showing unit in dialogs.
|
|
* @param unit curent unit
|
|
* @param translate true if need show translated name. Default value false.
|
|
* @return string reprezantation for unit.
|
|
*/
|
|
auto UnitsToStr(const Unit &unit, const bool translate) -> QString
|
|
{
|
|
switch (unit)
|
|
{
|
|
case Unit::Mm:
|
|
return translate ? QObject::tr("mm") : unitMM;
|
|
case Unit::Inch:
|
|
return translate ? QObject::tr("inch") : unitINCH;
|
|
case Unit::Px:
|
|
return translate ? QObject::tr("px") : unitPX;
|
|
case Unit::LAST_UNIT_DO_NOT_USE:
|
|
return {};
|
|
case Unit::Cm:
|
|
default:
|
|
return translate ? QObject::tr("cm") : unitCM;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void InitLanguages(QComboBox *combobox)
|
|
{
|
|
InitLanguageList(combobox);
|
|
|
|
// set default translators and language checked
|
|
qint32 const index = combobox->findData(VAbstractApplication::VApp()->Settings()->GetLocale());
|
|
if (index != -1)
|
|
{
|
|
combobox->setCurrentIndex(index);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void InitPieceLabelLanguages(QComboBox *combobox)
|
|
{
|
|
InitLanguageList(combobox);
|
|
|
|
combobox->addItem(QApplication::translate("InitPieceLabelLanguages", "Default"),
|
|
VCommonSettings::defaultPieceLabelLocale);
|
|
|
|
qint32 const index = combobox->findData(VAbstractApplication::VApp()->Settings()->GetPieceLabelLocale());
|
|
if (index != -1)
|
|
{
|
|
combobox->setCurrentIndex(index);
|
|
}
|
|
}
|
|
|
|
const quint32 CustomSARecord::streamHeader = 0xEBFF7586; // CRC-32Q string "CustomSARecord"
|
|
const quint16 CustomSARecord::classVersion = 1;
|
|
|
|
// Friend functions
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto operator<<(QDataStream &out, const CustomSARecord &record) -> QDataStream &
|
|
{
|
|
out << CustomSARecord::streamHeader << CustomSARecord::classVersion;
|
|
|
|
// Added in classVersion = 1
|
|
out << record.startPoint;
|
|
out << record.path;
|
|
out << record.endPoint;
|
|
out << record.reverse;
|
|
out << record.includeType;
|
|
|
|
// Added in classVersion = 2
|
|
|
|
return out;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto operator>>(QDataStream &in, CustomSARecord &record) -> QDataStream &
|
|
{
|
|
quint32 actualStreamHeader = 0;
|
|
in >> actualStreamHeader;
|
|
|
|
if (actualStreamHeader != CustomSARecord::streamHeader)
|
|
{
|
|
QString const message = QCoreApplication::tr("CustomSARecord prefix mismatch error: actualStreamHeader = 0x%1 "
|
|
"and streamHeader = 0x%2")
|
|
.arg(actualStreamHeader, 8, 0x10, '0'_L1)
|
|
.arg(CustomSARecord::streamHeader, 8, 0x10, '0'_L1);
|
|
throw VException(message);
|
|
}
|
|
|
|
quint16 actualClassVersion = 0;
|
|
in >> actualClassVersion;
|
|
|
|
if (actualClassVersion > CustomSARecord::classVersion)
|
|
{
|
|
QString const message = QCoreApplication::tr("CustomSARecord compatibility error: actualClassVersion = %1 and "
|
|
"classVersion = %2")
|
|
.arg(actualClassVersion)
|
|
.arg(CustomSARecord::classVersion);
|
|
throw VException(message);
|
|
}
|
|
|
|
in >> record.startPoint;
|
|
in >> record.path;
|
|
in >> record.endPoint;
|
|
in >> record.reverse;
|
|
in >> record.includeType;
|
|
|
|
// if (actualClassVersion >= 2)
|
|
// {
|
|
|
|
// }
|
|
|
|
return in;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto IncrementTypeToString(IncrementType type) -> QString
|
|
{
|
|
switch (type)
|
|
{
|
|
case IncrementType::Increment:
|
|
return strTypeIncrement;
|
|
case IncrementType::Separator:
|
|
return strTypeSeparator;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return strTypeIncrement;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto StringToIncrementType(const QString &value) -> IncrementType
|
|
{
|
|
const QStringList values{strTypeIncrement, strTypeSeparator};
|
|
|
|
switch (values.indexOf(value))
|
|
{
|
|
case 0:
|
|
return IncrementType::Increment;
|
|
case 1:
|
|
return IncrementType::Separator;
|
|
default:
|
|
break;
|
|
}
|
|
return IncrementType::Increment;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto MeasurementTypeToString(MeasurementType type) -> QString
|
|
{
|
|
switch (type)
|
|
{
|
|
case MeasurementType::Measurement:
|
|
return strTypeMeasurement;
|
|
case MeasurementType::Separator:
|
|
return strTypeSeparator;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return strTypeIncrement;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto StringToMeasurementType(const QString &value) -> MeasurementType
|
|
{
|
|
const QStringList values{strTypeMeasurement, strTypeSeparator};
|
|
|
|
switch (values.indexOf(value))
|
|
{
|
|
case 0:
|
|
return MeasurementType::Measurement;
|
|
case 1:
|
|
return MeasurementType::Separator;
|
|
default:
|
|
break;
|
|
}
|
|
return MeasurementType::Measurement;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto SplitFilePaths(const QString &path) -> QStringList
|
|
{
|
|
QStringList result;
|
|
QString subPath = QDir::cleanPath(path);
|
|
QString lastFileName;
|
|
|
|
do
|
|
{
|
|
QFileInfo const fileInfo(subPath);
|
|
lastFileName = fileInfo.fileName();
|
|
if (not lastFileName.isEmpty())
|
|
{
|
|
result.prepend(lastFileName);
|
|
subPath = fileInfo.path();
|
|
}
|
|
} while (not lastFileName.isEmpty());
|
|
|
|
return result;
|
|
}
|