ladybird/Userland/Libraries/LibGUI/AbstractTableView.cpp

/*
 * 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::Left)
        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);
        break;
    case SelectionBehavior::SelectRows:
        rect = row_rect(index.row());
        break;
    }
    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);
}

}