diff --git a/Userland/Libraries/LibGUI/Model.cpp b/Userland/Libraries/LibGUI/Model.cpp index 1e37d989bf5..77bd6c14067 100644 --- a/Userland/Libraries/LibGUI/Model.cpp +++ b/Userland/Libraries/LibGUI/Model.cpp @@ -1,5 +1,6 @@ /* * Copyright (c) 2018-2021, Andreas Kling + * Copyright (c) 2021, sin-ack * * SPDX-License-Identifier: BSD-2-Clause */ @@ -32,6 +33,7 @@ void Model::unregister_view(Badge, AbstractView& view) void Model::invalidate() { + m_persistent_handles.clear(); did_update(); } @@ -41,10 +43,17 @@ void Model::for_each_view(Function callback) callback(*view); } -void Model::did_update(unsigned flags) +void Model::for_each_client(Function callback) { for (auto* client : m_clients) - client->model_did_update(flags); + callback(*client); +} + +void Model::did_update(unsigned flags) +{ + for_each_client([flags](ModelClient& client) { + client.model_did_update(flags); + }); } ModelIndex Model::create_index(int row, int column, const void* data) const @@ -127,4 +136,354 @@ RefPtr Model::mime_data(const ModelSelection& selection) const return mime_data; } +void Model::begin_insert_rows(ModelIndex const& parent, int first, int last) +{ + VERIFY(first >= 0); + VERIFY(first <= last); + m_operation_stack.empend(OperationType::Insert, Direction::Row, parent, first, last); +} + +void Model::begin_insert_columns(ModelIndex const& parent, int first, int last) +{ + VERIFY(first >= 0); + VERIFY(first <= last); + m_operation_stack.empend(OperationType::Insert, Direction::Column, parent, first, last); +} + +void Model::begin_move_rows(ModelIndex const& source_parent, int first, int last, ModelIndex const& target_parent, int target_index) +{ + VERIFY(first >= 0); + VERIFY(first <= last); + VERIFY(target_index >= 0); + m_operation_stack.empend(OperationType::Move, Direction::Row, source_parent, first, last, target_parent, target_index); +} + +void Model::begin_move_columns(ModelIndex const& source_parent, int first, int last, ModelIndex const& target_parent, int target_index) +{ + VERIFY(first >= 0); + VERIFY(first <= last); + VERIFY(target_index >= 0); + m_operation_stack.empend(OperationType::Move, Direction::Column, source_parent, first, last, target_parent, target_index); +} + +void Model::begin_delete_rows(ModelIndex const& parent, int first, int last) +{ + VERIFY(first >= 0); + VERIFY(first <= last); + VERIFY(last < row_count(parent)); + + save_deleted_indices(parent, first, last); + m_operation_stack.empend(OperationType::Delete, Direction::Row, parent, first, last); +} + +void Model::begin_delete_columns(ModelIndex const& parent, int first, int last) +{ + VERIFY(first >= 0); + VERIFY(first <= last); + VERIFY(last < column_count(parent)); + + save_deleted_indices(parent, first, last); + m_operation_stack.empend(OperationType::Delete, Direction::Column, parent, first, last); +} + +template +void Model::save_deleted_indices(ModelIndex const& parent, int first, int last) +{ + Vector deleted_indices; + + for (auto& entry : m_persistent_handles) { + auto current_index = entry.key; + + // Walk up the persistent handle's parents to see if it is contained + // within the range that is being deleted. + while (current_index.is_valid()) { + auto current_parent = current_index.parent(); + + if (current_parent == parent) { + if constexpr (IsRow) { + if (current_index.row() >= first && current_index.row() <= last) + deleted_indices.append(current_index); + } else { + if (current_index.column() >= first && current_index.column() <= last) + deleted_indices.append(current_index); + } + } + + current_index = current_parent; + } + } + + m_deleted_indices_stack.append(move(deleted_indices)); +} + +void Model::end_insert_rows() +{ + auto operation = m_operation_stack.take_last(); + VERIFY(operation.type == OperationType::Insert); + VERIFY(operation.direction == Direction::Row); + handle_insert(operation); + + for_each_client([&operation](ModelClient& client) { + client.model_did_insert_rows(operation.source_parent, operation.first, operation.last); + }); +} + +void Model::end_insert_columns() +{ + auto operation = m_operation_stack.take_last(); + VERIFY(operation.type == OperationType::Insert); + VERIFY(operation.direction == Direction::Column); + handle_insert(operation); + + for_each_client([&operation](ModelClient& client) { + client.model_did_insert_columns(operation.source_parent, operation.first, operation.last); + }); +} + +void Model::end_move_rows() +{ + auto operation = m_operation_stack.take_last(); + VERIFY(operation.type == OperationType::Move); + VERIFY(operation.direction == Direction::Row); + handle_move(operation); + + for_each_client([&operation](ModelClient& client) { + client.model_did_move_rows(operation.source_parent, operation.first, operation.last, operation.target_parent, operation.target); + }); +} + +void Model::end_move_columns() +{ + auto operation = m_operation_stack.take_last(); + VERIFY(operation.type == OperationType::Move); + VERIFY(operation.direction == Direction::Column); + handle_move(operation); + + for_each_client([&operation](ModelClient& client) { + client.model_did_move_columns(operation.source_parent, operation.first, operation.last, operation.target_parent, operation.target); + }); +} + +void Model::end_delete_rows() +{ + auto operation = m_operation_stack.take_last(); + VERIFY(operation.type == OperationType::Delete); + VERIFY(operation.direction == Direction::Row); + handle_delete(operation); + + for_each_client([&operation](ModelClient& client) { + client.model_did_delete_rows(operation.source_parent, operation.first, operation.last); + }); +} + +void Model::end_delete_columns() +{ + auto operation = m_operation_stack.take_last(); + VERIFY(operation.type == OperationType::Delete); + VERIFY(operation.direction == Direction::Column); + handle_delete(operation); + + for_each_client([&operation](ModelClient& client) { + client.model_did_delete_columns(operation.source_parent, operation.first, operation.last); + }); +} + +void Model::change_persistent_index_list(Vector const& old_indices, Vector const& new_indices) +{ + VERIFY(old_indices.size() == new_indices.size()); + + for (size_t i = 0; i < old_indices.size(); i++) { + auto it = m_persistent_handles.find(old_indices.at(i)); + if (it == m_persistent_handles.end()) + continue; + + auto handle = move(it->value); + m_persistent_handles.remove(it); + + auto new_index = new_indices.at(i); + if (new_index.is_valid()) { + handle->m_index = new_index; + m_persistent_handles.set(new_index, move(handle)); + } + } +} + +void Model::handle_insert(Operation const& operation) +{ + bool is_row = operation.direction == Direction::Row; + Vector to_shift; + + for (auto& entry : m_persistent_handles) { + if (entry.key.parent() == operation.source_parent) { + if (is_row && entry.key.row() >= operation.first) { + to_shift.append(&entry.key); + } else if (!is_row && entry.key.column() >= operation.first) { + to_shift.append(&entry.key); + } + } + } + + int offset = operation.last - operation.first + 1; + + for (auto current_index : to_shift) { + int new_row = is_row ? current_index->row() + offset : current_index->row(); + int new_column = is_row ? current_index->column() : current_index->column() + offset; + auto new_index = create_index(new_row, new_column, current_index->internal_data()); + + auto it = m_persistent_handles.find(*current_index); + auto handle = move(it->value); + + handle->m_index = new_index; + + m_persistent_handles.remove(it); + m_persistent_handles.set(move(new_index), move(handle)); + } +} + +void Model::handle_delete(Operation const& operation) +{ + bool is_row = operation.direction == Direction::Row; + Vector deleted_indices = m_deleted_indices_stack.take_last(); + Vector to_shift; + + // Get rid of all persistent handles which have been marked for death + for (auto& deleted_index : deleted_indices) { + m_persistent_handles.remove(deleted_index); + } + + for (auto& entry : m_persistent_handles) { + if (entry.key.parent() == operation.source_parent) { + if (is_row) { + if (entry.key.row() > operation.last) { + to_shift.append(&entry.key); + } + } else { + if (entry.key.column() > operation.last) { + to_shift.append(&entry.key); + } + } + } + } + + int offset = operation.last - operation.first + 1; + + for (auto current_index : to_shift) { + int new_row = is_row ? current_index->row() - offset : current_index->row(); + int new_column = is_row ? current_index->column() : current_index->column() - offset; + auto new_index = create_index(new_row, new_column, current_index->internal_data()); + + auto it = m_persistent_handles.find(*current_index); + auto handle = move(it->value); + + handle->m_index = new_index; + + m_persistent_handles.remove(it); + m_persistent_handles.set(move(new_index), move(handle)); + } +} + +void Model::handle_move(Operation const& operation) +{ + bool is_row = operation.direction == Direction::Row; + bool move_within = operation.source_parent == operation.target_parent; + bool moving_down = operation.target > operation.first; + + if (move_within && operation.first == operation.target) + return; + + if (is_row) { + VERIFY(operation.target <= row_count(operation.target_parent)); + VERIFY(operation.last < row_count(operation.source_parent)); + } else { + VERIFY(operation.target <= column_count(operation.target_parent)); + VERIFY(operation.last < column_count(operation.source_parent)); + } + + // NOTE: to_shift_down is used as a generic "to shift" when move_within is true. + Vector to_move; // Items to be moved between the source and target + Vector to_shift_down; // Items to be shifted down after a move-to + Vector to_shift_up; // Items to be shifted up after a move-from + + int count = operation.last - operation.first + 1; + // [start, end) + int work_area_start = min(operation.first, operation.target); + int work_area_end = max(operation.last + 1, operation.target + count); + + for (auto& entry : m_persistent_handles) { + int dimension = is_row ? entry.key.row() : entry.key.column(); + + if (move_within) { + if (entry.key.parent() == operation.source_parent) { + if (dimension >= operation.first && dimension <= operation.last) { + to_move.append(&entry.key); + } else if (moving_down && dimension > operation.last && dimension < work_area_end) { + to_shift_down.append(&entry.key); + } else if (!moving_down && dimension >= work_area_start && dimension < operation.first) { + to_shift_down.append(&entry.key); + } + } + } else { + if (entry.key.parent() == operation.source_parent) { + if (dimension >= operation.first && dimension <= operation.last) { + to_move.append(&entry.key); + } else if (dimension > operation.last) { + to_shift_up.append(&entry.key); + } + } else if (entry.key.parent() == operation.target_parent) { + if (dimension >= operation.target) { + to_shift_down.append(&entry.key); + } + } + } + } + + auto replace_handle = [&](ModelIndex const& current_index, int new_dimension, bool relative) { + int new_row = is_row + ? (relative + ? current_index.row() + new_dimension + : new_dimension) + : current_index.row(); + int new_column = !is_row + ? (relative + ? current_index.column() + new_dimension + : new_dimension) + : current_index.column(); + auto new_index = index(new_row, new_column, operation.target_parent); + + auto it = m_persistent_handles.find(current_index); + auto handle = move(it->value); + + handle->m_index = new_index; + + m_persistent_handles.remove(it); + m_persistent_handles.set(move(new_index), move(handle)); + }; + + for (auto current_index : to_move) { + int dimension = is_row ? current_index->row() : current_index->column(); + int target_offset = dimension - operation.first; + int new_dimension = operation.target + target_offset; + + replace_handle(*current_index, new_dimension, false); + } + + if (move_within) { + for (auto current_index : to_shift_down) { + int dimension = is_row ? current_index->row() : current_index->column(); + int target_offset = moving_down ? dimension - (operation.last + 1) : dimension - work_area_start + count; + int new_dimension = work_area_start + target_offset; + + replace_handle(*current_index, new_dimension, false); + } + } else { + for (auto current_index : to_shift_down) { + replace_handle(*current_index, count, true); + } + + for (auto current_index : to_shift_up) { + replace_handle(*current_index, count, true); + } + } +} + } diff --git a/Userland/Libraries/LibGUI/Model.h b/Userland/Libraries/LibGUI/Model.h index 98b56b0f41b..1f6bc10fa14 100644 --- a/Userland/Libraries/LibGUI/Model.h +++ b/Userland/Libraries/LibGUI/Model.h @@ -1,5 +1,6 @@ /* * Copyright (c) 2018-2020, Andreas Kling + * Copyright (c) 2021, sin-ack * * SPDX-License-Identifier: BSD-2-Clause */ @@ -35,6 +36,13 @@ public: virtual ~ModelClient() { } virtual void model_did_update(unsigned flags) = 0; + + virtual void model_did_insert_rows([[maybe_unused]] ModelIndex const& parent, [[maybe_unused]] int first, [[maybe_unused]] int last) { } + virtual void model_did_insert_columns([[maybe_unused]] ModelIndex const& parent, [[maybe_unused]] int first, [[maybe_unused]] int last) { } + virtual void model_did_move_rows([[maybe_unused]] ModelIndex const& source_parent, [[maybe_unused]] int first, [[maybe_unused]] int last, [[maybe_unused]] ModelIndex const& target_parent, [[maybe_unused]] int target_index) { } + virtual void model_did_move_columns([[maybe_unused]] ModelIndex const& source_parent, [[maybe_unused]] int first, [[maybe_unused]] int last, [[maybe_unused]] ModelIndex const& target_parent, [[maybe_unused]] int target_index) { } + virtual void model_did_delete_rows([[maybe_unused]] ModelIndex const& parent, [[maybe_unused]] int first, [[maybe_unused]] int last) { } + virtual void model_did_delete_columns([[maybe_unused]] ModelIndex const& parent, [[maybe_unused]] int first, [[maybe_unused]] int last) { } }; class Model : public RefCounted { @@ -93,6 +101,7 @@ protected: Model(); void for_each_view(Function); + void for_each_client(Function); void did_update(unsigned flags = UpdateFlag::InvalidateAllIndices); static bool string_matches(const StringView& str, const StringView& needle, unsigned flags) @@ -107,7 +116,85 @@ protected: ModelIndex create_index(int row, int column, const void* data = nullptr) const; + void begin_insert_rows(ModelIndex const& parent, int first, int last); + void begin_insert_columns(ModelIndex const& parent, int first, int last); + void begin_move_rows(ModelIndex const& source_parent, int first, int last, ModelIndex const& target_parent, int target_index); + void begin_move_columns(ModelIndex const& source_parent, int first, int last, ModelIndex const& target_parent, int target_index); + void begin_delete_rows(ModelIndex const& parent, int first, int last); + void begin_delete_columns(ModelIndex const& parent, int first, int last); + + void end_insert_rows(); + void end_insert_columns(); + void end_move_rows(); + void end_move_columns(); + void end_delete_rows(); + void end_delete_columns(); + + void change_persistent_index_list(Vector const& old_indices, Vector const& new_indices); + private: + enum class OperationType { + Invalid = 0, + Insert, + Move, + Delete, + Reset + }; + enum class Direction { + Row, + Column + }; + + struct Operation { + OperationType type { OperationType::Invalid }; + Direction direction { Direction::Row }; + ModelIndex source_parent; + int first { 0 }; + int last { 0 }; + ModelIndex target_parent; + int target { 0 }; + + Operation(OperationType type) + : type(type) + { + } + + Operation(OperationType type, Direction direction, ModelIndex const& parent, int first, int last) + : type(type) + , direction(direction) + , source_parent(parent) + , first(first) + , last(last) + { + } + + Operation(OperationType type, Direction direction, ModelIndex const& source_parent, int first, int last, ModelIndex const& target_parent, int target) + : type(type) + , direction(direction) + , source_parent(source_parent) + , first(first) + , last(last) + , target_parent(target_parent) + , target(target) + { + } + }; + + void handle_insert(Operation const&); + void handle_move(Operation const&); + void handle_delete(Operation const&); + + template + void save_deleted_indices(ModelIndex const& parent, int first, int last); + + HashMap> m_persistent_handles; + Vector m_operation_stack; + // NOTE: We need to save which indices have been deleted before the delete + // actually happens, because we can't figure out which persistent handles + // belong to us in end_delete_rows/columns (because accessing the parents of + // the indices might be impossible). + Vector> m_deleted_indices_stack; + HashTable m_views; HashTable m_clients; };