MuditaOS/module-gui/gui/widgets/Item.cpp

/*
 * Item.cpp
 *
 *  Created on: 4 mar 2019
 *      Author: robert
 */

#include <list>
#include <algorithm>
#include <cstring>
#include "Navigation.hpp"
#include "Item.hpp"
#include "BoundingBox.hpp"

namespace gui {

Item::Item() :
	focus {false},
	type {ItemType::ITEM},
	parent{nullptr},
	radius{0},
	visible{true},
	verticalPolicy{ LayoutVerticalPolicy::LAYOUT_POLICY_VERTICAL_EXPAND },
	horizontalPolicy { LayoutHorizontalPolicy::LAYOUT_POLICY_HORIZONTAL_EXPAND },
	navigationDirections{ nullptr } {

	focusChangedCallback = [](Item&){ return false;};
	activatedCallback = [](Item&){ return false;};
	inputCallback = [](Item&, const InputEvent& inputEvent){ return false;};
	dimensionChangedCallback = [](Item&,  void* data){ return false;};
	contentCallback = [=](Item&){ if( parent != nullptr ) return parent->onContent(); return false;};
}

Item::~Item() {
	for( auto& widget : children )
		delete widget;

	if( navigationDirections )
		delete navigationDirections;
}

void Item::addWidget(Item *item)
{
    if (item == nullptr)
        return;
    if (item->parent)
    {
        item->parent->removeWidget(item);
    }
    item->parent = this;
	children.push_back(item);

	item->updateDrawArea();
}

bool Item::removeWidget( Item* item ) {
	if(item == nullptr) return false;
    if (item == focusItem)
    {
        focusItem = nullptr;
    }

    auto fi = std::find( children.begin(), children.end(), item );
	if( fi != children.end() ) {
		children.erase(fi);
		return true;
	}
	return false;
}

void Item::setVisible( bool value ) {
	visible = value;
}

std::list<DrawCommand*> Item::buildDrawList() {

	std::list<DrawCommand*> commands;

	for( auto& widget : children ) {
		std::list<DrawCommand*> widgetCommands = widget->buildDrawList();
		if( !widgetCommands.empty() )
			commands.insert( commands.end(), widgetCommands.begin(), widgetCommands.end() );
	}

	return commands;
}

void Item::setPosition( const short& x, const short& y ) {

	BoundingBox oldArea = widgetArea;
	widgetArea.x = x;
	widgetArea.y = y;
	updateDrawArea();

	onDimensionChanged(oldArea, widgetArea);
}

void Item::setX(const uint32_t x)
{
	BoundingBox oldArea = widgetArea;
	widgetArea.x = x;
	updateDrawArea();

	onDimensionChanged(oldArea, widgetArea);
}

void Item::setY(const uint32_t y)
{
	BoundingBox oldArea = widgetArea;
	widgetArea.y = y;
	updateDrawArea();

	onDimensionChanged(oldArea, widgetArea);
}

void Item::setSize(const unsigned short w, const unsigned short h)
{
    BoundingBox oldArea = widgetArea;
    widgetArea.w = w;
	widgetArea.h = h;
    widgetMaxArea.sum(widgetArea);
    updateDrawArea();

    onDimensionChanged(oldArea, widgetArea);
}

void Item::setBoundingBox(const BoundingBox &new_box)
{
    BoundingBox oldArea = widgetArea;
    widgetArea = new_box;
    updateDrawArea();
    onDimensionChanged(oldArea, widgetArea);
}

void Item::setRadius( int value ) {
	if( value < 0 )
		value = 0;
	radius = value;
}

void Item::updateDrawArea() {
	Item* parentItem = parent;

	BoundingBox result = widgetArea;

	//iterate up to top widget in hierarchy
	while( parentItem != nullptr ) {

		result.x += parentItem->widgetArea.x;
		result.y += parentItem->widgetArea.y;
		BoundingBox newResult;
		if( BoundingBox::intersect(parentItem->widgetArea, result, newResult) == false ) {
			result.clear();
			break;
		}
		result = newResult;

		parentItem = parentItem->parent;
	}

	drawArea = result;

	for( gui::Item* it : children )
		it->updateDrawArea();
}

Item* Item::getNavigationItem( NavigationDirection direction ) {
	if( navigationDirections != nullptr ) {
		return navigationDirections->getDirectionItem(direction);
	}
	return nullptr;
}

void Item::setNavigationItem( gui::NavigationDirection direction, Item* item ) {
	if( navigationDirections == nullptr )
		navigationDirections = new Navigation();
	navigationDirections->setDirectionItem(direction, item);
}

bool Item::handleNavigation(const InputEvent inputEvent)
{
    gui::Item *newFocusItem = nullptr;
    if ((focusItem != nullptr) && (inputEvent.state == InputEvent::State::keyReleasedShort))
    {
        if (itemNavigation && itemNavigation(inputEvent))
        {
            return true;
        }
        switch (inputEvent.keyCode)
        {
        case gui::KeyCode::KEY_LEFT:
            newFocusItem = focusItem->getNavigationItem(gui::NavigationDirection::LEFT);
            break;
        case gui::KeyCode::KEY_RIGHT:
            newFocusItem = focusItem->getNavigationItem(gui::NavigationDirection::RIGHT);
            break;
        case gui::KeyCode::KEY_UP:
            newFocusItem = focusItem->getNavigationItem(gui::NavigationDirection::UP);
            break;
        case gui::KeyCode::KEY_DOWN:
            newFocusItem = focusItem->getNavigationItem(gui::NavigationDirection::DOWN);
            break;
        case gui::KeyCode::KEY_ENTER:
            if (focusItem != nullptr)
                return focusItem->onActivated(nullptr);
            break;
        default:
            break;
        }
    }
    if (newFocusItem != nullptr)
    {
        setFocusItem(newFocusItem);
        return true;
    }
    return false;
}

bool Item::setFocus(bool state)
{
    if (state != focus)
    {
        focus = state;
        onFocus(state);
        focusChangedCallback(*this);
    };
    return state;
}

void Item::setFocusItem(Item *item)
{
    auto checknrun = [=](bool on) {
        if (focusItem != nullptr)
        {
            focusItem->setFocus(on);
        }
    };
    checknrun(false);
    focusItem = item;
    checknrun(true);
}

Item *Item::getFocusItem()
{
    return focusItem;
}

bool Item::onFocus(bool state)
{
    focus = state;
    return true;
}

bool Item::onActivated(void *data)
{
    if (activatedCallback)
        return activatedCallback(*this);
    return false;
}

bool Item::onInput(const InputEvent &inputEvent)
{
    return inputCallback(*this, inputEvent);
}

bool Item::onDimensionChanged(const BoundingBox &oldDim, const BoundingBox &newDim)
{
    return true;
}

bool Item::onContent()
{
    return false;
};
} /* namespace gui */