Nested crates

build/depends.py

@@ -947,8 +947,11 @@ def sources(self, build):
 
                    "library/features/crates/cratefeature.cpp",
                    "library/features/crates/cratetablemodel.cpp",
+                   "library/features/crates/cratetreemodel.cpp",
                    "library/features/crates/cratestorage.cpp",
+                   "library/features/crates/cratestoragehelpers.cpp",
                    "library/features/crates/cratefeaturehelper.cpp",
+                   "library/features/crates/cratehierarchy.cpp",
 
                    "library/features/history/historyfeature.cpp",
                    "library/features/history/historytreemodel.cpp",

res/schema.xml

@@ -446,4 +446,22 @@ METADATA
       );
     </sql>
   </revision>
+  <revision version="29" min_compatible="3">
+    <description>
+      Add tables to support nested crates.
+    </description>
+    <sql>
+      CREATE TABLE IF NOT EXISTS crateClosure (
+        parentId INTEGER,
+        childId INTEGER,
+        depth INTEGER
+      );
+
+      CREATE TABLE IF NOT EXISTS cratePath (
+        crateId INTEGER,
+        idPath TEXT,
+        namePath TEXT
+      );
+    </sql>
+  </revision>
 </schema>

src/database/mixxxdb.cpp

@@ -11,7 +11,7 @@
 const QString MixxxDb::kDefaultSchemaFile(":/schema.xml");
 
 //static
