feat(search): port CSearchListCtrl to wxDataViewCtrl - #796

Reviewed and built this on macOS (arm64, wx 3.3.3) and Ubuntu 26.04 arm64 (wxGTK 3.2.6); Windows ARM64 is building. Row colouring is confirmed working on macOS, so that box can be ticked.

1. Grouped rows show only the filename until expanded. wxDataViewModel::HasValue() is col == 0 || !IsContainer(item) || HasContainerColumns(item), and HasContainerColumns() defaults to false — so a container draws column 0 and nothing else. GetValue() already computes every column for parents, so the data is there; the control just never asks. wxListCtrl had no notion of container rows, which is why this only appears after the port.

Returning true is right for this model specifically: a grouped parent is a real result, and its children are alternative sources of the same file — not a section header over unrelated rows.

--- a/src/SearchListModel.h
+++ b/src/SearchListModel.h
 	bool IsContainer(const wxDataViewItem &item) const wxOVERRIDE;
+	//! A grouped result is a row in its own right, not a section header: the
+	//! parent carries the same name/size/sources/rating as any other result
+	//! and its children are alternative sources for the same file. Without
+	//! this, wxDataViewModel::HasValue() draws only column 0 for a container
+	//! -- the group shows its filename and nothing else until expanded.
+	bool HasContainerColumns(const wxDataViewItem &item) const wxOVERRIDE;

--- a/src/SearchListModel.cpp
+++ b/src/SearchListModel.cpp
+bool CSearchListModel::HasContainerColumns(const wxDataViewItem &WXUNUSED(item)) const
+{
+	return true;
+}

2. A new child of an existing group is never announced to the control. When a duplicate result arrives, CSearchList::AddToList does item->AddChild(toadd); Notify_Search_Update_Sources(item); — which reaches ItemChanged(parent). That refreshes the parent's values but doesn't tell the control the container gained a child. The model handles children correctly already (NotifyFileAdded sends ItemAdded(parent, child)); nothing calls it on this path, because Notify_Search_Add_Result fires only for new unique results.

Two consequences: a variant arriving for an already-expanded group won't appear until something forces a rebuild, and the leaf→container transition (first child of what was a plain row) relies on the port re-querying IsContainer() off an ItemChanged, which isn't guaranteed — wxGTK generally wants the item re-added to become a container.
Fix: send ItemAdded(parent, child) from the duplicate path, either via a NotifyChildAdded on the model or by routing children through Notify_Search_Add_Result.

3. NotifyFileRemoved doesn't apply the filter NotifyFileAdded does. Add is gated on ShouldShow(file); remove calls ItemDeleted unconditionally, so a result that was filtered out and never added gets deleted anyway — a no-op on some ports, an assertion on others.
Fix: gate both identically, or drop the gate on add and let GetChildren() do the filtering it already does.

4. A comment now names members this PR deletes. SearchList.cpp:307-312 justifies notifying the GUI before freeing results by citing SetItemPtrData and m_filteredOut, both gone with the port. The ordering requirement is still real — the control holds the same pointers as wxDataViewItem IDs — so the comment should say that instead.

Built this on Ubuntu 26.04 arm64 (wxGTK 3.2.6) and Windows 11 arm64 from f26334647 and gave both a visual pass. Grouped results have no expander on either platform, so child rows can't be reached at all. macOS is fine — this is the point 2 from my earlier comment, now observed rather than reasoned, and it's more serious than I put it there.

IsContainer() is ToFile(item)->HasChildren(), and a result is handed to the control the moment it arrives — before it has any children, so it registers as a leaf. The child turns up later, in CSearchList::AddToList:

item->AddChild(toadd);
Notify_Search_Update_Sources(item);   // -> ItemChanged(parent)

ItemChanged is a value notification. Leaf→container is a structural change, and the notifier API signals those with ItemAdded/ItemDeleted. macOS survives the omission because its backend is an NSOutlineView (wxDataViewCtrl → wxCocoaDataViewControl ↔ wxCocoaOutlineView) which re-asks isItemExpandable: on every draw, so IsContainer() is consulted continuously and the triangle appears as soon as HasChildren() flips. wxGTK drives a GtkTreeView through its own GtkTreeModel, and MSW uses the generic implementation; both maintain their own node tree and update container-ness only from the structural notifications — which this path never sends.

