1151 lines
28 KiB
C++
1151 lines
28 KiB
C++
#include <psemek/ui/default_element_factory.hpp>
|
|
|
|
#include <psemek/ui/button.hpp>
|
|
#include <psemek/ui/frame.hpp>
|
|
#include <psemek/ui/window.hpp>
|
|
#include <psemek/ui/checkbox.hpp>
|
|
#include <psemek/ui/slider.hpp>
|
|
#include <psemek/ui/spinbox.hpp>
|
|
#include <psemek/ui/box_shape.hpp>
|
|
#include <psemek/ui/container.hpp>
|
|
#include <psemek/ui/grid_layout.hpp>
|
|
#include <psemek/ui/scroller.hpp>
|
|
#include <psemek/ui/selector.hpp>
|
|
#include <psemek/ui/edit.hpp>
|
|
|
|
#include <psemek/io/memory_stream.hpp>
|
|
|
|
#include <psemek/ui/resources/cross_red_16x16_png.hpp>
|
|
|
|
namespace psemek::ui
|
|
{
|
|
|
|
namespace
|
|
{
|
|
|
|
struct button_impl
|
|
: button
|
|
{
|
|
struct shape const & shape() const override
|
|
{
|
|
return shape_;
|
|
}
|
|
|
|
void reshape(geom::box<float, 2> const & bbox) override
|
|
{
|
|
shape_.box = bbox;
|
|
auto st = merged_own_style();
|
|
|
|
geom::vector offset{0.f, 0.f};
|
|
if (state() == state_t::mousedown)
|
|
offset = geom::cast<float>(*st->action_offset);
|
|
|
|
auto c = child_.get();
|
|
if (c) c->reshape(geom::shrink(bbox, geom::vector<float, 2>{*st->border_width + (*st->inner_margin)[0], *st->border_width + (*st->inner_margin)[1]}) + offset);
|
|
}
|
|
|
|
void on_state_changed(state_t old) override
|
|
{
|
|
button::on_state_changed(old);
|
|
|
|
gfx::color_rgba color{0, 0, 0, 0};
|
|
|
|
switch (state()) {
|
|
case state_t::mouseover:
|
|
color = {255, 255, 255, 63};
|
|
break;
|
|
case state_t::mousedown:
|
|
color = {0, 0, 0, 63};
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (icon())
|
|
icon()->set_color(color);
|
|
}
|
|
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
if (!st) return;
|
|
|
|
if (st->shadow_offset != geom::vector{0, 0})
|
|
p.draw_rect(shape_.box + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
|
|
|
|
auto offset = geom::vector{0.f, 0.f};
|
|
if (state() == state_t::mousedown)
|
|
offset = geom::cast<float>(*st->action_offset);
|
|
|
|
if (st->border_width > 0)
|
|
p.draw_rect(shape_.box + offset, *st->border_color);
|
|
|
|
gfx::color_rgba color = *st->fg_color;
|
|
if (state() == state_t::mouseover)
|
|
color = *st->highlight_color;
|
|
else if (state() == state_t::mousedown)
|
|
color = *st->action_color;
|
|
p.draw_rect(geom::shrink(shape_.box, 1.f * (*st->border_width)) + offset, color);
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
auto sc = element::size_constraints();
|
|
|
|
if (child_)
|
|
{
|
|
auto csc = child_->size_constraints();
|
|
sc[0].min = csc[0].min;
|
|
sc[1].min = csc[1].min;
|
|
}
|
|
|
|
if (auto st = merged_own_style())
|
|
{
|
|
sc[0] += 2.f * (*st->border_width);
|
|
sc[1] += 2.f * (*st->border_width);
|
|
|
|
sc += 2.f * geom::cast<float>(*st->inner_margin);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
geom::interval<float> width_constraints(float height) const override
|
|
{
|
|
auto wc = element::width_constraints(height);
|
|
|
|
auto st = merged_own_style();
|
|
|
|
float extra = 2.f * (*st->border_width) + 2.f * geom::cast<float>(*st->inner_margin)[0];
|
|
|
|
if (child_)
|
|
{
|
|
auto cwc = child_->width_constraints(height - extra);
|
|
wc.min = cwc.min;
|
|
}
|
|
|
|
wc += extra;
|
|
|
|
return wc;
|
|
}
|
|
|
|
geom::interval<float> height_constraints(float width) const override
|
|
{
|
|
auto hc = element::height_constraints(width);
|
|
|
|
auto st = merged_own_style();
|
|
|
|
float extra = 2.f * (*st->border_width) + 2.f * geom::cast<float>(*st->inner_margin)[1];
|
|
|
|
if (child_)
|
|
{
|
|
auto chc = child_->height_constraints(width - extra);
|
|
hc.min = chc.min;
|
|
}
|
|
|
|
hc += extra;
|
|
|
|
return hc;
|
|
}
|
|
|
|
private:
|
|
box_shape shape_;
|
|
};
|
|
|
|
struct frame_impl
|
|
: frame
|
|
{
|
|
struct shape const & shape() const override { return shape_; }
|
|
|
|
void reshape(geom::box<float, 2> const & bbox) override
|
|
{
|
|
shape_.box = bbox;
|
|
auto st = merged_own_style();
|
|
if (!st) return;
|
|
for (auto c : children())
|
|
if (c) c->reshape(geom::shrink(bbox, 1.f * (*st->border_width + *st->bevel_width + *st->outer_margin)));
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
geom::box<float, 2> sc = frame::size_constraints();
|
|
|
|
auto st = merged_own_style();
|
|
if (st)
|
|
{
|
|
float extra = 2.f * (*st->border_width + *st->bevel_width + *st->outer_margin);
|
|
sc[0] += extra;
|
|
sc[1] += extra;
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
geom::interval<float> width_constraints(float height) const override
|
|
{
|
|
auto wc = frame::width_constraints(height);
|
|
|
|
auto st = merged_own_style();
|
|
if (st)
|
|
{
|
|
float extra = 2.f * (*st->border_width + *st->bevel_width + *st->outer_margin);
|
|
wc += extra;
|
|
}
|
|
|
|
return wc;
|
|
}
|
|
|
|
geom::interval<float> height_constraints(float width) const override
|
|
{
|
|
auto hc = frame::height_constraints(width);
|
|
|
|
auto st = merged_own_style();
|
|
if (st)
|
|
{
|
|
float extra = 2.f * (*st->border_width + *st->bevel_width + *st->outer_margin);
|
|
hc += extra;
|
|
}
|
|
|
|
return hc;
|
|
}
|
|
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
if (!st) return;
|
|
|
|
if (st->shadow_offset != geom::vector{0, 0})
|
|
p.draw_rect(shape_.box + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
|
|
|
|
if (st->border_width > 0)
|
|
p.draw_rect(shape_.box, *st->border_color);
|
|
|
|
if (st->bevel_width > 0)
|
|
{
|
|
geom::point<float, 2> corners[4];
|
|
geom::point<float, 2> corners_in[4];
|
|
|
|
auto box = geom::shrink<float>(shape_.box, *st->border_width);
|
|
|
|
corners[0] = box.corner(0, 0);
|
|
corners[1] = box.corner(1, 0);
|
|
corners[2] = box.corner(1, 1);
|
|
corners[3] = box.corner(0, 1);
|
|
|
|
auto box_in = geom::shrink<float>(box, *st->bevel_width);
|
|
|
|
corners_in[0] = box_in.corner(0, 0);
|
|
corners_in[1] = box_in.corner(1, 0);
|
|
corners_in[2] = box_in.corner(1, 1);
|
|
corners_in[3] = box_in.corner(0, 1);
|
|
|
|
auto c1 = *st->bevel_light_color;
|
|
auto c2 = *st->bevel_dark_color;
|
|
|
|
if (*st->bevel_type == bevel_type::down)
|
|
std::swap(c1, c2);
|
|
|
|
p.draw_triangle({corners[0], corners_in[0], corners[1]}, c1);
|
|
p.draw_triangle({corners[1], corners_in[0], corners_in[1]}, c1);
|
|
p.draw_triangle({corners[1], corners_in[1], corners[2]}, c1);
|
|
p.draw_triangle({corners[2], corners_in[1], corners_in[2]}, c1);
|
|
|
|
p.draw_triangle({corners[2], corners_in[2], corners[3]}, c2);
|
|
p.draw_triangle({corners[3], corners_in[2], corners_in[3]}, c2);
|
|
p.draw_triangle({corners[3], corners_in[3], corners[0]}, c2);
|
|
p.draw_triangle({corners[0], corners_in[3], corners_in[0]}, c2);
|
|
}
|
|
|
|
p.draw_rect(geom::shrink(shape_.box, 1.f * (*st->border_width + *st->bevel_width)), *st->bg_color);
|
|
}
|
|
|
|
private:
|
|
box_shape shape_;
|
|
};
|
|
|
|
struct window_impl
|
|
: window
|
|
{
|
|
window_impl(std::shared_ptr<gfx::texture_2d> close_icon)
|
|
: close_texture_(std::move(close_icon))
|
|
, caption_(std::make_shared<label>())
|
|
, close_button_(std::make_shared<button_impl>())
|
|
{
|
|
close_button_->set_child(std::make_shared<image_view>());
|
|
close_button_->icon()->set_image({close_texture_.get()});
|
|
close_button_->icon()->set_downscale(false);
|
|
|
|
caption_->set_parent(this);
|
|
close_button_->set_parent(this);
|
|
|
|
caption_->set_valign(label::valignment::center);
|
|
caption_->set_overflow(label::overflow_mode::ellipsis);
|
|
|
|
auto close_button_style = std::make_shared<struct style>();
|
|
close_button_style->shadow_offset = {0, 0};
|
|
close_button_->set_style(close_button_style);
|
|
|
|
children_[0] = caption_.get();
|
|
children_[1] = close_button_.get();
|
|
children_[2] = nullptr;
|
|
|
|
on_close_ = [this]
|
|
{
|
|
if (!parent()) return;
|
|
|
|
if (auto p = dynamic_cast<container *>(parent()))
|
|
p->remove_child(this);
|
|
else
|
|
throw std::runtime_error("Cannot remove window from non-container parent");
|
|
};
|
|
}
|
|
|
|
void setup_close()
|
|
{
|
|
auto weak_self = weak_from_this();
|
|
close_button_->on_click([weak_self]{
|
|
if (auto self = std::dynamic_pointer_cast<window_impl>(weak_self.lock()))
|
|
{
|
|
if (self->on_close_)
|
|
self->on_close_();
|
|
}
|
|
});
|
|
}
|
|
|
|
label * caption() override
|
|
{
|
|
return caption_.get();
|
|
}
|
|
|
|
std::shared_ptr<element> set_child(std::shared_ptr<element> c) override
|
|
{
|
|
if (child_) child_->set_parent(nullptr);
|
|
std::swap(child_, c);
|
|
if (child_) child_->set_parent(this);
|
|
children_[2] = child_.get();
|
|
return c;
|
|
}
|
|
|
|
children_range children() const override
|
|
{
|
|
return children_range{children_};
|
|
}
|
|
|
|
on_close_callback on_close() const override
|
|
{
|
|
return on_close_;
|
|
}
|
|
|
|
void on_close(on_close_callback callback) override
|
|
{
|
|
on_close_ = std::move(callback);
|
|
}
|
|
|
|
void close() override
|
|
{
|
|
if (on_close_)
|
|
on_close_();
|
|
}
|
|
|
|
bool on_event(mouse_move const & e) override
|
|
{
|
|
mouse_ = e.position;
|
|
|
|
if (drag_ && *drag_ != e.position)
|
|
{
|
|
shape_.box += geom::cast<float>(e.position - *drag_);
|
|
drag_ = e.position;
|
|
post_reshape();
|
|
}
|
|
|
|
return shape().contains(geom::cast<float>(*mouse_));
|
|
}
|
|
|
|
bool on_event(mouse_click const & e) override
|
|
{
|
|
if (!mouse_)
|
|
return false;
|
|
|
|
if (e.button == mouse_button::left && mouse_)
|
|
{
|
|
if (e.down && shape().contains(geom::cast<float>(*mouse_)))
|
|
{
|
|
drag_ = *mouse_;
|
|
return true;
|
|
}
|
|
|
|
if (!e.down && drag_)
|
|
{
|
|
drag_ = std::nullopt;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (e.button == mouse_button::left && mouse_)
|
|
{
|
|
if (shape().contains(geom::cast<float>(*mouse_)))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool on_event(mouse_wheel const &) override
|
|
{
|
|
return mouse_ && shape().contains(geom::cast<float>(*mouse_));
|
|
}
|
|
|
|
struct shape const & shape() const override
|
|
{
|
|
return shape_;
|
|
}
|
|
|
|
void reshape(geom::box<float, 2> const & bbox) override
|
|
{
|
|
shape_.box = bbox;
|
|
|
|
auto lc = caption_->size_constraints();
|
|
auto bc = close_button_->size_constraints();
|
|
|
|
auto st = merged_own_style();
|
|
|
|
float const header_height = std::max(lc[1].min + 2.f * (*st->inner_margin)[1] + 2.f * (*st->border_width), bc[1].min);
|
|
|
|
{
|
|
geom::box<float, 2> b;
|
|
b[0].min = bbox[0].max - bc[0].min;
|
|
b[0].max = bbox[0].max;
|
|
b[1].min = bbox[1].min;
|
|
b[1].max = bbox[1].min + header_height;
|
|
close_button_->reshape(b);
|
|
}
|
|
|
|
{
|
|
geom::box<float, 2> b;
|
|
b[0].min = bbox[0].min + (*st->inner_margin)[0] + (*st->border_width);
|
|
b[0].max = bbox[0].max - (*st->inner_margin)[0] - bc[0].min;
|
|
b[1].min = bbox[1].min + (*st->inner_margin)[1] + (*st->border_width);
|
|
b[1].max = bbox[1].min + header_height - (*st->inner_margin)[1] - (*st->border_width);
|
|
caption_->reshape(b);
|
|
}
|
|
|
|
if (child_)
|
|
{
|
|
geom::box<float, 2> b;
|
|
b[0].min = bbox[0].min + (*st->border_width);
|
|
b[0].max = bbox[0].max - (*st->border_width);
|
|
b[1].min = bbox[1].min + header_height;
|
|
b[1].max = bbox[1].max - (*st->border_width);
|
|
child_->reshape(b);
|
|
}
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
geom::box<float, 2> r = element::size_constraints();
|
|
if (child_) r = child_->size_constraints();
|
|
|
|
auto lc = caption_->size_constraints();
|
|
auto bc = close_button_->size_constraints();
|
|
|
|
auto st = merged_own_style();
|
|
|
|
float const header_height = std::max(lc[1].min + 2.f * (*st->inner_margin)[1] + 2.f * (*st->border_width), bc[1].min);
|
|
|
|
r[0].min = std::max(r[0].min + 2.f * (*st->inner_margin)[0] + 2.f * (*st->border_width), (*st->border_width) + lc[0].min + bc[0].min);
|
|
r[1] += (*st->border_width) * 1.f + header_height;
|
|
|
|
return r;
|
|
}
|
|
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
|
|
auto lc = caption_->size_constraints();
|
|
auto bc = close_button_->size_constraints();
|
|
|
|
auto const & bb = shape_.box;
|
|
|
|
if (*st->shadow_offset != geom::vector{0, 0})
|
|
p.draw_rect(bb + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
|
|
p.draw_rect(bb, *st->border_color);
|
|
|
|
float const header_height = std::max(lc[1].min + 2.f * (*st->inner_margin)[1] + 2.f * (*st->border_width), bc[1].min);
|
|
p.draw_rect({{{bb[0].min + (*st->border_width), bb[0].max - bc[0].min}, {bb[1].min + (*st->border_width), bb[1].min + header_height - (*st->border_width)}}},
|
|
*st->fg_color);
|
|
p.draw_rect({{{bb[0].min + (*st->border_width), bb[0].max - (*st->border_width)}, {bb[1].min + header_height, bb[1].max - (*st->border_width)}}},
|
|
*st->bg_color);
|
|
}
|
|
|
|
private:
|
|
std::shared_ptr<gfx::texture_2d> close_texture_;
|
|
std::shared_ptr<label> caption_;
|
|
std::shared_ptr<button> close_button_;
|
|
std::shared_ptr<element> child_;
|
|
|
|
on_close_callback on_close_;
|
|
|
|
std::optional<geom::point<int, 2>> mouse_;
|
|
std::optional<geom::point<int, 2>> drag_;
|
|
|
|
box_shape shape_;
|
|
|
|
element * children_[3];
|
|
};
|
|
|
|
struct checkbox_impl
|
|
: checkbox
|
|
{
|
|
std::shared_ptr<element> set_child(std::shared_ptr<element>) override
|
|
{
|
|
throw std::runtime_error("default checkbox doesn't support children");
|
|
}
|
|
|
|
struct shape const & shape() const override
|
|
{
|
|
return shape_;
|
|
}
|
|
|
|
void reshape(geom::box<float, 2> const & bbox) override
|
|
{
|
|
shape_.box = geom::expand(geom::box<float, 2>::singleton(bbox.center()), size() / 2.f);
|
|
}
|
|
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
if (!st) return;
|
|
|
|
geom::box<float, 2> boxes[5];
|
|
|
|
boxes[0] = {{shape_.box[0], {shape_.box[1].min, shape_.box[1].min + outer_width()}}};
|
|
boxes[1] = {{shape_.box[0], {shape_.box[1].max - outer_width(), shape_.box[1].max}}};
|
|
boxes[2] = {{{shape_.box[0].min, shape_.box[0].min + outer_width()}, {shape_.box[1].min + outer_width(), shape_.box[1].max - outer_width()}}};
|
|
boxes[3] = {{{shape_.box[0].max - outer_width(), shape_.box[0].max}, {shape_.box[1].min + outer_width(), shape_.box[1].max - outer_width()}}};
|
|
boxes[4] = geom::shrink(shape_.box, 0.f + outer_width() + outer_margin());
|
|
|
|
int const box_count = value() ? 5 : 4;
|
|
|
|
if (st->shadow_offset != geom::vector{0, 0})
|
|
{
|
|
auto const offset = geom::cast<float>(*st->shadow_offset);
|
|
for (int b = 0; b < box_count; ++b)
|
|
p.draw_rect(boxes[b] + offset, *st->shadow_color);
|
|
}
|
|
|
|
auto offset = geom::vector{0.f, 0.f};
|
|
if (state() == state_t::mousedown)
|
|
offset = geom::cast<float>(*st->action_offset);
|
|
|
|
gfx::color_rgba color = *st->fg_color;
|
|
if (state() == state_t::mouseover)
|
|
color = *st->highlight_color;
|
|
else if (state() == state_t::mousedown)
|
|
color = *st->action_color;
|
|
|
|
for (int b = 0; b < box_count; ++b)
|
|
p.draw_rect(boxes[b] + offset, color);
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
auto sc = element::size_constraints();
|
|
|
|
sc[0] &= geom::interval<float>{size(), std::numeric_limits<float>::infinity()};
|
|
sc[1] &= geom::interval<float>{size(), std::numeric_limits<float>::infinity()};
|
|
|
|
return sc;
|
|
}
|
|
|
|
private:
|
|
box_shape shape_;
|
|
|
|
int size() const
|
|
{
|
|
return *merged_own_style()->ref_height;
|
|
}
|
|
|
|
int outer_width() const
|
|
{
|
|
return *merged_own_style()->ref_height / 8;
|
|
}
|
|
|
|
int outer_margin() const
|
|
{
|
|
return *merged_own_style()->ref_height / 8;
|
|
}
|
|
};
|
|
|
|
struct toggle_button_impl
|
|
: checkbox
|
|
{
|
|
struct shape const & shape() const override
|
|
{
|
|
return shape_;
|
|
}
|
|
|
|
void reshape(geom::box<float, 2> const & bbox) override
|
|
{
|
|
shape_.box = bbox;
|
|
auto st = merged_own_style();
|
|
|
|
geom::vector offset{0.f, 0.f};
|
|
if (state() == state_t::mousedown || value())
|
|
offset = geom::cast<float>(*st->action_offset);
|
|
|
|
auto c = child_.get();
|
|
if (c) c->reshape(geom::shrink(bbox, geom::vector<float, 2>{*st->border_width + (*st->inner_margin)[0], *st->border_width + (*st->inner_margin)[1]}) + offset);
|
|
}
|
|
|
|
void on_state_changed(state_t old) override
|
|
{
|
|
checkbox::on_state_changed(old);
|
|
|
|
gfx::color_rgba color{0, 0, 0, 0};
|
|
|
|
switch (state()) {
|
|
case state_t::mouseover:
|
|
color = {255, 255, 255, 63};
|
|
break;
|
|
case state_t::mousedown:
|
|
color = {0, 0, 0, 63};
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (value())
|
|
color = {0, 0, 0, 63};
|
|
|
|
if (icon())
|
|
icon()->set_color(color);
|
|
}
|
|
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
if (!st) return;
|
|
|
|
if (st->shadow_offset != geom::vector{0, 0})
|
|
p.draw_rect(shape_.box + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
|
|
|
|
auto offset = geom::vector{0.f, 0.f};
|
|
if (state() == state_t::mousedown || value())
|
|
offset = geom::cast<float>(*st->action_offset);
|
|
|
|
if (st->border_width > 0)
|
|
p.draw_rect(shape_.box + offset, *st->border_color);
|
|
|
|
gfx::color_rgba color = *st->fg_color;
|
|
if (state() == state_t::mouseover)
|
|
color = *st->highlight_color;
|
|
else if (state() == state_t::mousedown || value())
|
|
color = *st->action_color;
|
|
p.draw_rect(geom::shrink(shape_.box, 1.f * (*st->border_width)) + offset, color);
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
auto sc = element::size_constraints();
|
|
|
|
if (child_)
|
|
{
|
|
auto csc = child_->size_constraints();
|
|
sc[0].min = csc[0].min;
|
|
sc[1].min = csc[1].min;
|
|
}
|
|
|
|
if (auto st = merged_own_style())
|
|
{
|
|
sc[0] += 2.f * (*st->border_width);
|
|
sc[1] += 2.f * (*st->border_width);
|
|
|
|
sc += 2.f * geom::cast<float>(*st->inner_margin);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
geom::interval<float> width_constraints(float height) const override
|
|
{
|
|
auto wc = element::width_constraints(height);
|
|
|
|
auto st = merged_own_style();
|
|
|
|
float extra = 2.f * (*st->border_width) + 2.f * geom::cast<float>(*st->inner_margin)[0];
|
|
|
|
if (child_)
|
|
{
|
|
auto cwc = child_->width_constraints(height - extra);
|
|
wc.min = cwc.min;
|
|
}
|
|
|
|
wc += extra;
|
|
|
|
return wc;
|
|
}
|
|
|
|
geom::interval<float> height_constraints(float width) const override
|
|
{
|
|
auto hc = element::height_constraints(width);
|
|
|
|
auto st = merged_own_style();
|
|
|
|
float extra = 2.f * (*st->border_width) + 2.f * geom::cast<float>(*st->inner_margin)[1];
|
|
|
|
if (child_)
|
|
{
|
|
auto chc = child_->height_constraints(width - extra);
|
|
hc.min = chc.min;
|
|
}
|
|
|
|
hc += extra;
|
|
|
|
return hc;
|
|
}
|
|
|
|
private:
|
|
box_shape shape_;
|
|
};
|
|
|
|
struct slider_impl
|
|
: slider
|
|
{
|
|
struct shape const & shape() const override { return shape_; }
|
|
|
|
void reshape(geom::box<float, 2> const & bbox) override
|
|
{
|
|
shape_.box = bbox;
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
static float const inf = std::numeric_limits<float>::infinity();
|
|
return {{{button_width(), inf}, {button_height(), inf}}};
|
|
}
|
|
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
|
|
geom::box<float, 2> ab;
|
|
ab[0] = shape_.box[0];
|
|
ab[1] = geom::expand(geom::interval<float>::singleton(shape_.box[1].center()), axis_width() / 2.f);
|
|
|
|
gfx::color_rgba c = *st->fg_color;
|
|
if (state() == state_t::mouseover)
|
|
c = *st->highlight_color;
|
|
else if (state() == state_t::mousedown)
|
|
c = *st->action_color;
|
|
|
|
auto const r = slider_range();
|
|
|
|
float x = geom::lerp(r, geom::unlerp<float>(geom::cast<float>(value_range()), value()));
|
|
|
|
geom::box<float, 2> sb;
|
|
sb[0] = geom::expand(geom::interval<float>::singleton(x), button_width() / 2.f);
|
|
sb[1] = geom::expand(geom::interval<float>::singleton(shape_.box[1].center()), button_height() / 2.f);
|
|
|
|
if (*st->shadow_offset != geom::vector{0, 0})
|
|
{
|
|
auto off = geom::cast<float>(*st->shadow_offset);
|
|
p.draw_rect(ab + off, *st->shadow_color);
|
|
p.draw_rect(sb + off, *st->shadow_color);
|
|
}
|
|
|
|
p.draw_rect(ab, *st->axis_color);
|
|
if (*st->border_width != 0)
|
|
p.draw_rect(sb, *st->border_color);
|
|
p.draw_rect(geom::shrink(sb, 1.f * (*st->border_width)), c);
|
|
}
|
|
|
|
protected:
|
|
|
|
geom::interval<float> slider_range() const override
|
|
{
|
|
return geom::shrink(shape_.box[0], button_width() / 2.f);
|
|
}
|
|
|
|
private:
|
|
box_shape shape_;
|
|
|
|
int button_width() const
|
|
{
|
|
auto st = merged_own_style();
|
|
return *st->ref_height / 3;
|
|
}
|
|
|
|
int button_height() const
|
|
{
|
|
auto st = merged_own_style();
|
|
return *st->ref_height;
|
|
}
|
|
|
|
int axis_width() const
|
|
{
|
|
auto st = merged_own_style();
|
|
return *st->ref_height / 5;
|
|
}
|
|
};
|
|
|
|
struct arrow_button_impl
|
|
: button
|
|
{
|
|
arrow_button_impl(int direction)
|
|
: direction_{direction}
|
|
{}
|
|
|
|
std::shared_ptr<element> set_child(std::shared_ptr<element>) override
|
|
{
|
|
throw std::runtime_error("default arrow button doesn't support children");
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
auto b = button::size_constraints();
|
|
|
|
auto st = merged_own_style();
|
|
b[0].min = *st->ref_height / 2.f;
|
|
b[1].min = *st->ref_height / 2.f;
|
|
|
|
return b;
|
|
}
|
|
|
|
struct shape const & shape() const override
|
|
{
|
|
return shape_;
|
|
}
|
|
|
|
void reshape(geom::box<float, 2> const & box) override
|
|
{
|
|
shape_.box = box;
|
|
|
|
switch (direction_)
|
|
{
|
|
case 0:
|
|
triangle_[0] = box.corner(0.f, 1.f);
|
|
triangle_[1] = box.corner(1.f, 1.f);
|
|
triangle_[2] = box.corner(0.5f, 0.f);
|
|
break;
|
|
case 1:
|
|
triangle_[0] = box.corner(0.f, 0.f);
|
|
triangle_[1] = box.corner(1.f, 0.f);
|
|
triangle_[2] = box.corner(0.5f, 1.f);
|
|
break;
|
|
case 2:
|
|
triangle_[0] = box.corner(1.f, 0.f);
|
|
triangle_[1] = box.corner(1.f, 1.f);
|
|
triangle_[2] = box.corner(0.f, 0.5f);
|
|
break;
|
|
case 3:
|
|
triangle_[0] = box.corner(0.f, 0.f);
|
|
triangle_[1] = box.corner(0.f, 1.f);
|
|
triangle_[2] = box.corner(1.f, 0.5f);
|
|
break;
|
|
default:
|
|
throw std::runtime_error("Unknown arrow button direction");
|
|
}
|
|
|
|
if (geom::volume(triangle_[0], triangle_[1], triangle_[2]) < 0.f)
|
|
std::swap(triangle_[1], triangle_[2]);
|
|
}
|
|
|
|
void draw(painter &p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
|
|
if (*st->shadow_offset != geom::vector{0, 0})
|
|
p.draw_triangle(triangle_ + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
|
|
|
|
geom::vector off{0.f, 0.f};
|
|
if (state() == state_t::mousedown)
|
|
off = geom::cast<float>(*st->action_offset);
|
|
|
|
gfx::color_rgba color = *st->fg_color;
|
|
if (state() == state_t::mouseover)
|
|
color = *st->highlight_color;
|
|
else if (state() == state_t::mousedown)
|
|
color = *st->action_color;
|
|
p.draw_triangle(triangle_ + off, color);
|
|
}
|
|
|
|
private:
|
|
int const direction_;
|
|
box_shape shape_;
|
|
geom::triangle<geom::point<float, 2>> triangle_;
|
|
};
|
|
|
|
struct spinbox_impl
|
|
: spinbox
|
|
{
|
|
spinbox_impl()
|
|
{
|
|
auto layout = std::make_shared<grid_layout>();
|
|
layout->set_row_count(2);
|
|
|
|
auto inc_button = std::make_shared<arrow_button_impl>(0);
|
|
auto dec_button = std::make_shared<arrow_button_impl>(1);
|
|
|
|
inc_button->on_click([this]{
|
|
inc();
|
|
});
|
|
|
|
dec_button->on_click([this]{
|
|
dec();
|
|
});
|
|
|
|
layout->set(0, 0, inc_button);
|
|
layout->set(1, 0, dec_button);
|
|
layout->set_outer_margin(false);
|
|
|
|
child_ = layout;
|
|
children_range_[0] = child_.get();
|
|
child_->set_parent(this);
|
|
|
|
inc_button_ = inc_button.get();
|
|
dec_button_ = dec_button.get();
|
|
}
|
|
|
|
geom::box<float, 2> size_constraints() const override
|
|
{
|
|
return child_->size_constraints();
|
|
}
|
|
|
|
children_range children() const override
|
|
{
|
|
return {children_range_};
|
|
}
|
|
|
|
struct shape const & shape() const override
|
|
{
|
|
return child_->shape();
|
|
}
|
|
|
|
void reshape(geom::box<float, 2> const & box) override
|
|
{
|
|
child_->reshape(box);
|
|
}
|
|
|
|
void draw(painter &) const override
|
|
{}
|
|
|
|
button * dec_button() const override { return dec_button_; }
|
|
button * inc_button() const override { return inc_button_; }
|
|
|
|
~spinbox_impl()
|
|
{
|
|
release_children();
|
|
}
|
|
|
|
private:
|
|
std::shared_ptr<element> child_;
|
|
element * children_range_[1] {nullptr};
|
|
|
|
button * inc_button_;
|
|
button * dec_button_;
|
|
};
|
|
|
|
struct scroller_impl
|
|
: scroller
|
|
{
|
|
void draw(struct painter & painter) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
|
|
auto draw_box = [&](geom::box<float, 2> box, state_t state, float position, int dimension)
|
|
{
|
|
float h = height();
|
|
|
|
box[dimension].max -= h;
|
|
float origin = geom::lerp(box[dimension], position);
|
|
box[dimension] = {origin, origin + h};
|
|
|
|
gfx::color_rgba color;
|
|
if (state == state_t::normal)
|
|
color = *st->fg_color;
|
|
else if (state == state_t::mouseover)
|
|
color = *st->highlight_color;
|
|
else
|
|
{
|
|
color = *st->action_color;
|
|
box += geom::cast<float>(*st->action_offset);
|
|
}
|
|
|
|
if (*st->shadow_offset != geom::vector{0, 0})
|
|
painter.draw_rect(box + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
|
|
painter.draw_rect(box, color);
|
|
};
|
|
|
|
if (horizontal_scroll())
|
|
draw_box(horizontal_box(), horizontal_state_, position(direction::horizontal), 0);
|
|
|
|
if (vertical_scroll())
|
|
draw_box(vertical_box(), vertical_state_, position(direction::vertical), 1);
|
|
|
|
scroller::draw(painter);
|
|
}
|
|
|
|
protected:
|
|
float width() const override
|
|
{
|
|
return 10.f;
|
|
}
|
|
|
|
float height() const
|
|
{
|
|
return 50.f;
|
|
}
|
|
};
|
|
|
|
struct selector_impl
|
|
: selector
|
|
{
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
|
|
auto bbox = shape().bbox();
|
|
|
|
if (st->shadow_offset)
|
|
p.draw_rect(bbox + geom::cast<float>(*st->shadow_offset), *st->shadow_color);
|
|
|
|
p.draw_rect(bbox, *st->fg_color);
|
|
|
|
if (auto i = selected())
|
|
p.draw_rect(item_box(*i), *st->highlight_color);
|
|
|
|
for (int i = 0; i < size(); ++i)
|
|
{
|
|
if (submenu(i))
|
|
{
|
|
auto box = item_box(i);
|
|
|
|
auto c = box.corner(1.f, 0.5f);
|
|
c[0] -= (*st->inner_margin)[0];
|
|
|
|
int w = st->font->size()[1];
|
|
|
|
auto p0 = c;
|
|
p0[0] -= w / 2.f;
|
|
p0[1] -= w / 2.f;
|
|
|
|
auto p1 = c;
|
|
p1[0] -= w / 2.f;
|
|
p1[1] += w / 2.f;
|
|
|
|
auto sh = geom::cast<float>(*st->shadow_offset);
|
|
|
|
p.draw_triangle({p0 + sh, p1 + sh, c + sh}, *st->shadow_color);
|
|
p.draw_triangle({p0, p1, c}, *st->text_color);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
int submenu_extra() const override
|
|
{
|
|
auto st = merged_own_style();
|
|
return 2 * (*st->inner_margin)[0] + st->font->size()[1] / 2;
|
|
}
|
|
};
|
|
|
|
struct edit_impl
|
|
: edit
|
|
{
|
|
void draw(painter & p) const override
|
|
{
|
|
auto st = merged_own_style();
|
|
p.draw_rect(shape().bbox(), *st->action_color);
|
|
|
|
edit::draw(p);
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
struct default_element_factory::impl
|
|
{
|
|
std::shared_ptr<gfx::texture_2d> close_icon;
|
|
|
|
impl();
|
|
};
|
|
|
|
default_element_factory::impl::impl()
|
|
{
|
|
close_icon = std::make_shared<gfx::texture_2d>(gfx::texture_2d::from_pixmap(gfx::read_png(io::memory_istream{resources::cross_red_16x16_png.data})));
|
|
close_icon->nearest_filter();
|
|
}
|
|
|
|
default_element_factory::default_element_factory()
|
|
: pimpl_{make_impl()}
|
|
{}
|
|
|
|
default_element_factory::~default_element_factory() = default;
|
|
|
|
void default_element_factory::set_close_icon(gfx::pixmap_rgba const & icon)
|
|
{
|
|
impl().close_icon->load(icon);
|
|
}
|
|
|
|
std::shared_ptr<button> default_element_factory::make_button()
|
|
{
|
|
return std::make_shared<button_impl>();
|
|
}
|
|
|
|
std::shared_ptr<frame> default_element_factory::make_frame()
|
|
{
|
|
return std::make_shared<frame_impl>();
|
|
}
|
|
|
|
std::shared_ptr<window> default_element_factory::make_window(std::string caption)
|
|
{
|
|
auto r = std::make_shared<window_impl>(impl().close_icon);
|
|
r->setup_close();
|
|
r->caption()->set_text(std::move(caption));
|
|
return r;
|
|
}
|
|
|
|
std::shared_ptr<spinbox> default_element_factory::make_spinbox()
|
|
{
|
|
return std::make_shared<spinbox_impl>();
|
|
}
|
|
|
|
std::shared_ptr<checkbox> default_element_factory::make_checkbox(bool value)
|
|
{
|
|
auto c = std::make_shared<checkbox_impl>();
|
|
c->set_value(value);
|
|
return c;
|
|
}
|
|
|
|
std::shared_ptr<checkbox> default_element_factory::make_toggle_button()
|
|
{
|
|
return std::make_shared<toggle_button_impl>();
|
|
}
|
|
|
|
std::shared_ptr<slider> default_element_factory::make_slider()
|
|
{
|
|
return std::make_shared<slider_impl>();
|
|
}
|
|
|
|
std::shared_ptr<button> default_element_factory::make_arrow_button(int direction)
|
|
{
|
|
return std::make_shared<arrow_button_impl>(direction);
|
|
}
|
|
|
|
std::shared_ptr<scroller> default_element_factory::make_scroller()
|
|
{
|
|
return std::make_shared<scroller_impl>();
|
|
}
|
|
|
|
std::shared_ptr<selector> default_element_factory::make_selector()
|
|
{
|
|
return std::make_shared<selector_impl>();
|
|
}
|
|
|
|
std::shared_ptr<edit> default_element_factory::make_edit()
|
|
{
|
|
return std::make_shared<edit_impl>();
|
|
}
|
|
|
|
}
|