-const int MixxxDb::kRequiredSchemaVersion = 28;
+const int MixxxDb::kRequiredSchemaVersion = 29;
 
 namespace {
 

src/library/crate/crateschema.h

@@ -7,6 +7,8 @@
 
 #define CRATE_TABLE "crates"
 #define CRATE_TRACKS_TABLE "crate_tracks"
+#define CRATE_CLOSURE_TABLE "crateClosure"
+#define CRATE_PATH_TABLE "cratePath"
 
 const QString CRATETABLE_ID = "id";
 const QString CRATETABLE_NAME = "name";
@@ -24,5 +26,12 @@ const QString CRATETABLE_AUTODJ_SOURCE = "autodj_source";
 const QString CRATETRACKSTABLE_CRATEID = "crate_id";
 const QString CRATETRACKSTABLE_TRACKID = "track_id";
 
+const QString CLOSURE_PARENTID = "parentId";
+const QString CLOSURE_CHILDID = "childId";
+const QString CLOSURE_DEPTH = "depth";
+
+const QString PATHTABLE_CRATEID = "crateId";
+const QString PATHTABLE_ID_PATH = "idPath";
+const QString PATHTABLE_NAME_PATH = "namePath";
 
 #endif // MIXXX_CRATESCHEMA_H

src/library/features/crates/cratefeature.cpp

@@ -45,13 +45,35 @@ CrateFeature::CrateFeature(UserSettingsPointer pConfig,
           m_cratesIcon(":/images/library/ic_library_crates.png"),
           m_lockedCrateIcon(":/images/library/ic_library_locked.png"),
           m_pTrackCollection(pTrackCollection),
-          m_pCrateTableModel(nullptr) {
+          m_pCrateTableModel(nullptr),
+          m_crateHierarchy(pTrackCollection) {
+
 
     initActions();
 
     // construct child model
-    m_childModel.setRootItem(std::make_unique<TreeItem>(this));
-    rebuildChildModel();
+    // m_childModel.setRootItem(std::make_unique<TreeItem>(this));
+    // rebuildChildModel();
+
+    // if closure does not have the same number of crates as the crates table
+    // this means that the user just started mixxx with nested crates for the
+    // first time, so we have to fill the closure table with (self,self,0)
+    if (!m_crateHierarchy.closureIsValid()) {
+        QMessageBox::warning(
+            nullptr,
+            tr("Nested Crates"),
+            tr("Crates now support hierarchical structure."
+               "All your crates have been converted to Level 1 crates"));
+
+        m_crateHierarchy.resetClosure();
+        m_crateHierarchy.initClosure();
+        m_crateHierarchy.resetPath();
+        m_crateHierarchy.generateAllPaths();
+    }
+
+    m_pChildModel = std::make_unique<CrateTreeModel>(this,
+                        m_pTrackCollection, &m_crateHierarchy);
+    m_pChildModel->reloadTree();
 
     connectLibrary(pLibrary);
     connectTrackCollection();
@@ -65,6 +87,10 @@ void CrateFeature::initActions() {
     connect(m_pCreateCrateAction.get(), SIGNAL(triggered()),
             this, SLOT(slotCreateCrate()));
 
+    m_pCreateChildCrateAction = std::make_unique<QAction>(tr("Create Subcrate"),this);
+    connect(m_pCreateChildCrateAction.get(), SIGNAL(triggered()),
+            this, SLOT(slotCreateChildCrate()));
+
     m_pDeleteCrateAction = std::make_unique<QAction>(tr("Remove"),this);
     connect(m_pDeleteCrateAction.get(), SIGNAL(triggered()),
             this, SLOT(slotDeleteCrate()));
@@ -204,7 +230,7 @@ void updateTreeItemForTrackSelection(
     pTreeItem->setBold(crateContainsSelectedTrack);
 }
 
-}
+} // anonymus namespace
 
 bool CrateFeature::dragMoveAccept(QUrl url) {
     return SoundSourceProxy::isUrlSupported(url) ||
@@ -273,7 +299,7 @@ parented_ptr<QWidget> CrateFeature::createPaneWidget(KeyboardEventFilter* pKeybo
 }
 
 QPointer<TreeItemModel> CrateFeature::getChildModel() {
-    return &m_childModel;
+    return m_pChildModel.get();
 }
 
 void CrateFeature::activate() {
@@ -380,6 +406,7 @@ void CrateFeature::onRightClickChild(const QPoint& globalPos, const QModelIndex&
 
     QMenu menu(NULL);
     menu.addAction(m_pCreateCrateAction.get());
+    menu.addAction(m_pCreateChildCrateAction.get());
     menu.addSeparator();
     menu.addAction(m_pRenameCrateAction.get());
     menu.addAction(m_pDuplicateCrateAction.get());
@@ -401,8 +428,29 @@ void CrateFeature::onRightClickChild(const QPoint& globalPos, const QModelIndex&
 void CrateFeature::slotCreateCrate() {
     CrateId crateId = CrateFeatureHelper(
             m_pTrackCollection, m_pConfig).createEmptyCrate();
+    Crate newCrate;
+    m_pTrackCollection->crates().readCrateById(crateId, &newCrate);
+    m_crateHierarchy.initClosureForCrate(crateId);
+    m_crateHierarchy.generateCratePaths(newCrate);
     if (crateId.isValid()) {
-        activateCrate(crateId);
+        m_pChildModel->reloadTree();
+    }
+}
+
+void CrateFeature::slotCreateChildCrate() {
+    Crate parent;
+    if (readLastRightClickedCrate(&parent)) {
+        CrateId newCrate = CrateFeatureHelper(
+            m_pTrackCollection, m_pConfig).createEmptyCrate();
+        if (newCrate.isValid()) {
+            m_crateHierarchy.initClosureForCrate(newCrate);
+            if (m_crateHierarchy.insertIntoClosure(parent.getId(), newCrate)) {
+                Crate child;
+                m_pTrackCollection->crates().readCrateById(newCrate, &child);
+                m_crateHierarchy.generateCratePaths(child);
+                m_pChildModel->reloadTree();
+            }
+        }
     }
 }
 
@@ -413,8 +461,16 @@ void CrateFeature::slotDeleteCrate() {
             qWarning() << "Refusing to delete locked crate" << crate;
             return;
         }
+        // better deletion requeried
+        if (m_crateHierarchy.hasChildern(crate.getId())) {
+            qWarning() << "Can't delete " << crate;
+            qWarning() << "Currently only delete leaf crates";
+            return;
+        }
         if (m_pTrackCollection->deleteCrate(crate.getId())) {
+            m_crateHierarchy.deleteCrate(crate.getId());
             qDebug() << "Deleted crate" << crate;
+            m_pChildModel->reloadTree();
             return;
         }
     }
@@ -502,11 +558,11 @@ void CrateFeature::slotAutoDjTrackSourceChanged() {
 QModelIndex CrateFeature::rebuildChildModel(CrateId selectedCrateId) {
     qDebug() << "CrateFeature::rebuildChildModel()" << selectedCrateId;
 
-    TreeItem* pRootItem = m_childModel.getRootItem();
+    TreeItem* pRootItem = m_pChildModel->getRootItem();
     VERIFY_OR_DEBUG_ASSERT(pRootItem != nullptr) {
         return QModelIndex();
     }
-    m_childModel.removeRows(0, pRootItem->childRows());
+    m_pChildModel->removeRows(0, pRootItem->childRows());
 
     QList<TreeItem*> modelRows;
     modelRows.reserve(m_pTrackCollection->crates().countCrates());
@@ -526,13 +582,13 @@ QModelIndex CrateFeature::rebuildChildModel(CrateId selectedCrateId) {
     }
 
     // Append all the newly created TreeItems in a dynamic way to the childmodel
-    m_childModel.insertTreeItemRows(modelRows, 0);
+    m_pChildModel->insertTreeItemRows(modelRows, 0);
 
     // Update rendering of crates depending on the currently selected track
     slotTrackSelected(m_pSelectedTrack);
 
     if (selectedRow >= 0) {
-        return m_childModel.index(selectedRow, 0);
+        return m_pChildModel->index(selectedRow, 0);
     } else {
         return QModelIndex();
     }
@@ -549,8 +605,8 @@ void CrateFeature::updateChildModel(const QSet<CrateId>& updatedCrateIds) {
         VERIFY_OR_DEBUG_ASSERT(crateStorage.readCrateSummaryById(crateId, &crateSummary)) {
             continue;
         }
-        updateTreeItemForCrateSummary(m_childModel.getItem(index), crateSummary);
-        m_childModel.triggerRepaint(index);
+        updateTreeItemForCrateSummary(m_pChildModel->getItem(index), crateSummary);
+        m_pChildModel->triggerRepaint(index);
     }
     if (m_pSelectedTrack) {
         // Crates containing the currently selected track might
@@ -566,7 +622,7 @@ CrateId CrateFeature::crateIdFromIndex(const QModelIndex& index) const {
     bool ok = false;
     int id = index.data(AbstractRole::RoleData).toInt(&ok);
     if (ok) {
-    	return CrateId(id);
+        return CrateId(id);
     }
     return CrateId();
 }
@@ -575,9 +631,9 @@ QModelIndex CrateFeature::indexFromCrateId(CrateId crateId) const {
     VERIFY_OR_DEBUG_ASSERT(crateId.isValid()) {
         return QModelIndex();
     }
-    for (int row = 0; row < m_childModel.rowCount(); ++row) {
-        QModelIndex index = m_childModel.index(row, 0);
-        TreeItem* pTreeItem = m_childModel.getItem(index);
+    for (int row = 0; row < m_pChildModel->rowCount(); ++row) {
+        QModelIndex index = m_pChildModel->index(row, 0);
+        TreeItem* pTreeItem = m_pChildModel->getItem(index);
         DEBUG_ASSERT(pTreeItem != nullptr);
         if (!pTreeItem->hasChildren() && // leaf node
                 (CrateId(pTreeItem->getData()) == crateId)) {
@@ -793,17 +849,19 @@ void CrateFeature::slotExportTrackFiles() {
 }
 
 void CrateFeature::slotCrateTableChanged(CrateId crateId) {
-    if (m_lastRightClickedIndex.isValid() &&
-            (crateIdFromIndex(m_lastRightClickedIndex) == crateId)) {
-        // Preserve crate selection
-        m_lastRightClickedIndex = rebuildChildModel(crateId);
-        if (m_lastRightClickedIndex.isValid()) {
-            activateCrate(crateId);
-        }
-    } else {
-        // Discard crate selection
-        rebuildChildModel();
-    }
+    Q_UNUSED(crateId)
+    // if (m_lastRightClickedIndex.isValid() &&
+    //         (crateIdFromIndex(m_lastRightClickedIndex) == crateId)) {
+    //     // Preserve crate selection
+    //     m_lastRightClickedIndex = rebuildChildModel(crateId);
+    //     if (m_lastRightClickedIndex.isValid()) {
+    //         activateCrate(crateId);
+    //     }
+    // } else {
+    //     // Discard crate selection
+    //     rebuildChildModel();
+    // }
+    m_pChildModel->reloadTree();
 }
 
 void CrateFeature::slotCrateContentChanged(CrateId crateId) {
@@ -827,7 +885,7 @@ void CrateFeature::htmlLinkClicked(const QUrl& link) {
 void CrateFeature::slotTrackSelected(TrackPointer pTrack) {
     m_pSelectedTrack = pTrack;
 
-    TreeItem* pRootItem = m_childModel.getRootItem();
+    TreeItem* pRootItem = m_pChildModel->getRootItem();
     VERIFY_OR_DEBUG_ASSERT(pRootItem != nullptr) {
         return;
     }
@@ -849,7 +907,7 @@ void CrateFeature::slotTrackSelected(TrackPointer pTrack) {
         updateTreeItemForTrackSelection(pTreeItem, selectedTrackId, sortedTrackCrates);
     }
 
-    m_childModel.triggerRepaint();
+    m_pChildModel->triggerRepaint();
 }
 
 void CrateFeature::slotResetSelectedTrack() {

src/library/features/crates/cratefeature.h

@@ -11,6 +11,9 @@
 #include <QStackedWidget>
 
 #include "library/features/crates/cratetablemodel.h"
+#include "library/features/crates/cratetreemodel.h"
+#include "library/features/crates/cratehierarchy.h"
+
 
 #include "library/libraryfeature.h"
 #include "library/treeitemmodel.h"
@@ -59,6 +62,7 @@ class CrateFeature : public LibraryFeature {
     void onRightClick(const QPoint& globalPos) override;
     void onRightClickChild(const QPoint& globalPos, const QModelIndex& index) override;
     void slotCreateCrate();
+    void slotCreateChildCrate();
 
   private slots:
     void slotDeleteCrate();
@@ -113,7 +117,7 @@ class CrateFeature : public LibraryFeature {
     TrackCollection* m_pTrackCollection;
 
     CrateTableModel* m_pCrateTableModel;
-    TreeItemModel m_childModel;
+    CrateHierarchy m_crateHierarchy;
 
     QModelIndex m_lastRightClickedIndex;
     TrackPointer m_pSelectedTrack;
@@ -123,6 +127,7 @@ class CrateFeature : public LibraryFeature {
     // variant of parented_ptr as soon as it becomes available.
     // See also: https://github.com/mixxxdj/mixxx/pull/1161
     std::unique_ptr<QAction> m_pCreateCrateAction;
+    std::unique_ptr<QAction> m_pCreateChildCrateAction;
     std::unique_ptr<QAction> m_pDeleteCrateAction;
     std::unique_ptr<QAction> m_pRenameCrateAction;
     std::unique_ptr<QAction> m_pLockCrateAction;
@@ -134,6 +139,8 @@ class CrateFeature : public LibraryFeature {
     std::unique_ptr<QAction> m_pExportTrackFilesAction;
     std::unique_ptr<QAction> m_pAnalyzeCrateAction;
 
+    std::unique_ptr<CrateTreeModel> m_pChildModel;
+
     QHash<int, QPointer<QStackedWidget> > m_panes;
     QHash<int, QPointer<CrateTableModel> > m_crateTableModel;
     QHash<int,int> m_idBrowse;

src/library/features/crates/cratefeaturehelper.cpp

@@ -56,6 +56,10 @@ CrateId CrateFeatureHelper::createEmptyCrate() {
             continue;
         }
 
+        // select name from crateClosure join crates on id = childId group by childId having count(*) = 1;
+        // check if it has parent, if not compare with names from above
+        // in closure.
+        // Else split path into tokens and compare to those
         if (m_pTrackCollection->crates().readCrateByName(newCrate.getName())) {
             QMessageBox::warning(
                     nullptr,