restore last selected library feature on restart

implements persistent library sidebar selection with debounced save strategy.
saves selection and scroll position 3 seconds after last change to balance performance and crash resilience.

- uses feature icon name + child data for robust cross-session matching
- falls back to default selection if saved item not found
- debounced timer prevents config spam during rapid navigation
- scroll position persisted with selection state
- uses VERIFY_OR_DEBUG_ASSERT for validation

addresses ronso0 feedback:
- 3 second debounce timing balances crash protection with performance
- scroll position saved with selection (not just on shutdown)
- proper error handling with debug assertions
- code organization optimized

config keys:
- [Library] last_selected_feature: feature icon name
- [Library] last_selected_child: child item data (playlist/crate id)
- [Library] SidebarScrollPosition: vertical scroll position

Author: Milkii Brewster

src/library/library.cpp

@@ -69,7 +69,7 @@ Library::Library(
           m_pConfig(pConfig),
           m_pDbConnectionPool(std::move(pDbConnectionPool)),
           m_pTrackCollectionManager(pTrackCollectionManager),
-          m_pSidebarModel(make_parented<SidebarModel>(this)),
+          m_pSidebarModel(make_parented<SidebarModel>(pConfig, this)),
           m_pLibraryControl(make_parented<LibraryControl>(this)),
           m_pLibraryWidget(nullptr),
           m_pKeyNotation(std::make_unique<ControlObject>(
@@ -341,12 +341,16 @@ void Library::bindSearchboxWidget(WSearchLineEdit* pSearchboxWidget) {
 void Library::bindSidebarWidget(WLibrarySidebar* pSidebarWidget) {
     m_pLibraryControl->bindSidebarWidget(pSidebarWidget);
 
-    // Setup the sources view
+    pSidebarWidget->setup(m_pConfig);
     pSidebarWidget->setModel(m_pSidebarModel);
     connect(m_pSidebarModel,
             &SidebarModel::selectIndex,
             pSidebarWidget,
             &WLibrarySidebar::selectIndex);
+    connect(m_pSidebarModel,
+            &SidebarModel::saveScrollPosition,
+            pSidebarWidget,
+            &WLibrarySidebar::saveScrollPosition);
     connect(pSidebarWidget,
             &WLibrarySidebar::pressed,
             m_pSidebarModel,
@@ -601,6 +605,8 @@ void Library::slotCreateCrate() {
 }
 
 void Library::onSkinLoadFinished() {
+    // Try to restore last selection, fallback to default if not found
+    m_pSidebarModel->restoreLastSelection();
     // Enable the default selection when a new skin is loaded.
     m_pSidebarModel->activateDefaultSelection();
 }

src/library/sidebarmodel.cpp

@@ -22,16 +22,26 @@ constexpr bool kDebug = false;
 
 } // anonymous namespace
 
-SidebarModel::SidebarModel(
-        QObject* parent)
+const ConfigKey kLastSelectedFeatureConfigKey = ConfigKey("[Library]", "last_selected_feature");
+const ConfigKey kLastSelectedChildConfigKey = ConfigKey("[Library]", "last_selected_child");
+
+SidebarModel::SidebarModel(UserSettingsPointer pConfig, QObject* parent)
         : QAbstractItemModel(parent),
           m_iDefaultSelectedIndex(0),
-          m_pressedUntilClickedTimer(new QTimer(this)) {
+          m_pConfig(pConfig),
+          m_pressedUntilClickedTimer(new QTimer(this)),
+          m_saveTimer(new QTimer(this)) {
     m_pressedUntilClickedTimer->setSingleShot(true);
     connect(m_pressedUntilClickedTimer,
             &QTimer::timeout,
             this,
             &SidebarModel::slotPressedUntilClickedTimeout);
+    
+    m_saveTimer->setSingleShot(true);
+    connect(m_saveTimer,
+            &QTimer::timeout,
+            this,
+            &SidebarModel::performSave);
 }
 
 void SidebarModel::addLibraryFeature(LibraryFeature* pFeature) {
@@ -351,19 +361,35 @@ void SidebarModel::clicked(const QModelIndex& index) {
     // When triggered by a mouse event pressed() has been
     // invoked immediately before. That doesn't matter,
     // because we stop any running timer before handling
-    // this event.
+    // the click.
     stopPressedUntilClickedTimer();
-    if (index.isValid()) {
-        if (index.internalPointer() == this) {
-            m_sFeatures[index.row()]->activate();
-        } else {
-            TreeItem* pTreeItem = static_cast<TreeItem*>(index.internalPointer());
-            if (pTreeItem) {
-                LibraryFeature* pFeature = pTreeItem->feature();
-                DEBUG_ASSERT(pFeature);
-                pFeature->activateChild(index);
-            }
-        }
+
+    if (!index.isValid()) {
+        return;
+    }
+
+    // Schedule save for this selection change
+    scheduleSelectionSave(index);
+
+    TreeItem* pTreeItem = static_cast<TreeItem*>(index.internalPointer());
+    VERIFY_OR_DEBUG_ASSERT(pTreeItem) {
+        return;
+    }
+
+    LibraryFeature* pFeature = pTreeItem->getFeature();
+    VERIFY_OR_DEBUG_ASSERT(pFeature) {
+        return;
+    }
+
+    if (kDebug) {
+        kLogger.debug() << "Activating feature:"
+                        << pFeature->title();
+    }
+
+    if (index.parent().isValid()) {
+        pFeature->activateChild(index);
+    } else {
+        pFeature->activate();
     }
 }
 
@@ -614,3 +640,108 @@ void SidebarModel::slotFeatureSelect(LibraryFeature* pFeature,
     }
     emit selectIndex(ind, scrollTo);
 }
+
+void SidebarModel::scheduleSelectionSave(const QModelIndex& index) {
+    if (!index.isValid()) {
+        return;
+    }
+    m_pendingSelection = index;
+    m_saveTimer->stop();
+    m_saveTimer->start(3000);
+}
+
+void SidebarModel::performSave() {
+    if (m_pendingSelection.isValid()) {
+        saveSelectionToConfig(m_pendingSelection);
+        emit saveScrollPosition();
+    }
+}
+
+void SidebarModel::saveSelectionToConfig(const QModelIndex& index) {
+    if (!index.isValid() || !m_pConfig) {
+        return;
+    }
+
+    TreeItem* pTreeItem = static_cast<TreeItem*>(index.internalPointer());
+    VERIFY_OR_DEBUG_ASSERT(pTreeItem) {
+        return;
+    }
+
+    LibraryFeature* pFeature = pTreeItem->getFeature();
+    VERIFY_OR_DEBUG_ASSERT(pFeature) {
+        return;
+    }
+
+    // Save feature icon name for robust matching
+    QString featureIconName = pFeature->getIconName();
+    m_pConfig->setValue(kLastSelectedFeatureConfigKey, featureIconName);
+
+    // Save child data if it's a child item
+    if (index.parent().isValid()) {
+        QVariant childData = index.data(DataRole);
+        if (childData.isValid()) {
+            m_pConfig->setValue(kLastSelectedChildConfigKey, childData);
+        } else {
+            m_pConfig->setValue(kLastSelectedChildConfigKey, QVariant());
+        }
+    } else {
+        // Root feature selected - clear child data
+        m_pConfig->setValue(kLastSelectedChildConfigKey, QVariant());
+    }
+}
+
+void SidebarModel::restoreLastSelection() {
+    if (!m_pConfig) {
+        return;
+    }
+
+    QString savedFeatureIcon = m_pConfig->getValueString(kLastSelectedFeatureConfigKey);
+    if (savedFeatureIcon.isEmpty()) {
+        return;
+    }
+
+    QVariant savedChildData = m_pConfig->getValue(kLastSelectedChildConfigKey);
+
+    // Find the feature by icon name
+    LibraryFeature* pTargetFeature = nullptr;
+    int featureIndex = -1;
+    for (int i = 0; i < m_sFeatures.size(); ++i) {
+        if (m_sFeatures[i]->getIconName() == savedFeatureIcon) {
+            pTargetFeature = m_sFeatures[i];
+            featureIndex = i;
+            break;
+        }
+    }
+
+    if (!pTargetFeature) {
+        return;
+    }
+
+    QModelIndex targetIndex = index(featureIndex, 0);
+    
+    // If we have child data, try to find the matching child
+    if (savedChildData.isValid() && pTargetFeature->getChildModel()) {
+        QAbstractItemModel* pChildModel = pTargetFeature->getChildModel();
+        const QModelIndexList matches = pChildModel->match(
+                pChildModel->index(0, 0),
+                DataRole,
+                savedChildData,
+                1,
+                Qt::MatchExactly);
+        
+        VERIFY_OR_DEBUG_ASSERT(!matches.isEmpty() && matches.first().isValid()) {
+            // Child not found, select feature root
+            emit selectIndex(targetIndex, true);
+            return;
+        }
+        
+        // Translate child index to sidebar index
+        QModelIndex childIndex = matches.first();
+        TreeItem* pTreeItem = static_cast<TreeItem*>(childIndex.internalPointer());
+        if (pTreeItem) {
+            targetIndex = createIndex(childIndex.row(), childIndex.column(), pTreeItem);
+        }
+    }
+
+    emit selectIndex(targetIndex, true);
+}

src/library/sidebarmodel.h

@@ -5,6 +5,8 @@
 #include <QModelIndex>
 #include <QVariant>
 
+#include "preferences/usersettings.h"
+
 class LibraryFeature;
 class QTimer;
 
@@ -22,13 +24,17 @@ class SidebarModel : public QAbstractItemModel {
     Q_ENUM(Roles);
 
     explicit SidebarModel(
+            UserSettingsPointer pConfig,
             QObject* parent = nullptr);
     ~SidebarModel() override = default;
 
     void addLibraryFeature(LibraryFeature* feature);
     QModelIndex getDefaultSelection();
     void setDefaultSelection(unsigned int index);
     void activateDefaultSelection();
+    
+    void restoreLastSelection();
+    void scheduleSelectionSave(const QModelIndex& index);
 
     // Required for QAbstractItemModel
     QModelIndex index(int row, int column,
@@ -82,9 +88,11 @@ class SidebarModel : public QAbstractItemModel {
 
   signals:
     void selectIndex(const QModelIndex& index, bool scrollTo);
+    void saveScrollPosition();
 
   private slots:
     void slotPressedUntilClickedTimeout();
+    void performSave();
 
   protected:
     QList<LibraryFeature*> m_sFeatures;
@@ -93,10 +101,14 @@ class SidebarModel : public QAbstractItemModel {
     QModelIndex translateSourceIndex(const QModelIndex& parent);
     QModelIndex translateIndex(const QModelIndex& index, const QAbstractItemModel* model);
     void featureRenamed(LibraryFeature*);
+    void saveSelectionToConfig(const QModelIndex& index);
     unsigned int m_iDefaultSelectedIndex; /** Index of the item in the sidebar model to select at startup. */
 
+    UserSettingsPointer m_pConfig;
     QTimer* const m_pressedUntilClickedTimer;
+    QTimer* m_saveTimer;
     QModelIndex m_pressedIndex;
+    QModelIndex m_pendingSelection;
 
     void startPressedUntilClickedTimer(const QModelIndex& pressedIndex);
     void stopPressedUntilClickedTimer();

src/widget/wlibrarysidebar.cpp

@@ -1,11 +1,14 @@
 #include "widget/wlibrarysidebar.h"
 
 #include <QHeaderView>
+#include <QScrollBar>
+#include <QTimer>
 #include <QUrl>
 #include <QtDebug>
 
 #include "library/sidebarmodel.h"
 #include "moc_wlibrarysidebar.cpp"
+#include "preferences/usersettings.h"
 #include "util/defs.h"
 #include "util/dnd.h"
 
@@ -16,10 +19,8 @@ WLibrarySidebar::WLibrarySidebar(QWidget* parent)
           WBaseWidget(this),
           m_lastDragMoveAccepted(false) {
     qRegisterMetaType<FocusWidget>("FocusWidget");
-    //Set some properties
     setHeaderHidden(true);
     setSelectionMode(QAbstractItemView::SingleSelection);
-    //Drag and drop setup
     setDragEnabled(false);
     setDragDropMode(QAbstractItemView::DragDrop);
     setDropIndicatorShown(true);
@@ -31,6 +32,31 @@ WLibrarySidebar::WLibrarySidebar(QWidget* parent)
     header()->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 }
 
+WLibrarySidebar::~WLibrarySidebar() {
+    saveScrollPosition();
+}
+
+void WLibrarySidebar::setup(UserSettingsPointer pConfig) {
+    m_pConfig = pConfig;
+}
+
+void WLibrarySidebar::saveScrollPosition() {
+    if (m_pConfig) {
+        m_pConfig->setValue(
+                ConfigKey(QStringLiteral("[Library]"), QStringLiteral("SidebarScrollPosition")),
+                verticalScrollBar()->value());
+    }
+}
+
+void WLibrarySidebar::restoreScrollPosition() {
+    if (m_pConfig) {
+        int scrollPos = m_pConfig->getValue(
+                ConfigKey(QStringLiteral("[Library]"), QStringLiteral("SidebarScrollPosition")),
+                0);
+        verticalScrollBar()->setValue(scrollPos);
+    }
+}
+
 void WLibrarySidebar::contextMenuEvent(QContextMenuEvent* pEvent) {
     // if (pEvent->state() & Qt::RightButton) { //Dis shiz don werk on windowze
     QModelIndex clickedIndex = indexAt(pEvent->pos());

src/widget/wlibrarysidebar.h

@@ -5,6 +5,7 @@
 #include <QTreeView>
 
 #include "library/library_decl.h"
+#include "preferences/usersettings.h"
 #include "widget/wbasewidget.h"
 
 class LibraryFeature;
@@ -14,7 +15,9 @@ class WLibrarySidebar : public QTreeView, public WBaseWidget {
     Q_OBJECT
   public:
     explicit WLibrarySidebar(QWidget* parent = nullptr);
+    ~WLibrarySidebar() override;
 
+    void setup(UserSettingsPointer pConfig);
     void contextMenuEvent(QContextMenuEvent* pEvent) override;
     void dragMoveEvent(QDragMoveEvent* pEvent) override;
     void dragEnterEvent(QDragEnterEvent* pEvent) override;
@@ -34,6 +37,8 @@ class WLibrarySidebar : public QTreeView, public WBaseWidget {
     void selectIndex(const QModelIndex& index, bool scrollToIndex = true);
     void selectChildIndex(const QModelIndex&, bool selectItem = true);
     void slotSetFont(const QFont& font);
+    void saveScrollPosition();
+    void restoreScrollPosition();
 
   signals:
     void rightClicked(const QPoint&, const QModelIndex&);
@@ -55,4 +60,5 @@ class WLibrarySidebar : public QTreeView, public WBaseWidget {
     QBasicTimer m_expandTimer;
     QModelIndex m_hoverIndex;
     bool m_lastDragMoveAccepted;
+    UserSettingsPointer m_pConfig;
 };