Cleaning and refactoring.

src/app/puzzle/puzzle.pri

@@ -18,11 +18,11 @@ SOURCES += \
     $$PWD/vpgraphicssheet.cpp \
     $$PWD/vpgraphicstilegrid.cpp \
     $$PWD/vplayout.cpp \
+    $$PWD/vplayoutsettings.cpp \
     $$PWD/vpmaingraphicsview.cpp \
     $$PWD/vpmainwindow.cpp \
     $$PWD/vpmimedatapiece.cpp \
     $$PWD/vppiece.cpp \
-    $$PWD/vppiecelist.cpp \
     $$PWD/vpsettings.cpp \
     $$PWD/vpsheet.cpp \
     $$PWD/vptilefactory.cpp \
@@ -49,11 +49,11 @@ HEADERS += \
     $$PWD/vpgraphicssheet.h \
     $$PWD/vpgraphicstilegrid.h \
     $$PWD/vplayout.h \
+    $$PWD/vplayoutsettings.h \
     $$PWD/vpmaingraphicsview.h \
     $$PWD/vpmainwindow.h \
     $$PWD/vpmimedatapiece.h \
     $$PWD/vppiece.h \
-    $$PWD/vppiecelist.h \
     $$PWD/vpsettings.h \
     $$PWD/vpsheet.h \
     $$PWD/vptilefactory.h \

src/app/puzzle/vpapplication.cpp

@@ -446,7 +446,7 @@ void VPApplication::ActivateDarkMode()
          {
              f.open(QFile::ReadOnly | QFile::Text);
              QTextStream ts(&f);
-             qApp->setStyleSheet(ts.readAll());
+             VPApplication::VApp()->setStyleSheet(ts.readAll());
          }
     }
 }
@@ -469,7 +469,7 @@ void VPApplication::ParseCommandLine(const SocketConnection &connection, const Q
             stream << arguments.join(";;");
             stream.flush();
             socket.waitForBytesWritten();
-            qApp->exit(V_EX_OK);
+            QCoreApplication::exit(V_EX_OK);
             return;
         }
 
@@ -548,14 +548,13 @@ void VPApplication::ProcessArguments(const VPCommandLinePtr &cmd)
         NewMainWindow(cmd);
         if (not rawLayouts.isEmpty())
         {
-//            MainWindow()->New(); // prepare layout settings
             MainWindow()->ImportRawLayouts(rawLayouts);
         }
     }
 
     if (not cmd->IsGuiEnabled())
     {
-        qApp->exit(V_EX_OK); // close program after processing in console mode
+        QCoreApplication::exit(V_EX_OK); // close program after processing in console mode
     }
 }
 

src/app/puzzle/vpcarrousel.cpp

@@ -33,7 +33,6 @@
 #include <QFontMetrics>
 
 #include "../vmisc/backport/qoverload.h"
-#include "vppiecelist.h"
 #include "vpsheet.h"
 
 #include <QLoggingCategory>
@@ -77,7 +76,7 @@ void VPCarrousel::Refresh()
             VPCarrouselSheet carrouselSheet;
             carrouselSheet.unplaced = true;
             carrouselSheet.name = tr("Unplaced pieces");
-            carrouselSheet.pieces = m_layout->GetUnplacedPieceList();
+            carrouselSheet.pieces = m_layout->GetUnplacedPieces();
 
             m_pieceLists.append(carrouselSheet);
         }
@@ -88,7 +87,7 @@ void VPCarrousel::Refresh()
             VPCarrouselSheet carrouselSheet;
             carrouselSheet.unplaced = false;
             carrouselSheet.name = sheet->GetName();
-            carrouselSheet.pieces = sheet->GetPieceList();
+            carrouselSheet.pieces = sheet->GetPieces();
 
             m_pieceLists.append(carrouselSheet);
         }
@@ -146,7 +145,7 @@ void VPCarrousel::on_ActivePieceListChanged(int index)
     }
     else
     {
-        ui->listWidget->SetCurrentPieceList(nullptr);
+        ui->listWidget->SetCurrentPieceList(QList<VPPiece *>());
     }
 }
 
@@ -183,24 +182,6 @@ void VPCarrousel::RefreshOrientation()
     }
 }
 