Confirmed on Linux: toggling the filter checkbox makes expanders appear on the groups that already exist. That routes through EnableFiltering() → NotifyFilterChanged() → Cleared(), which re-queries the model with the children present, so the control does render them as containers once it re-derives the tree — it simply never learns about the transition otherwise. (Switching tabs doesn't do this; each tab is its own CSearchListCtrl and OnSearchPageChanged never touches the model.)

Fix: send ItemAdded(ToItem(parent), ToItem(child)) from the duplicate-result path. CSearchListModel::NotifyFileAdded already handles a child correctly — file->GetParent() is non-null there — it's just never called for one. Keep the ItemChanged(parent) afterwards so the parent's aggregate source counts still refresh.

Reviewed 30b83ac7f. Point 1 is right as committed. Two problems in the other two, same root cause, plus a perf note.

1. Gating ItemDeleted on ShouldShow() can skip a delete for a row that exists — the use-after-free RemoveResults guards against. ShouldShow() reduces to IsFiltered(), which isn't stable for a given file:

if (result && m_filterKnown) {
    result = file->GetDownloadStatus() == CSearchFile::NEW;
}

With "filter known files" on, a result shown while NEW stops passing the moment the user starts downloading it — no Cleared() in between, so the row stays on screen. When the search is later removed, NotifyFileRemoved returns early, no ItemDeleted is sent, and RemoveResults frees the CSearchFile under a row the control still holds by pointer.

2. Notify_Search_Add_Result(child) can add a child under a parent the control was never told about. A parent that fails the filter and has no children yet isn't announced — ShouldShow() is just IsFiltered() at that point. When a filter-passing variant arrives later, ItemAdded(ToItem(parent), ToItem(child)) runs with an unknown parent, which is invalid precisely on the backends this fix is for.

Both are the same mistake: deciding what to notify by re-evaluating a predicate, when the question is what the control was actually told. Those diverge as soon as the predicate depends on mutable state (download status) or on data that arrives later (children).

Fix: track announcement rather than recomputing it — a std::set<const CSearchFile*> in the model, or a flag on CSearchFile. NotifyFileAdded inserts on success, announcing the parent first if it isn't in the set; NotifyFileRemoved sends ItemDeleted if and only if the item is in it; Cleared() empties it.

Both need an active filter, so they're edge cases — but the first is a crash, and "filter known files" plus starting a download is an ordinary sequence.

3. The child path now recomputes the tab label on every duplicate. Notify_Search_Add_Result reaches CSearchDlg::AddResult → UpdateHitCount, which walks the search's entire result list twice (GetItemCount() and GetHiddenItemCount(), with ShouldShow() looping each file's children inside). That already ran per unique result; it now runs per duplicate as well, so a heavily grouped search pays it far more often. It isn't wasted — a new child can change the hidden count — but it's worth coalescing (dirty flag, recompute on idle or a timer) rather than synchronously per result.

Built this on Ubuntu 26.04 arm64 (wxGTK 3.2.9) and worked through the failures with a debug build. Five distinct problems, all reproduced and all fixed in the diff below — the first is a crash, and two of them aren't GTK-specific.

1. Use-after-free on every grouped search (crash). CSearchFile::AddChild() merges a duplicate filename into an existing result and deletes the object it was handed, on two of its four paths. Notify_Search_Add_Result(toadd) afterwards passes that freed pointer onward — CSearchDlg::AddResult() dereferences it to pick the tab, then the model hands it to ItemAdded() as an item ID. Duplicate filenames are the common case in search results, so this faults within seconds of a search on GTK. Guarded by checking whether the child count actually grew.

2. Groups never gain an expander until something forces a rebuild. A result is announced when it arrives, before it has children, so the control records it as a leaf. Nothing afterwards makes wxGTK re-derive container-ness: ItemChanged is a value notification, and deleting and re-adding the row doesn't do it either — I tried both. Only Cleared() works, which is why toggling the filter fixed the display. But a reset can't be interleaved with incremental Item* calls in the same burst without leaving the tree inconsistent, so the model now marks itself dirty on every arrival and OnIdle flushes one rebuild, with selection and expansion captured and restored around it.

