aw/valentina_old
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge with feature

Browse Source 
--HG--
branch : develop
This commit is contained in:
Roman Telezhynskyi 2019-04-02 15:34:14 +03:00
commit de39309f5a
34 changed files with 903 additions and 844 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ChangeLog.txt
View File

@ -12,6 +12,7 @@
- [#932] 2nd version V passmarks. - [#932] 2nd version V passmarks.
- [#936] Improve list of predefined paper size formats for layout export. Added format Tabloid. - [#936] Improve list of predefined paper size formats for layout export. Added format Tabloid.
- Extend Label language to support Czech alphabet. - Extend Label language to support Czech alphabet.
- [#916] Improve layout generation.
# Version 0.6.2 (unreleased) # Version 0.6.2 (unreleased)
- [#903] Bug in tool Cut Spline path. - [#903] Bug in tool Cut Spline path.

10
dist/OBS_debian/debian.valentina.1 vendored
View File

@ -1,6 +1,6 @@
.\" Manpage for valentina. .\" Manpage for valentina.
.\" Contact dismine@gmail.com to correct errors. .\" Contact dismine@gmail.com to correct errors.
.TH valentina 1 "27 December, 2018" "valentina man page" .TH valentina 1 "30 March, 2019" "valentina man page"
.SH NAME .SH NAME
Valentina \- Pattern making program. Valentina \- Pattern making program.
.SH SYNOPSIS .SH SYNOPSIS
@ -23,6 +23,10 @@ Displays version information.
The path to output destination folder. By default the directory at which the application was started. The path must exists and be reachable for the program. The path to output destination folder. By default the directory at which the application was started. The path must exists and be reachable for the program.
.IP "-m, --mfile <The measure file>" .IP "-m, --mfile <The measure file>"
.RB "Path to custom measure file (" "export mode" ")." .RB "Path to custom measure file (" "export mode" ")."
.IP "-n, --time <Time>"
.RB "<Time> in minutes given for the algorithm to find best layout (" "export mode" "). Time must be in range from 1 minute to 60 minutes. Default value 1 minute."
.IP "--сoefficient <Coefficient>"
.RB "Set layout efficiency coefficient (" "export mode" "). Layout efficiency coefficient is the ratio of the area occupied by the pieces to the bounding rect of all pieces. If nesting reaches required level the process stops. If value is 0 no check will be made. Сoefficient must be in range from 0 to 100. Default value 0."
.IP "-f, --format <Format number>" .IP "-f, --format <Format number>"
.RB "Number corresponding to output format (default = 0, " "export mode" "):" .RB "Number corresponding to output format (default = 0, " "export mode" "):"
.RS .RS
@ -182,8 +186,6 @@ The path to output destination folder. By default the directory at which the app
.RB "Page top margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found." .RB "Page top margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found."
.IP "-B, --bmargin <The bottom margin>" .IP "-B, --bmargin <The bottom margin>"
.RB "Page bottom margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found." .RB "Page bottom margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found."
.IP "-r, --rotate <Angle>"
.RB "Rotation in degrees (one of predefined, " "export mode" "). Default value is " "180" ". 0 is no-rotate. Valid values: 0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 18, 20, 24, 30, 36, 40, 45, 60, 72, 90, 180. Each value show how many times details will be rotated. For example 180 mean two times (360/180=2) by 180 degree."
.IP "--followGrainline" .IP "--followGrainline"
.RB "Order detail to follow grainline direction (" "export mode" "). .RB "Order detail to follow grainline direction (" "export mode" ").
.IP "-c, --crop" .IP "-c, --crop"
@ -194,8 +196,6 @@ The path to output destination folder. By default the directory at which the app
.RB "Save length of the sheet if set (" "export mode" "). The option tells the program to use as much as possible width of sheet. Quality of a layout can be worse when this option was used." .RB "Save length of the sheet if set (" "export mode" "). The option tells the program to use as much as possible width of sheet. Quality of a layout can be worse when this option was used."
.IP "-l, --layounits <The unit>" .IP "-l, --layounits <The unit>"
.RB "Layout units (as paper's one except px, " "export mode" ")." .RB "Layout units (as paper's one except px, " "export mode" ")."
.IP "-s, --shiftlen <Shift length>"
.RB "Shift layout length measured in layout units (" "export mode" "). The option show how many points along edge will be used in creating a layout."
.IP "-G, --gapwidth <The gap width>" .IP "-G, --gapwidth <The gap width>"
.RB "The layout gap width x2, measured in layout units (" "export mode" "). Set distance between details and a detail and a sheet." .RB "The layout gap width x2, measured in layout units (" "export mode" "). Set distance between details and a detail and a sheet."
.IP "-g, --groups <Grouping type>" .IP "-g, --groups <Grouping type>"

10
dist/debian/valentina.1 vendored
View File

@ -1,6 +1,6 @@
.\" Manpage for valentina. .\" Manpage for valentina.
.\" Contact dismine@gmail.com to correct errors. .\" Contact dismine@gmail.com to correct errors.
.TH valentina 1 "27 December, 2018" "valentina man page" .TH valentina 1 "30 March, 2019" "valentina man page"
.SH NAME .SH NAME
Valentina \- Pattern making program. Valentina \- Pattern making program.
.SH SYNOPSIS .SH SYNOPSIS
@ -23,6 +23,10 @@ Displays version information.
The path to output destination folder. By default the directory at which the application was started. The path must exists and be reachable for the program. The path to output destination folder. By default the directory at which the application was started. The path must exists and be reachable for the program.
.IP "-m, --mfile <The measure file>" .IP "-m, --mfile <The measure file>"
.RB "Path to custom measure file (" "export mode" ")." .RB "Path to custom measure file (" "export mode" ")."
.IP "-n, --time <Time>"
.RB "<Time> in minutes given for the algorithm to find best layout (" "export mode" "). Time must be in range from 1 minute to 60 minutes. Default value 1 minute."
.IP "--сoefficient <Coefficient>"
.RB "Set layout efficiency coefficient (" "export mode" "). Layout efficiency coefficient is the ratio of the area occupied by the pieces to the bounding rect of all pieces. If nesting reaches required level the process stops. If value is 0 no check will be made. Сoefficient must be in range from 0 to 100. Default value 0."
.IP "-f, --format <Format number>" .IP "-f, --format <Format number>"
.RB "Number corresponding to output format (default = 0, " "export mode" "):" .RB "Number corresponding to output format (default = 0, " "export mode" "):"
.RS .RS
@ -182,8 +186,6 @@ The path to output destination folder. By default the directory at which the app
.RB "Page top margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found." .RB "Page top margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found."
.IP "-B, --bmargin <The bottom margin>" .IP "-B, --bmargin <The bottom margin>"
.RB "Page bottom margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found." .RB "Page bottom margin in current units like 3.0 (" "export mode" "). If not set will be used value from default printer. Or 0 if none printers was found."
.IP "-r, --rotate <Angle>"
.RB "Rotation in degrees (one of predefined, " "export mode" "). Default value is " "180" ". 0 is no-rotate. Valid values: 0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 18, 20, 24, 30, 36, 40, 45, 60, 72, 90, 180. Each value show how many times details will be rotated. For example 180 mean two times (360/180=2) by 180 degree."
.IP "--followGrainline" .IP "--followGrainline"
.RB "Order detail to follow grainline direction (" "export mode" "). .RB "Order detail to follow grainline direction (" "export mode" ").
.IP "-c, --crop" .IP "-c, --crop"
@ -194,8 +196,6 @@ The path to output destination folder. By default the directory at which the app
.RB "Save length of the sheet if set (" "export mode" "). The option tells the program to use as much as possible width of sheet. Quality of a layout can be worse when this option was used." .RB "Save length of the sheet if set (" "export mode" "). The option tells the program to use as much as possible width of sheet. Quality of a layout can be worse when this option was used."
.IP "-l, --layounits <The unit>" .IP "-l, --layounits <The unit>"
.RB "Layout units (as paper's one except px, " "export mode" ")." .RB "Layout units (as paper's one except px, " "export mode" ")."
.IP "-s, --shiftlen <Shift length>"
.RB "Shift layout length measured in layout units (" "export mode" "). The option show how many points along edge will be used in creating a layout."
.IP "-G, --gapwidth <The gap width>" .IP "-G, --gapwidth <The gap width>"
.RB "The layout gap width x2, measured in layout units (" "export mode" "). Set distance between details and a detail and a sheet." .RB "The layout gap width x2, measured in layout units (" "export mode" "). Set distance between details and a detail and a sheet."
.IP "-g, --groups <Grouping type>" .IP "-g, --groups <Grouping type>"

130
src/app/valentina/core/vcmdexport.cpp
View File

@ -110,19 +110,6 @@ VLayoutGeneratorPtr VCommandLine::DefaultGenerator() const
} }
{
//just anonymous namespace ...don' like to have a,b,c,d everywhere defined
bool a = IsOptionSet(LONG_OPTION_SHIFTLENGTH);
bool b = IsOptionSet(LONG_OPTION_SHIFTUNITS);
if ((a || b) && !(a && b))
{
qCritical() << translate("VCommandLine", "Shift/Offset length must be used together with shift units.")
<< "\n";
const_cast<VCommandLine*>(this)->parser.showHelp(V_EX_USAGE);
}
}
{ {
//just anonymous namespace ...don' like to have a,b,c,d everywhere defined //just anonymous namespace ...don' like to have a,b,c,d everywhere defined
bool a = IsOptionSet(LONG_OPTION_GAPWIDTH); bool a = IsOptionSet(LONG_OPTION_GAPWIDTH);
@ -163,19 +150,6 @@ VLayoutGeneratorPtr VCommandLine::DefaultGenerator() const
CheckKey(LONG_OPTION_TILED_PDF_BOTTOM_MARGIN, CheckKey(LONG_OPTION_TILED_PDF_BOTTOM_MARGIN,
translate("VCommandLine", "Tiled bottom margin must be used together with page units.")); translate("VCommandLine", "Tiled bottom margin must be used together with page units."));
const int rotateDegree = OptRotation();
diag.SetRotate(rotateDegree != 0 ); // 0 disable rotation
if (rotateDegree != VSettings::GetDefLayoutRotationIncrease())//Value by default
{
if (not diag.SetIncrease(rotateDegree))
{
qCritical() << translate("VCommandLine", "Invalid rotation value. That must be one of predefined values.")
<< "\n";
const_cast<VCommandLine*>(this)->parser.showHelp(V_EX_USAGE);
}
}
// if present units MUST be set before any other to keep conversions correct // if present units MUST be set before any other to keep conversions correct
if (!diag.SelectTemplate(OptPaperSize())) if (!diag.SelectTemplate(OptPaperSize()))
{ {
@ -212,11 +186,6 @@ VLayoutGeneratorPtr VCommandLine::DefaultGenerator() const
} }
} }
if (IsOptionSet(LONG_OPTION_SHIFTLENGTH))
{
diag.SetShift(Lo2Px(OptionValue(LONG_OPTION_SHIFTLENGTH), diag));
}
if (IsOptionSet(LONG_OPTION_GAPWIDTH)) if (IsOptionSet(LONG_OPTION_GAPWIDTH))
{ {
diag.SetLayoutWidth(Lo2Px(OptionValue(LONG_OPTION_GAPWIDTH), diag)); diag.SetLayoutWidth(Lo2Px(OptionValue(LONG_OPTION_GAPWIDTH), diag));
@ -256,6 +225,8 @@ VLayoutGeneratorPtr VCommandLine::DefaultGenerator() const
diag.SetFields(margins); diag.SetFields(margins);
diag.SetFollowGrainline(IsOptionSet(LONG_OPTION_FOLLOW_GRAINLINE)); diag.SetFollowGrainline(IsOptionSet(LONG_OPTION_FOLLOW_GRAINLINE));
diag.SetNestingTime(OptNestingTime());
diag.SetEfficiencyCoefficient(OptEfficiencyCoefficient());
diag.DialogAccepted(); // filling VLayoutGenerator diag.DialogAccepted(); // filling VLayoutGenerator
@ -340,24 +311,6 @@ VAbstractLayoutDialog::PaperSizeTemplate VCommandLine::OptPaperSize() const
return FormatSize(LONG_OPTION_PAGETEMPLATE); return FormatSize(LONG_OPTION_PAGETEMPLATE);
} }
//------------------------------------------------------------------------------------------------------
int VCommandLine::OptRotation() const
{
int rotate = VSettings::GetDefLayoutRotationIncrease();
if (IsOptionSet(LONG_OPTION_ROTATE))
{
bool ok = false;
rotate = OptionValue(LONG_OPTION_ROTATE).toInt(&ok);
if (not ok)
{
rotate = VSettings::GetDefLayoutRotationIncrease();
}
}
return rotate;
}
//------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------
Cases VCommandLine::OptGroup() const Cases VCommandLine::OptGroup() const
{ {
@ -635,6 +588,25 @@ void VCommandLine::InitCommandLineOptions()
optionsUsed.insert(LONG_OPTION_MEASUREFILE, option); optionsUsed.insert(LONG_OPTION_MEASUREFILE, option);
parser.addOption(option); parser.addOption(option);
option = VCommandLineOption(QStringList({SINGLE_OPTION_NESTING_TIME, LONG_OPTION_NESTING_TIME}),
translate("VCommandLine", "<Time> in minutes given for the algorithm to find best "
"layout. Time must be in range from 1 minute to 60 "
"minutes. Default value 1 minute."),
translate("VCommandLine", "Time"));
optionsUsed.insert(LONG_OPTION_NESTING_TIME, option);
parser.addOption(option);
option = VCommandLineOption(LONG_OPTION_EFFICIENCY_COEFFICIENT,
translate("VCommandLine", "Set layout efficiency <coefficient>. Layout efficiency "
"coefficient is the ratio of the area occupied by the pieces "
"to the bounding rect of all pieces. If nesting reaches "
"required level the process stops. If value is 0 no check "
"will be made. Сoefficient must be in range from 0 to 100. "
"Default value 0."),
translate("VCommandLine", "Coefficient"));
optionsUsed.insert(LONG_OPTION_EFFICIENCY_COEFFICIENT, option);
parser.addOption(option);
option = VCommandLineOption(QStringList({SINGLE_OPTION_EXP2FORMAT, LONG_OPTION_EXP2FORMAT}), option = VCommandLineOption(QStringList({SINGLE_OPTION_EXP2FORMAT, LONG_OPTION_EXP2FORMAT}),
translate("VCommandLine", "Number corresponding to output format (default = 0, " translate("VCommandLine", "Number corresponding to output format (default = 0, "
"export mode):") + "export mode):") +
@ -773,18 +745,6 @@ void VCommandLine::InitCommandLineOptions()
parser.addOption(option); parser.addOption(option);
//================================================================================================================= //=================================================================================================================
option = VCommandLineOption(QStringList({SINGLE_OPTION_ROTATE, LONG_OPTION_ROTATE}),
translate("VCommandLine", "Rotation in degrees (one of predefined, export mode). "
"Default value is 180. 0 is no-rotate. Valid values: "
"%1. Each value show how many times details will be "
"rotated. For example 180 mean two times (360/180=2) "
"by 180 degree.")
.arg("0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 18, 20, 24, 30, 36, 40, 45, 60, 72, 90, "
"180"),
translate("VCommandLine", "Angle"));
optionsUsed.insert(LONG_OPTION_ROTATE, option);
parser.addOption(option);
option = VCommandLineOption(LONG_OPTION_FOLLOW_GRAINLINE, option = VCommandLineOption(LONG_OPTION_FOLLOW_GRAINLINE,
translate("VCommandLine", "Order detail to follow grainline direction (export mode).")); translate("VCommandLine", "Order detail to follow grainline direction (export mode)."));
optionsUsed.insert(LONG_OPTION_FOLLOW_GRAINLINE, option); optionsUsed.insert(LONG_OPTION_FOLLOW_GRAINLINE, option);
@ -817,14 +777,6 @@ void VCommandLine::InitCommandLineOptions()
optionsUsed.insert(LONG_OPTION_SHIFTUNITS, option); optionsUsed.insert(LONG_OPTION_SHIFTUNITS, option);
parser.addOption(option); parser.addOption(option);
option = VCommandLineOption(QStringList({SINGLE_OPTION_SHIFTLENGTH, LONG_OPTION_SHIFTLENGTH}),
translate("VCommandLine", "Shift/Offset layout length measured in layout units "
"(export mode). The option show how many points along "
"edge will be used in creating a layout."),
translate("VCommandLine", "Shift/Offset length"));
optionsUsed.insert(LONG_OPTION_SHIFTLENGTH, option);
parser.addOption(option);
option = VCommandLineOption(QStringList({SINGLE_OPTION_GAPWIDTH, LONG_OPTION_GAPWIDTH}), option = VCommandLineOption(QStringList({SINGLE_OPTION_GAPWIDTH, LONG_OPTION_GAPWIDTH}),
translate("VCommandLine", "The layout gap width x2, measured in layout units " translate("VCommandLine", "The layout gap width x2, measured in layout units "
"(export mode). Set distance between details and a " "(export mode). Set distance between details and a "
@ -973,4 +925,44 @@ QStringList VCommandLine::OptionValues(const QString &option) const
return parser.values(optionsUsed.value(option)); return parser.values(optionsUsed.value(option));
} }
//---------------------------------------------------------------------------------------------------------------------
int VCommandLine::OptNestingTime() const
{
int time = VSettings::GetDefNestingTime();
if (IsOptionSet(LONG_OPTION_NESTING_TIME))
{
bool ok = false;
time = OptionValue(LONG_OPTION_NESTING_TIME).toInt(&ok);
if (not ok || time < 1 || time > 60)
{
qCritical() << translate("VCommandLine", "Time must be in range from 1 minute to 60 minutes.")
<< "\n";
const_cast<VCommandLine*>(this)->parser.showHelp(V_EX_USAGE);
}
}
return time;
}
//---------------------------------------------------------------------------------------------------------------------
qreal VCommandLine::OptEfficiencyCoefficient() const
{
qreal coefficient = VSettings::GetDefEfficiencyCoefficient();
if (IsOptionSet(LONG_OPTION_EFFICIENCY_COEFFICIENT))
{
bool ok = false;
coefficient = OptionValue(LONG_OPTION_EFFICIENCY_COEFFICIENT).toDouble(&ok);
if (not ok || coefficient < 0 || coefficient > 100)
{
qCritical() << translate("VCommandLine", "Сoefficient must be in range from 0 to 100.")
<< "\n";
const_cast<VCommandLine*>(this)->parser.showHelp(V_EX_USAGE);
}
}
return coefficient;
}
#undef translate #undef translate

5
src/app/valentina/core/vcmdexport.h
View File

@ -150,8 +150,6 @@ protected:
//@brief returns VAbstractLayoutDialog::PaperSizeTemplate //@brief returns VAbstractLayoutDialog::PaperSizeTemplate
VAbstractLayoutDialog::PaperSizeTemplate OptPaperSize() const; VAbstractLayoutDialog::PaperSizeTemplate OptPaperSize() const;
//@brief returns rotation in degrees or 0 if not set
int OptRotation() const;
Cases OptGroup() const; Cases OptGroup() const;
@ -175,6 +173,9 @@ private:
bool IsOptionSet(const QString &option) const; bool IsOptionSet(const QString &option) const;
QString OptionValue(const QString &option) const; QString OptionValue(const QString &option) const;
QStringList OptionValues(const QString &option) const; QStringList OptionValues(const QString &option) const;
int OptNestingTime() const;
qreal OptEfficiencyCoefficient() const;
}; };
#endif // VCMDEXPORT_H #endif // VCMDEXPORT_H

74
src/app/valentina/dialogs/dialoglayoutprogress.cpp
View File

@ -35,23 +35,26 @@
#include <QPushButton> #include <QPushButton>
#include <QMovie> #include <QMovie>
#include <QtDebug> #include <QtDebug>
#include <QTime>
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
DialogLayoutProgress::DialogLayoutProgress(int count, QWidget *parent) DialogLayoutProgress::DialogLayoutProgress(QElapsedTimer timer, qint64 timeout, QWidget *parent)
:QDialog(parent), ui(new Ui::DialogLayoutProgress), maxCount(count), movie(nullptr), isInitialized(false) : QDialog(parent),
ui(new Ui::DialogLayoutProgress),
m_movie(new QMovie(QStringLiteral("://icon/16x16/progress.gif"))),
m_timer(timer),
m_timeout(timeout),
progressTimer(new QTimer(this))
{ {
ui->setupUi(this); ui->setupUi(this);
qApp->ValentinaSettings()->GetOsSeparator() ? setLocale(QLocale()) : setLocale(QLocale::c()); qApp->ValentinaSettings()->GetOsSeparator() ? setLocale(QLocale()) : setLocale(QLocale::c());
ui->progressBar->setMaximum(maxCount); ui->progressBar->setMaximum(static_cast<int>(timeout/1000));
ui->progressBar->setValue(0); ui->progressBar->setValue(0);
ui->labelMessage->setText(tr("Arranged workpieces: %1 from %2").arg(0).arg(count)); ui->labelProgress->setMovie(m_movie);
m_movie->start();
movie = new QMovie("://icon/16x16/progress.gif");
ui->labelProgress->setMovie (movie);
movie->start ();
QPushButton *bCancel = ui->buttonBox->button(QDialogButtonBox::Cancel); QPushButton *bCancel = ui->buttonBox->button(QDialogButtonBox::Cancel);
SCASSERT(bCancel != nullptr) SCASSERT(bCancel != nullptr)
@ -59,13 +62,30 @@ DialogLayoutProgress::DialogLayoutProgress(int count, QWidget *parent)
setModal(true); setModal(true);
this->setWindowFlags(Qt::Dialog | Qt::WindowTitleHint | Qt::CustomizeWindowHint); this->setWindowFlags(Qt::Dialog | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
connect(progressTimer, &QTimer::timeout, this, [this]()
{
const qint64 elapsed = m_timer.elapsed();
const int timeout = static_cast<int>(m_timeout - elapsed);
QTime t(0, 0);
t = t.addMSecs(timeout);
ui->labelTimeLeft->setText(tr("Time left: %1").arg(t.toString()));
ui->progressBar->setValue(static_cast<int>(elapsed/1000));
if (timeout <= 1000)
{
emit Timeout();
progressTimer->stop();
}
});
progressTimer->start(1000);
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
DialogLayoutProgress::~DialogLayoutProgress() DialogLayoutProgress::~DialogLayoutProgress()
{ {
delete m_movie;
delete ui; delete ui;
delete movie;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -74,41 +94,19 @@ void DialogLayoutProgress::Start()
show(); show();
} }
//---------------------------------------------------------------------------------------------------------------------
void DialogLayoutProgress::Arranged(int count)
{
ui->progressBar->setValue(count);
ui->labelMessage->setText(tr("Arranged workpieces: %1 from %2").arg(count).arg(maxCount));
}
//---------------------------------------------------------------------------------------------------------------------
void DialogLayoutProgress::Error(const LayoutErrors &state)
{
switch (state)
{
case LayoutErrors::NoError:
return;
case LayoutErrors::PrepareLayoutError:
qCritical() << tr("Couldn't prepare data for creation layout");
break;
case LayoutErrors::EmptyPaperError:
qCritical() << tr("One or more pattern pieces are bigger than the paper format you selected. Please, "
"select a bigger paper format.");
break;
case LayoutErrors::ProcessStoped:
default:
break;
}
done(QDialog::Rejected);
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void DialogLayoutProgress::Finished() void DialogLayoutProgress::Finished()
{ {
progressTimer->stop();
done(QDialog::Accepted); done(QDialog::Accepted);
} }
//---------------------------------------------------------------------------------------------------------------------
void DialogLayoutProgress::Efficiency(qreal value)
{
ui->labelMessage->setText(tr("Efficiency coefficient: %1%").arg(qRound(value * 10.) / 10.));
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void DialogLayoutProgress::showEvent(QShowEvent *event) void DialogLayoutProgress::showEvent(QShowEvent *event)
{ {

16
src/app/valentina/dialogs/dialoglayoutprogress.h
View File

@ -30,6 +30,8 @@
#define DIALOGLAYOUTPROGRESS_H #define DIALOGLAYOUTPROGRESS_H
#include <QDialog> #include <QDialog>
#include <QElapsedTimer>
#include <QTimer>
#include "../vlayout/vlayoutdef.h" #include "../vlayout/vlayoutdef.h"
@ -43,17 +45,17 @@ class DialogLayoutProgress : public QDialog
Q_OBJECT Q_OBJECT
public: public:
explicit DialogLayoutProgress(int count, QWidget *parent = nullptr); explicit DialogLayoutProgress(QElapsedTimer timer, qint64 timeout, QWidget *parent = nullptr);
~DialogLayoutProgress(); ~DialogLayoutProgress();
signals: signals:
void Abort(); void Abort();
void Timeout();
public slots: public slots:
void Start(); void Start();
void Arranged(int count);
void Error(const LayoutErrors &state);
void Finished(); void Finished();
void Efficiency(qreal value);
protected: protected:
virtual void showEvent(QShowEvent *event) override; virtual void showEvent(QShowEvent *event) override;
@ -61,9 +63,11 @@ protected:
private: private:
Q_DISABLE_COPY(DialogLayoutProgress) Q_DISABLE_COPY(DialogLayoutProgress)
Ui::DialogLayoutProgress *ui; Ui::DialogLayoutProgress *ui;
const int maxCount; QMovie *m_movie;
QMovie *movie; QElapsedTimer m_timer;
bool isInitialized; qint64 m_timeout;
bool isInitialized{false};
QTimer *progressTimer;
}; };
#endif // DIALOGLAYOUTPROGRESS_H #endif // DIALOGLAYOUTPROGRESS_H

20
src/app/valentina/dialogs/dialoglayoutprogress.ui
View File

@ -33,7 +33,7 @@
</sizepolicy> </sizepolicy>
</property> </property>
<property name="text"> <property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Finding best position for workpieces. Please, wait.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> <string>Nesting. Please, wait.</string>
</property> </property>
</widget> </widget>
</item> </item>
@ -48,6 +48,15 @@
<property name="value"> <property name="value">
<number>24</number> <number>24</number>
</property> </property>
<property name="textVisible">
<bool>false</bool>
</property>
<property name="textDirection">
<enum>QProgressBar::TopToBottom</enum>
</property>
<property name="format">
<string notr="true">%p%</string>
</property>
</widget> </widget>
</item> </item>
<item> <item>
@ -62,7 +71,14 @@
<item> <item>
<widget class="QLabel" name="labelMessage"> <widget class="QLabel" name="labelMessage">
<property name="text"> <property name="text">
<string notr="true">Arranged:</string> <string notr="true">Efficiency coefficient: -</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="labelTimeLeft">
<property name="text">
<string>Time left:</string>
</property> </property>
</widget> </widget>
</item> </item>

80
src/app/valentina/dialogs/dialoglayoutsettings.cpp
View File

@ -141,15 +141,27 @@ void DialogLayoutSettings::SetPaperWidth(qreal value)
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
qreal DialogLayoutSettings::GetShift() const int DialogLayoutSettings::GetNestingTime() const
{ {
return UnitConvertor(ui->doubleSpinBoxShift->value(), oldLayoutUnit, Unit::Px); return ui->spinBoxNestingTime->value();
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void DialogLayoutSettings::SetShift(qreal value) void DialogLayoutSettings::SetNestingTime(int value)
{ {
ui->doubleSpinBoxShift->setValue(UnitConvertor(value, Unit::Px, LayoutUnit())); ui->spinBoxNestingTime->setValue(value);
}
//---------------------------------------------------------------------------------------------------------------------
qreal DialogLayoutSettings::GetEfficiencyCoefficient() const
{
return ui->doubleSpinBoxEfficiency->value();
}
//---------------------------------------------------------------------------------------------------------------------
void DialogLayoutSettings::SetEfficiencyCoefficient(qreal ration)
{
ui->doubleSpinBoxEfficiency->setValue(ration);
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -220,18 +232,6 @@ void DialogLayoutSettings::SetGroup(const Cases &value)
} }
} }
//---------------------------------------------------------------------------------------------------------------------
bool DialogLayoutSettings::GetRotate() const
{
return ui->groupBoxRotate->isChecked();
}
//---------------------------------------------------------------------------------------------------------------------
void DialogLayoutSettings::SetRotate(bool state)
{
ui->groupBoxRotate->setChecked(state);
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool DialogLayoutSettings::GetFollowGrainline() const bool DialogLayoutSettings::GetFollowGrainline() const
{ {
@ -244,28 +244,6 @@ void DialogLayoutSettings::SetFollowGrainline(bool state)
ui->checkBoxFollowGrainline->setChecked(state); ui->checkBoxFollowGrainline->setChecked(state);
} }
//---------------------------------------------------------------------------------------------------------------------
int DialogLayoutSettings::GetIncrease() const
{
return ui->comboBoxIncrease->currentText().toInt();
}
//---------------------------------------------------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
bool DialogLayoutSettings::SetIncrease(int increase)
{
int index = ui->comboBoxIncrease->findText(QString::number(increase));
bool failed = (index == -1);
if (failed)
{
const QString def = QString::number(VSettings::GetDefLayoutRotationIncrease());// Value by default
index = ui->comboBoxIncrease->findText(def);
}
ui->comboBoxIncrease->setCurrentIndex(index);
return failed;
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool DialogLayoutSettings::GetAutoCrop() const bool DialogLayoutSettings::GetAutoCrop() const
{ {
@ -512,20 +490,16 @@ void DialogLayoutSettings::ConvertLayoutSize()
{ {
const Unit unit = LayoutUnit(); const Unit unit = LayoutUnit();
const qreal layoutWidth = ui->doubleSpinBoxLayoutWidth->value(); const qreal layoutWidth = ui->doubleSpinBoxLayoutWidth->value();
const qreal shift = ui->doubleSpinBoxShift->value();
ui->doubleSpinBoxLayoutWidth->setMaximum(FromPixel(QIMAGE_MAX, unit)); ui->doubleSpinBoxLayoutWidth->setMaximum(FromPixel(QIMAGE_MAX, unit));
ui->doubleSpinBoxShift->setMaximum(FromPixel(QIMAGE_MAX, unit));
const qreal newLayoutWidth = UnitConvertor(layoutWidth, oldLayoutUnit, unit); const qreal newLayoutWidth = UnitConvertor(layoutWidth, oldLayoutUnit, unit);
const qreal newShift = UnitConvertor(shift, oldLayoutUnit, unit);
oldLayoutUnit = unit; oldLayoutUnit = unit;
CorrectLayoutDecimals(); CorrectLayoutDecimals();
MinimumLayoutSize(); MinimumLayoutSize();
ui->doubleSpinBoxLayoutWidth->setValue(newLayoutWidth); ui->doubleSpinBoxLayoutWidth->setValue(newLayoutWidth);
ui->doubleSpinBoxShift->setValue(newShift);
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -583,10 +557,9 @@ void DialogLayoutSettings::DialogAccepted()
generator->SetCaseType(GetGroup()); generator->SetCaseType(GetGroup());
generator->SetPaperHeight(GetPaperHeight()); generator->SetPaperHeight(GetPaperHeight());
generator->SetPaperWidth(GetPaperWidth()); generator->SetPaperWidth(GetPaperWidth());
generator->SetShift(static_cast<quint32>(qFloor(GetShift()))); generator->SetNestingTime(GetNestingTime());
generator->SetRotate(GetRotate()); generator->SetEfficiencyCoefficient(GetEfficiencyCoefficient());
generator->SetFollowGrainline(GetFollowGrainline()); generator->SetFollowGrainline(GetFollowGrainline());
generator->SetRotationIncrease(GetIncrease());
generator->SetAutoCrop(GetAutoCrop()); generator->SetAutoCrop(GetAutoCrop());
generator->SetSaveLength(IsSaveLength()); generator->SetSaveLength(IsSaveLength());
generator->SetUnitePages(IsUnitePages()); generator->SetUnitePages(IsUnitePages());
@ -674,14 +647,13 @@ void DialogLayoutSettings::RestoreDefaults()
ui->comboBoxPrinter->blockSignals(false); ui->comboBoxPrinter->blockSignals(false);
SetLayoutWidth(VSettings::GetDefLayoutWidth()); SetLayoutWidth(VSettings::GetDefLayoutWidth());
SetShift(VSettings::GetDefLayoutShift());
SetGroup(VSettings::GetDefLayoutGroup()); SetGroup(VSettings::GetDefLayoutGroup());
SetRotate(VSettings::GetDefLayoutRotate());
SetFollowGrainline(VSettings::GetDefLayoutFollowGrainline()); SetFollowGrainline(VSettings::GetDefLayoutFollowGrainline());
SetIncrease(VSettings::GetDefLayoutRotationIncrease());
SetFields(GetDefPrinterFields()); SetFields(GetDefPrinterFields());
SetIgnoreAllFields(VSettings::GetDefIgnoreAllFields()); SetIgnoreAllFields(VSettings::GetDefIgnoreAllFields());
SetMultiplier(VSettings::GetDefMultiplier()); SetMultiplier(VSettings::GetDefMultiplier());
SetNestingTime(VSettings::GetDefNestingTime());
SetEfficiencyCoefficient(VSettings::GetDefEfficiencyCoefficient());
CorrectMaxFileds(); CorrectMaxFileds();
IgnoreAllFields(ui->checkBoxIgnoreFileds->isChecked()); IgnoreAllFields(ui->checkBoxIgnoreFileds->isChecked());
@ -990,11 +962,9 @@ void DialogLayoutSettings::CorrectLayoutDecimals()
case Unit::Mm: case Unit::Mm:
case Unit::Px: case Unit::Px:
ui->doubleSpinBoxLayoutWidth->setDecimals(2); ui->doubleSpinBoxLayoutWidth->setDecimals(2);
ui->doubleSpinBoxShift->setDecimals(2);
break; break;
case Unit::Inch: case Unit::Inch:
ui->doubleSpinBoxLayoutWidth->setDecimals(5); ui->doubleSpinBoxLayoutWidth->setDecimals(5);
ui->doubleSpinBoxShift->setDecimals(5);
break; break;
default: default:
break; break;
@ -1021,15 +991,14 @@ void DialogLayoutSettings::ReadSettings()
{ {
const VSettings *settings = qApp->ValentinaSettings(); const VSettings *settings = qApp->ValentinaSettings();
SetLayoutWidth(settings->GetLayoutWidth()); SetLayoutWidth(settings->GetLayoutWidth());
SetShift(settings->GetLayoutShift()); SetNestingTime(settings->GetNestingTime());
SetEfficiencyCoefficient(settings->GetEfficiencyCoefficient());
const qreal width = UnitConvertor(settings->GetLayoutPaperWidth(), Unit::Px, LayoutUnit()); const qreal width = UnitConvertor(settings->GetLayoutPaperWidth(), Unit::Px, LayoutUnit());
const qreal height = UnitConvertor(settings->GetLayoutPaperHeight(), Unit::Px, LayoutUnit()); const qreal height = UnitConvertor(settings->GetLayoutPaperHeight(), Unit::Px, LayoutUnit());
SheetSize(QSizeF(width, height)); SheetSize(QSizeF(width, height));
SetGroup(settings->GetLayoutGroup()); SetGroup(settings->GetLayoutGroup());
SetFollowGrainline(settings->GetLayoutFollowGrainline()); SetFollowGrainline(settings->GetLayoutFollowGrainline());
SetRotate(settings->GetLayoutRotate());
SetIncrease(settings->GetLayoutRotationIncrease());
SetAutoCrop(settings->GetLayoutAutoCrop()); SetAutoCrop(settings->GetLayoutAutoCrop());
SetSaveLength(settings->GetLayoutSaveLength()); SetSaveLength(settings->GetLayoutSaveLength());
SetUnitePages(settings->GetLayoutUnitePages()); SetUnitePages(settings->GetLayoutUnitePages());
@ -1053,10 +1022,7 @@ void DialogLayoutSettings::WriteSettings() const
settings->SetLayoutGroup(GetGroup()); settings->SetLayoutGroup(GetGroup());
settings->SetLayoutPaperHeight(GetPaperHeight()); settings->SetLayoutPaperHeight(GetPaperHeight());
settings->SetLayoutPaperWidth(GetPaperWidth()); settings->SetLayoutPaperWidth(GetPaperWidth());
settings->SetLayoutShift(GetShift());
settings->SetLayoutRotate(GetRotate());
settings->SetLayoutFollowGrainline(GetFollowGrainline()); settings->SetLayoutFollowGrainline(GetFollowGrainline());
settings->SetLayoutRotationIncrease(GetIncrease());
settings->SetLayoutAutoCrop(GetAutoCrop()); settings->SetLayoutAutoCrop(GetAutoCrop());
settings->SetLayoutSaveLength(IsSaveLength()); settings->SetLayoutSaveLength(IsSaveLength());
settings->SetLayoutUnitePages(IsUnitePages()); settings->SetLayoutUnitePages(IsUnitePages());
@ -1065,6 +1031,8 @@ void DialogLayoutSettings::WriteSettings() const
settings->SetStripOptimization(IsStripOptimization()); settings->SetStripOptimization(IsStripOptimization());
settings->SetMultiplier(GetMultiplier()); settings->SetMultiplier(GetMultiplier());
settings->SetTextAsPaths(IsTextAsPaths()); settings->SetTextAsPaths(IsTextAsPaths());
settings->SetNestingTime(GetNestingTime());
settings->SetEfficiencyCoefficient(GetEfficiencyCoefficient());
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------

13
src/app/valentina/dialogs/dialoglayoutsettings.h
View File

@ -61,8 +61,11 @@ public:
qreal GetPaperWidth() const; qreal GetPaperWidth() const;
void SetPaperWidth(qreal value); void SetPaperWidth(qreal value);
qreal GetShift() const; int GetNestingTime() const;
void SetShift(qreal value); void SetNestingTime(int value);
qreal GetEfficiencyCoefficient() const;
void SetEfficiencyCoefficient(qreal ration);
qreal GetLayoutWidth() const; qreal GetLayoutWidth() const;
void SetLayoutWidth(qreal value); void SetLayoutWidth(qreal value);
@ -73,15 +76,9 @@ public:
Cases GetGroup() const; Cases GetGroup() const;
void SetGroup(const Cases &value); void SetGroup(const Cases &value);
bool GetRotate() const;
void SetRotate(bool state);
bool GetFollowGrainline() const; bool GetFollowGrainline() const;
void SetFollowGrainline(bool state); void SetFollowGrainline(bool state);
int GetIncrease() const;
bool SetIncrease(int increase);
bool GetAutoCrop() const; bool GetAutoCrop() const;
void SetAutoCrop(bool autoCrop); void SetAutoCrop(bool autoCrop);

238
src/app/valentina/dialogs/dialoglayoutsettings.ui
View File

@ -361,6 +361,39 @@
<layout class="QVBoxLayout" name="verticalLayout_4"> <layout class="QVBoxLayout" name="verticalLayout_4">
<item> <item>
<layout class="QGridLayout" name="gridLayout_2"> <layout class="QGridLayout" name="gridLayout_2">
<item row="1" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Time:</string>
</property>
</widget>
</item>
<item row="0" column="3">
<widget class="QComboBox" name="comboBoxLayoutUnit"/>
</item>
<item row="0" column="0">
<widget class="QLabel" name="labelLayoutWidth">
<property name="text">
<string>Gap width:</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QSpinBox" name="spinBoxNestingTime">
<property name="toolTip">
<string>Time given for the algorithm to find best layout.</string>
</property>
<property name="suffix">
<string> min</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>60</number>
</property>
</widget>
</item>
<item row="0" column="1"> <item row="0" column="1">
<widget class="QDoubleSpinBox" name="doubleSpinBoxLayoutWidth"> <widget class="QDoubleSpinBox" name="doubleSpinBoxLayoutWidth">
<property name="minimumSize"> <property name="minimumSize">
@ -369,6 +402,9 @@
<height>0</height> <height>0</height>
</size> </size>
</property> </property>
<property name="suffix">
<string notr="true"> ×2</string>
</property>
<property name="minimum"> <property name="minimum">
<double>0.000000000000000</double> <double>0.000000000000000</double>
</property> </property>
@ -380,43 +416,26 @@
</property> </property>
</widget> </widget>
</item> </item>
<item row="0" column="0"> <item row="2" column="0">
<widget class="QLabel" name="labelLayoutWidth"> <widget class="QLabel" name="label_3">
<property name="text"> <property name="text">
<string>Gap width:</string> <string>Efficiency:</string>
</property> </property>
</widget> </widget>
</item> </item>
<item row="1" column="0"> <item row="2" column="1">
<widget class="QLabel" name="labelShiftLength"> <widget class="QDoubleSpinBox" name="doubleSpinBoxEfficiency">
<property name="text"> <property name="toolTip">
<string>Shift/Offset length:</string> <string>Set layout efficiency coefficient. Layout efficiency coefficientt is the ratio of the area occupied by the pieces to the bounding rect of all pieces. If nesting reaches required level the process stops. If value is 0 no check will be made. </string>
</property> </property>
</widget> <property name="suffix">
</item> <string>%</string>
<item row="1" column="1">
<widget class="QDoubleSpinBox" name="doubleSpinBoxShift">
<property name="minimumSize">
<size>
<width>94</width>
<height>0</height>
</size>
</property> </property>
<property name="maximum"> <property name="decimals">
<double>99999.990000000005239</double> <number>1</number>
</property> </property>
<property name="value"> <property name="singleStep">
<double>0.000000000000000</double> <double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="1" column="2">
<widget class="QComboBox" name="comboBoxLayoutUnit"/>
</item>
<item row="0" column="2">
<widget class="QLabel" name="label_4">
<property name="text">
<string notr="true">×2</string>
</property> </property>
</widget> </widget>
</item> </item>
@ -443,165 +462,6 @@
</property> </property>
</widget> </widget>
</item> </item>
<item>
<widget class="Line" name="line_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBoxRotate">
<property name="title">
<string>Rotate workpiece</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
<property name="checked">
<bool>false</bool>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label_2">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Rotate by</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="comboBoxIncrease">
<property name="currentIndex">
<number>21</number>
</property>
<item>
<property name="text">
<string notr="true">1</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">2</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">3</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">4</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">5</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">6</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">8</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">9</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">10</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">12</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">15</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">18</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">20</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">24</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">30</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">36</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">40</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">45</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">60</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">72</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">90</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">180</string>
</property>
</item>
</widget>
</item>
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string>degree</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item> <item>
<widget class="Line" name="line_2"> <widget class="Line" name="line_2">
<property name="orientation"> <property name="orientation">

2
src/app/valentina/mainwindow.cpp
View File

@ -5283,7 +5283,7 @@ bool MainWindow::DoExport(const VCommandLinePtr &expParams)
auto settings = expParams->DefaultGenerator(); auto settings = expParams->DefaultGenerator();
settings->SetTextAsPaths(expParams->IsTextAsPaths()); settings->SetTextAsPaths(expParams->IsTextAsPaths());
if (LayoutSettings(*settings.get())) if (GenerateLayout(*settings.get()))
{ {
try try
{ {

208
src/app/valentina/mainwindowsnogui.cpp
View File

@ -194,7 +194,7 @@ void MainWindowsNoGUI::ToolLayoutSettings(bool checked)
return; return;
} }
layoutPrinterName = layout.SelectedPrinter(); layoutPrinterName = layout.SelectedPrinter();
LayoutSettings(lGenerator); GenerateLayout(lGenerator);
tButton->setChecked(false); tButton->setChecked(false);
} }
else else
@ -204,77 +204,182 @@ void MainWindowsNoGUI::ToolLayoutSettings(bool checked)
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool MainWindowsNoGUI::LayoutSettings(VLayoutGenerator& lGenerator) bool MainWindowsNoGUI::GenerateLayout(VLayoutGenerator& lGenerator)
{ {
lGenerator.SetDetails(listDetails); lGenerator.SetDetails(listDetails);
DialogLayoutProgress progress(listDetails.count(), this);
QElapsedTimer timer;
timer.start();
#if defined(Q_OS_WIN32) && QT_VERSION >= QT_VERSION_CHECK(5, 7, 0)
QTimer *progressTimer = nullptr;
#endif
QScopedPointer<DialogLayoutProgress> progress(new DialogLayoutProgress(timer, lGenerator.GetNestingTime()*60000,
this));
if (VApplication::IsGUIMode()) if (VApplication::IsGUIMode())
{ {
#if defined(Q_OS_WIN32) && QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) #if defined(Q_OS_WIN32) && QT_VERSION >= QT_VERSION_CHECK(5, 7, 0)
m_taskbarProgress->setVisible(true); m_taskbarProgress->setVisible(true);
m_taskbarProgress->setValue(0); m_taskbarProgress->setValue(0);
m_taskbarProgress->setMaximum(listDetails.count()); m_taskbarProgress->setMaximum(lGenerator.GetNestingTime());
connect(&lGenerator, &VLayoutGenerator::Arranged, m_taskbarProgress, &QWinTaskbarProgress::setValue); progressTimer = new QTimer(this);
connect(progressTimer, &QTimer::timeout, this, [timer, &lGenerator]()
{
m_taskbarProgress->setValue(static_cast<int>(timer.elapsed()/60000));
});
progressTimer->start(1000);
#endif #endif
connect(&lGenerator, &VLayoutGenerator::Start, &progress, &DialogLayoutProgress::Start); connect(progress.data(), &DialogLayoutProgress::Abort, &lGenerator, &VLayoutGenerator::Abort);
connect(&lGenerator, &VLayoutGenerator::Arranged, &progress, &DialogLayoutProgress::Arranged); connect(progress.data(), &DialogLayoutProgress::Timeout, &lGenerator, &VLayoutGenerator::Timeout);
connect(&lGenerator, &VLayoutGenerator::Error, &progress, &DialogLayoutProgress::Error);
connect(&lGenerator, &VLayoutGenerator::Finished, &progress, &DialogLayoutProgress::Finished);
connect(&progress, &DialogLayoutProgress::Abort, &lGenerator, &VLayoutGenerator::Abort);
} }
else
progress->Start();
LayoutErrors nestingState = LayoutErrors::NoError;
auto IsTimeout = [&progress, &lGenerator, timer, &nestingState]()
{ {
connect(&lGenerator, &VLayoutGenerator::Error, this, &MainWindowsNoGUI::ErrorConsoleMode); if (timer.hasExpired(lGenerator.GetNestingTime() * 60000))
{
if (nestingState != LayoutErrors::EmptyPaperError)
{
nestingState = LayoutErrors::Timeout;
}
progress->Finished();
return true;
}
return false;
};
bool rotationUsed = false;
int rotatate = 1;
lGenerator.SetShift(-1); // Trigger first shift calulation
lGenerator.SetRotate(false);
int papersCount = INT_MAX;
qreal efficiency = 0;
QCoreApplication::processEvents();
forever
{
if (IsTimeout())
{
break;
}
lGenerator.Generate(timer, lGenerator.GetNestingTime()*60000);
if (IsTimeout())
{
break;
}
switch (lGenerator.State())
{
case LayoutErrors::NoError:
if (lGenerator.PapersCount() <= papersCount)
{
const qreal layoutEfficiency = lGenerator.LayoutEfficiency();
if (efficiency < layoutEfficiency)
{
efficiency = layoutEfficiency;
progress->Efficiency(efficiency);
CleanLayout();
papers = lGenerator.GetPapersItems();// Blank sheets
details = lGenerator.GetAllDetailsItems();// All details items
detailsOnLayout = lGenerator.GetAllDetails();// All details items
shadows = CreateShadows(papers);
scenes = CreateScenes(papers, shadows, details);
//Uncomment to debug, shows global contour
// gcontours = lGenerator.GetGlobalContours(); // uncomment for debugging
// InsertGlobalContours(scenes, gcontours); // uncomment for debugging
PrepareSceneList();
ignorePrinterFields = not lGenerator.IsUsePrinterFields();
margins = lGenerator.GetPrinterFields();
paperSize = QSizeF(lGenerator.GetPaperWidth(), lGenerator.GetPaperHeight());
isAutoCrop = lGenerator.GetAutoCrop();
isUnitePages = lGenerator.IsUnitePages();
isLayoutStale = false;
}
}
lGenerator.SetShift(lGenerator.GetShift()/2.0);
break;
case LayoutErrors::EmptyPaperError:
if (lGenerator.IsRotationNeeded())
{
if (not rotationUsed)
{
lGenerator.SetRotate(true);
lGenerator.SetRotationNumber(++rotatate);
rotationUsed = true;
}
else
{
lGenerator.SetShift(lGenerator.GetShift()/2.0);
rotationUsed = false;
}
}
else
{
lGenerator.SetShift(lGenerator.GetShift()/2.0);
}
break;
case LayoutErrors::Timeout:
case LayoutErrors::PrepareLayoutError:
case LayoutErrors::ProcessStoped:
default:
break;
}
nestingState = lGenerator.State();
if (nestingState == LayoutErrors::PrepareLayoutError || nestingState == LayoutErrors::ProcessStoped
|| (nestingState == LayoutErrors::NoError && not qFuzzyIsNull(lGenerator.GetEfficiencyCoefficient())
&& efficiency >= lGenerator.GetEfficiencyCoefficient()))
{
break;
}
if (IsTimeout())
{
break;
}
} }
lGenerator.Generate();
progress->Finished();
#if defined(Q_OS_WIN32) && QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) #if defined(Q_OS_WIN32) && QT_VERSION >= QT_VERSION_CHECK(5, 7, 0)
if (VApplication::IsGUIMode()) if (VApplication::IsGUIMode())
{ {
progressTimer->stop();
m_taskbarProgress->setVisible(false); m_taskbarProgress->setVisible(false);
} }
#endif #endif
switch (lGenerator.State()) if (VApplication::IsGUIMode())
{ {
case LayoutErrors::NoError: QApplication::alert(this);
CleanLayout(); }
papers = lGenerator.GetPapersItems();// Blank sheets
details = lGenerator.GetAllDetailsItems();// All details items if (not papers.isEmpty() && nestingState != LayoutErrors::ProcessStoped)
detailsOnLayout = lGenerator.GetAllDetails();// All details items {
shadows = CreateShadows(papers); return true;
scenes = CreateScenes(papers, shadows, details); }
//Uncomment to debug, shows global contour else
// gcontours = lGenerator.GetGlobalContours(); // uncomment for debugging {
// InsertGlobalContours(scenes, gcontours); // uncomment for debugging ShowLayoutError(nestingState);
PrepareSceneList(); if (not VApplication::IsGUIMode())
ignorePrinterFields = not lGenerator.IsUsePrinterFields(); {
margins = lGenerator.GetPrinterFields(); qApp->exit(V_EX_DATAERR);
paperSize = QSizeF(lGenerator.GetPaperWidth(), lGenerator.GetPaperHeight()); }
isAutoCrop = lGenerator.GetAutoCrop(); return false;
isUnitePages = lGenerator.IsUnitePages();
isLayoutStale = false;
if (VApplication::IsGUIMode())
{
QApplication::alert(this);
}
break;
case LayoutErrors::ProcessStoped:
case LayoutErrors::PrepareLayoutError:
case LayoutErrors::EmptyPaperError:
if (VApplication::IsGUIMode())
{
QApplication::alert(this);
}
return false;
default:
break;
} }
return true;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void MainWindowsNoGUI::ErrorConsoleMode(const LayoutErrors &state) void MainWindowsNoGUI::ShowLayoutError(const LayoutErrors &state)
{ {
switch (state) switch (state)
{ {
@ -287,12 +392,13 @@ void MainWindowsNoGUI::ErrorConsoleMode(const LayoutErrors &state)
qCritical() << tr("One or more pattern pieces are bigger than the paper format you selected. Please, " qCritical() << tr("One or more pattern pieces are bigger than the paper format you selected. Please, "
"select a bigger paper format."); "select a bigger paper format.");
break; break;
case LayoutErrors::Timeout:
qCritical() << tr("Timeout.");
break;
case LayoutErrors::ProcessStoped: case LayoutErrors::ProcessStoped:
default: default:
break; break;
} }
qApp->exit(V_EX_DATAERR);
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------

5
src/app/valentina/mainwindowsnogui.h
View File

@ -133,7 +133,7 @@ protected:
virtual void CleanLayout()=0; virtual void CleanLayout()=0;
virtual void PrepareSceneList()=0; virtual void PrepareSceneList()=0;
QIcon ScenePreview(int i) const; QIcon ScenePreview(int i) const;
bool LayoutSettings(VLayoutGenerator& lGenerator); bool GenerateLayout(VLayoutGenerator& lGenerator);
int ContinueIfLayoutStale(); int ContinueIfLayoutStale();
QString FileName() const; QString FileName() const;
void SetSizeHeightForIndividualM() const; void SetSizeHeightForIndividualM() const;
@ -146,7 +146,6 @@ protected:
void CheckRequiredMeasurements(const VMeasurements *m) const; void CheckRequiredMeasurements(const VMeasurements *m) const;
private slots: private slots:
void PrintPages (QPrinter *printer); void PrintPages (QPrinter *printer);
void ErrorConsoleMode(const LayoutErrors &state);
private: private:
Q_DISABLE_COPY(MainWindowsNoGUI) Q_DISABLE_COPY(MainWindowsNoGUI)
@ -212,6 +211,8 @@ private:
bool ignorePrinterFields, const QMarginsF &margins); bool ignorePrinterFields, const QMarginsF &margins);
void ExportDetailsAsFlatLayout(const QVector<VLayoutPiece> &listDetails); void ExportDetailsAsFlatLayout(const QVector<VLayoutPiece> &listDetails);
void ShowLayoutError(const LayoutErrors &state);
}; };
#endif // MAINWINDOWSNOGUI_H #endif // MAINWINDOWSNOGUI_H

67
src/libs/vlayout/vbank.cpp
View File

@ -176,7 +176,29 @@ void VBank::NotArranged(int i)
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VBank::Prepare() bool VBank::PrepareUnsorted()
{
for (int i=0; i < details.size(); ++i)
{
const qint64 square = details.at(i).Square();
if (square <= 0)
{
qCCritical(lBank, "Preparing data for layout error: Detail '%s' square <= 0",
qUtf8Printable(details.at(i).GetName()));
prepare = false;
return prepare;
}
unsorted.insert(i, square);
}
PrepareGroup();
prepare = true;
return prepare;
}
//---------------------------------------------------------------------------------------------------------------------
bool VBank::PrepareDetails()
{ {
if (layoutWidth <= 0) if (layoutWidth <= 0)
{ {
@ -193,10 +215,12 @@ bool VBank::Prepare()
} }
diagonal = 0; diagonal = 0;
for (int i=0; i < details.size(); ++i) for (int i=0; i < details.size(); ++i)
{ {
details[i].SetLayoutWidth(layoutWidth); details[i].SetLayoutWidth(layoutWidth);
details[i].SetLayoutAllowancePoints(); details[i].SetLayoutAllowancePoints();
if (not details.at(i).IsLayoutAllowanceValid()) if (not details.at(i).IsLayoutAllowanceValid())
{ {
const QString errorMsg = QObject::tr("Piece '%1' has invalid layout allowance. Please, check seam allowance" const QString errorMsg = QObject::tr("Piece '%1' has invalid layout allowance. Please, check seam allowance"
@ -209,20 +233,8 @@ bool VBank::Prepare()
{ {
diagonal = d; diagonal = d;
} }
const qint64 square = details.at(i).Square();
if (square <= 0)
{
qCCritical(lBank, "Preparing data for layout error: Detail '%s' square <= 0",
qUtf8Printable(details.at(i).GetName()));
prepare = false;
return prepare;
}
unsorted.insert(i, square);
} }
PrepareGroup();
prepare = true; prepare = true;
return prepare; return prepare;
} }
@ -436,6 +448,35 @@ void VBank::SqMaxMin(qint64 &sMax, qint64 &sMin) const
} }
//---------------------------------------------------------------------------------------------------------------------
qreal VBank::DetailsBiggestEdge() const
{
qreal edge = 0;
for(auto &piece : details)
{
const qreal pieceEdge = piece.BiggestEdge();
if (pieceEdge > edge)
{
edge = pieceEdge;
}
}
return edge;
}
//---------------------------------------------------------------------------------------------------------------------
bool VBank::IsRotationNeeded() const
{
for(auto &piece : details)
{
if (not piece.IsGrainlineEnabled())
{
return true;
}
}
return false;
}
#if defined (Q_OS_WIN) && defined (Q_CC_MSVC) #if defined (Q_OS_WIN) && defined (Q_CC_MSVC)
#pragma pop_macro("small") #pragma pop_macro("small")
#endif #endif

7
src/libs/vlayout/vbank.h
View File

@ -54,6 +54,7 @@ public:
qreal GetLayoutWidth() const; qreal GetLayoutWidth() const;
void SetLayoutWidth(qreal value); void SetLayoutWidth(qreal value);
void SetDetails(const QVector<VLayoutPiece> &details); void SetDetails(const QVector<VLayoutPiece> &details);
int GetNext(); int GetNext();
VLayoutPiece GetDetail(int i) const; VLayoutPiece GetDetail(int i) const;
@ -61,7 +62,8 @@ public:
void Arranged(int i); void Arranged(int i);
void NotArranged(int i); void NotArranged(int i);
bool Prepare(); bool PrepareUnsorted();
bool PrepareDetails();
void Reset(); void Reset();
void SetCaseType(Cases caseType); void SetCaseType(Cases caseType);
@ -70,6 +72,9 @@ public:
int ArrangedCount() const; int ArrangedCount() const;
qreal GetBiggestDiagonal() const; qreal GetBiggestDiagonal() const;
qreal DetailsBiggestEdge() const;
bool IsRotationNeeded() const;
private: private:
Q_DISABLE_COPY(VBank) Q_DISABLE_COPY(VBank)

95
src/libs/vlayout/vcontour.cpp
View File

@ -96,6 +96,8 @@ void VContour::CeateEmptySheetContour()
{ {
d->globalContour = CutEmptySheetEdge(); d->globalContour = CutEmptySheetEdge();
d->globalContour.append(d->globalContour.first()); // Close path d->globalContour.append(d->globalContour.first()); // Close path
ResetAttributes();
} }
} }
@ -103,6 +105,8 @@ void VContour::CeateEmptySheetContour()
void VContour::SetContour(const QVector<QPointF> &contour) void VContour::SetContour(const QVector<QPointF> &contour)
{ {
d->globalContour = contour; d->globalContour = contour;
ResetAttributes();
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -112,15 +116,17 @@ QVector<QPointF> VContour::GetContour() const
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
quint32 VContour::GetShift() const qreal VContour::GetShift() const
{ {
return d->shift; return d->shift;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VContour::SetShift(quint32 shift) void VContour::SetShift(qreal shift)
{ {
d->shift = shift; d->shift = shift;
ResetAttributes();
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -200,17 +206,7 @@ QVector<QPointF> VContour::UniteWithContour(const VLayoutPiece &detail, int glob
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
int VContour::GlobalEdgesCount() const int VContour::GlobalEdgesCount() const
{ {
int count = 0; return d->m_emptySheetEdgesCount;
if (not d->globalContour.isEmpty())
{
count = d->globalContour.count();
}
else
{
const qreal shift = d->shift == 0 ? ToPixel(0.5, Unit::Cm) : d->shift;
count = qFloor(EmptySheetEdge().length()/shift);
}
return count;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -251,7 +247,7 @@ QLineF VContour::GlobalEdge(int i) const
QVector<QPointF> VContour::CutEdge(const QLineF &edge) const QVector<QPointF> VContour::CutEdge(const QLineF &edge) const
{ {
QVector<QPointF> points; QVector<QPointF> points;
if (d->shift == 0) if (qFuzzyIsNull(d->shift))
{ {
points.append(edge.p1()); points.append(edge.p1());
points.append(edge.p2()); points.append(edge.p2());
@ -267,6 +263,7 @@ QVector<QPointF> VContour::CutEdge(const QLineF &edge) const
} }
else else
{ {
points.reserve(n);
const qreal nShift = edge.length()/n; const qreal nShift = edge.length()/n;
for (int i = 1; i <= n+1; ++i) for (int i = 1; i <= n+1; ++i)
{ {
@ -302,30 +299,13 @@ const QPointF &VContour::at(int i) const
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
QRectF VContour::BoundingRect() const QRectF VContour::BoundingRect() const
{ {
QVector<QPointF> points = GetContour(); return d->m_boundingRect;
if (points.isEmpty())
{
return QRectF();
}
points.append(points.first());
return QPolygonF(points).boundingRect();
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
QPainterPath VContour::ContourPath() const QPainterPath VContour::ContourPath() const
{ {
QPainterPath path; return d->m_contourPath;
path.setFillRule(Qt::WindingFill);
const QVector<QPointF> points = GetContour();
path.moveTo(points.at(0));
for (qint32 i = 1; i < points.count(); ++i)
{
path.lineTo(points.at(i));
}
path.lineTo(points.at(0));
return path;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -375,6 +355,55 @@ void VContour::InsertDetail(QVector<QPointF> &contour, const VLayoutPiece &detai
while (processedEdges <= nD); while (processedEdges <= nD);
} }
//---------------------------------------------------------------------------------------------------------------------
void VContour::ResetAttributes()
{
if (not d->globalContour.isEmpty())
{
// Bounding rect
{
QVector<QPointF> points = d->globalContour;
if (points.isEmpty())
{
d->m_boundingRect = QRectF();
}
else
{
points.append(points.first());
d->m_boundingRect = QPolygonF(points).boundingRect();
}
}
{
// Countour path
QPainterPath path;
path.setFillRule(Qt::WindingFill);
const QVector<QPointF> points = d->globalContour;
path.moveTo(points.at(0));
for (qint32 i = 1; i < points.count(); ++i)
{
path.lineTo(points.at(i));
}
path.lineTo(points.at(0));
d->m_contourPath = path;
}
d->m_emptySheetEdgesCount = d->globalContour.count(); // Edges count
}
else
{
d->m_emptySheetEdgesCount = EmptySheetEdgesCount(); // Edges count
}
}
//---------------------------------------------------------------------------------------------------------------------
int VContour::EmptySheetEdgesCount() const
{
const qreal shift = qFuzzyIsNull(d->shift) ? ToPixel(0.5, Unit::Cm) : d->shift;
return qFloor(EmptySheetEdge().length()/shift);
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VContour::IsPortrait() const bool VContour::IsPortrait() const
{ {

8
src/libs/vlayout/vcontour.h
View File

@ -66,8 +66,8 @@ public:
void SetContour(const QVector<QPointF> &contour); void SetContour(const QVector<QPointF> &contour);
QVector<QPointF> GetContour() const; QVector<QPointF> GetContour() const;
quint32 GetShift() const; qreal GetShift() const;
void SetShift(quint32 shift); void SetShift(qreal shift);
int GetHeight() const; int GetHeight() const;
void SetHeight(int height); void SetHeight(int height);
@ -98,6 +98,10 @@ private:
void AppendWhole(QVector<QPointF> &contour, const VLayoutPiece &detail, int detJ) const; void AppendWhole(QVector<QPointF> &contour, const VLayoutPiece &detail, int detJ) const;
void InsertDetail(QVector<QPointF> &contour, const VLayoutPiece &detail, int detJ) const; void InsertDetail(QVector<QPointF> &contour, const VLayoutPiece &detail, int detJ) const;
void ResetAttributes();
int EmptySheetEdgesCount() const;
}; };
Q_DECLARE_TYPEINFO(VContour, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(VContour, Q_MOVABLE_TYPE);

14
src/libs/vlayout/vcontour_p.h
View File

@ -32,6 +32,8 @@
#include <QSharedData> #include <QSharedData>
#include <QPointF> #include <QPointF>
#include <QVector> #include <QVector>
#include <QRectF>
#include <QPainterPath>
#include "../vmisc/diagnostic.h" #include "../vmisc/diagnostic.h"
@ -57,7 +59,10 @@ public:
paperHeight(contour.paperHeight), paperHeight(contour.paperHeight),
paperWidth(contour.paperWidth), paperWidth(contour.paperWidth),
shift(contour.shift), shift(contour.shift),
layoutWidth(contour.layoutWidth) layoutWidth(contour.layoutWidth),
m_boundingRect(contour.m_boundingRect),
m_contourPath(contour.m_contourPath),
m_emptySheetEdgesCount(contour.m_emptySheetEdgesCount)
{} {}
~VContourData() {} ~VContourData() {}
@ -71,10 +76,15 @@ public:
/** @brief paperWidth width of paper in pixels*/ /** @brief paperWidth width of paper in pixels*/
int paperWidth{0}; int paperWidth{0};
quint32 shift{0}; qreal shift{0};
qreal layoutWidth{0}; qreal layoutWidth{0};
QRectF m_boundingRect{};
QPainterPath m_contourPath{};
int m_emptySheetEdgesCount{0};
private: private:
VContourData &operator=(const VContourData &) Q_DECL_EQ_DELETE; VContourData &operator=(const VContourData &) Q_DECL_EQ_DELETE;
}; };

3
src/libs/vlayout/vlayoutdef.h
View File

@ -40,7 +40,8 @@ enum class LayoutErrors : char
NoError, NoError,
PrepareLayoutError, PrepareLayoutError,
ProcessStoped, ProcessStoped,
EmptyPaperError EmptyPaperError,
Timeout
}; };
enum class BestFrom : char enum class BestFrom : char

167
src/libs/vlayout/vlayoutgenerator.cpp
View File

@ -28,6 +28,7 @@
#include "vlayoutgenerator.h" #include "vlayoutgenerator.h"
#include <QElapsedTimer>
#include <QGraphicsRectItem> #include <QGraphicsRectItem>
#include <QRectF> #include <QRectF>
#include <QThreadPool> #include <QThreadPool>
@ -56,7 +57,7 @@ VLayoutGenerator::VLayoutGenerator(QObject *parent)
shift(0), shift(0),
rotate(true), rotate(true),
followGrainline(false), followGrainline(false),
rotationIncrease(180), rotationNumber(2),
autoCrop(false), autoCrop(false),
saveLength(false), saveLength(false),
unitePages(false), unitePages(false),
@ -98,23 +99,25 @@ int VLayoutGenerator::DetailsCount()
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VLayoutGenerator::Generate() void VLayoutGenerator::Generate(QElapsedTimer timer, qint64 timeout)
{ {
stopGeneration.store(false); stopGeneration.store(false);
papers.clear(); papers.clear();
bank->Reset();
state = LayoutErrors::NoError; state = LayoutErrors::NoError;
#ifdef LAYOUT_DEBUG if (VFuzzyComparePossibleNulls(shift, -1))
const QString path = QDir::homePath()+QStringLiteral("/LayoutDebug");
QDir debugDir(path);
debugDir.removeRecursively();
debugDir.mkpath(path);
#endif
emit Start();
if (bank->Prepare())
{ {
if (bank->PrepareDetails())
{
SetShift(bank->DetailsBiggestEdge() + 1);
}
else
{
state = LayoutErrors::PrepareLayoutError;
return;
}
int width = PageWidth(); int width = PageWidth();
int height = PageHeight(); int height = PageHeight();
@ -133,20 +136,48 @@ void VLayoutGenerator::Generate()
IsPortrait() ? SetStrip(height) : SetStrip(width); IsPortrait() ? SetStrip(height) : SetStrip(width);
} }
}
if (timer.hasExpired(timeout))
{
state = LayoutErrors::Timeout;
return;
}
#ifdef LAYOUT_DEBUG
const QString path = QDir::homePath()+QStringLiteral("/LayoutDebug");
QDir debugDir(path);
debugDir.removeRecursively();
debugDir.mkpath(path);
#endif
if (bank->PrepareUnsorted())
{
if (timer.hasExpired(timeout))
{
state = LayoutErrors::Timeout;
return;
}
while (bank->AllDetailsCount() > 0) while (bank->AllDetailsCount() > 0)
{ {
if (stopGeneration.load()) if (stopGeneration.load())
{ {
break; return;
} }
VLayoutPaper paper(height, width, bank->GetLayoutWidth()); if (timer.hasExpired(timeout))
{
state = LayoutErrors::Timeout;
return;
}
VLayoutPaper paper(PageHeight(), PageWidth(), bank->GetLayoutWidth());
paper.SetShift(shift); paper.SetShift(shift);
paper.SetPaperIndex(static_cast<quint32>(papers.count())); paper.SetPaperIndex(static_cast<quint32>(papers.count()));
paper.SetRotate(rotate); paper.SetRotate(rotate);
paper.SetFollowGrainline(followGrainline); paper.SetFollowGrainline(followGrainline);
paper.SetRotationIncrease(rotationIncrease); paper.SetRotationNumber(rotationNumber);
paper.SetSaveLength(saveLength); paper.SetSaveLength(saveLength);
do do
{ {
@ -154,22 +185,35 @@ void VLayoutGenerator::Generate()
if (paper.ArrangeDetail(bank->GetDetail(index), stopGeneration)) if (paper.ArrangeDetail(bank->GetDetail(index), stopGeneration))
{ {
bank->Arranged(index); bank->Arranged(index);
emit Arranged(bank->ArrangedCount());
} }
else else
{ {
bank->NotArranged(index); bank->NotArranged(index);
} }
QCoreApplication::processEvents();
if (stopGeneration.load()) if (stopGeneration.load())
{ {
break; break;
} }
if (timer.hasExpired(timeout))
{
state = LayoutErrors::Timeout;
return;
}
} while(bank->LeftToArrange() > 0); } while(bank->LeftToArrange() > 0);
if (stopGeneration.load()) if (stopGeneration.load())
{ {
break; return;
}
if (timer.hasExpired(timeout))
{
state = LayoutErrors::Timeout;
return;
} }
if (paper.Count() > 0) if (paper.Count() > 0)
@ -179,7 +223,6 @@ void VLayoutGenerator::Generate()
else else
{ {
state = LayoutErrors::EmptyPaperError; state = LayoutErrors::EmptyPaperError;
emit Error(state);
return; return;
} }
} }
@ -187,7 +230,12 @@ void VLayoutGenerator::Generate()
else else
{ {
state = LayoutErrors::PrepareLayoutError; state = LayoutErrors::PrepareLayoutError;
emit Error(state); return;
}
if (timer.hasExpired(timeout))
{
state = LayoutErrors::Timeout;
return; return;
} }
@ -200,8 +248,22 @@ void VLayoutGenerator::Generate()
{ {
UnitePages(); UnitePages();
} }
}
emit Finished(); //---------------------------------------------------------------------------------------------------------------------
qreal VLayoutGenerator::LayoutEfficiency() const
{
qreal efficiency = 0;
if (not papers.isEmpty())
{
for(auto &paper : papers)
{
efficiency += paper.Efficiency();
}
efficiency /= papers.size();
}
return efficiency;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -262,6 +324,14 @@ void VLayoutGenerator::Abort()
QThreadPool::globalInstance()->clear(); QThreadPool::globalInstance()->clear();
} }
//---------------------------------------------------------------------------------------------------------------------
void VLayoutGenerator::Timeout()
{
stopGeneration.store(true);
state = LayoutErrors::Timeout;
QThreadPool::globalInstance()->clear();
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VLayoutGenerator::IsStripOptimization() const bool VLayoutGenerator::IsStripOptimization() const
{ {
@ -286,6 +356,19 @@ void VLayoutGenerator::SetTextAsPaths(bool value)
textAsPaths = value; textAsPaths = value;
} }
//---------------------------------------------------------------------------------------------------------------------
bool VLayoutGenerator::IsRotationNeeded() const
{
if (followGrainline)
{
return bank->IsRotationNeeded();
}
else
{
return true;
}
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
quint8 VLayoutGenerator::GetMultiplier() const quint8 VLayoutGenerator::GetMultiplier() const
{ {
@ -395,7 +478,7 @@ void VLayoutGenerator::GatherPages()
paper.SetPaperIndex(static_cast<quint32>(i)); paper.SetPaperIndex(static_cast<quint32>(i));
paper.SetRotate(rotate); paper.SetRotate(rotate);
paper.SetFollowGrainline(followGrainline); paper.SetFollowGrainline(followGrainline);
paper.SetRotationIncrease(rotationIncrease); paper.SetRotationNumber(rotationNumber);
paper.SetSaveLength(saveLength); paper.SetSaveLength(saveLength);
paper.SetDetails(nDetails.at(i)); paper.SetDetails(nDetails.at(i));
@ -498,7 +581,7 @@ void VLayoutGenerator::UnitePages()
paper.SetPaperIndex(static_cast<quint32>(i)); paper.SetPaperIndex(static_cast<quint32>(i));
paper.SetRotate(rotate); paper.SetRotate(rotate);
paper.SetFollowGrainline(followGrainline); paper.SetFollowGrainline(followGrainline);
paper.SetRotationIncrease(rotationIncrease); paper.SetRotationNumber(rotationNumber);
paper.SetSaveLength(saveLength); paper.SetSaveLength(saveLength);
paper.SetDetails(nDetails.at(i)); paper.SetDetails(nDetails.at(i));
@ -591,19 +674,19 @@ void VLayoutGenerator::SetAutoCrop(bool value)
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
// cppcheck-suppress unusedFunction // cppcheck-suppress unusedFunction
int VLayoutGenerator::GetRotationIncrease() const int VLayoutGenerator::GetRotationNumber() const
{ {
return rotationIncrease; return rotationNumber;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VLayoutGenerator::SetRotationIncrease(int value) void VLayoutGenerator::SetRotationNumber(int value)
{ {
rotationIncrease = value; rotationNumber = value;
if (not (rotationIncrease >= 1 && rotationIncrease <= 180 && 360 % rotationIncrease == 0)) if (rotationNumber > 360 || rotationNumber < 1)
{ {
rotationIncrease = 180; rotationNumber = 2;
} }
} }
@ -643,6 +726,30 @@ void VLayoutGenerator::SetPaperWidth(qreal value)
paperWidth = value; paperWidth = value;
} }
//---------------------------------------------------------------------------------------------------------------------
int VLayoutGenerator::GetNestingTime() const
{
return nestingTime;
}
//---------------------------------------------------------------------------------------------------------------------
void VLayoutGenerator::SetNestingTime(int value)
{
nestingTime = value;
}
//---------------------------------------------------------------------------------------------------------------------
qreal VLayoutGenerator::GetEfficiencyCoefficient() const
{
return efficiencyCoefficient;
}
//---------------------------------------------------------------------------------------------------------------------
void VLayoutGenerator::SetEfficiencyCoefficient(qreal coefficient)
{
efficiencyCoefficient = coefficient;
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VLayoutGenerator::IsUsePrinterFields() const bool VLayoutGenerator::IsUsePrinterFields() const
{ {
@ -663,13 +770,13 @@ void VLayoutGenerator::SetPrinterFields(bool usePrinterFields, const QMarginsF &
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
quint32 VLayoutGenerator::GetShift() const qreal VLayoutGenerator::GetShift() const
{ {
return shift; return shift;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VLayoutGenerator::SetShift(quint32 shift) void VLayoutGenerator::SetShift(qreal shift)
{ {
this->shift = shift; this->shift = shift;
} }

34
src/libs/vlayout/vlayoutgenerator.h
View File

@ -52,6 +52,7 @@ class QMarginsF;
class QGraphicsItem; class QGraphicsItem;
class VLayoutPaper; class VLayoutPaper;
class QElapsedTimer;
class VLayoutGenerator :public QObject class VLayoutGenerator :public QObject
{ {
@ -71,17 +72,27 @@ public:
qreal GetPaperWidth() const; qreal GetPaperWidth() const;
void SetPaperWidth(qreal value); void SetPaperWidth(qreal value);
int GetNestingTime() const;
void SetNestingTime(int value);
qreal GetEfficiencyCoefficient() const;
void SetEfficiencyCoefficient(qreal coefficient);
bool IsUsePrinterFields() const; bool IsUsePrinterFields() const;
QMarginsF GetPrinterFields() const; QMarginsF GetPrinterFields() const;
void SetPrinterFields(bool usePrinterFields, const QMarginsF &value); void SetPrinterFields(bool usePrinterFields, const QMarginsF &value);
quint32 GetShift() const; qreal GetShift() const;
void SetShift(quint32 shift); void SetShift(qreal shift);
void Generate(); void Generate(QElapsedTimer timer, qint64 timeout);
qreal LayoutEfficiency() const;
LayoutErrors State() const; LayoutErrors State() const;
int PapersCount() const {return papers.size();}
Q_REQUIRED_RESULT QList<QGraphicsItem *> GetPapersItems() const; Q_REQUIRED_RESULT QList<QGraphicsItem *> GetPapersItems() const;
Q_REQUIRED_RESULT QList<QGraphicsItem *> GetGlobalContours() const; Q_REQUIRED_RESULT QList<QGraphicsItem *> GetGlobalContours() const;
Q_REQUIRED_RESULT QList<QList<QGraphicsItem *>> GetAllDetailsItems() const; Q_REQUIRED_RESULT QList<QList<QGraphicsItem *>> GetAllDetailsItems() const;
@ -94,8 +105,8 @@ public:
bool GetFollowGrainline() const; bool GetFollowGrainline() const;
void SetFollowGrainline(bool value); void SetFollowGrainline(bool value);
int GetRotationIncrease() const; int GetRotationNumber() const;
void SetRotationIncrease(int value); void SetRotationNumber(int value);
bool GetAutoCrop() const; bool GetAutoCrop() const;
void SetAutoCrop(bool value); void SetAutoCrop(bool value);
@ -115,14 +126,11 @@ public:
bool IsTestAsPaths() const; bool IsTestAsPaths() const;
void SetTextAsPaths(bool value); void SetTextAsPaths(bool value);
signals: bool IsRotationNeeded() const;
void Start();
void Arranged(int count);
void Error(const LayoutErrors &state);
void Finished();
public slots: public slots:
void Abort(); void Abort();
void Timeout();
private: private:
Q_DISABLE_COPY(VLayoutGenerator) Q_DISABLE_COPY(VLayoutGenerator)
@ -134,10 +142,10 @@ private:
bool usePrinterFields; bool usePrinterFields;
std::atomic_bool stopGeneration; std::atomic_bool stopGeneration;
LayoutErrors state; LayoutErrors state;
quint32 shift; qreal shift;
bool rotate; bool rotate;
bool followGrainline; bool followGrainline;
int rotationIncrease; int rotationNumber;
bool autoCrop; bool autoCrop;
bool saveLength; bool saveLength;
bool unitePages; bool unitePages;
@ -145,6 +153,8 @@ private:
quint8 multiplier; quint8 multiplier;
bool stripOptimization; bool stripOptimization;
bool textAsPaths; bool textAsPaths;
int nestingTime{1};
qreal efficiencyCoefficient{0.0};
int PageHeight() const; int PageHeight() const;
int PageWidth() const; int PageWidth() const;

42
src/libs/vlayout/vlayoutpaper.cpp
View File

@ -119,13 +119,13 @@ void VLayoutPaper::SetLayoutWidth(qreal width)
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
quint32 VLayoutPaper::GetShift() const qreal VLayoutPaper::GetShift() const
{ {
return d->globalContour.GetShift(); return d->globalContour.GetShift();
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VLayoutPaper::SetShift(quint32 shift) void VLayoutPaper::SetShift(qreal shift)
{ {
d->globalContour.SetShift(shift); d->globalContour.SetShift(shift);
} }
@ -156,24 +156,22 @@ void VLayoutPaper::SetFollowGrainline(bool value)
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
int VLayoutPaper::GetRotationIncrease() const int VLayoutPaper::GetRotationNumber() const
{ {
return d->globalRotationIncrease; return d->globalRotationNumber;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VLayoutPaper::SetRotationIncrease(int value) void VLayoutPaper::SetRotationNumber(int value)
{ {
d->globalRotationIncrease = value; d->globalRotationNumber = value;
if (not (d->globalRotationIncrease >= 1 if (d->globalRotationNumber > 360 || d->globalRotationNumber < 1)
&& d->globalRotationIncrease <= 180
&& 360 % d->globalRotationIncrease == 0))
{ {
d->globalRotationIncrease = 180; d->globalRotationNumber = 2;
} }
d->localRotationIncrease = d->globalRotationIncrease; d->localRotationNumber = d->globalRotationNumber;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -211,12 +209,12 @@ bool VLayoutPaper::ArrangeDetail(const VLayoutPiece &detail, std::atomic_bool &s
if ((detail.IsForceFlipping() || detail.IsForbidFlipping()) && not d->globalRotate) if ((detail.IsForceFlipping() || detail.IsForbidFlipping()) && not d->globalRotate)
{ // Compensate forbidden flipping by rotating. 180 degree will be enough. { // Compensate forbidden flipping by rotating. 180 degree will be enough.
d->localRotate = true; d->localRotate = true;
d->localRotationIncrease = 180; d->localRotationNumber = 2;
} }
else else
{ // Return to global values if was changed { // Return to global values if was changed
d->localRotate = d->globalRotate; d->localRotate = d->globalRotate;
d->localRotationIncrease = d->globalRotationIncrease; d->localRotationNumber = d->globalRotationNumber;
} }
d->frame = 0; d->frame = 0;
@ -242,6 +240,8 @@ bool VLayoutPaper::AddToSheet(const VLayoutPiece &detail, std::atomic_bool &stop
for (int j=1; j <= d->globalContour.GlobalEdgesCount(); ++j) for (int j=1; j <= d->globalContour.GlobalEdgesCount(); ++j)
{ {
QCoreApplication::processEvents();
for (int i=1; i<= detailEdgesCount; ++i) for (int i=1; i<= detailEdgesCount; ++i)
{ {
VPositionData data; VPositionData data;
@ -250,7 +250,7 @@ bool VLayoutPaper::AddToSheet(const VLayoutPiece &detail, std::atomic_bool &stop
data.i = i; data.i = i;
data.j = j; data.j = j;
data.rotate = d->localRotate; data.rotate = d->localRotate;
data.rotationIncrease = d->localRotationIncrease; data.rotationNumber = d->localRotationNumber;
data.followGrainline = d->followGrainline; data.followGrainline = d->followGrainline;
auto *thread = new VPosition(data, &stop, d->saveLength); auto *thread = new VPosition(data, &stop, d->saveLength);
@ -426,3 +426,17 @@ QRectF VLayoutPaper::DetailsBoundingRect() const
return rec; return rec;
} }
//---------------------------------------------------------------------------------------------------------------------
qreal VLayoutPaper::Efficiency() const
{
qreal efficiency = 0;
for(auto &detail : d->details)
{
efficiency += static_cast<qreal>(detail.Square());
}
const QRectF boundingRect = DetailsBoundingRect();
return efficiency / (boundingRect.width() * boundingRect.height()) * 100.0;
}

10
src/libs/vlayout/vlayoutpaper.h
View File

@ -73,8 +73,8 @@ public:
qreal GetLayoutWidth() const; qreal GetLayoutWidth() const;
void SetLayoutWidth(qreal width); void SetLayoutWidth(qreal width);
quint32 GetShift() const; qreal GetShift() const;
void SetShift(quint32 shift); void SetShift(qreal shift);
bool GetRotate() const; bool GetRotate() const;
void SetRotate(bool value); void SetRotate(bool value);
@ -82,8 +82,8 @@ public:
bool GetFollowGrainline() const; bool GetFollowGrainline() const;
void SetFollowGrainline(bool value); void SetFollowGrainline(bool value);
int GetRotationIncrease() const; int GetRotationNumber() const;
void SetRotationIncrease(int value); void SetRotationNumber(int value);
bool IsSaveLength() const; bool IsSaveLength() const;
void SetSaveLength(bool value); void SetSaveLength(bool value);
@ -101,6 +101,8 @@ public:
QRectF DetailsBoundingRect() const; QRectF DetailsBoundingRect() const;
qreal Efficiency() const;
private: private:
QSharedDataPointer<VLayoutPaperData> d; QSharedDataPointer<VLayoutPaperData> d;

8
src/libs/vlayout/vlayoutpaper_p.h
View File

@ -60,8 +60,8 @@ public:
layoutWidth(paper.layoutWidth), layoutWidth(paper.layoutWidth),
globalRotate(paper.globalRotate), globalRotate(paper.globalRotate),
localRotate(paper.localRotate), localRotate(paper.localRotate),
globalRotationIncrease(paper.globalRotationIncrease), globalRotationNumber(paper.globalRotationNumber),
localRotationIncrease(paper.localRotationIncrease), localRotationNumber(paper.localRotationNumber),
saveLength(paper.saveLength), saveLength(paper.saveLength),
followGrainline(paper.followGrainline) followGrainline(paper.followGrainline)
{} {}
@ -79,8 +79,8 @@ public:
qreal layoutWidth{0}; qreal layoutWidth{0};
bool globalRotate{true}; bool globalRotate{true};
bool localRotate{true}; bool localRotate{true};
int globalRotationIncrease{180}; int globalRotationNumber{2};
int localRotationIncrease{180}; int localRotationNumber{2};
bool saveLength{false}; bool saveLength{false};
bool followGrainline{false}; bool followGrainline{false};

70
src/libs/vlayout/vlayoutpiece.cpp
View File

@ -314,45 +314,36 @@ VLayoutPiece VLayoutPiece::Create(const VPiece &piece, const VContainer *pattern
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
template <class T> template <class T>
QVector<T> VLayoutPiece::Map(const QVector<T> &points) const QVector<T> VLayoutPiece::Map(QVector<T> points) const
{ {
QVector<T> p; for (int i = 0; i < points.size(); ++i)
for (auto point : points)
{ {
p.append(d->matrix.map(point)); points[i] = d->matrix.map(points.at(i));
} }
if (d->mirror) if (d->mirror)
{ {
QList<T> list = p.toList(); QList<T> list = points.toList();
for (int k=0, s=list.size(), max=(s/2); k<max; k++) for (int k=0, s=list.size(), max=(s/2); k<max; k++)
{ {
list.swap(k, s-(1+k)); list.swap(k, s-(1+k));
} }
p = list.toVector(); points = list.toVector();
} }
return p; return points;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
template <> template <>
QVector<VLayoutPlaceLabel> VLayoutPiece::Map<VLayoutPlaceLabel>(const QVector<VLayoutPlaceLabel> &points) const QVector<VLayoutPlaceLabel> VLayoutPiece::Map<VLayoutPlaceLabel>(QVector<VLayoutPlaceLabel> points) const
{ {
QVector<VLayoutPlaceLabel> p; for (int i = 0; i < points.size(); ++i)
p.reserve(points.size());
for (auto &label : points)
{ {
VLayoutPlaceLabel mappedLabel; points[i].center = d->matrix.map(points.at(i).center);
mappedLabel.type = label.type; points[i].shape = Map(points.at(i).shape);
mappedLabel.center = d->matrix.map(label.center);
for (const auto &p : label.shape)
{
mappedLabel.shape.append(d->matrix.map(p));
}
p.append(mappedLabel);
} }
return p; return points;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -742,15 +733,7 @@ bool VLayoutPiece::isNull() const
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
qint64 VLayoutPiece::Square() const qint64 VLayoutPiece::Square() const
{ {
if (d->layoutAllowance.isEmpty()) //-V807 return d->m_square;
{
return 0;
}
const qreal res = SumTrapezoids(d->layoutAllowance);
const qint64 sq = qFloor(qAbs(res/2.0));
return sq;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -779,6 +762,13 @@ void VLayoutPiece::SetLayoutAllowancePoints()
{ {
d->layoutAllowance.clear(); d->layoutAllowance.clear();
} }
if (d->layoutAllowance.isEmpty()) //-V807
{
d->m_square = 0;
}
d->m_square = qFloor(qAbs(SumTrapezoids(d->layoutAllowance)/2.0));
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -945,6 +935,28 @@ bool VLayoutPiece::IsLayoutAllowanceValid() const
return VAbstractPiece::IsAllowanceValid(base, d->layoutAllowance); return VAbstractPiece::IsAllowanceValid(base, d->layoutAllowance);
} }
//---------------------------------------------------------------------------------------------------------------------
qreal VLayoutPiece::BiggestEdge() const
{
qreal edge = 0;
if (d->layoutAllowance.size() < 2)
{
return edge;
}
for (int i = 1; i < d->layoutAllowance.size() - 1; ++i)
{
const qreal length = QLineF(d->layoutAllowance.at(i-1), d->layoutAllowance.at(i)).length();
if (length > edge)
{
edge = length;
}
}
return edge;
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPointF> &labelShape, void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPointF> &labelShape,
const VTextManager &tm, bool textAsPaths) const const VTextManager &tm, bool textAsPaths) const

4
src/libs/vlayout/vlayoutpiece.h
View File

@ -144,6 +144,8 @@ public:
bool IsLayoutAllowanceValid() const; bool IsLayoutAllowanceValid() const;
qreal BiggestEdge() const;
private: private:
QSharedDataPointer<VLayoutPieceData> d; QSharedDataPointer<VLayoutPieceData> d;
@ -157,7 +159,7 @@ private:
void CreateGrainlineItem(QGraphicsItem *parent) const; void CreateGrainlineItem(QGraphicsItem *parent) const;
template <class T> template <class T>
QVector<T> Map(const QVector<T> &points) const; QVector<T> Map(QVector<T> points) const;
QLineF Edge(const QVector<QPointF> &path, int i) const; QLineF Edge(const QVector<QPointF> &path, int i) const;
int EdgeByPoint(const QVector<QPointF> &path, const QPointF &p1) const; int EdgeByPoint(const QVector<QPointF> &path, const QPointF &p1) const;

5
src/libs/vlayout/vlayoutpiece_p.h
View File

@ -87,7 +87,8 @@ public:
grainlineEnabled(detail.grainlineEnabled), grainlineEnabled(detail.grainlineEnabled),
m_tmDetail(detail.m_tmDetail), m_tmDetail(detail.m_tmDetail),
m_tmPattern(detail.m_tmPattern), m_tmPattern(detail.m_tmPattern),
m_placeLabels(detail.m_placeLabels) m_placeLabels(detail.m_placeLabels),
m_square(detail.m_square)
{} {}
~VLayoutPieceData() {} ~VLayoutPieceData() {}
@ -137,6 +138,8 @@ public:
/** @brief m_placeLabels list of place labels. */ /** @brief m_placeLabels list of place labels. */
QVector<VLayoutPlaceLabel> m_placeLabels; QVector<VLayoutPlaceLabel> m_placeLabels;
qint64 m_square{0};
private: private:
VLayoutPieceData &operator=(const VLayoutPieceData &) Q_DECL_EQ_DELETE; VLayoutPieceData &operator=(const VLayoutPieceData &) Q_DECL_EQ_DELETE;
}; };

24
src/libs/vlayout/vposition.cpp
View File

@ -147,9 +147,9 @@ VPosition::VPosition(const VPositionData &data, std::atomic_bool *stop, bool sav
stop(stop), stop(stop),
angle_between(0) angle_between(0)
{ {
if (not (m_data.rotationIncrease >= 1 && m_data.rotationIncrease <= 180 && 360 % m_data.rotationIncrease == 0)) if (m_data.rotationNumber > 360 || m_data.rotationNumber < 1)
{ {
m_data.rotationIncrease = 180; m_data.rotationNumber = 2;
} }
} }
@ -493,7 +493,7 @@ VPosition::CrossingType VPosition::Crossing(const VLayoutPiece &detail) const
const QPainterPath gPath = m_data.gContour.ContourPath(); const QPainterPath gPath = m_data.gContour.ContourPath();
CrossingType crossing = CrossingType::EdgeError; CrossingType crossing = CrossingType::EdgeError;
if (not gPath.intersects(detail.LayoutAllowancePath()) && not gPath.contains(detail.ContourPath())) if (not gPath.contains(detail.ContourPath()) && not gPath.intersects(detail.LayoutAllowancePath()))
{ {
crossing = CrossingType::NoIntersection; crossing = CrossingType::NoIntersection;
} }
@ -566,14 +566,15 @@ void VPosition::RotateEdges(VLayoutPiece &detail, const QLineF &globalEdge, int
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VPosition::Rotate(int increase) void VPosition::Rotate(int number)
{ {
int startAngle = 0; const qreal step = 360/number;
qreal startAngle = 0;
if (VFuzzyComparePossibleNulls(angle_between, 360)) if (VFuzzyComparePossibleNulls(angle_between, 360))
{ {
startAngle = increase; startAngle = step;
} }
for (int angle = startAngle; angle < 360; angle = angle+increase) for (qreal angle = startAngle; angle < 360; angle = angle+step)
{ {
if (stop->load()) if (stop->load())
{ {
@ -642,14 +643,7 @@ void VPosition::FindBestPosition()
if (m_data.rotate) if (m_data.rotate)
{ {
Rotate(m_data.rotationIncrease); Rotate(m_data.rotationNumber);
}
else
{
if (m_data.gContour.GetContour().isEmpty())
{
Rotate(m_data.rotationIncrease);
}
} }
} }
else else

4
src/libs/vlayout/vposition.h
View File

@ -47,7 +47,7 @@ struct VPositionData
int i{-1}; int i{-1};
int j{-1}; int j{-1};
bool rotate{false}; bool rotate{false};
int rotationIncrease{0}; int rotationNumber{0};
bool followGrainline{false}; bool followGrainline{false};
}; };
@ -124,7 +124,7 @@ private:
void CombineEdges(VLayoutPiece &detail, const QLineF &globalEdge, int dEdge); void CombineEdges(VLayoutPiece &detail, const QLineF &globalEdge, int dEdge);
void RotateEdges(VLayoutPiece &detail, const QLineF &globalEdge, int dEdge, qreal angle) const; void RotateEdges(VLayoutPiece &detail, const QLineF &globalEdge, int dEdge, qreal angle) const;
void Rotate(int increase); void Rotate(int number);
void FollowGrainline(); void FollowGrainline();
QLineF FabricGrainline() const; QLineF FabricGrainline() const;

103
src/libs/vmisc/commandoptions.cpp
View File

@ -54,9 +54,6 @@ const QString LONG_OPTION_TEXT2PATHS = QStringLiteral("text2paths");
const QString LONG_OPTION_EXPORTONLYDETAILS = QStringLiteral("exportOnlyDetails"); const QString LONG_OPTION_EXPORTONLYDETAILS = QStringLiteral("exportOnlyDetails");
const QString LONG_OPTION_EXPORTSUCHDETAILS = QStringLiteral("exportSuchDetails"); const QString LONG_OPTION_EXPORTSUCHDETAILS = QStringLiteral("exportSuchDetails");
const QString LONG_OPTION_ROTATE = QStringLiteral("rotate");
const QString SINGLE_OPTION_ROTATE = QStringLiteral("r");
const QString LONG_OPTION_CROP = QStringLiteral("crop"); const QString LONG_OPTION_CROP = QStringLiteral("crop");
const QString SINGLE_OPTION_CROP = QStringLiteral("c"); const QString SINGLE_OPTION_CROP = QStringLiteral("c");
@ -75,9 +72,6 @@ const QString SINGLE_OPTION_PAGEUNITS = QStringLiteral("U");
const QString LONG_OPTION_SAVELENGTH = QStringLiteral("savelen"); const QString LONG_OPTION_SAVELENGTH = QStringLiteral("savelen");
const QString SINGLE_OPTION_SAVELENGTH = QStringLiteral("S"); const QString SINGLE_OPTION_SAVELENGTH = QStringLiteral("S");
const QString LONG_OPTION_SHIFTLENGTH = QStringLiteral("shiftlen");
const QString SINGLE_OPTION_SHIFTLENGTH = QStringLiteral("s");
const QString LONG_OPTION_SHIFTUNITS = QStringLiteral("layounits"); const QString LONG_OPTION_SHIFTUNITS = QStringLiteral("layounits");
const QString SINGLE_OPTION_SHIFTUNITS = QStringLiteral("l"); const QString SINGLE_OPTION_SHIFTUNITS = QStringLiteral("l");
@ -115,6 +109,11 @@ const QString SINGLE_OPTION_TOP_MARGIN = QStringLiteral("T");
const QString LONG_OPTION_BOTTOM_MARGIN = QStringLiteral("bmargin"); const QString LONG_OPTION_BOTTOM_MARGIN = QStringLiteral("bmargin");
const QString SINGLE_OPTION_BOTTOM_MARGIN = QStringLiteral("B"); const QString SINGLE_OPTION_BOTTOM_MARGIN = QStringLiteral("B");
const QString LONG_OPTION_NESTING_TIME = QStringLiteral("time");
const QString SINGLE_OPTION_NESTING_TIME = QStringLiteral("n");
const QString LONG_OPTION_EFFICIENCY_COEFFICIENT = QStringLiteral("сoefficient");
const QString LONG_OPTION_CSVWITHHEADER = QStringLiteral("csvWithHeader"); const QString LONG_OPTION_CSVWITHHEADER = QStringLiteral("csvWithHeader");
const QString LONG_OPTION_CSVCODEC = QStringLiteral("csvCodec"); const QString LONG_OPTION_CSVCODEC = QStringLiteral("csvCodec");
const QString LONG_OPTION_CSVSEPARATOR = QStringLiteral("csvSeparator"); const QString LONG_OPTION_CSVSEPARATOR = QStringLiteral("csvSeparator");
@ -138,50 +137,50 @@ const QString LONG_OPTION_LANDSCAPE_ORIENTATION = QStringLiteral("landscapeOrien
*/ */
QStringList AllKeys() QStringList AllKeys()
{ {
QStringList list; return QStringList
list << LONG_OPTION_BASENAME << SINGLE_OPTION_BASENAME {
<< LONG_OPTION_DESTINATION << SINGLE_OPTION_DESTINATION LONG_OPTION_BASENAME, SINGLE_OPTION_BASENAME,
<< LONG_OPTION_MEASUREFILE << SINGLE_OPTION_MEASUREFILE LONG_OPTION_DESTINATION, SINGLE_OPTION_DESTINATION,
<< LONG_OPTION_PAGETEMPLATE << SINGLE_OPTION_PAGETEMPLATE LONG_OPTION_MEASUREFILE, SINGLE_OPTION_MEASUREFILE,
<< LONG_OPTION_EXP2FORMAT << SINGLE_OPTION_EXP2FORMAT LONG_OPTION_PAGETEMPLATE, SINGLE_OPTION_PAGETEMPLATE,
<< LONG_OPTION_BINARYDXF LONG_OPTION_EXP2FORMAT, SINGLE_OPTION_EXP2FORMAT,
<< LONG_OPTION_TEXT2PATHS LONG_OPTION_BINARYDXF,
<< LONG_OPTION_EXPORTONLYDETAILS LONG_OPTION_TEXT2PATHS,
<< LONG_OPTION_EXPORTSUCHDETAILS LONG_OPTION_EXPORTONLYDETAILS,
<< LONG_OPTION_ROTATE << SINGLE_OPTION_ROTATE LONG_OPTION_EXPORTSUCHDETAILS,
<< LONG_OPTION_CROP << SINGLE_OPTION_CROP LONG_OPTION_CROP, SINGLE_OPTION_CROP,
<< LONG_OPTION_UNITE << SINGLE_OPTION_UNITE LONG_OPTION_UNITE, SINGLE_OPTION_UNITE,
<< LONG_OPTION_PAGEW << SINGLE_OPTION_PAGEW LONG_OPTION_PAGEW, SINGLE_OPTION_PAGEW,
<< LONG_OPTION_PAGEH << SINGLE_OPTION_PAGEH LONG_OPTION_PAGEH, SINGLE_OPTION_PAGEH,
<< LONG_OPTION_PAGEUNITS << SINGLE_OPTION_PAGEUNITS LONG_OPTION_PAGEUNITS, SINGLE_OPTION_PAGEUNITS,
<< LONG_OPTION_SAVELENGTH << SINGLE_OPTION_SAVELENGTH LONG_OPTION_SAVELENGTH, SINGLE_OPTION_SAVELENGTH,
<< LONG_OPTION_SHIFTLENGTH << SINGLE_OPTION_SHIFTLENGTH LONG_OPTION_SHIFTUNITS, SINGLE_OPTION_SHIFTUNITS,
<< LONG_OPTION_SHIFTUNITS << SINGLE_OPTION_SHIFTUNITS LONG_OPTION_GAPWIDTH, SINGLE_OPTION_GAPWIDTH,
<< LONG_OPTION_GAPWIDTH << SINGLE_OPTION_GAPWIDTH LONG_OPTION_GROUPPING, SINGLE_OPTION_GROUPPING,
<< LONG_OPTION_GROUPPING << SINGLE_OPTION_GROUPPING LONG_OPTION_TEST, SINGLE_OPTION_TEST,
<< LONG_OPTION_TEST << SINGLE_OPTION_TEST LONG_OPTION_PENDANTIC,
<< LONG_OPTION_PENDANTIC LONG_OPTION_GRADATIONSIZE, SINGLE_OPTION_GRADATIONSIZE,
<< LONG_OPTION_GRADATIONSIZE << SINGLE_OPTION_GRADATIONSIZE LONG_OPTION_GRADATIONHEIGHT, SINGLE_OPTION_GRADATIONHEIGHT,
<< LONG_OPTION_GRADATIONHEIGHT << SINGLE_OPTION_GRADATIONHEIGHT LONG_OPTION_USER_MATERIAL,
<< LONG_OPTION_USER_MATERIAL LONG_OPTION_IGNORE_MARGINS, SINGLE_OPTION_IGNORE_MARGINS,
<< LONG_OPTION_IGNORE_MARGINS << SINGLE_OPTION_IGNORE_MARGINS LONG_OPTION_LEFT_MARGIN, SINGLE_OPTION_LEFT_MARGIN,
<< LONG_OPTION_LEFT_MARGIN << SINGLE_OPTION_LEFT_MARGIN LONG_OPTION_RIGHT_MARGIN, SINGLE_OPTION_RIGHT_MARGIN,
<< LONG_OPTION_RIGHT_MARGIN << SINGLE_OPTION_RIGHT_MARGIN LONG_OPTION_TOP_MARGIN, SINGLE_OPTION_TOP_MARGIN,
<< LONG_OPTION_TOP_MARGIN << SINGLE_OPTION_TOP_MARGIN LONG_OPTION_BOTTOM_MARGIN, SINGLE_OPTION_BOTTOM_MARGIN,
<< LONG_OPTION_BOTTOM_MARGIN << SINGLE_OPTION_BOTTOM_MARGIN LONG_OPTION_NESTING_TIME, SINGLE_OPTION_NESTING_TIME,
<< LONG_OPTION_NO_HDPI_SCALING LONG_OPTION_EFFICIENCY_COEFFICIENT,
<< LONG_OPTION_CSVWITHHEADER LONG_OPTION_NO_HDPI_SCALING,
<< LONG_OPTION_CSVCODEC LONG_OPTION_CSVWITHHEADER,
<< LONG_OPTION_CSVSEPARATOR LONG_OPTION_CSVCODEC,
<< LONG_OPTION_CSVEXPORTFM LONG_OPTION_CSVSEPARATOR,
<< LONG_OPTION_TILED_PDF_PAGE_TEMPLATE LONG_OPTION_CSVEXPORTFM,
<< LONG_OPTION_TILED_PDF_LEFT_MARGIN LONG_OPTION_TILED_PDF_PAGE_TEMPLATE,
<< LONG_OPTION_TILED_PDF_RIGHT_MARGIN LONG_OPTION_TILED_PDF_LEFT_MARGIN,
<< LONG_OPTION_TILED_PDF_TOP_MARGIN LONG_OPTION_TILED_PDF_RIGHT_MARGIN,
<< LONG_OPTION_TILED_PDF_BOTTOM_MARGIN LONG_OPTION_TILED_PDF_TOP_MARGIN,
<< LONG_OPTION_TILED_PDF_LANDSCAPE LONG_OPTION_TILED_PDF_BOTTOM_MARGIN,
<< LONG_OPTION_FOLLOW_GRAINLINE LONG_OPTION_TILED_PDF_LANDSCAPE,
<< LONG_OPTION_LANDSCAPE_ORIENTATION; LONG_OPTION_FOLLOW_GRAINLINE,
LONG_OPTION_LANDSCAPE_ORIENTATION
return list; };
} }

11
src/libs/vmisc/commandoptions.h
View File

@ -51,9 +51,6 @@ extern const QString LONG_OPTION_TEXT2PATHS;
extern const QString LONG_OPTION_EXPORTONLYDETAILS; extern const QString LONG_OPTION_EXPORTONLYDETAILS;
extern const QString LONG_OPTION_EXPORTSUCHDETAILS; extern const QString LONG_OPTION_EXPORTSUCHDETAILS;
extern const QString LONG_OPTION_ROTATE;
extern const QString SINGLE_OPTION_ROTATE;
extern const QString LONG_OPTION_CROP; extern const QString LONG_OPTION_CROP;
extern const QString SINGLE_OPTION_CROP; extern const QString SINGLE_OPTION_CROP;
@ -72,9 +69,6 @@ extern const QString SINGLE_OPTION_PAGEUNITS;
extern const QString LONG_OPTION_SAVELENGTH; extern const QString LONG_OPTION_SAVELENGTH;
extern const QString SINGLE_OPTION_SAVELENGTH; extern const QString SINGLE_OPTION_SAVELENGTH;
extern const QString LONG_OPTION_SHIFTLENGTH;
extern const QString SINGLE_OPTION_SHIFTLENGTH;
extern const QString LONG_OPTION_SHIFTUNITS; extern const QString LONG_OPTION_SHIFTUNITS;
extern const QString SINGLE_OPTION_SHIFTUNITS; extern const QString SINGLE_OPTION_SHIFTUNITS;
@ -112,6 +106,11 @@ extern const QString SINGLE_OPTION_TOP_MARGIN;
extern const QString LONG_OPTION_BOTTOM_MARGIN; extern const QString LONG_OPTION_BOTTOM_MARGIN;
extern const QString SINGLE_OPTION_BOTTOM_MARGIN; extern const QString SINGLE_OPTION_BOTTOM_MARGIN;
extern const QString LONG_OPTION_NESTING_TIME;
extern const QString SINGLE_OPTION_NESTING_TIME;
extern const QString LONG_OPTION_EFFICIENCY_COEFFICIENT;
extern const QString LONG_OPTION_CSVWITHHEADER; extern const QString LONG_OPTION_CSVWITHHEADER;
extern const QString LONG_OPTION_CSVCODEC; extern const QString LONG_OPTION_CSVCODEC;
extern const QString LONG_OPTION_CSVSEPARATOR; extern const QString LONG_OPTION_CSVSEPARATOR;

212
src/libs/vmisc/vsettings.cpp
View File

@ -1,4 +1,4 @@
/************************************************************************ /************************************************************************
** **
** @file vsettings.cpp ** @file vsettings.cpp
** @author Roman Telezhynskyi <dismine(at)gmail.com> ** @author Roman Telezhynskyi <dismine(at)gmail.com>
@ -82,10 +82,7 @@ Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutWidth, (QLatin1String("lay
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutSorting, (QLatin1String("layout/sorting"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutSorting, (QLatin1String("layout/sorting")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutPaperHeight, (QLatin1String("layout/paperHeight"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutPaperHeight, (QLatin1String("layout/paperHeight")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutPaperWidth, (QLatin1String("layout/paperWidth"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutPaperWidth, (QLatin1String("layout/paperWidth")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutShift, (QLatin1String("layout/shift")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutRotate, (QLatin1String("layout/Rotate")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutFollowGrainline, (QLatin1String("layout/followGrainline"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutFollowGrainline, (QLatin1String("layout/followGrainline")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutRotationIncrease, (QLatin1String("layout/rotationIncrease")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutAutoCrop, (QLatin1String("layout/autoCrop"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutAutoCrop, (QLatin1String("layout/autoCrop")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutSaveLength, (QLatin1String("layout/saveLength"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutSaveLength, (QLatin1String("layout/saveLength")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutUnitePages, (QLatin1String("layout/unitePages"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingLayoutUnitePages, (QLatin1String("layout/unitePages")))
@ -94,6 +91,8 @@ Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingIgnoreFields, (QLatin1String("la
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingStripOptimization, (QLatin1String("layout/stripOptimization"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingStripOptimization, (QLatin1String("layout/stripOptimization")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingMultiplier, (QLatin1String("layout/multiplier"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingMultiplier, (QLatin1String("layout/multiplier")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingTextAsPaths, (QLatin1String("layout/textAsPaths"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingTextAsPaths, (QLatin1String("layout/textAsPaths")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingNestingTime, (QLatin1String("layout/time")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingEfficiencyCoefficient, (QLatin1String("layout/efficiencyCoefficient")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingTiledPDFMargins, (QLatin1String("tiledPDF/margins"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingTiledPDFMargins, (QLatin1String("tiledPDF/margins")))
Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingTiledPDFPaperHeight, (QLatin1String("tiledPDF/paperHeight"))) Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingTiledPDFPaperHeight, (QLatin1String("tiledPDF/paperHeight")))
@ -182,17 +181,7 @@ void VSettings::SetOpenGLRender(bool value)
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
qreal VSettings::GetLayoutPaperHeight() const qreal VSettings::GetLayoutPaperHeight() const
{ {
const qreal def = UnitConvertor(1189/*A0*/, Unit::Mm, Unit::Px); return ValueOrDef<qreal>(*settingLayoutPaperHeight, UnitConvertor(1189/*A0*/, Unit::Mm, Unit::Px));
bool ok = false;
const qreal height = value(*settingLayoutPaperHeight, def).toDouble(&ok);
if (ok)
{
return height;
}
else
{
return def;
}
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -204,17 +193,7 @@ void VSettings::SetLayoutPaperHeight(qreal value)
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
qreal VSettings::GetLayoutPaperWidth() const qreal VSettings::GetLayoutPaperWidth() const
{ {
const qreal def = UnitConvertor(841/*A0*/, Unit::Mm, Unit::Px); return ValueOrDef<qreal>(*settingLayoutPaperWidth, UnitConvertor(841/*A0*/, Unit::Mm, Unit::Px));
bool ok = false;
const qreal width = value(*settingLayoutPaperWidth, def).toDouble(&ok);
if (ok)
{
return width;
}
else
{
return def;
}
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -223,48 +202,10 @@ void VSettings::SetLayoutPaperWidth(qreal value)
setValue(*settingLayoutPaperWidth, value); setValue(*settingLayoutPaperWidth, value);
} }
//---------------------------------------------------------------------------------------------------------------------
qreal VSettings::GetLayoutShift() const
{
const qreal def = GetDefLayoutShift();
bool ok = false;
const qreal shift = value(*settingLayoutShift, def).toDouble(&ok);
if (ok)
{
return shift;
}
else
{
return def;
}
}
//---------------------------------------------------------------------------------------------------------------------
qreal VSettings::GetDefLayoutShift()
{
return 0;
}
//---------------------------------------------------------------------------------------------------------------------
void VSettings::SetLayoutShift(qreal value)
{
setValue(*settingLayoutShift, value);
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
qreal VSettings::GetLayoutWidth() const qreal VSettings::GetLayoutWidth() const
{ {
const qreal def = GetDefLayoutWidth(); return ValueOrDef<qreal>(*settingLayoutWidth, GetDefLayoutWidth());
bool ok = false;
const qreal lWidth = value(*settingLayoutWidth, def).toDouble(&ok);
if (ok)
{
return lWidth;
}
else
{
return def;
}
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -279,15 +220,34 @@ void VSettings::SetLayoutWidth(qreal value)
setValue(*settingLayoutWidth, value); setValue(*settingLayoutWidth, value);
} }
//---------------------------------------------------------------------------------------------------------------------
int VSettings::GetNestingTime() const
{
return ValueOrDef<int>(*settingNestingTime, GetDefNestingTime());
}
//---------------------------------------------------------------------------------------------------------------------
void VSettings::SetNestingTime(int value)
{
setValue(*settingNestingTime, value);
}
//---------------------------------------------------------------------------------------------------------------------
qreal VSettings::GetEfficiencyCoefficient() const
{
return ValueOrDef<qreal>(*settingEfficiencyCoefficient, GetDefEfficiencyCoefficient());
}
//---------------------------------------------------------------------------------------------------------------------
void VSettings::SetEfficiencyCoefficient(qreal value)
{
setValue(*settingEfficiencyCoefficient, value);
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
QMarginsF VSettings::GetFields(const QMarginsF &def) const QMarginsF VSettings::GetFields(const QMarginsF &def) const
{ {
const QVariant val = value(*settingFields, QVariant::fromValue(def)); return ValueOrDef<QMarginsF>(*settingFields, def);
if (val.canConvert<QMarginsF>())
{
return val.value<QMarginsF>();
}
return def;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -299,24 +259,7 @@ void VSettings::SetFields(const QMarginsF &value)
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
Cases VSettings::GetLayoutGroup() const Cases VSettings::GetLayoutGroup() const
{ {
const Cases def = GetDefLayoutGroup(); return ValueOrDef<Cases>(*settingLayoutSorting, GetDefLayoutGroup());
bool ok = false;
const int g = value(*settingLayoutSorting, static_cast<int>(def)).toInt(&ok);
if (ok)
{
if (g >= static_cast<int>(Cases::UnknownCase))
{
return def;
}
else
{
return static_cast<Cases>(g);
}
}
else
{
return def;
}
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -331,24 +274,6 @@ void VSettings::SetLayoutGroup(const Cases &value)
setValue(*settingLayoutSorting, static_cast<int>(value)); setValue(*settingLayoutSorting, static_cast<int>(value));
} }
//---------------------------------------------------------------------------------------------------------------------
bool VSettings::GetLayoutRotate() const
{
return value(*settingLayoutRotate, GetDefLayoutRotate()).toBool();
}
//---------------------------------------------------------------------------------------------------------------------
bool VSettings::GetDefLayoutRotate()
{
return false;
}
//---------------------------------------------------------------------------------------------------------------------
void VSettings::SetLayoutRotate(bool value)
{
setValue(*settingLayoutRotate, value);
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VSettings::GetLayoutFollowGrainline() const bool VSettings::GetLayoutFollowGrainline() const
{ {
@ -367,41 +292,6 @@ void VSettings::SetLayoutFollowGrainline(bool value)
setValue(*settingLayoutFollowGrainline, value); setValue(*settingLayoutFollowGrainline, value);
} }
//---------------------------------------------------------------------------------------------------------------------
int VSettings::GetLayoutRotationIncrease() const
{
const int def = GetDefLayoutRotationIncrease();
bool ok = false;
const int r = value(*settingLayoutRotationIncrease, def).toInt(&ok);
if (ok)
{
if (not (r >= 1 && r <= 180 && 360 % r == 0))
{
return def;
}
else
{
return r;
}
}
else
{
return def;
}
}
//---------------------------------------------------------------------------------------------------------------------
int VSettings::GetDefLayoutRotationIncrease()
{
return 180;/*degree*/
}
//---------------------------------------------------------------------------------------------------------------------
void VSettings::SetLayoutRotationIncrease(int value)
{
setValue(*settingLayoutRotationIncrease, value);
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VSettings::GetLayoutAutoCrop() const bool VSettings::GetLayoutAutoCrop() const
{ {
@ -564,15 +454,7 @@ void VSettings::SetRememberPatternMaterials(bool value)
QMarginsF VSettings::GetTiledPDFMargins(const Unit &unit) const QMarginsF VSettings::GetTiledPDFMargins(const Unit &unit) const
{ {
// default value is 10mm. We save the margins in mm in the setting. // default value is 10mm. We save the margins in mm in the setting.
const QMarginsF def = QMarginsF(10, 10, 10, 10); return UnitConvertor(ValueOrDef<QMarginsF>(*settingTiledPDFMargins, QMarginsF(10, 10, 10, 10)), Unit::Mm, unit);
const QVariant val = value(*settingTiledPDFMargins, QVariant::fromValue(def));
if (val.canConvert<QMarginsF>())
{
return UnitConvertor(val.value<QMarginsF>(), Unit::Mm, unit);
}
return UnitConvertor(def, Unit::Mm, unit);
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -596,17 +478,7 @@ void VSettings::SetTiledPDFMargins(const QMarginsF &value, const Unit &unit)
*/ */
qreal VSettings::GetTiledPDFPaperHeight(const Unit &unit) const qreal VSettings::GetTiledPDFPaperHeight(const Unit &unit) const
{ {
const qreal def = 297 /*A4*/; return UnitConvertor(ValueOrDef<qreal>(*settingTiledPDFPaperHeight, 297 /*A4*/), Unit::Mm, unit);
bool ok = false;
const qreal height = value(*settingTiledPDFPaperHeight, def).toDouble(&ok);
if (ok)
{
return UnitConvertor(height, Unit::Mm, unit);
}
else
{
return UnitConvertor(def, Unit::Mm, unit);
}
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -629,18 +501,7 @@ void VSettings::SetTiledPDFPaperHeight(qreal value, const Unit &unit)
*/ */
qreal VSettings::GetTiledPDFPaperWidth(const Unit &unit) const qreal VSettings::GetTiledPDFPaperWidth(const Unit &unit) const
{ {
return UnitConvertor(ValueOrDef<qreal>(*settingTiledPDFPaperWidth, 210 /*A4*/), Unit::Mm, unit);
const qreal def = 210 /*A4*/;
bool ok = false;
const qreal width = value(*settingTiledPDFPaperWidth, def).toDouble(&ok);
if (ok)
{
return UnitConvertor(width, Unit::Mm, unit);
}
else
{
return UnitConvertor(def, Unit::Mm, unit);
}
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -744,8 +605,7 @@ T VSettings::GetCachedValue(T &cache, const QString &setting, T defValue, T valu
{ {
if (cache < 0) if (cache < 0)
{ {
const QVariant val = value(setting, defValue); cache = qBound(valueMin, ValueOrDef(setting, defValue), valueMax);
cache = val.canConvert<T>() ? qBound(valueMin, val.value<T>(), valueMax) : defValue;
} }
return cache; return cache;

47
src/libs/vmisc/vsettings.h
View File

@ -74,14 +74,18 @@ public:
qreal GetLayoutPaperWidth() const; qreal GetLayoutPaperWidth() const;
void SetLayoutPaperWidth(qreal value); void SetLayoutPaperWidth(qreal value);
qreal GetLayoutShift() const;
static qreal GetDefLayoutShift();
void SetLayoutShift(qreal value);
qreal GetLayoutWidth() const; qreal GetLayoutWidth() const;
static qreal GetDefLayoutWidth(); static qreal GetDefLayoutWidth();
void SetLayoutWidth(qreal value); void SetLayoutWidth(qreal value);
int GetNestingTime() const;
static int GetDefNestingTime(){return 1;}
void SetNestingTime(int value);
qreal GetEfficiencyCoefficient() const;
static qreal GetDefEfficiencyCoefficient(){return 0.0;}
void SetEfficiencyCoefficient(qreal value);
QMarginsF GetFields(const QMarginsF &def = QMarginsF()) const; QMarginsF GetFields(const QMarginsF &def = QMarginsF()) const;
void SetFields(const QMarginsF &value); void SetFields(const QMarginsF &value);
@ -89,18 +93,10 @@ public:
static Cases GetDefLayoutGroup(); static Cases GetDefLayoutGroup();
void SetLayoutGroup(const Cases &value); void SetLayoutGroup(const Cases &value);
bool GetLayoutRotate() const;
static bool GetDefLayoutRotate();
void SetLayoutRotate(bool value);
bool GetLayoutFollowGrainline() const; bool GetLayoutFollowGrainline() const;
static bool GetDefLayoutFollowGrainline(); static bool GetDefLayoutFollowGrainline();
void SetLayoutFollowGrainline(bool value); void SetLayoutFollowGrainline(bool value);
int GetLayoutRotationIncrease() const;
static int GetDefLayoutRotationIncrease();
void SetLayoutRotationIncrease(int value);
bool GetLayoutAutoCrop() const; bool GetLayoutAutoCrop() const;
static bool GetDefLayoutAutoCrop(); static bool GetDefLayoutAutoCrop();
void SetLayoutAutoCrop(bool value); void SetLayoutAutoCrop(bool value);
@ -183,6 +179,33 @@ private:
template <typename T> template <typename T>
T GetCachedValue(T &cache, const QString &setting, T defValue, T valueMin, T valueMax) const; T GetCachedValue(T &cache, const QString &setting, T defValue, T valueMin, T valueMax) const;
template <class T>
T ValueOrDef(const QString &setting, const T &defValue) const;
}; };
//---------------------------------------------------------------------------------------------------------------------
template <class T>
inline T VSettings::ValueOrDef(const QString &setting, const T &defValue) const
{
const QVariant val = value(setting, QVariant::fromValue(defValue));
return val.canConvert<T>() ? val.value<T>() : defValue;
}
//---------------------------------------------------------------------------------------------------------------------
template <>
inline Cases VSettings::ValueOrDef<Cases>(const QString &setting, const Cases &defValue) const
{
const QVariant val = value(setting, QVariant::fromValue(static_cast<int>(defValue)));
const int g = val.canConvert<int>() ? val.value<int>() : static_cast<int>(defValue);
if (g < static_cast<int>(Cases::CaseThreeGroup) || g >= static_cast<int>(Cases::UnknownCase))
{
return defValue;
}
else
{
return static_cast<Cases>(g);
}
}
#endif // VSETTINGS_H #endif // VSETTINGS_H