feat: support deleting selected note types

Author: caleblee789

ftl/core/notetypes.ftl

@@ -26,6 +26,16 @@ notetypes-cards = Cards
 notetypes-clone = Clone: { $val }
 notetypes-copy = { $val } copy
 notetypes-create-scalable-images-with-dvisvgm = Create scalable images with dvisvgm
+notetypes-delete-selected-note-types =
+    { $count ->
+        [one] Delete this selected note type?
+       *[other] Delete { $count } selected note types?
+    }
+notetypes-delete-selected-note-types-and-all =
+    { $count ->
+        [one] Delete this selected note type and all its notes and cards?
+       *[other] Delete { $count } selected note types and all their notes and cards?
+    }
 notetypes-delete-this-note-type-and-all = Delete this note type and all its cards?
 notetypes-delete-this-unused-note-type = Delete this unused note type?
 notetypes-fields = Fields
@@ -34,6 +44,11 @@ notetypes-header = Header
 notetypes-note-types = Note Types
 notetypes-options = Options
 notetypes-please-add-another-note-type-first = Please add another note type first.
+notetypes-selected-note-types-removed =
+    { $count ->
+        [one] Removed one selected note type.
+       *[other] Removed { $count } selected note types.
+    }
 notetypes-type = Type
 
 ## Image Occlusion

qt/aqt/models.py

@@ -9,7 +9,7 @@
 
 import aqt.clayout
 from anki import stdmodels
-from anki.collection import Collection, OpChangesWithId
+from anki.collection import Collection, OpChangesWithCount, OpChangesWithId
 from anki.lang import without_unicode_isolation
 from anki.models import NotetypeDict, NotetypeId, NotetypeNameIdUseCount
 from anki.notes import Note
@@ -18,6 +18,8 @@
 from aqt.operations.notetype import (
     add_notetype_legacy,
     remove_notetype,
+    remove_notetypes,
+    selected_notetype_ids_to_remove,
     update_notetype_legacy,
 )
 from aqt.qt import *
@@ -32,6 +34,7 @@
     restoreGeom,
     saveGeom,
     showInfo,
+    tooltip,
     tr,
 )
 
@@ -113,6 +116,7 @@ def setupModels(self) -> None:
             button = box.addButton(label, QDialogButtonBox.ButtonRole.ActionRole)
             qconnect(button.clicked, func)
 
+        f.modelsList.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
         qconnect(f.modelsList.itemDoubleClicked, self.onRename)
 
         def on_done(fut: Future) -> None:
@@ -163,6 +167,17 @@ def current_notetype(self) -> NotetypeDict:
         row = self.form.modelsList.currentRow()
         return self.mm.get(NotetypeId(self.models[row].id))
 
+    def selected_notetype_rows(self) -> list[int]:
+        rows = sorted({index.row() for index in self.form.modelsList.selectedIndexes()})
+        if rows:
+            return rows
+
+        row = self.form.modelsList.currentRow()
+        if row != -1:
+            return [row]
+
+        return []
+
     def onAdd(self) -> None:
         def on_success(notetype: NotetypeDict) -> None:
             # if legacy add-ons already added the notetype, skip adding
@@ -190,7 +205,16 @@ def onDelete(self) -> None:
         if len(self.models) < 2:
             showInfo(tr.notetypes_please_add_another_note_type_first(), parent=self)
             return
-        idx = self.form.modelsList.currentRow()
+
+        selected_rows = self.selected_notetype_rows()
+        if not selected_rows:
+            return
+
+        if len(selected_rows) > 1:
+            self.onDeleteSelected(selected_rows)
+            return
+
+        idx = selected_rows[0]
         if self.models[idx].use_count:
             msg = tr.notetypes_delete_this_note_type_and_all()
         else:
@@ -202,10 +226,65 @@ def onDelete(self) -> None:
         if not tracker.mark_schema():
             return
 
-        nt = self.current_notetype()
-        remove_notetype(parent=self, notetype_id=nt["id"]).success(
-            lambda _: self.refresh_list(None)
-        ).run_in_background()
+        remove_notetype(
+            parent=self, notetype_id=NotetypeId(self.models[idx].id)
+        ).success(lambda _: self.refresh_list(None)).run_in_background()
+
+    def onDeleteSelected(self, selected_rows: Sequence[int]) -> None:
+        selected_notetype_ids = [
+            NotetypeId(self.models[row].id)
+            for row in selected_rows
+            if 0 <= row < len(self.models)
+        ]
+        current_row = self.form.modelsList.currentRow()
+        protected_notetype_id = (
+            NotetypeId(self.models[current_row].id)
+            if len(selected_notetype_ids) == len(self.models) and current_row != -1
+            else None
+        )
+        notetype_ids = selected_notetype_ids_to_remove(
+            self.models,
+            selected_notetype_ids,
+            protected_notetype_id,
+        )
+        if not notetype_ids:
+            showInfo(tr.notetypes_please_add_another_note_type_first(), parent=self)
+            return
+
+        use_counts = {
+            NotetypeId(notetype.id): notetype.use_count for notetype in self.models
+        }
+        has_notes = any(use_counts[notetype_id] for notetype_id in notetype_ids)
+        msg = (
+            tr.notetypes_delete_selected_note_types_and_all(count=len(notetype_ids))
+            if has_notes
+            else tr.notetypes_delete_selected_note_types(count=len(notetype_ids))
+        )
+        if not askUser(
+            msg,
+            parent=self,
+        ):
+            return
+
+        tracker = ChangeTracker(self.mw)
+        if not tracker.mark_schema():
+            return
+
+        def on_success(out: OpChangesWithCount) -> None:
+            if out.count:
+                tooltip(
+                    tr.notetypes_selected_note_types_removed(count=out.count),
+                    parent=self,
+                )
+            else:
+                showInfo(tr.notetypes_please_add_another_note_type_first(), parent=self)
+            self.refresh_list(None)
+
+        remove_notetypes(
+            parent=self,
+            notetype_ids=notetype_ids,
+            protected_notetype_id=protected_notetype_id,
+        ).success(on_success).run_in_background()
 
     def onAdvanced(self) -> None:
         nt = self.current_notetype()