3. Dead expanders. IsContainer() asked HasChildren() while GetChildren() yields only children passing the filter, so a group whose variants were all filtered out drew an expander that opened onto nothing. Now both ask the same question.

4. Sort order is never restored (not GTK-specific). CListColumnStore::LoadSettings() returns the orders primary-last — its doc comment says so, and CMuleListCtrl consumed them by calling SetSorting() on each in turn, each pushing to the front. LoadColumnSettings() instead takes m_sort_orders.front() as the primary, which is the least significant entry. With TableOrderingSearch=Y:0:0,R:1:0,N:0:0,u:1:1 saved, sorting by Sources came back as a sort by Type. Fixed by replaying the decoded list through ApplySorting() in order.

5. No sort indicator in the header (not GTK-specific). The columns are appended wxDATAVIEW_COL_RESIZABLE only; wx won't render a sort caret on a column that isn't wxDATAVIEW_COL_SORTABLE. Adding the flag brings the caret back, and the custom click cycle — ascending, descending, alt-sort — still behaves. If it was omitted deliberately to keep wx's native sorting out of the way, that's worth a comment, since it currently reads as an oversight.

diff --git a/src/SearchList.cpp b/src/SearchList.cpp
index 1ed9f9205..d4177bffa 100644
--- a/src/SearchList.cpp
+++ b/src/SearchList.cpp
@@ -816,7 +816,12 @@ bool CSearchList::AddToList(CSearchFile *toadd, bool clientResponse)
 				CFormat("Received duplicate results for '%s' : %s") % item->GetFileName() %
 					item->GetFileHash().Encode());
 			// Add the child, possibly updating the parents filename.
+			const size_t childrenBefore = item->GetChildren().size();
 			item->AddChild(toadd);
+			// AddChild MERGES a duplicate filename into an existing result
+			// and `delete`s the file it was handed -- notifying with `toadd`
+			// after that reads freed memory.
+			const bool survived = item->GetChildren().size() > childrenBefore;
 			// Structural change (leaf-or-nothing -> container, or a new row
 			// under an existing container) needs its own notification --
 			// Search_Update_Sources only signals that the parent's values
@@ -826,7 +831,9 @@ bool CSearchList::AddToList(CSearchFile *toadd, bool clientResponse)
 			// becomes reachable there. Native NSOutlineView survives the
 			// omission by re-querying IsContainer() on every draw, which
 			// masked this on macOS.
-			Notify_Search_Add_Result(toadd);
+			if (survived) {
+				Notify_Search_Add_Result(toadd);
+			}
 			Notify_Search_Update_Sources(item);
 			return true;
 		}
