palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-06-29 07:38:11 +02:00
Code Issues Projects Releases Wiki Activity
valentina/src/app/puzzle/vpmainwindow.cpp
Ronan Le Tiec dc183eaa51 initialise placement values
2021-03-14 14:40:56 +01:00

1540 lines
56 KiB
C++
Raw Blame History

/************************************************************************
**
** @file vpmainwindow.cpp
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 16 2, 2020
**
** @brief
** @copyright
** This source code is part of the Valentina project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2020 Valentina project
** <https://gitlab.com/smart-pattern/valentina> All Rights Reserved.
**
** Valentina is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** Valentina is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#include "vpmainwindow.h"
#include <QFileDialog>
#include <QCloseEvent>
#include <QtMath>
#include <QSvgGenerator>
#include "ui_vpmainwindow.h"
#include "dialogs/vpdialogabout.h"
#include "xml/vplayoutfilewriter.h"
#include "xml/vplayoutfilereader.h"
#include "vpapplication.h"
#include "../vlayout/vrawlayout.h"
#include "../vmisc/vsysexits.h"
#include "../vmisc/projectversion.h"
#include "../ifc/xml/vlayoutconverter.h"
#include "../ifc/exception/vexception.h"
#include "../vwidgets/vmaingraphicsscene.h"
#include "vpsheet.h"
#include <QLoggingCategory>
QT_WARNING_PUSH
QT_WARNING_DISABLE_CLANG("-Wmissing-prototypes")
QT_WARNING_DISABLE_INTEL(1418)
Q_LOGGING_CATEGORY(pWindow, "p.window")
QT_WARNING_POP
//---------------------------------------------------------------------------------------------------------------------
VPMainWindow::VPMainWindow(const VPCommandLinePtr &cmd, QWidget *parent) :
QMainWindow(parent),
ui(new Ui::VPMainWindow),
m_cmd(cmd)
{
m_layout = new VPLayout();
// create a standard sheet
VPSheet *sheet = new VPSheet(m_layout);
sheet->SetName(QObject::tr("Sheet #1"));
m_layout->AddSheet(sheet);
m_layout->SetFocusedSheet();
// ----- for test purposes, to be removed------------------
sheet->SetSheetMarginsConverted(1, 1, 1, 1);
sheet->SetSheetSizeConverted(84.1, 118.9);
sheet->SetPiecesGapConverted(1);
m_layout->SetUnit(Unit::Cm);
m_layout->SetWarningSuperpositionOfPieces(true);
m_layout->SetTitle(QString("My Test Layout"));
m_layout->SetDescription(QString("Description of my Layout"));
m_layout->SetTilesSizeConverted(21,29.7);
m_layout->SetTilesOrientation(PageOrientation::Portrait);
m_layout->SetTilesMarginsConverted(1,1,1,1);
// m_layout->SetShowTiles(true);
// --------------------------------------------------------
ui->setupUi(this);
// init the tile factory
m_tileFactory = new VPTileFactory(m_layout, qApp->Settings());
m_tileFactory->refreshTileInfos();
InitMenuBar();
InitProperties();
InitCarrousel();
InitMainGraphics();
InitZoomToolBar();
SetPropertiesData();
ReadSettings();
}
//---------------------------------------------------------------------------------------------------------------------
VPMainWindow::~VPMainWindow()
{
delete ui;
delete m_carrousel;
}
//---------------------------------------------------------------------------------------------------------------------
bool VPMainWindow::LoadFile(QString path)
{
try
{
VLayoutConverter converter(path);
path = converter.Convert();
}
catch (VException &e)
{
qCCritical(pWindow, "%s\n\n%s\n\n%s", qUtf8Printable(tr("File error.")),
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
return false;
}
QFile file(path);
file.open(QIODevice::ReadOnly);
QScopedPointer<VPLayoutFileReader> fileReader(new VPLayoutFileReader());
if(m_layout == nullptr)
{
m_layout = new VPLayout();
}
fileReader->ReadFile(m_layout, &file);
// TODO / FIXME : better return value and error handling
return true;
}
//---------------------------------------------------------------------------------------------------------------------
bool VPMainWindow::SaveFile(const QString &path)
{
QFile file(path);
file.open(QIODevice::WriteOnly);
VPLayoutFileWriter *fileWriter = new VPLayoutFileWriter();
fileWriter->WriteFile(m_layout, &file);
// TODO / FIXME : better return value and error handling
return true;
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::ImportRawLayouts(const QStringList &rawLayouts)
{
VRawLayout rawLayoutReader;
for(auto &path : rawLayouts)
{
VRawLayoutData data;
if (rawLayoutReader.ReadFile(path, data))
{
for (int i = 0; i < data.pieces.size(); ++i)
{
VLayoutPiece rawPiece = data.pieces.at(i);
// TODO / FIXME: make a few tests, on the data to check for validity. If not
//
// If seam allowance enabled, but the path is empty — invalid.
// If seam line path not hidden, but the path is empty — invalid.
// If seam allowance is built-in, but the seam line path is empty — invalid.
// TODO for feature "Update piece" : CreateOrUpdate() function indstead of CreatePiece()
VPPiece *piece = CreatePiece(rawPiece);
m_layout->GetUnplacedPieceList()->AddPiece(piece);
}
m_carrousel->Refresh();
}
else
{
qCCritical(pWindow, "%s\n", qPrintable(tr("Could not extract data from file '%1'. %2")
.arg(path, rawLayoutReader.ErrorString())));
if (m_cmd != nullptr && not m_cmd->IsGuiEnabled())
{
m_cmd->ShowHelp(V_EX_DATAERR);
}
}
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitZoom()
{
m_graphicsView->ZoomFitBest();
}
//---------------------------------------------------------------------------------------------------------------------
VPPiece* VPMainWindow::CreatePiece(const VLayoutPiece &rawPiece)
{
VPPiece *piece = new VPPiece(rawPiece);
// cutting line : GetMappedSeamAllowancePoints();
// seamline : GetMappedContourPoints();
// rawPiece.IsGrainlineEnabled() , GrainlineAngle , GetGrainline
// TODO : set all the information we need for the piece!
//
connect(piece, &VPPiece::SelectionChanged, this, &VPMainWindow::on_PieceSelectionChanged);
connect(piece, &VPPiece::PositionChanged, this, &VPMainWindow::on_PiecePositionChanged);
connect(piece, &VPPiece::RotationChanged, this, &VPMainWindow::on_PieceRotationChanged);
return piece;
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitMenuBar()
{
// most of the actions are connected through name convention (auto-connection)
// -------------------- connects the actions for the file menu
connect(ui->actionExit, &QAction::triggered, this, &VPMainWindow::close);
// -------------------- connects the actions for the edit menu
// TODO : initialise the undo / redo
// -------------------- connects the actions for the windows menu
// TODO : initialise the entries for the different windows
// Add dock properties action
QAction* actionDockWidgetToolOptions = ui->dockWidgetProperties->toggleViewAction();
ui->menuWindows->addAction(actionDockWidgetToolOptions);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitProperties()
{
InitPropertyTabCurrentPiece();
InitPropertyTabCurrentSheet();
InitPropertyTabLayout();
InitPropertyTabTiles();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitPropertyTabCurrentPiece()
{
// FIXME ---- For MVP we hide a few things. To be displayed when functions there
ui->groupBoxLayoutControl->hide();
ui->groupBoxCurrentPieceGeometry->hide();
// ------------------------------ placement -----------------------------------
connect(ui->doubleSpinBoxCurrentPieceBoxPositionX, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_CurrentPiecePositionEdited);
connect(ui->doubleSpinBoxCurrentPieceBoxPositionY, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_CurrentPiecePositionEdited);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitPropertyTabCurrentSheet()
{
// FIXME ---- For MVP we hide a few things. To be displayed when functions there
ui->pushButtonSheetRemoveUnusedLength->hide();
ui->groupBoxSheetControl->hide();
// some of the UI Elements are connected to the slots via auto-connect
// see https://doc.qt.io/qt-5/designer-using-a-ui-file.html#widgets-and-dialogs-with-auto-connect
// -------------------- layout width, length, orientation ------------------------
connect(ui->doubleSpinBoxSheetWidth, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_SheetSizeChanged);
connect(ui->doubleSpinBoxSheetLength, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_SheetSizeChanged);
connect(ui->radioButtonSheetPortrait, QOverload<bool>::of(&QRadioButton::clicked), this,
&VPMainWindow::on_SheetOrientationChanged);
connect(ui->radioButtonSheetLandscape, QOverload<bool>::of(&QRadioButton::clicked), this,
&VPMainWindow::on_SheetOrientationChanged);
// -------------------- margins ------------------------
connect(ui->doubleSpinBoxSheetMarginTop, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_SheetMarginChanged);
connect(ui->doubleSpinBoxSheetMarginRight, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_SheetMarginChanged);
connect(ui->doubleSpinBoxSheetMarginBottom, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_SheetMarginChanged);
connect(ui->doubleSpinBoxSheetMarginLeft, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_SheetMarginChanged);
// ------------------- follow grainline -----------------------
connect(ui->radioButtonSheetFollowGrainlineNo, QOverload<bool>::of(&QRadioButton::clicked), this,
&VPMainWindow::on_SheetFollowGrainlineChanged);
connect(ui->radioButtonSheetFollowGrainlineVertical, QOverload<bool>::of(&QRadioButton::clicked), this,
&VPMainWindow::on_SheetFollowGrainlineChanged);
connect(ui->radioButtonSheetFollowGrainlineHorizontal, QOverload<bool>::of(&QRadioButton::clicked), this,
&VPMainWindow::on_SheetFollowGrainlineChanged);
// -------------------- sheet template ---------------------------
// FIXME: find a nicer way to initiliase it
QVector<PaperSizeTemplate> sheetTemplates = QVector<PaperSizeTemplate>();
sheetTemplates.append(PaperSizeTemplate::A0);
sheetTemplates.append(PaperSizeTemplate::A1);
sheetTemplates.append(PaperSizeTemplate::A2);
sheetTemplates.append(PaperSizeTemplate::A3);
sheetTemplates.append(PaperSizeTemplate::A4);
sheetTemplates.append(PaperSizeTemplate::Letter);
sheetTemplates.append(PaperSizeTemplate::Legal);
sheetTemplates.append(PaperSizeTemplate::Tabloid);
sheetTemplates.append(PaperSizeTemplate::Roll24in);
sheetTemplates.append(PaperSizeTemplate::Roll30in);
sheetTemplates.append(PaperSizeTemplate::Roll36in);
sheetTemplates.append(PaperSizeTemplate::Roll42in);
sheetTemplates.append(PaperSizeTemplate::Roll44in);
sheetTemplates.append(PaperSizeTemplate::Roll48in);
sheetTemplates.append(PaperSizeTemplate::Roll62in);
sheetTemplates.append(PaperSizeTemplate::Roll72in);
sheetTemplates.append(PaperSizeTemplate::Custom);
ui->comboBoxSheetTemplate->blockSignals(true);
VPSheet::PopulateComboBox(&sheetTemplates, ui->comboBoxSheetTemplate);
ui->comboBoxSheetTemplate->blockSignals(false);
ui->comboBoxSheetTemplate->setCurrentIndex(0);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitPropertyTabTiles()
{
// -------------------- layout width, length, orientation ------------------------
connect(ui->doubleSpinBoxTilesWidth, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_TilesSizeChanged);
connect(ui->doubleSpinBoxTilesLength, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_TilesSizeChanged);
connect(ui->radioButtonTilesPortrait, QOverload<bool>::of(&QRadioButton::clicked), this,
&VPMainWindow::on_TilesOrientationChanged);
connect(ui->radioButtonTilesLandscape, QOverload<bool>::of(&QRadioButton::clicked), this,
&VPMainWindow::on_TilesOrientationChanged);
// -------------------- tiles template
QVector<PaperSizeTemplate> tilesTemplates = QVector<PaperSizeTemplate>();
tilesTemplates.append(PaperSizeTemplate::A0);
tilesTemplates.append(PaperSizeTemplate::A1);
tilesTemplates.append(PaperSizeTemplate::A2);
tilesTemplates.append(PaperSizeTemplate::A3);
tilesTemplates.append(PaperSizeTemplate::A4);
tilesTemplates.append(PaperSizeTemplate::Letter);
tilesTemplates.append(PaperSizeTemplate::Legal);
tilesTemplates.append(PaperSizeTemplate::Custom);
ui->comboBoxTilesTemplate->blockSignals(true);
VPSheet::PopulateComboBox(&tilesTemplates, ui->comboBoxTilesTemplate);
ui->comboBoxTilesTemplate->blockSignals(false);
ui->comboBoxTilesTemplate->setCurrentIndex(4); //A4
// -------------------- margins ------------------------
connect(ui->doubleSpinBoxTilesMarginTop, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_TilesMarginChanged);
connect(ui->doubleSpinBoxTilesMarginRight, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_TilesMarginChanged);
connect(ui->doubleSpinBoxTilesMarginBottom, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_TilesMarginChanged);
connect(ui->doubleSpinBoxTilesMarginLeft, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
&VPMainWindow::on_TilesMarginChanged);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitPropertyTabLayout()
{
// FIXME ---- For MVP we hide a few things. To be displayed when functions there
ui->groupBoxLayoutControl->hide();
// -------------------- init the unit combobox ---------------------
ui->comboBoxLayoutUnit->addItem(tr("Centimeters"), QVariant(UnitsToStr(Unit::Cm)));
ui->comboBoxLayoutUnit->addItem(tr("Millimiters"), QVariant(UnitsToStr(Unit::Mm)));
ui->comboBoxLayoutUnit->addItem(tr("Inches"), QVariant(UnitsToStr(Unit::Inch)));
// set default unit - TODO when we have the setting for the unit
// const qint32 indexUnit = -1;//ui->comboBoxLayoutUnit->findData(qApp->ValentinaSettings()->GetUnit());
// if (indexUnit != -1)
// {
// ui->comboBoxLayoutUnit->setCurrentIndex(indexUnit);
// }
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitCarrousel()
{
m_carrousel = new VPCarrousel(m_layout, ui->dockWidgetCarrousel);
ui->dockWidgetCarrousel->setWidget(m_carrousel);
connect(ui->dockWidgetCarrousel, QOverload<Qt::DockWidgetArea>::of(&QDockWidget::dockLocationChanged), this,
&VPMainWindow::on_CarrouselLocationChanged);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::SetPropertiesData()
{
if(m_layout == nullptr)
{
// TODO : hide the tabs when there is no layout
}
else
{
SetPropertyTabCurrentPieceData();
SetPropertyTabSheetData();
SetPropertyTabTilesData();
SetPropertyTabLayoutData();
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::SetPropertyTabCurrentPieceData()
{
if(m_selectedPieces.count() == 0)
{
// show the content "no piece selected"
ui->containerCurrentPieceNoData->setVisible(true);
ui->containerCurrentPieceData->setVisible(false);
ui->containerCurrentPieceMultipleData->setVisible(false);
}
else if(m_selectedPieces.count() == 1)
{
// show the content "selected piece data"
ui->containerCurrentPieceNoData->setVisible(false);
ui->containerCurrentPieceData->setVisible(true);
ui->containerCurrentPieceMultipleData->setVisible(false);
VPPiece *selectedPiece = m_selectedPieces.first();
// set the value to the current piece
ui->lineEditCurrentPieceName->setText(selectedPiece->GetName());
ui->plainTextEditCurrentPieceUUID->setPlainText(selectedPiece->GetUUID().toString());
ui->checkBoxCurrentPieceShowSeamline->setChecked(selectedPiece->GetShowSeamLine());
ui->checkBoxCurrentPieceMirrorPiece->setChecked(selectedPiece->GetPieceMirrored());
QPointF pos = selectedPiece->GetPosition();
SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionX,
UnitConvertor(pos.x(), Unit::Px, m_layout->GetUnit()));
SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionY,
UnitConvertor(pos.y(), Unit::Px, m_layout->GetUnit()));
qreal angle = selectedPiece->GetRotation();
SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceAngle, angle);
}
else
{
// show the content "multiple pieces selected"
ui->containerCurrentPieceNoData->setVisible(false);
ui->containerCurrentPieceData->setVisible(false);
ui->containerCurrentPieceMultipleData->setVisible(true);
// if needed in the future, we can show some properties that coul be edited for all the pieces
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::SetPropertyTabSheetData()
{
// set name // TODO FIXME make it better
ui->lineEditSheetName->setText(m_layout->GetFocusedSheet()->GetName());
// set Width / Length
QSizeF size = m_layout->GetFocusedSheet()->GetSheetSizeConverted();
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetWidth, size.width());
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetLength, size.height());
// Set Orientation
if(m_layout->GetFocusedSheet()->GetOrientation() == PageOrientation::Portrait)
{
ui->radioButtonSheetPortrait->setChecked(true);
}
else
{
ui->radioButtonSheetLandscape->setChecked(true);
}
// set margins
QMarginsF margins = m_layout->GetFocusedSheet()->GetSheetMarginsConverted();
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetMarginLeft, margins.left());
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetMarginTop, margins.top());
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetMarginRight, margins.right());
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetMarginBottom, margins.bottom());
// set placement grid
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetGridColWidth, m_layout->GetFocusedSheet()->GetGridColWidthConverted());
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetGridRowHeight, m_layout->GetFocusedSheet()->GetGridRowHeightConverted());
SetCheckBoxValue(ui->checkBoxSheetShowGrid, m_layout->GetFocusedSheet()->GetShowGrid());
// set pieces gap
SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetPiecesGap, m_layout->GetFocusedSheet()->GetPiecesGapConverted());
// set the checkboxes
SetCheckBoxValue(ui->checkBoxSheetStickyEdges, m_layout->GetFocusedSheet()->GetStickyEdges());
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::SetPropertyTabTilesData()
{
// set Width / Length
QSizeF size = m_layout->GetTilesSizeConverted();
SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesWidth, size.width());
SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesLength, size.height());
// Set Orientation
if(m_layout->GetTilesOrientation() == PageOrientation::Portrait)
{
ui->radioButtonSheetPortrait->setChecked(true);
}
else
{
ui->radioButtonSheetLandscape->setChecked(true);
}
// set margins
QMarginsF margins = m_layout->GetTilesMarginsConverted();
SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesMarginLeft, margins.left());
SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesMarginTop, margins.top());
SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesMarginRight, margins.right());
SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesMarginBottom, margins.bottom());
// set "show tiles" checkbox
SetCheckBoxValue(ui->checkBoxTilesShowTiles, m_layout->GetShowTiles());
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::SetPropertyTabLayoutData()
{
// set the title and description
ui->lineEditLayoutName->setText(m_layout->GetTitle());
ui->plainTextEditLayoutDescription->setPlainText(m_layout->GetDescription());
// set Unit
int index = ui->comboBoxLayoutUnit->findData(QVariant(UnitsToStr(m_layout->GetUnit())));
if(index != -1)
{
ui->comboBoxLayoutUnit->blockSignals(true); // FIXME: is there a better way to block the signals?
ui->comboBoxLayoutUnit->setCurrentIndex(index);
ui->comboBoxLayoutUnit->blockSignals(false);
}
// set controls
SetCheckBoxValue(ui->checkBoxLayoutWarningPiecesOutOfBound, m_layout->GetWarningPiecesOutOfBound());
SetCheckBoxValue(ui->checkBoxLayoutWarningPiecesSuperposition, m_layout->GetWarningSuperpositionOfPieces());
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitMainGraphics()
{
m_graphicsView = new VPMainGraphicsView(m_layout, m_tileFactory, this);
ui->centralWidget->layout()->addWidget(m_graphicsView);
m_graphicsView->RefreshLayout();
connect(m_graphicsView, &VPMainGraphicsView::ScaleChanged, this, &VPMainWindow::on_ScaleChanged);
connect(m_graphicsView->GetScene(), &VMainGraphicsScene::mouseMove, this, &VPMainWindow::on_MouseMoved);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::InitZoomToolBar()
{
if (not m_doubleSpinBoxScale.isNull())
{
delete m_doubleSpinBoxScale;
}
if (m_mouseCoordinate != nullptr)
{
delete m_mouseCoordinate;
}
// connect the zoom buttons and shortcuts to the slots
QList<QKeySequence> zoomInShortcuts;
zoomInShortcuts.append(QKeySequence(QKeySequence::ZoomIn));
zoomInShortcuts.append(QKeySequence(Qt::ControlModifier + Qt::Key_Plus + Qt::KeypadModifier));
ui->actionZoomIn->setShortcuts(zoomInShortcuts);
connect(ui->actionZoomIn, &QAction::triggered, m_graphicsView, &VPMainGraphicsView::ZoomIn);
QList<QKeySequence> zoomOutShortcuts;
zoomOutShortcuts.append(QKeySequence(QKeySequence::ZoomOut));
zoomOutShortcuts.append(QKeySequence(Qt::ControlModifier + Qt::Key_Minus + Qt::KeypadModifier));
ui->actionZoomOut->setShortcuts(zoomOutShortcuts);
connect(ui->actionZoomOut, &QAction::triggered, m_graphicsView, &VPMainGraphicsView::ZoomOut);
QList<QKeySequence> zoomOriginalShortcuts;
zoomOriginalShortcuts.append(QKeySequence(Qt::ControlModifier + Qt::Key_0));
zoomOriginalShortcuts.append(QKeySequence(Qt::ControlModifier + Qt::Key_0 + Qt::KeypadModifier));
ui->actionZoomOriginal->setShortcuts(zoomOriginalShortcuts);
connect(ui->actionZoomOriginal, &QAction::triggered, m_graphicsView, &VPMainGraphicsView::ZoomOriginal);
QList<QKeySequence> zoomFitBestShortcuts;
zoomFitBestShortcuts.append(QKeySequence(Qt::ControlModifier + Qt::Key_Equal));
ui->actionZoomFitBest->setShortcuts(zoomFitBestShortcuts);
connect(ui->actionZoomFitBest, &QAction::triggered, m_graphicsView, &VPMainGraphicsView::ZoomFitBest);
// defined the scale
ui->toolBarZoom->addSeparator();
QLabel* zoomScale = new QLabel(tr("Scale:"), this);
ui->toolBarZoom->addWidget(zoomScale);
m_doubleSpinBoxScale = new QDoubleSpinBox(this);
m_doubleSpinBoxScale->setDecimals(1);
m_doubleSpinBoxScale->setSuffix("%");
on_ScaleChanged(m_graphicsView->transform().m11());
connect(m_doubleSpinBoxScale.data(), QOverload<double>::of(&QDoubleSpinBox::valueChanged),
this, [this](double d){m_graphicsView->Zoom(d/100.0);});
ui->toolBarZoom->addWidget(m_doubleSpinBoxScale);
// define the mouse position
ui->toolBarZoom->addSeparator();
m_mouseCoordinate = new QLabel(QString("0, 0 (%1)").arg(UnitsToStr(m_layout->GetUnit(), true)));
ui->toolBarZoom->addWidget(m_mouseCoordinate);
ui->toolBarZoom->addSeparator();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::SetDoubleSpinBoxValue(QDoubleSpinBox *spinBox, qreal value)
{
spinBox->blockSignals(true);
spinBox->setValue(value);
spinBox->blockSignals(false);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::SetCheckBoxValue(QCheckBox *checkbox, bool value)
{
checkbox->blockSignals(true);
checkbox->setChecked(value);
checkbox->blockSignals(false);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::ReadSettings()
{
qCDebug(pWindow, "Reading settings.");
const VPSettings *settings = qApp->PuzzleSettings();
if (settings->status() == QSettings::NoError)
{
restoreGeometry(settings->GetGeometry());
restoreState(settings->GetWindowState());
restoreState(settings->GetToolbarsState(), APP_VERSION);
ui->dockWidgetProperties->setVisible(settings->IsDockWidgetPropertiesActive());
ui->dockWidgetPropertiesContents->setVisible(settings->IsDockWidgetPropertiesContentsActive());
// Scene antialiasing
m_graphicsView->SetAntialiasing(settings->GetGraphicalOutput());
// Stack limit
// qApp->getUndoStack()->setUndoLimit(settings->GetUndoCount());
}
else
{
qWarning() << tr("Cannot read settings from a malformed .INI file.");
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::WriteSettings()
{
VPSettings *settings = qApp->PuzzleSettings();
settings->SetGeometry(saveGeometry());
settings->SetWindowState(saveState());
settings->SetToolbarsState(saveState(APP_VERSION));
settings->SetDockWidgetPropertiesActive(ui->dockWidgetProperties->isEnabled());
settings->SetDockWidgetPropertiesContentsActive(ui->dockWidgetPropertiesContents->isEnabled());
settings->sync();
if (settings->status() == QSettings::AccessError)
{
qWarning() << tr("Cannot save settings. Access denied.");
}
}
//---------------------------------------------------------------------------------------------------------------------
bool VPMainWindow::MaybeSave()
{
// TODO: Implement maybe save check
// if (this->isWindowModified())
// {
// if (curFile.isEmpty() && ui->tableWidget->rowCount() == 0)
// {
// return true;// Don't ask if file was created without modifications.
// }
// QScopedPointer<QMessageBox> messageBox(new QMessageBox(tr("Unsaved changes"),
// tr("Measurements have been modified.\n"
// "Do you want to save your changes?"),
// QMessageBox::Warning, QMessageBox::Yes, QMessageBox::No,
// QMessageBox::Cancel, this, Qt::Sheet));
// messageBox->setDefaultButton(QMessageBox::Yes);
// messageBox->setEscapeButton(QMessageBox::Cancel);
// messageBox->setButtonText(QMessageBox::Yes, curFile.isEmpty() || mIsReadOnly ? tr("Save…") : tr("Save"));
// messageBox->setButtonText(QMessageBox::No, tr("Don't Save"));
// messageBox->setWindowModality(Qt::ApplicationModal);
// const auto ret = static_cast<QMessageBox::StandardButton>(messageBox->exec());
// switch (ret)
// {
// case QMessageBox::Yes:
// if (mIsReadOnly)
// {
// return FileSaveAs();
// }
// else
// {
// return FileSave();
// }
// case QMessageBox::No:
// return true;
// case QMessageBox::Cancel:
// return false;
// default:
// break;
// }
// }
return true;
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::generateTiledPdf(QString fileName)
{
if(not fileName.isEmpty())
{
m_graphicsView->PrepareForExport();
m_tileFactory->refreshTileInfos();
PageOrientation tilesOrientation = m_layout->GetTilesOrientation();
// ------------- Set up the printer
QPrinter* printer = new QPrinter();
printer->setCreator(QGuiApplication::applicationDisplayName()+QChar(QChar::Space)+
QCoreApplication::applicationVersion());
printer->setOrientation(QPrinter::Portrait); // in the pdf file the pages should always be in portrait
// here we might need to so some rounding for the size.
printer->setPageSize(QPageSize(m_layout->GetTilesSize(Unit::Mm),
QPageSize::Millimeter));
printer->setFullPage(true);
#ifdef Q_OS_MAC
printer->setOutputFormat(QPrinter::NativeFormat);
#else
printer->setOutputFormat(QPrinter::PdfFormat);
#endif
printer->setOutputFileName(fileName);
printer->setResolution(static_cast<int>(PrintDPI));
printer->setDocName("Test"); // FIXME
// ------------- Set up the painter
QPainter painter;
if (not painter.begin(printer))
{ // failed to open file
qCritical() << tr("Failed to open file, is it writable?");
return;
}
painter.setFont( QFont( QStringLiteral("Arial"), 8, QFont::Normal ) );
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setBrush ( QBrush ( Qt::NoBrush ) );
if(tilesOrientation == PageOrientation::Landscape)
{
// The landscape tiles have to be rotated, because the pages
// stay portrait in the pdf
painter.rotate(90);
painter.translate(0, -ToPixel(printer->pageRect(QPrinter::Millimeter).width(), Unit::Mm));
}
for(int row=0;row<m_tileFactory->getRowNb();row++) // for each row of the tiling grid
{
for(int col=0;col<m_tileFactory->getColNb();col++) // for each column of tiling grid
{
if(not (row == 0 && col == 0))
{
if (not printer->newPage())
{
qWarning("failed in flushing page to disk, disk full?");
return;
}
}
m_tileFactory->drawTile(&painter, m_graphicsView, row, col);
}
}
painter.end();
m_graphicsView->CleanAfterExport();
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionNew_triggered()
{
// just for test purpuses, to be removed:
QMessageBox msgBox;
msgBox.setText("TODO VPMainWindow::New");
int ret = msgBox.exec();
Q_UNUSED(ret);
// TODO
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::closeEvent(QCloseEvent *event)
{
#if defined(Q_OS_MAC) && QT_VERSION < QT_VERSION_CHECK(5, 11, 1)
// Workaround for Qt bug https://bugreports.qt.io/browse/QTBUG-43344
static int numCalled = 0;
if (numCalled++ >= 1)
{
return;
}
#endif
if (MaybeSave())
{
WriteSettings();
event->accept();
deleteLater();
}
else
{
event->ignore();
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionOpen_triggered()
{
qCDebug(pWindow, "Openning puzzle layout file.");
const QString filter(tr("Layout files") + QLatin1String(" (*.vlt)"));
//Get list last open files
QStringList recentFiles = qApp->PuzzleSettings()->GetRecentFileList();
QString dir;
if (recentFiles.isEmpty())
{
dir = QDir::homePath();
}
else
{
//Absolute path to last open file
dir = QFileInfo(recentFiles.first()).absolutePath();
}
qCDebug(pWindow, "Run QFileDialog::getOpenFileName: dir = %s.", qUtf8Printable(dir));
const QString filePath = QFileDialog::getOpenFileName(this, tr("Open file"), dir, filter, nullptr);
if (filePath.isEmpty())
{
return;
}
// TODO : if m_layout == nullptr, open in current window
// otherwise open in new window
// TODO : if layout file has a lock, warning message
if(!LoadFile(filePath))
{
return;
}
// Updates the list of recent files
recentFiles.removeAll(filePath);
recentFiles.prepend(filePath);
while (recentFiles.size() > MaxRecentFiles)
{
recentFiles.removeLast();
}
qApp->PuzzleSettings()->SetRecentFileList(recentFiles);
// updates the properties with the loaded data
SetPropertiesData();
// TODO : update the Carrousel and the QGraphicView
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionSave_triggered()
{
// just for test purpuses, to be removed:
QMessageBox msgBox;
msgBox.setText("TODO VPMainWindow::Save");
int ret = msgBox.exec();
Q_UNUSED(ret);
// TODO
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionSaveAs_triggered()
{
// TODO / FIXME : See valentina how the save is done over there. we need to add the
// extension .vlt, check for empty file names etc.
//Get list last open files
QStringList recentFiles = qApp->PuzzleSettings()->GetRecentFileList();
QString dir;
if (recentFiles.isEmpty())
{
dir = QDir::homePath();
}
else
{
//Absolute path to last open file
dir = QFileInfo(recentFiles.first()).absolutePath();
}
QString filters(tr("Layout files") + QLatin1String("(*.vlt)"));
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"),
dir + QLatin1String("/") + tr("Layout") + QLatin1String(".vlt"),
filters, nullptr
#ifdef Q_OS_LINUX
, QFileDialog::DontUseNativeDialog
#endif
);
SaveFile(fileName);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionImportRawLayout_triggered()
{
// TODO: here the code is probably just bad, to be edited
QString dir;
if (true)
{
dir = QDir::homePath();
}
else
{
// TODO / FIXME get the default path for raw layouts
}
const QString filter(tr("Raw Layout files") + QLatin1String(" (*.rld)"));
qCDebug(pWindow, "Run QFileDialog::getOpenFileName: dir = %s.", qUtf8Printable(dir));
const QString filePath = QFileDialog::getOpenFileName(this, tr("Open file"), dir, filter, nullptr);
QStringList rawLayouts = QStringList();
rawLayouts.append(filePath);
ImportRawLayouts(rawLayouts);
// TODO / FIXME : better error handling
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionCloseLayout_triggered()
{
// just for test purpuses, to be removed:
QMessageBox msgBox;
msgBox.setText("TODO VPMainWindow::CloseLayout");
int ret = msgBox.exec();
Q_UNUSED(ret);
// TODO
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionAboutQt_triggered()
{
QMessageBox::aboutQt(this, tr("About Qt"));
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_actionAboutPuzzle_triggered()
{
auto *aboutDialog = new VPDialogAbout(this);
aboutDialog->setAttribute(Qt::WA_DeleteOnClose, true);
aboutDialog->show();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_comboBoxLayoutUnit_currentIndexChanged(int index)
{
Q_UNUSED(index);
QVariant comboBoxValue = ui->comboBoxLayoutUnit->currentData();
if(comboBoxValue == QVariant(UnitsToStr(Unit::Cm)))
{
m_layout->SetUnit(Unit::Cm);
}
else if(comboBoxValue == QVariant(UnitsToStr(Unit::Mm)))
{
m_layout->SetUnit(Unit::Mm);
}
else if(comboBoxValue == QVariant(UnitsToStr(Unit::Inch)))
{
m_layout->SetUnit(Unit::Inch);
}
SetPropertyTabCurrentPieceData();
SetPropertyTabSheetData();
SetPropertyTabTilesData();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_lineEditSheetName_textChanged(const QString &text)
{
m_layout->GetFocusedSheet()->SetName(text);
if(m_carrousel != nullptr)
{
m_carrousel->RefreshFocusedSheetName();
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_comboBoxSheetTemplate_currentIndexChanged(int index)
{
PaperSizeTemplate tmpl = static_cast<PaperSizeTemplate>(
ui->comboBoxSheetTemplate->itemData(index).toInt()
);
QSizeF tmplSize = VPSheet::GetTemplateSize(tmpl);
if(!tmplSize.isEmpty())
{
ui->doubleSpinBoxSheetWidth->blockSignals(true);
ui->doubleSpinBoxSheetLength->blockSignals(true);
ui->doubleSpinBoxSheetWidth->setValue(UnitConvertor(tmplSize.width(), Unit::Px, m_layout->GetUnit()));
ui->doubleSpinBoxSheetLength->setValue(UnitConvertor(tmplSize.height(), Unit::Px, m_layout->GetUnit()));
on_SheetSizeChanged(false);
ui->doubleSpinBoxSheetWidth->blockSignals(false);
ui->doubleSpinBoxSheetLength->blockSignals(false);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_SheetSizeChanged(bool changedViaSizeCombobox)
{
m_layout->GetFocusedSheet()->SetSheetSizeConverted(
ui->doubleSpinBoxSheetWidth->value(),
ui->doubleSpinBoxSheetLength->value()
);
if(changedViaSizeCombobox)
{
ui->comboBoxSheetTemplate->blockSignals(true);
// we don't try to get the right size, because it doesn't work well because of mm / inch conversion
int index = ui->comboBoxSheetTemplate->findData(
QVariant(static_cast<int>(PaperSizeTemplate::Custom)));
ui->comboBoxSheetTemplate->setCurrentIndex(index);
ui->comboBoxSheetTemplate->blockSignals(false);
}
m_tileFactory->refreshTileInfos();
// TODO Undo / Redo
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_SheetOrientationChanged()
{
// Updates the orientation
if(ui->radioButtonSheetPortrait->isChecked())
{
m_layout->GetFocusedSheet()->SetOrientation(PageOrientation::Portrait);
}
else
{
m_layout->GetFocusedSheet()->SetOrientation(PageOrientation::Landscape);
}
m_tileFactory->refreshTileInfos();
// TODO Undo / Redo
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_pushButtonSheetRemoveUnusedLength_clicked()
{
// just for test purpuses, to be removed:
QMessageBox msgBox;
msgBox.setText("TODO VPMainWindow::on_pushButtonSheetRemoveUnusedLength_clicked");
int ret = msgBox.exec();
Q_UNUSED(ret);
// TODO
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_SheetMarginChanged()
{
m_layout->GetFocusedSheet()->SetSheetMarginsConverted(
ui->doubleSpinBoxSheetMarginLeft->value(),
ui->doubleSpinBoxSheetMarginTop->value(),
ui->doubleSpinBoxSheetMarginRight->value(),
ui->doubleSpinBoxSheetMarginBottom->value()
);
// TODO Undo / Redo
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_checkBoxSheetShowGrid_toggled(bool checked)
{
m_layout->GetFocusedSheet()->SetShowGrid(checked);
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_doubleSpinBoxSheetGridColWidth_valueChanged(double value)
{
m_layout->GetFocusedSheet()->SetGridColWidthConverted(value);
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_doubleSpinBoxSheetGridRowHeight_valueChanged(double value)
{
m_layout->GetFocusedSheet()->SetGridRowHeightConverted(value);
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_comboBoxTilesTemplate_currentIndexChanged(int index)
{
PaperSizeTemplate tmpl = static_cast<PaperSizeTemplate>(
ui->comboBoxTilesTemplate->itemData(index).toInt()
);
QSizeF tmplSize = VPSheet::GetTemplateSize(tmpl);
if(!tmplSize.isEmpty())
{
ui->doubleSpinBoxTilesWidth->blockSignals(true);
ui->doubleSpinBoxTilesLength->blockSignals(true);
ui->doubleSpinBoxTilesWidth->setValue(UnitConvertor(tmplSize.width(), Unit::Px, m_layout->GetUnit()));
ui->doubleSpinBoxTilesLength->setValue(UnitConvertor(tmplSize.height(), Unit::Px, m_layout->GetUnit()));
on_TilesSizeChanged(false);
ui->doubleSpinBoxTilesWidth->blockSignals(false);
ui->doubleSpinBoxTilesLength->blockSignals(false);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_TilesSizeChanged(bool changedViaSizeCombobox)
{
m_layout->SetTilesSizeConverted(ui->doubleSpinBoxTilesWidth->value(), ui->doubleSpinBoxTilesLength->value());
m_tileFactory->refreshTileInfos();
if(changedViaSizeCombobox)
{
ui->comboBoxTilesTemplate->blockSignals(true);
// we don't try to get the right size, because it doesn't work well because of mm / inch conversion
int index = ui->comboBoxTilesTemplate->findData(
QVariant(static_cast<int>(PaperSizeTemplate::Custom)));
ui->comboBoxTilesTemplate->setCurrentIndex(index);
ui->comboBoxTilesTemplate->blockSignals(false);
}
// TODO Undo / Redo
if(m_graphicsView != nullptr)
{
m_graphicsView->RefreshLayout();
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_TilesOrientationChanged()
{
// Updates the orientation
if(ui->radioButtonTilesPortrait->isChecked())
{
m_layout->SetTilesOrientation(PageOrientation::Portrait);
}
else
{
m_layout->SetTilesOrientation(PageOrientation::Landscape);
}
m_tileFactory->refreshTileInfos();
// TODO Undo / Redo
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_TilesMarginChanged()
{
m_layout->SetTilesMarginsConverted(
ui->doubleSpinBoxTilesMarginLeft->value(),
ui->doubleSpinBoxTilesMarginTop->value(),
ui->doubleSpinBoxTilesMarginRight->value(),
ui->doubleSpinBoxTilesMarginBottom->value()
);
m_tileFactory->refreshTileInfos();
// TODO Undo / Redo
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_checkBoxTilesShowTiles_toggled(bool checked)
{
m_layout->SetShowTiles(checked);
// TODO Undo / Redo
m_graphicsView->RefreshLayout();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_pushButtonTilesExport_clicked()
{
// svg export to do some test for the first test
QString dir = QDir::homePath();
QString filters(tr("PDF Files") + QLatin1String("(*.pdf)"));
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"),
dir + QLatin1String("/") + tr("Layout") + QLatin1String(".pdf"),
filters, nullptr
#ifdef Q_OS_LINUX
, QFileDialog::DontUseNativeDialog
#endif
);
generateTiledPdf(fileName);
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_SheetFollowGrainlineChanged()
{
// just for test purpuses, to be removed:
QMessageBox msgBox;
msgBox.setText("TODO VPMainWindow::on_SheetFollowGrainlineChanged");
int ret = msgBox.exec();
Q_UNUSED(ret);
// TODO
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_doubleSpinBoxSheetPiecesGap_valueChanged(double value)
{
m_layout->GetFocusedSheet()->SetPiecesGapConverted(value);
// TODO Undo / Redo
// TODO update the QGraphicView
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_checkBoxLayoutWarningPiecesSuperposition_toggled(bool checked)
{
m_layout->SetWarningSuperpositionOfPieces(checked);
// TODO Undo / Redo
// TODO update the QGraphicView
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_checkBoxLayoutWarningPiecesOutOfBound_toggled(bool checked)
{
m_layout->SetWarningPiecesOutOfBound(checked);
// TODO Undo / Redo
// TODO update the QGraphicView
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_checkBoxSheetStickyEdges_toggled(bool checked)
{
m_layout->GetFocusedSheet()->SetStickyEdges(checked);
// TODO Undo / Redo
// TODO update the QGraphicView
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_pushButtonSheetExport_clicked()
{
// svg export to do some test for the first test
QString dir = QDir::homePath();
QString filters(tr("SVG Files") + QLatin1String("(*.svg)"));
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"),
dir + QLatin1String("/") + tr("Layout") + QLatin1String(".svg"),
filters, nullptr
#ifdef Q_OS_LINUX
, QFileDialog::DontUseNativeDialog
#endif
);
if(not fileName.isEmpty())
{
m_graphicsView->PrepareForExport();
const QSizeF s = m_layout->GetFocusedSheet()->GetSheetSize();
const QRectF r = QRectF(0, 0, s.width(), s.height());
QSvgGenerator generator;
generator.setFileName(fileName);
generator.setSize(QSize(qFloor(s.width()),qFloor(s.height())));
generator.setViewBox(r);
generator.setTitle(tr("Pattern"));
generator.setDescription(m_layout->GetDescription().toHtmlEscaped());
generator.setResolution(static_cast<int>(PrintDPI));
QPainter painter;
painter.begin(&generator);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(QPen(Qt::black, qApp->Settings()->WidthHairLine(), Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
painter.setBrush ( QBrush ( Qt::NoBrush ) );
m_graphicsView->GetScene()->render(&painter, r, r, Qt::IgnoreAspectRatio);
painter.end();
m_graphicsView->CleanAfterExport();
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_checkBoxCurrentPieceShowSeamline_toggled(bool checked)
{
if(m_selectedPieces.count() == 1)
{
m_selectedPieces.first()->SetShowSeamLine(checked);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_checkBoxCurrentPieceMirrorPiece_toggled(bool checked)
{
if(m_selectedPieces.count() == 1)
{
m_selectedPieces.first()->SetPieceMirrored(checked);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_pushButtonCurrentPieceRotate90Anticlockwise_clicked()
{
if(m_selectedPieces.count() == 1)
{
m_selectedPieces.first()->RotateBy(90);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_pushButtonCurrentPieceRotate90Clockwise_clicked()
{
if(m_selectedPieces.count() == 1)
{
m_selectedPieces.first()->RotateBy(-90);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_pushButtonCurrentPieceRotateGrainlineVertical_clicked()
{
if(m_selectedPieces.count() == 1)
{
m_selectedPieces.first()->RotateToGrainline(90, true);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_pushButtonCurrentPieceRotateGrainlineHorizontal_clicked()
{
if(m_selectedPieces.count() == 1)
{
m_selectedPieces.first()->RotateToGrainline(0, true);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_doubleSpinBoxCurrentPieceAngle_valueChanged(double value)
{
if(m_selectedPieces.count() == 1)
{
VPPiece *piece = m_selectedPieces.first();
piece->SetRotation(value);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_CurrentPiecePositionEdited()
{
if(m_selectedPieces.count() == 1)
{
VPPiece *piece = m_selectedPieces.first();
QPointF pos(UnitConvertor(ui->doubleSpinBoxCurrentPieceBoxPositionX->value(), m_layout->GetUnit(), Unit::Px),
UnitConvertor(ui->doubleSpinBoxCurrentPieceBoxPositionY->value(), m_layout->GetUnit(), Unit::Px));
piece->SetPosition(pos);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_CarrouselLocationChanged(Qt::DockWidgetArea area)
{
if(area == Qt::BottomDockWidgetArea || area == Qt::TopDockWidgetArea)
{
m_carrousel->SetOrientation(Qt::Horizontal);
}
else if (area == Qt::LeftDockWidgetArea || area == Qt::RightDockWidgetArea)
{
m_carrousel->SetOrientation(Qt::Vertical);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_PieceSelectionChanged()
{
m_selectedPieces = m_layout->GetSelectedPieces();
// update the property of the piece currently selected
SetPropertyTabCurrentPieceData();
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_PiecePositionChanged()
{
if(m_selectedPieces.count() == 1)
{
VPPiece *piece = m_selectedPieces.first();
QPointF pos = piece->GetPosition();
SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionX,
UnitConvertor(pos.x(), Unit::Px, m_layout->GetUnit()));
SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionY,
UnitConvertor(pos.y(), Unit::Px, m_layout->GetUnit()));
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_PieceRotationChanged()
{
if(m_selectedPieces.count() == 1)
{
VPPiece *piece = m_selectedPieces.first();
qreal angle = piece->GetRotation();
SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceAngle, angle);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_ScaleChanged(qreal scale)
{
if (not m_doubleSpinBoxScale.isNull())
{
m_doubleSpinBoxScale->blockSignals(true);
m_doubleSpinBoxScale->setMaximum(qFloor(VPMainGraphicsView::MaxScale()*1000)/10.0);
m_doubleSpinBoxScale->setMinimum(qFloor(VPMainGraphicsView::MinScale()*1000)/10.0);
m_doubleSpinBoxScale->setValue(qFloor(scale*1000)/10.0);
m_doubleSpinBoxScale->setSingleStep(1);
m_doubleSpinBoxScale->blockSignals(false);
}
}
//---------------------------------------------------------------------------------------------------------------------
void VPMainWindow::on_MouseMoved(const QPointF &scenePos)
{
if (m_mouseCoordinate != nullptr)
{
m_mouseCoordinate->setText(QStringLiteral("%1, %2 (%3)")
.arg(static_cast<qint32>(FromPixel(scenePos.x(), m_layout->GetUnit())))
.arg(static_cast<qint32>(FromPixel(scenePos.y(), m_layout->GetUnit())))
.arg(UnitsToStr(m_layout->GetUnit(), true)));
}
}
Reference in a new issue View git blame Copy permalink