start of set completion tracking

ui_wx/AGENTS.md

@@ -5,8 +5,8 @@
 ## Layer pointers
 
 - `include/ccm/ui/AppContext.hpp` — the boundary type. A struct of references to shared core services + per-game modules and a `std::vector<IGameView*>` of all UI bundles. UI code talks to core only through this struct (and the typed pointers go through `IGameView`, never directly).
-- `include/ccm/ui/IGameView.hpp` — abstract base class for per-game UI bundles. `MainFrame` only ever sees `IGameView` references; this is the seam that lets the frame swap between Magic, Pokemon, and any future TCG without knowing their card types.
-- `include/ccm/ui/MainFrame.hpp` + `src/MainFrame.cpp` — top-level window (default size `1210×770`), menu strip (`File` / `Game` / `Sets` / `Help`), toolbar (Add / Edit / Delete + filter input), and the splitter that swaps the active `IGameView`'s panels. The `Game` and `Sets` menus are built dynamically from `AppContext::gameViews` so adding a new game lights up its menu entries automatically. Filter and toolbar actions forward to `activeView()`. `EVT_PREVIEW_STATUS` (preview fetch outcome → status label; empty string resets to `"Ready"`) is the only event the frame binds; `EVT_CARD_SELECTED` is bound *per view* (each `IGameView` connects its typed list panel to its typed selected panel internally). About is a custom themed dialog (not `wxAboutBox`) so dark mode behavior stays consistent.
+- `include/ccm/ui/IGameView.hpp` — abstract base class for per-game UI bundles. `MainFrame` only ever sees `IGameView` references; this is the seam that lets the frame swap between Magic, Pokemon, and any future TCG without knowing their card types. Optional `contentPanel` / `hostsOwnLayout` / `contentPanelIfCreated` let Digimon own a tabbed layout without changing other games’ splitter mounting.
+- `include/ccm/ui/MainFrame.hpp` + `src/MainFrame.cpp` — top-level window (default size `1210×770`), menu strip (`File` / `Game` / `Sets` / `Help`), shared toolbar (Add / Edit / Delete + filter input; hidden for Digimon via `toolbarPanel_` when `hostsOwnLayout()`), and a `contentHost_` that either shows the shared splitter (Magic / Pokémon / Yu-Gi-Oh!) or a game’s `IGameView::contentPanel` (Digimon Digi-Battle notebook). The `Game` and `Sets` menus are built dynamically from `AppContext::gameViews` so adding a new game lights up its menu entries automatically. Filter and toolbar actions forward to `activeView()`. `EVT_PREVIEW_STATUS` (preview fetch outcome → status label; empty string resets to `"Ready"`) is the only event the frame binds; `EVT_CARD_SELECTED` is bound *per view* (each `IGameView` connects its typed list panel to its typed selected panel internally). About is a custom themed dialog (not `wxAboutBox`) so dark mode behavior stays consistent.
 - `include/ccm/ui/BaseCardListPanel.hpp` — header-only template `BaseCardListPanel<TCard, TSortColumn>` that owns ALL the non-game-specific `wxListCtrl` machinery: hidden zero-width spacer column (legacy of the MSW comctl32 image-list gutter workaround, kept to preserve column-index math), themed header row (clickable to sort, edge-drag to resize, divider double-click to autosize), per-icon-column cached `wxBitmap` pairs (normal + selected color) consumed by `IconListCtrl::MSWOnNotify` so row icons are pixel-perfect centered under the themed-header icons, rebuild guard so DESELECTED/SELECTED storms collapse into a single bubbled `EVT_CARD_SELECTED`, case-insensitive substring filter via `setFilter(...)`, per-column toggle-direction sort. Subclasses fill in column descriptors + per-row text + per-icon-column flag predicates + dispatch hooks (`sortBy`, `matchesFilter`).
 - `include/ccm/ui/IconListCtrl.hpp` + `src/IconListCtrl.cpp` — small `wxListCtrl` subclass that intercepts `NM_CUSTOMDRAW` on Windows and paints flag-icon sub-items at the exact center of each cell. It owns a `HIMAGELIST` (built from the cached `wxBitmap` pairs via straight-RGBA 32 bpp DIB sections) and draws each cell's icon with `ImageList_Draw(ILD_TRANSPARENT)` onto the native `HDC` from `NMLVCUSTOMDRAW`. This is the same low-level pixel path `wxImageList` uses internally, which is the only rendering path that has reliably preserved SVG transparency + correct fill color across light/dark themes on MSW. Two earlier attempts — `wxGraphicsContext::DrawBitmap` and a manually-premultiplied-DIB `AlphaBlend` — both rendered runtime-fill SVG icons as solid white in light mode and were abandoned (see convention 11). The custom-draw is purely about positioning; pixel format handling is delegated to comctl32.
 - `include/ccm/ui/BaseSelectedCardPanel.hpp` — header-only template `BaseSelectedCardPanel<TCard>` that owns the right-hand-side detail panel: preview image fetched via `CardPreviewService` (with the `shared_ptr<State>` + `std::atomic alive`/`currentGen` cancellation pattern), 2-column detail grid, flag-icon strip that collapses when no flags are set, image list with double-click viewer. If preview lookup fails or returns empty bytes, the panel loads a per-game **card-back fallback**: Magic and Pokémon West use fixed HTTPS URLs (`fallbackImageUrlForGame`, CCM2-aligned); **Pokémon Asia** uses the Japanese TCG back via `previewGameFor(card)` → `Game::JapanesePokemon`; **Yu-Gi-Oh!** tries Yugipedia thumbnail URL, then full `Back-EN.png` on `ms.yugipedia.com`, then reads `<exeDir>/assets/ygo_card_back.png`; **Digimon Digi-Battle** reads `<exeDir>/assets/digibattle99_card_back.png` (both bundled assets copied by `app/CMakeLists.txt` on link). The constructor caches `<exeDir>/` for that disk path. Subclasses describe the detail rows / flag icons / preview lookup `(name, setId, setNo)` and own a `Game` constant; override `previewGameFor` when preview routing differs from collection `gameId()` (Pokemon West/Asia).