qt/aqt/operations/notetype.py

@@ -3,13 +3,40 @@
 
 from __future__ import annotations
 
-from anki.collection import OpChanges, OpChangesWithId
-from anki.models import ChangeNotetypeRequest, NotetypeDict, NotetypeId
+from collections.abc import Sequence
+
+from anki.collection import OpChanges, OpChangesWithCount, OpChangesWithId
+from anki.models import (
+    ChangeNotetypeRequest,
+    NotetypeDict,
+    NotetypeId,
+    NotetypeNameIdUseCount,
+)
 from anki.stdmodels import StockNotetypeKind
 from aqt.operations import CollectionOp
 from aqt.qt import QWidget
 
 
+def selected_notetype_ids_to_remove(
+    notetypes: Sequence[NotetypeNameIdUseCount],
+    notetype_ids: Sequence[NotetypeId],
+    protected_notetype_id: NotetypeId | None = None,
+) -> list[NotetypeId]:
+    """Return selected note type IDs to remove, keeping at least one note type."""
+    removable_count = max(len(notetypes) - 1, 0)
+    requested_ids = {NotetypeId(notetype_id) for notetype_id in notetype_ids}
+    protected_id = (
+        NotetypeId(protected_notetype_id) if protected_notetype_id is not None else None
+    )
+    selected_ids = [
+        NotetypeId(notetype.id)
+        for notetype in notetypes
+        if NotetypeId(notetype.id) in requested_ids
+        and NotetypeId(notetype.id) != protected_id
+    ]
+    return selected_ids[:removable_count]
+
+
 def add_notetype_legacy(
     *,
     parent: QWidget,
@@ -37,6 +64,33 @@ def remove_notetype(
     return CollectionOp(parent, lambda col: col.models.remove(notetype_id))
 
 
+def remove_notetypes(
+    *,
+    parent: QWidget,
+    notetype_ids: Sequence[NotetypeId],
+    protected_notetype_id: NotetypeId | None = None,
+) -> CollectionOp[OpChangesWithCount]:
+    def op(col) -> OpChangesWithCount:
+        ids_to_remove = selected_notetype_ids_to_remove(
+            col.models.all_use_counts(),
+            notetype_ids,
+            protected_notetype_id,
+        )
+        if not ids_to_remove:
+            return OpChangesWithCount(changes=OpChanges(), count=0)
+
+        changes = col.models.remove(ids_to_remove[0])
+        target = col.undo_status().last_step
+
+        for notetype_id in ids_to_remove[1:]:
+            col.models.remove(notetype_id)
+            changes = col.merge_undo_entries(target)
+
+        return OpChangesWithCount(changes=changes, count=len(ids_to_remove))
+
+    return CollectionOp(parent, op)
+
+
 def change_notetype_of_notes(
     *, parent: QWidget, input: ChangeNotetypeRequest
 ) -> CollectionOp[OpChanges]:

qt/tests/test_notetype_delete.py

@@ -0,0 +1,50 @@
+# Copyright: Ankitects Pty Ltd and contributors
+# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
+
+from dataclasses import dataclass
+
+from anki.models import NotetypeId
+from aqt.operations.notetype import selected_notetype_ids_to_remove
+
+
+@dataclass
+class Notetype:
+    id: int
+    use_count: int
+
+
+def test_selected_notetype_ids_to_remove() -> None:
+    notetypes = [Notetype(1, 2), Notetype(2, 0), Notetype(3, 0)]
+
+    assert selected_notetype_ids_to_remove(
+        notetypes,
+        [NotetypeId(1), NotetypeId(3)],
+    ) == [1, 3]
+
+
+def test_selected_notetype_ids_to_remove_keeps_one() -> None:
+    notetypes = [Notetype(1, 0), Notetype(2, 0), Notetype(3, 0)]
+
+    assert selected_notetype_ids_to_remove(
+        notetypes,
+        [NotetypeId(1), NotetypeId(2), NotetypeId(3)],
+    ) == [1, 2]
+
+
+def test_selected_notetype_ids_to_remove_keeps_protected_notetype() -> None:
+    notetypes = [Notetype(1, 0), Notetype(2, 0), Notetype(3, 0)]
+
+    assert selected_notetype_ids_to_remove(
+        notetypes,
+        [NotetypeId(1), NotetypeId(2), NotetypeId(3)],
+        protected_notetype_id=NotetypeId(2),
+    ) == [1, 3]
+
+
+def test_selected_notetype_ids_to_remove_ignores_stale_ids() -> None:
+    notetypes = [Notetype(1, 0), Notetype(2, 0), Notetype(3, 0)]
+
+    assert selected_notetype_ids_to_remove(
+        notetypes,
+        [NotetypeId(2), NotetypeId(4)],
+    ) == [2]