298 lines
6.5 KiB
C++
298 lines
6.5 KiB
C++
/*
|
|
* \brief Common base class for all widgets
|
|
* \author Norman Feske
|
|
* \date 2009-09-11
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2014-2017 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU Affero General Public License version 3.
|
|
*/
|
|
|
|
#ifndef _WIDGET_H_
|
|
#define _WIDGET_H_
|
|
|
|
/* Genode includes */
|
|
#include <util/xml_generator.h>
|
|
#include <util/list_model.h>
|
|
#include <gems/animated_geometry.h>
|
|
|
|
/* local includes */
|
|
#include <widget_factory.h>
|
|
|
|
namespace Menu_view {
|
|
|
|
struct Margin;
|
|
struct Widget;
|
|
|
|
typedef Margin Padding;
|
|
}
|
|
|
|
|
|
struct Menu_view::Margin
|
|
{
|
|
unsigned left, right, top, bottom;
|
|
|
|
Margin(unsigned left, unsigned right, unsigned top, unsigned bottom)
|
|
:
|
|
left(left), right(right), top(top), bottom(bottom)
|
|
{ }
|
|
|
|
unsigned horizontal() const { return left + right; }
|
|
unsigned vertical() const { return top + bottom; }
|
|
};
|
|
|
|
|
|
class Menu_view::Widget : List_model<Widget>::Element
|
|
{
|
|
private:
|
|
|
|
friend class List_model<Widget>;
|
|
friend class List<Widget>;
|
|
|
|
public:
|
|
|
|
using List_model<Widget>::Element::next;
|
|
|
|
enum { NAME_MAX_LEN = 32 };
|
|
typedef String<NAME_MAX_LEN> Name;
|
|
|
|
typedef Name Type_name;
|
|
typedef String<10> Version;
|
|
|
|
struct Unique_id
|
|
{
|
|
unsigned value = 0;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* Only to be called by widget factory.
|
|
*/
|
|
Unique_id(unsigned value) : value(value) { }
|
|
|
|
/**
|
|
* Default constructor creates invalid ID
|
|
*/
|
|
Unique_id() { }
|
|
|
|
bool operator != (Unique_id const &other) const
|
|
{
|
|
return other.value != value;
|
|
}
|
|
|
|
bool valid() const { return value != 0; }
|
|
};
|
|
|
|
struct Hovered
|
|
{
|
|
/* widget */
|
|
Unique_id unique_id;
|
|
|
|
/* widget-local detail */
|
|
using Detail = String<16>;
|
|
|
|
Detail detail;
|
|
|
|
bool operator != (Hovered const &other) const
|
|
{
|
|
return (unique_id != other.unique_id) || (detail != other.detail);
|
|
}
|
|
};
|
|
|
|
static Name node_name(Xml_node node)
|
|
{
|
|
return node.attribute_value("name", Name(node.type()));
|
|
}
|
|
|
|
static Animated_rect::Steps motion_steps() { return { 60 }; };
|
|
|
|
protected:
|
|
|
|
Type_name const _type_name;
|
|
Name const _name;
|
|
Version const _version { };
|
|
|
|
Unique_id const _unique_id;
|
|
|
|
Widget_factory &_factory;
|
|
|
|
List_model<Widget> _children { };
|
|
|
|
struct Model_update_policy : List_model<Widget>::Update_policy
|
|
{
|
|
Widget_factory &_factory;
|
|
|
|
Model_update_policy(Widget_factory &factory) : _factory(factory) { }
|
|
|
|
void destroy_element(Widget &w) { _factory.destroy(&w); }
|
|
|
|
Widget &create_element(Xml_node elem_node)
|
|
{
|
|
if (Widget *w = _factory.create(elem_node))
|
|
return *w;
|
|
|
|
throw Unknown_element_type();
|
|
}
|
|
|
|
void update_element(Widget &w, Xml_node node) { w.update(node); }
|
|
|
|
static bool element_matches_xml_node(Widget const &w, Xml_node node)
|
|
{
|
|
return node.has_type(w._type_name.string())
|
|
&& Widget::node_name(node) == w._name
|
|
&& node.attribute_value("version", Version()) == w._version;
|
|
}
|
|
|
|
} _model_update_policy { _factory };
|
|
|
|
inline void _update_children(Xml_node node)
|
|
{
|
|
_children.update_from_xml(_model_update_policy, node);
|
|
}
|
|
|
|
void _draw_children(Surface<Pixel_rgb888> &pixel_surface,
|
|
Surface<Pixel_alpha8> &alpha_surface,
|
|
Point at) const
|
|
{
|
|
_children.for_each([&] (Widget const &w) {
|
|
w.draw(pixel_surface, alpha_surface, at + w._animated_geometry.p1()); });
|
|
}
|
|
|
|
virtual void _layout() { }
|
|
|
|
Rect _inner_geometry() const
|
|
{
|
|
return Rect(Point(margin.left, margin.top),
|
|
Area(geometry().w() - margin.horizontal(),
|
|
geometry().h() - margin.vertical()));
|
|
}
|
|
|
|
/*
|
|
* Position relative to the parent widget and actual size, defined by
|
|
* the parent
|
|
*/
|
|
Rect _geometry { Point(0, 0), Area(0, 0) };
|
|
|
|
Animated_rect _animated_geometry { _factory.animator };
|
|
|
|
void _trigger_geometry_animation()
|
|
{
|
|
bool const changed = (_geometry.p1() != _animated_geometry.p1()
|
|
|| _geometry.p2() != _animated_geometry.p2());
|
|
if (changed)
|
|
_animated_geometry.move_to(_geometry, motion_steps());
|
|
}
|
|
|
|
void _gen_common_hover_attr(Xml_generator &xml) const
|
|
{
|
|
xml.attribute("name", _name.string());
|
|
xml.attribute("xpos", geometry().x1());
|
|
xml.attribute("ypos", geometry().y1());
|
|
xml.attribute("width", geometry().w());
|
|
xml.attribute("height", geometry().h());
|
|
}
|
|
|
|
public:
|
|
|
|
Margin margin { 0, 0, 0, 0 };
|
|
|
|
Rect geometry() const { return _geometry; }
|
|
|
|
Rect animated_geometry() const { return _animated_geometry.rect(); }
|
|
|
|
/*
|
|
* Return x/y positions of the edges of the widget with the margin
|
|
* applied
|
|
*/
|
|
Rect edges() const
|
|
{
|
|
Rect const r = _animated_geometry.rect();
|
|
return Rect(Point(r.x1() + margin.left, r.y1() + margin.top),
|
|
Point(r.x2() - margin.right, r.y2() - margin.bottom));
|
|
}
|
|
|
|
Widget(Widget_factory &factory, Xml_node node, Unique_id unique_id)
|
|
:
|
|
_type_name(node.type()),
|
|
_name(node_name(node)),
|
|
_unique_id(unique_id),
|
|
_factory(factory)
|
|
{ }
|
|
|
|
virtual ~Widget()
|
|
{
|
|
_children.destroy_all_elements(_model_update_policy);
|
|
}
|
|
|
|
bool has_name(Name const &name) const { return name == _name; }
|
|
|
|
virtual void update(Xml_node node) = 0;
|
|
|
|
virtual Area min_size() const = 0;
|
|
|
|
virtual void draw(Surface<Pixel_rgb888> &pixel_surface,
|
|
Surface<Pixel_alpha8> &alpha_surface,
|
|
Point at) const = 0;
|
|
|
|
/**
|
|
* Set widget size and update the widget tree's layout accordingly
|
|
*/
|
|
void size(Area size)
|
|
{
|
|
_geometry = Rect(_geometry.p1(), size);
|
|
|
|
_layout();
|
|
|
|
_trigger_geometry_animation();
|
|
}
|
|
|
|
void position(Point position)
|
|
{
|
|
_geometry = Rect(position, _geometry.area());
|
|
}
|
|
|
|
/**
|
|
* Return unique ID of inner-most hovered widget
|
|
*
|
|
* This function is used to track changes of the hover model.
|
|
*/
|
|
virtual Hovered hovered(Point at) const
|
|
{
|
|
if (!_inner_geometry().contains(at))
|
|
return { };
|
|
|
|
Hovered result { .unique_id = _unique_id, .detail = { } };
|
|
_children.for_each([&] (Widget const &w) {
|
|
Hovered const hovered = w.hovered(at - w.geometry().p1());
|
|
if (hovered.unique_id.valid())
|
|
result = hovered;
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
void print(Output &out) const
|
|
{
|
|
Genode::print(out, _name);
|
|
}
|
|
|
|
virtual void gen_hover_model(Xml_generator &xml, Point at) const
|
|
{
|
|
if (_inner_geometry().contains(at)) {
|
|
|
|
xml.node(_type_name.string(), [&]() {
|
|
|
|
_gen_common_hover_attr(xml);
|
|
|
|
_children.for_each([&] (Widget const &w) {
|
|
w.gen_hover_model(xml, at - w.geometry().p1()); });
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
#endif /* _WIDGET_H_ */
|