Merge branch 'calamares' of https://github.com/calamares/calamares into development

README.md

@@ -10,8 +10,10 @@
 [![Coverity Scan Build Status](https://scan.coverity.com/projects/5389/badge.svg)](https://scan.coverity.com/projects/5389)
 [![GitHub license](https://img.shields.io/github/license/calamares/calamares.svg)](https://github.com/calamares/calamares/blob/calamares/LICENSE)
 
-| [Report a Bug](https://github.com/calamares/calamares/issues/new) | [Translate](https://www.transifex.com/projects/p/calamares/) | [Contribute](CONTRIBUTING.md) | [Freenode (IRC): #calamares](https://webchat.freenode.net/?channel=#calamares?nick=guest|) | [Wiki](https://github.com/calamares/calamares/wiki) |
+
-|:-----------------------------------------:|:----------------------:|:-----------------------:|:--------------------------:|:--------------------------:|
+| [Report a Bug](https://github.com/calamares/calamares/issues/new) | [Translate](https://www.transifex.com/projects/p/calamares/) | [Contribute](CONTRIBUTING.md) | [Freenode (IRC): #calamares](https://webchat.freenode.net/?channel=#calamares?nick=guest) | [Wiki](https://github.com/calamares/calamares/wiki) |
+|:--:|:--:|:--:|:--:|:--:|
+
 
 > Calamares is a distribution-independent system installer, with an advanced partitioning
 > feature for both manual and automated partitioning operations. Calamares is designed to

src/libcalamares/partition/KPMHelper.h

@@ -0,0 +1,43 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2020 Adriaan de Groot <groot@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+/*
+ * KPMCore header file inclusion.
+ *
+ * Includes the system KPMCore headers without warnings (by switching off
+ * the expected warnings).
+ */
+#ifndef PARTITION_KPMHELPER_H
+#define PARTITION_KPMHELPER_H
+
+// The kpmcore headers are not C++17 warning-proof, especially
+// with picky compilers like Clang 10. Since we use Clang for the
+// find-all-the-warnings case, switch those warnings off for
+// the we-can't-change-them system headers.
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#pragma clang diagnostic ignored "-Wsuggest-destructor-override"
+#pragma clang diagnostic ignored "-Winconsistent-missing-destructor-override"
+#endif
+
+#include <backend/corebackend.h>
+#include <core/device.h>
+#include <core/lvmdevice.h>
+#include <core/partition.h>
+#include <core/partitionrole.h>
+#include <core/partitiontable.h>
+#include <fs/filesystem.h>
+#include <fs/filesystemfactory.h>
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif

src/libcalamares/partition/PartitionQuery.cpp

@@ -27,14 +27,14 @@ using ::Device;
 using ::Partition;
 
 bool
-isPartitionFreeSpace( Partition* partition )
+isPartitionFreeSpace( const Partition* partition )
 {
     return partition->roles().has( PartitionRole::Unallocated );
 }
 
 
 bool
-isPartitionNew( Partition* partition )
+isPartitionNew( const Partition* partition )
 {
 #if defined( WITH_KPMCORE4API )
     constexpr auto NewState = Partition::State::New;
@@ -67,11 +67,15 @@ findPartitionByPath( const QList< Device* >& devices, const QString& path )
     }
 
     for ( auto device : devices )
+    {
         for ( auto it = PartitionIterator::begin( device ); it != PartitionIterator::end( device ); ++it )
+        {
             if ( ( *it )->partitionPath() == path.simplified() )
             {
                 return *it;
             }
+        }
+    }
     return nullptr;
 }
 
@@ -81,11 +85,15 @@ findPartitions( const QList< Device* >& devices, std::function< bool( Partition*
 {
     QList< Partition* > results;
     for ( auto device : devices )
+    {
         for ( auto it = PartitionIterator::begin( device ); it != PartitionIterator::end( device ); ++it )
+        {
             if ( criterionFunction( *it ) )
             {
                 results.append( *it );
             }
+        }
+    }
     return results;
 }
 

src/libcalamares/partition/PartitionQuery.h

@@ -34,14 +34,14 @@ using ::Device;
 using ::Partition;
 
 /** @brief Is this a free-space area? */
-bool isPartitionFreeSpace( Partition* );
+bool isPartitionFreeSpace( const Partition* );
 
 /** @brief Is this partition newly-to-be-created?
  *
  * Returns true if the partition is planned to be created by the installer as
  * opposed to already existing on the disk.
  */
-bool isPartitionNew( Partition* );
+bool isPartitionNew( const Partition* );
 
 /**
  * Iterates on all devices and return the first partition which is (already)

src/modules/keyboard/Config.cpp

@@ -108,7 +108,7 @@ xkbmap_query_grp_option()
     //it's either in the end of line or before the other option so \s or ,
     int lastIndex = outputLine.indexOf( QRegExp( "[\\s,]" ), index );
 
-    return outputLine.mid( index, lastIndex - 1 );
+    return outputLine.mid( index, lastIndex - index );
 }
 
 AdditionalLayoutInfo

src/modules/keyboard/non-ascii-layouts

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+#
 # Layouts stored here need additional layout (usually us) to provide ASCII support for user
 
 #layout   additional-layout   additional-variant   vconsole-keymap

src/modules/locale/timezonewidget/TimeZoneImage.cpp

@@ -24,9 +24,6 @@ static_assert( TimeZoneImageList::zoneCount == ( sizeof( zoneNames ) / sizeof( z
 
 #define ZONE_NAME QStringLiteral( "zone" )
 
-/* static constexpr */ const int TimeZoneImageList::zoneCount;
-/* static constexpr */ const QSize TimeZoneImageList::imageSize;
-
 static_assert( TimeZoneImageList::zoneCount == 37, "Incorrect number of zones" );
 
 TimeZoneImageList::TimeZoneImageList() {}

src/modules/partition/core/PartUtils.cpp

@@ -1,7 +1,7 @@
 /* === This file is part of Calamares - <https://calamares.io> ===
  *
  *   SPDX-FileCopyrightText: 2015-2016 Teo Mrnjavac <teo@kde.org>
- *   Copyright 2018-2019 Adriaan de Groot <groot@kde.org>
+ *   SPDX-FileCopyrightText: 2018-2019 Adriaan de Groot <groot@kde.org>
  *   SPDX-FileCopyrightText: 2019 Collabora Ltd <arnaud.ferraris@collabora.com>
  *   SPDX-License-Identifier: GPL-3.0-or-later
  *

src/modules/partition/core/PartitionCoreModule.cpp

@@ -860,82 +860,10 @@ PartitionCoreModule::setBootLoaderInstallPath( const QString& path )
     m_bootLoaderInstallPath = path;
 }
 
-void
-PartitionCoreModule::initLayout()
-{
-    m_partLayout = new PartitionLayout();
-
-    m_partLayout->addEntry( QString( "/" ), QString( "100%" ) );
-}
-
 void
 PartitionCoreModule::initLayout( const QVariantList& config )
 {
-    bool ok;
+    m_partLayout.init( config );
-    QString sizeString;
-    QString minSizeString;
-    QString maxSizeString;
-
-    m_partLayout = new PartitionLayout();
-
-    for ( const auto& r : config )
-    {
-        QVariantMap pentry = r.toMap();
-
-        if ( !pentry.contains( "name" ) || !pentry.contains( "mountPoint" ) || !pentry.contains( "filesystem" )
-             || !pentry.contains( "size" ) )
-        {
-            cError() << "Partition layout entry #" << config.indexOf( r )
-                     << "lacks mandatory attributes, switching to default layout.";
-            delete ( m_partLayout );
-            initLayout();
-            break;
-        }
-
-        if ( pentry.contains( "size" ) && CalamaresUtils::getString( pentry, "size" ).isEmpty() )
-        {
-            sizeString.setNum( CalamaresUtils::getInteger( pentry, "size", 0 ) );
-        }
-        else
-        {
-            sizeString = CalamaresUtils::getString( pentry, "size" );
-        }
-
-        if ( pentry.contains( "minSize" ) && CalamaresUtils::getString( pentry, "minSize" ).isEmpty() )
-        {
-            minSizeString.setNum( CalamaresUtils::getInteger( pentry, "minSize", 0 ) );
-        }
-        else
-        {
-            minSizeString = CalamaresUtils::getString( pentry, "minSize" );
-        }
-
-        if ( pentry.contains( "maxSize" ) && CalamaresUtils::getString( pentry, "maxSize" ).isEmpty() )
-        {
-            maxSizeString.setNum( CalamaresUtils::getInteger( pentry, "maxSize", 0 ) );
-        }
-        else
-        {
-            maxSizeString = CalamaresUtils::getString( pentry, "maxSize" );
-        }
-
-        if ( !m_partLayout->addEntry( CalamaresUtils::getString( pentry, "name" ),
-                                      CalamaresUtils::getString( pentry, "uuid" ),
-                                      CalamaresUtils::getString( pentry, "type" ),
-                                      CalamaresUtils::getUnsignedInteger( pentry, "attributes", 0 ),
-                                      CalamaresUtils::getString( pentry, "mountPoint" ),
-                                      CalamaresUtils::getString( pentry, "filesystem" ),
-                                      CalamaresUtils::getSubMap( pentry, "features", ok ),
-                                      sizeString,
-                                      minSizeString,
-                                      maxSizeString ) )
-        {
-            cError() << "Partition layout entry #" << config.indexOf( r ) << "is invalid, switching to default layout.";
-            delete ( m_partLayout );
-            initLayout();
-            break;
-        }
-    }
 }
 
 void
@@ -947,7 +875,7 @@ PartitionCoreModule::layoutApply( Device* dev,
                                   const PartitionRole& role )
 {
     bool isEfi = PartUtils::isEfiSystem();
-    QList< Partition* > partList = m_partLayout->execute( dev, firstSector, lastSector, luksPassphrase, parent, role );
+    QList< Partition* > partList = m_partLayout.createPartitions( dev, firstSector, lastSector, luksPassphrase, parent, role );
 
     // Partition::mountPoint() tells us where it is mounted **now**, while
     // PartitionInfo::mountPoint() says where it will be mounted in the target system.

src/modules/partition/core/PartitionCoreModule.h

@@ -156,8 +156,7 @@ public:
     /// @brief Set the path where the bootloader will be installed
     void setBootLoaderInstallPath( const QString& path );
 
-    void initLayout();
+    void initLayout( const QVariantList& config = QVariantList() );
-    void initLayout( const QVariantList& config );
 
     void layoutApply( Device* dev, qint64 firstSector, qint64 lastSector, QString luksPassphrase );
     void layoutApply( Device* dev,
@@ -256,7 +255,7 @@ private:
     bool m_hasRootMountPoint = false;
     bool m_isDirty = false;
     QString m_bootLoaderInstallPath;
-    PartitionLayout* m_partLayout;
+    PartitionLayout m_partLayout;
 
     OsproberEntryList m_osproberLines;
 

src/modules/partition/core/PartitionLayout.cpp

@@ -21,6 +21,8 @@
 #include "core/PartitionActions.h"
 #include "core/PartitionInfo.h"
 
+#include "utils/Variant.h"
+
 #include <kpmcore/core/device.h>
 #include <kpmcore/core/partition.h>
 #include <kpmcore/fs/filesystem.h>
@@ -48,12 +50,6 @@ PartitionLayout::PartitionLayout()
 {
 }
 
-PartitionLayout::PartitionLayout( PartitionLayout::PartitionEntry entry )
-    : PartitionLayout()
-{
-    m_partLayout.append( entry );
-}
-
 PartitionLayout::PartitionLayout( const PartitionLayout& layout )
     : m_defaultFsType( layout.m_defaultFsType )
     , m_partLayout( layout.m_partLayout )
@@ -62,59 +58,21 @@ PartitionLayout::PartitionLayout( const PartitionLayout& layout )
 
 PartitionLayout::~PartitionLayout() {}
 
-bool
-PartitionLayout::addEntry( PartitionLayout::PartitionEntry entry )
-{
-    if ( !entry.isValid() )
-    {
-        cError() << "Partition size is invalid or has min size > max size";
-        return false;
-    }
-
-    m_partLayout.append( entry );
-
-    return true;
-}
-
 PartitionLayout::PartitionEntry::PartitionEntry()
     : partAttributes( 0 )
 {
 }
 
-PartitionLayout::PartitionEntry::PartitionEntry( const QString& size, const QString& min, const QString& max )
+PartitionLayout::PartitionEntry::PartitionEntry( const QString& mountPoint, const QString& size, const QString& minSize, const QString& maxSize )
     : partAttributes( 0 )
+    , partMountPoint( mountPoint )
     , partSize( size )
-    , partMinSize( min )
+    , partMinSize( minSize )
-    , partMaxSize( max )
+    , partMaxSize( maxSize )
 {
 }
 
-bool
+PartitionLayout::PartitionEntry::PartitionEntry( const QString& label,
-PartitionLayout::addEntry( const QString& mountPoint, const QString& size, const QString& min, const QString& max )
-{
-    PartitionLayout::PartitionEntry entry( size, min, max );
-
-    if ( !entry.isValid() )
-    {
-        cError() << "Partition size" << size << "is invalid or" << min << ">" << max;
-        return false;
-    }
-    if ( mountPoint.isEmpty() || !mountPoint.startsWith( QString( "/" ) ) )
-    {
-        cError() << "Partition mount point" << mountPoint << "is invalid";
-        return false;
-    }
-
-    entry.partMountPoint = mountPoint;
-    entry.partFileSystem = m_defaultFsType;
-
-    m_partLayout.append( entry );
-
-    return true;
-}
-
-bool
-PartitionLayout::addEntry( const QString& label,
                                                  const QString& uuid,
                                                  const QString& type,
                                                  quint64 attributes,
@@ -122,41 +80,94 @@ PartitionLayout::addEntry( const QString& label,
                                                  const QString& fs,
                                                  const QVariantMap& features,
                                                  const QString& size,
-                           const QString& min,
+                                                 const QString& minSize,
-                           const QString& max )
+                                                 const QString& maxSize )
+    : partLabel( label )
+    , partUUID( uuid )
+    , partType( type )
+    , partAttributes( attributes )
+    , partMountPoint( mountPoint )
+    , partFeatures( features )
+    , partSize( size )
+    , partMinSize( minSize )
+    , partMaxSize( maxSize )
 {
-    PartitionLayout::PartitionEntry entry( size, min, max );
+    PartUtils::findFS( fs, &partFileSystem );
+}
 
+PartitionLayout::PartitionEntry::PartitionEntry( const PartitionEntry& e )
+    : partLabel( e.partLabel )
+    , partUUID( e.partUUID )
+    , partType( e.partType )
+    , partAttributes( e.partAttributes )
+    , partMountPoint( e.partMountPoint )
+    , partFileSystem( e.partFileSystem )
+    , partFeatures( e.partFeatures )
+    , partSize( e.partSize )
+    , partMinSize( e.partMinSize )
+    , partMaxSize( e.partMaxSize )
+{
+}
+
+
+bool
+PartitionLayout::addEntry( const PartitionEntry& entry )
+{
     if ( !entry.isValid() )
     {
-        cError() << "Partition size" << size << "is invalid or" << min << ">" << max;
         return false;
     }
-    if ( mountPoint.isEmpty() || !mountPoint.startsWith( QString( "/" ) ) )
-    {
-        cError() << "Partition mount point" << mountPoint << "is invalid";
-        return false;
-    }
-
-    entry.partLabel = label;
-    entry.partUUID = uuid;
-    entry.partType = type;
-    entry.partAttributes = attributes;
-    entry.partMountPoint = mountPoint;
-    PartUtils::findFS( fs, &entry.partFileSystem );
-    if ( entry.partFileSystem == FileSystem::Unknown )
-    {
-        entry.partFileSystem = m_defaultFsType;
-    }
-    entry.partFeatures = features;
 
     m_partLayout.append( entry );
 
     return true;
 }
 
+void
+PartitionLayout::init( const QVariantList& config )
+{
+    bool ok;
+
+    m_partLayout.clear();
+
+    for ( const auto& r : config )
+    {
+        QVariantMap pentry = r.toMap();
+
+        if ( !pentry.contains( "name" ) || !pentry.contains( "mountPoint" ) || !pentry.contains( "filesystem" )
+             || !pentry.contains( "size" ) )
+        {
+            cError() << "Partition layout entry #" << config.indexOf( r )
+                     << "lacks mandatory attributes, switching to default layout.";
+            m_partLayout.clear();
+            break;
+        }
+
+        if ( !addEntry( { CalamaresUtils::getString( pentry, "name" ),
+                          CalamaresUtils::getString( pentry, "uuid" ),
+                          CalamaresUtils::getString( pentry, "type" ),
+                          CalamaresUtils::getUnsignedInteger( pentry, "attributes", 0 ),
+                          CalamaresUtils::getString( pentry, "mountPoint" ),
+                          CalamaresUtils::getString( pentry, "filesystem" ),
+                          CalamaresUtils::getSubMap( pentry, "features", ok ),
+                          CalamaresUtils::getString( pentry, "size", QStringLiteral( "0" ) ),
+                          CalamaresUtils::getString( pentry, "minSize", QStringLiteral( "0" ) ),
+                          CalamaresUtils::getString( pentry, "maxSize", QStringLiteral( "0" ) ) } ) )
+        {
+            cError() << "Partition layout entry #" << config.indexOf( r ) << "is invalid, switching to default layout.";
+            m_partLayout.clear();
+            break;
+        }
+    }
+
+    if ( !m_partLayout.count() )
+    {
+        addEntry( { QString( "/" ), QString( "100%" ) } );
+    }
+}
+
 QList< Partition* >
-PartitionLayout::execute( Device* dev,
+PartitionLayout::createPartitions( Device* dev,
                                    qint64 firstSector,
                                    qint64 lastSector,
                                    QString luksPassphrase,
@@ -165,167 +176,129 @@ PartitionLayout::execute( Device* dev,
 {
     QList< Partition* > partList;
     // Map each partition entry to its requested size (0 when calculated later)
-    QMap< const PartitionLayout::PartitionEntry*, qint64 > partSizeMap;
+    QMap< const PartitionLayout::PartitionEntry*, qint64 > partSectorsMap;
-    qint64 totalSize = lastSector - firstSector + 1;
+    const qint64 totalSectors = lastSector - firstSector + 1;
-    qint64 availableSize = totalSize;
+    qint64 currentSector, availableSectors = totalSectors;
 
-    // Let's check if we have enough space for each partSize
+    // Let's check if we have enough space for each partitions, using the size
-    for ( const auto& part : qAsConst( m_partLayout ) )
+    // propery or the min-size property if unit is in percentage.
+    for ( const auto& entry : qAsConst( m_partLayout ) )
     {
-        if ( !part.partSize.isValid() )
+        if ( !entry.partSize.isValid() )
         {
-            cWarning() << "Partition" << part.partMountPoint << "size is invalid, skipping...";
+            cWarning() << "Partition" << entry.partMountPoint << "size is invalid, skipping...";
             continue;
         }
 
         // Calculate partition size: Rely on "possibly uninitialized use"
         // warnings to ensure that all the cases are covered below.
-        qint64 size;
         // We need to ignore the percent-defined until later
-        if ( part.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
+        qint64 sectors = 0;
+        if ( entry.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
         {
-            size = part.partSize.toSectors( totalSize, dev->logicalSize() );
+            sectors = entry.partSize.toSectors( totalSectors, dev->logicalSize() );
         }
-        else
+        else if ( entry.partMinSize.isValid() )
         {
-            if ( part.partMinSize.isValid() )
+            sectors = entry.partMinSize.toSectors( totalSectors, dev->logicalSize() );
-            {
-                size = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
         }
-            else
+        partSectorsMap.insert( &entry, sectors );
+        availableSectors -= sectors;
+    }
+
+    // There is not enough space for all partitions, use the min-size property
+    // and see if we can do better afterward.
+    if ( availableSectors < 0 )
     {
-                size = 0;
+        availableSectors = totalSectors;
+        for ( const auto& entry : qAsConst( m_partLayout ) )
+        {
+            qint64 sectors = partSectorsMap.value( &entry );
+            if ( entry.partMinSize.isValid() )
+            {
+                sectors = entry.partMinSize.toSectors( totalSectors, dev->logicalSize() );
+                partSectorsMap.insert( &entry, sectors );
+            }
+            availableSectors -= sectors;
         }
     }
 
-        partSizeMap.insert( &part, size );
+    // Assign sectors for percentage-defined partitions.
-        availableSize -= size;
+    for ( const auto& entry : qAsConst( m_partLayout ) )
+    {
+        if ( entry.partSize.unit() == CalamaresUtils::Partition::SizeUnit::Percent )
+        {
+            qint64 sectors = entry.partSize.toSectors( availableSectors + partSectorsMap.value( &entry ),
+                                                      dev->logicalSize() );
+            if ( entry.partMinSize.isValid() )
+            {
+                sectors = std::max( sectors, entry.partMinSize.toSectors( totalSectors, dev->logicalSize() ) );
             }
-
+            if ( entry.partMaxSize.isValid() )
-    // Use partMinSize and see if we can do better afterward.
-    if ( availableSize < 0 )
             {
-        availableSize = totalSize;
+                sectors = std::min( sectors, entry.partMaxSize.toSectors( totalSectors, dev->logicalSize() ) );
-        for ( const auto& part : qAsConst( m_partLayout ) )
-        {
-            qint64 size;
-
-            if ( part.partMinSize.isValid() )
-            {
-                size = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
             }
-            else if ( part.partSize.isValid() )
+            partSectorsMap.insert( &entry, sectors );
-            {
-                if ( part.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
-                {
-                    size = part.partSize.toSectors( totalSize, dev->logicalSize() );
-                }
-                else
-                {
-                    size = 0;
-                }
-            }
-            else
-            {
-                size = 0;
-            }
-
-            partSizeMap.insert( &part, size );
-            availableSize -= size;
         }
     }
 
-    // Assign size for percentage-defined partitions
+    // Create the partitions.
-    for ( const auto& part : qAsConst( m_partLayout ) )
+    currentSector = firstSector;
+    availableSectors = totalSectors;
+    for ( const auto& entry : qAsConst( m_partLayout ) )
     {
-        if ( part.partSize.unit() == CalamaresUtils::Partition::SizeUnit::Percent )
+        // Adjust partition size based on available space.
+        qint64 sectors = partSectorsMap.value( &entry );
+        sectors = std::min( sectors, availableSectors );
+        if ( sectors == 0 )
         {
-            qint64 size = partSizeMap.value( &part );
+            continue;
-            size = part.partSize.toSectors( availableSize + size, dev->logicalSize() );
-            if ( part.partMinSize.isValid() )
-            {
-                qint64 minSize = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
-                if ( minSize > size )
-                {
-                    size = minSize;
-                }
-            }
-            if ( part.partMaxSize.isValid() )
-            {
-                qint64 maxSize = part.partMaxSize.toSectors( totalSize, dev->logicalSize() );
-                if ( maxSize < size )
-                {
-                    size = maxSize;
-                }
         }
 
-            partSizeMap.insert( &part, size );
+        Partition* part = nullptr;
-        }
-    }
-
-    availableSize = totalSize;
-
-    // TODO: Refine partition sizes to make sure there is room for every partition
-    // Use a default (200-500M ?) minimum size for partition without minSize
-
-    for ( const auto& part : qAsConst( m_partLayout ) )
-    {
-        qint64 size, end;
-        Partition* currentPartition = nullptr;
-
-        size = partSizeMap.value( &part );
-
-        // Adjust partition size based on available space
-        if ( size > availableSize )
-        {
-            size = availableSize;
-        }
-
-        end = firstSector + std::max( size - 1, Q_INT64_C( 0 ) );
-
         if ( luksPassphrase.isEmpty() )
         {
-            currentPartition = KPMHelpers::createNewPartition(
+            part = KPMHelpers::createNewPartition(
-                parent, *dev, role, part.partFileSystem, firstSector, end, KPM_PARTITION_FLAG( None ) );
+                parent, *dev, role, entry.partFileSystem, currentSector, currentSector + sectors - 1, KPM_PARTITION_FLAG( None ) );
         }
         else
         {
-            currentPartition = KPMHelpers::createNewEncryptedPartition(
+            part = KPMHelpers::createNewEncryptedPartition(
-                parent, *dev, role, part.partFileSystem, firstSector, end, luksPassphrase, KPM_PARTITION_FLAG( None ) );
+                parent, *dev, role, entry.partFileSystem, currentSector, currentSector + sectors - 1, luksPassphrase, KPM_PARTITION_FLAG( None ) );
         }
-        PartitionInfo::setFormat( currentPartition, true );
+        PartitionInfo::setFormat( part, true );
-        PartitionInfo::setMountPoint( currentPartition, part.partMountPoint );
+        PartitionInfo::setMountPoint( part, entry.partMountPoint );
-        if ( !part.partLabel.isEmpty() )
+        if ( !entry.partLabel.isEmpty() )
         {
-            currentPartition->setLabel( part.partLabel );
+            part->setLabel( entry.partLabel );
-            currentPartition->fileSystem().setLabel( part.partLabel );
+            part->fileSystem().setLabel( entry.partLabel );
         }
-        if ( !part.partUUID.isEmpty() )
+        if ( !entry.partUUID.isEmpty() )
         {
-            currentPartition->setUUID( part.partUUID );
+            part->setUUID( entry.partUUID );
         }
-        if ( !part.partType.isEmpty() )
+        if ( !entry.partType.isEmpty() )
         {
 #if defined( WITH_KPMCORE42API )
-            currentPartition->setType( part.partType );
+            part->setType( entry.partType );
 #else
             cWarning() << "Ignoring type; requires KPMcore >= 4.2.0.";
 #endif
         }
-        if ( part.partAttributes )
+        if ( entry.partAttributes )
         {
 #if defined( WITH_KPMCORE42API )
-            currentPartition->setAttributes( part.partAttributes );
+            part->setAttributes( entry.partAttributes );
 #else
             cWarning() << "Ignoring attributes; requires KPMcore >= 4.2.0.";
 #endif
         }
-        if ( !part.partFeatures.isEmpty() )
+        if ( !entry.partFeatures.isEmpty() )
         {
 #if defined( WITH_KPMCORE42API )
-            for ( const auto& k : part.partFeatures.keys() )
+            for ( const auto& k : entry.partFeatures.keys() )
             {
-                currentPartition->fileSystem().addFeature( k, part.partFeatures.value( k ) );
+                part->fileSystem().addFeature( k, entry.partFeatures.value( k ) );
             }
 #else
             cWarning() << "Ignoring features; requires KPMcore >= 4.2.0.";
@@ -333,9 +306,9 @@ PartitionLayout::execute( Device* dev,
         }
         // Some buggy (legacy) BIOSes test if the bootflag of at least one partition is set.
         // Otherwise they ignore the device in boot-order, so add it here.
-        partList.append( currentPartition );
+        partList.append( part );
-        firstSector = end + 1;
+        currentSector += sectors;
-        availableSize -= size;
+        availableSectors -= sectors;
     }
 
     return partList;

src/modules/partition/core/PartitionLayout.h

@@ -44,8 +44,24 @@ public:
 
         /// @brief All-zeroes PartitionEntry
         PartitionEntry();
-        /// @brief Parse @p size, @p min and @p max to their respective member variables
+        /// @brief Parse @p mountPoint, @p size, @p minSize and @p maxSize to their respective member variables
-        PartitionEntry( const QString& size, const QString& min, const QString& max );
+        PartitionEntry( const QString& mountPoint,
+                        const QString& size,
+                        const QString& minSize = QString(),
+                        const QString& maxSize = QString() );
+        /// @brief All-field PartitionEntry
+        PartitionEntry( const QString& label,
+                        const QString& uuid,
+                        const QString& type,
+                        quint64 attributes,
+                        const QString& mountPoint,
+                        const QString& fs,
+                        const QVariantMap& features,
+                        const QString& size,
+                        const QString& minSize = QString(),
+                        const QString& maxSize = QString() );
+        /// @brief Copy PartitionEntry
+        PartitionEntry( const PartitionEntry& e );
 
         bool isValid() const
         {
@@ -59,31 +75,17 @@ public:
     };
 
     PartitionLayout();
-    PartitionLayout( PartitionEntry entry );
     PartitionLayout( const PartitionLayout& layout );
     ~PartitionLayout();
 
-    bool addEntry( PartitionEntry entry );
+    void init( const QVariantList& config );
-    bool addEntry( const QString& mountPoint,
+    bool addEntry( const PartitionEntry& entry );
-                   const QString& size,
-                   const QString& min = QString(),
-                   const QString& max = QString() );
-    bool addEntry( const QString& label,
-                   const QString& uuid,
-                   const QString& type,
-                   quint64 attributes,
-                   const QString& mountPoint,
-                   const QString& fs,
-                   const QVariantMap& features,
-                   const QString& size,
-                   const QString& min = QString(),
-                   const QString& max = QString() );
 
     /**
      * @brief Apply the current partition layout to the selected drive space.
      * @return  A list of Partition objects.
      */
-    QList< Partition* > execute( Device* dev,
+    QList< Partition* > createPartitions( Device* dev,
                                           qint64 firstSector,
                                           qint64 lastSector,
                                           QString luksPassphrase,

src/modules/partition/gui/ChoicePage.cpp

@@ -736,14 +736,12 @@ ChoicePage::doReplaceSelectedPartition( const QModelIndex& current )
         return;
     }
 
+    // This will be deleted by the second lambda, below.
     QString* homePartitionPath = new QString();
-    bool doReuseHomePartition = m_reuseHomeCheckBox->isChecked();
 
-    // NOTE: using by-ref captures because we need to write homePartitionPath and
-    //       doReuseHomePartition *after* the device revert, for later use.
     ScanningDialog::run(
         QtConcurrent::run(
-            [this, current]( QString* homePartitionPath, bool doReuseHomePartition ) {
+            [this, current, homePartitionPath]( bool doReuseHomePartition ) {
                 QMutexLocker locker( &m_coreMutex );
 
                 if ( m_core->isDirty() )
@@ -823,9 +821,8 @@ ChoicePage::doReplaceSelectedPartition( const QModelIndex& current )
                     }
                 }
             },
-            homePartitionPath,
+            m_reuseHomeCheckBox->isChecked() ),
-            doReuseHomePartition ),
+        [this, homePartitionPath] {
-        [=] {
             m_reuseHomeCheckBox->setVisible( !homePartitionPath->isEmpty() );
             if ( !homePartitionPath->isEmpty() )
                 m_reuseHomeCheckBox->setText( tr( "Reuse %1 as home partition for %2." )
@@ -906,7 +903,9 @@ ChoicePage::updateDeviceStatePreview()
         m_beforePartitionBarsView->setSelectionMode( QAbstractItemView::SingleSelection );
         m_beforePartitionLabelsView->setSelectionMode( QAbstractItemView::SingleSelection );
         break;
-    default:
+    case InstallChoice::NoChoice:
+    case InstallChoice::Erase:
+    case InstallChoice::Manual:
         m_beforePartitionBarsView->setSelectionMode( QAbstractItemView::NoSelection );
         m_beforePartitionLabelsView->setSelectionMode( QAbstractItemView::NoSelection );
     }
@@ -990,7 +989,7 @@ ChoicePage::updateActionChoicePreview( InstallChoice choice )
         m_previewAfterFrame->show();
         m_previewAfterLabel->show();
 
-        SelectionFilter filter = [this]( const QModelIndex& index ) {
+        SelectionFilter filter = []( const QModelIndex& index ) {
             return PartUtils::canBeResized(
                 static_cast< Partition* >( index.data( PartitionModel::PartitionPtrRole ).value< void* >() ) );
         };
@@ -1079,7 +1078,7 @@ ChoicePage::updateActionChoicePreview( InstallChoice choice )
         }
         else
         {
-            SelectionFilter filter = [this]( const QModelIndex& index ) {
+            SelectionFilter filter = []( const QModelIndex& index ) {
                 return PartUtils::canBeReplaced(
                     static_cast< Partition* >( index.data( PartitionModel::PartitionPtrRole ).value< void* >() ) );
             };
@@ -1125,7 +1124,9 @@ ChoicePage::updateActionChoicePreview( InstallChoice choice )
     case InstallChoice::Alongside:
         previewSelectionMode = QAbstractItemView::SingleSelection;
         break;
-    default:
+    case InstallChoice::NoChoice:
+    case InstallChoice::Erase:
+    case InstallChoice::Manual:
         previewSelectionMode = QAbstractItemView::NoSelection;
     }
 
@@ -1179,15 +1180,15 @@ ChoicePage::setupEfiSystemPartitionSelector()
 QComboBox*
 ChoicePage::createBootloaderComboBox( QWidget* parent )
 {
-    QComboBox* bcb = new QComboBox( parent );
+    QComboBox* comboForBootloader = new QComboBox( parent );
-    bcb->setModel( m_core->bootLoaderModel() );
+    comboForBootloader->setModel( m_core->bootLoaderModel() );
 
     // When the chosen bootloader device changes, we update the choice in the PCM
-    connect( bcb, QOverload< int >::of( &QComboBox::currentIndexChanged ), this, [this]( int newIndex ) {
+    connect( comboForBootloader, QOverload< int >::of( &QComboBox::currentIndexChanged ), this, [this]( int newIndex ) {
-        QComboBox* bcb = qobject_cast< QComboBox* >( sender() );
+        QComboBox* bootloaderCombo = qobject_cast< QComboBox* >( sender() );
-        if ( bcb )
+        if ( bootloaderCombo )
         {
-            QVariant var = bcb->itemData( newIndex, BootLoaderModel::BootLoaderPathRole );
+            QVariant var = bootloaderCombo->itemData( newIndex, BootLoaderModel::BootLoaderPathRole );
             if ( !var.isValid() )
             {
                 return;
@@ -1196,7 +1197,7 @@ ChoicePage::createBootloaderComboBox( QWidget* parent )
         }
     } );
 
-    return bcb;
+    return comboForBootloader;
 }
 
 
@@ -1220,7 +1221,6 @@ operator<<( QDebug& s, PartitionIterator& it )
  * @brief ChoicePage::setupActions happens every time a new Device* is selected in the
  *      device picker. Sets up the text and visibility of the partitioning actions based
  *      on the currently selected Device*, bootloader and os-prober output.
- * @param currentDevice
  */
 void
 ChoicePage::setupActions()

src/modules/partition/gui/PartitionViewStep.cpp

@@ -596,15 +596,8 @@ PartitionViewStep::setConfigurationMap( const QVariantMap& configurationMap )
     QFuture< void > future = QtConcurrent::run( this, &PartitionViewStep::initPartitionCoreModule );
     m_future->setFuture( future );
 
-    if ( configurationMap.contains( "partitionLayout" ) )
-    {
     m_core->initLayout( configurationMap.value( "partitionLayout" ).toList() );
 }
-    else
-    {
-        m_core->initLayout();
-    }
-}
 
 
 Calamares::JobList

src/modules/partition/partition.conf

@@ -154,7 +154,19 @@ defaultFileSystemType:  "ext4"
 # If nothing is specified, LUKS is enabled in automated modes.
 #enableLuksAutomatedPartitioning:    true
 
-# To apply a custom partition layout, it has to be defined this way :
+# Partition layout.
+#
+# This optional setting specifies a custom partition layout.
+#
+# If nothing is specified, the default partition layout is a single partition
+# for root that uses 100% of the space and uses the filesystem defined by
+# defaultFileSystemType.
+#
+# Note: the EFI system partition is prepend automatically to the layout if
+# needed; the swap partition is appended to the layout if enabled (small of
+# suspend).
+#
+# Otherwise, the partition layout is defined as follow:
 #
 # partitionLayout:
 #     - name: "rootfs"

src/modules/partition/tests/CreateLayoutsTests.cpp

@@ -15,10 +15,6 @@
 #include "partition/KPMManager.h"
 #include "utils/Logger.h"
 
-#include <core/lvmdevice.h>
-#include <core/partition.h>
-#include <fs/filesystemfactory.h>
-
 #include <memory>
 
 #include <QtTest/QtTest>
@@ -61,12 +57,12 @@ CreateLayoutsTests::testFixedSizePartition()
     PartitionRole role( PartitionRole::Role::Any );
     QList< Partition* > partitions;
 
-    if ( !layout.addEntry( QString( "/" ), QString( "5MiB" ) ) )
+    if ( !layout.addEntry( { QString( "/" ), QString( "5MiB" ) } ) )
     {
         QFAIL( qPrintable( "Unable to create / partition" ) );
     }
 
-    partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
+    partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
 
     QCOMPARE( partitions.count(), 1 );
 
@@ -81,12 +77,12 @@ CreateLayoutsTests::testPercentSizePartition()
     PartitionRole role( PartitionRole::Role::Any );
     QList< Partition* > partitions;
 
-    if ( !layout.addEntry( QString( "/" ), QString( "50%" ) ) )
+    if ( !layout.addEntry( { QString( "/" ), QString( "50%" ) } ) )
     {
         QFAIL( qPrintable( "Unable to create / partition" ) );
     }
 
-    partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
+    partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
 
     QCOMPARE( partitions.count(), 1 );
 
@@ -101,22 +97,22 @@ CreateLayoutsTests::testMixedSizePartition()
     PartitionRole role( PartitionRole::Role::Any );
     QList< Partition* > partitions;
 
-    if ( !layout.addEntry( QString( "/" ), QString( "5MiB" ) ) )
+    if ( !layout.addEntry( { QString( "/" ), QString( "5MiB" ) } ) )
     {
         QFAIL( qPrintable( "Unable to create / partition" ) );
     }
 
-    if ( !layout.addEntry( QString( "/home" ), QString( "50%" ) ) )
+    if ( !layout.addEntry( { QString( "/home" ), QString( "50%" ) } ) )
     {
         QFAIL( qPrintable( "Unable to create /home partition" ) );
     }
 
-    if ( !layout.addEntry( QString( "/bkup" ), QString( "50%" ) ) )
+    if ( !layout.addEntry( { QString( "/bkup" ), QString( "50%" ) } ) )
     {
         QFAIL( qPrintable( "Unable to create /bkup partition" ) );
     }
 
-    partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
+    partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
 
     QCOMPARE( partitions.count(), 3 );
 

src/modules/partition/tests/CreateLayoutsTests.h

@@ -10,8 +10,9 @@
 #ifndef CLEARMOUNTSJOBTESTS_H
 #define CLEARMOUNTSJOBTESTS_H
 
+#include "partition/KPMHelper.h"
+
 #include <QObject>
-#include <core/device.h>
 
 class CreateLayoutsTests : public QObject
 {

src/modules/partition/tests/PartitionJobTests.cpp

@@ -16,14 +16,12 @@
 #include "jobs/CreatePartitionTableJob.h"
 #include "jobs/ResizePartitionJob.h"
 
+#include "partition/KPMHelper.h"
 #include "partition/KPMManager.h"
 #include "partition/PartitionQuery.h"
 #include "utils/Logger.h"
 #include "utils/Units.h"
 
-#include <backend/corebackend.h>
-#include <fs/filesystemfactory.h>
-
 #include <QEventLoop>
 #include <QProcess>
 #include <QtTest/QtTest>

src/modules/partition/tests/PartitionJobTests.h

@@ -12,12 +12,7 @@
 
 #include "JobQueue.h"
 
-// CalaPM
+#include "partition/KPMHelper.h"
-#include <core/device.h>
-#include <core/partition.h>
-#include <core/partitionrole.h>
-#include <core/partitiontable.h>
-#include <fs/filesystem.h>
 
 // Qt
 #include <QObject>