@@ -14,6 +14,7 @@
 - `include/ccm/ui/SwitchCtrl.hpp` + `src/SwitchCtrl.cpp` — custom pill-track + thumb switch for small modal rows (Yu-Gi-Oh! set picker); fires `EVT_CCM_SWITCH` on user toggle and reads colors from `inferThemeFromWindow` / `paletteForTheme`.
 - `include/ccm/ui/Magic*.hpp` + `src/Magic*.cpp` — Magic implementations: `MagicCardListPanel`, `MagicSelectedCardPanel`, `MagicCardEditDialog`, `MagicGameView`. Each is ~50–100 lines of hook overrides on top of the matching base template.
 - `include/ccm/ui/Pokemon*.hpp` + `src/Pokemon*.cpp` — Pokemon implementations: `PokemonCardListPanel`, `PokemonSelectedCardPanel`, `PokemonCardEditDialog`, `PokemonGameView`. Same shape as the Magic ones; differences are limited to the Set # field, the Holo / 1. Edition flags, and the Pokemon TCG preview lookup key (which includes `setNo`).
+- `include/ccm/ui/DigiBattle99*.hpp` + `src/DigiBattle99*.cpp` — Digimon Digi-Battle: list/selected/edit plus `DigiBattle99GameView` notebook (**Single Cards** | **Set Completion**) via `contentPanel`, and `DigiBattle99SetCompletionPanel` (pack progress tiles + greyed checklist). Catalog from `DigiBattle99SetCatalogService` (`set-catalog.json`), filled on Update Sets. The Add/Edit/Delete + filter toolbar lives **inside** the Single Cards tab (under the notebook); MainFrame hides its shared toolbar while Digimon is active (`hostsOwnLayout`).
 - `include/ccm/ui/SvgIcons.hpp` + `src/SvgIcons.cpp` — embedded SVG templates with a `@FILL@` placeholder. Magic flags: `kSvgFoil` / `kSvgSigned` / `kSvgAltered`. Pokemon flags: `kSvgHolo` (sparkle, mirroring the original `IconHolo` from `PokemonTable.tsx`) and `kSvgFirstEdition` (themed "1" inside an outlined badge, rebuilt from the original `IconPokemonFirstEdition.tsx` — every fill/stroke uses `@FILL@` so the icon themes alongside the others). Toolbar glyphs: `kSvgToolbarAdd` / `kSvgToolbarEdit` / `kSvgToolbarDelete` (vscode-codicons). `svgIconBitmap` / `paddedSvgIcon` helpers backed by `wxBitmapBundle::FromSVG`. Bitmaps from `svgIconBitmap` go straight to `wxStaticBitmap` / `wxBitmapButton::SetBitmap` cleanly; for the row-icon path `IconListCtrl` packs them into a private premultiplied-BGRA `HIMAGELIST` and draws with `ImageList_Draw`. See convention 11 for the full pitfall write-up.
 - `src/BaseEvents.cpp` — single-translation-unit definitions for `EVT_CARD_SELECTED` and `EVT_PREVIEW_STATUS`. Both events are template-instantiation-agnostic so all per-game panels share the same event types.
 - `include/ccm/ui/SettingsDialog.hpp` + `src/SettingsDialog.cpp` — edits `Configuration` via `ConfigService::store`.
@@ -27,7 +28,7 @@
 3. **Ownership**: dialogs and panels are heap-allocated and parented to a `wxWindow`. wxWidgets owns the lifetime — do **not** wrap them in `unique_ptr`. `IGameView` instances themselves are owned by `app/main.cpp` (`std::unique_ptr<>`); the panels owned by the views become children of the `MainFrame` splitter on first mount.
 4. **Custom events**: `EVT_CARD_SELECTED` is fired by the list panel on itself (not its parent). Each `IGameView` binds it on its typed list panel inside the panel's first construction so the typed selection flows directly into the typed selected panel — `MainFrame` never sees a `MagicCard` or a `PokemonCard`. Do not move that binding back into `MainFrame`.
 5. **wxFont modifications** mutate in place: `font.MakeBold().MakeLarger()` — do not call `Scale` (it does not exist on wxFont 3.2; use `MakeLarger` / `SetPointSize`).
-6. **Single-active-game UX.** `MainFrame` only ever shows one game's panels at a time; the splitter swaps `listPanel()` / `selectedPanel()` when the user picks a different `Game` menu entry. Do not stand up parallel side-by-side tabs for different games.
+6. **Single-active-game UX.** `MainFrame` only ever shows one game's panels at a time; the content host swaps either the shared `listPanel()` / `selectedPanel()` splitter or a game’s `contentPanel()` when the user picks a different `Game` menu entry. Do not stand up parallel side-by-side tabs for different games. Digimon’s Single Cards / Set Completion notebook is an in-game mode switch, not multi-game tabs.
 7. **No `ccm_warnings`.** This target intentionally does **not** link the strict warning interface — wxWidgets headers trip `-Wpedantic` / `-Wshadow`. Keep it that way; do not add the link.
 8. **Async background work** must not capture `this` raw. Use the pattern from `BaseSelectedCardPanel`: a `std::shared_ptr<State>` holding `std::atomic<bool> alive`, `std::atomic<unsigned> currentGen`, and a back-pointer to the panel; spawn a detached `std::thread`, then deliver the result with `wxTheApp->CallAfter([state, gen, ...]() { if (!state->alive) return; if (state->currentGen != gen) return; ... })`. Flip `alive=false` in the panel destructor so late callbacks become no-ops.
 9. **Icons come from `SvgIcons.hpp`.** Don't inline new SVG strings in panel sources; add them to `SvgIcons.{hpp,cpp}` so all panels stay in sync. Always pass a runtime fill color (`wxSystemSettings::GetColour(...).GetAsString(wxC2S_HTML_SYNTAX)`); never bake one into the SVG.

ui_wx/CMakeLists.txt

