widget.cpp

Go to the documentation of this file.

 
#include <gui/widget.h>
 
using namespace MaxOS::common;
using namespace MaxOS::gui;
using namespace MaxOS::drivers;
using namespace MaxOS::drivers::peripherals;
 
Widget::Widget()
: KeyboardEventHandler()
{
 
}
 
Widget::Widget(int32_t left, int32_t top, uint32_t width, uint32_t height)
: KeyboardEventHandler(),
  m_position(left, top, width, height)
{
 
}
 
Widget::~Widget() = default;
 
void Widget::draw(GraphicsContext*, Rectangle<int32_t>&) {
 
}
 
void Widget::invalidate() {
 
    // Convert the relative coordinates to absolute coordinates
    Coordinates coordinates = absolute_coordinates(Coordinates(0, 0));
 
    // Create a rectangle with the absolute coordinates and the size of the widget
    Rectangle<int32_t> invalid_area = Rectangle<int32_t>(coordinates.first, coordinates.second, m_position.width, m_position.height);
 
    // Invalidate the area
    invalidate(invalid_area);
 
}
 
void Widget::invalidate(Rectangle<int32_t>& area) {
 
    // If the widget has a parent, invalidate the area of the parent
    if (m_parent != nullptr)
        m_parent->invalidate(area);
}
 
void Widget::add_child(Widget* child) {
 
    // Parent the child to this widget
    child->m_parent = this;
 
}
 
Coordinates Widget::absolute_coordinates(common::Coordinates coordinates) {
 
    // Return the parents absolute coordinates
    if (m_parent != nullptr)
        return m_parent->absolute_coordinates( Coordinates(coordinates.first + m_position.left, coordinates.second + m_position.top));
 
    // If the widget has no m_parent, return the coordinates of the widget
    return {coordinates.first + m_position.left, coordinates.second + m_position.top};
 
}
 
bool Widget::contains_coordinate(uint32_t x, uint32_t y) {
 
    // Check if the coordinates are within the bounds of the widget
    return m_position.contains(x, y);
}
 
Rectangle<int32_t> Widget::position() {
 
    return m_position;
}
 
void Widget::move(int32_t left, int32_t top) {
 
    // Invalidate the old position
    invalidate();
 
    // Set the new position
    m_position.left = left;
    m_position.top = top;
 
    // Re draw the widget in the new position
    invalidate();
}
 
void Widget::resize(int32_t width, int32_t height) {
 
    // Restrict the width and height to the minimum and maximum values
    if (width < (int) m_min_width) width = m_min_width;
    if (height < (int) m_min_height) height = m_min_height;
    if (width > (int) m_max_width) width = m_max_width;
    if (height > (int) m_max_height) height = m_max_height;
 
    // Store the old position, set the new position
    Rectangle<int32_t> old_position = m_position;
    m_position.width = width;
    m_position.height = height;
 
    // Find the areas that need to be redrawn by subtracting the old position from the new position, and vice versa
    Vector<Rectangle<int32_t>> invalid_areas_old = old_position.subtract(m_position);
    Vector<Rectangle<int32_t>> invalid_areas_new = m_position.subtract(old_position);
 
    // Right and Bottom require to be fully invalidated
    if (m_position.width > old_position.width || m_position.height > old_position.height ||
        old_position.width > m_position.width || old_position.height > m_position.height) {
        invalidate();
        return;
    }
 
    //Loop through the areas that need to be redrawn and invalidate them
    for (auto& area: invalid_areas_old)
        invalidate(area);
 
    for (auto& area: invalid_areas_new)
        invalidate(area);
 
}
 
void Widget::focus() {
 
    // Set the focus the widget to this widget
    set_focus(this);
}
 
void Widget::set_focus(Widget* widget) {
 
    // Focus the parent to this widget
    if (m_parent != nullptr)
        m_parent->set_focus(widget);
}
 
void Widget::on_focus() {
 
}
 
void Widget::on_focus_lost() {
 
}
 
void Widget::bring_to_front() {
 
    // Bring this widget to the front of the screen
    bring_to_front(this);
}
 
void Widget::bring_to_front(Widget* widget) {
 
    // Bring the parent to the front of the screen
    if (m_parent != nullptr)
        m_parent->bring_to_front(widget);
 
}
 
void Widget::on_mouse_enter_widget(uint32_t to_x, uint32_t to_y) {
 
}
 
void Widget::on_mouse_leave_widget(uint32_t from_x, uint32_t from_y) {
 
}
 
void Widget::on_mouse_move_widget(uint32_t from_x, uint32_t from_y, uint32_t to_x, uint32_t to_y) {
 
}
 
peripherals::MouseEventHandler* Widget::on_mouse_button_pressed(uint32_t, uint32_t, uint8_t) {
 
    // Bring the widget to the front of the screen
    bring_to_front();
 
    // Focus the widget
    focus();
 
    // Return 0 as the event has been handled
    return nullptr;
}
 
void Widget::on_mouse_button_released(uint32_t, uint32_t, uint8_t) {
 
}
 
CompositeWidget::CompositeWidget() = default;
 
CompositeWidget::CompositeWidget(int32_t left, int32_t top, uint32_t width, uint32_t height)
: Widget(left, top, width, height) {
 
}
 
CompositeWidget::~CompositeWidget() = default;
 