-//---------------------------------------------------------------------------------------------------------------------
-void VPCarrousel::ClearSelection()
-{
-    if (m_layout != nullptr)
-    {
-        m_layout->ClearSelection();
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPCarrousel::ClearSelectionExceptForCurrentPieceList()
-{
-    if (m_layout != nullptr)
-    {
-        m_layout->ClearSelectionExceptForGivenPieceList(ui->listWidget->GetCurrentPieceList());
-    }
-}
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPCarrousel::changeEvent(QEvent *event)
 {

src/app/puzzle/vpcarrousel.h

@@ -44,7 +44,7 @@ struct VPCarrouselSheet
 {
     bool unplaced{true};
     QString name{};
-    VPPieceList* pieces{nullptr};
+    QList<VPPiece *> pieces{};
 };
 
 class VPCarrousel : public QWidget
@@ -79,17 +79,6 @@ public:
      */
     void Clear();
 
-    /**
-     * @brief ClearSelection Clears the selection of the carrousel.
-     */
-    void ClearSelection();
-
-    /**
-     * @brief ClearSelectionExceptForCurrentPieceList Clears the selection of all pieces of
-     * the layout except for the one in the current piece list
-     */
-    void ClearSelectionExceptForCurrentPieceList();
-
 protected:
     virtual void changeEvent(QEvent* event) override;
 

src/app/puzzle/vpcarrouselpiecelist.cpp

@@ -37,6 +37,7 @@
 #include "vpcarrouselpiece.h"
 #include "../vmisc/backport/qoverload.h"
 #include "vpmimedatapiece.h"
+#include "vpsheet.h"
 
 #include <QLoggingCategory>
 
@@ -51,8 +52,6 @@ VPCarrouselPieceList::VPCarrouselPieceList(QWidget* parent) :
     setContextMenuPolicy(Qt::DefaultContextMenu);
     setSelectionMode(QAbstractItemView::MultiSelection);
     setViewMode(QListView::IconMode);
-
-    connect(this, &VPCarrouselPieceList::itemSelectionChanged, this, &VPCarrouselPieceList::on_SelectionChangedInternal);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -72,15 +71,10 @@ void VPCarrouselPieceList::Refresh()
 {
     clear();
 
-    if(m_pieceList != nullptr)
+    if(not m_pieceList.isEmpty())
     {
-        m_pieceList->disconnect(this);
-
-        // Updates the carrousel pieces from the pieces list
-        QList<VPPiece*> pieces = m_pieceList->GetPieces();
-
         // create the corresponding carrousel pieces
-        for (auto *piece : pieces)
+        for (auto *piece : m_pieceList)
         {
             // update the label of the piece
              auto* carrouselpiece = new VPCarrouselPiece(piece, this);
@@ -88,21 +82,11 @@ void VPCarrouselPieceList::Refresh()
              connect(piece, &VPPiece::SelectionChanged, this, &VPCarrouselPieceList::on_SelectionChangedExternal);
         }
         sortItems();
-
-        connect(m_pieceList, &VPPieceList::PieceAdded, this, &VPCarrouselPieceList::on_PieceAdded);
-        connect(m_pieceList, &VPPieceList::PieceRemoved, this, &VPCarrouselPieceList::on_PieceRemoved);
     }
 }
 
-
 //---------------------------------------------------------------------------------------------------------------------
-VPPieceList* VPCarrouselPieceList::GetCurrentPieceList()
+void VPCarrouselPieceList::SetCurrentPieceList(const QList<VPPiece *> &pieceList)
-{
-    return m_pieceList;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPCarrouselPieceList::SetCurrentPieceList(VPPieceList* pieceList)
 {
     m_pieceList = pieceList;
 
@@ -135,7 +119,7 @@ void VPCarrouselPieceList::mouseMoveEvent(QMouseEvent *event)
     if ((event->buttons() & Qt::LeftButton) &&
         ((event->pos() - m_dragStart).manhattanLength() >= QApplication::startDragDistance()) &&
         (selectedItems().count() > 0) &&
-        (m_pieceList->GetSheet() == nullptr)) // only if it's from unplaced pieces
+        (not m_pieceList.isEmpty() && m_pieceList.first()->Sheet() == nullptr)) // only if it's from unplaced pieces
     {
         startDrag(Qt::MoveAction);
     }
@@ -187,115 +171,51 @@ void VPCarrouselPieceList::dragMoveEvent(QDragMoveEvent* e)
 void VPCarrouselPieceList::contextMenuEvent(QContextMenuEvent *event)
 {
     QListWidgetItem* _item = currentItem();
-    if(_item != nullptr)
+    if(_item != nullptr && _item->type() == 1001)
-    {
-        if(_item->type() == 1001)
-        {
-            VPCarrouselPiece *pieceItem = static_cast<VPCarrouselPiece *> (_item);
-
-            QMenu contextMenu;
-
-            if(m_pieceList->GetSheet() == nullptr)
-            {
-                VPPieceList* sheetPieces = pieceItem->GetPiece()->GetPieceList()->GetLayout()->GetFocusedSheet()->GetPieceList();
-                QAction *moveAction = contextMenu.addAction(tr("Move to Sheet"));
-                QVariant moveData = QVariant::fromValue(sheetPieces);
-                moveAction->setData(moveData);
-
-                VPPieceList* trashPieceList = pieceItem->GetPiece()->GetPieceList()->GetLayout()->GetTrashPieceList();
-                QAction *deleteAction = contextMenu.addAction(tr("Delete"));
-                QVariant deleteData = QVariant::fromValue(trashPieceList);
-                deleteAction->setData(deleteData);
-
-                connect(moveAction, &QAction::triggered, this, &VPCarrouselPieceList::on_ActionPieceMovedToPieceList);
-                connect(deleteAction, &QAction::triggered, this, &VPCarrouselPieceList::on_ActionPieceMovedToPieceList);
-            }
-
-            // remove from piece list action
-            if(m_pieceList->GetSheet() != nullptr)
-            {
-                VPPieceList* unplacedPieces = pieceItem->GetPiece()->GetPieceList()->GetLayout()->GetUnplacedPieceList();
-                QAction *removeAction = contextMenu.addAction(tr("Remove from Sheet"));
-                QVariant data = QVariant::fromValue(unplacedPieces);
-                removeAction->setData(data);
-                connect(removeAction, &QAction::triggered, this, &VPCarrouselPieceList::on_ActionPieceMovedToPieceList);
-            }
-
-            contextMenu.exec(event->globalPos());
-        }
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPCarrouselPieceList::on_ActionPieceMovedToPieceList()
-{
-    QListWidgetItem* _item = currentItem();
-    if(_item->type() == 1001)
     {
         VPCarrouselPiece *pieceItem = static_cast<VPCarrouselPiece *> (_item);
-        QAction *act = qobject_cast<QAction *>(sender());
+
-        QVariant v = act->data();
+        QMenu menu;
-        VPPieceList *pieceList = v.value<VPPieceList *>();
+
-        if(pieceList != nullptr)
+        QAction *moveAction = menu.addAction(tr("Move to Sheet"));
+        moveAction->setVisible(false);
+
+        QAction *deleteAction = menu.addAction(tr("Delete"));
+        deleteAction->setVisible(false);
+
+        QAction *removeAction = menu.addAction(tr("Remove from Sheet"));
+        removeAction->setVisible(false);
+
+        if(not m_pieceList.isEmpty() && m_pieceList.first()->Sheet() == nullptr)
         {
-            pieceList->GetLayout()->MovePieceToPieceList(pieceItem->GetPiece(), pieceList);
+            moveAction->setVisible(true);
+            deleteAction->setVisible(true);
+        }
+
+        if(not m_pieceList.isEmpty() && m_pieceList.first()->Sheet() != nullptr)
+        {
+            removeAction->setVisible(true);
+        }
+
+        QAction *selectedAction = menu.exec(event->globalPos());
+
+        if (selectedAction == moveAction)
+        {
+            VPSheet *sheet = pieceItem->GetPiece()->Layout()->GetFocusedSheet();
+            pieceItem->GetPiece()->SetSheet(sheet);
+        }
+        else if (selectedAction == deleteAction)
+        {
+            VPSheet *sheet = pieceItem->GetPiece()->Layout()->GetTrashSheet();
+            pieceItem->GetPiece()->SetSheet(sheet);
+        }
+        else if (selectedAction == removeAction)
+        {
+            pieceItem->GetPiece()->SetSheet(nullptr);
         }
     }
 }
 
-//---------------------------------------------------------------------------------------------------------------------
-void VPCarrouselPieceList::on_PieceAdded(VPPiece* piece)
-{
-    if(piece->GetPieceList() == m_pieceList)
-    {
-        // update the label of the piece
-         VPCarrouselPiece* carrouselpiece = new VPCarrouselPiece(piece,this);
-         carrouselpiece->setSelected(piece->GetIsSelected());
-         connect(piece, &VPPiece::SelectionChanged, this, &VPCarrouselPieceList::on_SelectionChangedExternal);
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPCarrouselPieceList::on_PieceRemoved(VPPiece* piece)
-{
-    for(int i = 0; i < count(); ++i)
-    {
-        QListWidgetItem* _item = item(i);
-        if(_item->type() == 1001)
-        {
-            VPCarrouselPiece *itemPiece = static_cast<VPCarrouselPiece *> (_item);
-
-            if(piece == itemPiece->GetPiece())
-            {
-                delete takeItem(row(_item));
-
-                return;
-            }
-        }
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPCarrouselPieceList::on_SelectionChangedInternal()
-{
-    blockSignals(true);
-
-    for(int i = 0; i < count(); ++i)
-    {
-        QListWidgetItem* _item = item(i);
-        if(_item->type() == 1001)
-        {
-            VPCarrouselPiece *itemPiece = static_cast<VPCarrouselPiece *> (_item);
-            itemPiece->GetPiece()->SetIsSelected(itemPiece->isSelected());
-        }
-    }
-    m_carrousel->ClearSelectionExceptForCurrentPieceList();
-    // TODO FIXME:  when selecting pieces on the sheet, and then selecting a unplaced piece in the piece carrousel
-    // the selection is cleared in the sheet (good !) but the cliked item in unplaced pieces in not selected (bad!)
-
-    blockSignals(false);
-}
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPCarrouselPieceList::on_SelectionChangedExternal()
 {

src/app/puzzle/vpcarrouselpiecelist.h

@@ -30,7 +30,7 @@
 #define VPCARROUSELPIECELIST_H
 
 #include <QListWidget>
-#include "vppiecelist.h"
+
 #include "vpcarrousel.h"
 
 
@@ -46,17 +46,11 @@ public:
      */
     void Refresh();
 
-    /**
-     * @brief GetPieceList Returns the corresponding VPPieceList
-     * @return the VPPieceList
-     */
-    VPPieceList* GetCurrentPieceList();
-
     /**
      * @brief SetCurrentPieceList Sets the current piece list to the given piece list and redraw
      * the carrousel.
      */
-    void SetCurrentPieceList(VPPieceList *pieceList);
+    void SetCurrentPieceList(const QList<VPPiece *> &pieceList);
 
     /**
      * @brief SetCarrousel Sets the carrousel corresponding to the list
@@ -83,31 +77,9 @@ protected:
 private:
     Q_DISABLE_COPY(VPCarrouselPieceList)
 
-    VPPieceList *m_pieceList{nullptr};
+    QList<VPPiece *> m_pieceList{};
     QPoint m_dragStart;
     VPCarrousel *m_carrousel{nullptr};
-
-private slots:
-
-    /**
-     * @brief on_PieceUpdated This slot is called when a piece was added
-     */
-    void on_PieceAdded(VPPiece* piece);
-
-    /**
-     * @brief on_PieceUpdated This slot is called when a piece was removed
-     */
-    void on_PieceRemoved(VPPiece* piece);
-
-    /**
-     * @brief on_SelectionChangedInternal when the selection was changed inside of the carrousel
-     */
-    void on_SelectionChangedInternal();
-
-    /**
-     * @brief on_ActionPieceMovedToPieceList when a piece is moved to another piece list via a context menu
-     */
-    void on_ActionPieceMovedToPieceList();
 };
 
 #endif // VPCARROUSELPIECELIST_H

src/app/puzzle/vpexporter.cpp

@@ -43,8 +43,8 @@ void VPExporter::Export(VPLayout* layout, LayoutExportFormats format, VPMainGrap
 
         SetFileName(fileName);
 
-        QSizeF size = QSizeF(layout->GetFocusedSheet()->GetSheetSize());
+        QSizeF size = QSizeF(layout->GetFocusedSheet()->GetLayout()->LayoutSettings().GetSheetSize());
-        if(layout->GetFocusedSheet()->GetOrientation() == PageOrientation::Landscape)
+        if(layout->GetFocusedSheet()->GetLayout()->LayoutSettings().GetOrientation() == PageOrientation::Landscape)
         {
             size.transpose();
         }

src/app/puzzle/vpgraphicspiece.cpp

@@ -40,7 +40,6 @@
 #include <QApplication>
 
 #include "vppiece.h"
-#include "vppiecelist.h"
 #include "vplayout.h"
 #include "vpsheet.h"
 
@@ -394,58 +393,44 @@ void VPGraphicsPiece::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 void VPGraphicsPiece::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
 {
 
-
     // TODO/FIXME   context menu needs to be refactored
 
-    QMenu contextMenu;
+//    QMenu menu;
 
-    // move to piece list actions  -- TODO : To be tested properly when we have several piece lists
+//    // move to piece list actions  -- TODO : To be tested properly when we have several piece lists
-    QList<VPPieceList*> pieceLists =  QList<VPPieceList*>();
+//    QList<VPPieceList*> pieceLists =  QList<VPPieceList*>();
-    for(auto sheet : m_piece->GetPieceList()->GetLayout()->GetSheets())
+//    for(auto sheet : m_piece->GetPieceList()->GetLayout()->GetSheets())
-    {
+//    {
-        pieceLists.append(sheet->GetPieceList());
+//        pieceLists.append(sheet->GetPieceList());
-    }
+//    }
 
-    pieceLists.removeAll(m_piece->GetPieceList());
+//    pieceLists.removeAll(m_piece->GetPieceList());
 
-    if(pieceLists.count() > 0)
+//    if(pieceLists.count() > 0)
-    {
+//    {
-        QMenu *moveMenu = contextMenu.addMenu(tr("Move to"));
+//        QMenu *moveMenu = menu.addMenu(tr("Move to"));
 
-        // TODO order in alphabetical order
+//        // TODO order in alphabetical order
 
-        for (auto pieceList : pieceLists)
+//        for (auto pieceList : pieceLists)
-        {
+//        {
-            QAction* moveToPieceList = moveMenu->addAction(pieceList->GetName());
+//            QAction* moveToPieceList = moveMenu->addAction(pieceList->GetName());
-            QVariant data = QVariant::fromValue(pieceList);
+//            QVariant data = QVariant::fromValue(pieceList);
-            moveToPieceList->setData(data);
+//            moveToPieceList->setData(data);
 
-            connect(moveToPieceList, &QAction::triggered, this, &VPGraphicsPiece::on_ActionPieceMovedToPieceList);
+//            connect(moveToPieceList, &QAction::triggered, this, &VPGraphicsPiece::on_ActionPieceMovedToPieceList);
-        }
+//        }
-    }
+//    }
 
-    // remove from layout action
+//    // remove from layout action
-    QAction *removeAction = contextMenu.addAction(tr("Remove from Sheet"));
+//    QAction *removeAction = menu.addAction(tr("Remove from Sheet"));
-    QVariant data = QVariant::fromValue(m_piece->GetPieceList()->GetLayout()->GetUnplacedPieceList());
+//    QVariant data = QVariant::fromValue(m_piece->GetPieceList()->GetLayout()->GetUnplacedPieceList());
-    removeAction->setData(data);
+//    removeAction->setData(data);
-    connect(removeAction, &QAction::triggered, this, &VPGraphicsPiece::on_ActionPieceMovedToPieceList);
+//    connect(removeAction, &QAction::triggered, this, &VPGraphicsPiece::on_ActionPieceMovedToPieceList);
 
-    contextMenu.exec(event->screenPos());
+//    menu.exec(event->screenPos());
 }
 
-//---------------------------------------------------------------------------------------------------------------------
-void VPGraphicsPiece::on_ActionPieceMovedToPieceList()
-{
-    QAction *act = qobject_cast<QAction *>(sender());
-    QVariant v = act->data();
-    VPPieceList *pieceList = v.value<VPPieceList *>();
-    if(pieceList != nullptr)
-    {
-        pieceList->GetLayout()->MovePieceToPieceList(m_piece, pieceList);
-    }
-}
-
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPGraphicsPiece::on_PieceSelectionChanged()
 {

src/app/puzzle/vpgraphicspiece.h

@@ -84,13 +84,6 @@ protected:
 
     void contextMenuEvent(QGraphicsSceneContextMenuEvent *event) override;
 
-private slots:
-    /**
-     * @brief on_ActionPieceMovedToPieceList Slot called when the piece is moved via the
-     * context menu to anoter piece list
-     */
-    void on_ActionPieceMovedToPieceList();
-
 private:
     Q_DISABLE_COPY(VPGraphicsPiece)
     VPPiece *m_piece;

src/app/puzzle/vpgraphicssheet.cpp

@@ -72,12 +72,12 @@ void VPGraphicsSheet::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
         painter->drawRect(sheetRect);
     }
 
-    if(m_sheet->GetShowGrid())
+    if(m_sheet->GetLayout()->LayoutSettings().GetShowGrid())
     {
         pen.setColor(QColor(204,204,204));
         painter->setPen(pen);
 
-        qreal colWidth = m_sheet->GetGridColWidth();
+        qreal colWidth = m_sheet->GetLayout()->LayoutSettings().GetGridColWidth();
         if(colWidth > 0)
         {
             qreal colX = colWidth;
@@ -89,7 +89,7 @@ void VPGraphicsSheet::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
             }
         }
 
-        qreal rowHeight = m_sheet->GetGridRowHeight();
+        qreal rowHeight = m_sheet->GetLayout()->LayoutSettings().GetGridRowHeight();
         if(rowHeight > 0)
         {
             qreal rowY = rowHeight;
@@ -110,8 +110,8 @@ void VPGraphicsSheet::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
 QRectF VPGraphicsSheet::GetSheetRect() const
 {
     QPoint topLeft = QPoint(0,0);
-    QSizeF size = m_sheet->GetSheetSize();
+    QSizeF size = m_sheet->GetLayout()->LayoutSettings().GetSheetSize();
-    if(m_sheet->GetOrientation() == PageOrientation::Landscape)
+    if(m_sheet->GetLayout()->LayoutSettings().GetOrientation() == PageOrientation::Landscape)
     {
         size.transpose();
     }
@@ -122,10 +122,10 @@ QRectF VPGraphicsSheet::GetSheetRect() const
 //---------------------------------------------------------------------------------------------------------------------
 QRectF VPGraphicsSheet::GetMarginsRect() const
 {
-    QMarginsF margins = m_sheet->GetSheetMargins();
+    QMarginsF margins = m_sheet->GetLayout()->LayoutSettings().GetSheetMargins();
-    QSizeF size = m_sheet->GetSheetSize();
+    QSizeF size = m_sheet->GetLayout()->LayoutSettings().GetSheetSize();
 
-    if(m_sheet->GetOrientation() == PageOrientation::Landscape)
+    if(m_sheet->GetLayout()->LayoutSettings().GetOrientation() == PageOrientation::Landscape)
     {
         size.transpose();
     }

src/app/puzzle/vpgraphicstilegrid.cpp

@@ -21,7 +21,7 @@ VPGraphicsTileGrid::~VPGraphicsTileGrid()
 //---------------------------------------------------------------------------------------------------------------------
 QRectF VPGraphicsTileGrid::boundingRect() const
 {
-    if(m_layout->GetShowTiles())
+    if(m_layout->LayoutSettings().GetShowTiles())
     {
         return QRectF(0,
                    0,
@@ -29,10 +29,8 @@ QRectF VPGraphicsTileGrid::boundingRect() const
                    m_tileFactory->getRowNb()* m_tileFactory->getDrawingAreaHeight()
                    );
     }
-    else
+
-    {
+    return {};
-        return QRectF(0,0,0,0);
-    }
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -41,7 +39,7 @@ void VPGraphicsTileGrid::paint(QPainter *painter, const QStyleOptionGraphicsItem
     Q_UNUSED(widget);
     Q_UNUSED(option);
 
-    if(m_layout->GetShowTiles())
+    if(m_layout->LayoutSettings().GetShowTiles())
     {
         QPen pen(QColor(255,0,0,127), 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);
         pen.setCosmetic(true);

src/app/puzzle/vplayout.cpp

@@ -25,8 +25,8 @@
  **  along with Valentina.  If not, see <http://www.gnu.org/licenses/>.
  **
  *************************************************************************/
+
 #include "vplayout.h"
-#include "vppiecelist.h"
 #include "vppiece.h"
 #include "vpsheet.h"
 
@@ -36,329 +36,114 @@
 Q_LOGGING_CATEGORY(pLayout, "p.layout")
 
 //---------------------------------------------------------------------------------------------------------------------
-VPLayout::VPLayout() :
+VPLayout::VPLayout(QObject *parent) :
-    m_unplacedPieceList(new VPPieceList(this)),
+    QObject(parent),
-    m_trashPieceList(new VPPieceList(this))
+    m_trashSheet(new VPSheet(this))
-{
+{}
-    m_unplacedPieceList->SetName(tr("Unplaced pieces"));
-}
 
 //---------------------------------------------------------------------------------------------------------------------
 VPLayout::~VPLayout()
 {
-    qDeleteAll(m_sheets);
+    qDeleteAll(m_pieces);
-    delete m_unplacedPieceList;
-    delete m_trashPieceList;
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPPieceList* VPLayout::GetUnplacedPieceList()
+void VPLayout::AddPiece(VPPiece *piece)
 {
-    return m_unplacedPieceList;
+    if ((piece != nullptr) && not m_pieces.contains(piece))
+    {
+        piece->SetLayout(this);
+        m_pieces.append(piece);
+    }
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPPieceList* VPLayout::GetTrashPieceList()
+auto VPLayout::GetPieces() const -> QList<VPPiece *>
 {
-    return m_trashPieceList;
+    return m_pieces;
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPSheet* VPLayout::AddSheet()
+auto VPLayout::GetUnplacedPieces() const -> QList<VPPiece *>
 {
-    VPSheet *newSheet = new VPSheet(this);
+    return PiecesForSheet(nullptr);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayout::GetTrashedPieces() const -> QList<VPPiece *>
+{
+    return PiecesForSheet(m_trashSheet);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayout::AddSheet() -> VPSheet*
+{
+    auto *newSheet = new VPSheet(this);
     m_sheets.append(newSheet);
     return newSheet;
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPSheet* VPLayout::AddSheet(VPSheet *sheet)
+auto VPLayout::AddSheet(VPSheet *sheet) -> VPSheet*
 {
-    m_sheets.append(sheet);
+    if ((sheet != nullptr) && not m_sheets.contains(sheet))
+    {
+        sheet->setParent(this);
+        m_sheets.append(sheet);
+    }
     return sheet;
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-QList<VPSheet *> VPLayout::GetSheets()
+auto VPLayout::GetSheets() -> QList<VPSheet *>
 {
     return m_sheets;
 }
 
-//---------------------------------------------------------------------------------------------------------------------
-QList<VPPiece *> VPLayout::GetSelectedPieces()
-{
-    QList<VPPiece *> result = QList<VPPiece *>();
-
-    QList<VPPieceList *> pieceLists = QList<VPPieceList *>();
-    pieceLists.append(m_unplacedPieceList);
-    for (auto *sheet : m_sheets)
-    {
-        pieceLists.append(sheet->GetPieceList());
-    }
-
-    for (auto *pieceList : pieceLists)
-    {
-        for (auto *piece : pieceList->GetPieces())
-        {
-            if(piece->GetIsSelected())
-            {
-                result.append(piece);
-            }
-        }
-    }
-
-    return result;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetUnit(Unit unit)
-{
-    m_unit = unit;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-Unit VPLayout::GetUnit() const
-{
-    return m_unit;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetWarningSuperpositionOfPieces(bool state)
-{
-    m_warningSuperpositionOfPieces = state;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-bool VPLayout::GetWarningSuperpositionOfPieces() const
-{
-    return m_warningSuperpositionOfPieces;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetWarningPiecesOutOfBound(bool state)
-{
-    m_warningPiecesOutOfBound = state;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-bool VPLayout::GetWarningPiecesOutOfBound() const
-{
-    return m_warningPiecesOutOfBound;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTitle(const QString &title)
-{
-    m_title = title;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QString VPLayout::GetTitle() const
-{
-    return m_title;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetDescription(const QString &description)
-{
-    m_description = description;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QString VPLayout::GetDescription() const
-{
-    return m_description;
-}
-
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::ClearSelection()
-{
-    m_unplacedPieceList->ClearSelection();
-
-    for (auto *sheet : m_sheets)
-    {
-        sheet->ClearSelection();
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::ClearSelectionExceptForGivenPieceList(VPPieceList* pieceList)
-{
-    if(m_unplacedPieceList != pieceList)
-    {
-        m_unplacedPieceList->ClearSelection();
-    }
-
-    for (auto *sheet : m_sheets)
-    {
-        if(sheet->GetPieceList() != pieceList)
-        {
-            sheet->ClearSelection();
-        }
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::MovePieceToPieceList(VPPiece* piece, VPPieceList* pieceList)
-{
-    VPPieceList* pieceListBefore = piece->GetPieceList();
-
-    if(pieceListBefore != nullptr)
-    {
-        piece->GetPieceList()->RemovePiece(piece);
-    }
-    pieceList->AddPiece(piece);
-
-    // signal, that a piece was moved
-    emit PieceMovedToPieceList(piece, pieceListBefore, pieceList);
-}
-
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPLayout::SetFocusedSheet(VPSheet *focusedSheet)
 {
-    if(focusedSheet == nullptr)
+    if (m_sheets.isEmpty())
     {
-        m_focusedSheet = m_sheets.first();
+        m_focusedSheet = nullptr;
     }
     else
     {
-        m_focusedSheet = focusedSheet;
+        m_focusedSheet = focusedSheet == nullptr ? m_sheets.first() : focusedSheet;
     }
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPSheet* VPLayout::GetFocusedSheet()
+auto VPLayout::GetFocusedSheet() -> VPSheet*
 {
     return m_focusedSheet;
 }
 
-
 //---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTilesSize(qreal width, qreal height)
+auto VPLayout::GetTrashSheet() -> VPSheet*
 {
-    m_tilesSize.setWidth(width);
+    return m_trashSheet;
-    m_tilesSize.setHeight(height);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTilesSizeConverted(qreal width, qreal height)
+auto VPLayout::LayoutSettings() -> VPLayoutSettings &
 {
-    m_tilesSize.setWidth(UnitConvertor(width, GetUnit(), Unit::Px));
+    return m_layoutSettings;
-    m_tilesSize.setHeight(UnitConvertor(height, GetUnit(), Unit::Px));
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTilesSize(const QSizeF &size)
+auto VPLayout::PiecesForSheet(const VPSheet *sheet) const -> QList<VPPiece *>
 {
-    m_tilesSize = size;
+    QList<VPPiece *> list;
-}
+    list.reserve(m_pieces.size());
 
-//---------------------------------------------------------------------------------------------------------------------
+    for (auto *piece : m_pieces)
-void VPLayout::SetTilesSizeConverted(const QSizeF &size)
-{
-    m_tilesSize = QSizeF(
-                UnitConvertor(size.width(), GetUnit(), Unit::Px),
-                UnitConvertor(size.height(), GetUnit(), Unit::Px)
-                );
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QSizeF VPLayout::GetTilesSize() const
-{
-    return m_tilesSize;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QSizeF VPLayout::GetTilesSize(Unit unit) const
-{
-    QSizeF convertedSize = QSizeF(
-                UnitConvertor(m_tilesSize.width(), Unit::Px, unit),
-                UnitConvertor(m_tilesSize.height(), Unit::Px, unit)
-                );
-
-    return convertedSize;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QSizeF VPLayout::GetTilesSizeConverted() const
-{
-    return GetTilesSize(GetUnit());
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-PageOrientation VPLayout::GetTilesOrientation()
-{
-    return m_tilesOrientation;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTilesOrientation(PageOrientation orientation)
-{
-    if(orientation != m_tilesOrientation)
     {
-        m_tilesOrientation = orientation;
+        if ((piece != nullptr) && piece->Sheet() == sheet)
+        {
+            list.append(piece);
+        }
     }
-}
 
-//---------------------------------------------------------------------------------------------------------------------
+    return list;
-void VPLayout::SetTilesMargins(qreal left, qreal top, qreal right, qreal bottom)
-{
-    m_tilesMargins.setLeft(left);
-    m_tilesMargins.setTop(top);
-    m_tilesMargins.setRight(right);
-    m_tilesMargins.setBottom(bottom);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTilesMarginsConverted(qreal left, qreal top, qreal right, qreal bottom)
-{
-    m_tilesMargins.setLeft(UnitConvertor(left, GetUnit(), Unit::Px));
-    m_tilesMargins.setTop(UnitConvertor(top, GetUnit(), Unit::Px));
-    m_tilesMargins.setRight(UnitConvertor(right, GetUnit(), Unit::Px));
-    m_tilesMargins.setBottom(UnitConvertor(bottom, GetUnit(), Unit::Px));
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTilesMargins(const QMarginsF &margins)
-{
-    m_tilesMargins = margins;
-}
-
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetTilesMarginsConverted(const QMarginsF &margins)
-{
-    m_tilesMargins = UnitConvertor(margins, GetUnit(), Unit::Px);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QMarginsF VPLayout::GetTilesMargins() const
-{
-    return m_tilesMargins;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QMarginsF VPLayout::GetTilesMargins(Unit unit) const
-{
-    return UnitConvertor(m_tilesMargins, Unit::Px, unit);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QMarginsF VPLayout::GetTilesMarginsConverted() const
-{
-    return UnitConvertor(m_tilesMargins, Unit::Px, GetUnit());
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-bool VPLayout::GetShowTiles()
-{
-    return m_showTiles;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayout::SetShowTiles(bool value)
-{
-    m_showTiles = value;
 }

src/app/puzzle/vplayout.h

@@ -28,12 +28,11 @@
 #ifndef VPLAYOUT_H
 #define VPLAYOUT_H
 
-
 #include <QList>
 
 #include "def.h"
+#include "vplayoutsettings.h"
 
-class VPPieceList;
 class VPPiece;
 class VPSheet;
 
@@ -41,93 +40,17 @@ class VPLayout : public QObject
 {
     Q_OBJECT
 public:
-    VPLayout();
+    explicit VPLayout(QObject *parent=nullptr);
     virtual ~VPLayout();
 
-    /**
+    void AddPiece(VPPiece *piece);
-     * @brief GetUnplacedPieceList Returns the piece list of unplaced pieces
+    auto GetPieces() const -> QList<VPPiece *>;
-     * @return the unplaced pieces list
+    auto GetUnplacedPieces() const -> QList<VPPiece *>;
-     */
+    auto GetTrashedPieces() const -> QList<VPPiece *>;
-    VPPieceList* GetUnplacedPieceList();
 
-    /**
+    auto AddSheet() -> VPSheet*;
-     * @brief GetTrashPieceList Returns the piece list of the trash
+    auto AddSheet(VPSheet *sheet) -> VPSheet*;
-     * @return the pieces list of trashed pieces.
+    auto GetSheets() -> QList<VPSheet *>;
-     */
-    VPPieceList* GetTrashPieceList();
-
-    VPSheet* AddSheet();
-    VPSheet* AddSheet(VPSheet *sheet);
-    QList<VPSheet *> GetSheets();
-
-    /**
-     * @brief GetSelectedPieces Returns the list of the selected pieces
-     * @return the selected pieces
-     */
-    QList<VPPiece *> GetSelectedPieces();
-
-    /**
-     * @brief SetUnit Sets the unit of the layout to the given unit
-     * @param unit the new unit
-     */
-    void SetUnit(Unit unit);
-
-    /**
-     * @brief GetUnit Returns the current unit of the layout
-     * @return the unit
-     */
-    Unit GetUnit() const;
-
-    void SetWarningSuperpositionOfPieces(bool state);
-    bool GetWarningSuperpositionOfPieces() const;
-
-    void SetWarningPiecesOutOfBound(bool state);
-    bool GetWarningPiecesOutOfBound() const;
-
-    /**
-     * @brief SetTitle Sets the title of the layout to the given value
-     * @param title the title of the layout
-     */
-    void SetTitle(const QString &title);
-
-    /**
-     * @brief GetTitle Returns the title of the layout
-     * @return title of the layout
-     */
-    QString GetTitle() const;
-
-    /**
-     * @brief SetDescription Sets the description of the layout to the given value
-     * @param description the description of the layout
-     */
-    void SetDescription(const QString &description);
-
-    /**
-     * @brief GetDescription Returns the description of the layout.
-     * @return description of the layout
-     */
-    QString GetDescription() const;
-
-    /**
-     * @brief ClearSelection goes through the unplaced pieces and through the sheets and calls
-     * SetIsSelected(false) for the pieces that were selected.
-     */
-    void ClearSelection();
-
-    /**
-     * @brief ClearSelectionExceptForPieceList same as clearSelection but it leaves the selection
-     * for the given piece list like it ist.
-     *
-     * @param pieceList the piece list to let be the way it is.
-     */
-    void ClearSelectionExceptForGivenPieceList(VPPieceList* pieceList);
-
-    /**
-     * @brief MovePieceToPieceList Moves the given piece to the given piece list
-     * @param piece the piece to move
-     * @param pieceList the piece list to move the piece to
-     */
-    void MovePieceToPieceList(VPPiece* piece, VPPieceList* pieceList);
 
     /**
      * @brief SetFocusedSheet Sets the focused sheet, to which pieces are added from the carrousel via drag
@@ -141,171 +64,25 @@ public:
      * and drop
      * @return the focused sheet
      */
-    VPSheet* GetFocusedSheet();
+    auto GetFocusedSheet() -> VPSheet*;
 
+    auto GetTrashSheet() -> VPSheet*;
 
-    /**
+    auto LayoutSettings() -> VPLayoutSettings &;
-     * @brief SetTilesSize sets the size of the tiles, the values have to be in Unit::Px
-     * @param width tiles width
-     * @param height tiles height
-     */
-    void SetTilesSize(qreal width, qreal height);
 
-    /**
+    auto PiecesForSheet(const VPSheet* sheet) const -> QList<VPPiece *>;
-     * @brief SetTilesSizeConverted sets the size of the sheet, the values have to be in the layout's unit
-     * @param width tiles width
-     * @param height tiles height
-     */
-    void SetTilesSizeConverted(qreal width, qreal height);
-
-    /**
-     * @brief SetTilesSize sets the size of the tiles, the values have to be in Unit::Px
-     * @param size tiles size
-     */
-    void SetTilesSize(const QSizeF &size);
-    /**
-     * @brief SetTilesSizeConverted sets the size of the tiles, the values have to be in the layout's unit
-     * @param size tiles size
-     */
-    void SetTilesSizeConverted(const QSizeF &size);
-
-    /**
-     * @brief GetTilesSize Returns the size of the tiles in Unit::Px
-     * @return tiles size in Unit::Px
-     */
-    QSizeF GetTilesSize() const;
-
-    /**
-     * @brief GetTilesSize Returns the size of the tiles in given Unit
-     * @return tiles size
-     */
-    QSizeF GetTilesSize(Unit unit) const;
-
-    /**
-     * @brief GetTilesSizeConverted Returns the size of the tiles in the layout's unit
-     * @return the size in the layout's unit
-     */
-    QSizeF GetTilesSizeConverted() const;
-
-    /**
-     * @brief GetOrientation Returns the orientation of the tiles
-     * @return orientation of the tiles
-     */
-    PageOrientation GetTilesOrientation();
-
-    /**
-     * @brief SetOrientation Sets the orientation of the tiles to the given value
-     * @param orientation the new tiles orientation
-     */
-    void SetTilesOrientation(PageOrientation orientation);
-
-    /**
-     * @brief SetTilesMargins, set the margins of the tiles, the values have to be in Unit::Px
-     * @param left in Unit::Px
-     * @param top in Unit::Px
-     * @param right in Unit::Px
-     * @param bottom in Unit::Px
-     */
-    void SetTilesMargins(qreal left, qreal top, qreal right, qreal bottom);
-
-    /**
-     * @brief SetSheetMargins, set the margins of the tiles, the values have to be in the unit of the layout
-     * @param left in Unit::Px
-     * @param top in Unit::Px
-     * @param right in Unit::Px
-     * @param bottom in Unit::Px
-     */
-    void SetTilesMarginsConverted(qreal left, qreal top, qreal right, qreal bottom);
-
-    /**
-     * @brief SetTilesMargins set the margins of the tiles, the values have to be in Unit::Px
-     * @param margins tiles margins
-     */
-    void SetTilesMargins(const QMarginsF &margins);
-
-    /**
-     * @brief SetTilesMarginsConverted set the margins of the tiles, the values have to be in the unit of the layout
-     * @param margins tiles margins
-     */
-    void SetTilesMarginsConverted(const QMarginsF &margins);
-
-    /**
-     * @brief GetTilesMargins Returns margins of the tiles in Unit::Px
-     * @return the margins in Unit::Px
-     */
-    QMarginsF GetTilesMargins() const;
-
-    /**
-     * @brief GetTilesMargins Returns margins of the tiles in the given unit
-     * @param unit the unit in which we want the margins
-     * @return the margins in the given unit
-     */
-    QMarginsF GetTilesMargins(Unit unit) const;
-
-    /**
-     * @brief GetTilesMarginsConverted Returns the margins of the tiles in the layout's unit
-     * @return the margins in the tiles's unit
-     */
-    QMarginsF GetTilesMarginsConverted() const;
-
-    /**
-     * @brief GetShowTiles Returns true if the tiles has to be shown on the current sheet
-     * @return true if the tiles has to be shown on the current sheet
-     */
-    bool GetShowTiles();
-
-    /**
-     * @brief SetShowTiles Sets wether to show the tiles on the current sheet or not
-     * @param value true to show the tiles
-     */
-    void SetShowTiles(bool value);
-
-
-
-signals:
-
-    void PieceMovedToPieceList(VPPiece *piece, VPPieceList *pieceListBefore, VPPieceList *pieceListAfter);
 
 private:
     Q_DISABLE_COPY(VPLayout)
 
-    VPPieceList *m_unplacedPieceList;
+    QList<VPPiece *> m_pieces{};
 
-    /**
+    VPSheet* m_trashSheet;
-     * @brief m_trashPieceList Holds the pieces that were deleted
-     */
-    VPPieceList *m_trashPieceList;
 
     QList<VPSheet*> m_sheets{};
     VPSheet *m_focusedSheet{nullptr};
 
-    // format
+    VPLayoutSettings m_layoutSettings{};
-    Unit m_unit{Unit::Cm};
-
-    bool m_warningSuperpositionOfPieces{false};
-    bool m_warningPiecesOutOfBound{false};
-
-    QString m_title{};
-    QString m_description{};
-
-
-    /**
-     * @brief m_size the Size of the tiles in Unit::Px
-     */
-    QSizeF m_tilesSize{};
-
-    /**
-     * @brief holds the orientation of the tiles
-     */
-    PageOrientation m_tilesOrientation {PageOrientation::Portrait};
-
-    // margins
-    /**
-     * @brief m_margins the margins of the tiles in Unit::Px
-     */
-    QMarginsF m_tilesMargins{};
-
-    bool m_showTiles{false};
 };
 
 #endif // VPLAYOUT_H

src/app/puzzle/vplayoutsettings.cpp

@@ -0,0 +1,672 @@
+/************************************************************************
+ **
+ **  @file   vplayoutsettings.cpp
+ **  @author Roman Telezhynskyi <dismine(at)gmail.com>
+ **  @date   29 7, 2021
+ **
+ **  @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) 2021 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 "vplayoutsettings.h"
+
+#include <QComboBox>
+#include <QIcon>
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetUnit(Unit unit)
+{
+    m_unit = unit;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetUnit() const -> Unit
+{
+    return m_unit;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetWarningSuperpositionOfPieces(bool state)
+{
+    m_warningSuperpositionOfPieces = state;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetWarningSuperpositionOfPieces() const -> bool
+{
+    return m_warningSuperpositionOfPieces;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetWarningPiecesOutOfBound(bool state)
+{
+    m_warningPiecesOutOfBound = state;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetWarningPiecesOutOfBound() const -> bool
+{
+    return m_warningPiecesOutOfBound;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTitle(const QString &title)
+{
+    m_title = title;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTitle() const -> QString
+{
+    return m_title;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetDescription(const QString &description)
+{
+    m_description = description;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetDescription() const -> QString
+{
+    return m_description;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesSize(qreal width, qreal height)
+{
+    m_tilesSize.setWidth(width);
+    m_tilesSize.setHeight(height);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesSizeConverted(qreal width, qreal height)
+{
+    m_tilesSize.setWidth(UnitConvertor(width, GetUnit(), Unit::Px));
+    m_tilesSize.setHeight(UnitConvertor(height, GetUnit(), Unit::Px));
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesSize(const QSizeF &size)
+{
+    m_tilesSize = size;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesSizeConverted(const QSizeF &size)
+{
+    m_tilesSize = QSizeF(
+                UnitConvertor(size.width(), GetUnit(), Unit::Px),
+                UnitConvertor(size.height(), GetUnit(), Unit::Px)
+                );
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTilesSize() const -> QSizeF
+{
+    return m_tilesSize;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTilesSize(Unit unit) const -> QSizeF
+{
+    QSizeF convertedSize = QSizeF(
+                UnitConvertor(m_tilesSize.width(), Unit::Px, unit),
+                UnitConvertor(m_tilesSize.height(), Unit::Px, unit)
+                );
+
+    return convertedSize;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTilesSizeConverted() const -> QSizeF
+{
+    return GetTilesSize(GetUnit());
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTilesOrientation() -> PageOrientation
+{
+    return m_tilesOrientation;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesOrientation(PageOrientation orientation)
+{
+    if(orientation != m_tilesOrientation)
+    {
+        m_tilesOrientation = orientation;
+    }
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesMargins(qreal left, qreal top, qreal right, qreal bottom)
+{
+    m_tilesMargins.setLeft(left);
+    m_tilesMargins.setTop(top);
+    m_tilesMargins.setRight(right);
+    m_tilesMargins.setBottom(bottom);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesMarginsConverted(qreal left, qreal top, qreal right, qreal bottom)
+{
+    m_tilesMargins.setLeft(UnitConvertor(left, GetUnit(), Unit::Px));
+    m_tilesMargins.setTop(UnitConvertor(top, GetUnit(), Unit::Px));
+    m_tilesMargins.setRight(UnitConvertor(right, GetUnit(), Unit::Px));
+    m_tilesMargins.setBottom(UnitConvertor(bottom, GetUnit(), Unit::Px));
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesMargins(const QMarginsF &margins)
+{
+    m_tilesMargins = margins;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetTilesMarginsConverted(const QMarginsF &margins)
+{
+    m_tilesMargins = UnitConvertor(margins, GetUnit(), Unit::Px);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTilesMargins() const -> QMarginsF
+{
+    return m_tilesMargins;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTilesMargins(Unit unit) const -> QMarginsF
+{
+    return UnitConvertor(m_tilesMargins, Unit::Px, unit);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTilesMarginsConverted() const -> QMarginsF
+{
+    return UnitConvertor(m_tilesMargins, Unit::Px, GetUnit());
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetShowTiles() const -> bool
+{
+    return m_showTiles;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetShowTiles(bool value)
+{
+    m_showTiles = value;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTemplateSize(PaperSizeTemplate tmpl) -> QSizeF
+{
+    qreal height = 0;
+    qreal width = 0;
+
+    switch (tmpl)
+    {
+        case PaperSizeTemplate::A0:
+            width = UnitConvertor(841, Unit::Mm, Unit::Px);
+            height = UnitConvertor(1189, Unit::Mm, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::A1:
+            width = UnitConvertor(594, Unit::Mm, Unit::Px);
+            height = UnitConvertor(841, Unit::Mm, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::A2:
+            width = UnitConvertor(420, Unit::Mm, Unit::Px);
+            height = UnitConvertor(594, Unit::Mm, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::A3:
+            width = UnitConvertor(297, Unit::Mm, Unit::Px);
+            height = UnitConvertor(420, Unit::Mm, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::A4:
+            width = UnitConvertor(210, Unit::Mm, Unit::Px);
+            height = UnitConvertor(297, Unit::Mm, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Letter:
+            width = UnitConvertor(8.5, Unit::Inch, Unit::Px);
+            height = UnitConvertor(11, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Legal:
+            width = UnitConvertor(8.5, Unit::Inch, Unit::Px);
+            height = UnitConvertor(14, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Tabloid:
+            width = UnitConvertor(11, Unit::Inch, Unit::Px);
+            height = UnitConvertor(17, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll24in:
+            width = UnitConvertor(24, Unit::Inch, Unit::Px);
+            height = UnitConvertor(48, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll30in:
+            width = UnitConvertor(30, Unit::Inch, Unit::Px);
+            height = UnitConvertor(60, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll36in:
+            width = UnitConvertor(36, Unit::Inch, Unit::Px);
+            height = UnitConvertor(72, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll42in:
+            width = UnitConvertor(42, Unit::Inch, Unit::Px);
+            height = UnitConvertor(84, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll44in:
+            width = UnitConvertor(44, Unit::Inch, Unit::Px);
+            height = UnitConvertor(88, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll48in:
+            width = UnitConvertor(48, Unit::Inch, Unit::Px);
+            height = UnitConvertor(96, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll62in:
+            width = UnitConvertor(62, Unit::Inch, Unit::Px);
+            height = UnitConvertor(124, Unit::Inch, Unit::Px);
+        break;
+
+        case PaperSizeTemplate::Roll72in:
+            width = UnitConvertor(72, Unit::Inch, Unit::Px);
+            height = UnitConvertor(144, Unit::Inch, Unit::Px);
+        break;
+
+        default:
+            break;
+    }
+
+    return QSizeF(width, height);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTemplateName(PaperSizeTemplate tmpl) -> QString
+{
+    QString tmplName;
+    switch (tmpl)
+    {
+        case PaperSizeTemplate::A0:
+            tmplName = QString("A0");
+        break;
+
+        case PaperSizeTemplate::A1:
+            tmplName = QString("A1");
+        break;
+
+        case PaperSizeTemplate::A2:
+            tmplName = QString("A2");
+        break;
+
+        case PaperSizeTemplate::A3:
+            tmplName = QString("A3");
+        break;
+
+        case PaperSizeTemplate::A4:
+            tmplName = QString("A4");
+        break;
+
+        case PaperSizeTemplate::Letter:
+            tmplName = tr("Letter");
+        break;
+
+        case PaperSizeTemplate::Legal:
+            tmplName = tr("Legal");
+        break;
+
+        case PaperSizeTemplate::Tabloid:
+            tmplName = tr("Tabloid");
+        break;
+
+        case PaperSizeTemplate::Roll24in:
+            tmplName = tr("Roll 24in");
+        break;
+
+        case PaperSizeTemplate::Roll30in:
+            tmplName = tr("Roll 30in");
+        break;
+
+        case PaperSizeTemplate::Roll36in:
+            tmplName = tr("Roll 36in");
+        break;
+
+        case PaperSizeTemplate::Roll42in:
+            tmplName = tr("Roll 42in");
+        break;
+
+        case PaperSizeTemplate::Roll44in:
+            tmplName = tr("Roll 44in");
+        break;
+
+        case PaperSizeTemplate::Roll48in:
+            tmplName = tr("Roll 48in");
+        break;
+
+        case PaperSizeTemplate::Roll62in:
+            tmplName = tr("Roll 62in");
+        break;
+
+        case PaperSizeTemplate::Roll72in:
+            tmplName = tr("Roll 72in");
+        break;
+
+        case PaperSizeTemplate::Custom:
+            tmplName = tr("Custom");
+        break;
+
+        default:
+            break;
+    }
+
+    if(not tmplName.isEmpty())
+    {
+        tmplName += " " + QStringLiteral("(%1ppi)").arg(PrintDPI);
+    }
+
+    return tmplName;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetTemplate(QSizeF size) -> PaperSizeTemplate
+{
+    Q_UNUSED(size);
+    // TODO, float comparision not safe and problems with
+    // inch / cm
+
+//    const int max = static_cast<int>(PaperSizeTemplate::Custom);
+
+//    for (int i=0; i < max; i++)
+//    {
+//        PaperSizeTemplate tmpl = static_cast<PaperSizeTemplate>(i);
+//        const QSizeF tmplSize = GetTemplateSize(tmpl);
+
+//        if(size.width() == tmplSize.width())
+//        {
+//            if(isRollTemplate(tmpl))
+//            {
+//                return tmpl;
+//            }
+//            else if(size.height() == tmplSize.height())
+//            {
+//                return tmpl;
+//            }
+//        }
+//    }
+
+    return PaperSizeTemplate::Custom;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::isRollTemplate(PaperSizeTemplate tmpl) -> bool
+{
+    switch (tmpl) {
+        case PaperSizeTemplate::Roll24in:
+        case PaperSizeTemplate::Roll30in:
+        case PaperSizeTemplate::Roll36in:
+        case PaperSizeTemplate::Roll42in:
+        case PaperSizeTemplate::Roll44in:
+        case PaperSizeTemplate::Roll48in:
+        case PaperSizeTemplate::Roll62in:
+        case PaperSizeTemplate::Roll72in:
+            return true;
+        default:
+            return false;
+    }
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::PopulateComboBox(QVector<PaperSizeTemplate> *tmpls, QComboBox* comboBox)
+{
+    const QIcon icoPaper("://puzzleicon/16x16/template.png");
+    const QIcon icoRoll("://puzzleicon/16x16/roll.png");
+
+    QIcon icon;
+    for (auto tmpl : *tmpls)
+    {
+        icon = (isRollTemplate(tmpl))? icoRoll : icoPaper;
+        comboBox->addItem(icon, GetTemplateName(tmpl), QVariant(static_cast<int>(tmpl)));
+    }
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetSize(qreal width, qreal height)
+{
+    m_size.setWidth(width);
+    m_size.setHeight(height);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetSizeConverted(qreal width, qreal height)
+{
+    m_size.setWidth(UnitConvertor(width, m_unit, Unit::Px));
+    m_size.setHeight(UnitConvertor(height, m_unit, Unit::Px));
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetSize(const QSizeF &size)
+{
+    m_size = size;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetSizeConverted(const QSizeF &size)
+{
+    m_size = QSizeF(
+                UnitConvertor(size.width(), m_unit, Unit::Px),
+                UnitConvertor(size.height(), m_unit, Unit::Px)
+                );
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetSheetSize() const -> QSizeF
+{
+    return m_size;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetSheetSizeConverted() const -> QSizeF
+{
+    QSizeF convertedSize = QSizeF(
+                UnitConvertor(m_size.width(), Unit::Px, m_unit),
+                UnitConvertor(m_size.height(), Unit::Px, m_unit)
+                );
+
+    return convertedSize;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetOrientation() -> PageOrientation
+{
+    return m_orientation;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetOrientation(PageOrientation orientation)
+{
+    if(orientation != m_orientation)
+    {
+        m_orientation = orientation;
+    }
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetMargins(qreal left, qreal top, qreal right, qreal bottom)
+{
+    m_margins.setLeft(left);
+    m_margins.setTop(top);
+    m_margins.setRight(right);
+    m_margins.setBottom(bottom);
+}
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetMarginsConverted(qreal left, qreal top, qreal right, qreal bottom)
+{
+    m_margins.setLeft(UnitConvertor(left, m_unit, Unit::Px));
+    m_margins.setTop(UnitConvertor(top, m_unit, Unit::Px));
+    m_margins.setRight(UnitConvertor(right, m_unit, Unit::Px));
+    m_margins.setBottom(UnitConvertor(bottom, m_unit, Unit::Px));
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetMargins(const QMarginsF &margins)
+{
+    m_margins = margins;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetSheetMarginsConverted(const QMarginsF &margins)
+{
+    m_margins = UnitConvertor(margins, m_unit, Unit::Px);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetSheetMargins() const -> QMarginsF
+{
+    return m_margins;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetSheetMarginsConverted() const -> QMarginsF
+{
+    return UnitConvertor(m_margins, Unit::Px, m_unit);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetFollowGrainline(FollowGrainline state)
+{
+    m_followGrainLine = state;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetFollowGrainline() const -> FollowGrainline
+{
+    return m_followGrainLine;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetPiecesGap(qreal value)
+{
+    m_piecesGap = value;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetPiecesGapConverted(qreal value)
+{
+    m_piecesGap = UnitConvertor(value, m_unit, Unit::Px);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetPiecesGap() const -> qreal
+{
+    return m_piecesGap;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetPiecesGapConverted() const -> qreal
+{
+    return UnitConvertor(m_piecesGap, Unit::Px, m_unit);
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetStickyEdges(bool state)
+{
+    m_stickyEdges = state;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetStickyEdges() const -> bool
+{
+    return m_stickyEdges;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetShowGrid() const -> bool
+{
+    return m_showGrid;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetShowGrid(bool value)
+{
+    m_showGrid = value;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetGridColWidth() const -> qreal
+{
+    return m_gridColWidth;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetGridColWidthConverted() const -> qreal
+{
+    return UnitConvertor(m_gridColWidth, Unit::Px, m_unit);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetGridColWidth(qreal value)
+{
+    m_gridColWidth = value;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetGridColWidthConverted(qreal value)
+{
+    m_gridColWidth = UnitConvertor(value, m_unit, Unit::Px);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetGridRowHeight() const -> qreal
+{
+    return m_gridRowHeight;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VPLayoutSettings::GetGridRowHeightConverted() const -> qreal
+{
+    return UnitConvertor(m_gridRowHeight, Unit::Px, m_unit);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetGridRowHeight(qreal value)
+{
+    m_gridRowHeight = value;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPLayoutSettings::SetGridRowHeightConverted(qreal value)
+{
+    m_gridRowHeight = UnitConvertor(value, m_unit, Unit::Px);
+}

src/app/puzzle/vplayoutsettings.h

@@ -0,0 +1,524 @@
+/************************************************************************
+ **
+ **  @file   vplayoutsettings.h
+ **  @author Roman Telezhynskyi <dismine(at)gmail.com>
+ **  @date   29 7, 2021
+ **
+ **  @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) 2021 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/>.
+ **
+ *************************************************************************/
+#ifndef VPLAYOUTSETTINGS_H
+#define VPLAYOUTSETTINGS_H
+
+#include <QMarginsF>
+#include <QSizeF>
+#include <QString>
+#include <QCoreApplication>
+
+#include "def.h"
+
+enum class FollowGrainline : qint8 {
+    No = 0,
+    Follow90 = 1,
+    Follow180 = 2
+};
+
+enum class PaperSizeTemplate : qint8 {
+    A0 = 0,
+    A1,
+    A2,
+    A3,
+    A4,
+    Letter,
+    Legal,
+    Tabloid,
+    Roll24in,
+    Roll30in,
+    Roll36in,
+    Roll42in,
+    Roll44in,
+    Roll48in,
+    Roll62in,
+    Roll72in,
+    Custom
+};
+
+class VPLayoutSettings
+{
+    Q_DECLARE_TR_FUNCTIONS(VPLayoutSettings)
+public:
+    VPLayoutSettings() = default;
+
+    /**
+     * @brief SetUnit Sets the unit of the layout to the given unit
+     * @param unit the new unit
+     */
+    void SetUnit(Unit unit);
+
+    /**
+     * @brief GetUnit Returns the current unit of the layout
+     * @return the unit
+     */
+    auto GetUnit() const -> Unit;
+
+    void SetWarningSuperpositionOfPieces(bool state);
+    auto GetWarningSuperpositionOfPieces() const -> bool;
+
+    void SetWarningPiecesOutOfBound(bool state);
+    auto GetWarningPiecesOutOfBound() const -> bool;
+
+    /**
+     * @brief SetTitle Sets the title of the layout to the given value
+     * @param title the title of the layout
+     */
+    void SetTitle(const QString &title);
+
+    /**
+     * @brief GetTitle Returns the title of the layout
+     * @return title of the layout
+     */
+    auto GetTitle() const -> QString;
+
+    /**
+     * @brief SetDescription Sets the description of the layout to the given value
+     * @param description the description of the layout
+     */
+    void SetDescription(const QString &description);
+
+    /**
+     * @brief GetDescription Returns the description of the layout.
+     * @return description of the layout
+     */
+    auto GetDescription() const -> QString;
+
+    /**
+     * @brief SetTilesSize sets the size of the tiles, the values have to be in Unit::Px
+     * @param width tiles width
+     * @param height tiles height
+     */
+    void SetTilesSize(qreal width, qreal height);
+
+    /**
+     * @brief SetTilesSizeConverted sets the size of the sheet, the values have to be in the layout's unit
+     * @param width tiles width
+     * @param height tiles height
+     */
+    void SetTilesSizeConverted(qreal width, qreal height);
+
+    /**
+     * @brief SetTilesSize sets the size of the tiles, the values have to be in Unit::Px
+     * @param size tiles size
+     */
+    void SetTilesSize(const QSizeF &size);
+    /**
+     * @brief SetTilesSizeConverted sets the size of the tiles, the values have to be in the layout's unit
+     * @param size tiles size
+     */
+    void SetTilesSizeConverted(const QSizeF &size);
+
+    /**
+     * @brief GetTilesSize Returns the size of the tiles in Unit::Px
+     * @return tiles size in Unit::Px
+     */
+    auto GetTilesSize() const -> QSizeF;
+
+    /**
+     * @brief GetTilesSize Returns the size of the tiles in given Unit
+     * @return tiles size
+     */
+    auto GetTilesSize(Unit unit) const -> QSizeF;
+
+    /**
+     * @brief GetTilesSizeConverted Returns the size of the tiles in the layout's unit
+     * @return the size in the layout's unit
+     */
+    auto GetTilesSizeConverted() const -> QSizeF;
+
+    /**
+     * @brief GetOrientation Returns the orientation of the tiles
+     * @return orientation of the tiles
+     */
+    auto GetTilesOrientation() -> PageOrientation;
+
+    /**
+     * @brief SetOrientation Sets the orientation of the tiles to the given value
+     * @param orientation the new tiles orientation
+     */
+    void SetTilesOrientation(PageOrientation orientation);
+
+    /**
+     * @brief SetTilesMargins, set the margins of the tiles, the values have to be in Unit::Px
+     * @param left in Unit::Px
+     * @param top in Unit::Px
+     * @param right in Unit::Px
+     * @param bottom in Unit::Px
+     */
+    void SetTilesMargins(qreal left, qreal top, qreal right, qreal bottom);
+
+    /**
+     * @brief SetSheetMargins, set the margins of the tiles, the values have to be in the unit of the layout
+     * @param left in Unit::Px
+     * @param top in Unit::Px
+     * @param right in Unit::Px
+     * @param bottom in Unit::Px
+     */
+    void SetTilesMarginsConverted(qreal left, qreal top, qreal right, qreal bottom);
+
+    /**
+     * @brief SetTilesMargins set the margins of the tiles, the values have to be in Unit::Px
+     * @param margins tiles margins
+     */
+    void SetTilesMargins(const QMarginsF &margins);
+
+    /**
+     * @brief SetTilesMarginsConverted set the margins of the tiles, the values have to be in the unit of the layout
+     * @param margins tiles margins
+     */
+    void SetTilesMarginsConverted(const QMarginsF &margins);
+
+    /**
+     * @brief GetTilesMargins Returns margins of the tiles in Unit::Px
+     * @return the margins in Unit::Px
+     */
+    auto GetTilesMargins() const -> QMarginsF;
+
+    /**
+     * @brief GetTilesMargins Returns margins of the tiles in the given unit
+     * @param unit the unit in which we want the margins
+     * @return the margins in the given unit
+     */
+    auto GetTilesMargins(Unit unit) const -> QMarginsF;
+
+    /**
+     * @brief GetTilesMarginsConverted Returns the margins of the tiles in the layout's unit
+     * @return the margins in the tiles's unit
+     */
+    auto GetTilesMarginsConverted() const -> QMarginsF;
+
+    /**
+     * @brief GetShowTiles Returns true if the tiles has to be shown on the current sheet
+     * @return true if the tiles has to be shown on the current sheet
+     */
+    auto GetShowTiles() const -> bool;
+
+    /**
+     * @brief SetShowTiles Sets wether to show the tiles on the current sheet or not
+     * @param value true to show the tiles
+     */
+    void SetShowTiles(bool value);
+
+    /**
+     * @brief GetTemplateSize Returns the size in Px of the given template
+     * @param tmpl paper size template
+     * @return the size in Px
+     */
+    static auto GetTemplateSize(PaperSizeTemplate tmpl) -> QSizeF;
+
+    /**
+     * @brief GetTemplateName Returns the name of the given template
+     * @param tmpl paper size template
+     * @return name of the given template
+     */
+    static auto GetTemplateName(PaperSizeTemplate tmpl) -> QString;
+
+    /**
+     * @brief GetTemplate GetTemplate Returns the template that corresponds to the given size
+     * @param size the Size in Px
+     * @return template that corresponds to the given size
+     */
+    static auto GetTemplate(QSizeF size) -> PaperSizeTemplate;
+
+    /**
+     * @brief PopulateComboBox Populates the given combo with the given templates
+     * @param tmpls list of paper size templates
+     * @param comboBox pointer to the combobox
+     */
+    static void PopulateComboBox(QVector<PaperSizeTemplate> *tmpls, QComboBox* comboBox);
+
+    /**
+     * @brief isRollTemplate Returns wether the given template is a roll or not.
+     * @param tmpl paper size template
+     * @return true if the given template is a roll
+     */
+    static auto isRollTemplate(PaperSizeTemplate tmpl) -> bool;
+
+    /**
+     * @brief SetSheetSize sets the size of the sheet, the values have to be in Unit::Px
+     * @param width sheet width
+     * @param height sheet height
+     */
+    void SetSheetSize(qreal width, qreal height);
+
+    /**
+     * @brief SetSheetSize sets the size of the sheet, the values have to be in the layout's unit
+     * @param width sheet width
+     * @param height sheet height
+     */
+    void SetSheetSizeConverted(qreal width, qreal height);
+
+    /**
+     * @brief SetSheetSize sets the size of the sheet, the values have to be in Unit::Px
+     * @param size sheet size
+     */
+    void SetSheetSize(const QSizeF &size);
+    /**
+     * @brief SetSheetSizeConverted sets the size of the sheet, the values have to be in the layout's unit
+     * @param size sheet size
+     */
+    void SetSheetSizeConverted(const QSizeF &size);
+
+    /**
+     * @brief GetSheetSize Returns the size in Unit::Px
+     * @return sheet size in Unit::Px
+     */
+    auto GetSheetSize() const -> QSizeF;
+
+    /**
+     * @brief GetSheetSizeConverted Returns the size in the layout's unit
+     * @return the size in the layout's unit
+     */
+    auto GetSheetSizeConverted() const -> QSizeF;
+
+    /**
+     * @brief GetOrientation Returns the orientation of the sheet
+     * @return orientation of the sheet
+     */
+    auto GetOrientation() -> PageOrientation;
+
+    /**
+     * @brief SetOrientation Sets the orientation of the sheet to the given value
+     * @param orientation the new page orientation
+     */
+    void SetOrientation(PageOrientation orientation);
+
+    /**
+     * @brief SetSheetMargins, set the margins of the sheet, the values have to be in Unit::Px
+     * @param left in Unit::Px
+     * @param top in Unit::Px
+     * @param right in Unit::Px
+     * @param bottom in Unit::Px
+     */
+    void SetSheetMargins(qreal left, qreal top, qreal right, qreal bottom);
+
+    /**
+     * @brief SetSheetMargins, set the margins of the sheet, the values have to be in the unit of the layout
+     * @param left in Unit::Px
+     * @param top in Unit::Px
+     * @param right in Unit::Px
+     * @param bottom in Unit::Px
+     */
+    void SetSheetMarginsConverted(qreal left, qreal top, qreal right, qreal bottom);
+
+    /**
+     * @brief SetSheetMargins set the margins of the sheet, the values have to be in Unit::Px
+     * @param margins sheet margins
+     */
+    void SetSheetMargins(const QMarginsF &margins);
+
+    /**
+     * @brief SetSheetMargins set the margins of the sheet, the values have to be in the unit of the layout
+     * @param margins sheet margins
+     */
+    void SetSheetMarginsConverted(const QMarginsF &margins);
+
+    /**
+     * @brief GetSheetMargins Returns the size in Unit::Px
+     * @return the size in Unit::Px
+     */
+    auto GetSheetMargins() const -> QMarginsF;
+
+    /**
+     * @brief GetSheetMarginsConverted Returns the margins in the layout's unit
+     * @return the margins in the sheet's unit
+     */
+    auto GetSheetMarginsConverted() const -> QMarginsF;
+
+    /**
+     * @brief SetFollowGrainline Sets the type of grainline for the pieces to follow
+     * @param state the type of grainline
+     */
+    void SetFollowGrainline(FollowGrainline state);
+
+    /**
+     * @brief GetFollowGrainline Returns if the sheet's pieces follow a grainline or not
+     * @return wether the pieces follow a grainline and if so, which grainline
+     */
+    auto GetFollowGrainline() const -> FollowGrainline;
+
+    /**
+     * @brief SetPiecesGap sets the pieces gap to the given value, the unit has to be in Unit::Px
+     * @param value pieces gap
+     */
+    void SetPiecesGap(qreal value);
+
+    /**
+     * @brief SetPiecesGapConverted sets the pieces gap to the given value, the unit has to be in the layout's unit
+     * @param value pieces gap
+     */
+    void SetPiecesGapConverted(qreal value);
+
+    /**
+     * @brief GetPiecesGap returns the pieces gap in Unit::Px
+     * @return the pieces gap in Unit::Px
+     */
+    auto GetPiecesGap() const -> qreal;
+
+    /**
+     * @brief GetPiecesGapConverted returns the pieces gap in the layout's unit
+     * @return the pieces gap in the layout's unit
+     */
+    auto GetPiecesGapConverted() const -> qreal;
+
+    /**
+     * @brief GetShowGrid Returns true if the placement grid has to be shown on the current sheet
+     * @return true if the placement grid has to be shown on the current sheet
+     */
+    auto GetShowGrid() const -> bool;
+
+    /**
+     * @brief SetShowGrid Returns true if the placement grid has to be shown on the current sheet
+     * @param value whether to show the grid or not
+     */
+    void SetShowGrid(bool value);
+
+    /**
+    * @brief GetGridColWidth returns the placement grid column width in Unit::Px
+    * @return the placement grid column width in Unit::Px
+    */
+    auto GetGridColWidth() const -> qreal;
+
+    /**
+    * @brief GetGridColWidth returns the placement grid column width in the layout's unit
+    * @return the placement grid column width in the layout's unit
+    */
+    auto GetGridColWidthConverted() const -> qreal;
+
+    /**
+     * @brief SetGridColWidth sets the placement grid column width to the given value, the unit has to be Unit::Px
+     * @param value the placement grid column width in Unit::Px
+     */
+    void SetGridColWidth(qreal value);
+
+    /**
+     * @brief SetGridColWidthConverted sets the placement grid column width to the given value, the unit has to be in
+     * the layout's unit
+     * @param value the placement grid column width in the layout's unit
+     */
+    void SetGridColWidthConverted(qreal value);
+
+    /**
+    * @brief GetGridRowHeight returns the placement grid row height in Unit::Px
+    * @return the placement grid row height in Unit::Px
+    */
+    auto GetGridRowHeight() const -> qreal;
+
+    /**
+    * @brief GetGridRowHeightConverted returns the placement grid row height in the layout's unit
+    * @return the placement grid row height in the layout's unit
+    */
+    auto GetGridRowHeightConverted() const -> qreal;
+
+    /**
+     * @brief SetGridRowHeight sets the placement grid row height to the given value, the unit has to be Unit::Px
+     * @param value the placement grid row height in Unit::Px
+     */
+    void SetGridRowHeight(qreal value);
+
+    /**
+     * @brief SetGridRowHeightConverted sets the placement grid row height to the given value, the unit has to be in
+     * the layout's unit
+     * @param value the placement grid row height in the layout's unit
+     */
+    void SetGridRowHeightConverted(qreal value);
+
+    void SetStickyEdges(bool state);
+    auto GetStickyEdges() const -> bool;
+
+private:
+    Unit m_unit{Unit::Cm};
+
+    bool m_warningSuperpositionOfPieces{false};
+    bool m_warningPiecesOutOfBound{false};
+
+    QString m_title{};
+    QString m_description{};
+
+    /**
+     * @brief m_size the Size of the tiles in Unit::Px
+     */
+    QSizeF m_tilesSize{};
+
+    /**
+     * @brief holds the orientation of the tiles
+     */
+    PageOrientation m_tilesOrientation {PageOrientation::Portrait};
+
+    // margins
+    /**
+     * @brief m_margins the margins of the tiles in Unit::Px
+     */
+    QMarginsF m_tilesMargins{};
+
+    bool m_showTiles{false};
+
+    /**
+     * @brief m_size the Size in Unit::Px
+     */
+    QSizeF m_size{};
+
+    /**
+     * @brief holds the orientation of the sheet
+     */
+    PageOrientation m_orientation {PageOrientation::Portrait};
+
+    // margins
+    /**
+     * @brief m_margins the margins in Unit::Px
+     */
+    QMarginsF m_margins{};
+
+    // control
+    FollowGrainline m_followGrainLine{FollowGrainline::No};
+
+    /**
+     * @brief m_piecesGap the pieces gap in Unit::Px
+     */
+    qreal m_piecesGap{0};
+
+    // placement grid
+    /**
+     * @brief GetShowGrid Returns true if the placement grid has to be shown on the current sheet
+     */
+    bool m_showGrid{false};
+    /**
+     * @brief m_gridColWidth the column width of the placement grid in Unit::Px
+     */
+    qreal m_gridColWidth{0};
+
+    /**
+     * @brief m_gridRowHeight the row height of the placement grid in Unit::Px
+     */
+    qreal m_gridRowHeight{0};
+
+    bool m_stickyEdges{false};
+};
+
+#endif // VPLAYOUTSETTINGS_H

src/app/puzzle/vpmaingraphicsview.cpp

@@ -33,7 +33,6 @@
 #include <QKeyEvent>
 
 #include "vpmimedatapiece.h"
-#include "vppiecelist.h"
 #include "vplayout.h"
 #include "vpsheet.h"
 #include "../vwidgets/vmaingraphicsscene.h"
@@ -61,11 +60,6 @@ VPMainGraphicsView::VPMainGraphicsView(VPLayout *layout, VPTileFactory *tileFact
 
     m_graphicsTileGrid = new VPGraphicsTileGrid(layout, tileFactory);
     m_scene->addItem(m_graphicsTileGrid);
-
-    // add the connections
-    connect(m_layout, &VPLayout::PieceMovedToPieceList, this, &VPMainGraphicsView::on_PieceMovedToPieceList);
-    connect(m_scene, &VMainGraphicsScene::selectionChanged, this,
-            &VPMainGraphicsView::on_SceneSelectionChanged);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -90,16 +84,14 @@ VMainGraphicsScene* VPMainGraphicsView::GetScene()
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainGraphicsView::PrepareForExport()
 {
-    m_layout->ClearSelection();
-
     m_graphicsSheet->SetShowBorder(false);
     m_graphicsSheet->SetShowMargin(false);
 
-    m_showGridTmp = m_layout->GetFocusedSheet()->GetShowGrid();
+    m_showGridTmp = m_layout->GetFocusedSheet()->GetLayout()->LayoutSettings().GetShowGrid();
-    m_layout->GetFocusedSheet()->SetShowGrid(false);
+    m_layout->GetFocusedSheet()->GetLayout()->LayoutSettings().SetShowGrid(false);
 
-    m_showTilesTmp = m_layout->GetShowTiles();
+    m_showTilesTmp = m_layout->LayoutSettings().GetShowTiles();
-    m_layout->SetShowTiles(false);
+    m_layout->LayoutSettings().SetShowTiles(false);
 
     RefreshLayout();
 }
@@ -110,14 +102,13 @@ void VPMainGraphicsView::CleanAfterExport()
     m_graphicsSheet->SetShowBorder(true);
     m_graphicsSheet->SetShowMargin(true);
 
-    m_layout->GetFocusedSheet()->SetShowGrid(m_showGridTmp);
+    m_layout->GetFocusedSheet()->GetLayout()->LayoutSettings().SetShowGrid(m_showGridTmp);
 
-    m_layout->SetShowTiles(m_showTilesTmp);
+    m_layout->LayoutSettings().SetShowTiles(m_showTilesTmp);
 
     RefreshLayout();
 }
 
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainGraphicsView::dragEnterEvent(QDragEnterEvent *event)
 {
@@ -147,8 +138,6 @@ void VPMainGraphicsView::dragLeaveEvent(QDragLeaveEvent *event)
     event->accept();
 }
 
-
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainGraphicsView::dropEvent(QDropEvent *event)
 {
@@ -170,11 +159,7 @@ void VPMainGraphicsView::dropEvent(QDropEvent *event)
             piece->SetPosition(mapToScene(point));
 
             // change the piecelist of the piece
-            VPPieceList *focusedPieceList = m_layout->GetFocusedSheet()->GetPieceList();
+            piece->SetSheet(m_layout->GetFocusedSheet());
-            if(focusedPieceList != nullptr)
-            {
-                m_layout->MovePieceToPieceList(piece, focusedPieceList);
-            }
         }
     }
 }
@@ -193,65 +178,7 @@ void VPMainGraphicsView::keyPressEvent(QKeyEvent *event)
             if(piece->GetIsSelected())
             {
                 piece->SetIsSelected(false);
-                m_layout->MovePieceToPieceList(piece, m_layout->GetUnplacedPieceList());
+                piece->SetSheet(nullptr);
-            }
-        }
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPMainGraphicsView::on_PieceMovedToPieceList(VPPiece *piece, VPPieceList *pieceListBefore, VPPieceList *pieceListAfter)
-{
-    Q_UNUSED(pieceListBefore)
-
-    VPGraphicsPiece *_graphicsPiece = nullptr;
-    for(auto *graphicPiece : m_graphicsPieces)
-    {
-        if(graphicPiece->GetPiece() == piece)
-        {
-            _graphicsPiece = graphicPiece;
-        }
-    }
-
-    if(pieceListAfter == m_layout->GetUnplacedPieceList() && _graphicsPiece != nullptr)
-    {
-        scene()->removeItem(_graphicsPiece);
-        m_graphicsPieces.removeAll(_graphicsPiece);
-    }
-    else if(pieceListAfter != m_layout->GetUnplacedPieceList() && pieceListAfter != m_layout->GetTrashPieceList())
-    {
-        if(_graphicsPiece == nullptr)
-        {
-            _graphicsPiece = new VPGraphicsPiece(piece);
-            m_graphicsPieces.append(_graphicsPiece);
-        }
-
-        scene()->addItem(_graphicsPiece);
-        // not very clean to directly call slots
-        _graphicsPiece->on_PieceSelectionChanged();
-        _graphicsPiece->on_PiecePositionChanged();
-        _graphicsPiece->on_PieceRotationChanged();
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPMainGraphicsView::on_SceneSelectionChanged()
-{
-    // most of the selection behaviour takes place automatically
-    // but we need to make sure that the unplaced pieces are unselected when the scene selection has changed
-    // because as they are not part of the scene, they are not updated
-    m_layout->GetUnplacedPieceList()->ClearSelection();
-
-
-    // make sure, that the selected items are on top
-    // FIXME: maybe there is a more proper way to do it
-    for(auto *graphicPiece : m_graphicsPieces)
-    {
-        if((graphicPiece != nullptr) && not graphicPiece->GetPiece()->GetIsSelected())
-        {
-            if(!m_scene->selectedItems().isEmpty())
-            {
-                graphicPiece->stackBefore(m_scene->selectedItems().first());
             }
         }
     }

src/app/puzzle/vpmaingraphicsview.h

@@ -68,7 +68,6 @@ public:
      */
     void CleanAfterExport();
 
-
 protected:
     void dragEnterEvent(QDragEnterEvent *event) override;
     void dragMoveEvent(QDragMoveEvent *event) override;
@@ -79,21 +78,6 @@ protected:
 
     void drawTilesLine();
 
-private slots:
-    /**
-     * @brief on_PieceMovedToPieceList The slot is called when the given piece was moved from the given piece list to the other
-     * given piece list
-     * @param piece the piece that was moved
-     * @param pieceListBefore the piece list before the move
-     * @param pieceListAfter the piece list after the move
-     */
-    void on_PieceMovedToPieceList(VPPiece *piece, VPPieceList *pieceListBefore, VPPieceList *pieceListAfter);
-
-    /**
-     * @brief on_SceneSelectionChanged Slot is called when the scene selection has changed
-     */
-    void on_SceneSelectionChanged();
-
 private:
     Q_DISABLE_COPY(VPMainGraphicsView)
 

src/app/puzzle/vpmainwindow.cpp

@@ -70,15 +70,15 @@ VPMainWindow::VPMainWindow(const VPCommandLinePtr &cmd, QWidget *parent) :
     m_statusLabel(new QLabel(this))
 {
     //    // ----- for test purposes, to be removed------------------
-    m_layout->SetUnit(Unit::Cm);
+    m_layout->LayoutSettings().SetUnit(Unit::Cm);
-    m_layout->SetWarningSuperpositionOfPieces(true);
+    m_layout->LayoutSettings().SetWarningSuperpositionOfPieces(true);
-    m_layout->SetTitle(QString("My Test Layout"));
+    m_layout->LayoutSettings().SetTitle(QString("My Test Layout"));
-    m_layout->SetDescription(QString("Description of my Layout"));
+    m_layout->LayoutSettings().SetDescription(QString("Description of my Layout"));
 
-    m_layout->SetTilesSizeConverted(21,29.7);
+    m_layout->LayoutSettings().SetTilesSizeConverted(21,29.7);
-    m_layout->SetTilesOrientation(PageOrientation::Portrait);
+    m_layout->LayoutSettings().SetTilesOrientation(PageOrientation::Portrait);
-    m_layout->SetTilesMarginsConverted(1,1,1,1);
+    m_layout->LayoutSettings().SetTilesMarginsConverted(1,1,1,1);
-    m_layout->SetShowTiles(true);
+    m_layout->LayoutSettings().SetShowTiles(true);
 
     // --------------------------------------------------------
 
@@ -281,7 +281,8 @@ void VPMainWindow::ImportRawLayouts(const QStringList &rawLayouts)
 
                 // TODO for feature "Update piece" : CreateOrUpdate() function indstead of CreatePiece()
                 VPPiece *piece = CreatePiece(rawPiece);
-                m_layout->GetUnplacedPieceList()->AddPiece(piece);
+                piece->SetSheet(nullptr); // just in case
+                m_layout->AddPiece(piece);
             }
 
             m_carrousel->Refresh();
@@ -475,7 +476,7 @@ void VPMainWindow::InitPropertyTabCurrentSheet()
     sheetTemplates.append(PaperSizeTemplate::Custom);
 
     ui->comboBoxSheetTemplate->blockSignals(true);
-    VPSheet::PopulateComboBox(&sheetTemplates, ui->comboBoxSheetTemplate);
+    VPLayoutSettings::PopulateComboBox(&sheetTemplates, ui->comboBoxSheetTemplate);
     ui->comboBoxSheetTemplate->blockSignals(false);
 
     ui->comboBoxSheetTemplate->setCurrentIndex(0);
@@ -514,7 +515,7 @@ void VPMainWindow::InitPropertyTabTiles()
     tilesTemplates.append(PaperSizeTemplate::Custom);
 
     ui->comboBoxTilesTemplate->blockSignals(true);
-    VPSheet::PopulateComboBox(&tilesTemplates, ui->comboBoxTilesTemplate);
+    VPLayoutSettings::PopulateComboBox(&tilesTemplates, ui->comboBoxTilesTemplate);
     ui->comboBoxTilesTemplate->blockSignals(false);
 
     ui->comboBoxTilesTemplate->setCurrentIndex(4); //A4
@@ -607,9 +608,9 @@ void VPMainWindow::SetPropertyTabCurrentPieceData()
 
         QPointF pos = selectedPiece->GetPosition();
         SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionX,
-                              UnitConvertor(pos.x(), Unit::Px, m_layout->GetUnit()));
+                              UnitConvertor(pos.x(), Unit::Px, m_layout->LayoutSettings().GetUnit()));
         SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionY,
-                              UnitConvertor(pos.y(), Unit::Px, m_layout->GetUnit()));
+                              UnitConvertor(pos.y(), Unit::Px, m_layout->LayoutSettings().GetUnit()));
 
         qreal angle = selectedPiece->GetRotation();
         SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceAngle, angle);
@@ -633,12 +634,12 @@ void VPMainWindow::SetPropertyTabSheetData()
     ui->lineEditSheetName->setText(m_layout->GetFocusedSheet()->GetName());
 
     // set Width / Length
-    QSizeF size = m_layout->GetFocusedSheet()->GetSheetSizeConverted();
+    QSizeF size = m_layout->LayoutSettings().GetSheetSizeConverted();
     SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetWidth, size.width());
     SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetLength, size.height());
 
     // Set Orientation
-    if(m_layout->GetFocusedSheet()->GetOrientation() == PageOrientation::Portrait)
+    if(m_layout->LayoutSettings().GetOrientation() == PageOrientation::Portrait)
     {
         ui->radioButtonSheetPortrait->setChecked(true);
     }
@@ -648,22 +649,22 @@ void VPMainWindow::SetPropertyTabSheetData()
     }
 
     // set margins
-    QMarginsF margins = m_layout->GetFocusedSheet()->GetSheetMarginsConverted();
+    QMarginsF margins = m_layout->LayoutSettings().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->doubleSpinBoxSheetGridColWidth, m_layout->LayoutSettings().GetGridColWidthConverted());
-    SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetGridRowHeight, m_layout->GetFocusedSheet()->GetGridRowHeightConverted());
+    SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetGridRowHeight, m_layout->LayoutSettings().GetGridRowHeightConverted());
-    SetCheckBoxValue(ui->checkBoxSheetShowGrid, m_layout->GetFocusedSheet()->GetShowGrid());
+    SetCheckBoxValue(ui->checkBoxSheetShowGrid, m_layout->LayoutSettings().GetShowGrid());
 
     // set pieces gap
-    SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetPiecesGap, m_layout->GetFocusedSheet()->GetPiecesGapConverted());
+    SetDoubleSpinBoxValue(ui->doubleSpinBoxSheetPiecesGap, m_layout->LayoutSettings().GetPiecesGapConverted());
 
     // set the checkboxes
-    SetCheckBoxValue(ui->checkBoxSheetStickyEdges, m_layout->GetFocusedSheet()->GetStickyEdges());
+    SetCheckBoxValue(ui->checkBoxSheetStickyEdges, m_layout->LayoutSettings().GetStickyEdges());
 }
 
 
@@ -671,12 +672,12 @@ void VPMainWindow::SetPropertyTabSheetData()
 void VPMainWindow::SetPropertyTabTilesData()
 {
     // set Width / Length
-    QSizeF size = m_layout->GetTilesSizeConverted();
+    QSizeF size = m_layout->LayoutSettings().GetTilesSizeConverted();
     SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesWidth, size.width());
     SetDoubleSpinBoxValue(ui->doubleSpinBoxTilesLength, size.height());
 
     // Set Orientation
-    if(m_layout->GetTilesOrientation() == PageOrientation::Portrait)
+    if(m_layout->LayoutSettings().GetTilesOrientation() == PageOrientation::Portrait)
     {
         ui->radioButtonSheetPortrait->setChecked(true);
     }
@@ -686,25 +687,25 @@ void VPMainWindow::SetPropertyTabTilesData()
     }
 
     // set margins
-    QMarginsF margins = m_layout->GetTilesMarginsConverted();
+    QMarginsF margins = m_layout->LayoutSettings().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());
+    SetCheckBoxValue(ui->checkBoxTilesShowTiles, m_layout->LayoutSettings().GetShowTiles());
 }
 
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::SetPropertyTabLayoutData()
 {
     // set the title and description
-    ui->lineEditLayoutName->setText(m_layout->GetTitle());
+    ui->lineEditLayoutName->setText(m_layout->LayoutSettings().GetTitle());
-    ui->plainTextEditLayoutDescription->setPlainText(m_layout->GetDescription());
+    ui->plainTextEditLayoutDescription->setPlainText(m_layout->LayoutSettings().GetDescription());
 
     // set Unit
-    int index = ui->comboBoxLayoutUnit->findData(QVariant(UnitsToStr(m_layout->GetUnit())));
+    int index = ui->comboBoxLayoutUnit->findData(QVariant(UnitsToStr(m_layout->LayoutSettings().GetUnit())));
     if(index != -1)
     {
         ui->comboBoxLayoutUnit->blockSignals(true); // FIXME: is there a better way to block the signals?
@@ -713,8 +714,10 @@ void VPMainWindow::SetPropertyTabLayoutData()
     }
 
     // set controls
-    SetCheckBoxValue(ui->checkBoxLayoutWarningPiecesOutOfBound, m_layout->GetWarningPiecesOutOfBound());
+    SetCheckBoxValue(ui->checkBoxLayoutWarningPiecesOutOfBound,
-    SetCheckBoxValue(ui->checkBoxLayoutWarningPiecesSuperposition, m_layout->GetWarningSuperpositionOfPieces());
+                     m_layout->LayoutSettings().GetWarningPiecesOutOfBound());
+    SetCheckBoxValue(ui->checkBoxLayoutWarningPiecesSuperposition,
+                     m_layout->LayoutSettings().GetWarningSuperpositionOfPieces());
 }
 
 
@@ -786,7 +789,8 @@ void VPMainWindow::InitScaleToolBar()
     // define the mouse position
     ui->toolBarScale->addSeparator();
 
-    m_mouseCoordinate = new QLabel(QStringLiteral("0, 0 (%1)").arg(UnitsToStr(m_layout->GetUnit(), true)));
+    m_mouseCoordinate = new QLabel(QStringLiteral("0, 0 (%1)")
+                                   .arg(UnitsToStr(m_layout->LayoutSettings().GetUnit(), true)));
     ui->toolBarScale->addWidget(m_mouseCoordinate);
     ui->toolBarScale->addSeparator();
 }
@@ -975,7 +979,7 @@ void VPMainWindow::generateTiledPdf(QString fileName)
         m_graphicsView->PrepareForExport();
         m_tileFactory->refreshTileInfos();
 
-        PageOrientation tilesOrientation = m_layout->GetTilesOrientation();
+        PageOrientation tilesOrientation = m_layout->LayoutSettings().GetTilesOrientation();
 
         // -------------  Set up the printer
         QScopedPointer<QPrinter> printer(new QPrinter());
@@ -985,7 +989,7 @@ void VPMainWindow::generateTiledPdf(QString fileName)
         printer->setPageOrientation(QPageLayout::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),
+        printer->setPageSize(QPageSize(m_layout->LayoutSettings().GetTilesSize(Unit::Mm),
                                                            QPageSize::Millimeter));
         printer->setFullPage(true);
 
@@ -1087,12 +1091,12 @@ void VPMainWindow::AddSheet()
     auto *sheet = new VPSheet(m_layout);
     sheet->SetName(QObject::tr("Sheet %1").arg(m_layout->GetSheets().size()+1));
     m_layout->AddSheet(sheet);
-    m_layout->SetFocusedSheet();
+    m_layout->SetFocusedSheet(sheet);
 
 //    // ----- for test purposes, to be removed------------------
-    sheet->SetSheetMarginsConverted(1, 1, 1, 1);
+    m_layout->LayoutSettings().SetSheetMarginsConverted(1, 1, 1, 1);
-    sheet->SetSheetSizeConverted(84.1, 118.9);
+    m_layout->LayoutSettings().SetSheetSizeConverted(84.1, 118.9);
-    sheet->SetPiecesGapConverted(1);
+    m_layout->LayoutSettings().SetPiecesGapConverted(1);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -1359,15 +1363,15 @@ void VPMainWindow::on_comboBoxLayoutUnit_currentIndexChanged(int index)
 
     if(comboBoxValue == QVariant(UnitsToStr(Unit::Cm)))
     {
-        m_layout->SetUnit(Unit::Cm);
+        m_layout->LayoutSettings().SetUnit(Unit::Cm);
     }
     else if(comboBoxValue == QVariant(UnitsToStr(Unit::Mm)))
     {
-        m_layout->SetUnit(Unit::Mm);
+        m_layout->LayoutSettings().SetUnit(Unit::Mm);
     }
     else if(comboBoxValue == QVariant(UnitsToStr(Unit::Inch)))
     {
-        m_layout->SetUnit(Unit::Inch);
+        m_layout->LayoutSettings().SetUnit(Unit::Inch);
     }
 
     SetPropertyTabCurrentPieceData();
@@ -1393,14 +1397,16 @@ void VPMainWindow::on_comboBoxSheetTemplate_currentIndexChanged(int index)
                 ui->comboBoxSheetTemplate->itemData(index).toInt()
                 );
 
-    QSizeF tmplSize = VPSheet::GetTemplateSize(tmpl);
+    QSizeF tmplSize = VPLayoutSettings::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->doubleSpinBoxSheetWidth->setValue(UnitConvertor(tmplSize.width(), Unit::Px,
-        ui->doubleSpinBoxSheetLength->setValue(UnitConvertor(tmplSize.height(), Unit::Px, m_layout->GetUnit()));
+                                                            m_layout->LayoutSettings().GetUnit()));
+        ui->doubleSpinBoxSheetLength->setValue(UnitConvertor(tmplSize.height(), Unit::Px,
+                                                             m_layout->LayoutSettings().GetUnit()));
 
         on_SheetSizeChanged(false);
 
@@ -1412,7 +1418,7 @@ void VPMainWindow::on_comboBoxSheetTemplate_currentIndexChanged(int index)
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_SheetSizeChanged(bool changedViaSizeCombobox)
 {
-    m_layout->GetFocusedSheet()->SetSheetSizeConverted(
+    m_layout->LayoutSettings().SetSheetSizeConverted(
                 ui->doubleSpinBoxSheetWidth->value(),
                 ui->doubleSpinBoxSheetLength->value()
                 );
@@ -1442,11 +1448,11 @@ void VPMainWindow::on_SheetOrientationChanged()
     // Updates the orientation
     if(ui->radioButtonSheetPortrait->isChecked())
     {
-        m_layout->GetFocusedSheet()->SetOrientation(PageOrientation::Portrait);
+        m_layout->LayoutSettings().SetOrientation(PageOrientation::Portrait);
     }
     else
     {
-        m_layout->GetFocusedSheet()->SetOrientation(PageOrientation::Landscape);
+        m_layout->LayoutSettings().SetOrientation(PageOrientation::Landscape);
     }
     m_tileFactory->refreshTileInfos();
 
@@ -1472,7 +1478,7 @@ void VPMainWindow::on_pushButtonSheetRemoveUnusedLength_clicked()
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_SheetMarginChanged()
 {
-    m_layout->GetFocusedSheet()->SetSheetMarginsConverted(
+    m_layout->LayoutSettings().SetSheetMarginsConverted(
                 ui->doubleSpinBoxSheetMarginLeft->value(),
                 ui->doubleSpinBoxSheetMarginTop->value(),
                 ui->doubleSpinBoxSheetMarginRight->value(),
@@ -1487,21 +1493,21 @@ void VPMainWindow::on_SheetMarginChanged()
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_checkBoxSheetShowGrid_toggled(bool checked)
 {
-    m_layout->GetFocusedSheet()->SetShowGrid(checked);
+    m_layout->LayoutSettings().SetShowGrid(checked);
     m_graphicsView->RefreshLayout();
 }
 
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_doubleSpinBoxSheetGridColWidth_valueChanged(double value)
 {
-    m_layout->GetFocusedSheet()->SetGridColWidthConverted(value);
+    m_layout->LayoutSettings().SetGridColWidthConverted(value);
     m_graphicsView->RefreshLayout();
 }
 
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_doubleSpinBoxSheetGridRowHeight_valueChanged(double value)
 {
-    m_layout->GetFocusedSheet()->SetGridRowHeightConverted(value);
+    m_layout->LayoutSettings().SetGridRowHeightConverted(value);
     m_graphicsView->RefreshLayout();
 }
 
@@ -1512,14 +1518,16 @@ void VPMainWindow::on_comboBoxTilesTemplate_currentIndexChanged(int index)
                 ui->comboBoxTilesTemplate->itemData(index).toInt()
                 );
 
-    QSizeF tmplSize = VPSheet::GetTemplateSize(tmpl);
+    QSizeF tmplSize = VPLayoutSettings::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->doubleSpinBoxTilesWidth->setValue(UnitConvertor(tmplSize.width(), Unit::Px,
-        ui->doubleSpinBoxTilesLength->setValue(UnitConvertor(tmplSize.height(), Unit::Px, m_layout->GetUnit()));
+                                                            m_layout->LayoutSettings().GetUnit()));
+        ui->doubleSpinBoxTilesLength->setValue(UnitConvertor(tmplSize.height(), Unit::Px,
+                                                             m_layout->LayoutSettings().GetUnit()));
 
         on_TilesSizeChanged(false);
 
@@ -1531,7 +1539,8 @@ void VPMainWindow::on_comboBoxTilesTemplate_currentIndexChanged(int index)
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_TilesSizeChanged(bool changedViaSizeCombobox)
 {
-    m_layout->SetTilesSizeConverted(ui->doubleSpinBoxTilesWidth->value(), ui->doubleSpinBoxTilesLength->value());
+    m_layout->LayoutSettings().SetTilesSizeConverted(ui->doubleSpinBoxTilesWidth->value(),
+                                                     ui->doubleSpinBoxTilesLength->value());
     m_tileFactory->refreshTileInfos();
 
     if(changedViaSizeCombobox)
@@ -1560,11 +1569,11 @@ void VPMainWindow::on_TilesOrientationChanged()
     // Updates the orientation
     if(ui->radioButtonTilesPortrait->isChecked())
     {
-        m_layout->SetTilesOrientation(PageOrientation::Portrait);
+        m_layout->LayoutSettings().SetTilesOrientation(PageOrientation::Portrait);
     }
     else
     {
-        m_layout->SetTilesOrientation(PageOrientation::Landscape);
+        m_layout->LayoutSettings().SetTilesOrientation(PageOrientation::Landscape);
     }
     m_tileFactory->refreshTileInfos();
 
@@ -1576,7 +1585,7 @@ void VPMainWindow::on_TilesOrientationChanged()
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_TilesMarginChanged()
 {
-    m_layout->SetTilesMarginsConverted(
+    m_layout->LayoutSettings().SetTilesMarginsConverted(
                 ui->doubleSpinBoxTilesMarginLeft->value(),
                 ui->doubleSpinBoxTilesMarginTop->value(),
                 ui->doubleSpinBoxTilesMarginRight->value(),
@@ -1593,7 +1602,7 @@ void VPMainWindow::on_TilesMarginChanged()
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_checkBoxTilesShowTiles_toggled(bool checked)
 {
-    m_layout->SetShowTiles(checked);
+    m_layout->LayoutSettings().SetShowTiles(checked);
 
     // TODO Undo / Redo
 
@@ -1635,7 +1644,7 @@ void VPMainWindow::on_SheetFollowGrainlineChanged()
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_doubleSpinBoxSheetPiecesGap_valueChanged(double value)
 {
-    m_layout->GetFocusedSheet()->SetPiecesGapConverted(value);
+    m_layout->LayoutSettings().SetPiecesGapConverted(value);
 
     // TODO Undo / Redo
     // TODO update the QGraphicView
@@ -1644,7 +1653,7 @@ void VPMainWindow::on_doubleSpinBoxSheetPiecesGap_valueChanged(double value)
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_checkBoxLayoutWarningPiecesSuperposition_toggled(bool checked)
 {
-    m_layout->SetWarningSuperpositionOfPieces(checked);
+    m_layout->LayoutSettings().SetWarningSuperpositionOfPieces(checked);
 
     // TODO Undo / Redo
     // TODO update the QGraphicView
@@ -1653,7 +1662,7 @@ void VPMainWindow::on_checkBoxLayoutWarningPiecesSuperposition_toggled(bool chec
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_checkBoxLayoutWarningPiecesOutOfBound_toggled(bool checked)
 {
-    m_layout->SetWarningPiecesOutOfBound(checked);
+    m_layout->LayoutSettings().SetWarningPiecesOutOfBound(checked);
 
     // TODO Undo / Redo
     // TODO update the QGraphicView
@@ -1662,7 +1671,7 @@ void VPMainWindow::on_checkBoxLayoutWarningPiecesOutOfBound_toggled(bool checked
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_checkBoxSheetStickyEdges_toggled(bool checked)
 {
-    m_layout->GetFocusedSheet()->SetStickyEdges(checked);
+    m_layout->LayoutSettings().SetStickyEdges(checked);
 
     // TODO Undo / Redo
     // TODO update the QGraphicView
@@ -1748,8 +1757,10 @@ 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),
+        QPointF pos(UnitConvertor(ui->doubleSpinBoxCurrentPieceBoxPositionX->value(),
-                    UnitConvertor(ui->doubleSpinBoxCurrentPieceBoxPositionY->value(), m_layout->GetUnit(), Unit::Px));
+                                  m_layout->LayoutSettings().GetUnit(), Unit::Px),
+                    UnitConvertor(ui->doubleSpinBoxCurrentPieceBoxPositionY->value(),
+                                  m_layout->LayoutSettings().GetUnit(), Unit::Px));
         piece->SetPosition(pos);
     }
 }
@@ -1770,7 +1781,7 @@ void VPMainWindow::on_CarrouselLocationChanged(Qt::DockWidgetArea area)
 //---------------------------------------------------------------------------------------------------------------------
 void VPMainWindow::on_PieceSelectionChanged()
 {
-    m_selectedPieces = m_layout->GetSelectedPieces();
+//    m_selectedPieces = m_layout->GetSelectedPieces();
 
     // update the property of the piece currently selected
     SetPropertyTabCurrentPieceData();
@@ -1786,9 +1797,9 @@ void VPMainWindow::on_PiecePositionChanged()
         QPointF pos = piece->GetPosition();
 
         SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionX,
-                              UnitConvertor(pos.x(), Unit::Px, m_layout->GetUnit()));
+                              UnitConvertor(pos.x(), Unit::Px, m_layout->LayoutSettings().GetUnit()));
         SetDoubleSpinBoxValue(ui->doubleSpinBoxCurrentPieceBoxPositionY,
-                              UnitConvertor(pos.y(), Unit::Px, m_layout->GetUnit()));
+                              UnitConvertor(pos.y(), Unit::Px, m_layout->LayoutSettings().GetUnit()));
     }
 }
 
@@ -1825,9 +1836,11 @@ 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.x(),
-                                   .arg(static_cast<qint32>(FromPixel(scenePos.y(), m_layout->GetUnit())))
+                                                                      m_layout->LayoutSettings().GetUnit())))
-                                   .arg(UnitsToStr(m_layout->GetUnit(), true)));
+                                   .arg(static_cast<qint32>(FromPixel(scenePos.y(),
+                                                                      m_layout->LayoutSettings().GetUnit())))
+                                   .arg(UnitsToStr(m_layout->LayoutSettings().GetUnit(), true)));
     }
 }
 

src/app/puzzle/vpmainwindow.h

@@ -415,7 +415,7 @@ private:
 
     VPCommandLinePtr m_cmd;
 
-    VPLayout *m_layout{new VPLayout()};
+    VPLayout *m_layout{new VPLayout(this)};
     QList<VPPiece *>m_selectedPieces{QList<VPPiece *>()};
 
     VPTileFactory *m_tileFactory{nullptr};

src/app/puzzle/vppiece.cpp

@@ -29,7 +29,6 @@
 
 #include <QtMath>
 
-#include "vppiecelist.h"
 #include "../vmisc/def.h"
 
 #include <QIcon>
@@ -38,12 +37,6 @@
 
 Q_LOGGING_CATEGORY(pPiece, "p.piece")
 
-//---------------------------------------------------------------------------------------------------------------------
-VPPiece::VPPiece()
-{
-
-}
-
 //---------------------------------------------------------------------------------------------------------------------
 VPPiece::VPPiece(VLayoutPiece layoutPiece): VLayoutPiece(layoutPiece)
 {
@@ -198,16 +191,26 @@ bool VPPiece::GetIsSelected()
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPPieceList* VPPiece::GetPieceList()
+auto VPPiece::Sheet() const -> VPSheet *
 {
-    return m_pieceList;
+    return m_sheet;
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VPPiece::SetPieceList(VPPieceList* pieceList)
+void VPPiece::SetSheet(VPSheet *newSheet)
 {
-    if(pieceList != m_pieceList)
+    m_sheet = newSheet;
-    {
+}
-        m_pieceList = pieceList;
+
-    }
+//---------------------------------------------------------------------------------------------------------------------
+auto VPPiece::Layout() const -> VPLayout *
+{
+    return m_layout;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VPPiece::SetLayout(VPLayout *layout)
+{
+    SCASSERT(layout != nullptr)
+    m_layout = layout;
 }

src/app/puzzle/vppiece.h

@@ -35,17 +35,17 @@
 
 #include "../vlayout/vlayoutpiece.h"
 
-class VPPieceList;
+class VPLayout;
+class VPSheet;
 
 class VPPiece : public QObject, public VLayoutPiece
 {
     Q_OBJECT
 public:
-    VPPiece();
+    VPPiece() = default;
     explicit VPPiece(VLayoutPiece layoutPiece);
 
-    ~VPPiece();
+    virtual ~VPPiece();
-
 
     /**
      * @brief GetShowSeamLine returns wether the seam line of the piece has to be shown or not
@@ -111,7 +111,6 @@ public:
      */
     void RotateToGrainline(qreal angleOfGrainline, bool add180IfAlreadyInPosition = false);
 
-
     /**
      * @brief SetIsSelected Sets wether the piece is selected
      * @param value true if the piece is selected
@@ -124,20 +123,14 @@ public:
      */
     bool GetIsSelected();
 
-    /**
-     * @brief GetPieceList Returns the piecelist in which the piece is.
-     * @return pieceList of the piece
-     */
-    VPPieceList* GetPieceList();
-
-    /**
-     * @brief SetPieceList Sets the pieceList of the piece to the given pieceList
-     * @param pieceList pointer to the piece list
-     */
-    void SetPieceList(VPPieceList* pieceList);
-
     QIcon PieceIcon(const QSize &size) const;
 
+    auto Sheet() const -> VPSheet *;
+    void SetSheet(VPSheet *newSheet);
+
+    auto Layout() const -> VPLayout *;
+    void SetLayout(VPLayout *layout);
+
 signals:
     /**
      * @brief SelectionChanged emited when the selection of the piece was
@@ -163,11 +156,13 @@ signals:
      */
     void PropertiesChanged();
 
-
-
 private:
     Q_DISABLE_COPY(VPPiece)
 
+    VPLayout *m_layout{nullptr};
+
+    VPSheet *m_sheet{nullptr};
+
     QVector<QPointF> m_grainline{};
     bool m_isGrainlineEnabled{false};
 
@@ -181,7 +176,6 @@ private:
     bool m_mirrorPiece{false};
 
     bool m_isSelected{false};
-    VPPieceList *m_pieceList{nullptr};
 };
 
 #endif // VPPIECE_H

src/app/puzzle/vppiecelist.cpp

@@ -1,120 +0,0 @@
-/************************************************************************
- **
- **  @file   vppiecelist.cpp
- **  @author Ronan Le Tiec
- **  @date   13 4, 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 "vppiecelist.h"
-
-#include "vplayout.h"
-
-#include <QLoggingCategory>
-
-Q_LOGGING_CATEGORY(pPieceList, "p.pieceList")
-
-//---------------------------------------------------------------------------------------------------------------------
-VPPieceList::VPPieceList(VPLayout *layout, VPSheet *sheet):
-    m_sheet(sheet),
-    m_layout(layout)
-{
-
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-VPPieceList::~VPPieceList()
-{
-    qDeleteAll(m_pieces);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-VPLayout* VPPieceList::GetLayout()
-{
-    return m_layout;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-VPSheet* VPPieceList::GetSheet()
-{
-    return m_sheet;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QList<VPPiece *> VPPieceList::GetPieces()
-{
-    return m_pieces;
-}
-
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPPieceList::ClearSelection()
-{
-    for (auto *piece: m_pieces)
-    {
-        piece->SetIsSelected(false);
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPPieceList::AddPiece(VPPiece *piece)
-{
-    qCDebug(pPieceList(), "piece -- %s -- added to %s", qUtf8Printable(piece->GetName()), qUtf8Printable(this->GetName()));
-
-    m_pieces.append(piece);
-    piece->SetPieceList(this);
-
-    emit PieceAdded(piece);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPPieceList::RemovePiece(VPPiece *piece)
-{
-    m_pieces.removeAll(piece);
-    piece->SetPieceList(nullptr);
-
-    emit PieceRemoved(piece);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QString VPPieceList::GetName() const
-{
-    return m_name;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPPieceList::SetName(const QString &name)
-{
-    m_name = name;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPPieceList::SetIsVisible(bool value)
-{
-    m_isVisible = value;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-bool VPPieceList::GetIsVisible() const
-{
-    return m_isVisible;
-}

src/app/puzzle/vppiecelist.h

@@ -1,102 +0,0 @@
-/************************************************************************
- **
- **  @file   vppiecelist.h
- **  @author Ronan Le Tiec
- **  @date   13 4, 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/>.
- **
- *************************************************************************/
-#ifndef VPPIECELIST_H
-#define VPPIECELIST_H
-
-#include <QList>
-#include "vppiece.h"
-#include "vpsheet.h"
-
-class VPLayout;
-
-class VPPieceList : public QObject
-{
-    Q_OBJECT
-public:
-    VPPieceList(VPLayout *layout, VPSheet *sheet = nullptr);
-    ~VPPieceList();
-
-    QList<VPPiece *> GetPieces();
-    void AddPiece(VPPiece *piece);
-    void RemovePiece(VPPiece *piece);
-
-    // here add some more function if we want to add/move a piece at a
-    // certain position in the list
-
-    QString GetName() const;
-    void SetName(const QString &name);
-
-    void SetIsVisible(bool value);
-    bool GetIsVisible() const;
-
-    /**
-     * @brief GetLayout Returns the layout in which this piece list is
-     * @return the layout of this piece list
-     */
-    VPLayout* GetLayout();
-
-
-    /**
-     * @brief GetSheet returns the sheet corresponding to this piece list, or nullptr
-     * if no sheet associated
-     * @return the sheet
-     */
-    VPSheet* GetSheet();
-
-    /**
-     * @brief ClearSelection Clears the selection of the pieces in this piece list
-     */
-    void ClearSelection();
-
-signals:
-    /**
-     * @brief PieceAdded The signal is emited when a piece was added
-     */
-    void PieceAdded(VPPiece *piece);
-
-    /**
-     * @brief PieceRemoved The signal is emited when a piece was removed
-     */
-    void PieceRemoved(VPPiece *piece);
-
-private:
-    Q_DISABLE_COPY(VPPieceList)
-
-    QString m_name{};
-    QList<VPPiece *> m_pieces{};
-
-    VPSheet *m_sheet{nullptr};
-
-    VPLayout *m_layout{nullptr};
-
-    // control
-    bool m_isVisible{true};
-
-};
-
-#endif // VPPIECELIST_H

src/app/puzzle/vpsheet.cpp

@@ -27,279 +27,37 @@
  *************************************************************************/
 #include "vpsheet.h"
 
-#include "vppiecelist.h"
 #include "vplayout.h"
 
 //---------------------------------------------------------------------------------------------------------------------
 VPSheet::VPSheet(VPLayout* layout) :
+    QObject(layout),
     m_layout(layout)
 {
-    m_pieceList = new VPPieceList(layout, this);
+    SCASSERT(layout != nullptr)
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPSheet::~VPSheet()
+auto VPSheet::GetLayout() -> VPLayout*
-{
-    delete m_pieceList;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QSizeF VPSheet::GetTemplateSize(PaperSizeTemplate tmpl)
-{
-    qreal height = 0;
-    qreal width = 0;
-
-    switch (tmpl)
-    {
-        case PaperSizeTemplate::A0:
-            width = UnitConvertor(841, Unit::Mm, Unit::Px);
-            height = UnitConvertor(1189, Unit::Mm, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::A1:
-            width = UnitConvertor(594, Unit::Mm, Unit::Px);
-            height = UnitConvertor(841, Unit::Mm, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::A2:
-            width = UnitConvertor(420, Unit::Mm, Unit::Px);
-            height = UnitConvertor(594, Unit::Mm, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::A3:
-            width = UnitConvertor(297, Unit::Mm, Unit::Px);
-            height = UnitConvertor(420, Unit::Mm, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::A4:
-            width = UnitConvertor(210, Unit::Mm, Unit::Px);
-            height = UnitConvertor(297, Unit::Mm, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Letter:
-            width = UnitConvertor(8.5, Unit::Inch, Unit::Px);
-            height = UnitConvertor(11, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Legal:
-            width = UnitConvertor(8.5, Unit::Inch, Unit::Px);
-            height = UnitConvertor(14, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Tabloid:
-            width = UnitConvertor(11, Unit::Inch, Unit::Px);
-            height = UnitConvertor(17, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll24in:
-            width = UnitConvertor(24, Unit::Inch, Unit::Px);
-            height = UnitConvertor(48, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll30in:
-            width = UnitConvertor(30, Unit::Inch, Unit::Px);
-            height = UnitConvertor(60, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll36in:
-            width = UnitConvertor(36, Unit::Inch, Unit::Px);
-            height = UnitConvertor(72, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll42in:
-            width = UnitConvertor(42, Unit::Inch, Unit::Px);
-            height = UnitConvertor(84, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll44in:
-            width = UnitConvertor(44, Unit::Inch, Unit::Px);
-            height = UnitConvertor(88, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll48in:
-            width = UnitConvertor(48, Unit::Inch, Unit::Px);
-            height = UnitConvertor(96, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll62in:
-            width = UnitConvertor(62, Unit::Inch, Unit::Px);
-            height = UnitConvertor(124, Unit::Inch, Unit::Px);
-        break;
-
-        case PaperSizeTemplate::Roll72in:
-            width = UnitConvertor(72, Unit::Inch, Unit::Px);
-            height = UnitConvertor(144, Unit::Inch, Unit::Px);
-        break;
-
-        default:
-            break;
-    }
-
-    return QSizeF(width, height);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QString VPSheet::GetTemplateName(PaperSizeTemplate tmpl)
-{
-    QString tmplName;
-    switch (tmpl)
-    {
-        case PaperSizeTemplate::A0:
-            tmplName = QString("A0");
-        break;
-
-        case PaperSizeTemplate::A1:
-            tmplName = QString("A1");
-        break;
-
-        case PaperSizeTemplate::A2:
-            tmplName = QString("A2");
-        break;
-
-        case PaperSizeTemplate::A3:
-            tmplName = QString("A3");
-        break;
-
-        case PaperSizeTemplate::A4:
-            tmplName = QString("A4");
-        break;
-
-        case PaperSizeTemplate::Letter:
-            tmplName = tr("Letter");
-        break;
-
-        case PaperSizeTemplate::Legal:
-            tmplName = tr("Legal");
-        break;
-
-        case PaperSizeTemplate::Tabloid:
-            tmplName = tr("Tabloid");
-        break;
-
-        case PaperSizeTemplate::Roll24in:
-            tmplName = tr("Roll 24in");
-        break;
-
-        case PaperSizeTemplate::Roll30in:
-            tmplName = tr("Roll 30in");
-        break;
-
-        case PaperSizeTemplate::Roll36in:
-            tmplName = tr("Roll 36in");
-        break;
-
-        case PaperSizeTemplate::Roll42in:
-            tmplName = tr("Roll 42in");
-        break;
-
-        case PaperSizeTemplate::Roll44in:
-            tmplName = tr("Roll 44in");
-        break;
-
-        case PaperSizeTemplate::Roll48in:
-            tmplName = tr("Roll 48in");
-        break;
-
-        case PaperSizeTemplate::Roll62in:
-            tmplName = tr("Roll 62in");
-        break;
-
-        case PaperSizeTemplate::Roll72in:
-            tmplName = tr("Roll 72in");
-        break;
-
-        case PaperSizeTemplate::Custom:
-            tmplName = tr("Custom");
-        break;
-
-        default:
-            break;
-    }
-
-    if(not tmplName.isEmpty())
-    {
-        tmplName += " " + QStringLiteral("(%1ppi)").arg(PrintDPI);
-    }
-
-    return tmplName;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-PaperSizeTemplate VPSheet::GetTemplate(QSizeF size)
-{
-    Q_UNUSED(size);
-    // TODO, float comparision not safe and problems with
-    // inch / cm
-
-//    const int max = static_cast<int>(PaperSizeTemplate::Custom);
-
-//    for (int i=0; i < max; i++)
-//    {
-//        PaperSizeTemplate tmpl = static_cast<PaperSizeTemplate>(i);
-//        const QSizeF tmplSize = GetTemplateSize(tmpl);
-
-//        if(size.width() == tmplSize.width())
-//        {
-//            if(isRollTemplate(tmpl))
-//            {
-//                return tmpl;
-//            }
-//            else if(size.height() == tmplSize.height())
-//            {
-//                return tmpl;
-//            }
-//        }
-//    }
-
-    return PaperSizeTemplate::Custom;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-bool VPSheet::isRollTemplate(PaperSizeTemplate tmpl)
-{
-    switch (tmpl) {
-        case PaperSizeTemplate::Roll24in:
-        case PaperSizeTemplate::Roll30in:
-        case PaperSizeTemplate::Roll36in:
-        case PaperSizeTemplate::Roll42in:
-        case PaperSizeTemplate::Roll44in:
-        case PaperSizeTemplate::Roll48in:
-        case PaperSizeTemplate::Roll62in:
-        case PaperSizeTemplate::Roll72in:
-            return true;
-        default:
-            return false;
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::PopulateComboBox(QVector<PaperSizeTemplate> *tmpls, QComboBox* comboBox)
-{
-    const QIcon icoPaper("://puzzleicon/16x16/template.png");
-    const QIcon icoRoll("://puzzleicon/16x16/roll.png");
-
-    QIcon icon;
-    for (auto tmpl : *tmpls)
-    {
-        icon = (isRollTemplate(tmpl))? icoRoll : icoPaper;
-        comboBox->addItem(icon, GetTemplateName(tmpl), QVariant(static_cast<int>(tmpl)));
-    }
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-VPLayout* VPSheet::GetLayout()
 {
     return m_layout;
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-VPPieceList* VPSheet::GetPieceList()
+auto VPSheet::GetPieces() const -> QList<VPPiece *>
 {
-    return m_pieceList;
+    QList<VPPiece *> list;
+
+    if (m_layout != nullptr)
+    {
+        return m_layout->PiecesForSheet(this);
+    }
+
+    return {};
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-QString VPSheet::GetName() const
+auto VPSheet::GetName() const -> QString
 {
     return m_name;
 }
@@ -309,222 +67,3 @@ void VPSheet::SetName(const QString &name)
 {
     m_name = name;
 }
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetSize(qreal width, qreal height)
-{
-    m_size.setWidth(width);
-    m_size.setHeight(height);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetSizeConverted(qreal width, qreal height)
-{
-    m_size.setWidth(UnitConvertor(width, m_layout->GetUnit(), Unit::Px));
-    m_size.setHeight(UnitConvertor(height, m_layout->GetUnit(), Unit::Px));
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetSize(const QSizeF &size)
-{
-    m_size = size;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetSizeConverted(const QSizeF &size)
-{
-    m_size = QSizeF(
-                UnitConvertor(size.width(), m_layout->GetUnit(), Unit::Px),
-                UnitConvertor(size.height(), m_layout->GetUnit(), Unit::Px)
-                );
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QSizeF VPSheet::GetSheetSize() const
-{
-    return m_size;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QSizeF VPSheet::GetSheetSizeConverted() const
-{
-    QSizeF convertedSize = QSizeF(
-                UnitConvertor(m_size.width(), Unit::Px, m_layout->GetUnit()),
-                UnitConvertor(m_size.height(), Unit::Px, m_layout->GetUnit())
-                );
-
-    return convertedSize;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-PageOrientation VPSheet::GetOrientation()
-{
-    return m_orientation;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetOrientation(PageOrientation orientation)
-{
-    if(orientation != m_orientation)
-    {
-        m_orientation = orientation;
-    }
-}
-
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetMargins(qreal left, qreal top, qreal right, qreal bottom)
-{
-    m_margins.setLeft(left);
-    m_margins.setTop(top);
-    m_margins.setRight(right);
-    m_margins.setBottom(bottom);
-}
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetMarginsConverted(qreal left, qreal top, qreal right, qreal bottom)
-{
-    m_margins.setLeft(UnitConvertor(left, m_layout->GetUnit(), Unit::Px));
-    m_margins.setTop(UnitConvertor(top, m_layout->GetUnit(), Unit::Px));
-    m_margins.setRight(UnitConvertor(right, m_layout->GetUnit(), Unit::Px));
-    m_margins.setBottom(UnitConvertor(bottom, m_layout->GetUnit(), Unit::Px));
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetMargins(const QMarginsF &margins)
-{
-    m_margins = margins;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetSheetMarginsConverted(const QMarginsF &margins)
-{
-    m_margins = UnitConvertor(margins, m_layout->GetUnit(), Unit::Px);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QMarginsF VPSheet::GetSheetMargins() const
-{
-    return m_margins;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-QMarginsF VPSheet::GetSheetMarginsConverted() const
-{
-    return UnitConvertor(m_margins, Unit::Px, m_layout->GetUnit());
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetFollowGrainline(FollowGrainline state)
-{
-    m_followGrainLine = state;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-FollowGrainline VPSheet::GetFollowGrainline() const
-{
-    return m_followGrainLine;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetPiecesGap(qreal value)
-{
-    m_piecesGap = value;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetPiecesGapConverted(qreal value)
-{
-    m_piecesGap = UnitConvertor(value, m_layout->GetUnit(), Unit::Px);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-qreal VPSheet::GetPiecesGap() const
-{
-    return m_piecesGap;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-qreal VPSheet::GetPiecesGapConverted() const
-{
-    return UnitConvertor(m_piecesGap, Unit::Px, m_layout->GetUnit());
-}
-
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetStickyEdges(bool state)
-{
-    m_stickyEdges = state;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-bool VPSheet::GetStickyEdges() const
-{
-    return m_stickyEdges;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::ClearSelection()
-{
-    m_pieceList->ClearSelection();
-}
-
-
-//---------------------------------------------------------------------------------------------------------------------
-bool VPSheet::GetShowGrid()
-{
-    return m_showGrid;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetShowGrid(bool value)
-{
-    m_showGrid = value;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-qreal VPSheet::GetGridColWidth() const
-{
-    return m_gridColWidth;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-qreal VPSheet::GetGridColWidthConverted() const
-{
-    return UnitConvertor(m_gridColWidth, Unit::Px, m_layout->GetUnit());
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetGridColWidth(qreal value)
-{
-    m_gridColWidth = value;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetGridColWidthConverted(qreal value)
-{
-    m_gridColWidth = UnitConvertor(value, m_layout->GetUnit(), Unit::Px);
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-qreal VPSheet::GetGridRowHeight() const
-{
-    return m_gridRowHeight;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-qreal VPSheet::GetGridRowHeightConverted() const
-{
-    return UnitConvertor(m_gridRowHeight, Unit::Px, m_layout->GetUnit());
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetGridRowHeight(qreal value)
-{
-    m_gridRowHeight = value;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-void VPSheet::SetGridRowHeightConverted(qreal value)
-{
-    m_gridRowHeight = UnitConvertor(value, m_layout->GetUnit(), Unit::Px);
-}

src/app/puzzle/vpsheet.h

@@ -36,35 +36,8 @@
 
 #include "def.h"
 
-// is this the right place for the definition?
-enum class FollowGrainline : qint8 {
-    No = 0,
-    Follow90 = 1,
-    Follow180 = 2
-};
-
-enum class PaperSizeTemplate : qint8 {
-    A0 = 0,
-    A1,
-    A2,
-    A3,
-    A4,
-    Letter,
-    Legal,
-    Tabloid,
-    Roll24in,
-    Roll30in,
-    Roll36in,
-    Roll42in,
-    Roll44in,
-    Roll48in,
-    Roll62in,
-    Roll72in,
-    Custom
-};
-
 class VPLayout;
-class VPPieceList;
+class VPPiece;
 
 class VPSheet : public QObject
 {
@@ -72,60 +45,21 @@ class VPSheet : public QObject
 public:
     explicit VPSheet(VPLayout* layout);
 
-    ~VPSheet();
+    virtual ~VPSheet() = default;
-
-    /**
-     * @brief GetTemplateSize Returns the size in Px of the given template
-     * @param tmpl paper size template
-     * @return the size in Px
-     */
-    static QSizeF GetTemplateSize(PaperSizeTemplate tmpl);
-
-    /**
-     * @brief GetTemplateName Returns the name of the given template
-     * @param tmpl paper size template
-     * @return name of the given template
-     */
-    static QString GetTemplateName(PaperSizeTemplate tmpl);
-
-    /**
-     * @brief GetTemplate GetTemplate Returns the template that corresponds to the given size
-     * @param size the Size in Px
-     * @return template that corresponds to the given size
-     */
-    static PaperSizeTemplate GetTemplate(QSizeF size);
-
-    /**
-     * @brief PopulateComboBox Populates the given combo with the given templates
-     * @param tmpls list of paper size templates
-     * @param comboBox pointer to the combobox
-     */
-    static void PopulateComboBox(QVector<PaperSizeTemplate> *tmpls, QComboBox* comboBox);
-
-    /**
-     * @brief isRollTemplate Returns wether the given template is a roll or not.
-     * @param tmpl paper size template
-     * @return true if the given template is a roll
-     */
-    static bool isRollTemplate(PaperSizeTemplate tmpl);
 
     /**
      * @brief GetLayout Returns the Layout of the sheet
      * @return Layout of the sheet
      */
-    VPLayout* GetLayout();
+    auto GetLayout() -> VPLayout*;
 
-    /**
+    auto GetPieces() const -> QList<VPPiece *>;
-     * @brief GetPieceList returns the piece list of the sheet
-     * @return piece list
-     */
-    VPPieceList* GetPieceList();
 
     /**
      * @brief GetName Returns the name of the sheet
      * @return the name
      */
-    QString GetName() const;
+    auto GetName() const -> QString;
 
     /**
      * @brief SetName Sets the name of the sheet to the given name
@@ -133,256 +67,12 @@ public:
      */
     void SetName(const QString &name);
 
-    /**
-     * @brief SetSheetSize sets the size of the sheet, the values have to be in Unit::Px
-     * @param width sheet width
-     * @param height sheet height
-     */
-    void SetSheetSize(qreal width, qreal height);
-
-    /**
-     * @brief SetSheetSize sets the size of the sheet, the values have to be in the layout's unit
-     * @param width sheet width
-     * @param height sheet height
-     */
-    void SetSheetSizeConverted(qreal width, qreal height);
-
-    /**
-     * @brief SetSheetSize sets the size of the sheet, the values have to be in Unit::Px
-     * @param size sheet size
-     */
-    void SetSheetSize(const QSizeF &size);
-    /**
-     * @brief SetSheetSizeConverted sets the size of the sheet, the values have to be in the layout's unit
-     * @param size sheet size
-     */
-    void SetSheetSizeConverted(const QSizeF &size);
-
-    /**
-     * @brief GetSheetSize Returns the size in Unit::Px
-     * @return sheet size in Unit::Px
-     */
-    QSizeF GetSheetSize() const;
-
-    /**
-     * @brief GetSheetSizeConverted Returns the size in the layout's unit
-     * @return the size in the layout's unit
-     */
-    QSizeF GetSheetSizeConverted() const;
-
-    /**
-     * @brief GetOrientation Returns the orientation of the sheet
-     * @return orientation of the sheet
-     */
-    PageOrientation GetOrientation();
-
-    /**
-     * @brief SetOrientation Sets the orientation of the sheet to the given value
-     * @param orientation the new page orientation
-     */
-    void SetOrientation(PageOrientation orientation);
-
-    /**
-     * @brief SetSheetMargins, set the margins of the sheet, the values have to be in Unit::Px
-     * @param left in Unit::Px
-     * @param top in Unit::Px
-     * @param right in Unit::Px
-     * @param bottom in Unit::Px
-     */
-    void SetSheetMargins(qreal left, qreal top, qreal right, qreal bottom);
-
-    /**
-     * @brief SetSheetMargins, set the margins of the sheet, the values have to be in the unit of the layout
-     * @param left in Unit::Px
-     * @param top in Unit::Px
-     * @param right in Unit::Px
-     * @param bottom in Unit::Px
-     */
-    void SetSheetMarginsConverted(qreal left, qreal top, qreal right, qreal bottom);
-
-    /**
-     * @brief SetSheetMargins set the margins of the sheet, the values have to be in Unit::Px
-     * @param margins sheet margins
-     */
-    void SetSheetMargins(const QMarginsF &margins);
-
-    /**
-     * @brief SetSheetMargins set the margins of the sheet, the values have to be in the unit of the layout
-     * @param margins sheet margins
-     */
-    void SetSheetMarginsConverted(const QMarginsF &margins);
-
-    /**
-     * @brief GetSheetMargins Returns the size in Unit::Px
-     * @return the size in Unit::Px
-     */
-    QMarginsF GetSheetMargins() const;
-
-    /**
-     * @brief GetSheetMarginsConverted Returns the margins in the layout's unit
-     * @return the margins in the sheet's unit
-     */
-    QMarginsF GetSheetMarginsConverted() const;
-
-    /**
-     * @brief SetFollowGrainline Sets the type of grainline for the pieces to follow
-     * @param state the type of grainline
-     */
-    void SetFollowGrainline(FollowGrainline state);
-
-    /**
-     * @brief GetFollowGrainline Returns if the sheet's pieces follow a grainline or not
-     * @return wether the pieces follow a grainline and if so, which grainline
-     */
-    FollowGrainline GetFollowGrainline() const;
-
-    /**
-     * @brief SetPiecesGap sets the pieces gap to the given value, the unit has to be in Unit::Px
-     * @param value pieces gap
-     */
-    void SetPiecesGap(qreal value);
-
-    /**
-     * @brief SetPiecesGapConverted sets the pieces gap to the given value, the unit has to be in the layout's unit
-     * @param value pieces gap
-     */
-    void SetPiecesGapConverted(qreal value);
-
-    /**
-     * @brief GetPiecesGap returns the pieces gap in Unit::Px
-     * @return the pieces gap in Unit::Px
-     */
-    qreal GetPiecesGap() const;
-
-    /**
-     * @brief GetPiecesGapConverted returns the pieces gap in the layout's unit
-     * @return the pieces gap in the layout's unit
-     */
-    qreal GetPiecesGapConverted() const;
-
-    /**
-     * @brief ClearSelection goes through the piece list and pieces and calls
-     * SetIsSelected(false) for the pieces that were selected.
-     */
-    void ClearSelection();
-
-    /**
-     * @brief GetShowGrid Returns true if the placement grid has to be shown on the current sheet
-     * @return true if the placement grid has to be shown on the current sheet
-     */
-    bool GetShowGrid();
-
-    /**
-     * @brief SetShowGrid Returns true if the placement grid has to be shown on the current sheet
-     * @param value whether to show the grid or not
-     */
-    void SetShowGrid(bool value);
-
-    /**
-    * @brief GetGridColWidth returns the placement grid column width in Unit::Px
-    * @return the placement grid column width in Unit::Px
-    */
-    qreal GetGridColWidth() const;
-
-    /**
-    * @brief GetGridColWidth returns the placement grid column width in the layout's unit
-    * @return the placement grid column width in the layout's unit
-    */
-    qreal GetGridColWidthConverted() const;
-
-    /**
-     * @brief SetGridColWidth sets the placement grid column width to the given value, the unit has to be Unit::Px
-     * @param value the placement grid column width in Unit::Px
-     */
-    void SetGridColWidth(qreal value);
-
-    /**
-     * @brief SetGridColWidthConverted sets the placement grid column width to the given value, the unit has to be in the layout's unit
-     * @param value the placement grid column width in the layout's unit
-     */
-    void SetGridColWidthConverted(qreal value);
-
-    /**
-    * @brief GetGridRowHeight returns the placement grid row height in Unit::Px
-    * @return the placement grid row height in Unit::Px
-    */
-    qreal GetGridRowHeight() const;
-
-    /**
-    * @brief GetGridRowHeightConverted returns the placement grid row height in the layout's unit
-    * @return the placement grid row height in the layout's unit
-    */
-    qreal GetGridRowHeightConverted() const;
-
-    /**
-     * @brief SetGridRowHeight sets the placement grid row height to the given value, the unit has to be Unit::Px
-     * @param value the placement grid row height in Unit::Px
-     */
-    void SetGridRowHeight(qreal value);
-
-    /**
-     * @brief SetGridRowHeightConverted sets the placement grid row height to the given value, the unit has to be in the layout's unit
-     * @param value the placement grid row height in the layout's unit
-     */
-    void SetGridRowHeightConverted(qreal value);
-
-
-
-
-
-    void SetStickyEdges(bool state);
-    bool GetStickyEdges() const;
-
-
 private:
     Q_DISABLE_COPY(VPSheet)
 
     VPLayout *m_layout;
 
-    VPPieceList *m_pieceList {nullptr};
-
     QString m_name{};
-
-    /**
-     * @brief m_size the Size in Unit::Px
-     */
-    QSizeF m_size{};
-
-    /**
-     * @brief holds the orientation of the sheet
-     */
-    PageOrientation m_orientation {PageOrientation::Portrait};
-
-    // margins
-    /**
-     * @brief m_margins the margins in Unit::Px
-     */
-    QMarginsF m_margins{};
-
-    // control
-    FollowGrainline m_followGrainLine{FollowGrainline::No};
-
-    /**
-     * @brief m_piecesGap the pieces gap in Unit::Px
-     */
-    qreal m_piecesGap{0};
-
-    // placement grid
-    /**
-     * @brief GetShowGrid Returns true if the placement grid has to be shown on the current sheet
-     */
-    bool m_showGrid{false};
-    /**
-     * @brief m_gridColWidth the column width of the placement grid in Unit::Px
-     */
-    qreal m_gridColWidth{0};
-
-    /**
-     * @brief m_gridRowHeight the row height of the placement grid in Unit::Px
-     */
-    qreal m_gridRowHeight{0};
-
-    bool m_stickyEdges{false};
 };
 
 #endif // VPSHEET_H

src/app/puzzle/vptilefactory.cpp

@@ -27,9 +27,9 @@ void VPTileFactory::refreshTileInfos()
 {
     if(m_layout != nullptr)
     {
-        PageOrientation tilesOrientation = m_layout->GetTilesOrientation();
+        PageOrientation tilesOrientation = m_layout->LayoutSettings().GetTilesOrientation();
-        QSizeF tilesSize =  m_layout->GetTilesSize();
+        QSizeF tilesSize =  m_layout->LayoutSettings().GetTilesSize();
-        QMarginsF tilesMargins = m_layout->GetTilesMargins();
+        QMarginsF tilesMargins = m_layout->LayoutSettings().GetTilesMargins();
 
         // sets the drawing height
         m_drawingAreaHeight = (tilesOrientation == PageOrientation::Portrait)?
@@ -44,11 +44,11 @@ void VPTileFactory::refreshTileInfos()
                 tilesMargins.left() + tilesMargins.right() + m_infoStripeWidth;
 
 
-        QSizeF sheetSize = m_layout->GetFocusedSheet()->GetSheetSize();
+        QSizeF sheetSize = m_layout->LayoutSettings().GetSheetSize();
         qreal totalDrawingWidth = 0;
         qreal totaldrawingHeight = 0;
 
-        if(m_layout->GetFocusedSheet()->GetOrientation() == PageOrientation::Portrait)
+        if(m_layout->LayoutSettings().GetOrientation() == PageOrientation::Portrait)
         {
              totalDrawingWidth = sheetSize.width();
              totaldrawingHeight = sheetSize.height();
@@ -68,7 +68,7 @@ void VPTileFactory::refreshTileInfos()
 //---------------------------------------------------------------------------------------------------------------------
 void VPTileFactory::drawTile(QPainter *painter, VPMainGraphicsView *graphicsView, int row, int col)
 {
-    QMarginsF tilesMargins = m_layout->GetTilesMargins();
+    QMarginsF tilesMargins = m_layout->LayoutSettings().GetTilesMargins();
     QPen penTileInfos = QPen(QColor(180,180,180), m_commonSettings->WidthHairLine(), Qt::DashLine, Qt::RoundCap, Qt::RoundJoin);
     QPen penTileDrawing = QPen(Qt::black, m_commonSettings->WidthMainLine(), Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);
 

src/app/puzzle/vptilefactory.h

@@ -45,7 +45,7 @@ class VPTileFactory : QObject
 public:
     VPTileFactory(VPLayout *layout, VCommonSettings *commonSettings);
 
-    ~VPTileFactory();
+    virtual ~VPTileFactory();
 
     /**
      * @brief drawTile draws the tile of given coordinate (row, col) from the

src/app/puzzle/xml/vplayoutfilereader.cpp

@@ -30,6 +30,7 @@
 #include "vplayoutfilereader.h"
 #include "vplayoutfilewriter.h"
 #include "vplayoutliterals.h"
+#include "vpsheet.h"
 #include "../ifc/exception/vexception.h"
 #include "../ifc/exception/vexceptionconversionerror.h"
 
@@ -66,7 +67,14 @@ void VPLayoutFileReader::ReadLayout(VPLayout *layout)
 {
     AssertRootTag(ML::TagLayout);
 
-    const QStringList tags({ML::TagProperties, ML::TagUnplacedPieces, ML::TagSheets});
+    const QStringList tags
+    {
+        ML::TagProperties,     // 0
+        ML::TagUnplacedPieces, // 1
+        ML::TagSheets,         // 2
+        ML::TagSize,           // 3
+        ML::TagMargin          // 4
+    };
 
     while (readNextStartElement())
     {
@@ -81,6 +89,12 @@ void VPLayoutFileReader::ReadLayout(VPLayout *layout)
             case 2: // ML::TagSheets
                 ReadSheets(layout);
                 break;
+            case 3: // size
+                layout->LayoutSettings().SetSheetSize(ReadSize());
+                break;
+            case 4: // margin
+                layout->LayoutSettings().SetSheetMargins(ReadMargins());
+                break;
             default:
                 qCDebug(MLReader, "Ignoring tag %s", qUtf8Printable(name().toString()));
                 skipCurrentElement();
@@ -111,15 +125,15 @@ void VPLayoutFileReader::ReadProperties(VPLayout *layout)
         {
             case 0:// unit
                 qDebug("read unit");
-                layout->SetUnit(StrToUnits(readElementText()));
+                layout->LayoutSettings().SetUnit(StrToUnits(readElementText()));
                 break;
             case 1:// title
                 qDebug("read title");
-                layout->SetTitle(readElementText());
+                layout->LayoutSettings().SetTitle(readElementText());
                 break;
             case 2:// description
                 qDebug("read description");
-                layout->SetDescription(readElementText());
+                layout->LayoutSettings().SetDescription(readElementText());
                 break;
             case 3:// control
                 qDebug("read control");
@@ -143,8 +157,9 @@ void VPLayoutFileReader::ReadControl(VPLayout *layout)
     AssertRootTag(ML::TagControl);
 
     QXmlStreamAttributes attribs = attributes();
-    layout->SetWarningSuperpositionOfPieces(ReadAttributeBool(attribs, ML::AttrWarningSuperposition, trueStr));
+    layout->LayoutSettings().SetWarningSuperpositionOfPieces(
-    layout->SetWarningPiecesOutOfBound(ReadAttributeBool(attribs, ML::AttrWarningOutOfBound, trueStr));
+                ReadAttributeBool(attribs, ML::AttrWarningSuperposition, trueStr));
+    layout->LayoutSettings().SetWarningPiecesOutOfBound(ReadAttributeBool(attribs, ML::AttrWarningOutOfBound, trueStr));
 
     readElementText();
 }
@@ -154,7 +169,7 @@ void VPLayoutFileReader::ReadUnplacedPieces(VPLayout *layout)
 {
     AssertRootTag(ML::TagUnplacedPieces);
 
-    ReadPieceList(layout->GetUnplacedPieceList());
+    ReadPieces(layout);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -163,7 +178,7 @@ void VPLayoutFileReader::ReadTiles(VPLayout *layout)
     AssertRootTag(ML::TagTiles);
 
     QXmlStreamAttributes attribs = attributes();
-    layout->SetShowTiles(ReadAttributeBool(attribs, ML::AttrVisible, falseStr));
+    layout->LayoutSettings().SetShowTiles(ReadAttributeBool(attribs, ML::AttrVisible, falseStr));
 //    attribs.value(ML::AttrMatchingMarks); // TODO
 
     const QStringList tags
@@ -177,10 +192,10 @@ void VPLayoutFileReader::ReadTiles(VPLayout *layout)
         switch (tags.indexOf(name().toString()))
         {
             case 0: // size
-                layout->SetTilesSize(ReadSize());
+                layout->LayoutSettings().SetTilesSize(ReadSize());
                 break;
             case 1: // margin
-                layout->SetTilesMargins(ReadMargins());
+                layout->LayoutSettings().SetTilesMargins(ReadMargins());
                 break;
             default:
                 qCDebug(MLReader, "Ignoring tag %s", qUtf8Printable(name().toString()));
@@ -211,14 +226,6 @@ void VPLayoutFileReader::ReadSheets(VPLayout *layout)
     }
 }
 
-//---------------------------------------------------------------------------------------------------------------------
-void VPLayoutFileReader::ReadSheetPieces(VPSheet *sheet)
-{
-    AssertRootTag(ML::TagPieces);
-
-    ReadPieceList(sheet->GetPieceList());
-}
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPLayoutFileReader::ReadSheet(VPLayout *layout)
 {
@@ -227,9 +234,7 @@ void VPLayoutFileReader::ReadSheet(VPLayout *layout)
     const QStringList tags
     {
         ML::TagName,   // 0
-        ML::TagSize,   // 1
+        ML::TagPieces  // 1
-        ML::TagMargin, // 2
-        ML::TagPieces  // 3
     };
 
     QScopedPointer<VPSheet> sheet (new VPSheet(layout));
@@ -241,17 +246,11 @@ void VPLayoutFileReader::ReadSheet(VPLayout *layout)
             case 0: // name
                 sheet->SetName(readElementText());
                 break;
-            case 1: // size
+            case 1: // pieces
-                sheet->SetSheetSize(ReadSize());
-                break;
-            case 2: // margin
-                sheet->SetSheetMargins(ReadMargins());
-                break;
-            case 3: // pieces
 #if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
-                ReadSheetPieces(sheet.get());
+                ReadPieces(layout, sheet.get());
 #else
-                ReadSheetPieces(sheet.data());
+                ReadPieces(layout, sheet.data());
 #endif
                 break;
             default:
@@ -268,19 +267,16 @@ void VPLayoutFileReader::ReadSheet(VPLayout *layout)
 
 
 //---------------------------------------------------------------------------------------------------------------------
-void VPLayoutFileReader::ReadPieceList(VPPieceList *pieceList)
+void VPLayoutFileReader::ReadPieces(VPLayout *layout, VPSheet *sheet)
 {
-    QXmlStreamAttributes attribs = attributes();
-    pieceList->SetName(ReadAttributeString(attribs, ML::AttrName, tr("Piece List")));
-    pieceList->SetIsVisible(ReadAttributeBool(attribs, ML::AttrVisible, trueStr));
-
     while (readNextStartElement())
     {
         if (name() == ML::TagPiece)
         {
             QScopedPointer<VPPiece>piece(new VPPiece());
             ReadPiece(piece.data());
-            pieceList->AddPiece(piece.take());
+            piece->SetSheet(sheet);
+            layout->AddPiece(piece.take());
         }
         else
         {

src/app/puzzle/xml/vplayoutfilereader.h

@@ -32,7 +32,6 @@
 #include <QXmlStreamReader>
 #include "../ifc/xml/vabstractconverter.h"
 #include "vplayout.h"
-#include "vppiecelist.h"
 #include "vppiece.h"
 
 #include <QLoggingCategory>
@@ -57,9 +56,8 @@ private:
     void ReadTiles(VPLayout *layout);
     void ReadUnplacedPieces(VPLayout *layout);
     void ReadSheets(VPLayout *layout);
-    void ReadSheetPieces(VPSheet *sheet);
     void ReadSheet(VPLayout *layout);
-    void ReadPieceList(VPPieceList *pieceList);
+    void ReadPieces(VPLayout *layout, VPSheet *sheet=nullptr);
     void ReadPiece(VPPiece *piece);
 
     QMarginsF ReadMargins();

src/app/puzzle/xml/vplayoutfilewriter.cpp

@@ -29,7 +29,6 @@
 #include "vplayoutfilewriter.h"
 #include "vplayout.h"
 #include "vpsheet.h"
-#include "vppiecelist.h"
 #include "vppiece.h"
 #include "vplayoutliterals.h"
 #include "../ifc/xml/vlayoutconverter.h"
@@ -57,7 +56,7 @@ void VPLayoutFileWriter::WriteLayout(VPLayout *layout)
                  .arg(APP_VERSION_STR));
 
     WriteProperties(layout);
-    WritePieceList(layout->GetUnplacedPieceList(), ML::TagUnplacedPieces);
+    WritePieceList(layout->GetUnplacedPieces(), ML::TagUnplacedPieces);
     WriteSheets(layout);
 
     writeEndElement(); //layout
@@ -68,13 +67,15 @@ void VPLayoutFileWriter::WriteProperties(VPLayout *layout)
 {
     writeStartElement(ML::TagProperties);
 
-    writeTextElement(ML::TagUnit, UnitsToStr(layout->GetUnit()));
+    writeTextElement(ML::TagUnit, UnitsToStr(layout->LayoutSettings().GetUnit()));
-    writeTextElement(ML::TagTitle, layout->GetTitle());
+    writeTextElement(ML::TagTitle, layout->LayoutSettings().GetTitle());
-    writeTextElement(ML::TagDescription, layout->GetDescription());
+    writeTextElement(ML::TagDescription, layout->LayoutSettings().GetDescription());
+    WriteSize(layout->LayoutSettings().GetSheetSize());
+    WriteMargins(layout->LayoutSettings().GetSheetMargins());
 
     writeStartElement(ML::TagControl);
-    SetAttribute(ML::AttrWarningSuperposition, layout->GetWarningSuperpositionOfPieces());
+    SetAttribute(ML::AttrWarningSuperposition, layout->LayoutSettings().GetWarningSuperpositionOfPieces());
-    SetAttribute(ML::AttrWarningOutOfBound, layout->GetWarningPiecesOutOfBound());
+    SetAttribute(ML::AttrWarningOutOfBound, layout->LayoutSettings().GetWarningPiecesOutOfBound());
     writeEndElement(); // control
 
     WriteTiles(layout);
@@ -102,9 +103,7 @@ void VPLayoutFileWriter::WriteSheet(VPSheet* sheet)
     writeStartElement(ML::TagSheet);
 
     writeTextElement(ML::TagName, sheet->GetName());
-    WriteSize(sheet->GetSheetSize());
+    WritePieceList(sheet->GetPieces(), ML::TagPieces);
-    WriteMargins(sheet->GetSheetMargins());
-    WritePieceList(sheet->GetPieceList(), ML::TagPieces);
 
     writeEndElement(); // sheet
 
@@ -116,26 +115,20 @@ void VPLayoutFileWriter::WriteTiles(VPLayout *layout)
     Q_UNUSED(layout); // to be removed
 
    writeStartElement(ML::TagTiles);
-   SetAttribute(ML::AttrVisible, layout->GetShowTiles());
+   SetAttribute(ML::AttrVisible, layout->LayoutSettings().GetShowTiles());
    SetAttribute(ML::AttrMatchingMarks, "standard"); // TODO / Fixme get the right value
 
-   WriteSize(layout->GetTilesSize());
+   WriteSize(layout->LayoutSettings().GetTilesSize());
-   WriteMargins(layout->GetTilesMargins());
+   WriteMargins(layout->LayoutSettings().GetTilesMargins());
 
    writeEndElement(); // tiles
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VPLayoutFileWriter::WritePieceList(VPPieceList *pieceList, const QString &tagName)
+void VPLayoutFileWriter::WritePieceList(const QList<VPPiece *> &list, const QString &tagName)
 {
     writeStartElement(tagName); // piece list
-    SetAttribute(ML::AttrName, pieceList->GetName());
+    for (auto *piece : list)
-    SetAttribute(ML::AttrVisible, pieceList->GetIsVisible());
-    //  TODO selected info. Not sure how it's saved yet
-    //SetAttribute("selected", pieceList->GetIsSelected());
-
-    QList<VPPiece*> pieces = pieceList->GetPieces();
-    for (auto *piece : pieces)
     {
         WritePiece(piece);
     }

src/app/puzzle/xml/vplayoutfilewriter.h

@@ -58,7 +58,7 @@ private:
     void WriteSheets(VPLayout *layout);
     void WriteSheet(VPSheet* sheet);
     void WriteTiles(VPLayout *layout);
-    void WritePieceList(VPPieceList *pieceList, const QString &tagName);
+    void WritePieceList(const QList<VPPiece *> &list, const QString &tagName);
     void WritePiece(VPPiece *piece);
 
     void WriteMargins(const QMarginsF &margins);