feat(weather editor): add filter options for objects window

[SkrubbySkrubInAShrub]

• filter by type
• ensure all UI stays in the window.

Summary by CodeRabbit

• New Features
  • Enhanced object filtering with column-specific options (EditorID, FormID, File, Status) plus an All mode that searches across fields.
  • Added favorites/flagged toggles to filter visible objects.
• Refactor
  • Filter and category state now scoped per-window for more reliable category switching, recent lists, and predictable filter resets.
• UI
  • Improved filter controls and layout: aligned search input, filter-by selector, and updated help text.

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

📝 Walkthrough

Walkthrough

Replaces global/static objects-window filter state with instance members on EditorWindow, adds FilterColumn enum and kFilterColumnNames, implements ResetObjectsFilter and MatchesObjectFilter, centralizes per-object filtering across object lists, and updates the Objects window UI to include a unified search and filter-by combo.

Changes

Cohort / File(s)

Summary

Objects filter implementation src/WeatherEditor/EditorWindow.cpp, src/WeatherEditor/EditorWindow.h

Adds FilterColumn enum and kFilterColumnNames; introduces instance members (m_selectedCategory, m_previousSelectedCategory, m_filterBuffer, m_currentFilterColumn, m_showOnlyFlagged, m_showOnlyFavorites); adds ResetObjectsFilter() and MatchesObjectFilter(Widget*) const; replaces static globals with members and centralizes filtering logic; updates Objects UI layout (search + filter-by combo) and wiring.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

• fix(weather editor): reorder categories for better intuition. #1725 — Modifies ShowObjectsWindow and category selection logic; strongly related to replacing/adjusting selectedCategory and objects-window behavior.

Suggested reviewers

• doodlum

Poem

🐇
I hopped through lists and found a thread,
I tidied filters in my cozy bed,
A search and combo side by side,
Widgets sorted, nothing to hide,
Hopping happy — code well-fed.

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 50.00% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'feat(weather editor): add filter options for objects window' accurately reflects the main changes: adding a new FilterColumn enum, filter state members (m_currentFilterColumn, m_filterBuffer, m_showOnlyFlagged, m_showOnlyFavorites), and two new filter methods (ResetObjectsFilter, MatchesObjectFilter) to support filtering in the objects window.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[github-actions]

Using provided base ref: e4c0842
Using base ref: e4c0842
Base commit date: 2026-02-22T09:26:01Z (Sunday, February 22, 2026 09:26 AM)
No actionable suggestions for changed features.

[coderabbitai]

Actionable comments posted: 1

🧹 Nitpick comments (2)

src/WeatherEditor/EditorWindow.cpp (2)

193-206: GetEditorID() called twice in the All case — cache the result.

Lines 195 and 202 both call w->GetEditorID(). If GetEditorID() returns by value, this constructs two std::string copies per widget per frame in the All path.

♻️ Proposed fix

 case FilterColumn::All:
 default:
-    if (ContainsStringIgnoreCase(w->GetEditorID(), filterBuffer))
+    {
+    const auto& editorID = w->GetEditorID();
+    if (ContainsStringIgnoreCase(editorID, filterBuffer))
         return true;
     if (ContainsStringIgnoreCase(w->GetFormID(), filterBuffer))
         return true;
     if (ContainsStringIgnoreCase(w->GetFilename(), filterBuffer))
         return true;
     {
-        auto it = settings.markedRecords.find(w->GetEditorID());
+        auto it = settings.markedRecords.find(editorID);
         if (it != settings.markedRecords.end() && ContainsStringIgnoreCase(it->second, filterBuffer))
             return true;
     }
     return false;
+    }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 193 - 206, In the
FilterColumn::All branch avoid calling w->GetEditorID() twice by capturing its
result into a local string (e.g., editorId) and reuse that for the
ContainsStringIgnoreCase check and for the settings.markedRecords lookup; ensure
you compare editorId with filterBuffer and use the cached editorId when doing
settings.markedRecords.find(editorId), leaving the other checks (GetFormID,
GetFilename, and markedRecords value check) unchanged.

