mirror of
https://github.com/mirkobrombin/raven.git
synced 2026-11-03 21:46:32 +00:00
451 lines
22 KiB
C++
451 lines
22 KiB
C++
#include "windows.h"
|
|
#include "canvas.h"
|
|
#include "shapes.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstring>
|
|
#include <stdexcept>
|
|
|
|
namespace raven {
|
|
|
|
using namespace paint;
|
|
|
|
NativeWindows::FrameLayout NativeWindows::frame_layout(const DesktopWindow &window) const
|
|
{
|
|
const auto &metrics = objects.nonclient_metrics();
|
|
const uint32_t style = window.style & ~0x10000000U;
|
|
FrameLayout layout{};
|
|
const int32_t width = window.outer.right - window.outer.left, height = window.outer.bottom - window.outer.top;
|
|
// AdjustWindowRect already encodes ReactOS' border and caption rules; its deltas are the frame thickness.
|
|
const auto adjusted = adjust_window_rect(metrics, {0, 0, 0, 0}, style, false, window.ex_style);
|
|
layout.border = -adjusted.left;
|
|
layout.caption_height = (style & 0xc00000U) == 0xc00000U ? metrics.caption : 0;
|
|
layout.menu_height = window.menu ? metrics.menu : 0;
|
|
layout.edge = (style & 0x40000U) || (style & 0xc00000U) == 0x400000U || (style & 0xc00000U) == 0xc00000U;
|
|
const int32_t border = layout.border;
|
|
layout.caption = {border, border, width - border, border + std::max(layout.caption_height - 1, 0)};
|
|
layout.menu_bar = {border, border + layout.caption_height, width - border, border + layout.caption_height + layout.menu_height};
|
|
// Windows 11 caption buttons are 46 pixels wide and fill the caption; the classic ones are bevelled boxes inside it.
|
|
const bool modern = themed();
|
|
const int32_t inset = modern ? 0 : 2;
|
|
const int32_t button_height = std::max(layout.caption.bottom - layout.caption.top - 2 * inset + (modern ? 1 : 0), 0);
|
|
const int32_t button_width = std::min(modern ? 46 : metrics.button_x, std::max(layout.caption.right - layout.caption.left, 0));
|
|
int32_t cursor = layout.caption.right - inset;
|
|
layout.close = layout.maximize = layout.minimize = {0, 0, 0, 0};
|
|
if (layout.caption_height && (style & 0x80000U)) {
|
|
layout.close = {cursor - button_width, layout.caption.top + inset, cursor, layout.caption.top + inset + button_height};
|
|
cursor = layout.close.left - inset;
|
|
if (style & 0x30000U) {
|
|
layout.maximize = {cursor - button_width, layout.caption.top + inset, cursor, layout.caption.top + inset + button_height};
|
|
layout.minimize = {layout.maximize.left - button_width, layout.maximize.top, layout.maximize.left, layout.maximize.bottom};
|
|
// WS_MINIMIZEBOX or WS_MAXIMIZEBOX alone leaves the other button visible but disabled in Windows.
|
|
if (!(style & 0x20000U) && !(style & 0x10000U))
|
|
layout.minimize = layout.maximize = {0, 0, 0, 0};
|
|
}
|
|
}
|
|
layout.icon = {layout.caption.left + 2, layout.caption.top + (layout.caption.bottom - layout.caption.top - 16) / 2, layout.caption.left + 18,
|
|
layout.caption.top + (layout.caption.bottom - layout.caption.top - 16) / 2 + 16};
|
|
return layout;
|
|
}
|
|
|
|
uint64_t NativeWindows::nonclient_hit(const DesktopWindow &window,int32_t x,int32_t y) const
|
|
{
|
|
constexpr uint64_t nowhere=0,client=1,caption=2,system_menu=3,menu=5,minimize=8,maximize=9,left=10,right=11,top=12,top_left=13,
|
|
top_right=14,bottom=15,bottom_left=16,bottom_right=17,border=18,close=20;
|
|
const auto &outer=window.outer;
|
|
if (x<outer.left || y<outer.top || x>=outer.right || y>=outer.bottom) return nowhere;
|
|
if (x>=window.x && y>=window.y && int64_t(x)<int64_t(window.x)+window.width && int64_t(y)<int64_t(window.y)+window.height) return client;
|
|
const auto layout=frame_layout(window);
|
|
const int32_t px=x-outer.left,py=y-outer.top;
|
|
const auto inside=[&](DesktopRect rect) { return px>=rect.left && px<rect.right && py>=rect.top && py<rect.bottom; };
|
|
if (inside(layout.close)) return close;
|
|
if (inside(layout.maximize)) return maximize;
|
|
if (inside(layout.minimize)) return minimize;
|
|
if (layout.caption_height && (window.style & 0x80000U) && inside(layout.icon)) return system_menu;
|
|
if (layout.caption_height && inside({layout.caption.left,layout.caption.top,layout.caption.right,layout.caption.bottom+1})) return caption;
|
|
if (layout.menu_height && inside(layout.menu_bar)) return menu;
|
|
if (window.style & 0x40000U) {
|
|
const int32_t width=outer.right-outer.left,height=outer.bottom-outer.top,corner=layout.border*2+8;
|
|
const bool west=px<layout.border,east=px>=width-layout.border,north=py<layout.border,south=py>=height-layout.border;
|
|
if (north && px<corner) return top_left;
|
|
if (north && px>=width-corner) return top_right;
|
|
if (south && px<corner) return bottom_left;
|
|
if (south && px>=width-corner) return bottom_right;
|
|
if (west && py<corner) return top_left;
|
|
if (west && py>=height-corner) return bottom_left;
|
|
if (east && py<corner) return top_right;
|
|
if (east && py>=height-corner) return bottom_right;
|
|
if (north) return top;
|
|
if (south) return bottom;
|
|
if (west) return left;
|
|
if (east) return right;
|
|
}
|
|
return border;
|
|
}
|
|
|
|
void NativeWindows::hover_frame(uint64_t handle,uint64_t hit)
|
|
{
|
|
if (hovered_frame_window==handle && hovered_frame_hit==hit)
|
|
return;
|
|
const auto previous=hovered_frame_window;
|
|
hovered_frame_window=hit ? handle : 0;
|
|
hovered_frame_hit=hit;
|
|
if (!themed())
|
|
return;
|
|
if (previous && previous!=handle && objects.window(previous))
|
|
refresh_frame(previous);
|
|
if (objects.window(handle))
|
|
refresh_frame(handle);
|
|
}
|
|
|
|
void NativeWindows::nonclient_pointer(uint64_t handle,uint64_t hit,uint32_t message,int32_t x,int32_t y)
|
|
{
|
|
const auto *window=objects.window(handle);
|
|
if (!window) return;
|
|
constexpr uint64_t caption_hit=2,system_menu_hit=3,menu_hit=5,minimize_hit=8,maximize_hit=9,close_hit=20;
|
|
// The window menu opens where the secondary button is released over the caption, or under the icon when the icon is pressed.
|
|
if (message==0x205 && (hit==caption_hit || hit==system_menu_hit)) { system_menu_open(handle,x,y); return; }
|
|
if (message==0x201 && hit==system_menu_hit) {
|
|
const auto layout=frame_layout(*window);
|
|
system_menu_open(handle,layout.icon.left,layout.caption.bottom+1);
|
|
return;
|
|
}
|
|
if (message==0x200) {
|
|
// The caption button under the pointer lights up in the Windows 11 frame.
|
|
hover_frame(handle,hit==minimize_hit || hit==maximize_hit || hit==close_hit ? hit : 0);
|
|
return;
|
|
}
|
|
if (message==0x201) {
|
|
pressed_frame_hit=hit; pressed_frame_window=handle;
|
|
// A drag that starts on the caption or a sizing border continues in the compositor (maximized windows do not move).
|
|
// A tool window shown on its owner is moved here: the compositor moves only the host windows it places itself.
|
|
if (hit==2 && shown_on_owner(*window) && !(window->style & 0x01000000U)) {
|
|
frame_drag={handle,cursor_x,cursor_y,window->outer};
|
|
return;
|
|
}
|
|
if (presentation.interactive && !(window->style & 0x01000000U)) {
|
|
// Hit codes 10..17 are the sizing borders: left, right, top, top-left, top-right, bottom, bottom-left, bottom-right.
|
|
static constexpr uint32_t edges[]{4,8,1,5,9,2,6,10};
|
|
if (hit==2) { presentation.interactive(handle,0); return; }
|
|
if (hit>=10 && hit<=17) { presentation.interactive(handle,edges[hit-10]); return; }
|
|
}
|
|
if (hit==menu_hit) {
|
|
const auto rects=menu_bar_items(*window);
|
|
for (size_t index=0;index<rects.size();++index)
|
|
if (x>=rects[index].left && x<rects[index].right) { menu_open_bar(handle,index); break; }
|
|
}
|
|
return;
|
|
}
|
|
if (message==0x202 && pressed_frame_window==handle && pressed_frame_hit==hit) {
|
|
pressed_frame_hit=0; pressed_frame_window=0;
|
|
if (hit==close_hit) send(handle,0x112,0xf060,0);
|
|
else if (hit==minimize_hit && (window->style & 0x20000U)) send(handle,0x112,0xf020,0);
|
|
else if (hit==maximize_hit && (window->style & 0x10000U)) send(handle,0x112,0xf030,0);
|
|
}
|
|
}
|
|
|
|
#ifdef RAVEN_SKIA
|
|
std::vector<DesktopRect> NativeWindows::menu_bar_items(const DesktopWindow &window)
|
|
{
|
|
std::vector<DesktopRect> rects;
|
|
const auto *menu = objects.menu(window.menu);
|
|
if (!menu)
|
|
return rects;
|
|
const auto layout = frame_layout(window);
|
|
auto &renderer = objects.text();
|
|
const auto font = interface_font();
|
|
(void)font;
|
|
std::vector<int32_t> widths;
|
|
for (const auto &item : menu->items)
|
|
widths.push_back(text_width(renderer, menu_label(item.text).first) + 2 * 8);
|
|
// The first right-justified item and every item after it sit against the right edge of the bar.
|
|
size_t split = menu->items.size();
|
|
int32_t trailing = 0;
|
|
for (size_t index = 0; index < menu->items.size(); ++index)
|
|
if (menu->items[index].type & 0x4000U) { split = index; break; }
|
|
for (size_t index = split; index < widths.size(); ++index)
|
|
trailing += widths[index];
|
|
int32_t x = layout.menu_bar.left;
|
|
for (size_t index = 0; index < widths.size(); ++index) {
|
|
if (index == split)
|
|
x = std::max(x, layout.menu_bar.right - trailing);
|
|
rects.push_back({x, layout.menu_bar.top, x + widths[index], layout.menu_bar.bottom});
|
|
x += widths[index];
|
|
}
|
|
return rects;
|
|
}
|
|
|
|
void NativeWindows::paint_nonclient(uint64_t handle)
|
|
{
|
|
auto *window = objects.window(handle);
|
|
if (!window || window->parent || !window->bitmap)
|
|
return;
|
|
const auto layout = frame_layout(*window);
|
|
if (!layout.border && !layout.caption_height && !layout.menu_height)
|
|
return;
|
|
const auto *bitmap = objects.bitmap(window->bitmap);
|
|
if (!bitmap || !bitmap->shared || bitmap->depth != 32)
|
|
return;
|
|
const int32_t width = window->outer.right - window->outer.left, height = window->outer.bottom - window->outer.top;
|
|
const bool is_active = active == handle;
|
|
// The frame is drawn again only when something it shows changed; guest drawing stays inside the client area.
|
|
{
|
|
std::u16string key;
|
|
const auto add = [&](uint64_t value) { key.append(reinterpret_cast<const char16_t *>(&value), 4); };
|
|
add(window->bitmap); add(uint64_t(bitmap->width) << 32 | bitmap->height); add(uint64_t(uint32_t(width)) << 32 | uint32_t(height));
|
|
add(uint64_t(window->style) << 32 | window->ex_style); add(is_active); add(window->menu);
|
|
add(open_menu_item && open_menu_window == handle ? *open_menu_item + 1 : 0);
|
|
add(hovered_frame_window == handle ? hovered_frame_hit : 0);
|
|
add(themed());
|
|
add(uint64_t(uint32_t(window->x - window->outer.left)) << 32 | uint32_t(window->y - window->outer.top));
|
|
key += window->title;
|
|
key += u'\0';
|
|
if (const auto *menu = objects.menu(window->menu))
|
|
for (const auto &item : menu->items) {
|
|
add(uint64_t(item.type) << 32 | item.state);
|
|
key += item.text;
|
|
key += u'\0';
|
|
}
|
|
auto &painted = painted_frames[handle];
|
|
if (painted == key)
|
|
return;
|
|
painted = std::move(key);
|
|
}
|
|
auto *pixels = objects.bitmap(window->bitmap)->pixels().data();
|
|
Canvas canvas{pixels, int32_t(bitmap->width), int32_t(bitmap->height)};
|
|
const auto color = [&](int index) { return rgb(objects.system_color(index)); };
|
|
// A program that draws its own frame answers WM_NCCALCSIZE with a client area over part of the frame: what it drew there stays, and
|
|
// the frame shows only around it.
|
|
const int32_t client_left = std::max(window->x - window->outer.left, 0), client_top = std::max(window->y - window->outer.top, 0);
|
|
const int32_t client_right = std::min(client_left + window->width, int32_t(bitmap->width));
|
|
const int32_t client_bottom = std::min(client_top + window->height, int32_t(bitmap->height));
|
|
std::vector<uint8_t> kept;
|
|
const bool over_frame = client_top < layout.border + layout.caption_height + layout.menu_height && client_right > client_left &&
|
|
client_bottom > client_top;
|
|
const size_t row_bytes = size_t(std::max(client_right - client_left, 0)) * 4;
|
|
if (over_frame)
|
|
for (int32_t y = client_top; y < client_bottom; ++y) {
|
|
const auto *row = pixels + (size_t(y) * bitmap->width + client_left) * 4;
|
|
kept.insert(kept.end(), row, row + row_bytes);
|
|
}
|
|
const auto restore = [&] {
|
|
for (int32_t y = client_top; over_frame && y < client_bottom; ++y)
|
|
std::memcpy(pixels + (size_t(y) * bitmap->width + client_left) * 4, kept.data() + size_t(y - client_top) * row_bytes, row_bytes);
|
|
};
|
|
if (themed()) {
|
|
paint_modern_frame(handle, *window, layout, canvas, is_active, width, height);
|
|
restore();
|
|
return;
|
|
}
|
|
if (layout.border) {
|
|
// The ring first takes the frame color, then the bevel is laid over its outer two pixels.
|
|
const DesktopRect all{0, 0, width, height};
|
|
const DesktopRect inner{layout.border, layout.border, width - layout.border, height - layout.border};
|
|
canvas.fill({all.left, all.top, all.right, inner.top}, color(color_button_face));
|
|
canvas.fill({all.left, inner.bottom, all.right, all.bottom}, color(color_button_face));
|
|
canvas.fill({all.left, inner.top, inner.left, inner.bottom}, color(color_button_face));
|
|
canvas.fill({inner.right, inner.top, all.right, inner.bottom}, color(color_button_face));
|
|
if (layout.edge && layout.border >= 2)
|
|
canvas.edge(all, color(color_light), color(color_dark_shadow), color(color_button_highlight), color(color_button_shadow));
|
|
}
|
|
if (layout.caption_height) {
|
|
const auto from = color(is_active ? color_active_caption : color_inactive_caption);
|
|
const auto to = color(is_active ? color_gradient_active : color_gradient_inactive);
|
|
const auto span = layout.caption.right - layout.caption.left;
|
|
for (int32_t x = layout.caption.left; x < layout.caption.right; ++x)
|
|
canvas.fill({x, layout.caption.top, x + 1, layout.caption.bottom}, mix(from, to, x - layout.caption.left, span - 1));
|
|
canvas.fill({layout.caption.left, layout.caption.bottom, layout.caption.right, layout.caption.bottom + 1}, color(color_button_face));
|
|
auto &renderer = objects.text();
|
|
const auto text_color = color(is_active ? color_caption_text : color_inactive_text);
|
|
const int32_t text_left = layout.caption.left + (window->style & 0x80000U ? 20 : 4);
|
|
int32_t text_right = layout.caption.right - 2;
|
|
for (const auto &button : {layout.minimize, layout.maximize, layout.close})
|
|
if (button.right > button.left)
|
|
text_right = std::min(text_right, button.left - 4);
|
|
const auto metrics = renderer.metrics(interface_font());
|
|
draw_text(renderer, canvas, window->title, text_left, layout.caption.top + (layout.caption.bottom - layout.caption.top - metrics.height) / 2,
|
|
text_color, std::nullopt, text_right - text_left);
|
|
const auto button = [&](DesktopRect rect, int glyph) {
|
|
if (rect.right <= rect.left)
|
|
return;
|
|
canvas.fill(rect, color(color_button_face));
|
|
canvas.edge(rect, color(color_button_highlight), color(color_dark_shadow), color(color_light), color(color_button_shadow));
|
|
const int32_t cx = (rect.left + rect.right) / 2, cy = (rect.top + rect.bottom) / 2;
|
|
const auto ink = color(color_menu_text);
|
|
if (glyph == 0) {
|
|
for (int32_t d = -3; d <= 3; ++d) { canvas.set(cx + d, cy + d, ink); canvas.set(cx + d, cy - d, ink); }
|
|
} else if (glyph == 1) {
|
|
for (int32_t d = -4; d <= 4; ++d) { canvas.set(cx + d, cy - 4, ink); canvas.set(cx + d, cy + 4, ink); canvas.set(cx - 4, cy + d, ink); canvas.set(cx + 4, cy + d, ink); }
|
|
} else {
|
|
for (int32_t d = -3; d <= 3; ++d) canvas.set(cx + d, cy + 4, ink);
|
|
}
|
|
};
|
|
button(layout.close, 0);
|
|
button(layout.maximize, 1);
|
|
button(layout.minimize, 2);
|
|
}
|
|
if (layout.menu_height) {
|
|
canvas.fill(layout.menu_bar, color(color_menu_bar));
|
|
auto &renderer = objects.text();
|
|
const auto metrics = renderer.metrics(interface_font());
|
|
const auto *menu = objects.menu(window->menu);
|
|
const auto rects = menu_bar_items(*window);
|
|
for (size_t index = 0; menu && index < rects.size() && index < menu->items.size(); ++index) {
|
|
const auto &rect = rects[index];
|
|
if (rect.right > layout.menu_bar.right)
|
|
break;
|
|
const auto [label, mnemonic] = menu_label(menu->items[index].text);
|
|
const bool open = open_menu_item && open_menu_window == handle && *open_menu_item == index;
|
|
if (open) {
|
|
canvas.fill(rect, color(13));
|
|
draw_text(renderer, canvas, label, rect.left + 8, rect.top + (rect.bottom - rect.top - metrics.height) / 2, color(14), mnemonic);
|
|
} else {
|
|
draw_text(renderer, canvas, label, rect.left + 8, rect.top + (rect.bottom - rect.top - metrics.height) / 2, color(color_menu_text), mnemonic);
|
|
}
|
|
}
|
|
}
|
|
restore();
|
|
}
|
|
namespace {
|
|
|
|
// The frame's pixels as a surface for the antialiased shapes.
|
|
struct CanvasSurface {
|
|
Canvas &canvas;
|
|
void blend(int64_t x, int64_t y, uint32_t color, 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 ? color : shapes::mix(below, color, alpha));
|
|
}
|
|
};
|
|
|
|
constexpr uint32_t shade(uint32_t r, uint32_t g, uint32_t b) { return r | g << 8 | b << 16; }
|
|
|
|
}
|
|
|
|
uint32_t NativeWindows::caption_color(const DesktopWindow &window, bool is_active) const
|
|
{
|
|
if (window.dark_frame)
|
|
return is_active ? shade(0x20, 0x20, 0x20) : shade(0x2b, 0x2b, 0x2b);
|
|
return is_active ? shade(0xef, 0xf4, 0xf9) : shade(0xf3, 0xf3, 0xf3);
|
|
}
|
|
|
|
// The minimize, maximize and close buttons of the Windows 11 caption, which also appear over the frame a program extends into its client area.
|
|
void NativeWindows::paint_caption_buttons(uint64_t handle, const DesktopWindow &window, const FrameLayout &layout, Canvas &canvas, bool is_active)
|
|
{
|
|
CanvasSurface surface{canvas};
|
|
shapes::Shapes<CanvasSurface> shapes{surface};
|
|
const bool dark = window.dark_frame;
|
|
const uint32_t ink = dark ? (is_active ? shade(0xff, 0xff, 0xff) : shade(0x9a, 0x9a, 0x9a)) : is_active ? shade(0x1a, 0x1a, 0x1a) : shade(0x8a, 0x8a, 0x8a);
|
|
const bool maximized = (window.style & 0x01000000U) != 0;
|
|
const auto button = [&](DesktopRect rect, uint64_t hit) {
|
|
if (rect.right <= rect.left)
|
|
return;
|
|
// A button the window's style leaves out is shown greyed beside the one it has, and does nothing.
|
|
const bool enabled = hit == 20 || (window.style & (hit == 9 ? 0x10000U : 0x20000U));
|
|
const bool hot = enabled && hovered_frame_window == handle && hovered_frame_hit == hit;
|
|
const bool pressed = hot && pressed_frame_window == handle && pressed_frame_hit == hit;
|
|
uint32_t glyph = enabled ? ink : dark ? shade(0x5c, 0x5c, 0x5c) : shade(0xc4, 0xc4, 0xc4);
|
|
if (hot && hit == 20) {
|
|
canvas.fill(rect, pressed ? shade(0xc8, 0x3c, 0x30) : shade(0xc4, 0x2b, 0x1c));
|
|
glyph = shade(0xff, 0xff, 0xff);
|
|
} else if (hot) {
|
|
canvas.fill(rect, dark ? (pressed ? shade(0x3a, 0x3a, 0x3a) : shade(0x2d, 0x2d, 0x2d)) : pressed ? shade(0xdc, 0xe0, 0xe5) : shade(0xe3, 0xe7, 0xec));
|
|
}
|
|
const double cx = (rect.left + rect.right) / 2.0, cy = (rect.top + rect.bottom) / 2.0;
|
|
if (hit == 20) {
|
|
shapes.segment(cx - 5, cy - 5, cx + 5, cy + 5, 1, glyph);
|
|
shapes.segment(cx + 5, cy - 5, cx - 5, cy + 5, 1, glyph);
|
|
} else if (hit == 9 && maximized) {
|
|
shapes.rounded(cx - 5, cy - 3, cx + 3, cy + 5, 1, std::nullopt, glyph);
|
|
shapes.segment(cx - 3, cy - 5, cx + 5, cy - 5, 1, glyph);
|
|
shapes.segment(cx + 5, cy - 5, cx + 5, cy + 3, 1, glyph);
|
|
} else if (hit == 9) {
|
|
shapes.rounded(cx - 5, cy - 5, cx + 5, cy + 5, 1, std::nullopt, glyph);
|
|
} else {
|
|
shapes.segment(cx - 5, cy, cx + 5, cy, 1, glyph);
|
|
}
|
|
};
|
|
button(layout.close, 20);
|
|
button(layout.maximize, 9);
|
|
button(layout.minimize, 8);
|
|
}
|
|
|
|
// The Windows 11 frame: a light caption that continues into the sizing border and the menu bar, a thin outline, the title in dark text,
|
|
// flat caption buttons with line glyphs that light up under the pointer, red for close, and the open menu item on a rounded highlight.
|
|
void NativeWindows::paint_modern_frame(uint64_t handle, const DesktopWindow &window, const FrameLayout &layout, Canvas &canvas, bool is_active, int32_t width,
|
|
int32_t height)
|
|
{
|
|
CanvasSurface surface{canvas};
|
|
shapes::Shapes<CanvasSurface> shapes{surface};
|
|
const bool dark = window.dark_frame;
|
|
const uint32_t title = caption_color(window, is_active);
|
|
const uint32_t ink = dark ? (is_active ? shade(0xff, 0xff, 0xff) : shade(0x9a, 0x9a, 0x9a)) : is_active ? shade(0x1a, 0x1a, 0x1a) : shade(0x8a, 0x8a, 0x8a);
|
|
const int32_t client_top = layout.border + layout.caption_height + layout.menu_height;
|
|
// The ring, the caption and the menu bar share one surface color.
|
|
canvas.fill({0, 0, width, client_top}, title);
|
|
canvas.fill({0, client_top, layout.border, height}, title);
|
|
canvas.fill({width - layout.border, client_top, width, height}, title);
|
|
canvas.fill({0, height - layout.border, width, height}, title);
|
|
if (layout.border)
|
|
shapes.rounded(0, 0, width, height, 0, std::nullopt, dark ? (is_active ? shade(0x4a, 0x4a, 0x4a) : shade(0x3c, 0x3c, 0x3c))
|
|
: is_active ? shade(0xb9, 0xbf, 0xc7) : shade(0xd2, 0xd2, 0xd2));
|
|
if (layout.caption_height) {
|
|
auto &renderer = objects.text();
|
|
const int32_t text_left = layout.caption.left + (window.style & 0x80000U ? 22 : 8);
|
|
int32_t text_right = layout.caption.right - 8;
|
|
for (const auto &button : {layout.minimize, layout.maximize, layout.close})
|
|
if (button.right > button.left)
|
|
text_right = std::min(text_right, button.left - 8);
|
|
const auto metrics = renderer.metrics(interface_font());
|
|
draw_text(renderer, canvas, window.title, text_left, layout.caption.top + (layout.caption.bottom - layout.caption.top - metrics.height) / 2,
|
|
ink, std::nullopt, text_right - text_left);
|
|
paint_caption_buttons(handle, window, layout, canvas, is_active);
|
|
}
|
|
if (layout.menu_height) {
|
|
auto &renderer = objects.text();
|
|
const auto metrics = renderer.metrics(interface_font());
|
|
const auto *menu = objects.menu(window.menu);
|
|
const auto rects = menu_bar_items(window);
|
|
for (size_t index = 0; menu && index < rects.size() && index < menu->items.size(); ++index) {
|
|
const auto &rect = rects[index];
|
|
if (rect.right > layout.menu_bar.right)
|
|
break;
|
|
const auto [label, mnemonic] = menu_label(menu->items[index].text);
|
|
if (open_menu_item && open_menu_window == handle && *open_menu_item == index)
|
|
shapes.rounded(rect.left + 1, rect.top + 2, rect.right - 1, rect.bottom - 2, 4, dark ? shade(0x3a, 0x3a, 0x3a) : shade(0xe0, 0xe4, 0xea),
|
|
std::nullopt);
|
|
draw_text(renderer, canvas, label, rect.left + 8, rect.top + (rect.bottom - rect.top - metrics.height) / 2,
|
|
(menu->items[index].state & 3) ? (dark ? shade(0x6e, 0x6e, 0x6e) : shade(0xa0, 0xa0, 0xa0)) : dark ? shade(0xff, 0xff, 0xff)
|
|
: shade(0x1a, 0x1a, 0x1a), mnemonic);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
void NativeWindows::paint_nonclient(uint64_t)
|
|
{
|
|
// Without the text engine, nonclient text cannot be drawn; the window keeps its unpainted frame.
|
|
}
|
|
|
|
std::vector<DesktopRect> NativeWindows::menu_bar_items(const DesktopWindow &)
|
|
{
|
|
return {};
|
|
}
|
|
|
|
uint32_t NativeWindows::caption_color(const DesktopWindow &window, bool is_active) const
|
|
{
|
|
if (window.dark_frame)
|
|
return is_active ? 0x202020U : 0x2b2b2bU;
|
|
return is_active ? 0xf9f4efU : 0xf3f3f3U;
|
|
}
|
|
|
|
void NativeWindows::paint_caption_buttons(uint64_t, const DesktopWindow &, const FrameLayout &, Canvas &, bool)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
}
|