mirror of
https://github.com/mirkobrombin/raven.git
synced 2026-11-03 21:46:32 +00:00
616 lines
22 KiB
C++
616 lines
22 KiB
C++
#include "windows.h"
|
|
#include "canvas.h"
|
|
#include "shapes.h"
|
|
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <stdexcept>
|
|
|
|
namespace raven {
|
|
|
|
#ifdef RAVEN_SKIA
|
|
|
|
using namespace paint;
|
|
|
|
namespace {
|
|
|
|
uint32_t message_time()
|
|
{
|
|
return uint32_t(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count());
|
|
}
|
|
|
|
constexpr uint32_t item_grayed = 3, item_checked = 8, type_separator = 0x800, type_radio = 0x200;
|
|
constexpr int32_t popup_border = 2, gutter = 22, arrow_width = 20, separator_height = 9;
|
|
|
|
bool is_enabled(const DesktopMenuItem &item)
|
|
{
|
|
return !(item.state & item_grayed) && !(item.type & type_separator);
|
|
}
|
|
|
|
// Label up to a tab, and the accelerator text after it.
|
|
std::pair<std::u16string, std::u16string> split_tab(std::u16string_view text)
|
|
{
|
|
const auto tab = text.find(u'\t');
|
|
return {std::u16string(text.substr(0, tab)), tab == text.npos ? std::u16string{} : std::u16string(text.substr(tab + 1))};
|
|
}
|
|
|
|
}
|
|
|
|
void NativeWindows::menu_render(MenuPopup &popup)
|
|
{
|
|
const auto *menu = objects.menu(popup.menu);
|
|
if (!menu)
|
|
return;
|
|
const auto color = [&](int index) { return rgb(objects.system_color(index)); };
|
|
Canvas canvas{std::vector<uint8_t>(size_t(popup.width) * size_t(popup.height) * 4), popup.width, popup.height};
|
|
if (themed()) {
|
|
menu_render_modern(popup, *menu, canvas);
|
|
popup.pixels = std::move(canvas.owned);
|
|
return;
|
|
}
|
|
canvas.fill({0, 0, popup.width, popup.height}, color(4));
|
|
canvas.edge({0, 0, popup.width, popup.height}, color(22), color(21), color(20), color(16));
|
|
auto &renderer = objects.text();
|
|
const auto metrics = renderer.metrics(interface_font());
|
|
for (size_t index = 0; index < menu->items.size() && index < popup.items.size(); ++index) {
|
|
const auto &item = menu->items[index];
|
|
const auto rect = popup.items[index];
|
|
if (item.type & type_separator) {
|
|
const int32_t y = rect.top + (rect.bottom - rect.top) / 2;
|
|
for (int32_t x = rect.left + 2; x < rect.right - 2; ++x) {
|
|
canvas.set(x, y - 1, color(16));
|
|
canvas.set(x, y, color(20));
|
|
}
|
|
continue;
|
|
}
|
|
const bool selected = popup.highlight && *popup.highlight == index;
|
|
if (selected)
|
|
canvas.fill(rect, color(13));
|
|
const bool enabled = is_enabled(item);
|
|
const auto ink = enabled ? color(selected ? 14 : 7) : color(17);
|
|
const auto [text, accelerator] = split_tab(item.text);
|
|
const auto [label, mnemonic] = menu_label(text);
|
|
const int32_t text_top = rect.top + (rect.bottom - rect.top - metrics.height) / 2;
|
|
draw_text(renderer, canvas, label, rect.left + gutter, text_top, ink, mnemonic);
|
|
if (!accelerator.empty()) {
|
|
const auto characters = printable(accelerator);
|
|
const auto width = renderer.extent(interface_font(), characters).width;
|
|
draw_text(renderer, canvas, accelerator, rect.right - arrow_width - width, text_top, ink);
|
|
}
|
|
const int32_t cy = (rect.top + rect.bottom) / 2;
|
|
if (item.state & item_checked) {
|
|
const int32_t cx = rect.left + 10;
|
|
if (item.type & type_radio) {
|
|
for (int32_t dy = -2; dy <= 2; ++dy)
|
|
for (int32_t dx = -2; dx <= 2; ++dx)
|
|
if (dx * dx + dy * dy <= 5)
|
|
canvas.set(cx + dx, cy + dy, ink);
|
|
} else {
|
|
for (int32_t step = 0; step < 3; ++step) {
|
|
canvas.set(cx - 3 + step, cy + step, ink);
|
|
canvas.set(cx - 3 + step, cy + step + 1, ink);
|
|
}
|
|
for (int32_t step = 0; step < 5; ++step) {
|
|
canvas.set(cx - 1 + step, cy + 2 - step, ink);
|
|
canvas.set(cx - 1 + step, cy + 3 - step, ink);
|
|
}
|
|
}
|
|
}
|
|
if (item.submenu) {
|
|
const int32_t ax = rect.right - 10;
|
|
for (int32_t step = 0; step < 4; ++step)
|
|
for (int32_t dy = -3 + step; dy <= 3 - step; ++dy)
|
|
canvas.set(ax + step, cy + dy, ink);
|
|
}
|
|
}
|
|
popup.pixels = std::move(canvas.owned);
|
|
}
|
|
|
|
// A Windows 11 menu: a light surface with a thin border, items highlighted on a rounded shape inset from the edges, thin separators,
|
|
// and the check, the radio dot and the submenu chevron drawn with antialiasing.
|
|
void NativeWindows::menu_render_modern(MenuPopup &popup, const DesktopMenu &menu, Canvas &canvas)
|
|
{
|
|
struct Surface {
|
|
Canvas &canvas;
|
|
void blend(int64_t x, int64_t y, uint32_t ink, double alpha)
|
|
{
|
|
if (x < 0 || y < 0 || x >= canvas.width || y >= canvas.height)
|
|
return;
|
|
const auto *pixel = canvas.pixels + (size_t(y) * size_t(canvas.width) + size_t(x)) * 4;
|
|
const uint32_t below = uint32_t(pixel[2]) | uint32_t(pixel[1]) << 8 | uint32_t(pixel[0]) << 16;
|
|
canvas.set(int32_t(x), int32_t(y), alpha >= 0.998 ? ink : shapes::mix(below, ink, alpha));
|
|
}
|
|
} surface{canvas};
|
|
shapes::Shapes<Surface> shapes{surface};
|
|
canvas.fill({0, 0, popup.width, popup.height}, 0xf9f9f9);
|
|
shapes.rounded(0, 0, popup.width, popup.height, 0, std::nullopt, 0xd6d6d6);
|
|
auto &renderer = objects.text();
|
|
const auto metrics = renderer.metrics(interface_font());
|
|
for (size_t index = 0; index < menu.items.size() && index < popup.items.size(); ++index) {
|
|
const auto &item = menu.items[index];
|
|
const auto rect = popup.items[index];
|
|
if (item.type & type_separator) {
|
|
const int32_t y = rect.top + (rect.bottom - rect.top) / 2;
|
|
canvas.fill({rect.left + 4, y, rect.right - 4, y + 1}, 0xe5e5e5);
|
|
continue;
|
|
}
|
|
const bool selected = popup.highlight && *popup.highlight == index;
|
|
const bool enabled = is_enabled(item);
|
|
if (selected)
|
|
shapes.rounded(rect.left + 3, rect.top + 1, rect.right - 3, rect.bottom - 1, 4, enabled ? 0xefefef : 0xf4f4f4, std::nullopt);
|
|
const uint32_t ink = enabled ? 0x1a1a1a : 0xa0a0a0;
|
|
const auto [text, accelerator] = split_tab(item.text);
|
|
const auto [label, mnemonic] = menu_label(text);
|
|
const int32_t text_top = rect.top + (rect.bottom - rect.top - metrics.height) / 2;
|
|
draw_text(renderer, canvas, label, rect.left + gutter + 6, text_top, ink, mnemonic);
|
|
if (!accelerator.empty()) {
|
|
const auto width = renderer.extent(interface_font(), printable(accelerator)).width;
|
|
draw_text(renderer, canvas, accelerator, rect.right - arrow_width - width, text_top, enabled ? 0x606060 : 0xa0a0a0);
|
|
}
|
|
const double cy = (rect.top + rect.bottom) / 2.0, cx = rect.left + 14.0;
|
|
if (item.state & item_checked) {
|
|
if (item.type & type_radio) {
|
|
shapes.circle(cx, cy, 3, ink, std::nullopt);
|
|
} else {
|
|
shapes.segment(cx - 4, cy, cx - 1.5, cy + 3, 1.2, ink);
|
|
shapes.segment(cx - 1.5, cy + 3, cx + 4, cy - 3.5, 1.2, ink);
|
|
}
|
|
}
|
|
if (item.submenu)
|
|
shapes.chevron(rect.right - 12.0, cy, 8, 'r', ink);
|
|
}
|
|
}
|
|
|
|
void NativeWindows::menu_open_popup(uint64_t menu_handle, uint64_t parent, int32_t x, int32_t y)
|
|
{
|
|
const auto *menu = objects.menu(menu_handle);
|
|
if (!menu || !presentation.popup)
|
|
throw uint32_t(120);
|
|
if (popups.size() >= 8)
|
|
throw uint32_t(120);
|
|
auto &renderer = objects.text();
|
|
const auto font = interface_font();
|
|
const auto metrics = renderer.metrics(font);
|
|
// Windows 11 spaces its menu items wider than the classic menus.
|
|
const int32_t item_height = metrics.height + (themed() ? 13 : 5);
|
|
int32_t label_width = 0, accelerator_width = 0, total = popup_border;
|
|
std::vector<DesktopRect> rects;
|
|
for (const auto &item : menu->items) {
|
|
if (item.type & type_separator) {
|
|
rects.push_back({popup_border, total, 0, total + separator_height});
|
|
total += separator_height;
|
|
continue;
|
|
}
|
|
const auto [text, accelerator] = split_tab(item.text);
|
|
const auto label = menu_label(text).first;
|
|
const auto labels = printable(label);
|
|
label_width = std::max(label_width, labels.empty() ? 0 : renderer.extent(font, labels).width);
|
|
const auto accelerators = printable(accelerator);
|
|
accelerator_width = std::max(accelerator_width, accelerators.empty() ? 0 : renderer.extent(font, accelerators).width);
|
|
rects.push_back({popup_border, total, 0, total + item_height});
|
|
total += item_height;
|
|
}
|
|
const int32_t width = popup_border * 2 + gutter + label_width + (accelerator_width ? 16 + accelerator_width : 0) + arrow_width;
|
|
const int32_t height = total + popup_border;
|
|
for (auto &rect : rects)
|
|
rect.right = width - popup_border;
|
|
MenuPopup popup{next_popup++, menu_handle, parent, x, y, width, height, std::move(rects), std::nullopt, {}};
|
|
menu_render(popup);
|
|
presentation.popup(popup.handle, parent, x, y, uint32_t(width), uint32_t(height), popup.pixels);
|
|
popups.push_back(std::move(popup));
|
|
}
|
|
|
|
void NativeWindows::menu_close()
|
|
{
|
|
const bool was_active = menu_active();
|
|
const auto owner = open_menu_window;
|
|
while (!popups.empty()) {
|
|
const auto handle = popups.back().handle;
|
|
popups.pop_back();
|
|
if (presentation.remove)
|
|
presentation.remove(handle);
|
|
}
|
|
open_menu_item.reset();
|
|
if (was_active && owner && objects.window(owner)) {
|
|
send(owner, 0x11f, 0xffff0000ULL, 0);
|
|
send(owner, 0x212, 0, 0);
|
|
if (objects.window_visible(owner))
|
|
present(owner);
|
|
}
|
|
open_menu_window = 0;
|
|
}
|
|
|
|
void NativeWindows::menu_open_bar(uint64_t window, size_t index)
|
|
{
|
|
auto *owner = objects.window(window);
|
|
if (!owner || !owner->menu)
|
|
return;
|
|
const bool already = menu_active();
|
|
while (popups.size() > 0) {
|
|
const auto handle = popups.back().handle;
|
|
popups.pop_back();
|
|
if (presentation.remove)
|
|
presentation.remove(handle);
|
|
}
|
|
const auto rects = menu_bar_items(*owner);
|
|
const auto *bar = objects.menu(owner->menu);
|
|
if (!bar || index >= bar->items.size() || index >= rects.size())
|
|
return;
|
|
if (!already) {
|
|
open_menu_window = window;
|
|
send(window, 0x211, 0, 0);
|
|
}
|
|
send(window, 0x116, owner->menu, 0);
|
|
owner = objects.window(window);
|
|
if (!owner)
|
|
return;
|
|
bar = objects.menu(owner->menu);
|
|
if (!bar || index >= bar->items.size())
|
|
return;
|
|
const auto &item = bar->items[index];
|
|
if (!item.submenu) {
|
|
// A menu bar command without a drop-down runs immediately.
|
|
const auto command = item.id;
|
|
menu_close();
|
|
if (messages.size() < 10000)
|
|
queue({window, command, 0, 0x111, message_time(), cursor_x, cursor_y});
|
|
return;
|
|
}
|
|
send(window, 0x117, item.submenu, uint64_t(index));
|
|
if (!objects.window(window))
|
|
return;
|
|
open_menu_item = index;
|
|
open_menu_window = window;
|
|
const auto rect = menu_bar_items(*objects.window(window))[index];
|
|
menu_open_popup(item.submenu, window, rect.left, rect.bottom);
|
|
present(window);
|
|
}
|
|
|
|
void NativeWindows::menu_highlight(size_t level, std::optional<size_t> index)
|
|
{
|
|
if (level >= popups.size())
|
|
return;
|
|
// Deeper levels belong to the previously highlighted item.
|
|
while (popups.size() > level + 1) {
|
|
const auto handle = popups.back().handle;
|
|
popups.pop_back();
|
|
if (presentation.remove)
|
|
presentation.remove(handle);
|
|
}
|
|
auto &popup = popups[level];
|
|
if (popup.highlight == index)
|
|
return;
|
|
popup.highlight = index;
|
|
const auto *menu = objects.menu(popup.menu);
|
|
if (menu && index && *index < menu->items.size()) {
|
|
const auto &item = menu->items[*index];
|
|
const uint64_t flags = 0x80 | (item.submenu ? 0x10U : 0U) | ((item.state & item_grayed) ? 0x3U : 0U) | ((item.state & item_checked) ? 0x8U : 0U);
|
|
if (open_menu_window && objects.window(open_menu_window))
|
|
send(open_menu_window, 0x11f, (item.submenu ? *index : item.id) | (flags << 16), popup.menu);
|
|
if (item.submenu && is_enabled(item)) {
|
|
const auto rect = popup.items[*index];
|
|
send(open_menu_window, 0x117, item.submenu, *index);
|
|
menu_render(popup);
|
|
presentation.popup(popup.handle, popup.parent, popup.x, popup.y, uint32_t(popup.width), uint32_t(popup.height), popup.pixels);
|
|
menu_open_popup(item.submenu, popup.handle, popup.width - 4, rect.top - 2);
|
|
return;
|
|
}
|
|
}
|
|
menu_render(popup);
|
|
presentation.popup(popup.handle, popup.parent, popup.x, popup.y, uint32_t(popup.width), uint32_t(popup.height), popup.pixels);
|
|
}
|
|
|
|
void NativeWindows::menu_select(size_t level, size_t index)
|
|
{
|
|
if (level >= popups.size())
|
|
return;
|
|
const auto *menu = objects.menu(popups[level].menu);
|
|
if (!menu || index >= menu->items.size())
|
|
return;
|
|
const auto item = menu->items[index];
|
|
if (!is_enabled(item))
|
|
return;
|
|
if (item.submenu) {
|
|
menu_highlight(level, index);
|
|
return;
|
|
}
|
|
const auto owner = open_menu_window;
|
|
const auto found = system_menus.find(owner);
|
|
const bool system = found != system_menus.end() && popups.front().menu == found->second;
|
|
menu_close();
|
|
if (menu_tracking)
|
|
tracked_command = item.id;
|
|
else if (owner && objects.window(owner) && messages.size() < 10000)
|
|
queue({owner, item.id, 0, system ? 0x112U : 0x111U, message_time(), cursor_x, cursor_y});
|
|
}
|
|
|
|
void NativeWindows::system_menu_open(uint64_t window, int32_t x, int32_t y)
|
|
{
|
|
if (menu_active() || menu_tracking || !objects.window(window))
|
|
return;
|
|
const auto handle = system_menu(window);
|
|
if (!handle)
|
|
return;
|
|
const auto *owner = objects.window(window);
|
|
// As in Windows, the standard commands are greyed for what the window's state and style rule out; items a program added keep theirs.
|
|
const uint32_t style = owner->style;
|
|
const bool maximized = style & 0x01000000U, minimized = style & 0x20000000U;
|
|
const auto *type = objects.window_class(owner->class_id);
|
|
for (auto &entry : objects.edit_menu(handle)->items) {
|
|
bool grayed;
|
|
switch (entry.id) {
|
|
case 0xf120: grayed = !maximized && !minimized; break;
|
|
case 0xf010: grayed = maximized; break;
|
|
case 0xf000: grayed = maximized || minimized || !(style & 0x40000U); break;
|
|
case 0xf020: grayed = minimized || !(style & 0x20000U); break;
|
|
case 0xf030: grayed = maximized || !(style & 0x10000U); break;
|
|
case 0xf060: grayed = type && (type->style & 0x200U); break;
|
|
default: continue;
|
|
}
|
|
entry.state = grayed ? entry.state | 3U : entry.state & ~3U;
|
|
}
|
|
open_menu_window = window;
|
|
send(window, 0x211, 0, 0);
|
|
send(window, 0x116, handle, 0);
|
|
// The high word of WM_INITMENUPOPUP's lParam says the popup is the window menu.
|
|
send(window, 0x117, handle, 0x10000);
|
|
if (!objects.window(window) || !objects.menu(handle)) {
|
|
open_menu_window = 0;
|
|
if (objects.window(window))
|
|
send(window, 0x212, 0, 0);
|
|
return;
|
|
}
|
|
menu_open_popup(handle, window, x, y);
|
|
present(window);
|
|
}
|
|
|
|
uint64_t NativeWindows::track_popup_menu(uint64_t menu, uint32_t flags, int32_t x, int32_t y, uint64_t window)
|
|
{
|
|
const auto root = objects.window_root(window);
|
|
const auto *top = objects.window(root);
|
|
if (!objects.menu(menu) || !top)
|
|
throw uint32_t(1401);
|
|
if (menu_active() || menu_tracking)
|
|
throw uint32_t(1456);
|
|
// TrackPopupMenu runs its own loop until the menu closes, as Windows does: the owner learns the menu loop started and the menu
|
|
// is about to show, and the popup opens at the screen point given, on the owner's host window.
|
|
open_menu_window = window;
|
|
send(window, 0x211, 1, 0);
|
|
if (!(flags & 0x80))
|
|
send(window, 0x117, menu, 0);
|
|
top = objects.window(root);
|
|
if (!top || !objects.menu(menu)) {
|
|
open_menu_window = 0;
|
|
return 0;
|
|
}
|
|
present(root);
|
|
menu_tracking = true;
|
|
tracked_command = 0;
|
|
try {
|
|
menu_open_popup(menu, root, x - top->outer.left, y - top->outer.top);
|
|
while (!popups.empty()) {
|
|
serve_sent();
|
|
flush_dirty();
|
|
deliver_pending();
|
|
if (!presentation.poll)
|
|
break;
|
|
for (const auto &event : presentation.poll(std::chrono::milliseconds(20)))
|
|
receive(event);
|
|
}
|
|
} catch (...) {
|
|
menu_tracking = false;
|
|
menu_close();
|
|
throw;
|
|
}
|
|
menu_tracking = false;
|
|
menu_close();
|
|
const auto command = tracked_command;
|
|
// TPM_RETURNCMD answers the command itself; otherwise it reaches the owner as WM_COMMAND and the answer is only whether one was chosen.
|
|
if (flags & 0x100)
|
|
return command;
|
|
if (command && !(flags & 0x80) && objects.window(window) && messages.size() < 10000)
|
|
queue({window, command, 0, 0x111, message_time(), cursor_x, cursor_y});
|
|
return command ? 1 : 0;
|
|
}
|
|
|
|
bool NativeWindows::menu_event(const DesktopEvent &event)
|
|
{
|
|
const bool in_popup = event.window >= 0x7b000000ULL && event.window < next_popup;
|
|
if (!menu_active() && !in_popup)
|
|
return false;
|
|
if (event.kind == DesktopEventKind::popup_done) {
|
|
menu_close();
|
|
return true;
|
|
}
|
|
if (event.kind == DesktopEventKind::keymap || event.kind == DesktopEventKind::modifiers || event.kind == DesktopEventKind::message)
|
|
return false;
|
|
if (event.kind == DesktopEventKind::keyboard_focus)
|
|
return true;
|
|
const auto level_of = [&](uint64_t handle) -> std::optional<size_t> {
|
|
for (size_t index = 0; index < popups.size(); ++index)
|
|
if (popups[index].handle == handle)
|
|
return index;
|
|
return std::nullopt;
|
|
};
|
|
const auto item_at = [&](const MenuPopup &popup, int32_t x, int32_t y) -> std::optional<size_t> {
|
|
for (size_t index = 0; index < popup.items.size(); ++index) {
|
|
const auto &rect = popup.items[index];
|
|
if (x >= rect.left && x < rect.right && y >= rect.top && y < rect.bottom)
|
|
return index;
|
|
}
|
|
return std::nullopt;
|
|
};
|
|
const auto bar_at = [&](int32_t x, int32_t y) -> std::optional<size_t> {
|
|
const auto *owner = objects.window(open_menu_window);
|
|
if (!owner)
|
|
return std::nullopt;
|
|
const auto layout = frame_layout(*owner);
|
|
if (x < layout.menu_bar.left || x >= layout.menu_bar.right || y < layout.menu_bar.top || y >= layout.menu_bar.bottom)
|
|
return std::nullopt;
|
|
const auto rects = menu_bar_items(*owner);
|
|
for (size_t index = 0; index < rects.size(); ++index)
|
|
if (x >= rects[index].left && x < rects[index].right)
|
|
return index;
|
|
return std::nullopt;
|
|
};
|
|
if (event.kind == DesktopEventKind::pointer_motion) {
|
|
if (const auto level = level_of(event.window)) {
|
|
const auto &popup = popups[*level];
|
|
const auto hit = item_at(popup, event.x, event.y);
|
|
const auto *menu = objects.menu(popup.menu);
|
|
if (hit && menu && !(menu->items[*hit].type & type_separator))
|
|
menu_highlight(*level, hit);
|
|
else if (!hit)
|
|
menu_highlight(*level, std::nullopt);
|
|
} else if (event.window == open_menu_window) {
|
|
if (const auto hit = bar_at(event.x, event.y); hit && (!open_menu_item || *hit != *open_menu_item))
|
|
menu_open_bar(open_menu_window, *hit);
|
|
}
|
|
return true;
|
|
}
|
|
if (event.kind == DesktopEventKind::pointer_button) {
|
|
if (event.message != 0x110)
|
|
return true;
|
|
const bool pressed = event.wparam != 0;
|
|
if (const auto level = level_of(event.window)) {
|
|
const auto hit = item_at(popups[*level], event.x, event.y);
|
|
if (hit && !pressed)
|
|
menu_select(*level, *hit);
|
|
else if (hit && pressed)
|
|
menu_highlight(*level, hit);
|
|
return true;
|
|
}
|
|
if (pressed) {
|
|
const auto hit = event.window == open_menu_window ? bar_at(event.x, event.y) : std::nullopt;
|
|
if (hit && open_menu_item && *hit == *open_menu_item)
|
|
menu_close();
|
|
else if (hit)
|
|
menu_open_bar(open_menu_window, *hit);
|
|
else
|
|
menu_close();
|
|
}
|
|
return true;
|
|
}
|
|
if (event.kind == DesktopEventKind::key) {
|
|
if (event.message < key_down.size())
|
|
key_down[event.message] = event.wparam != 0;
|
|
if (event.wparam != 1 || popups.empty())
|
|
return true;
|
|
const auto key = keyboard_map.decode(event.message);
|
|
auto &top = popups.back();
|
|
const auto *menu = objects.menu(top.menu);
|
|
if (!menu)
|
|
return true;
|
|
const size_t level = popups.size() - 1;
|
|
const auto step = [&](int direction) {
|
|
const size_t count = menu->items.size();
|
|
if (!count)
|
|
return;
|
|
size_t at = top.highlight ? *top.highlight : (direction > 0 ? count - 1 : 0);
|
|
for (size_t tried = 0; tried < count; ++tried) {
|
|
at = direction > 0 ? (at + 1) % count : (at + count - 1) % count;
|
|
if (!(menu->items[at].type & type_separator)) {
|
|
menu_highlight(level, at);
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
if (key.code == 0x1b) {
|
|
if (popups.size() > 1) {
|
|
const auto handle = popups.back().handle;
|
|
popups.pop_back();
|
|
if (presentation.remove)
|
|
presentation.remove(handle);
|
|
} else {
|
|
menu_close();
|
|
}
|
|
} else if (key.code == 0x28) {
|
|
step(1);
|
|
} else if (key.code == 0x26) {
|
|
step(-1);
|
|
} else if (key.code == 0x0d) {
|
|
if (top.highlight)
|
|
menu_select(level, *top.highlight);
|
|
} else if (key.code == 0x27) {
|
|
if (top.highlight && menu->items[*top.highlight].submenu && is_enabled(menu->items[*top.highlight])) {
|
|
menu_highlight(level, std::nullopt);
|
|
menu_highlight(level, *top.highlight);
|
|
if (popups.size() > level + 1)
|
|
menu_highlight(level + 1, [&]() -> std::optional<size_t> {
|
|
const auto *child = objects.menu(popups[level + 1].menu);
|
|
for (size_t index = 0; child && index < child->items.size(); ++index)
|
|
if (!(child->items[index].type & type_separator)) return index;
|
|
return std::nullopt;
|
|
}());
|
|
} else if (popups.size() == 1 && open_menu_item) {
|
|
const auto *owner = objects.window(open_menu_window);
|
|
const auto *bar = owner ? objects.menu(owner->menu) : nullptr;
|
|
if (bar && !bar->items.empty())
|
|
menu_open_bar(open_menu_window, (*open_menu_item + 1) % bar->items.size());
|
|
}
|
|
} else if (key.code == 0x25) {
|
|
if (popups.size() > 1) {
|
|
const auto handle = popups.back().handle;
|
|
popups.pop_back();
|
|
if (presentation.remove)
|
|
presentation.remove(handle);
|
|
} else if (open_menu_item) {
|
|
const auto *owner = objects.window(open_menu_window);
|
|
const auto *bar = owner ? objects.menu(owner->menu) : nullptr;
|
|
if (bar && !bar->items.empty())
|
|
menu_open_bar(open_menu_window, (*open_menu_item + bar->items.size() - 1) % bar->items.size());
|
|
}
|
|
} else if (key.character) {
|
|
const auto wanted = char16_t(key.character >= 'A' && key.character <= 'Z' ? key.character + 32 : key.character);
|
|
for (size_t index = 0; index < menu->items.size(); ++index) {
|
|
const auto &text = menu->items[index].text;
|
|
for (size_t at = 0; at + 1 < text.size(); ++at)
|
|
if (text[at] == u'&' && text[at + 1] != u'&') {
|
|
const auto mark = char16_t(text[at + 1] >= u'A' && text[at + 1] <= u'Z' ? text[at + 1] + 32 : text[at + 1]);
|
|
if (mark == wanted && is_enabled(menu->items[index])) {
|
|
menu_select(level, index);
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#else
|
|
|
|
void NativeWindows::menu_render(MenuPopup &) {}
|
|
void NativeWindows::menu_open_popup(uint64_t, uint64_t, int32_t, int32_t) { throw uint32_t(120); }
|
|
void NativeWindows::menu_close() {}
|
|
void NativeWindows::menu_open_bar(uint64_t, size_t) {}
|
|
void NativeWindows::menu_highlight(size_t, std::optional<size_t>) {}
|
|
void NativeWindows::menu_select(size_t, size_t) {}
|
|
bool NativeWindows::menu_event(const DesktopEvent &) { return false; }
|
|
uint64_t NativeWindows::track_popup_menu(uint64_t, uint32_t, int32_t, int32_t, uint64_t) { throw uint32_t(120); }
|
|
void NativeWindows::system_menu_open(uint64_t, int32_t, int32_t) {}
|
|
|
|
#endif
|
|
|
|
uint64_t NativeWindows::system_menu(uint64_t window)
|
|
{
|
|
if (!objects.window(window))
|
|
return 0;
|
|
auto found = system_menus.find(window);
|
|
if (found == system_menus.end() || !objects.menu(found->second)) {
|
|
DesktopMenu menu;
|
|
const auto item = [](uint32_t id, const char16_t *text) { return DesktopMenuItem{0, 0, id, text}; };
|
|
menu.items = {item(0xf120, u"&Restore"), item(0xf010, u"&Move"), item(0xf000, u"&Size"), item(0xf020, u"Mi&nimize"),
|
|
item(0xf030, u"Ma&ximize"), DesktopMenuItem{0x800, 0, 0, u""}, item(0xf060, u"&Close\tAlt+F4")};
|
|
const auto handle = objects.add(std::move(menu));
|
|
if (!handle)
|
|
return 0;
|
|
found = system_menus.insert_or_assign(window, handle).first;
|
|
}
|
|
return found->second;
|
|
}
|
|
|
|
}
|