khodowany
544 lines
17 KiB
C++
544 lines
17 KiB
C++
#include <luma/window.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <expected>
|
|
#include <functional>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <modulus.hpp>
|
|
#include <modulus/log.hpp>
|
|
|
|
#include <luma/detail/errors.hpp>
|
|
#include <luma/geometry.hpp>
|
|
#include <luma/input.hpp>
|
|
#include <luma/render.hpp>
|
|
#include <luma/theme.hpp>
|
|
|
|
|
|
namespace {
|
|
|
|
class scope_exit {
|
|
public:
|
|
explicit scope_exit(std::function<void()> action);
|
|
scope_exit(scope_exit const &) = delete;
|
|
auto operator=(scope_exit const &) -> scope_exit & = delete;
|
|
~scope_exit();
|
|
private:
|
|
std::function<void()> action_{};
|
|
};
|
|
|
|
constexpr auto window_title_vertical_padding = std::float32_t{6.0F};
|
|
|
|
auto finite_rect(luma::rect value) -> std::bool_t {
|
|
return std::isfinite(value.x) && std::isfinite(value.y) && std::isfinite(value.width) && std::isfinite(value.height) && value.width >= 0.0F && value.height >= 0.0F;
|
|
}
|
|
|
|
auto title_height(luma::window_options const &options, std::float32_t line_height) -> std::float32_t {
|
|
if (!options.decorated) {
|
|
return {};
|
|
}
|
|
auto desired = line_height + window_title_vertical_padding * 2.0F;
|
|
return std::min(desired, options.bounds.height);
|
|
}
|
|
|
|
auto title_bounds(luma::window_options const &options, std::float32_t line_height) -> luma::rect {
|
|
return {
|
|
.x = options.bounds.x,
|
|
.y = options.bounds.y,
|
|
.width = options.bounds.width,
|
|
.height = title_height(options, line_height),
|
|
};
|
|
}
|
|
|
|
auto client_bounds(luma::window_options const &options, std::float32_t line_height) -> luma::rect {
|
|
if (!options.decorated) {
|
|
return options.bounds;
|
|
}
|
|
auto title = title_bounds(options, line_height);
|
|
return {
|
|
.x = options.bounds.x,
|
|
.y = options.bounds.y + title.height,
|
|
.width = options.bounds.width,
|
|
.height = std::max(std::float32_t{}, options.bounds.height - title.height),
|
|
};
|
|
}
|
|
|
|
template <typename VALUE>
|
|
auto invalid(std::string message) -> std::expected<VALUE, modulus::error> {
|
|
return luma::detail::fail<VALUE>(luma::detail::error_invalid_argument, std::move(message));
|
|
}
|
|
|
|
template <typename VALUE>
|
|
auto unavailable(std::string message) -> std::expected<VALUE, modulus::error> {
|
|
return luma::detail::fail<VALUE>(luma::detail::error_unavailable, std::move(message));
|
|
}
|
|
|
|
auto make_event(luma::touch_event const &event, luma::touch_point point) -> luma::touch_event {
|
|
return {
|
|
.points = {point},
|
|
.time = event.time,
|
|
};
|
|
}
|
|
|
|
scope_exit::scope_exit(std::function<void()> action)
|
|
: action_{std::move(action)} {}
|
|
|
|
scope_exit::~scope_exit() {
|
|
if (action_) {
|
|
action_();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
luma::window::window(std::uint64_t id, luma::window_options options, std::unique_ptr<luma::control> content)
|
|
: id_{id}, options_{std::move(options)}, content_{std::move(content)} {
|
|
assert(id_ != 0);
|
|
assert(finite_rect(options_.bounds));
|
|
assert(content_ != nullptr);
|
|
}
|
|
|
|
auto luma::window::id() const -> std::uint64_t {
|
|
assert(id_ != 0);
|
|
return id_;
|
|
}
|
|
|
|
auto luma::window::options() const -> luma::window_options const & {
|
|
assert(finite_rect(options_.bounds));
|
|
return options_;
|
|
}
|
|
|
|
auto luma::window::set_bounds(luma::rect bounds) -> std::expected<void, modulus::error> {
|
|
if (!finite_rect(bounds)) {
|
|
return invalid<void>("window bounds must be finite and non-negative");
|
|
}
|
|
options_.bounds = bounds;
|
|
return {};
|
|
}
|
|
|
|
auto luma::window::set_visible(std::bool_t value) -> void {
|
|
options_.visible = value;
|
|
}
|
|
|
|
auto luma::window::visible() const -> std::bool_t {
|
|
return options_.visible;
|
|
}
|
|
|
|
auto luma::window::content() -> luma::control * {
|
|
assert(content_ != nullptr);
|
|
return content_.get();
|
|
}
|
|
|
|
auto luma::window::content() const -> luma::control const * {
|
|
assert(content_ != nullptr);
|
|
return content_.get();
|
|
}
|
|
|
|
auto luma::window_manager::open(luma::window_options options, std::unique_ptr<luma::control> content) -> std::expected<std::uint64_t, modulus::error> {
|
|
if (next_id_ == 0) {
|
|
return unavailable<std::uint64_t>("window id space exhausted");
|
|
}
|
|
if (!finite_rect(options.bounds)) {
|
|
return invalid<std::uint64_t>("window bounds must be finite and non-negative");
|
|
}
|
|
if (content == nullptr) {
|
|
return invalid<std::uint64_t>("window content must not be null");
|
|
}
|
|
content->bind_layout_invalidator(layout_invalidator());
|
|
auto id = next_id_++;
|
|
auto created = std::unique_ptr<luma::window>{
|
|
new luma::window{
|
|
id,
|
|
std::move(options),
|
|
std::move(content),
|
|
},
|
|
};
|
|
if (mutation_depth_ > 0) {
|
|
pending_operations_.push_back({
|
|
.kind = luma::window_manager::pending_kind::OPEN,
|
|
.id = id,
|
|
.window = std::move(created),
|
|
});
|
|
} else {
|
|
windows_.push_back(std::move(created));
|
|
}
|
|
modulus::log_debug("luma window opened: " + std::to_string(id));
|
|
return modulus::success(id);
|
|
}
|
|
|
|
auto luma::window_manager::close(std::uint64_t id) -> std::expected<void, modulus::error> {
|
|
if (id == 0) {
|
|
return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
|
|
}
|
|
if (!contains_effective(id)) {
|
|
return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
|
|
}
|
|
if (mutation_depth_ > 0) {
|
|
pending_operations_.push_back({
|
|
.kind = luma::window_manager::pending_kind::CLOSE,
|
|
.id = id,
|
|
});
|
|
} else {
|
|
close_now(id);
|
|
}
|
|
modulus::log_debug("luma window close requested: " + std::to_string(id));
|
|
return {};
|
|
}
|
|
|
|
auto luma::window_manager::bring_to_front(std::uint64_t id) -> std::expected<void, modulus::error> {
|
|
if (id == 0) {
|
|
return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
|
|
}
|
|
if (!contains_effective(id)) {
|
|
return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
|
|
}
|
|
if (mutation_depth_ > 0) {
|
|
pending_operations_.push_back({
|
|
.kind = luma::window_manager::pending_kind::BRING_TO_FRONT,
|
|
.id = id,
|
|
});
|
|
} else {
|
|
bring_to_front_now(id);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
auto luma::window_manager::set_bounds(std::uint64_t id, luma::rect bounds) -> std::expected<void, modulus::error> {
|
|
if (id == 0) {
|
|
return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
|
|
}
|
|
if (!finite_rect(bounds)) {
|
|
return invalid<void>("window bounds must be finite and non-negative");
|
|
}
|
|
if (!contains_effective(id)) {
|
|
return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
|
|
}
|
|
if (mutation_depth_ > 0) {
|
|
pending_operations_.push_back({
|
|
.kind = luma::window_manager::pending_kind::SET_BOUNDS,
|
|
.id = id,
|
|
.bounds = bounds,
|
|
});
|
|
} else {
|
|
set_bounds_now(id, bounds);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
auto luma::window_manager::set_visible(std::uint64_t id, std::bool_t visible) -> std::expected<void, modulus::error> {
|
|
if (id == 0) {
|
|
return luma::detail::fail<void>(luma::detail::error_invalid_argument, "window id must not be zero");
|
|
}
|
|
if (!contains_effective(id)) {
|
|
return luma::detail::fail<void>(luma::detail::error_not_found, "window not found");
|
|
}
|
|
if (mutation_depth_ > 0) {
|
|
pending_operations_.push_back({
|
|
.kind = luma::window_manager::pending_kind::SET_VISIBLE,
|
|
.id = id,
|
|
.visible = visible,
|
|
});
|
|
} else {
|
|
set_visible_now(id, visible);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
auto luma::window_manager::find(std::uint64_t id) -> luma::window * {
|
|
if (id == 0) {
|
|
return nullptr;
|
|
}
|
|
auto found = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; });
|
|
return found == windows_.end() ? nullptr : found->get();
|
|
}
|
|
|
|
auto luma::window_manager::clear() -> void {
|
|
if (mutation_depth_ > 0) {
|
|
pending_operations_.push_back({
|
|
.kind = luma::window_manager::pending_kind::CLEAR,
|
|
});
|
|
return;
|
|
}
|
|
windows_.clear();
|
|
active_touches_.clear();
|
|
}
|
|
|
|
auto luma::window_manager::measure(luma::draw_context &context, luma::theme const &theme, luma::constraints limits) -> luma::size {
|
|
title_line_height_ = theme.body.line_height;
|
|
++mutation_depth_;
|
|
auto guard = scope_exit{[this] {
|
|
assert(mutation_depth_ > 0);
|
|
--mutation_depth_;
|
|
apply_pending_operations();
|
|
}};
|
|
for (auto &window : windows_) {
|
|
assert(window != nullptr);
|
|
if (!window->visible()) {
|
|
continue;
|
|
}
|
|
assert(window->content() != nullptr);
|
|
auto client = client_bounds(window->options(), title_line_height_);
|
|
window->content()->measure(context, theme, {
|
|
.min = {},
|
|
.max = {
|
|
.width = client.width,
|
|
.height = client.height,
|
|
},
|
|
});
|
|
}
|
|
return luma::clamp(limits.max, limits);
|
|
}
|
|
|
|
auto luma::window_manager::arrange(luma::rect bounds) -> void {
|
|
assert(finite_rect(bounds));
|
|
++mutation_depth_;
|
|
auto guard = scope_exit{[this] {
|
|
assert(mutation_depth_ > 0);
|
|
--mutation_depth_;
|
|
apply_pending_operations();
|
|
}};
|
|
luma::control::arrange(bounds);
|
|
for (auto &window : windows_) {
|
|
assert(window != nullptr);
|
|
if (window->visible()) {
|
|
assert(window->content() != nullptr);
|
|
window->content()->arrange(client_bounds(window->options(), title_line_height_));
|
|
}
|
|
}
|
|
}
|
|
|
|
auto luma::window_manager::draw(luma::draw_context &context, luma::theme const &theme) const -> void {
|
|
title_line_height_ = theme.body.line_height;
|
|
++mutation_depth_;
|
|
auto guard = scope_exit{[this] {
|
|
assert(mutation_depth_ > 0);
|
|
--mutation_depth_;
|
|
apply_pending_operations();
|
|
}};
|
|
for (auto const &window : windows_) {
|
|
assert(window != nullptr);
|
|
if (!window->visible()) {
|
|
continue;
|
|
}
|
|
auto bounds = window->options().bounds;
|
|
auto client = client_bounds(window->options(), title_line_height_);
|
|
context.fill_rect(bounds, theme.surface);
|
|
assert(window->content() != nullptr);
|
|
context.push_clip(client);
|
|
window->content()->draw(context, theme);
|
|
context.pop_clip();
|
|
if (window->options().decorated) {
|
|
auto title = title_bounds(window->options(), title_line_height_);
|
|
context.fill_rect(title, theme.surface_active);
|
|
context.draw_text(window->options().title, {
|
|
.x = title.x + 8.0F,
|
|
.y = title.y + window_title_vertical_padding,
|
|
},
|
|
theme.body, theme.text);
|
|
}
|
|
context.stroke_rect(bounds, 1.0F, theme.border);
|
|
}
|
|
}
|
|
|
|
auto luma::window_manager::handle_touch(luma::touch_event const &event) -> std::bool_t {
|
|
if (event.points.empty()) {
|
|
return false;
|
|
}
|
|
++mutation_depth_;
|
|
auto guard = scope_exit{[this] {
|
|
assert(mutation_depth_ > 0);
|
|
--mutation_depth_;
|
|
apply_pending_operations();
|
|
}};
|
|
auto handled = false;
|
|
for (auto const &point : event.points) {
|
|
if (auto captured = active_touches_.find(point.id); captured != active_touches_.end()) {
|
|
auto const window_id = captured->second;
|
|
auto *captured_window = find(window_id);
|
|
auto const captured_visible = captured_window != nullptr && captured_window->visible();
|
|
if (captured_visible) {
|
|
assert(captured_window->content() != nullptr);
|
|
auto single = make_event(event, point);
|
|
static_cast<void>(captured_window->content()->handle_touch(single));
|
|
handled = true;
|
|
}
|
|
if (point.phase == luma::touch_phase::UP || point.phase == luma::touch_phase::CANCEL || !captured_visible) {
|
|
active_touches_.erase(point.id);
|
|
}
|
|
continue;
|
|
}
|
|
for (auto current = windows_.rbegin(); current != windows_.rend(); ++current) {
|
|
assert(*current != nullptr);
|
|
if (!(*current)->visible()) {
|
|
continue;
|
|
}
|
|
if (luma::contains((*current)->options().bounds, point.position)) {
|
|
auto consumed = false;
|
|
if (luma::contains(client_bounds((*current)->options(), title_line_height_), point.position)) {
|
|
assert((*current)->content() != nullptr);
|
|
auto single = make_event(event, point);
|
|
consumed = (*current)->content()->handle_touch(single);
|
|
if (point.phase == luma::touch_phase::DOWN && (consumed || (*current)->options().modal)) {
|
|
active_touches_[point.id] = (*current)->id();
|
|
}
|
|
}
|
|
handled = true;
|
|
break;
|
|
}
|
|
if ((*current)->options().modal) {
|
|
handled = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return handled;
|
|
}
|
|
|
|
auto luma::window_manager::contains_effective(std::uint64_t id) const -> std::bool_t {
|
|
if (id == 0) {
|
|
return false;
|
|
}
|
|
auto exists = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; }) != windows_.end();
|
|
for (auto const &operation : pending_operations_) {
|
|
switch (operation.kind) {
|
|
case luma::window_manager::pending_kind::OPEN:
|
|
if (operation.id == id) {
|
|
exists = true;
|
|
}
|
|
break;
|
|
case luma::window_manager::pending_kind::CLOSE:
|
|
if (operation.id == id) {
|
|
exists = false;
|
|
}
|
|
break;
|
|
case luma::window_manager::pending_kind::BRING_TO_FRONT:
|
|
case luma::window_manager::pending_kind::SET_BOUNDS:
|
|
case luma::window_manager::pending_kind::SET_VISIBLE:
|
|
break;
|
|
case luma::window_manager::pending_kind::CLEAR:
|
|
exists = false;
|
|
break;
|
|
}
|
|
}
|
|
return exists;
|
|
}
|
|
|
|
auto luma::window_manager::close_now(std::uint64_t id) const -> void {
|
|
auto found = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; });
|
|
if (found == windows_.end()) {
|
|
return;
|
|
}
|
|
auto const closed_id = (*found)->id();
|
|
for (auto current = active_touches_.begin(); current != active_touches_.end();) {
|
|
if (current->second == closed_id) {
|
|
current = active_touches_.erase(current);
|
|
} else {
|
|
++current;
|
|
}
|
|
}
|
|
windows_.erase(found);
|
|
}
|
|
|
|
auto luma::window_manager::bring_to_front_now(std::uint64_t id) const -> void {
|
|
auto found = std::find_if(windows_.begin(), windows_.end(), [id](auto const &window) { return window && window->id() == id; });
|
|
if (found == windows_.end()) {
|
|
return;
|
|
}
|
|
auto moved = std::move(*found);
|
|
windows_.erase(found);
|
|
windows_.push_back(std::move(moved));
|
|
}
|
|
|
|
auto luma::window_manager::set_bounds_now(std::uint64_t id, luma::rect bounds) const -> void {
|
|
auto *window = const_cast<luma::window_manager *>(this)->find(id);
|
|
if (window != nullptr) {
|
|
static_cast<void>(window->set_bounds(bounds));
|
|
}
|
|
}
|
|
|
|
auto luma::window_manager::set_visible_now(std::uint64_t id, std::bool_t visible) const -> void {
|
|
auto *window = const_cast<luma::window_manager *>(this)->find(id);
|
|
if (window != nullptr) {
|
|
window->set_visible(visible);
|
|
}
|
|
}
|
|
|
|
auto luma::window_manager::apply_pending_operations() const -> void {
|
|
if (mutation_depth_ != 0 || pending_operations_.empty()) {
|
|
return;
|
|
}
|
|
auto pending = std::vector<luma::window_manager::pending_operation>{};
|
|
pending.swap(pending_operations_);
|
|
for (auto &operation : pending) {
|
|
switch (operation.kind) {
|
|
case luma::window_manager::pending_kind::OPEN:
|
|
if (operation.window) {
|
|
windows_.push_back(std::move(operation.window));
|
|
}
|
|
break;
|
|
case luma::window_manager::pending_kind::CLOSE:
|
|
close_now(operation.id);
|
|
break;
|
|
case luma::window_manager::pending_kind::BRING_TO_FRONT:
|
|
bring_to_front_now(operation.id);
|
|
break;
|
|
case luma::window_manager::pending_kind::SET_BOUNDS:
|
|
set_bounds_now(operation.id, operation.bounds);
|
|
break;
|
|
case luma::window_manager::pending_kind::SET_VISIBLE:
|
|
set_visible_now(operation.id, operation.visible);
|
|
break;
|
|
case luma::window_manager::pending_kind::CLEAR:
|
|
windows_.clear();
|
|
active_touches_.clear();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
auto luma::window_manager::invalidate_layout() -> void {
|
|
++mutation_depth_;
|
|
auto guard = scope_exit{[this] {
|
|
assert(mutation_depth_ > 0);
|
|
--mutation_depth_;
|
|
apply_pending_operations();
|
|
}};
|
|
auto controls = std::vector<luma::control *>{};
|
|
controls.reserve(windows_.size() + pending_operations_.size());
|
|
for (auto &window : windows_) {
|
|
assert(window != nullptr);
|
|
assert(window->content() != nullptr);
|
|
controls.push_back(window->content());
|
|
}
|
|
for (auto &operation : pending_operations_) {
|
|
if (operation.window) {
|
|
assert(operation.window->content() != nullptr);
|
|
controls.push_back(operation.window->content());
|
|
}
|
|
}
|
|
for (auto *control : controls) {
|
|
assert(control != nullptr);
|
|
control->invalidate_layout();
|
|
}
|
|
}
|
|
|
|
auto luma::window_manager::bind_layout_invalidator(std::function<void()> invalidator) -> void {
|
|
luma::control::bind_layout_invalidator(invalidator);
|
|
for (auto &window : windows_) {
|
|
assert(window != nullptr);
|
|
assert(window->content() != nullptr);
|
|
window->content()->bind_layout_invalidator(invalidator);
|
|
}
|
|
for (auto &operation : pending_operations_) {
|
|
if (operation.window) {
|
|
assert(operation.window->content() != nullptr);
|
|
operation.window->content()->bind_layout_invalidator(invalidator);
|
|
}
|
|
}
|
|
}
|