@@ -23,6 +23,7 @@ add_library(ccm_ui_wx STATIC
     src/DigiBattle99SelectedCardPanel.cpp
     src/DigiBattle99CardEditDialog.cpp
     src/DigiBattle99GameView.cpp
+    src/DigiBattle99SetCompletionPanel.cpp
 
     src/SettingsDialog.cpp
     src/SwitchCtrl.cpp

ui_wx/include/ccm/ui/DigiBattle99GameView.hpp

@@ -5,18 +5,27 @@
 #include "ccm/services/CardPreviewService.hpp"
 #include "ccm/services/CollectionService.hpp"
 #include "ccm/services/ConfigService.hpp"
+#include "ccm/services/DigiBattle99SetCatalogService.hpp"
 #include "ccm/services/ImageService.hpp"
 #include "ccm/services/SetService.hpp"
 #include "ccm/ui/IGameView.hpp"
 
+#include <array>
 #include <string>
 #include <string_view>
 #include <vector>
 
+class wxBitmapButton;
+class wxBoxSizer;
+class wxNotebook;
+class wxSplitterWindow;
+class wxTextCtrl;
+
 namespace ccm::ui {
 
 class DigiBattle99CardListPanel;
 class DigiBattle99SelectedCardPanel;
+class DigiBattle99SetCompletionPanel;
 
 class DigiBattle99GameView final : public IGameView {
 public:
@@ -25,13 +34,19 @@ public:
                          SetService&                            sets,
                          ImageService&                          images,
                          CardPreviewService&                    cardPreview,
-                         IGameModule&                           module);
+                         IGameModule&                           module,
+                         DigiBattle99SetCatalogService&         catalogStore);
 
     [[nodiscard]] Game        gameId() const noexcept override { return Game::DigiBattle99; }
     [[nodiscard]] std::string displayName() const override { return "Digimon (Digi-Battle)"; }
 
     wxPanel* listPanel(wxWindow* parent) override;
     wxPanel* selectedPanel(wxWindow* parent) override;
+    wxPanel* contentPanel(wxWindow* parent) override;
+    [[nodiscard]] wxPanel* contentPanelIfCreated() const noexcept override {
+        return contentPanel_;
+    }
+    [[nodiscard]] bool hostsOwnLayout() const noexcept override { return true; }
 
     void refreshCollection() override;
     void onAddCard(wxWindow* parentWindow) override;
@@ -47,6 +62,9 @@ public:
 private:
     void ensureSetsLoaded();
     const std::vector<Set>& setsForDialog();
+    void ensureSingleCardsMounted(wxWindow* splitterParent);
+    void buildSingleCardsToolbar(wxWindow* parent, wxBoxSizer* pageSizer);
+    void refreshToolbarIcons(const ThemePalette& palette);
 
     ConfigService&                        config_;
     CollectionService<DigiBattle99Card>&  collection_;
@@ -54,9 +72,16 @@ private:
     ImageService&                         images_;
     CardPreviewService&                   cardPreview_;
     IGameModule&                          module_;
+    DigiBattle99SetCatalogService&        catalogStore_;
 
+    wxPanel*                       contentPanel_{nullptr};
+    wxNotebook*                    notebook_{nullptr};
+    wxSplitterWindow*              singleSplitter_{nullptr};
     DigiBattle99CardListPanel*     listPanel_{nullptr};
     DigiBattle99SelectedCardPanel* selectedPanel_{nullptr};
+    DigiBattle99SetCompletionPanel* setCompletionPanel_{nullptr};
+    std::array<wxBitmapButton*, 3> toolbarButtons_{{nullptr, nullptr, nullptr}};
+    wxTextCtrl*                    filterInput_{nullptr};
     std::vector<Set>               setsCache_;
     bool                           attemptedInitialSetLoad_{false};
 };

ui_wx/include/ccm/ui/DigiBattle99SetCompletionPanel.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+// DigiBattle99SetCompletionPanel: Set Completion tab — pack tiles with
+// progress bars for sets the user owns ≥1 card of, plus an in-tab checklist
+// drill-down (unowned rows greyed). Catalog is offline (set-catalog.json).
+
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/domain/DigiBattle99SetCatalog.hpp"
+#include "ccm/services/DigiBattle99SetCatalogService.hpp"
+#include "ccm/ui/Theme.hpp"
+
+#include <wx/panel.h>
+
+#include <string>
+#include <vector>
+
+class wxBoxSizer;
+class wxListCtrl;
+class wxScrolledWindow;
+class wxSimplebook;
+class wxStaticText;
+
+namespace ccm::ui {
+
+class DigiBattle99SetCompletionPanel : public wxPanel {
+public:
+    DigiBattle99SetCompletionPanel(wxWindow* parent, DigiBattle99SetCatalogService& catalogStore);
+
+    void setCollection(std::vector<DigiBattle99Card> cards);
+    void reloadFromStore();
+    void applyTheme(const ThemePalette& palette);
+
+private:
+    void showGridPage();
+    void showChecklistPage(const std::string& setId, const std::string& setName);
+    void rebuildGrid();
+    void rebuildChecklist(const std::string& setId);
+    void setEmptyMessage(const wxString& message);
+    void clearGridTiles();
+
+    DigiBattle99SetCatalogService&     catalogStore_;
+    DigiBattle99SetCatalog             catalog_;
+    bool                               catalogLoaded_{false};
+    std::vector<DigiBattle99Card>      collection_;
+    ThemePalette                       palette_{};
+
+    wxSimplebook*      book_{nullptr};
+    wxPanel*           gridPage_{nullptr};
+    wxScrolledWindow*  scroll_{nullptr};
+    wxBoxSizer*        gridSizer_{nullptr};
+    wxStaticText*      emptyLabel_{nullptr};
+
+    wxPanel*           detailPage_{nullptr};
+    wxStaticText*      detailTitle_{nullptr};
+    wxListCtrl*        checklist_{nullptr};
+    std::string        detailSetId_;
+};
+
+}  // namespace ccm::ui

ui_wx/include/ccm/ui/IGameView.hpp