void CompositeWidget::draw(GraphicsContext* gc, Rectangle<int32_t>& area) {
 
    // Draw the widget with its m_children
    draw(gc, area, m_children.begin());
}
 
void CompositeWidget::draw(GraphicsContext* gc, Rectangle<int32_t>& area, Vector<Widget*>::iterator start) {
 
    // Draw the widget
    Widget::draw(gc, area);
 
    // Get the area of the widget
    Rectangle<int32_t> own_area = position();
 
    //Note: has to use iterator as the start is not necessarily the m_first_memory_chunk child
    for (Vector<Widget*>::iterator child_widget = start; child_widget != m_children.end(); child_widget++) {
 
        Rectangle<int32_t> child_area = (*child_widget)->position();
 
        // Check if the child is in the area that needs to be redrawn
        if (area.intersects(child_area)) {
 
            // Get the area that needs to be redrawn
            Rectangle<int32_t> rectangle = area.intersection(child_area);
 
            // Translate the area so that it is relative to the child
            rectangle.left -= child_area.left;
            rectangle.top -= child_area.top;
 
            // Draw the child
            (*child_widget)->draw(gc, rectangle);
 
            // Draw what is left of the area that needs to be redrawn
            Vector<Rectangle<int32_t>> rest_draw_area = area.subtract(child_area);
            for (auto& rest_area_part: rest_draw_area)
                draw(gc, rest_area_part, child_widget + 1);
 
            // Return as the entire area has now been drawn
            return;
        }
    }
 
    // Now draw the widget itself
    draw_self(gc, area);
}
 
void CompositeWidget::draw_self(common::GraphicsContext*, common::Rectangle<int32_t>&) {
 
}
 
void CompositeWidget::add_child(Widget* child) {
 
    // Store the child and parent the child to this widget
    m_children.push_back(child);
    Widget::add_child(child);
}
 
void CompositeWidget::on_mouse_enter_widget(uint32_t to_x, uint32_t to_y) {
 
    for (auto& child_widget: m_children) {
 
        // Check if the mouse is in the child
        Rectangle<int32_t> child_area = child_widget->position();
        if (child_area.contains(to_x, to_y)) {
 
            // Get the position of the mouse relative to the child
            uint32_t child_x = to_x - child_area.left;
            uint32_t child_y = to_y - child_area.top;
 
            // Call the child's on_mouse_enter_widget function
            child_widget->on_mouse_enter_widget(child_x, child_y);
 
            // Break as the event has been handled
            break;
        }
    }
}
 
void CompositeWidget::on_mouse_leave_widget(uint32_t from_x, uint32_t from_y) {
 
    for (auto& child_widget: m_children) {
 
        // Check if the mouse is in the child
        Rectangle<int32_t> child_area = child_widget->position();
        if (child_area.contains(from_x, from_y)) {
 
            // Get the position of the mouse relative to the child
            uint32_t child_x = from_x - child_area.left;
            uint32_t child_y = from_y - child_area.top;
 
            // Call the child's on_mouse_leave_widget function
            child_widget->on_mouse_leave_widget(child_x, child_y);
 
            // Event has been handled
            break;
        }
    }
}
 
void CompositeWidget::on_mouse_move_widget(uint32_t from_x, uint32_t from_y, uint32_t to_x, uint32_t to_y) {
 
    Widget* left_child = nullptr;
    Widget* entered_child = nullptr;
 
    for (auto& child_widget: m_children) {
 
        // Check if the mouse is in the child
        Rectangle<int32_t> child_area = child_widget->position();
        bool mouse_in_from = child_area.contains(from_x, from_y);
        bool mouse_in_to = child_area.contains(to_x, to_y);
 
        // If the mouse started in the child
        if (mouse_in_from) {
 
            // The mouse moved out of the child
            if (!mouse_in_to) {
                left_child = child_widget;
                continue;
            }
 
            // Mouse still in the child
            child_widget->on_mouse_move_widget(from_x, from_y, to_x, to_y);
 
        } else {
 
            // Mouse moved into the child
            if (mouse_in_to)
                entered_child = child_widget;
        }
 
        // Pass the events to the child
        if (left_child != nullptr)
            left_child->on_mouse_leave_widget(from_x, from_y);
 
        if (entered_child != nullptr)
            entered_child->on_mouse_enter_widget(to_x, to_y);
    }
}
 
peripherals::MouseEventHandler* CompositeWidget::on_mouse_button_pressed(uint32_t x, uint32_t y, uint8_t button) {
 
    MouseEventHandler* mouse_event_handler = nullptr;
 
    for (auto& child_widget: m_children) {
 
        // Pass the event to the child
        if (child_widget->contains_coordinate(x, y)) {
            mouse_event_handler = child_widget->on_mouse_button_pressed(x - child_widget->m_position.left,
                                                                        y - child_widget->m_position.top, button);
            break;
        }
    }
 
    return mouse_event_handler;
}
 
void CompositeWidget::on_mouse_button_released(uint32_t x, uint32_t y, uint8_t button) {
 
    // Loop through the m_children
    for (auto& child_widget: m_children) {
 
        // Pass the event to the child
        if (child_widget->contains_coordinate(x, y)) {
            child_widget->on_mouse_button_released(x - child_widget->m_position.left, y - child_widget->m_position.top,
                                                   button);
            break;
        }
    }
}