---

291-292: * 8.0f spacing multiplier must be manually kept in sync with the UI layout.

The magic constant 8.0f encodes the exact number of SameLine() spacings between the filter input and the right edge of the row. If any item is added or removed from this line, this formula silently produces incorrect widths, potentially reintroducing overflow.

Consider a brief comment:

♻️ Suggested comment

-const float fixedW = style.ItemSpacing.x * 8.0f + comboW + helpW + 10.0f + iconW +
-                     ImGui::CalcTextSize("Favorites").x + 10.0f + iconW + ImGui::CalcTextSize("Flagged").x;
+// 8 SameLine spacings: filter→combo, combo→help, help→sp1, sp1→star, star→Fav, Fav→sp2, sp2→circle, circle→Flagged
+const float fixedW = style.ItemSpacing.x * 8.0f + comboW + helpW + 10.0f + iconW +
+                     ImGui::CalcTextSize("Favorites").x + 10.0f + iconW + ImGui::CalcTextSize("Flagged").x;

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 291 - 292, The expression
computing fixedW uses a hardcoded multiplier "8.0f" tied to the number of
SameLine() gaps, which will break when the UI row layout changes; update the
calculation in EditorWindow.cpp (the fixedW computation that uses
style.ItemSpacing.x, comboW, helpW, iconW and
ImGui::CalcTextSize("Favorites"/"Flagged")) to compute the spacing count
programmatically (e.g., derive numGaps from the actual list of items on the row
or a small const/enum that is updated with the layout) and replace the magic
8.0f with style.ItemSpacing.x * numGaps, and add a short inline comment
explaining that numGaps must match the number of SameLine() items so future
edits update both the layout and this constant.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 287-288: The combo width calculation underestimates space for the
arrow button; update the computation of comboW in EditorWindow.cpp (the line
computing comboW using ImGui::CalcTextSize and style.FramePadding) to add
ImGui::GetFrameHeight() and only two times FramePadding.x (i.e. text width +
2*FramePadding.x + ImGui::GetFrameHeight()) so the preview text "Editor ID" is
not clipped; keep the rest of the code using comboW unchanged.

---

Nitpick comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 193-206: In the FilterColumn::All branch avoid calling
w->GetEditorID() twice by capturing its result into a local string (e.g.,
editorId) and reuse that for the ContainsStringIgnoreCase check and for the
settings.markedRecords lookup; ensure you compare editorId with filterBuffer and
use the cached editorId when doing settings.markedRecords.find(editorId),
leaving the other checks (GetFormID, GetFilename, and markedRecords value check)
unchanged.
- Around line 291-292: The expression computing fixedW uses a hardcoded
multiplier "8.0f" tied to the number of SameLine() gaps, which will break when
the UI row layout changes; update the calculation in EditorWindow.cpp (the
fixedW computation that uses style.ItemSpacing.x, comboW, helpW, iconW and
ImGui::CalcTextSize("Favorites"/"Flagged")) to compute the spacing count
programmatically (e.g., derive numGaps from the actual list of items on the row
or a small const/enum that is updated with the layout) and replace the magic
8.0f with style.ItemSpacing.x * numGaps, and add a short inline comment
explaining that numGaps must match the number of SameLine() items so future
edits update both the layout and this constant.

[coderabbitai]

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/WeatherEditor/EditorWindow.cpp (1)

158-175: ⚠️ Potential issue | 🟡 Minor

currentFilterColumn not reset on category change may produce an unexpectedly empty list.

If currentFilterColumn is Status and the user switches to a category with no marked records, matchesFilter returns false for every widget, leaving the list blank with no visible explanation. A simple reset to FilterColumn::All whenever selectedCategory changes would prevent the surprise:

🛡️ Suggested guard