@@ -35,6 +35,24 @@ public:
     virtual wxPanel* listPanel(wxWindow* parent) = 0;
     virtual wxPanel* selectedPanel(wxWindow* parent) = 0;
 
+    // When non-null, MainFrame mounts this as the sole content under the
+    // toolbar instead of the shared selected|list splitter. Digimon uses this
+    // for its Single Cards / Set Completion notebook. Default: no custom host.
+    virtual wxPanel* contentPanel(wxWindow* parent) {
+        (void)parent;
+        return nullptr;
+    }
+
+    // Non-constructing accessor so MainFrame can hide a previously mounted
+    // content panel without forcing lazy creation for inactive games.
+    [[nodiscard]] virtual wxPanel* contentPanelIfCreated() const noexcept {
+        return nullptr;
+    }
+
+    // Games that own their layout via contentPanel must not have their
+    // list/selected panels parented onto MainFrame's shared splitter.
+    [[nodiscard]] virtual bool hostsOwnLayout() const noexcept { return false; }
+
     // Reload the active collection from disk and refresh the panels. The
     // selected card is preserved when possible.
     virtual void refreshCollection() = 0;

ui_wx/include/ccm/ui/MainFrame.hpp

@@ -59,6 +59,8 @@ private:
     Game        activeGame_{Game::Magic};
 
     wxSplitterWindow*   splitter_{nullptr};
+    wxPanel*            contentHost_{nullptr};
+    wxPanel*            toolbarPanel_{nullptr};
     wxTextCtrl*         filterInput_{nullptr};
     wxPanel*            menuStrip_{nullptr};
     wxStaticText*       statusText_{nullptr};

ui_wx/src/DigiBattle99GameView.cpp

@@ -1,31 +1,45 @@
 #include "ccm/ui/DigiBattle99GameView.hpp"
 
+#include "ccm/games/digibattle99/DigiBattle99SetSource.hpp"
 #include "ccm/ui/CardEditModalGuard.hpp"
 #include "ccm/ui/DigiBattle99CardEditDialog.hpp"
 #include "ccm/ui/DigiBattle99CardListPanel.hpp"
 #include "ccm/ui/DigiBattle99SelectedCardPanel.hpp"
+#include "ccm/ui/DigiBattle99SetCompletionPanel.hpp"
+#include "ccm/ui/SvgIcons.hpp"
 #include "ccm/ui/Theme.hpp"
 
-#include <wx/msgdlg.h>
+#include <wx/bmpbuttn.h>
+#include <wx/notebook.h>
+#include <wx/panel.h>
+#include <wx/sizer.h>
+#include <wx/splitter.h>
+#include <wx/textctrl.h>
 #include <wx/window.h>
 
-#include <optional>
 #include <string>
 
 namespace ccm::ui {
 
+namespace {
+constexpr int kDigiToolbarIconPx = 18;
+constexpr const char kDigiFilterHint[] = "Filter";
+}  // namespace
+
 DigiBattle99GameView::DigiBattle99GameView(ConfigService&                         config,
                                            CollectionService<DigiBattle99Card>&   collection,
                                            SetService&                            sets,
                                            ImageService&                          images,
                                            CardPreviewService&                    cardPreview,
-                                           IGameModule&                           module)
+                                           IGameModule&                           module,
+                                           DigiBattle99SetCatalogService&         catalogStore)
     : config_(config),
       collection_(collection),
       sets_(sets),
       images_(images),
       cardPreview_(cardPreview),
-      module_(module) {}
+      module_(module),
+      catalogStore_(catalogStore) {}
 
 void DigiBattle99GameView::ensureSetsLoaded() {
     if (attemptedInitialSetLoad_) return;
@@ -45,6 +59,101 @@ void DigiBattle99GameView::ensureSetsLoaded() {
     }
 }
 