diff --git a/src/SearchListCtrl.cpp b/src/SearchListCtrl.cpp
index f27d017ee..12348d839 100644
--- a/src/SearchListCtrl.cpp
+++ b/src/SearchListCtrl.cpp
@@ -105,44 +105,44 @@ CSearchListCtrl::CSearchListCtrl(
 		wxDATAVIEW_CELL_INERT,
 		500,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	AppendTextColumn(_("Size"),
 		CSearchListModel::COL_SIZE,
 		wxDATAVIEW_CELL_INERT,
 		100,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	AppendTextColumn(_("Sources"),
 		CSearchListModel::COL_SOURCES,
 		wxDATAVIEW_CELL_INERT,
 		50,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	AppendTextColumn(_("Type"),
 		CSearchListModel::COL_TYPE,
 		wxDATAVIEW_CELL_INERT,
 		65,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	// Rating: smiley icon + text label in one cell.
 	AppendIconTextColumn(_("Rating"),
 		CSearchListModel::COL_RATING,
 		wxDATAVIEW_CELL_INERT,
 		120,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	AppendTextColumn(_("FileID"),
 		CSearchListModel::COL_FILEID,
 		wxDATAVIEW_CELL_INERT,
 		280,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	AppendTextColumn(_("Status"),
 		CSearchListModel::COL_STATUS,
 		wxDATAVIEW_CELL_INERT,
 		100,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	// Media tag columns: ed2k/Kad publishers (eMule, eMule AI, aMule) can
 	// advertise per-file media metadata in FT_MEDIA_LENGTH / _BITRATE /
 	// _CODEC. Cells stay empty for non-media results.
@@ -151,19 +151,19 @@ CSearchListCtrl::CSearchListCtrl(
 		wxDATAVIEW_CELL_INERT,
 		80,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	AppendTextColumn(_("Bitrate"),
 		CSearchListModel::COL_BITRATE,
 		wxDATAVIEW_CELL_INERT,
 		80,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	AppendTextColumn(_("Codec"),
 		CSearchListModel::COL_CODEC,
 		wxDATAVIEW_CELL_INERT,
 		80,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 	// Directories is almost always empty (only populated when the result
 	// came from a "view shared files" request, rare in practice), so put
 	// it at the end with the other usually-empty columns.
@@ -173,7 +173,7 @@ CSearchListCtrl::CSearchListCtrl(
 		wxDATAVIEW_CELL_INERT,
 		280,
 		wxALIGN_LEFT,
-		wxDATAVIEW_COL_RESIZABLE);
+		wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE);
 
 	m_columnStore.RegisterColumn(CSearchListModel::COL_NAME, 500, "N");
 	m_columnStore.RegisterColumn(CSearchListModel::COL_SIZE, 100, "Z");
@@ -237,17 +237,22 @@ void CSearchListCtrl::LoadColumnSettings()
 	CListColumnStore::CSortingList decoded;
 	m_columnStore.LoadSettings(m_widthAdapter, "N,Z,u,Y,I,S", decoded);
 
+	// LoadSettings() returns the orders primary-LAST: CMuleListCtrl applied
+	// them by calling SetSorting() on each in turn, and each call pushes to
+	// the front, so the last one processed ends up primary. ApplySorting()
+	// has the same push-to-front semantics, so replaying them in order
+	// reproduces that -- taking front() as the primary instead picks the
+	// least significant entry.
 	m_sort_orders.clear();
 	for (const CListColumnStore::CColPair &pair : decoded) {
-		m_sort_orders.emplace_back(pair.first, pair.second);
+		ApplySorting(pair.first, pair.second);
 	}
 	if (m_sort_orders.empty()) {
-		m_sort_orders.emplace_back(CSearchListModel::COL_NAME, 0);
+		ApplySorting(CSearchListModel::COL_NAME, 0);
 	}
+	return;
+
 
-	const CColPair &primary = m_sort_orders.front();
-	GetColumn(primary.first)->SetSortOrder(!(primary.second & SORT_DES));
-	GetModel()->Resort();
 }
 
 void CSearchListCtrl::SaveColumnSettings()
@@ -626,6 +631,46 @@ void CSearchListCtrl::OnIdle(wxIdleEvent &event)
 {
 	event.Skip();
 
+	// One coalesced rebuild per idle for everything that arrived since the
+	// last one. Cleared() throws away the control's own view state,
+	// so selection and expansion are captured and re-applied around it --
+	// otherwise a result landing mid-search deselects whatever the user had
+	// picked. Items are CSearchFile*, still valid across the rebuild; the ones
+	// that went away are dropped by re-checking membership after it.
+	if (m_model->HasPending()) {
+		wxDataViewItemArray selected;
+		GetSelections(selected);
+		wxDataViewItemArray expanded;
+		{
+			wxDataViewItemArray roots;
+			m_model->GetChildren(wxDataViewItem(), roots);
+			for (size_t i = 0; i < roots.GetCount(); ++i) {
+				if (IsExpanded(roots[i])) {
+					expanded.Add(roots[i]);
+				}
+			}
+		}
+
+		m_model->FlushPending();
+
+		wxDataViewItemArray live;
+		m_model->GetChildren(wxDataViewItem(), live);
+		for (size_t i = 0; i < expanded.GetCount(); ++i) {
+			if (live.Index(expanded[i]) != wxNOT_FOUND) {
+				Expand(expanded[i]);
+			}
+		}
+		wxDataViewItemArray restore;
+		for (size_t i = 0; i < selected.GetCount(); ++i) {
+			if (live.Index(selected[i]) != wxNOT_FOUND) {
+				restore.Add(selected[i]);
+			}
+		}
+		if (!restore.IsEmpty()) {
+			SetSelections(restore);
+		}
+	}
+
 	// No portable wxDataViewCtrl "column resized" event exists to hook
 	// directly (unlike wxListCtrl's EVT_LIST_COL_END_DRAG), so a drag-resize
 	// is detected here by simply comparing against the last-seen widths.
diff --git a/src/SearchListModel.cpp b/src/SearchListModel.cpp
index 615968696..75e796eee 100644
--- a/src/SearchListModel.cpp
+++ b/src/SearchListModel.cpp
@@ -43,42 +43,36 @@ CSearchListModel::CSearchListModel(CSearchListCtrl *owner)
 {
 }
 
-void CSearchListModel::NotifyFileAdded(CSearchFile *file)
+void CSearchListModel::NotifyFileAdded(CSearchFile *)
 {
-	if (!m_owner->ShouldShow(file)) {
-		return;
-	}
-	CSearchFile *parent = file->GetParent();
-	ItemAdded(parent ? ToItem(parent) : wxDataViewItem(), ToItem(file));
+	MarkDirty();
 }
 
-void CSearchListModel::NotifyFileRemoved(CSearchFile *file)
+void CSearchListModel::NotifyFileRemoved(CSearchFile *)
 {
-	// Mirror NotifyFileAdded's gate: a file the control was never told about
-	// (filtered out at add time) must not be deleted from it either -- that
-	// gate is exactly ShouldShow(), the same test GetChildren() itself uses
-	// to decide what's visible (root items via ShouldShow(); children via
-	// PassesFilter(), which ShouldShow() reduces to for a childless file).
-	if (!m_owner->ShouldShow(file)) {
-		return;
-	}
-	CSearchFile *parent = file->GetParent();
-	ItemDeleted(parent ? ToItem(parent) : wxDataViewItem(), ToItem(file));
+	MarkDirty();
 }
 
-void CSearchListModel::NotifyFileUpdated(CSearchFile *file)
+void CSearchListModel::NotifyFileUpdated(CSearchFile *)
 {
-	ItemChanged(ToItem(file));
+	MarkDirty();
 }
 
 void CSearchListModel::NotifyFilterChanged()
 {
-	// The set of visible root items (and which parents count as containers)
-	// may have changed arbitrarily; a full reset is the only thing that's
-	// guaranteed correct here, at the cost of resetting expand state -- the
-	// same cost EnableFiltering()/SetFilter() already paid via
-	// DeleteAllItems()-equivalent behaviour before this port.
+	// User action: reset now rather than waiting for idle.
+	m_pendingReset = false;
+	Cleared();
+}
+
+bool CSearchListModel::FlushPending()
+{
+	if (!m_pendingReset) {
+		return false;
+	}
+	m_pendingReset = false;
 	Cleared();
+	return true;
 }
 
 unsigned int CSearchListModel::GetColumnCount() const
@@ -233,7 +227,17 @@ bool CSearchListModel::IsContainer(const wxDataViewItem &item) const
 	if (!item.IsOk()) {
 		return true; // invisible root
 	}
-	return ToFile(item)->HasChildren();
+	// Must agree with GetChildren(), which only yields children that pass the
+	// filter: answering "has children" here for a group whose variants are all
+	// filtered out draws an expander that opens onto nothing.
+	const CSearchFile *file = ToFile(item);
+	const CSearchResultList &kids = file->GetChildren();
+	for (const CSearchFile *kid : kids) {
+		if (m_owner->PassesFilter(kid)) {
+			return true;
+		}
+	}
+	return false;
 }
 
 bool CSearchListModel::HasContainerColumns(const wxDataViewItem &WXUNUSED(item)) const
diff --git a/src/SearchListModel.h b/src/SearchListModel.h
index 21a0bd8e4..478758b72 100644
--- a/src/SearchListModel.h
+++ b/src/SearchListModel.h
@@ -70,6 +70,14 @@ public:
 	//! tree should be re-evaluated (some rows may appear/disappear).
 	void NotifyFilterChanged();
 
+	//! Results arrive in bursts, and mixing incremental Item*
+	//! notifications with the full Cleared() that a group formation requires
+	//! leaves the control's tree inconsistent. Every arrival now just marks
+	//! the model dirty; the control flushes one reset per idle.
+	void MarkDirty() { m_pendingReset = true; }
+	bool FlushPending();
+	bool HasPending() const { return m_pendingReset; }
+
 	static CSearchFile *ToFile(const wxDataViewItem &item)
 	{
 		return static_cast<CSearchFile *>(item.GetID());
@@ -120,6 +128,7 @@ public:
 
 private:
 	CSearchListCtrl *m_owner;
+	bool m_pendingReset = false;
 };
 
 #endif // SEARCHLISTMODEL_H

Testing. All five reproduced and verified fixed on Linux/GTK against live searches. Windows was built with the first three but not visually checked; macOS never exhibited 1–3, because NSOutlineView re-derives the tree every draw — but 4 and 5 are platform-independent and should reproduce there too.

Two caveats on the patch. The use-after-free guard infers deletion from a child-count delta; cleaner would be for AddChild() to report what it did rather than callers deducing it. And the coalesced rebuild is a design change rather than a fix — it's the shape that worked after several narrower attempts failed, but it's your call whether to take it, throttle it, or find a lighter way to force container re-derivation.

Two of my comments above review the same commit (30b83ac7f) with different prescriptions. The later one supersedes the earlier — implementing both would be wrong.

Withdrawing point 1 of the earlier comment (the ItemDeleted use-after-free). It isn't reachable. CSearchListModel::NotifyFileRemoved has no callers: its only route in was CSearchListCtrl::RemoveResult, whose sole pre-port caller was ShowChildren() — the flat-list expand/collapse emulation this port correctly retires. And CSearchList::RemoveResults doesn't take that path at all, it fires Notify_Search_Removed and closes the tab before freeing anything. The ShouldShow() gate there is latent-wrong, not a crash, and I overstated it.

Concrete follow-up instead: CSearchListCtrl::RemoveResult and CSearchListModel::NotifyFileRemoved are dead code after this port and can be deleted.

Point 2 of that comment (child announced under a parent the control never heard about) was real against 30b83ac7f, but the later patch removes the mechanism rather than repairing it — NotifyFileAdded/Removed/Updated no longer gate or emit Item* at all; they mark the model dirty and one Cleared() per idle re-derives the tree from GetChildren(). So the std::set announcement-tracking suggestion is moot — it solves a problem the later patch deletes.

Still open, and not addressed by that patch: point 3, UpdateHitCount recomputing per duplicate. Notify_Search_Add_Result still fires on the surviving-child path, so a heavily grouped search keeps paying the double list walk per duplicate.

Testing correction. The later comment said Windows was built with the first three fixes but not visually checked. Windows ARM64 has since been rebuilt with all five: points 4 and 5 (sort restore and the header caret) are confirmed fixed there. 1–3 are in that build, but the visual pass concentrated on sorting.

Unrelated to this PR: fast touchpad scrolling bounces the view back toward the top on Windows. It reproduces on the Shared Files list, which this PR doesn't touch — both it and wxDataViewCtrl use wx's generic implementation on MSW, where accumulated wheel rotation overflows a 16-bit field. Pre-existing, and not something to chase here.

Pushed 25d103aae onto this branch with the two follow-ups from my last comment.

Dead code removed. CSearchListCtrl::RemoveResult() and CSearchListModel::NotifyFileRemoved() have no callers after the port: the only route in was ShowChildren(), the flat-list expand/collapse emulation wxDataViewCtrl makes unnecessary. Swept the whole tree including the #ifdef-gated remote-GUI paths — CSearchListRem::RemoveResults() is a different method.

Hit-count recompute coalesced. UpdateHitCount() walks the result list twice, each pass looping every result's children, and it ran once per arriving result — quadratic over a search, and since the notification rework it ran per duplicate as well. AddResult/UpdateResult now mark the tab pending and one recompute per idle flushes it, mirroring the coalescing CSearchListCtrl::OnIdle already does for the tree rebuild. The flush iterates the notebook's live pages and updates those in the pending set, so a tab closed between mark and flush is never matched and its pointer never followed. The other five call sites are user actions (tab change, filter toggle, browse status) and stay immediate.

One trap worth knowing if you touch idle handling here: amuleDlg sets wxIdleEvent::SetMode(wxIDLE_PROCESS_SPECIFIED), so idle events only reach windows carrying wxWS_EX_PROCESS_IDLE. CSearchListCtrl opts in for its own OnIdle; CSearchDlg didn't, so the flush silently never ran — it builds and lints clean either way, and the only symptom is the tab counter freezing mid-search. The commit adds the style.

Verified on macOS and Ubuntu 26.04 arm64 (wxGTK 3.2.9); Windows ARM64 is still building. clang-format and both clang-tidy tiers clean on the diff.

Pulled 25d103aae/db7a34156 and the master merge, rebuilt clean locally (macOS). Agreed on both: RemoveResult()/NotifyFileRemoved() were genuinely dead after the port, and the hit-count coalescing mirrors the tree-rebuild pattern well. Good catch on wxDV_MULTIPLE -- missed that the pre-port style flags carried multi-select implicitly.

Nothing further from me right now; CI looks green apart from mingw-w64 and clang-tidy still running.

Pushed four more commits after testing the port on all three platforms. Three of them are regressions the port introduced by inheriting wxDataViewCtrl's defaults where the old wxListCtrl behaved differently — worth calling out as a class, since they were found one at a time by chance rather than by looking.

db7a34156 — multi-selection. wxDataViewCtrl defaults to single selection; wxListCtrl was multi-select unless given wxLC_SINGLE_SEL, and the pre-port construction site passed wxLC_REPORT | wxNO_BORDER. Without wxDV_MULTIPLE every multi-selection action silently reduced to one item — download, download-into-category, copy eD2k links, related search — and OnRightClick's GetSelectedItemCount() == 1 guard could never be false.

b3866cf75 — type-to-select. CMuleListCtrl::OnChar() gave every list type-ahead: typing jumps the selection to the first row whose name starts with what was typed, resetting after a 1.5 s pause. The backends disagree about what to do instead — GTK pops up its own interactive-search box, macOS and MSW do nothing — so it's reimplemented on CSearchListCtrl and the three ports match again. Matching walks the top-level rows through the list's own CompareFiles(), so the jump follows the displayed order under the current sort; GetItemByRow()/GetRowByItem() would be the direct route but exist only in wx's generic implementation, not on GTK or macOS.

609ede048 — Cmd/Ctrl+A select-all. Only wxGTK implements it for wxDataViewCtrl, so it was gone on macOS and Windows. CMuleListCtrl::OnChar() implemented it explicitly for the same reason.

1f635882a — dead Mark as known file handler. The menu entry went with the port (it had been behind #if 0 for years, with a comment warning it might corrupt known.met), but the handler, its event-table binding and the MP_MARK_AS_KNOWN id survived with nothing able to reach them. Removed, along with the KnownFileList.h include that existed only for it. MP_ASSIGNCAT is anchored at MP_LISTCOL_15 + 1, so dropping an earlier enumerator doesn't shift the category id range.

Page Up/Down is deliberately left alone: it moves the selection on GTK and MSW but scrolls without moving it on macOS, which is the platform convention (Finder, Mail). Shift+PgUp/Dn extends the selection on Linux and Windows. Navigation and other shortcut keys are skipped to the backend so this stays true.

Also merged master in (ea979a44f) — the conflict was catalogs only, resolved by taking master's Weblate round and re-running scripts/update-po.sh against the merged source.

Verified interactively on macOS, Ubuntu 26.04 arm64 (wxGTK 3.2.9) and Windows 11 arm64: multi-select, type-to-select, select-all, sorting and grouping all behave the same on the three ports. clang-format and both clang-tidy tiers clean throughout; amule and amulegui built separately where #ifndef CLIENT_GUI was involved.