+    static std::string prevSelectedCategory;
+    if (prevSelectedCategory != selectedCategory) {
+        prevSelectedCategory = selectedCategory;
+        currentFilterColumn = FilterColumn::All;
+    }

(Place this immediately after the currentFilterColumn static declaration.)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 158 - 175, The filter column
(currentFilterColumn) isn't reset when selectedCategory changes, which can leave
the list empty if the new category has no items matching the previously chosen
column (e.g., Status); add a guard right after the currentFilterColumn static
declaration that detects a change in selectedCategory (store a
previousSelectedCategory static string), and when it differs set
currentFilterColumn = FilterColumn::All (optionally also clear
filterBuffer/showOnlyFlagged/showOnlyFavorites) so matchesFilter uses the
default "All" column after a category switch; reference symbols:
selectedCategory, currentFilterColumn, matchesFilter.

🧹 Nitpick comments (2)

src/WeatherEditor/EditorWindow.cpp (2)

165-175: Consider hoisting FilterColumn, kFilterColumnNames, and currentFilterColumn out of the function body.

All three are re-declared inside ShowObjectsWindow() on every call. static ensures they initialize only once, and C++ permits a static local of a local enum class type — but this pattern is non-idiomatic and makes the type invisible to the rest of the class. Moving them to class scope (or to an anonymous namespace in the .cpp) eliminates the per-call re-definition noise and makes the state easier to spot during debugging.

♻️ Sketch of class-scope placement

In EditorWindow.h / EditorWindow.cpp private section:

+    enum class FilterColumn : int { All = 0, EditorID, FormID, File, Status };
+    static constexpr const char* kFilterColumnNames[] = { "All", "Editor ID", "Form ID", "File", "Status" };
+    FilterColumn currentFilterColumn = FilterColumn::All;

Then in ShowObjectsWindow() remove the three local declarations.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 165 - 175, Move the local
enum and static variables out of ShowObjectsWindow to file- or class-scope:
define FilterColumn (enum class FilterColumn), kFilterColumnNames (constexpr
const char*[]), and currentFilterColumn (FilterColumn) either as private members
in the EditorWindow class or in an anonymous namespace at top of the .cpp, then
remove their local declarations from ShowObjectsWindow so the function uses the
hoisted symbols; ensure any references (FilterColumn::All, currentFilterColumn,
kFilterColumnNames) are updated to the new scope.

---

293-297: numGaps is a fragile magic constant with no compile-time guard.

The accompanying comment correctly warns that numGaps must be kept in sync with the number of SameLine() calls — but that synchronization is entirely manual. A mismatch causes the input field to either overflow the row or leave a visible gap, with no compile-time or runtime diagnostic.

A self-verifying alternative (counts items at compile time rather than hard-coding the gap count):

♻️ Suggested approach

-    constexpr int numGaps = 8;
-    const float fixedW = style.ItemSpacing.x * numGaps + comboW + helpW + 10.0f + iconW +
-                         ImGui::CalcTextSize("Favorites").x + 10.0f + iconW + ImGui::CalcTextSize("Flagged").x;
+    // Each SameLine() item after the search bar contributes one ItemSpacing gap.
+    // Items: [combo] [help] [spacer10] [fav icon] ["Favorites"] [spacer10] [flag icon] ["Flagged"]
+    const float fixedItemsW = comboW + helpW + 10.0f + iconW +
+                               ImGui::CalcTextSize("Favorites").x + 10.0f + iconW +
+                               ImGui::CalcTextSize("Flagged").x;
+    constexpr int numSameLines = 8;  // one per SameLine() call that follows the search bar
+    const float fixedW = style.ItemSpacing.x * numSameLines + fixedItemsW;