+void DigiBattle99GameView::ensureSingleCardsMounted(wxWindow* splitterParent) {
+    if (singleSplitter_ == nullptr) {
+        singleSplitter_ = new wxSplitterWindow(splitterParent, wxID_ANY, wxDefaultPosition,
+                                               wxDefaultSize, wxSP_LIVE_UPDATE);
+        singleSplitter_->SetMinimumPaneSize(280);
+    }
+    auto* list = listPanel(singleSplitter_);
+    auto* selected = selectedPanel(singleSplitter_);
+    if (!singleSplitter_->IsSplit()) {
+        singleSplitter_->SplitVertically(selected, list, 360);
+    }
+}
+
+void DigiBattle99GameView::buildSingleCardsToolbar(wxWindow* parent, wxBoxSizer* pageSizer) {
+    auto* toolbar = new wxBoxSizer(wxHORIZONTAL);
+    auto makeToolBtn = [&](const char* svg, const wxString& tip) {
+        wxBitmap bmp = svgIconBitmap(svg, kDigiToolbarIconPx, "#000000");
+        auto* b = new wxBitmapButton(parent, wxID_ANY, bmp, wxDefaultPosition, wxDefaultSize,
+                                     wxBU_EXACTFIT);
+        b->SetToolTip(tip);
+        return b;
+    };
+    toolbarButtons_[0] = makeToolBtn(kSvgToolbarAdd,    "Add Card");
+    toolbarButtons_[1] = makeToolBtn(kSvgToolbarEdit,   "Edit");
+    toolbarButtons_[2] = makeToolBtn(kSvgToolbarDelete, "Delete");
+    toolbar->AddSpacer(4);
+    toolbar->Add(toolbarButtons_[0], 0, wxALIGN_CENTER_VERTICAL | wxALL, 4);
+    toolbar->Add(toolbarButtons_[1], 0, wxALIGN_CENTER_VERTICAL | wxALL, 4);
+    toolbar->Add(toolbarButtons_[2], 0, wxALIGN_CENTER_VERTICAL | wxALL, 4);
+    toolbar->AddStretchSpacer(1);
+    filterInput_ = new wxTextCtrl(parent, wxID_ANY, "", wxDefaultPosition, wxSize(260, -1));
+    filterInput_->SetHint(kDigiFilterHint);
+    toolbar->Add(filterInput_, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT | wxTOP | wxBOTTOM, 4);
+    pageSizer->Add(toolbar, 0, wxEXPAND);
+
+    toolbarButtons_[0]->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
+        wxWindow* owner = wxGetTopLevelParent(contentPanel_);
+        onAddCard(owner != nullptr ? owner : contentPanel_);
+    });
+    toolbarButtons_[1]->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
+        wxWindow* owner = wxGetTopLevelParent(contentPanel_);
+        onEditCard(owner != nullptr ? owner : contentPanel_);
+    });
+    toolbarButtons_[2]->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
+        wxWindow* owner = wxGetTopLevelParent(contentPanel_);
+        onDeleteCard(owner != nullptr ? owner : contentPanel_);
+    });
+    filterInput_->Bind(wxEVT_TEXT, [this](wxCommandEvent&) {
+        if (filterInput_ == nullptr) return;
+        setFilter(filterInput_->GetValue().ToStdString(wxConvUTF8));
+    });
+}
+
+void DigiBattle99GameView::refreshToolbarIcons(const ThemePalette& palette) {
+    const std::string tbHex = palette.buttonText.GetAsString(wxC2S_HTML_SYNTAX).ToStdString();
+    if (toolbarButtons_[0]) {
+        toolbarButtons_[0]->SetBitmap(
+            svgIconBitmap(kSvgToolbarAdd, kDigiToolbarIconPx, tbHex.c_str()));
+    }
+    if (toolbarButtons_[1]) {
+        toolbarButtons_[1]->SetBitmap(
+            svgIconBitmap(kSvgToolbarEdit, kDigiToolbarIconPx, tbHex.c_str()));
+    }
+    if (toolbarButtons_[2]) {
+        toolbarButtons_[2]->SetBitmap(
+            svgIconBitmap(kSvgToolbarDelete, kDigiToolbarIconPx, tbHex.c_str()));
+    }
+}
+
+wxPanel* DigiBattle99GameView::contentPanel(wxWindow* parent) {
+    if (contentPanel_ == nullptr) {
+        contentPanel_ = new wxPanel(parent);
+        auto* root = new wxBoxSizer(wxVERTICAL);
+
+        notebook_ = new wxNotebook(contentPanel_, wxID_ANY);
+        auto* singlePage = new wxPanel(notebook_);
+        auto* singleSizer = new wxBoxSizer(wxVERTICAL);
+        buildSingleCardsToolbar(singlePage, singleSizer);
+        ensureSingleCardsMounted(singlePage);
+        singleSizer->Add(singleSplitter_, 1, wxEXPAND);
+        singlePage->SetSizer(singleSizer);
+        notebook_->AddPage(singlePage, "Single Cards");
+
+        setCompletionPanel_ = new DigiBattle99SetCompletionPanel(notebook_, catalogStore_);
+        setCompletionPanel_->reloadFromStore();
+        notebook_->AddPage(setCompletionPanel_, "Set Completion");
+
+        root->Add(notebook_, 1, wxEXPAND);
+        contentPanel_->SetSizer(root);
+
+        refreshToolbarIcons(paletteForTheme(config_.current().theme));
+    }
+    return contentPanel_;
+}
+
 wxPanel* DigiBattle99GameView::listPanel(wxWindow* parent) {
     if (listPanel_ == nullptr) {
         listPanel_ = new DigiBattle99CardListPanel(parent);
@@ -69,7 +178,10 @@ wxPanel* DigiBattle99GameView::selectedPanel(wxWindow* parent) {
 }
 
 void DigiBattle99GameView::refreshCollection() {
-    if (listPanel_ == nullptr) return;
+    // Ensure the Digimon host (and list panel) exist even when MainFrame mounts
+    // via contentPanel before an explicit listPanel call.
+    if (contentPanel_ == nullptr && listPanel_ == nullptr) return;
+
     auto loaded = collection_.list(Game::DigiBattle99);
     if (!loaded) {
         showThemedMessageDialog(
@@ -78,9 +190,15 @@ void DigiBattle99GameView::refreshCollection() {
             "Error", wxOK | wxICON_ERROR);
         return;
     }
-    listPanel_->setCards(std::move(loaded).value());
-    listPanel_->activateSelection();
-    if (selectedPanel_) selectedPanel_->setCard(listPanel_->selected());
+    auto cards = std::move(loaded).value();
+    if (listPanel_ != nullptr) {
+        listPanel_->setCards(cards);
+        listPanel_->activateSelection();
+        if (selectedPanel_) selectedPanel_->setCard(listPanel_->selected());
+    }
+    if (setCompletionPanel_ != nullptr) {
+        setCompletionPanel_->setCollection(std::move(cards));
+    }
 }
 
 const std::vector<Set>& DigiBattle99GameView::setsForDialog() {
@@ -190,27 +308,79 @@ void DigiBattle99GameView::onDeleteCard(wxWindow* parentWindow) {
 }
 
 std::string DigiBattle99GameView::onUpdateSets(wxWindow* parentWindow) {
-    auto out = sets_.updateSets(Game::DigiBattle99);
-    if (!out) {
-        showThemedMessageDialog(parentWindow, "Failed to update sets: " + out.error(),
+    auto* digiSrc = dynamic_cast<DigiBattle99SetSource*>(&module_.setSource());
+    if (digiSrc == nullptr) {
+        showThemedMessageDialog(parentWindow, "Digimon Digi-Battle set source unavailable.",
                                 "Error", wxOK | wxICON_ERROR);
         return "Update failed";
     }
-    setsCache_ = out.value();
+
+    auto both = digiSrc->fetchAllWithCatalog();
+    if (!both) {
+        showThemedMessageDialog(parentWindow, "Failed to update sets: " + both.error(),
+                                "Error", wxOK | wxICON_ERROR);
+        return "Update failed";
+    }
+
+    auto savedSets = sets_.saveSets(Game::DigiBattle99, both.value().sets);
+    if (!savedSets) {
+        showThemedMessageDialog(parentWindow, "Failed to save sets: " + savedSets.error(),
+                                "Error", wxOK | wxICON_ERROR);
+        return "Update failed";
+    }
+
+    auto savedCatalog = catalogStore_.save(both.value().catalog);
+    if (!savedCatalog) {
+        showThemedMessageDialog(parentWindow,
+                                "Sets saved, but set catalog failed: " + savedCatalog.error(),
+                                "Warning", wxOK | wxICON_WARNING);
+    }
+
+    setsCache_ = both.value().sets;
+    if (setCompletionPanel_ != nullptr) {
+        setCompletionPanel_->reloadFromStore();
+        if (auto loaded = collection_.list(Game::DigiBattle99)) {
+            setCompletionPanel_->setCollection(std::move(loaded).value());
+        }
+    }
+
+    const std::size_t setCount = both.value().sets.size();
+    const std::size_t packCount = both.value().catalog.packs.size();
     showThemedMessageDialog(
         parentWindow,
-        "Updated " + std::to_string(out.value().size()) + " Digimon (Digi-Battle) sets.",
+        "Updated " + std::to_string(setCount) + " Digimon (Digi-Battle) sets and " +
+            std::to_string(packCount) + " set checklists.",
         "Sets updated", wxOK | wxICON_INFORMATION);
     return "Digimon (Digi-Battle) sets updated.";
 }
 
 void DigiBattle99GameView::setFilter(std::string_view filter) {
+    if (filterInput_ != nullptr) {
+        const wxString wanted = wxString::FromUTF8(std::string(filter).c_str());
+        if (filterInput_->GetValue() != wanted) {
+            filterInput_->ChangeValue(wanted);
+            if (filter.empty()) {
+                filterInput_->SetHint(kDigiFilterHint);
+                filterInput_->Refresh();
+            }
+        }
+    }
     if (listPanel_) listPanel_->setFilter(filter);
 }
 
 void DigiBattle99GameView::applyTheme(const ThemePalette& palette) {
+    if (contentPanel_) applyThemeToWindowTree(contentPanel_, palette, config_.current().theme);
     if (listPanel_)     listPanel_->applyTheme(palette);
     if (selectedPanel_) selectedPanel_->applyTheme(palette);
+    if (setCompletionPanel_) setCompletionPanel_->applyTheme(palette);
+    refreshToolbarIcons(palette);
+    if (filterInput_ != nullptr) {
+        filterInput_->SetBackgroundColour(palette.inputBg);
+        filterInput_->SetForegroundColour(palette.inputText);
+        filterInput_->SetOwnBackgroundColour(palette.inputBg);
+        filterInput_->SetOwnForegroundColour(palette.inputText);
+        filterInput_->Refresh();
+    }
 }
 
 }  // namespace ccm::ui

ui_wx/src/DigiBattle99SetCompletionPanel.cpp

@@ -0,0 +1,228 @@
+#include "ccm/ui/DigiBattle99SetCompletionPanel.hpp"
+
+#include "ccm/services/DigiBattle99SetCompletion.hpp"
+
+#include <wx/button.h>
+#include <wx/cursor.h>
+#include <wx/gauge.h>
+#include <wx/listctrl.h>
+#include <wx/scrolwin.h>
+#include <wx/simplebook.h>
+#include <wx/sizer.h>
+#include <wx/stattext.h>
+
+#include <utility>
+
+namespace ccm::ui {
+
+namespace {
+
+wxColour mutedTextColour(const ThemePalette& palette) {
+    // Blend text toward panel background so missing checklist rows read as greyed.
+    const auto blend = [](unsigned char a, unsigned char b) -> unsigned char {
+        return static_cast<unsigned char>((static_cast<int>(a) * 2 + static_cast<int>(b)) / 3);
+    };
+    return wxColour(blend(palette.text.Red(), palette.panelBg.Red()),
+                    blend(palette.text.Green(), palette.panelBg.Green()),
+                    blend(palette.text.Blue(), palette.panelBg.Blue()));
+}
+
+}  // namespace
+
+DigiBattle99SetCompletionPanel::DigiBattle99SetCompletionPanel(
+    wxWindow* parent, DigiBattle99SetCatalogService& catalogStore)
+    : wxPanel(parent), catalogStore_(catalogStore) {
+    palette_ = paletteForTheme(inferThemeFromWindow(this));
+
+    book_ = new wxSimplebook(this, wxID_ANY);
+
+    gridPage_ = new wxPanel(book_);
+    auto* gridRoot = new wxBoxSizer(wxVERTICAL);
+    emptyLabel_ = new wxStaticText(gridPage_, wxID_ANY, "");
+    emptyLabel_->Wrap(480);
+    gridRoot->Add(emptyLabel_, 0, wxALL | wxEXPAND, 12);
+
+    scroll_ = new wxScrolledWindow(gridPage_, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                                   wxVSCROLL | wxTAB_TRAVERSAL);
+    scroll_->SetScrollRate(0, 16);
+    gridSizer_ = new wxBoxSizer(wxVERTICAL);
+    scroll_->SetSizer(gridSizer_);
+    gridRoot->Add(scroll_, 1, wxEXPAND);
+    gridPage_->SetSizer(gridRoot);
+    book_->AddPage(gridPage_, "Grid");
+
+    detailPage_ = new wxPanel(book_);
+    auto* detailRoot = new wxBoxSizer(wxVERTICAL);
+    auto* topRow = new wxBoxSizer(wxHORIZONTAL);
+    auto* backBtn = new wxButton(detailPage_, wxID_ANY, "Back");
+    backBtn->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { showGridPage(); });
+    detailTitle_ = new wxStaticText(detailPage_, wxID_ANY, "");
+    auto titleFont = detailTitle_->GetFont();
+    titleFont.MakeBold().MakeLarger();
+    detailTitle_->SetFont(titleFont);
+    topRow->Add(backBtn, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 8);
+    topRow->Add(detailTitle_, 1, wxALIGN_CENTER_VERTICAL);
+    detailRoot->Add(topRow, 0, wxEXPAND | wxALL, 8);
+
+    checklist_ = new wxListCtrl(detailPage_, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                                wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER);
+    checklist_->AppendColumn("Card", wxLIST_FORMAT_LEFT, 520);
+    detailRoot->Add(checklist_, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 8);
+    detailPage_->SetSizer(detailRoot);
+    book_->AddPage(detailPage_, "Detail");
+
+    auto* root = new wxBoxSizer(wxVERTICAL);
+    root->Add(book_, 1, wxEXPAND);
+    SetSizer(root);
+
+    showGridPage();
+}
+
+void DigiBattle99SetCompletionPanel::setCollection(std::vector<DigiBattle99Card> cards) {
+    collection_ = std::move(cards);
+    if (book_->GetSelection() == 1 && !detailSetId_.empty()) {
+        rebuildChecklist(detailSetId_);
+    } else {
+        rebuildGrid();
+    }
+}
+
+void DigiBattle99SetCompletionPanel::reloadFromStore() {
+    catalogLoaded_ = false;
+    catalog_ = {};
+    if (catalogStore_.exists()) {
+        if (auto loaded = catalogStore_.load()) {
+            catalog_ = std::move(loaded).value();
+            catalogLoaded_ = true;
+        }
+    }
+    showGridPage();
+    rebuildGrid();
+}
+
+void DigiBattle99SetCompletionPanel::applyTheme(const ThemePalette& palette) {
+    palette_ = palette;
+    applyThemeToWindowTree(this, palette, inferThemeFromWindow(this));
+    if (book_->GetSelection() == 1 && !detailSetId_.empty()) {
+        rebuildChecklist(detailSetId_);
+    } else {
+        rebuildGrid();
+    }
+}
+
+void DigiBattle99SetCompletionPanel::showGridPage() {
+    detailSetId_.clear();
+    book_->SetSelection(0);
+}
+
+void DigiBattle99SetCompletionPanel::showChecklistPage(const std::string& setId,
+                                                      const std::string& setName) {
+    detailSetId_ = setId;
+    detailTitle_->SetLabelText(wxString::FromUTF8(setName.c_str()));
+    rebuildChecklist(setId);
+    book_->SetSelection(1);
+}
+
+void DigiBattle99SetCompletionPanel::setEmptyMessage(const wxString& message) {
+    clearGridTiles();
+    emptyLabel_->SetLabelText(message);
+    emptyLabel_->Wrap(480);
+    emptyLabel_->Show();
+    scroll_->Hide();
+    gridPage_->Layout();
+}
+
+void DigiBattle99SetCompletionPanel::clearGridTiles() {
+    if (gridSizer_ == nullptr) return;
+    gridSizer_->Clear(true);
+}
+
+void DigiBattle99SetCompletionPanel::rebuildGrid() {
+    if (!catalogLoaded_) {
+        setEmptyMessage(wxString::FromUTF8(
+            "Set checklists are not downloaded yet.\n"
+            "Run Sets → Update Digimon (Digi-Battle) to enable Set Completion."));
+        return;
+    }
+
+    const auto rows = computeDigiBattle99SetCompletion(collection_, catalog_);
+    if (rows.empty()) {
+        setEmptyMessage(wxString::FromUTF8(
+            "No Digimon (Digi-Battle) sets in progress yet.\n"
+            "Add cards on the Single Cards tab to track set completion here."));
+        return;
+    }
+
+    emptyLabel_->Hide();
+    scroll_->Show();
+    clearGridTiles();
+
+    for (const auto& row : rows) {
+        auto* tile = new wxPanel(scroll_, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                                 wxBORDER_SIMPLE);
+        tile->SetBackgroundColour(palette_.panelBg);
+        auto* tileSizer = new wxBoxSizer(wxVERTICAL);
+
+        auto* nameLbl = new wxStaticText(tile, wxID_ANY, wxString::FromUTF8(row.setName.c_str()));
+        auto nameFont = nameLbl->GetFont();
+        nameFont.MakeBold();
+        nameLbl->SetFont(nameFont);
+        nameLbl->SetForegroundColour(palette_.text);
+
+        const std::string counts =
+            std::to_string(row.ownedUnique) + " / " + std::to_string(row.total) + "  (" +
+            std::to_string(row.percent()) + "%)";
+        auto* countLbl = new wxStaticText(tile, wxID_ANY, wxString::FromUTF8(counts.c_str()));
+        countLbl->SetForegroundColour(palette_.text);
+
+        auto* gauge = new wxGauge(tile, wxID_ANY, 100, wxDefaultPosition, wxSize(-1, 14),
+                                  wxGA_HORIZONTAL | wxGA_SMOOTH);
+        gauge->SetValue(row.percent());
+
+        tileSizer->Add(nameLbl, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, 10);
+        tileSizer->Add(countLbl, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, 6);
+        tileSizer->Add(gauge, 0, wxEXPAND | wxALL, 10);
+        tile->SetSizer(tileSizer);
+
+        const std::string setId = row.setId;
+        const std::string setName = row.setName;
+        auto openDetail = [this, setId, setName](wxMouseEvent&) {
+            showChecklistPage(setId, setName);
+        };
+        tile->Bind(wxEVT_LEFT_UP, openDetail);
+        nameLbl->Bind(wxEVT_LEFT_UP, openDetail);
+        countLbl->Bind(wxEVT_LEFT_UP, openDetail);
+        gauge->Bind(wxEVT_LEFT_UP, openDetail);
+        tile->SetCursor(wxCursor(wxCURSOR_HAND));
+        nameLbl->SetCursor(wxCursor(wxCURSOR_HAND));
+        countLbl->SetCursor(wxCursor(wxCURSOR_HAND));
+
+        gridSizer_->Add(tile, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, 8);
+    }
+    gridSizer_->AddStretchSpacer(1);
+    scroll_->FitInside();
+    gridPage_->Layout();
+    Layout();
+}
+
+void DigiBattle99SetCompletionPanel::rebuildChecklist(const std::string& setId) {
+    checklist_->DeleteAllItems();
+    const auto entries = digiBattle99ChecklistForSet(collection_, catalog_, setId);
+    const wxColour muted = mutedTextColour(palette_);
+
+    long idx = 0;
+    for (const auto& entry : entries) {
+        const std::string line = entry.setNo + "  —  " + entry.name;
+        const long row = checklist_->InsertItem(idx++, wxString::FromUTF8(line.c_str()));
+        if (row < 0) continue;
+        if (entry.owned) {
+            checklist_->SetItemTextColour(row, palette_.text);
+        } else {
+            checklist_->SetItemTextColour(row, muted);
+        }
+    }
+    checklist_->SetColumnWidth(0, wxLIST_AUTOSIZE);
+    detailPage_->Layout();
+}
+
+}  // namespace ccm::ui

ui_wx/src/MainFrame.cpp

@@ -133,10 +133,11 @@ void MainFrame::buildLayout() {
     menuStrip_->SetSizer(menuSizer);
     root->Add(menuStrip_, 0, wxEXPAND);
 
+    toolbarPanel_ = new wxPanel(this, wxID_ANY);
     auto* toolbar = new wxBoxSizer(wxHORIZONTAL);
     auto makeToolBtn = [&](int id, const char* svg, const wxString& tip) {
         wxBitmap bmp = svgIconBitmap(svg, kToolbarIconPx, "#000000");
-        auto* b = new wxBitmapButton(this, id, bmp, wxDefaultPosition,
+        auto* b = new wxBitmapButton(toolbarPanel_, id, bmp, wxDefaultPosition,
                                      wxDefaultSize,
                                      wxBU_EXACTFIT);
         b->SetToolTip(tip);
@@ -150,16 +151,21 @@ void MainFrame::buildLayout() {
     toolbar->Add(toolbarButtons_[1], 0, wxALIGN_CENTER_VERTICAL | wxALL, 4);
     toolbar->Add(toolbarButtons_[2], 0, wxALIGN_CENTER_VERTICAL | wxALL, 4);
     toolbar->AddStretchSpacer(1);
-    filterInput_ = new wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition,
+    filterInput_ = new wxTextCtrl(toolbarPanel_, wxID_ANY, "", wxDefaultPosition,
                                   wxSize(260, -1));
     filterInput_->SetHint(kFilterInputHint);
     toolbar->Add(filterInput_, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT | wxTOP | wxBOTTOM, 4);
-    root->Add(toolbar, 0, wxEXPAND);
+    toolbarPanel_->SetSizer(toolbar);
+    root->Add(toolbarPanel_, 0, wxEXPAND);
 
-    splitter_ = new wxSplitterWindow(this, wxID_ANY, wxDefaultPosition,
+    contentHost_ = new wxPanel(this, wxID_ANY);
+    auto* hostSizer = new wxBoxSizer(wxVERTICAL);
+    splitter_ = new wxSplitterWindow(contentHost_, wxID_ANY, wxDefaultPosition,
                                      wxDefaultSize, wxSP_LIVE_UPDATE);
     splitter_->SetMinimumPaneSize(280);
-    root->Add(splitter_, 1, wxEXPAND);
+    hostSizer->Add(splitter_, 1, wxEXPAND);
+    contentHost_->SetSizer(hostSizer);
+    root->Add(contentHost_, 1, wxEXPAND);
 
     auto* statusPanel = new wxPanel(this, wxID_ANY);
     auto* statusSizer = new wxBoxSizer(wxHORIZONTAL);
@@ -199,15 +205,53 @@ IGameView* MainFrame::activeView() {
 
 void MainFrame::mountActiveView() {
     auto* view = activeView();
-    if (view == nullptr || splitter_ == nullptr) return;
+    if (view == nullptr || splitter_ == nullptr || contentHost_ == nullptr) return;
+
+    auto* hostSizer = contentHost_->GetSizer();
+    if (hostSizer == nullptr) return;
 
     // Hide every other view's panels so wx doesn't double-paint them.
     for (auto* other : ctx_.gameViews) {
         if (other == nullptr || other == view) continue;
+        if (other->hostsOwnLayout()) {
+            if (auto* cp = other->contentPanelIfCreated()) cp->Hide();
+            continue;
+        }
         if (auto* lp = other->listPanel(splitter_)) lp->Hide();
         if (auto* sp = other->selectedPanel(splitter_)) sp->Hide();
     }
 
+    const ThemePalette palette = paletteForTheme(ctx_.config.current().theme);
+
+    if (toolbarPanel_ != nullptr) {
+        if (view->hostsOwnLayout()) toolbarPanel_->Hide();
+        else                        toolbarPanel_->Show();
+        Layout();
+    }
+
+    if (view->hostsOwnLayout()) {
+        auto* custom = view->contentPanel(contentHost_);
+        if (custom == nullptr) return;
+
+        splitter_->Hide();
+        hostSizer->Clear(false);
+        custom->Show();
+        hostSizer->Add(custom, 1, wxEXPAND);
+        contentHost_->Layout();
+
+        view->applyTheme(palette);
+        applyThemeToWindowTree(custom, palette, ctx_.config.current().theme);
+        return;
+    }
+
+    if (auto* previousCustom = view->contentPanelIfCreated()) {
+        previousCustom->Hide();
+    }
+    // Re-seat the shared splitter if a contentPanel game was showing.
+    hostSizer->Clear(false);
+    splitter_->Show();
+    hostSizer->Add(splitter_, 1, wxEXPAND);
+
     auto* listPanel = view->listPanel(splitter_);
     auto* selectedPanel = view->selectedPanel(splitter_);
     if (listPanel == nullptr || selectedPanel == nullptr) return;
@@ -221,7 +265,7 @@ void MainFrame::mountActiveView() {
         splitter_->SplitVertically(selectedPanel, listPanel, 360);
     }
 
-    const ThemePalette palette = paletteForTheme(ctx_.config.current().theme);
+    contentHost_->Layout();
     view->applyTheme(palette);
     applyThemeToWindowTree(selectedPanel, palette, ctx_.config.current().theme);
     applyThemeToWindowTree(listPanel, palette, ctx_.config.current().theme);