#351 add: allow notes to be marked as favorite

Signed-off-by: Patrizio Bekerle <patrizio@bekerle.com>

Author: pbek

CHANGELOG.md

@@ -1,5 +1,19 @@
 # QOwnNotes Changelog
 
+## 25.12.5
+
+- Added ability to **mark notes as favorite** (for [#351](https://github.com/pbek/QOwnNotes/issues/351))
+  - Right-click on a note and select "Mark as favorite" or "Unmark as favorite"
+  - Favorite notes are displayed with a star icon in the note tree widget
+  - Favorite notes are automatically positioned at the top of the note list
+  - Favorite status is stored per note folder in local settings
+  - The feature uses subfolder path and filename to identify notes (persistent across restarts)
+  - Works with all sorting modes (alphabetical, by date)
+  - **Automatic migration**: When a note is moved, renamed, or its headline changes
+    (triggering auto-rename), favorite status is preserved
+  - **Automatic cleanup**: When a note is deleted, it's removed from the favorites list
+  - **Periodic cleanup**: Non-existent notes are automatically removed from favorites on note list refresh
+
 ## 25.12.4
 
 - Fixed an issue where external changes to recently edited notes were silently

src/entities/note.cpp

@@ -212,6 +212,119 @@ QString Note::getNextcloudNotesLink() const {
     return link;
 }
 
+/**
+ * @brief Get a unique identifier for this note (subfolder path + filename)
+ * @return Unique identifier string
+ */
+QString Note::getFavoriteIdentifier() const {
+    // Combine subfolder path and filename to create a unique identifier
+    QString subFolderPath = relativeNoteSubFolderPath();
+    if (subFolderPath.isEmpty()) {
+        return _fileName;
+    }
+    return subFolderPath + QStringLiteral("/") + _fileName;
+}
+
+/**
+ * @brief Check if this note is marked as favorite
+ * @return true if the note is favorite, false otherwise
+ */
+bool Note::isFavorite() const {
+    const QStringList favoriteIdentifiers = getFavoriteNoteIdentifiers();
+    return favoriteIdentifiers.contains(getFavoriteIdentifier());
+}
+
+/**
+ * @brief Toggle the favorite status of this note
+ * @return true if the note is now favorite, false otherwise
+ */
+bool Note::toggleFavorite() {
+    NoteFolder noteFolder = NoteFolder::currentNoteFolder();
+    QStringList favoriteIdentifiers = getFavoriteNoteIdentifiers();
+    QString identifier = getFavoriteIdentifier();
+
+    bool wasFavorite = favoriteIdentifiers.contains(identifier);
+
+    if (wasFavorite) {
+        // Remove from favorites
+        favoriteIdentifiers.removeAll(identifier);
+    } else {
+        // Add to favorites
+        favoriteIdentifiers.append(identifier);
+    }
+
+    // Store the updated list
+    noteFolder.setSettingsValue(QStringLiteral("favoriteNoteIdentifiers"), favoriteIdentifiers);
+
+    return !wasFavorite;
+}
+
+/**
+ * @brief Get the list of favorite note identifiers for the current note folder
+ * @return List of favorite note identifiers (subfolderPath/filename)
+ */
+QStringList Note::getFavoriteNoteIdentifiers() {
+    NoteFolder noteFolder = NoteFolder::currentNoteFolder();
+    return noteFolder.settingsValue(QStringLiteral("favoriteNoteIdentifiers")).toStringList();
+}
+
+/**
+ * @brief Migrate a favorite note identifier when a note is moved
+ * @param oldIdentifier The old identifier (before the move)
+ */
+void Note::migrateFavoriteIdentifier(const QString &oldIdentifier) {
+    QStringList favoriteIdentifiers = getFavoriteNoteIdentifiers();
+
+    // Check if the old identifier was in the favorites list
+    if (favoriteIdentifiers.contains(oldIdentifier)) {
+        // Remove the old identifier
+        favoriteIdentifiers.removeAll(oldIdentifier);
+
+        // Add the new identifier
+        QString newIdentifier = getFavoriteIdentifier();
+        if (!favoriteIdentifiers.contains(newIdentifier)) {
+            favoriteIdentifiers.append(newIdentifier);
+        }
+
+        // Store the updated list
+        NoteFolder noteFolder = NoteFolder::currentNoteFolder();
+        noteFolder.setSettingsValue(QStringLiteral("favoriteNoteIdentifiers"), favoriteIdentifiers);
+
+        qDebug() << __func__ << "Migrated favorite from" << oldIdentifier << "to" << newIdentifier;
+    }
+}
+
+/**
+ * @brief Clean up favorite notes list by removing entries for notes that no longer exist
+ */
+void Note::cleanupFavoriteNotes() {
+    NoteFolder noteFolder = NoteFolder::currentNoteFolder();
+    QStringList favoriteIdentifiers = getFavoriteNoteIdentifiers();
+    QStringList validIdentifiers;
+
+    QString noteFolderPath = noteFolder.getLocalPath();
+
+    for (const QString &identifier : favoriteIdentifiers) {
+        // Build the full file path
+        QString filePath = noteFolderPath + QDir::separator() + identifier;
+
+        // Check if the file exists
+        QFile file(filePath);
+        if (file.exists()) {
+            validIdentifiers.append(identifier);
+        } else {
+            qDebug() << __func__ << "Removing non-existent favorite:" << identifier;
+        }
+    }
+
+    // Only update if something changed
+    if (validIdentifiers.count() != favoriteIdentifiers.count()) {
+        noteFolder.setSettingsValue(QStringLiteral("favoriteNoteIdentifiers"), validIdentifiers);
+        qDebug() << __func__ << "Cleaned up"
+                 << (favoriteIdentifiers.count() - validIdentifiers.count()) << "favorite entries";
+    }
+}
+
 void Note::setCryptoKey(const qint64 cryptoKey) { this->_cryptoKey = cryptoKey; }
 
 void Note::setNoteText(QString text) { this->_noteText = std::move(text); }
@@ -363,6 +476,17 @@ bool Note::remove(bool withFile) {
         return false;
     } else {
         if (withFile) {
+            // Remove from favorites if it was marked as favorite
+            QString identifier = getFavoriteIdentifier();
+            QStringList favoriteIdentifiers = getFavoriteNoteIdentifiers();
+            if (favoriteIdentifiers.contains(identifier)) {
+                favoriteIdentifiers.removeAll(identifier);
+                NoteFolder noteFolder = NoteFolder::currentNoteFolder();
+                noteFolder.setSettingsValue(QStringLiteral("favoriteNoteIdentifiers"),
+                                            favoriteIdentifiers);
+                qDebug() << __func__ << "Removed favorite:" << identifier;
+            }
+
             this->removeNoteFile();
 
             // remove all links to tags
@@ -3876,6 +4000,13 @@ bool Note::handleNoteMoving(Note oldNote) {
     const int noteCount = noteIdList.count();
     bool result = false;
 
+    // Migrate favorite status if the note was moved to a different subfolder or renamed
+    QString oldIdentifier = oldNote.getFavoriteIdentifier();
+    QString newIdentifier = getFavoriteIdentifier();
+    if (oldIdentifier != newIdentifier) {
+        migrateFavoriteIdentifier(oldIdentifier);
+    }
+
     // Handle incoming note links
     if (noteCount > 0) {
         result = handleBacklinkedNotesAfterMoving(oldNote, noteIdList);

src/entities/note.h

@@ -410,6 +410,18 @@ class Note {
 
     QString getNextcloudNotesLink() const;
 
+    bool isFavorite() const;
+
+    bool toggleFavorite();
+
+    static QStringList getFavoriteNoteIdentifiers();
+
+    QString getFavoriteIdentifier() const;
+
+    void migrateFavoriteIdentifier(const QString &oldIdentifier);
+
+    static void cleanupFavoriteNotes();
+
    protected:
     int _id;
     int _noteSubFolderId;

src/mainwindow.cpp

@@ -2190,6 +2190,9 @@ QIcon MainWindow::getSystemTrayIcon() {
 void MainWindow::loadNoteDirectoryList() {
     qDebug() << __func__;
 
+    // Clean up favorite notes list (remove entries for deleted notes)
+    Note::cleanupFavoriteNotes();
+
     const QSignalBlocker blocker(ui->noteTextEdit);
     Q_UNUSED(blocker)
 
@@ -2280,7 +2283,17 @@ bool MainWindow::addNoteToNoteTreeWidget(const Note &note, QTreeWidgetItem *pare
     noteItem->setText(0, name);
     noteItem->setData(0, Qt::UserRole, note.getId());
     noteItem->setData(0, Qt::UserRole + 1, NoteType);
-    noteItem->setIcon(0, Utils::Gui::noteIcon());
+
+    // Store favorite status for sorting (UserRole + 2)
+    const bool isFavorite = note.isFavorite();
+    noteItem->setData(0, Qt::UserRole + 2, isFavorite);
+
+    // Set the icon based on favorite status
+    if (isFavorite) {
+        noteItem->setIcon(0, Utils::Gui::favoriteNoteIcon());
+    } else {
+        noteItem->setIcon(0, Utils::Gui::noteIcon());
+    }
 
     const Tag tag = Tag::fetchOneOfNoteWithColor(note);
     if (tag.isFetched()) {
@@ -2297,8 +2310,26 @@ bool MainWindow::addNoteToNoteTreeWidget(const Note &note, QTreeWidgetItem *pare
     Q_UNUSED(blocker)
 
     if (parent == nullptr) {
-        // strange things happen if we insert with insertTopLevelItem
-        ui->noteTreeWidget->addTopLevelItem(noteItem);
+        // Insert notes with favorites at the top
+        // Find the insertion position based on favorite status
+        if (isFavorite) {
+            // For favorite notes, find the last position of favorites
+            int insertPos = 0;
+            const int count = ui->noteTreeWidget->topLevelItemCount();
+            for (int i = 0; i < count; ++i) {
+                QTreeWidgetItem *existingItem = ui->noteTreeWidget->topLevelItem(i);
+                if (existingItem->data(0, Qt::UserRole + 1) == NoteType &&
+                    existingItem->data(0, Qt::UserRole + 2).toBool()) {
+                    insertPos = i + 1;
+                } else {
+                    break;
+                }
+            }
+            ui->noteTreeWidget->insertTopLevelItem(insertPos, noteItem);
+        } else {
+            // Non-favorite notes go after all favorites
+            ui->noteTreeWidget->addTopLevelItem(noteItem);
+        }
     } else {
         parent->addChild(noteItem);
     }
@@ -2355,7 +2386,27 @@ void MainWindow::makeCurrentNoteFirstInNoteList() {
         Q_UNUSED(blocker)
 
         ui->noteTreeWidget->takeTopLevelItem(ui->noteTreeWidget->indexOfTopLevelItem(item));
-        ui->noteTreeWidget->insertTopLevelItem(0, item);
+
+        // Determine insertion position based on favorite status
+        const bool isFavorite = currentNote.isFavorite();
+        int insertPos = 0;
+
+        if (!isFavorite) {
+            // Non-favorite note: insert after all favorites
+            const int count = ui->noteTreeWidget->topLevelItemCount();
+            for (int i = 0; i < count; ++i) {
+                QTreeWidgetItem *existingItem = ui->noteTreeWidget->topLevelItem(i);
+                if (existingItem->data(0, Qt::UserRole + 1) == NoteType &&
+                    existingItem->data(0, Qt::UserRole + 2).toBool()) {
+                    insertPos = i + 1;
+                } else {
+                    break;
+                }
+            }
+        }
+        // For favorite notes, insertPos stays at 0 (first position)
+
+        ui->noteTreeWidget->insertTopLevelItem(insertPos, item);
 
         // set the item as current item if it is visible
         if (!item->isHidden()) {
@@ -9889,6 +9940,7 @@ void MainWindow::openNotesContextMenu(const QPoint globalPos, bool multiNoteMenu
     QAction *showInFileManagerAction = nullptr;
     QAction *showNoteGitLogAction = nullptr;
     QAction *copyNotePathToClipboardAction = nullptr;
+    QAction *toggleFavoriteAction = nullptr;
 
     if (!multiNoteMenuEntriesOnly) {
         noteMenu.addSeparator();
@@ -9914,6 +9966,17 @@ void MainWindow::openNotesContextMenu(const QPoint globalPos, bool multiNoteMenu
         if (Utils::Git::isCurrentNoteFolderUseGit() && Utils::Git::hasLogCommand()) {
             showNoteGitLogAction = noteMenu.addAction(tr("Show note git versions"));
         }
+
+        // Add favorite toggle action for single note
+        noteMenu.addSeparator();
+        const Note note = getCurrentNote();
+        if (note.isFetched()) {
+            if (note.isFavorite()) {
+                toggleFavoriteAction = noteMenu.addAction(tr("Unmark as favorite"));
+            } else {
+                toggleFavoriteAction = noteMenu.addAction(tr("Mark as favorite"));
+            }
+        }
     }
 
     // add the custom actions to the context menu
@@ -9981,6 +10044,11 @@ void MainWindow::openNotesContextMenu(const QPoint globalPos, bool multiNoteMenu
         } else if (selectedItem == showNoteGitLogAction) {
             // show the git log of the current note
             on_actionShow_note_git_versions_triggered();
+        } else if (selectedItem == toggleFavoriteAction) {
+            // toggle favorite status of the current note
+            currentNote.toggleFavorite();
+            // Reload the note list to update the icon and sorting
+            loadNoteDirectoryList();
         } else if (selectedItem == renameAction) {
             QTreeWidgetItem *item = ui->noteTreeWidget->currentItem();
 

src/utils/gui.cpp

@@ -1160,6 +1160,16 @@ QIcon Utils::Gui::noteIcon() {
     return s_noteIcon;
 }
 
+QIcon Utils::Gui::favoriteNoteIcon() {
+    // Try different common star icon names
+    static const QIcon s_favoriteNoteIcon = QIcon::fromTheme(
+        QStringLiteral("starred-symbolic"),
+        QIcon::fromTheme(QStringLiteral("emblem-favorite"),
+                         QIcon::fromTheme(QStringLiteral("star"),
+                                          noteIcon())));    // Fallback to regular note icon
+    return s_favoriteNoteIcon;
+}
+
 QIcon Utils::Gui::tagIcon() {
     static const QIcon s_tagIcon = QIcon::fromTheme(
         QStringLiteral("tag"), QIcon(QStringLiteral(":/icons/breeze-qownnotes/16x16/tag.svg")));

src/utils/gui.h

@@ -141,6 +141,7 @@ bool doLinuxDarkModeCheck();
 
 QIcon folderIcon();
 QIcon noteIcon();
+QIcon favoriteNoteIcon();
 QIcon tagIcon();
 
 /**