The split makes it clearer what "gaps" means vs. "item widths", reducing the chance of off-by-one when a new item is inserted.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 293 - 297, The hard-coded
constexpr int numGaps is brittle and must be derived instead of manually kept in
sync with the number of ImGui::SameLine() items; update the code around numGaps
and fixedW to compute the gap count from the actual set of UI items (e.g. define
a constexpr list/array of the row elements or a constexpr numItems and compute
constexpr int numGaps = numItems - 1) and use that computed numGaps when
building fixedW (still referencing comboW, helpW, iconW and the text widths), so
adding/removing ImGui::SameLine() calls no longer requires a manual numGaps
change.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 158-175: The filter column (currentFilterColumn) isn't reset when
selectedCategory changes, which can leave the list empty if the new category has
no items matching the previously chosen column (e.g., Status); add a guard right
after the currentFilterColumn static declaration that detects a change in
selectedCategory (store a previousSelectedCategory static string), and when it
differs set currentFilterColumn = FilterColumn::All (optionally also clear
filterBuffer/showOnlyFlagged/showOnlyFavorites) so matchesFilter uses the
default "All" column after a category switch; reference symbols:
selectedCategory, currentFilterColumn, matchesFilter.

---

Nitpick comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 165-175: Move the local enum and static variables out of
ShowObjectsWindow to file- or class-scope: define FilterColumn (enum class
FilterColumn), kFilterColumnNames (constexpr const char*[]), and
currentFilterColumn (FilterColumn) either as private members in the EditorWindow
class or in an anonymous namespace at top of the .cpp, then remove their local
declarations from ShowObjectsWindow so the function uses the hoisted symbols;
ensure any references (FilterColumn::All, currentFilterColumn,
kFilterColumnNames) are updated to the new scope.
- Around line 293-297: The hard-coded constexpr int numGaps is brittle and must
be derived instead of manually kept in sync with the number of ImGui::SameLine()
items; update the code around numGaps and fixedW to compute the gap count from
the actual set of UI items (e.g. define a constexpr list/array of the row
elements or a constexpr numItems and compute constexpr int numGaps = numItems -
1) and use that computed numGaps when building fixedW (still referencing comboW,
helpW, iconW and the text widths), so adding/removing ImGui::SameLine() calls no
longer requires a manual numGaps change.

[github-actions]

✅ A pre-release build is available for this PR:
Download

[coderabbitai]

🧹 Nitpick comments (1)

src/WeatherEditor/EditorWindow.cpp (1)

300-312: Width arithmetic looks correct; consider a comment mapping each addend to its UI element.

I verified the 8 SameLine() calls (combo, help, spacer, fav-icon, "Favorites", spacer, flag-icon, "Flagged") match numFixedItems = 8 and each corresponding width addend in fixedW. The formula is correct.

A small maintainability suggestion: the fixedW expression packs many terms into one line. Naming intermediate sums (or adding inline comments per addend) would make it easier for the next person to verify they're still in sync when items are added/removed—especially given the "Update numFixedItems when adding or removing items" comment.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 300 - 312, The fixed-width
calculation in EditorWindow.cpp uses a long expression assigned to fixedW (and
related vars comboW, helpW, iconW) that is correct but hard to maintain;
refactor by introducing clearly named intermediate variables (e.g., gapWidth =
style.ItemSpacing.x * numGaps, previewWidth = comboW, labelFavoritesWidth =
ImGui::CalcTextSize("Favorites").x, labelFlaggedWidth =
ImGui::CalcTextSize("Flagged").x, spacerWidth = 10.0f) or add inline comments
beside each addend so the mapping between numFixedItems/SameLine() items and the
terms in fixedW is explicit, then use those intermediates when calling
ImGui::SetNextItemWidth to compute the same value. Ensure you update/keep
numFixedItems in sync with the named parts (comboW, helpW, iconW,
labelFavoritesWidth, labelFlaggedWidth, gapWidth, spacerWidth) so future edits
are clearer.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 316-322: The Combo and HelpMarker integration is correct—ensure
the combo width calculation using comboW (which uses FramePadding.x * 2.0f +
GetFrameHeight()) remains and keep the temporary int round-trip around
currentFilterColumn (cast to int for ImGui::Combo then back to FilterColumn) as
shown in the block that updates currentFilterColumn; no functional changes
required other than preserving this pattern in EditorWindow:: (the
combo/HelpMarker snippet) to maintain safe bounds and consistent UI behavior.

