RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 04:07:44 +00:00
Code Issues Activity Actions

LibGUI: Improve IconView performance with large selections

Browse source 
This implements the following optimizations:

* Rather than clearing a HashTable of selected items and re-populating
  it every time the selection rectangle changes, determine the delta
  by only examining the items that might be in the area where the
  selection may have changed compared to the previous area. Then
  only add/remove selection items as needed.

* When painting, only query and paint the items actually visible.
  Also, keep a local cache of item information such as calculated
  rectangles and selection state, so it doesn't have to be calculated
  over and over again.
This commit is contained in:
Tom 2020-07-11 07:02:03 -06:00 • committed by Andreas Kling
parent b778804d20
commit f266f0e880
4 changed files with 449 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

111
Libraries/LibGUI/IconView.h
View file

@ -26,8 +26,10 @@
#pragma once
#include <AK/IterationDecision.h>
#include <LibGUI/AbstractView.h>
#include <LibGUI/Forward.h>
#include <LibGUI/Variant.h>
namespace GUI {
@ -48,6 +50,7 @@ public:
virtual ModelIndex index_at_event_position(const Gfx::IntPoint&) const override;
virtual void select_all() override;
private:
IconView();
@ -61,14 +64,110 @@ private:
virtual void keydown_event(KeyEvent&) override;
virtual void drag_move_event(DragEvent&) override;
struct ItemData {
Gfx::IntRect text_rect;
Gfx::IntRect icon_rect;
int icon_offset_y;
int text_offset_y;
Variant data;
ModelIndex index;
bool valid { false };
bool selected { false }; // always valid
bool selection_toggled; // only used as a temporary marker
bool is_valid() const { return valid; }
void invalidate()
{
valid = false;
data.clear();
}
bool is_intersecting(const Gfx::IntRect& rect) const
{
ASSERT(valid);
return icon_rect.intersects(rect) || text_rect.intersects(rect);
}
bool is_containing(const Gfx::IntPoint& point) const
{
ASSERT(valid);
return icon_rect.contains(point) || text_rect.contains(point);
}
};
template<typename Function>
IterationDecision for_each_item_intersecting_rect(const Gfx::IntRect& rect, Function f) const
{
ASSERT(model());
if (rect.is_empty())
return IterationDecision::Continue;
int begin_row, begin_column;
column_row_from_content_position(rect.top_left(), begin_row, begin_column);
int end_row, end_column;
column_row_from_content_position(rect.bottom_right(), end_row, end_column);
int items_per_column = end_column - begin_column + 1;
int item_index = max(0, begin_row * m_visual_column_count + begin_column);
int last_index = min(item_count(), end_row * m_visual_column_count + end_column + 1);
while (item_index < last_index) {
for (int i = item_index; i < min(item_index + items_per_column, last_index); i++) {
auto& item_data = get_item_data(i);
if (item_data.is_intersecting(rect)) {
auto decision = f(item_data);
if (decision != IterationDecision::Continue)
return decision;
}
}
item_index += m_visual_column_count;
};
return IterationDecision::Continue;
}
template<typename Function>
IterationDecision for_each_item_intersecting_rects(const Vector<Gfx::IntRect>& rects, Function f) const
{
for (auto& rect : rects) {
auto decision = for_each_item_intersecting_rect(rect, f);
if (decision != IterationDecision::Continue)
return decision;
}
return IterationDecision::Continue;
}
void column_row_from_content_position(const Gfx::IntPoint& content_position, int& row, int& column) const
{
row = max(0, min(m_visual_row_count - 1, content_position.y() / effective_item_size().height()));
column = max(0, min(m_visual_column_count - 1, content_position.x() / effective_item_size().width()));
}
int item_count() const;
Gfx::IntRect item_rect(int item_index) const;
Vector<int> items_intersecting_rect(const Gfx::IntRect&) const;
void update_content_size();
void get_item_rects(int item_index, const Gfx::Font&, const Variant& item_text, Gfx::IntRect& item_rect, Gfx::IntRect& icon_rect, Gfx::IntRect& text_rect) const;
void update_item_rects(int item_index, ItemData& item_data) const;
void get_item_rects(int item_index, ItemData& item_data, const Gfx::Font&) const;
bool update_rubber_banding(const Gfx::IntPoint&);
void scroll_out_of_view_timer_fired();
void reinit_item_cache() const;
int model_index_to_item_index(const ModelIndex& model_index) const
{
ASSERT(model_index.row() < item_count());
return model_index.row();
}
virtual void did_update_selection() override;
virtual void clear_selection() override;
virtual void add_selection(const ModelIndex& new_index) override;
virtual void set_selection(const ModelIndex& new_index) override;
virtual void toggle_selection(const ModelIndex& new_index) override;
ItemData& get_item_data(int) const;
ItemData* item_data_from_content_position(const Gfx::IntPoint&) const;
void do_clear_selection();
bool do_add_selection(ItemData&);
void add_selection(ItemData&);
void remove_selection(ItemData&);
void toggle_selection(ItemData&);
int m_horizontal_padding { 5 };
int m_model_column { 0 };
int m_visual_column_count { 0 };
@ -82,9 +181,15 @@ private:
Gfx::IntPoint m_out_of_view_position;
Gfx::IntPoint m_rubber_band_origin;
Gfx::IntPoint m_rubber_band_current;
Vector<ModelIndex> m_rubber_band_remembered_selection;
ModelIndex m_drop_candidate_index;
mutable Vector<ItemData> m_item_data_cache;
mutable int m_selected_count_cache { 0 };
mutable int m_first_selected_hint { 0 };
mutable bool m_item_data_cache_valid { false };
bool m_changing_selection { false };
};
}