8eb8949d9c
When a user is navigating a table view with arrow keys and a row is outside of the current view, then scroll_into_view is called, and the position of the rectangle passed to this should take into account the column headers. This can be seen making more pleasant the navigation in the System Monitor in the Processes view, for example.
477 lines
15 KiB
C++
477 lines
15 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/Vector.h>
|
|
#include <LibGUI/AbstractTableView.h>
|
|
#include <LibGUI/Action.h>
|
|
#include <LibGUI/Button.h>
|
|
#include <LibGUI/HeaderView.h>
|
|
#include <LibGUI/Menu.h>
|
|
#include <LibGUI/Model.h>
|
|
#include <LibGUI/Painter.h>
|
|
#include <LibGUI/Window.h>
|
|
#include <LibGfx/Palette.h>
|
|
|
|
namespace GUI {
|
|
|
|
AbstractTableView::AbstractTableView()
|
|
{
|
|
set_selection_behavior(SelectionBehavior::SelectRows);
|
|
m_corner_button = add<Button>();
|
|
m_corner_button->move_to_back();
|
|
m_corner_button->set_background_role(Gfx::ColorRole::ThreedShadow1);
|
|
m_corner_button->set_fill_with_background_color(true);
|
|
m_column_header = add<HeaderView>(*this, Gfx::Orientation::Horizontal);
|
|
m_column_header->move_to_back();
|
|
m_column_header->on_resize_doubleclick = [this](auto column) {
|
|
auto_resize_column(column);
|
|
};
|
|
m_row_header = add<HeaderView>(*this, Gfx::Orientation::Vertical);
|
|
m_row_header->move_to_back();
|
|
m_row_header->set_visible(false);
|
|
set_should_hide_unnecessary_scrollbars(true);
|
|
}
|
|
|
|
AbstractTableView::~AbstractTableView()
|
|
{
|
|
}
|
|
|
|
void AbstractTableView::select_all()
|
|
{
|
|
selection().clear();
|
|
for (int item_index = 0; item_index < item_count(); ++item_index) {
|
|
auto index = model()->index(item_index);
|
|
selection().add(index);
|
|
}
|
|
}
|
|
|
|
void AbstractTableView::auto_resize_column(int column)
|
|
{
|
|
if (!model())
|
|
return;
|
|
|
|
if (!column_header().is_section_visible(column))
|
|
return;
|
|
|
|
auto& model = *this->model();
|
|
int row_count = model.row_count();
|
|
|
|
int header_width = m_column_header->font().width(model.column_name(column));
|
|
if (column == m_key_column && model.is_column_sortable(column))
|
|
header_width += font().width(" \xE2\xAC\x86");
|
|
|
|
int column_width = header_width;
|
|
bool is_empty = true;
|
|
for (int row = 0; row < row_count; ++row) {
|
|
auto cell_data = model.index(row, column).data();
|
|
int cell_width = 0;
|
|
if (cell_data.is_icon()) {
|
|
cell_width = cell_data.as_icon().bitmap_for_size(16)->width();
|
|
} else if (cell_data.is_bitmap()) {
|
|
cell_width = cell_data.as_bitmap().width();
|
|
} else if (cell_data.is_valid()) {
|
|
cell_width = font().width(cell_data.to_string());
|
|
}
|
|
if (is_empty && cell_width > 0)
|
|
is_empty = false;
|
|
column_width = max(column_width, cell_width);
|
|
}
|
|
|
|
auto default_column_size = column_header().default_section_size(column);
|
|
if (is_empty && column_header().is_default_section_size_initialized(column))
|
|
column_header().set_section_size(column, default_column_size);
|
|
else
|
|
column_header().set_section_size(column, column_width);
|
|
}
|
|
void AbstractTableView::update_column_sizes()
|
|
{
|
|
if (!model())
|
|
return;
|
|
|
|
auto& model = *this->model();
|
|
int column_count = model.column_count();
|
|
int row_count = model.row_count();
|
|
|
|
for (int column = 0; column < column_count; ++column) {
|
|
if (!column_header().is_section_visible(column))
|
|
continue;
|
|
int header_width = m_column_header->font().width(model.column_name(column));
|
|
if (column == m_key_column && model.is_column_sortable(column))
|
|
header_width += font().width(" \xE2\xAC\x86"); // UPWARDS BLACK ARROW
|
|
int column_width = header_width;
|
|
for (int row = 0; row < row_count; ++row) {
|
|
auto cell_data = model.index(row, column).data();
|
|
int cell_width = 0;
|
|
if (cell_data.is_icon()) {
|
|
if (auto bitmap = cell_data.as_icon().bitmap_for_size(16))
|
|
cell_width = bitmap->width();
|
|
} else if (cell_data.is_bitmap()) {
|
|
cell_width = cell_data.as_bitmap().width();
|
|
} else if (cell_data.is_valid()) {
|
|
cell_width = font().width(cell_data.to_string());
|
|
}
|
|
column_width = max(column_width, cell_width);
|
|
}
|
|
column_header().set_section_size(column, max(m_column_header->section_size(column), column_width));
|
|
}
|
|
}
|
|
|
|
void AbstractTableView::update_row_sizes()
|
|
{
|
|
if (!model())
|
|
return;
|
|
|
|
auto& model = *this->model();
|
|
int row_count = model.row_count();
|
|
|
|
for (int row = 0; row < row_count; ++row) {
|
|
if (!row_header().is_section_visible(row))
|
|
continue;
|
|
row_header().set_section_size(row, row_height());
|
|
}
|
|
}
|
|
|
|
void AbstractTableView::update_content_size()
|
|
{
|
|
if (!model())
|
|
return set_content_size({});
|
|
|
|
int content_width = 0;
|
|
int column_count = model()->column_count();
|
|
|
|
for (int i = 0; i < column_count; ++i) {
|
|
if (column_header().is_section_visible(i))
|
|
content_width += column_width(i) + horizontal_padding() * 2;
|
|
}
|
|
int content_height = item_count() * row_height();
|
|
|
|
set_content_size({ content_width, content_height });
|
|
set_size_occupied_by_fixed_elements({ row_header().width(), column_header().height() });
|
|
layout_headers();
|
|
}
|
|
|
|
TableCellPaintingDelegate* AbstractTableView::column_painting_delegate(int column) const
|
|
{
|
|
// FIXME: This should return a const pointer I think..
|
|
return const_cast<TableCellPaintingDelegate*>(m_column_painting_delegate.get(column).value_or(nullptr));
|
|
}
|
|
|
|
void AbstractTableView::set_column_painting_delegate(int column, OwnPtr<TableCellPaintingDelegate> delegate)
|
|
{
|
|
if (!delegate)
|
|
m_column_painting_delegate.remove(column);
|
|
else
|
|
m_column_painting_delegate.set(column, move(delegate));
|
|
}
|
|
|
|
int AbstractTableView::column_width(int column_index) const
|
|
{
|
|
if (!model())
|
|
return 0;
|
|
return m_column_header->section_size(column_index);
|
|
}
|
|
|
|
void AbstractTableView::set_column_width(int column, int width)
|
|
{
|
|
column_header().set_section_size(column, width);
|
|
}
|
|
|
|
int AbstractTableView::minimum_column_width(int)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
int AbstractTableView::minimum_row_height(int)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
Gfx::TextAlignment AbstractTableView::column_header_alignment(int column_index) const
|
|
{
|
|
if (!model())
|
|
return Gfx::TextAlignment::CenterLeft;
|
|
return m_column_header->section_alignment(column_index);
|
|
}
|
|
|
|
void AbstractTableView::set_column_header_alignment(int column, Gfx::TextAlignment alignment)
|
|
{
|
|
column_header().set_section_alignment(column, alignment);
|
|
}
|
|
|
|
void AbstractTableView::mousedown_event(MouseEvent& event)
|
|
{
|
|
m_tab_moves = 0;
|
|
if (!model())
|
|
return AbstractView::mousedown_event(event);
|
|
|
|
if (event.button() != MouseButton::Primary)
|
|
return AbstractView::mousedown_event(event);
|
|
|
|
bool is_toggle;
|
|
auto index = index_at_event_position(event.position(), is_toggle);
|
|
|
|
if (index.is_valid() && is_toggle && model()->row_count(index)) {
|
|
toggle_index(index);
|
|
return;
|
|
}
|
|
|
|
AbstractView::mousedown_event(event);
|
|
}
|
|
|
|
ModelIndex AbstractTableView::index_at_event_position(const Gfx::IntPoint& position, bool& is_toggle) const
|
|
{
|
|
is_toggle = false;
|
|
if (!model())
|
|
return {};
|
|
|
|
auto adjusted_position = this->adjusted_position(position);
|
|
for (int row = 0, row_count = model()->row_count(); row < row_count; ++row) {
|
|
if (!row_rect(row).contains(adjusted_position))
|
|
continue;
|
|
for (int column = 0, column_count = model()->column_count(); column < column_count; ++column) {
|
|
if (!content_rect(row, column).contains(adjusted_position))
|
|
continue;
|
|
return model()->index(row, column);
|
|
}
|
|
return model()->index(row, 0);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
ModelIndex AbstractTableView::index_at_event_position(const Gfx::IntPoint& position) const
|
|
{
|
|
bool is_toggle;
|
|
auto index = index_at_event_position(position, is_toggle);
|
|
return is_toggle ? ModelIndex() : index;
|
|
}
|
|
|
|
int AbstractTableView::item_count() const
|
|
{
|
|
if (!model())
|
|
return 0;
|
|
return model()->row_count();
|
|
}
|
|
|
|
void AbstractTableView::move_cursor_relative(int vertical_steps, int horizontal_steps, SelectionUpdate selection_update)
|
|
{
|
|
if (!model())
|
|
return;
|
|
auto& model = *this->model();
|
|
ModelIndex new_index;
|
|
if (cursor_index().is_valid()) {
|
|
new_index = model.index(cursor_index().row() + vertical_steps, cursor_index().column() + horizontal_steps);
|
|
} else {
|
|
new_index = model.index(0, 0);
|
|
}
|
|
if (new_index.is_valid()) {
|
|
set_cursor(new_index, selection_update);
|
|
}
|
|
}
|
|
|
|
void AbstractTableView::scroll_into_view(const ModelIndex& index, bool scroll_horizontally, bool scroll_vertically)
|
|
{
|
|
Gfx::IntRect rect;
|
|
switch (selection_behavior()) {
|
|
case SelectionBehavior::SelectItems:
|
|
rect = content_rect(index);
|
|
if (row_header().is_visible())
|
|
rect.set_left(rect.left() - row_header().width());
|
|
break;
|
|
case SelectionBehavior::SelectRows:
|
|
rect = row_rect(index.row());
|
|
break;
|
|
}
|
|
if (column_header().is_visible())
|
|
rect.set_top(rect.top() - column_header().height());
|
|
AbstractScrollableWidget::scroll_into_view(rect, scroll_horizontally, scroll_vertically);
|
|
}
|
|
|
|
void AbstractTableView::context_menu_event(ContextMenuEvent& event)
|
|
{
|
|
if (!model())
|
|
return;
|
|
|
|
bool is_toggle;
|
|
auto index = index_at_event_position(event.position(), is_toggle);
|
|
if (index.is_valid()) {
|
|
if (!selection().contains(index))
|
|
selection().set(index);
|
|
} else {
|
|
selection().clear();
|
|
}
|
|
if (on_context_menu_request)
|
|
on_context_menu_request(index, event);
|
|
}
|
|
|
|
Gfx::IntRect AbstractTableView::paint_invalidation_rect(ModelIndex const& index) const
|
|
{
|
|
if (!index.is_valid())
|
|
return {};
|
|
return row_rect(index.row());
|
|
}
|
|
|
|
Gfx::IntRect AbstractTableView::content_rect(int row, int column) const
|
|
{
|
|
auto row_rect = this->row_rect(row);
|
|
int x = 0;
|
|
for (int i = 0; i < column; ++i)
|
|
x += column_width(i) + horizontal_padding() * 2;
|
|
|
|
return { row_rect.x() + x, row_rect.y(), column_width(column) + horizontal_padding() * 2, row_height() };
|
|
}
|
|
|
|
Gfx::IntRect AbstractTableView::content_rect(const ModelIndex& index) const
|
|
{
|
|
return content_rect(index.row(), index.column());
|
|
}
|
|
|
|
Gfx::IntRect AbstractTableView::row_rect(int item_index) const
|
|
{
|
|
return { row_header().is_visible() ? row_header().width() : 0,
|
|
(column_header().is_visible() ? column_header().height() : 0) + (item_index * row_height()),
|
|
max(content_size().width(), width()),
|
|
row_height() };
|
|
}
|
|
|
|
Gfx::IntPoint AbstractTableView::adjusted_position(const Gfx::IntPoint& position) const
|
|
{
|
|
return position.translated(horizontal_scrollbar().value() - frame_thickness(), vertical_scrollbar().value() - frame_thickness());
|
|
}
|
|
|
|
void AbstractTableView::model_did_update(unsigned flags)
|
|
{
|
|
AbstractView::model_did_update(flags);
|
|
update_row_sizes();
|
|
update_column_sizes();
|
|
update_content_size();
|
|
update();
|
|
}
|
|
|
|
void AbstractTableView::resize_event(ResizeEvent& event)
|
|
{
|
|
AbstractView::resize_event(event);
|
|
layout_headers();
|
|
}
|
|
|
|
void AbstractTableView::header_did_change_section_size(Badge<HeaderView>, Gfx::Orientation, int, int)
|
|
{
|
|
update_content_size();
|
|
update();
|
|
}
|
|
|
|
void AbstractTableView::header_did_change_section_visibility(Badge<HeaderView>, Gfx::Orientation, int, bool)
|
|
{
|
|
update_content_size();
|
|
update();
|
|
}
|
|
|
|
void AbstractTableView::set_default_column_width(int column, int width)
|
|
{
|
|
column_header().set_default_section_size(column, width);
|
|
}
|
|
|
|
void AbstractTableView::set_column_visible(int column, bool visible)
|
|
{
|
|
column_header().set_section_visible(column, visible);
|
|
}
|
|
|
|
void AbstractTableView::set_column_headers_visible(bool visible)
|
|
{
|
|
column_header().set_visible(visible);
|
|
}
|
|
|
|
void AbstractTableView::did_scroll()
|
|
{
|
|
AbstractView::did_scroll();
|
|
layout_headers();
|
|
}
|
|
|
|
void AbstractTableView::layout_headers()
|
|
{
|
|
if (column_header().is_visible()) {
|
|
int row_header_width = row_header().is_visible() ? row_header().width() : 0;
|
|
int vertical_scrollbar_width = vertical_scrollbar().is_visible() ? vertical_scrollbar().width() : 0;
|
|
|
|
int x = frame_thickness() + row_header_width - horizontal_scrollbar().value();
|
|
int y = frame_thickness();
|
|
int width = max(content_width(), rect().width() - frame_thickness() * 2 - row_header_width - vertical_scrollbar_width);
|
|
|
|
column_header().set_relative_rect(x, y, width, column_header().min_size().height());
|
|
}
|
|
|
|
if (row_header().is_visible()) {
|
|
int column_header_height = column_header().is_visible() ? column_header().height() : 0;
|
|
int horizontal_scrollbar_height = horizontal_scrollbar().is_visible() ? horizontal_scrollbar().height() : 0;
|
|
|
|
int x = frame_thickness();
|
|
int y = frame_thickness() + column_header_height - vertical_scrollbar().value();
|
|
int height = max(content_height(), rect().height() - frame_thickness() * 2 - column_header_height - horizontal_scrollbar_height);
|
|
|
|
row_header().set_relative_rect(x, y, row_header().min_size().width(), height);
|
|
}
|
|
|
|
if (row_header().is_visible() && column_header().is_visible()) {
|
|
m_corner_button->set_relative_rect(frame_thickness(), frame_thickness(), row_header().width(), column_header().height());
|
|
m_corner_button->set_visible(true);
|
|
} else {
|
|
m_corner_button->set_visible(false);
|
|
}
|
|
}
|
|
|
|
void AbstractTableView::keydown_event(KeyEvent& event)
|
|
{
|
|
if (is_tab_key_navigation_enabled()) {
|
|
if (!event.modifiers() && event.key() == KeyCode::Key_Tab) {
|
|
move_cursor(CursorMovement::Right, SelectionUpdate::Set);
|
|
event.accept();
|
|
++m_tab_moves;
|
|
return;
|
|
} else if (is_navigation(event)) {
|
|
if (event.key() == KeyCode::Key_Return) {
|
|
move_cursor_relative(0, -m_tab_moves, SelectionUpdate::Set);
|
|
}
|
|
m_tab_moves = 0;
|
|
}
|
|
|
|
if (event.modifiers() == KeyModifier::Mod_Shift && event.key() == KeyCode::Key_Tab) {
|
|
move_cursor(CursorMovement::Left, SelectionUpdate::Set);
|
|
event.accept();
|
|
return;
|
|
}
|
|
}
|
|
|
|
AbstractView::keydown_event(event);
|
|
}
|
|
|
|
bool AbstractTableView::is_navigation(GUI::KeyEvent& event)
|
|
{
|
|
switch (event.key()) {
|
|
case KeyCode::Key_Tab:
|
|
case KeyCode::Key_Left:
|
|
case KeyCode::Key_Right:
|
|
case KeyCode::Key_Up:
|
|
case KeyCode::Key_Down:
|
|
case KeyCode::Key_Return:
|
|
case KeyCode::Key_Home:
|
|
case KeyCode::Key_End:
|
|
case KeyCode::Key_PageUp:
|
|
case KeyCode::Key_PageDown:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Gfx::IntPoint AbstractTableView::automatic_scroll_delta_from_position(const Gfx::IntPoint& pos) const
|
|
{
|
|
if (pos.y() > column_header().height() + autoscroll_threshold())
|
|
return AbstractScrollableWidget::automatic_scroll_delta_from_position(pos);
|
|
|
|
Gfx::IntPoint position_excluding_header = { pos.x(), pos.y() - column_header().height() };
|
|
return AbstractScrollableWidget::automatic_scroll_delta_from_position(position_excluding_header);
|
|
}
|
|
|
|
}
|