---

Nitpick comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 300-312: The fixed-width calculation in EditorWindow.cpp uses a
long expression assigned to fixedW (and related vars comboW, helpW, iconW) that
is correct but hard to maintain; refactor by introducing clearly named
intermediate variables (e.g., gapWidth = style.ItemSpacing.x * numGaps,
previewWidth = comboW, labelFavoritesWidth = ImGui::CalcTextSize("Favorites").x,
labelFlaggedWidth = ImGui::CalcTextSize("Flagged").x, spacerWidth = 10.0f) or
add inline comments beside each addend so the mapping between
numFixedItems/SameLine() items and the terms in fixedW is explicit, then use
those intermediates when calling ImGui::SetNextItemWidth to compute the same
value. Ensure you update/keep numFixedItems in sync with the named parts
(comboW, helpW, iconW, labelFavoritesWidth, labelFlaggedWidth, gapWidth,
spacerWidth) so future edits are clearer.

[coderabbitai]

Actionable comments posted: 2

🧹 Nitpick comments (2)

src/WeatherEditor/EditorWindow.cpp (2)

307-311: numFixedItems and numGaps are always equal — consolidate into one constant.

Two separate constexpr values that must be kept in sync add maintenance burden without benefit. A single constexpr int numItemsAfterSearchBar = 8 (with the existing comment enumerating what those 8 items are) is clearer.

♻️ Proposed refactor

-// Each fixed-width item on the row is preceded by one SameLine().
-// Update numFixedItems when adding or removing items from the row.
-constexpr int numFixedItems = 8;  // combo, help, spacer, fav icon, "Favorites", spacer, flag icon, "Flagged"
-constexpr int numGaps = numFixedItems;
-const float fixedW = style.ItemSpacing.x * numGaps + comboW + helpW + 10.0f + iconW +
+// Items following the search bar (each preceded by one SameLine() gap).
+// Update this count and fixedW when adding or removing items from the row.
+constexpr int numItemsAfterSearchBar = 8;  // combo, help, spacer, fav icon, "Favorites", spacer, flag icon, "Flagged"
+const float fixedW = style.ItemSpacing.x * numItemsAfterSearchBar + comboW + helpW + 10.0f + iconW +

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 307 - 311, Replace the two
synchronized constants numFixedItems and numGaps with a single constexpr
(suggested name numItemsAfterSearchBar) and update fixedW to use that single
constant; change references to numFixedItems and numGaps in the block that
computes fixedW (and the comment above it) so the meaning is preserved (e.g.,
keep the comment enumerating the 8 items) and ensure fixedW still uses the
single count for calculating style.ItemSpacing.x * count.

---

153-162: Wrap file-scope declarations in an anonymous namespace.

FilterColumn and kFilterColumnNames are visible as TU-global symbols. Since they're only used inside ShowObjectsWindow, wrapping them in an anonymous namespace or moving them into the function avoids any future name conflicts.

♻️ Proposed refactor

