From 4ca65894c842a042b0d21a5449355be475f6fe7c Mon Sep 17 00:00:00 2001 From: Berthold Stoeger Date: Tue, 19 Nov 2019 21:40:03 +0100 Subject: Dive trip model: send changed signals if visibility changed in trips To avoid having to do full filter reloads, send dive-changed signals for dives in trips when the shown-status changed. But only for trips where not all dives are hidden. Because for those, the plan is to hide the trip as a whole. Implement the signal sending in its own function so that it can be reused for top-level items and the list-view. Signed-off-by: Berthold Stoeger --- qt-models/divetripmodel.cpp | 38 ++++++++++++++++++++++++++++++++++---- qt-models/divetripmodel.h | 4 ++++ 2 files changed, 38 insertions(+), 4 deletions(-) (limited to 'qt-models') diff --git a/qt-models/divetripmodel.cpp b/qt-models/divetripmodel.cpp index 1d4a9a2a0..55ba37a5c 100644 --- a/qt-models/divetripmodel.cpp +++ b/qt-models/divetripmodel.cpp @@ -691,14 +691,43 @@ dive *DiveTripModelTree::diveOrNull(const QModelIndex &index) const return tripOrDive(index).dive; } -static bool calculateFilterForTrip(const std::vector &dives, const DiveFilter *filter) +// Send data changed signals blockwise. Which entries are changed is collected +// in the first parameter "changed". +void DiveTripModelBase::sendShownChangedSignals(const std::vector &changed, quintptr parentIndex) +{ + static const QVector roles { SHOWN_ROLE }; + for (size_t i = 0; i < changed.size(); ++i) { + // Find first and last block of changed items + if (!changed[i]) + continue; + size_t j; + for (j = i + 1; j < changed.size() && changed[j]; ++j) + ; // Pass + dataChanged(createIndex(i, 0, parentIndex), createIndex(j - 1, 0, parentIndex), roles); + i = j - 1; + } +} + +// Applying the filter to trip-items is a bit tricky: +// We only want to send changed-signals if one of the dives remains visible. +// Because if no dive remains visible, we'll simply send a signal on the parent trip, +// which will then be hidden and all the dives will be hidden implicitly as well. +// Thus, do this in two passes: collect changed dives and only if any dive is visible, +// send the signals. +bool DiveTripModelTree::calculateFilterForTrip(const std::vector &dives, const DiveFilter *filter, int parentIndex) { bool showTrip = false; + std::vector changed; + changed.reserve(dives.size()); for (dive *d: dives) { bool shown = filter->showDive(d); - filter_dive(d, shown); + changed.push_back(filter_dive(d, shown)); showTrip |= shown; } + + // If any dive is shown, send changed-signals + if (showTrip) + sendShownChangedSignals(changed, parentIndex); return showTrip; } @@ -714,14 +743,15 @@ void DiveTripModelTree::recalculateFilter() // as a consequence of the filterReset signal right after the local scope. auto marker = diveListNotifier.enterCommand(); DiveFilter *filter = DiveFilter::instance(); - for (Item &item: items) { + for (size_t i = 0; i < items.size(); ++i) { + Item &item = items[i]; if (item.d_or_t.dive) { dive *d = item.d_or_t.dive; item.shown = filter->showDive(item.d_or_t.dive); filter_dive(d, item.shown); } else { // Trips are shown if any of the dives is shown - item.shown = calculateFilterForTrip(item.dives, filter); + item.shown = calculateFilterForTrip(item.dives, filter, i); } } } diff --git a/qt-models/divetripmodel.h b/qt-models/divetripmodel.h index c7e488030..5952fa558 100644 --- a/qt-models/divetripmodel.h +++ b/qt-models/divetripmodel.h @@ -6,6 +6,8 @@ #include "core/subsurface-qt/DiveListNotifier.h" #include +struct DiveFilter; + // There are two different representations of the dive list: // 1) Tree view: two-level model where dives are grouped by trips // 2) List view: one-level model where dives are sorted by one out @@ -98,6 +100,7 @@ protected: // Access trip and dive data static QVariant diveData(const struct dive *d, int column, int role); static QVariant tripData(const dive_trip *trip, int column, int role); + void sendShownChangedSignals(const std::vector &changed, quintptr parentIndex); virtual dive *diveOrNull(const QModelIndex &index) const = 0; // Returns a dive if this index represents a dive, null otherwise virtual void clearData() = 0; @@ -130,6 +133,7 @@ private: void recalculateFilter(); void divesChangedTrip(dive_trip *trip, const QVector &dives); void divesTimeChangedTrip(dive_trip *trip, timestamp_t delta, const QVector &dives); + bool calculateFilterForTrip(const std::vector &dives, const DiveFilter *filter, int parentIndex); // The tree model has two levels. At the top level, we have either trips or dives // that do not belong to trips. Such a top-level item is represented by the "Item" -- cgit v1.2.3-70-g09d2