diff options
Diffstat (limited to 'Libraries/LibGUI/HeaderView.cpp')
| -rw-r--r-- | Libraries/LibGUI/HeaderView.cpp | 342 |
1 files changed, 342 insertions, 0 deletions
diff --git a/Libraries/LibGUI/HeaderView.cpp b/Libraries/LibGUI/HeaderView.cpp new file mode 100644 index 0000000000..31caa71b5b --- /dev/null +++ b/Libraries/LibGUI/HeaderView.cpp @@ -0,0 +1,342 @@ +/* + * Copyright (c) 2020, Andreas Kling <kling@serenityos.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <LibGUI/AbstractTableView.h> +#include <LibGUI/Action.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> +#include <LibGfx/StylePainter.h> + +namespace GUI { + +static constexpr int minimum_column_size = 2; + +HeaderView::HeaderView(AbstractTableView& table_view, Gfx::Orientation orientation) + : m_table_view(table_view) + , m_orientation(orientation) +{ + set_font(Gfx::Font::default_bold_font()); + + if (m_orientation == Gfx::Orientation::Horizontal) { + set_size_policy(SizePolicy::Fill, SizePolicy::Fixed); + set_preferred_size(0, 16); + } else { + set_size_policy(SizePolicy::Fixed, SizePolicy::Fill); + set_preferred_size(40, 0); + } +} + +HeaderView::~HeaderView() +{ +} + +void HeaderView::set_section_size(int section, int size) +{ + auto& data = section_data(section); + data.size = size; + data.has_initialized_size = true; +} + +int HeaderView::section_size(int section) const +{ + return section_data(section).size; +} + +HeaderView::SectionData& HeaderView::section_data(int section) const +{ + if (static_cast<size_t>(section) >= m_section_data.size()) + m_section_data.resize(section + 1); + return m_section_data.at(section); +} + +Gfx::IntRect HeaderView::section_rect(int section) const +{ + if (!model()) + return {}; + auto& data = section_data(section); + if (!data.visibility) + return {}; + int offset = 0; + for (int i = 0; i < section; ++i) { + if (!is_section_visible(i)) + continue; + offset += section_data(i).size + horizontal_padding() * 2; + } + if (orientation() == Gfx::Orientation::Horizontal) + return { offset, 0, section_size(section) + horizontal_padding() * 2, height() }; + return { 0, offset, width(), section_size(section) }; +} + +Gfx::IntRect HeaderView::section_resize_grabbable_rect(int section) const +{ + if (!model()) + return {}; + auto rect = section_rect(section); + return { rect.right() - 1, rect.top(), 4, rect.height() }; +} + +int HeaderView::section_count() const +{ + if (!model()) + return 0; + return m_orientation == Gfx::Orientation::Horizontal ? model()->column_count() : model()->row_count(); +} + +void HeaderView::mousedown_event(MouseEvent& event) +{ + if (!model()) + return; + + auto& model = *this->model(); + int section_count = this->section_count(); + + for (int i = 0; i < section_count; ++i) { + if (section_resize_grabbable_rect(i).contains(event.position())) { + m_resizing_section = i; + m_in_section_resize = true; + m_section_resize_original_width = section_size(i); + m_section_resize_origin = event.position(); + return; + } + auto rect = this->section_rect(i); + if (rect.contains(event.position()) && model.is_column_sortable(i)) { + m_pressed_section = i; + m_pressed_section_is_pressed = true; + update(); + return; + } + } +} + +void HeaderView::mousemove_event(MouseEvent& event) +{ + if (!model()) + return; + + if (m_in_section_resize) { + auto delta = event.position() - m_section_resize_origin; + int new_size = m_section_resize_original_width + delta.primary_offset_for_orientation(m_orientation); + if (new_size <= minimum_column_size) + new_size = minimum_column_size; + ASSERT(m_resizing_section >= 0 && m_resizing_section < model()->column_count()); + auto& data = this->section_data(m_resizing_section); + if (data.size != new_size) { + data.size = new_size; + m_table_view.header_did_change_section_size({}, m_orientation, m_resizing_section, new_size); + update(); + } + return; + } + + if (m_pressed_section != -1) { + auto header_rect = this->section_rect(m_pressed_section); + if (header_rect.contains(event.position())) { + set_hovered_section(m_pressed_section); + if (!m_pressed_section_is_pressed) + update(); + m_pressed_section_is_pressed = true; + } else { + set_hovered_section(-1); + if (m_pressed_section_is_pressed) + update(); + m_pressed_section_is_pressed = false; + } + return; + } + + if (event.buttons() == 0) { + int section_count = this->section_count(); + bool found_hovered_header = false; + for (int i = 0; i < section_count; ++i) { + if (section_resize_grabbable_rect(i).contains(event.position())) { + window()->set_override_cursor(StandardCursor::ResizeColumn); + set_hovered_section(-1); + return; + } + if (section_rect(i).contains(event.position())) { + set_hovered_section(i); + found_hovered_header = true; + } + } + if (!found_hovered_header) + set_hovered_section(-1); + } + window()->set_override_cursor(StandardCursor::None); +} + +void HeaderView::mouseup_event(MouseEvent& event) +{ + Gfx::IntPoint horizontally_adjusted_position(event.x(), event.y()); + if (event.button() == MouseButton::Left) { + if (m_in_section_resize) { + if (!section_resize_grabbable_rect(m_resizing_section).contains(horizontally_adjusted_position)) + window()->set_override_cursor(StandardCursor::None); + m_in_section_resize = false; + return; + } + if (m_pressed_section != -1) { + auto header_rect = this->section_rect(m_pressed_section); + if (header_rect.contains(horizontally_adjusted_position)) { + auto new_sort_order = SortOrder::Ascending; + if (m_table_view.key_column() == m_pressed_section) + new_sort_order = m_table_view.sort_order() == SortOrder::Ascending + ? SortOrder::Descending + : SortOrder::Ascending; + m_table_view.set_key_column_and_sort_order(m_pressed_section, new_sort_order); + } + m_pressed_section = -1; + m_pressed_section_is_pressed = false; + update(); + return; + } + } +} + +void HeaderView::paint_event(PaintEvent& event) +{ + Painter painter(*this); + painter.add_clip_rect(event.rect()); + painter.fill_rect(rect(), palette().button()); + painter.draw_line({ 0, 0 }, { rect().right(), 0 }, palette().threed_highlight()); + painter.draw_line({ 0, rect().bottom() }, { rect().right(), rect().bottom() }, palette().threed_shadow1()); + int x_offset = 0; + int section_count = this->section_count(); + for (int section = 0; section < section_count; ++section) { + if (!is_section_visible(section)) + continue; + int section_width = section_size(section); + bool is_key_column = m_table_view.key_column() == section; + Gfx::IntRect cell_rect(x_offset, 0, section_width + horizontal_padding() * 2, height()); + bool pressed = section == m_pressed_section && m_pressed_section_is_pressed; + bool hovered = section == m_hovered_section && model()->is_column_sortable(section); + Gfx::StylePainter::paint_button(painter, cell_rect, palette(), Gfx::ButtonStyle::Normal, pressed, hovered); + String text; + if (is_key_column) { + StringBuilder builder; + builder.append(model()->column_name(section)); + if (m_table_view.sort_order() == SortOrder::Ascending) + builder.append(" \xE2\xAC\x86"); // UPWARDS BLACK ARROW + else if (m_table_view.sort_order() == SortOrder::Descending) + builder.append(" \xE2\xAC\x87"); // DOWNWARDS BLACK ARROW + text = builder.to_string(); + } else { + text = model()->column_name(section); + } + auto text_rect = cell_rect.shrunken(horizontal_padding() * 2, 0); + if (pressed) + text_rect.move_by(1, 1); + painter.draw_text(text_rect, text, font(), section_alignment(section), palette().button_text()); + x_offset += section_width + horizontal_padding() * 2; + } +} + +void HeaderView::set_section_visible(int section, bool visible) +{ + auto& data = section_data(section); + if (data.visibility == visible) + return; + data.visibility = visible; + if (data.visibility_action) { + data.visibility_action->set_checked(visible); + } + m_table_view.header_did_change_section_visibility({}, m_orientation, section, visible); + update(); +} + +Menu& HeaderView::ensure_context_menu() +{ + // FIXME: This menu needs to be rebuilt if the model is swapped out, + // or if the column count/names change. + if (!m_context_menu) { + ASSERT(model()); + m_context_menu = Menu::construct(); + + int section_count = this->section_count(); + for (int section = 0; section < section_count; ++section) { + auto& column_data = this->section_data(section); + // FIXME: Vertical support + ASSERT(m_orientation == Gfx::Orientation::Horizontal); + auto name = model()->column_name(section); + column_data.visibility_action = Action::create_checkable(name, [this, section](auto& action) { + set_section_visible(section, action.is_checked()); + }); + column_data.visibility_action->set_checked(column_data.visibility); + + m_context_menu->add_action(*column_data.visibility_action); + } + } + return *m_context_menu; +} + +void HeaderView::context_menu_event(ContextMenuEvent& event) +{ + ensure_context_menu().popup(event.screen_position()); +} + +void HeaderView::leave_event(Core::Event& event) +{ + Widget::leave_event(event); + window()->set_override_cursor(StandardCursor::None); +} + +Gfx::TextAlignment HeaderView::section_alignment(int section) const +{ + return section_data(section).alignment; +} + +void HeaderView::set_section_alignment(int section, Gfx::TextAlignment alignment) +{ + section_data(section).alignment = alignment; +} + +bool HeaderView::is_section_visible(int section) const +{ + return section_data(section).visibility; +} + +void HeaderView::set_hovered_section(int section) +{ + if (m_hovered_section == section) + return; + m_hovered_section = section; + update(); +} + +Model* HeaderView::model() +{ + return m_table_view.model(); +} + +const Model* HeaderView::model() const +{ + return m_table_view.model(); +} + +} |