+namespace {
+
 // Filter column options for the Objects window search bar.
 enum class FilterColumn : int
 {
     All = 0,
     EditorID,
     FormID,
     File,
     Status
 };
 constexpr const char* kFilterColumnNames[] = { "All", "Editor ID", "Form ID", "File", "Status" };
+
+}  // namespace

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 153 - 162, FilterColumn and
kFilterColumnNames are currently TU-global; wrap these file-scope declarations
in an anonymous namespace (or move them into ShowObjectsWindow) to limit linkage
and prevent name collisions. Locate the enum class FilterColumn and the
constexpr array kFilterColumnNames and enclose them in "namespace { ... }" (or
relocate both inside the ShowObjectsWindow function body) so they become
internal linkage; ensure any code in ShowObjectsWindow referencing FilterColumn
and kFilterColumnNames still compiles after the move.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Line 322: Update the help text passed to HelpMarker in EditorWindow.cpp so it
documents the Status-column special case: when the Status column is selected and
the search box is non-empty, items without a status marker are hidden. Locate
the HelpMarker(...) call (the string that currently reads "Filter the object
list by the selected column.\nAll: searches Editor ID, Form ID, File, and
Status.\nCtrl+F: Focus search\nEnter: Open selected") and append a short
sentence describing the Status behavior so users know that selecting Status +
non-empty search will hide items with no status marker.
- Around line 191-192: Add a defensive null check at the start of the
matchesFilter lambda used to test Widget* entries: if the passed Widget* (w) is
null, immediately return false so the function never dereferences a null
pointer; update the lambda in EditorWindow.cpp (matchesFilter) to guard against
a null w before accessing filterBuffer or widget properties, leaving the rest of
the filter logic intact so sortedWidgets processing remains unchanged.

---

Nitpick comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 307-311: Replace the two synchronized constants numFixedItems and
numGaps with a single constexpr (suggested name numItemsAfterSearchBar) and
update fixedW to use that single constant; change references to numFixedItems
and numGaps in the block that computes fixedW (and the comment above it) so the
meaning is preserved (e.g., keep the comment enumerating the 8 items) and ensure
fixedW still uses the single count for calculating style.ItemSpacing.x * count.
- Around line 153-162: FilterColumn and kFilterColumnNames are currently
TU-global; wrap these file-scope declarations in an anonymous namespace (or move
them into ShowObjectsWindow) to limit linkage and prevent name collisions.
Locate the enum class FilterColumn and the constexpr array kFilterColumnNames
and enclose them in "namespace { ... }" (or relocate both inside the
ShowObjectsWindow function body) so they become internal linkage; ensure any
code in ShowObjectsWindow referencing FilterColumn and kFilterColumnNames still
compiles after the move.

[coderabbitai]

🧹 Nitpick comments (4)

src/WeatherEditor/EditorWindow.h (1)

231-246: Optional: add a Count_ sentinel to guard kFilterColumnNames sync

kFilterColumnNames in the .cpp anonymous namespace must stay in sync with FilterColumn manually. A sentinel enum value enables a cheap compile-time check inside any EditorWindow member function.

♻️ Proposed change

 enum class FilterColumn : int
 {
     All = 0,
     EditorID,
     FormID,
     File,
-    Status
+    Status,
+    Count_  // sentinel — do not use as a filter value
 };

Then, inside EditorWindow::MatchesObjectFilter or EditorWindow::ResetObjectsFilter in the .cpp:

static_assert(static_cast<int>(FilterColumn::Count_) == IM_ARRAYSIZE(kFilterColumnNames),
    "kFilterColumnNames must have one entry per FilterColumn value");

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.h` around lines 231 - 246, Add a sentinel
value to the FilterColumn enum (e.g., Count_) after Status so the enum size can
be checked against kFilterColumnNames; then add a compile-time check
(static_assert) in an EditorWindow member function such as MatchesObjectFilter
or ResetObjectsFilter that compares static_cast<int>(FilterColumn::Count_) to
IM_ARRAYSIZE(kFilterColumnNames) with a clear message like "kFilterColumnNames
must have one entry per FilterColumn value" to ensure the arrays stay in sync.

src/WeatherEditor/EditorWindow.cpp (3)

583-595: Duplicated three-condition filter block

Lines 588–595 are an exact copy of lines 678–685. Extracting a lambda keeps the filter logic in one place and ensures both loops apply the same checks.

♻️ Proposed extraction (before the first loop, after sortedWidgets is built)

auto shouldShowWidget = [&](Widget* w) -> bool {
    if (!MatchesObjectFilter(w))
        return false;
    if (m_showOnlyFavorites && !IsFavorite(w->GetEditorID()))
        return false;
    if (m_showOnlyFlagged && settings.markedRecords.find(w->GetEditorID()) == settings.markedRecords.end())
        return false;
    return true;
};

Then replace both three-condition blocks with if (!shouldShowWidget(sortedWidgets[i])) continue;.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 583 - 595, Extract the
repeated three-condition filter into a single lambda (e.g., shouldShowWidget)
declared after sortedWidgets is built and before both loops; the lambda should
accept Widget* w and return false if !MatchesObjectFilter(w), if
m_showOnlyFavorites && !IsFavorite(w->GetEditorID()), or if m_showOnlyFlagged &&
settings.markedRecords.find(w->GetEditorID()) == settings.markedRecords.end(),
otherwise return true; then replace the duplicated blocks in the loops that
iterate over sortedWidgets and check LightingTemplateWidget* ltWidget (the code
around LightingTemplateWidget* ltWidget =
dynamic_cast<LightingTemplateWidget*>(sortedWidgets[i]) and the subsequent
continues) with a single call if (!shouldShowWidget(sortedWidgets[i])) continue;
so both loops use the same centralized filter logic.

---

296-300: numItemsAfterSearchBar = 8 is a fragile coupling point

If any item is added to or removed from the same-line row without updating this constant and the fixedW formula, the search bar width will silently break. Consider computing fixedW bottom-up from the actual item widths rather than relying on a separate item count.

♻️ Proposed simplification

-        constexpr int numItemsAfterSearchBar = 8;  // combo, help, spacer, fav icon, "Favorites", spacer, flag icon, "Flagged"
-        const float fixedW = style.ItemSpacing.x * numItemsAfterSearchBar + comboW + helpW + 10.0f + iconW +
-                             ImGui::CalcTextSize("Favorites").x + 10.0f + iconW + ImGui::CalcTextSize("Flagged").x;
+        // One ItemSpacing per SameLine that will follow the search bar.
+        const float fixedW =
+            style.ItemSpacing.x + comboW +                            // combo
+            style.ItemSpacing.x + helpW +                             // help marker
+            style.ItemSpacing.x + 10.0f +                             // spacer dummy
+            style.ItemSpacing.x + iconW +                             // fav icon
+            style.ItemSpacing.x + ImGui::CalcTextSize("Favorites").x +// "Favorites"
+            style.ItemSpacing.x + 10.0f +                             // spacer dummy
+            style.ItemSpacing.x + iconW +                             // flag icon
+            style.ItemSpacing.x + ImGui::CalcTextSize("Flagged").x;   // "Flagged"

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 296 - 300, The hardcoded
constant numItemsAfterSearchBar and the computed fixedW are fragile; change the
logic in the same scope where fixedW is computed (around the
fixedW/numItemsAfterSearchBar usage and the ImGui::SetNextItemWidth call) to
calculate fixedW by summing the actual widths of each widget that follows the
search bar (e.g., comboW, helpW, iconW, plus ImGui::CalcTextSize("Favorites").x
and ImGui::CalcTextSize("Flagged").x, spacers and paddings) instead of
multiplying style.ItemSpacing.x by a magic count, then use that computed fixedW
when calling ImGui::SetNextItemWidth so adding/removing widgets only requires
updating their own width expressions.

---

342-349: Duplicate category→widget-collection mappings have diverging fallbacks

This chain (for "recent" click-to-open) and the display chain at lines 418–425 encode the same mapping with different defaults — map 1 falls back to weatherWidgets, map 2 falls back to lightingTemplateWidgets. Adding a new category requires updating both, and forgetting one silently uses the wrong collection.

♻️ Proposed helper (add as private method or lambda near line 342)

// Returns a const reference to the widget collection for the given category.
// emptyWidgets is a local empty vector for categories with no standalone widgets.
auto getWidgetsForCategory = [&](const std::string& category) -> const std::vector<std::unique_ptr<Widget>>& {
    if (category == "Weather")                  return weatherWidgets;
    if (category == "Lighting Template")        return lightingTemplateWidgets;
    if (category == "ImageSpace")               return imageSpaceWidgets;
    if (category == "Volumetric Lighting")      return volumetricLightingWidgets;
    if (category == "Shader Particle Geometry") return precipitationWidgets;
    if (category == "Lens Flare")               return lensFlareWidgets;
    if (category == "Visual Effect")            return referenceEffectWidgets;
    return emptyWidgets;  // Cell Lighting, Interior Only, unknown
};

Then both call sites become getWidgetsForCategory(m_selectedCategory), eliminating the divergence.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/WeatherEditor/EditorWindow.cpp` around lines 342 - 349, Replace the
duplicated category→widget mapping chains with a single helper (private method
or lambda) that accepts a category string and returns a const reference to the
appropriate widget collection (use weatherWidgets, lightingTemplateWidgets,
imageSpaceWidgets, volumetricLightingWidgets, precipitationWidgets,
lensFlareWidgets, referenceEffectWidgets and an emptyWidgets local fallback for
unknown/no-standalone categories); then change both call sites that now switch
on m_selectedCategory (the recent click-to-open mapping and the display mapping)
to call getWidgetsForCategory(m_selectedCategory) so they use the same canonical
mapping and fallback.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@src/WeatherEditor/EditorWindow.cpp`:
- Around line 583-595: Extract the repeated three-condition filter into a single
lambda (e.g., shouldShowWidget) declared after sortedWidgets is built and before
both loops; the lambda should accept Widget* w and return false if
!MatchesObjectFilter(w), if m_showOnlyFavorites &&
!IsFavorite(w->GetEditorID()), or if m_showOnlyFlagged &&
settings.markedRecords.find(w->GetEditorID()) == settings.markedRecords.end(),
otherwise return true; then replace the duplicated blocks in the loops that
iterate over sortedWidgets and check LightingTemplateWidget* ltWidget (the code
around LightingTemplateWidget* ltWidget =
dynamic_cast<LightingTemplateWidget*>(sortedWidgets[i]) and the subsequent
continues) with a single call if (!shouldShowWidget(sortedWidgets[i])) continue;
so both loops use the same centralized filter logic.
- Around line 296-300: The hardcoded constant numItemsAfterSearchBar and the
computed fixedW are fragile; change the logic in the same scope where fixedW is
computed (around the fixedW/numItemsAfterSearchBar usage and the
ImGui::SetNextItemWidth call) to calculate fixedW by summing the actual widths
of each widget that follows the search bar (e.g., comboW, helpW, iconW, plus
ImGui::CalcTextSize("Favorites").x and ImGui::CalcTextSize("Flagged").x, spacers
and paddings) instead of multiplying style.ItemSpacing.x by a magic count, then
use that computed fixedW when calling ImGui::SetNextItemWidth so adding/removing
widgets only requires updating their own width expressions.
- Around line 342-349: Replace the duplicated category→widget mapping chains
with a single helper (private method or lambda) that accepts a category string
and returns a const reference to the appropriate widget collection (use
weatherWidgets, lightingTemplateWidgets, imageSpaceWidgets,
volumetricLightingWidgets, precipitationWidgets, lensFlareWidgets,
referenceEffectWidgets and an emptyWidgets local fallback for
unknown/no-standalone categories); then change both call sites that now switch
on m_selectedCategory (the recent click-to-open mapping and the display mapping)
to call getWidgetsForCategory(m_selectedCategory) so they use the same canonical
mapping and fallback.

In `@src/WeatherEditor/EditorWindow.h`:
- Around line 231-246: Add a sentinel value to the FilterColumn enum (e.g.,
Count_) after Status so the enum size can be checked against kFilterColumnNames;
then add a compile-time check (static_assert) in an EditorWindow member function
such as MatchesObjectFilter or ResetObjectsFilter that compares
static_cast<int>(FilterColumn::Count_) to IM_ARRAYSIZE(kFilterColumnNames) with
a clear message like "kFilterColumnNames must have one entry per FilterColumn
value" to ensure the arrays stay in sync.