Mirror-bot/raven
1
1 Fork 0
mirror of https://github.com/mirkobrombin/raven.git synced 2026-11-03 21:46:32 +00:00
Code Issues Projects Releases Activity
Files
91eed7db6cf559ece58261ce72110ca2d433c19d
raven/native/desktop/gdi_api.cpp
T

1867 lines
75 KiB
C++
Raw Blame History

#include "api.h"
#include "gdi.h"
#include "nt/api.h"
#include "nt/text.h"
#include <sys/mman.h>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <new>
namespace raven {
namespace {
constexpr uint32_t clr_invalid = 0xffffffffU;
struct Point { int32_t x, y; };
Point read_point(const ApiCall &call, uint64_t address)
{
return {call.load<int32_t>(address), call.load<int32_t>(address + 4)};
}
DesktopRect read_rect(const ApiCall &call, uint64_t address)
{
return {call.load<int32_t>(address), call.load<int32_t>(address + 4), call.load<int32_t>(address + 8), call.load<int32_t>(address + 12)};
}
void write_point(const ApiCall &call, uint64_t address, int32_t x, int32_t y)
{
if (!address)
return;
call.store<int32_t>(address, x);
call.store<int32_t>(address + 4, y);
}
// One decoded device-independent bitmap: top-down BGRA rows with no alpha semantics unless the source carried it.
struct DibImage {
int32_t width = 0, height = 0;
std::vector<uint32_t> pixels;
bool has_alpha = false;
};
// Reads BITMAPINFO plus the pixel data and converts any supported depth to 32-bit pixels (0xAARRGGBB), rows top to bottom.
// Fewer rows than the image height may be supplied; they are the first rows in storage order and the others stay zero.
DibImage decode_dib(const ApiCall &call, uint64_t info, uint64_t bits, uint32_t usage, uint32_t rows_available = 0, int32_t *source_height_out = nullptr)
{
const auto header_size = call.load<uint32_t>(info);
if (header_size < 40)
throw uint32_t(87);
DibImage image;
const auto width = call.load<int32_t>(info + 4);
const auto height = call.load<int32_t>(info + 8);
const auto bit_count = call.load<uint16_t>(info + 14);
const auto compression = call.load<uint32_t>(info + 16);
auto colors_used = call.load<uint32_t>(info + 32);
if (width <= 0 || !height || width > 16384 || std::abs(int64_t(height)) > 16384)
throw uint32_t(87);
if (compression != 0 && compression != 3)
throw uint32_t(120);
const bool top_down = height < 0;
const uint32_t rows = uint32_t(std::abs(int64_t(height)));
if (source_height_out)
*source_height_out = int32_t(rows);
if (!(bit_count == 1 || bit_count == 4 || bit_count == 8 || bit_count == 16 || bit_count == 24 || bit_count == 32))
throw uint32_t(87);
uint64_t palette = info + header_size;
uint32_t masks[3] = {0, 0, 0};
if (compression == 3) {
for (unsigned i = 0; i < 3; ++i)
masks[i] = call.load<uint32_t>(palette + i * 4);
palette += header_size == 40 ? 12 : 0;
}
if (bit_count <= 8 && (!colors_used || colors_used > (1U << bit_count)))
colors_used = 1U << bit_count;
std::vector<uint32_t> table(bit_count <= 8 ? 256 : 0, 0);
if (bit_count <= 8 && usage != 1)
for (uint32_t i = 0; i < colors_used; ++i)
table[i] = call.load<uint32_t>(palette + i * 4) & 0xffffff;
const size_t stride = ((size_t(width) * bit_count + 31) / 32) * 4;
const uint32_t take = rows_available ? std::min(rows_available, rows) : rows;
image.width = width;
image.height = int32_t(rows);
image.pixels.assign(size_t(width) * rows, 0);
const auto payload = call.read(bits, stride * take);
for (uint32_t stored = 0; stored < take; ++stored) {
const uint32_t row = top_down ? stored : rows - 1 - stored;
const uint8_t *line = payload.data() + size_t(stored) * stride;
for (int32_t x = 0; x < width; ++x) {
uint32_t value = 0;
switch (bit_count) {
case 1: value = table[(line[x / 8] >> (7 - x % 8)) & 1]; break;
case 4: value = table[(line[x / 2] >> (x % 2 ? 0 : 4)) & 15]; break;
case 8: value = table[line[x]]; break;
case 16: {
const uint32_t word = line[x * 2] | (uint32_t(line[x * 2 + 1]) << 8);
if (compression == 3 && masks[1] == 0x7e0)
value = (((word >> 11) & 31) * 255 / 31) << 16 | (((word >> 5) & 63) * 255 / 63) << 8 | ((word & 31) * 255 / 31);
else
value = (((word >> 10) & 31) * 255 / 31) << 16 | (((word >> 5) & 31) * 255 / 31) << 8 | ((word & 31) * 255 / 31);
break;
}
case 24: value = line[x * 3 + 2] << 16 | line[x * 3 + 1] << 8 | line[x * 3]; break;
default:
value = uint32_t(line[x * 4 + 2]) << 16 | uint32_t(line[x * 4 + 1]) << 8 | line[x * 4] | uint32_t(line[x * 4 + 3]) << 24;
if (line[x * 4 + 3])
image.has_alpha = true;
}
image.pixels[size_t(row) * width + x] = value;
}
}
return image;
}
uint32_t colorref(uint32_t rgb) { return ((rgb & 0xff) << 16) | (rgb & 0xff00) | ((rgb >> 16) & 0xff); }
// COLORREF to 0x00RRGGBB.
uint32_t to_rgb(uint32_t color) { return colorref(color); }
}
void NativeDesktop::register_gdi_api(ApiRegistry &registry)
{
// Marks the window behind a leased DC as changed so the next message retrieval presents it.
const auto touched = [this](const DesktopDC &dc) {
if (dc.window && dc.leased && updated)
updated(dc.window);
};
const auto require_dc = [this](const ApiCall &call, size_t index) -> DesktopDC & {
auto *dc = objects.dc(call[index]);
if (!dc)
throw uint32_t(6);
return *dc;
};
// Runs a drawing handler, translating thrown Windows errors into last-error and a zero return.
const auto guarded = [](ApiCall &call, uint64_t failure, const std::function<void()> &body) {
try {
body();
} catch (const uint32_t &error) {
call.fail(error, failure);
} catch (const std::bad_alloc &) {
call.fail(8, failure);
}
};
// ---- device context state ----
registry.add("SaveDC", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
DesktopDCState state;
state.bitmap = dc.bitmap; state.font = dc.font; state.brush = dc.brush; state.pen = dc.pen;
state.clip = dc.clip; state.application_clip = dc.application_clip; state.bounds = dc.bounds;
state.text_color = dc.text_color; state.background_color = dc.background_color; state.background_mode = dc.background_mode;
state.rop2 = dc.rop2; state.text_align = dc.text_align; state.poly_fill = dc.poly_fill;
state.origin_x = dc.origin_x; state.origin_y = dc.origin_y; state.position_x = dc.position_x; state.position_y = dc.position_y;
state.brush_org_x = dc.brush_org_x; state.brush_org_y = dc.brush_org_y; state.window_org_x = dc.window_org_x;
state.window_org_y = dc.window_org_y; state.viewport_org_x = dc.viewport_org_x; state.viewport_org_y = dc.viewport_org_y;
state.graphics_mode = dc.graphics_mode; state.world = dc.world;
dc.saved.push_back(std::move(state));
call.ret(dc.saved.size());
});
});
registry.add("RestoreDC", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const int32_t requested = call.i32(1);
const int64_t index = requested < 0 ? int64_t(dc.saved.size()) + requested : int64_t(requested) - 1;
if (index < 0 || index >= int64_t(dc.saved.size()))
throw uint32_t(87);
const auto state = dc.saved[size_t(index)];
dc.saved.resize(size_t(index));
// Objects deleted while saved cannot be reselected; the DC keeps what it has.
if (objects.font(state.font)) objects.select_font(call[0], state.font);
if (objects.brush(state.brush)) objects.select_brush(call[0], state.brush);
if (objects.pen(state.pen)) objects.select_pen(call[0], state.pen);
dc.clip = state.clip; dc.application_clip = state.application_clip; dc.bounds = state.bounds;
dc.text_color = state.text_color; dc.background_color = state.background_color; dc.background_mode = state.background_mode;
dc.rop2 = state.rop2; dc.text_align = state.text_align; dc.poly_fill = state.poly_fill;
dc.origin_x = state.origin_x; dc.origin_y = state.origin_y; dc.position_x = state.position_x; dc.position_y = state.position_y;
dc.brush_org_x = state.brush_org_x; dc.brush_org_y = state.brush_org_y; dc.window_org_x = state.window_org_x;
dc.window_org_y = state.window_org_y; dc.viewport_org_x = state.viewport_org_x; dc.viewport_org_y = state.viewport_org_y;
dc.user_dx = state.viewport_org_x - state.window_org_x; dc.user_dy = state.viewport_org_y - state.window_org_y;
dc.graphics_mode = state.graphics_mode; dc.world = state.world;
call.ret(1);
});
});
registry.add("SetGraphicsMode", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const uint32_t mode = call.u32(1);
if (mode != 1 && mode != 2)
throw uint32_t(87);
// Leaving the advanced mode drops a world transform that is not the identity, as Windows refuses to keep one.
if (mode == 1 && dc.world != std::array<float, 6>{1, 0, 0, 1, 0, 0})
throw uint32_t(87);
const auto previous = dc.graphics_mode;
dc.graphics_mode = mode;
call.ret(previous);
});
});
registry.add("GetGraphicsMode", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] { call.ret(require_dc(call, 0).graphics_mode); });
});
// XFORM: eM11, eM12, eM21, eM22, eDx, eDy.
const auto read_xform = [](ApiCall &call, uint64_t address) {
std::array<float, 6> value{};
const auto bytes = call.read(address, 24);
std::memcpy(value.data(), bytes.data(), 24);
return value;
};
const auto multiply = [](const std::array<float, 6> &a, const std::array<float, 6> &b) {
return std::array<float, 6>{a[0] * b[0] + a[1] * b[2], a[0] * b[1] + a[1] * b[3], a[2] * b[0] + a[3] * b[2], a[2] * b[1] + a[3] * b[3],
a[4] * b[0] + a[5] * b[2] + b[4], a[4] * b[1] + a[5] * b[3] + b[5]};
};
registry.add("SetWorldTransform", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
if (dc.graphics_mode != 2 || !call[1])
throw uint32_t(87);
dc.world = read_xform(call, call[1]);
call.ret(1);
});
});
registry.add("GetWorldTransform", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
if (!call[1])
throw uint32_t(87);
call.write(call[1], std::span<const uint8_t>(reinterpret_cast<const uint8_t *>(dc.world.data()), 24));
call.ret(1);
});
});
// GetTransform(dc, which, XFORM): world to page (0x203) is the world transform; page to device (0x304) moves the window origin onto the
// viewport origin, the whole MM_TEXT mapping these device contexts keep; world to device (0x204) is their product and device to world
// (0x402) its inverse. GDI+ reads world to device to place what it draws on a context whose origin a program moved.
registry.add("GetTransform", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const uint32_t which = call.u32(1);
if (!call[2] || (which != 0x203 && which != 0x304 && which != 0x204 && which != 0x402))
throw uint32_t(87);
const float dx = float(dc.viewport_org_x - dc.window_org_x), dy = float(dc.viewport_org_y - dc.window_org_y);
const auto &w = dc.world;
std::array<float, 6> result = which == 0x203 ? w : which == 0x304 ? std::array<float, 6>{1, 0, 0, 1, dx, dy} :
std::array<float, 6>{w[0], w[1], w[2], w[3], w[4] + dx, w[5] + dy};
if (which == 0x402) {
const auto t = result;
const float determinant = t[0] * t[3] - t[1] * t[2];
if (determinant == 0)
throw uint32_t(87);
result = {t[3] / determinant, -t[1] / determinant, -t[2] / determinant, t[0] / determinant,
(t[2] * t[5] - t[3] * t[4]) / determinant, (t[1] * t[4] - t[0] * t[5]) / determinant};
}
call.write(call[2], std::span<const uint8_t>(reinterpret_cast<const uint8_t *>(result.data()), 24));
call.ret(1);
});
});
registry.add("ModifyWorldTransform", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const uint32_t mode = call.u32(2);
// Resetting to the identity takes no matrix and changes nothing a compatible-mode context could use; the other modes need
// GM_ADVANCED.
if (mode < 1 || mode > 3 || (mode != 1 && (dc.graphics_mode != 2 || !call[1])))
throw uint32_t(87);
if (mode == 1)
dc.world = {1, 0, 0, 1, 0, 0};
else if (mode == 2)
dc.world = multiply(read_xform(call, call[1]), dc.world);
else
dc.world = multiply(dc.world, read_xform(call, call[1]));
call.ret(1);
});
});
registry.add("SetTextAlign", 2, [=, this](ApiCall &call) {
guarded(call, clr_invalid, [&] {
auto &dc = require_dc(call, 0);
const auto previous = dc.text_align;
dc.text_align = call.u32(1);
call.ret(previous);
});
});
registry.add("GetTextAlign", 1, [=, this](ApiCall &call) {
guarded(call, clr_invalid, [&] { call.ret(require_dc(call, 0).text_align); });
});
registry.add("SetPolyFillMode", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
if (call.u32(1) != 1 && call.u32(1) != 2)
throw uint32_t(87);
const auto previous = dc.poly_fill;
dc.poly_fill = call.u32(1);
call.ret(previous);
});
});
registry.add("GetPolyFillMode", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] { call.ret(require_dc(call, 0).poly_fill); });
});
registry.add("GetROP2", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] { call.ret(require_dc(call, 0).rop2); });
});
registry.add("GetMapMode", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0);
call.ret(1);
});
});
registry.add("SetMapMode", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0);
// Only the default mapping exists; requesting another one fails visibly.
if (call.u32(1) != 1)
throw uint32_t(120);
call.ret(1);
});
});
registry.add("SetStretchBltMode", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0);
call.ret(1);
});
});
registry.add("SetBrushOrgEx", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[3], dc.brush_org_x, dc.brush_org_y);
dc.brush_org_x = call.i32(1);
dc.brush_org_y = call.i32(2);
call.ret(1);
});
});
registry.add("GetBrushOrgEx", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[1], dc.brush_org_x, dc.brush_org_y);
call.ret(1);
});
});
// Window and viewport origins shift logical coordinates; the DC origin carries the sum and clip regions stay in device units.
const auto shift_origin = [this](DesktopDC &dc, int32_t window_x, int32_t window_y, int32_t viewport_x, int32_t viewport_y) {
const int32_t dx = (viewport_x - dc.viewport_org_x) - (window_x - dc.window_org_x);
const int32_t dy = (viewport_y - dc.viewport_org_y) - (window_y - dc.window_org_y);
dc.window_org_x = window_x; dc.window_org_y = window_y; dc.viewport_org_x = viewport_x; dc.viewport_org_y = viewport_y;
dc.origin_x += dx; dc.origin_y += dy; dc.user_dx += dx; dc.user_dy += dy;
};
registry.add("SetViewportOrgEx", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[3], dc.viewport_org_x, dc.viewport_org_y);
shift_origin(dc, dc.window_org_x, dc.window_org_y, call.i32(1), call.i32(2));
call.ret(1);
});
});
registry.add("OffsetViewportOrgEx", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[3], dc.viewport_org_x, dc.viewport_org_y);
shift_origin(dc, dc.window_org_x, dc.window_org_y, dc.viewport_org_x + call.i32(1), dc.viewport_org_y + call.i32(2));
call.ret(1);
});
});
registry.add("SetWindowOrgEx", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[3], dc.window_org_x, dc.window_org_y);
shift_origin(dc, call.i32(1), call.i32(2), dc.viewport_org_x, dc.viewport_org_y);
call.ret(1);
});
});
registry.add("OffsetWindowOrgEx", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[3], dc.window_org_x, dc.window_org_y);
shift_origin(dc, dc.window_org_x + call.i32(1), dc.window_org_y + call.i32(2), dc.viewport_org_x, dc.viewport_org_y);
call.ret(1);
});
});
registry.add("GetViewportOrgEx", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[1], dc.viewport_org_x, dc.viewport_org_y);
call.ret(1);
});
});
registry.add("GetWindowOrgEx", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
write_point(call, call[1], dc.window_org_x, dc.window_org_y);
call.ret(1);
});
});
// Logical and device coordinates differ only by the window and viewport origins.
registry.add("DPtoLP", 3, [=, this](ApiCall &call) {
// An unknown device context fails silently, and a non-positive count has nothing to convert.
auto *dc = objects.dc(call[0]);
if (!dc) {
call.ret(0);
return;
}
const int32_t count = call.i32(2);
if (count > 65536) {
call.fail(120, 0);
return;
}
for (int32_t i = 0; i < count; ++i) {
const auto at = call[1] + uint64_t(i) * 8;
call.store<int32_t>(at, call.load<int32_t>(at) - dc->user_dx);
call.store<int32_t>(at + 4, call.load<int32_t>(at + 4) - dc->user_dy);
}
call.ret(1);
});
registry.add("LPtoDP", 3, [=, this](ApiCall &call) {
// An unknown device context fails silently, and a non-positive count has nothing to convert.
auto *dc = objects.dc(call[0]);
if (!dc) {
call.ret(0);
return;
}
const int32_t count = call.i32(2);
if (count > 65536) {
call.fail(120, 0);
return;
}
for (int32_t i = 0; i < count; ++i) {
const auto at = call[1] + uint64_t(i) * 8;
call.store<int32_t>(at, call.load<int32_t>(at) + dc->user_dx);
call.store<int32_t>(at + 4, call.load<int32_t>(at + 4) + dc->user_dy);
}
call.ret(1);
});
registry.add("GetNearestColor", 2, [=, this](ApiCall &call) {
guarded(call, clr_invalid, [&] {
require_dc(call, 0);
call.ret(call.u32(1) & 0xffffff);
});
});
registry.add("SelectPalette", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0);
call.ret(0);
});
});
registry.add("GetPixel", 3, [=, this](ApiCall &call) {
guarded(call, clr_invalid, [&] {
auto &dc = require_dc(call, 0);
Painter painter(objects, dc);
const int64_t x = int64_t(call.i32(1)) + dc.origin_x, y = int64_t(call.i32(2)) + dc.origin_y;
call.ret(painter.visible(x, y) ? painter.read(x, y) : clr_invalid);
});
});
// ---- stock objects ----
registry.add("GetStockObject", 1, [=, this](ApiCall &call) {
const uint32_t index = call.u32(0);
if (index < 6) call.ret(desktop_stock_brush + index);
else if (index <= 8) call.ret(desktop_stock_pen + index - 6);
else if (index == 18) call.ret(desktop_stock_brush + 6);
else if (index == 19) call.ret(desktop_stock_pen + 3);
else if (index == 10 || index == 11 || index == 16) call.ret(desktop_fixed_font);
else if (index == 12 || index == 17 || index == 14) call.ret(desktop_gui_font);
else if (index == 13) call.ret(desktop_system_font);
else if (index == 15) call.ret(0x7fff0001);
else call.fail(87);
});
registry.add("SetDCBrushColor", 2, [=, this](ApiCall &call) {
guarded(call, clr_invalid, [&] {
require_dc(call, 0);
call.ret(objects.set_dc_brush_color(call.u32(1) & 0xffffff));
});
});
registry.add("SetDCPenColor", 2, [=, this](ApiCall &call) {
guarded(call, clr_invalid, [&] {
require_dc(call, 0);
call.ret(objects.set_dc_pen_color(call.u32(1) & 0xffffff));
});
});
// ---- brushes and pens ----
// LOGBRUSH: style, color, then a hatch index or bitmap handle that is as wide as the program's pointers.
registry.add("CreateBrushIndirect", 1, [=, this, &registry](ApiCall &call) {
guarded(call, 0, [&] {
if (!call[0])
throw uint32_t(87);
const auto style = call.load<uint32_t>(call[0]);
const auto color = call.load<uint32_t>(call[0] + 4) & 0xffffff;
const uint64_t detail = call.process.mode() == NativeMode::x86 ? call.load<uint32_t>(call[0] + 8) : call.load<uint64_t>(call[0] + 8);
DesktopBrush brush;
switch (style) {
case 0:
brush.color = color;
break;
case 1:
brush.hollow = true;
break;
case 2:
if (detail > 5)
throw uint32_t(87);
brush.color = color;
brush.style = 2;
brush.hatch = uint32_t(detail);
break;
case 3: {
// A pattern brush takes the bitmap named by the third member.
const auto entry = registry.find("CreatePatternBrush");
if (!entry)
throw uint32_t(120);
ApiCall inner(call.process, call.environment, {detail});
entry->second(inner);
call.ret(inner.result);
return;
}
default:
throw uint32_t(120);
}
const auto handle = objects.add(brush);
if (!handle)
throw uint32_t(8);
call.ret(handle);
});
});
registry.add("CreateHatchBrush", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
if (call.u32(0) > 5)
throw uint32_t(87);
DesktopBrush brush;
brush.color = call.u32(1) & 0xffffff;
brush.style = 2;
brush.hatch = call.u32(0);
const auto handle = objects.add(brush);
if (!handle)
throw uint32_t(8);
call.ret(handle);
});
});
registry.add("CreatePatternBrush", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const auto *bitmap = objects.bitmap(call[0]);
if (!bitmap)
throw uint32_t(6);
DesktopBrush brush;
brush.style = 3;
brush.pattern_width = bitmap->width;
brush.pattern_height = bitmap->height;
brush.pattern_mono = bitmap->depth == 1;
brush.pattern.assign(size_t(bitmap->width) * bitmap->height, 0);
const auto pixels = bitmap->pixels();
for (uint32_t y = 0; y < bitmap->height; ++y)
for (uint32_t x = 0; x < bitmap->width; ++x) {
const size_t row = bitmap->top_down ? y : bitmap->height - 1 - y;
uint32_t value;
if (bitmap->depth == 1) {
const size_t stride = ((size_t(bitmap->width) + 15) / 16) * 2;
value = (pixels[row * stride + x / 8] >> (7 - x % 8)) & 1;
} else {
const auto *p = &pixels[(row * bitmap->width + x) * 4];
value = uint32_t(p[2]) | uint32_t(p[1]) << 8 | uint32_t(p[0]) << 16;
}
brush.pattern[size_t(y) * bitmap->width + x] = value;
}
const auto handle = objects.add(std::move(brush));
if (!handle)
throw uint32_t(8);
call.ret(handle);
});
});
const auto make_pen = [this](uint32_t style, int32_t width, uint32_t color, bool geometric) {
DesktopPen pen;
pen.color = color & 0xffffff;
pen.style = style;
pen.hollow = style == 5;
pen.width = width;
pen.geometric = geometric;
const auto handle = objects.add(pen);
if (!handle)
throw uint32_t(8);
return handle;
};
registry.add("CreatePen", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
if ((call.u32(0) & 0xff) > 6 || call.i32(1) < 0)
throw uint32_t(87);
call.ret(make_pen(call.u32(0) & 0xff, call.i32(1), call.u32(2), false));
});
});
registry.add("CreatePenIndirect", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const auto style = call.load<uint32_t>(call[0]);
if ((style & 0xff) > 6)
throw uint32_t(87);
call.ret(make_pen(style & 0xff, call.load<int32_t>(call[0] + 4), call.load<uint32_t>(call[0] + 12), false));
});
});
registry.add("ExtCreatePen", 5, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const auto style = call.u32(0);
const bool geometric = (style & 0xf0000) == 0x10000;
if ((style & 0xff) > 7 || !call[2])
throw uint32_t(87);
call.ret(make_pen(std::min<uint32_t>(style & 0xff, 6), int32_t(call.u32(1)), call.load<uint32_t>(call[2] + 4), geometric));
});
});
// ---- bitmaps ----
registry.add("CreateBitmap", 5, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const int32_t width = call.i32(0), height = call.i32(1);
const uint32_t planes = call.u32(2), bits_per_pixel = call.u32(3);
if (width <= 0 || height <= 0 || width > 16384 || height > 16384 || planes != 1 ||
!(bits_per_pixel == 1 || bits_per_pixel == 4 || bits_per_pixel == 8 || bits_per_pixel == 16 || bits_per_pixel == 24 || bits_per_pixel == 32))
throw uint32_t(87);
const auto handle = allocate_bitmap(uint32_t(width), uint32_t(height), bits_per_pixel == 1 ? 1 : 32, false, true);
if (!handle)
return;
auto *bitmap = objects.bitmap(handle);
if (call[4]) {
// DDB bits are word-aligned rows, top row first.
const size_t stride = ((size_t(width) * bits_per_pixel + 15) / 16) * 2;
const auto source = call.read(call[4], stride * size_t(height));
auto destination = bitmap->pixels();
for (int32_t y = 0; y < height; ++y)
for (int32_t x = 0; x < width; ++x) {
const uint8_t *line = source.data() + size_t(y) * stride;
if (bits_per_pixel == 1) {
const size_t target_stride = ((size_t(width) + 15) / 16) * 2;
const bool set = (line[x / 8] >> (7 - x % 8)) & 1;
auto &byte = destination[size_t(y) * target_stride + x / 8];
byte = uint8_t(set ? (byte | (0x80 >> (x % 8))) : (byte & ~(0x80 >> (x % 8))));
continue;
}
uint8_t blue = 0, green = 0, red = 0;
switch (bits_per_pixel) {
case 32: blue = line[x * 4]; green = line[x * 4 + 1]; red = line[x * 4 + 2]; break;
case 24: blue = line[x * 3]; green = line[x * 3 + 1]; red = line[x * 3 + 2]; break;
case 16: {
const uint32_t word = line[x * 2] | (uint32_t(line[x * 2 + 1]) << 8);
red = uint8_t(((word >> 10) & 31) * 255 / 31); green = uint8_t(((word >> 5) & 31) * 255 / 31); blue = uint8_t((word & 31) * 255 / 31);
break;
}
default: {
const uint32_t shift = bits_per_pixel == 8 ? 0 : (x % 2 ? 0 : 4);
const uint32_t index = bits_per_pixel == 8 ? line[x] : (line[x / 2] >> shift) & 15;
blue = green = red = uint8_t(index * 255 / (bits_per_pixel == 8 ? 255 : 15));
}
}
auto *p = &destination[(size_t(y) * width + x) * 4];
p[0] = blue; p[1] = green; p[2] = red; p[3] = 0;
}
} else if (bitmap->depth == 1) {
// Uninitialized monochrome bitmaps start black.
}
call.ret(handle);
});
});
registry.add("SetBitmapDimensionEx", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto *bitmap = objects.bitmap(call[0]);
if (!bitmap)
throw uint32_t(6);
if (call[3]) {
call.store<int32_t>(call[3], bitmap->dimension_x);
call.store<int32_t>(call[3] + 4, bitmap->dimension_y);
}
bitmap->dimension_x = call.i32(1);
bitmap->dimension_y = call.i32(2);
call.ret(1);
});
});
registry.add("GetBitmapDimensionEx", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const auto *bitmap = objects.bitmap(call[0]);
if (!bitmap || !call[1])
throw uint32_t(bitmap ? 87 : 6);
call.store<int32_t>(call[1], bitmap->dimension_x);
call.store<int32_t>(call[1] + 4, bitmap->dimension_y);
call.ret(1);
});
});
registry.add("SetBitmapBits", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto *bitmap = objects.bitmap(call[0]);
if (!bitmap)
throw uint32_t(6);
auto pixels = bitmap->pixels();
const size_t size = std::min<size_t>(call.u32(1), pixels.size());
const auto data = call.read(call[2], size);
if (bitmap->top_down || bitmap->depth == 1) {
std::copy(data.begin(), data.end(), pixels.begin());
} else {
const size_t stride = size_t(bitmap->width) * 4;
for (size_t offset = 0; offset < size; ++offset) {
const size_t row = offset / stride;
pixels[(bitmap->height - 1 - row) * stride + offset % stride] = data[offset];
}
}
call.ret(size);
});
});
// ---- regions ----
const auto box_region = [](int32_t left, int32_t top, int32_t right, int32_t bottom) {
DesktopRegion region;
if (right > left && bottom > top)
region.add({left, top, right, bottom});
return region;
};
const auto adopt = [this](DesktopRegion region, ApiCall &call) {
const auto handle = objects.add(std::move(region));
if (!handle)
throw uint32_t(8);
call.ret(handle);
};
registry.add("CreateRectRgnIndirect", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const auto rect = read_rect(call, call[0]);
adopt(box_region(std::min(rect.left, rect.right), std::min(rect.top, rect.bottom), std::max(rect.left, rect.right), std::max(rect.top, rect.bottom)), call);
});
});
registry.add("CreateRoundRectRgn", 6, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const int64_t left = call.i32(0), top = call.i32(1), right = call.i32(2), bottom = call.i32(3);
if (right <= left || bottom <= top || right - left > 16384 || bottom - top > 16384)
throw uint32_t(87);
DesktopRegion region;
const double rx = std::min<double>(std::abs(call.i32(4)), double(right - left)) / 2.0, ry = std::min<double>(std::abs(call.i32(5)), double(bottom - top)) / 2.0;
for (int64_t y = top; y < bottom; ++y) {
const double row = double(y - top) + 0.5;
double inset = 0;
const double height = double(bottom - top);
double dy = row < ry ? ry - row : row > height - ry ? row - (height - ry) : 0;
if (dy > 0 && ry > 0)
inset = rx - rx * std::sqrt(std::max(0.0, 1.0 - (dy / ry) * (dy / ry)));
region.add({int32_t(left + std::floor(inset + 0.5)), int32_t(y), int32_t(right - std::floor(inset + 0.5)), int32_t(y + 1)});
}
adopt(std::move(region), call);
});
});
// The pixels closed polygons cover, row by row at pixel centres: ALTERNATE (even_odd) or WINDING filling over the edges of all of
// them together, each polygon closed back to its first point.
const auto fill_polygons = [](const std::vector<std::vector<std::array<double, 2>>> &polygons, bool even_odd) {
double min_y = INFINITY, max_y = -INFINITY;
for (const auto &polygon : polygons)
for (const auto &point : polygon) {
min_y = std::min(min_y, point[1]);
max_y = std::max(max_y, point[1]);
}
DesktopRegion region;
if (!(min_y < max_y))
return region;
if (max_y - min_y > 16384)
throw uint32_t(120);
for (int32_t y = int32_t(std::floor(min_y)); y < int32_t(std::ceil(max_y)); ++y) {
std::vector<std::pair<double, int>> crossings;
const double center = y + 0.5;
for (const auto &points : polygons)
for (size_t i = 0; i < points.size(); ++i) {
const auto &a = points[i], &b = points[(i + 1) % points.size()];
if (a[1] == b[1] || center < std::min(a[1], b[1]) || center >= std::max(a[1], b[1]))
continue;
const double t = (center - a[1]) / (b[1] - a[1]);
crossings.push_back({a[0] + t * (b[0] - a[0]), b[1] > a[1] ? 1 : -1});
}
std::sort(crossings.begin(), crossings.end());
int winding = 0;
for (size_t i = 0; i + 1 < crossings.size(); ++i) {
winding += crossings[i].second;
if (!(even_odd ? i % 2 == 0 : winding != 0))
continue;
const int32_t from = int32_t(std::ceil(crossings[i].first - 0.5)), to = int32_t(std::ceil(crossings[i + 1].first - 0.5));
if (to > from)
region.add({from, y, to, y + 1});
}
}
return region;
};
registry.add("CreatePolygonRgn", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const int32_t count = call.i32(1);
if (count < 3 || count > 65536)
throw uint32_t(87);
std::vector<std::array<double, 2>> points;
for (int32_t i = 0; i < count; ++i) {
const auto point = read_point(call, call[0] + uint64_t(i) * 8);
points.push_back({double(point.x), double(point.y)});
}
adopt(fill_polygons({points}, call.u32(2) != 2), call);
});
});
// ---- paths ----
// BeginPath opens a bracket in which PolyDraw records figures instead of drawing; EndPath closes it, AbortPath drops it.
registry.add("BeginPath", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0).path = DesktopDC::Path{};
call.ret(1);
});
});
registry.add("EndPath", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
if (!dc.path || !dc.path->open)
throw uint32_t(1003);
dc.path->open = false;
call.ret(1);
});
});
registry.add("AbortPath", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0).path.reset();
call.ret(1);
});
});
registry.add("CloseFigure", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
if (!dc.path || !dc.path->open || dc.path->figures.empty())
throw uint32_t(1003);
// The next point starts a figure of its own.
dc.path->figures.push_back({});
call.ret(1);
});
});
// PolyDraw(dc, points, types, count): PT_MOVETO (6) starts a figure, PT_LINETO (2) and three PT_BEZIERTO (4) points extend it, and
// PT_CLOSEFIGURE (1) on a point closes it. Inside a path bracket the figures are recorded; outside they are stroked with the pen.
registry.add("PolyDraw", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const int32_t count = call.i32(3);
if (count < 0 || count > 65536 || (count && (!call[1] || !call[2])))
throw uint32_t(87);
const auto types = call.read(call[2], size_t(count));
std::vector<std::vector<std::array<double, 2>>> figures;
std::array<double, 2> current{double(dc.position_x), double(dc.position_y)};
bool closed = true;
const auto point_at = [&](int32_t index) {
const auto point = read_point(call, call[1] + uint64_t(index) * 8);
return std::array<double, 2>{double(point.x), double(point.y)};
};
const auto extend = [&](const std::array<double, 2> &point) {
if (closed)
figures.push_back({current});
closed = false;
figures.back().push_back(point);
current = point;
};
for (int32_t index = 0; index < count; ++index) {
const uint8_t type = types[size_t(index)] & ~1;
if (type == 6) {
current = point_at(index);
closed = true;
} else if (type == 2) {
extend(point_at(index));
} else if (type == 4 && index + 2 < count && (types[size_t(index) + 1] & ~1) == 4 && (types[size_t(index) + 2] & ~1) == 4) {
// A cubic Bezier from the current point, flattened into short lines.
const auto start = current, first = point_at(index), second = point_at(index + 1), end = point_at(index + 2);
for (int step = 1; step <= 16; ++step) {
const double t = step / 16.0, u = 1 - t;
extend({u * u * u * start[0] + 3 * u * u * t * first[0] + 3 * u * t * t * second[0] + t * t * t * end[0],
u * u * u * start[1] + 3 * u * u * t * first[1] + 3 * u * t * t * second[1] + t * t * t * end[1]});
}
index += 2;
} else {
throw uint32_t(87);
}
if ((types[size_t(index)] & 1) && !closed && !figures.empty()) {
current = figures.back().front();
if (!dc.path || !dc.path->open)
figures.back().push_back(current);
closed = true;
}
}
dc.position_x = int32_t(std::lround(current[0]));
dc.position_y = int32_t(std::lround(current[1]));
if (dc.path && dc.path->open) {
if (!dc.path->figures.empty() && dc.path->figures.back().empty())
dc.path->figures.pop_back();
for (auto &figure : figures)
dc.path->figures.push_back(std::move(figure));
call.ret(1);
return;
}
Painter painter(objects, dc);
for (const auto &figure : figures) {
std::vector<std::pair<int32_t, int32_t>> points;
for (const auto &point : figure)
points.push_back({int32_t(std::lround(point[0])), int32_t(std::lround(point[1]))});
painter.polyline(points, selected_pen(objects, dc), false);
}
if (painter.changed())
touched(dc);
call.ret(1);
});
});
// FillPath, StrokePath and StrokeAndFillPath(dc): the closed path filled with the brush as the polygon fill mode says, its figures
// outlined, closed, with the pen, or both; the path is used up.
const auto draw_path = [=, this](ApiCall &call, bool fill, bool stroke) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
if (!dc.path || dc.path->open)
throw uint32_t(1003);
const auto figures = std::move(dc.path->figures);
dc.path.reset();
Painter painter(objects, dc);
if (fill) {
const auto &brush = selected_brush(objects, dc);
for (const auto &box : fill_polygons(figures, dc.poly_fill != 2).rectangles())
painter.fill(box.left, box.top, box.right, box.bottom, brush);
}
if (stroke)
for (const auto &figure : figures) {
std::vector<std::pair<int32_t, int32_t>> points;
for (const auto &point : figure)
points.push_back({int32_t(std::lround(point[0])), int32_t(std::lround(point[1]))});
if (points.size() > 1)
painter.polyline(points, selected_pen(objects, dc), true);
}
if (painter.changed())
touched(dc);
call.ret(1);
});
};
registry.add("FillPath", 1, [draw_path](ApiCall &call) { draw_path(call, true, false); });
registry.add("StrokePath", 1, [draw_path](ApiCall &call) { draw_path(call, false, true); });
registry.add("StrokeAndFillPath", 1, [draw_path](ApiCall &call) { draw_path(call, true, true); });
// PathToRegion(dc): the region the closed path covers in device coordinates, filled as the polygon fill mode says; the path is used up.
registry.add("PathToRegion", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
if (!dc.path || dc.path->open)
throw uint32_t(1003);
auto figures = std::move(dc.path->figures);
dc.path.reset();
const double dx = double(dc.viewport_org_x) - dc.window_org_x, dy = double(dc.viewport_org_y) - dc.window_org_y;
for (auto &figure : figures)
for (auto &point : figure) {
point[0] += dx;
point[1] += dy;
}
adopt(fill_polygons(figures, dc.poly_fill != 2), call);
});
});
// SelectClipPath(dc, mode): the closed path becomes the clipping region, combined with the clipping the program set as
// ExtSelectClipRgn combines; the path is used up.
registry.add("SelectClipPath", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const auto mode = call.u32(1);
if (mode < 1 || mode > 5)
throw uint32_t(87);
if (!dc.path || dc.path->open)
throw uint32_t(1003);
auto figures = std::move(dc.path->figures);
dc.path.reset();
const double dx = double(dc.viewport_org_x) - dc.window_org_x, dy = double(dc.viewport_org_y) - dc.window_org_y;
for (auto &figure : figures)
for (auto &point : figure) {
point[0] += dx;
point[1] += dy;
}
auto region = fill_polygons(figures, dc.poly_fill != 2);
std::optional<DesktopRegion> value;
if (mode == 5 || !dc.application_clip) {
value = std::move(region);
} else {
DesktopRegion next;
next.combine(*dc.application_clip, region, mode);
value = std::move(next);
}
if (!objects.select_clip(call[0], std::move(value)))
throw uint32_t(8);
call.ret(1);
});
});
registry.add("ExtCreateRegion", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
if (call.u32(1) < 32 || !call[2])
throw uint32_t(87);
// RGNDATA: RGNDATAHEADER (dwSize, iType, nCount, nRgnSize, rcBound) then RECTs.
const auto header_size = call.load<uint32_t>(call[2]);
const auto count = call.load<uint32_t>(call[2] + 8);
if (header_size != 32 || count > 100000 || call.u32(1) < 32 + count * 16)
throw uint32_t(87);
DesktopRegion region;
for (uint32_t i = 0; i < count; ++i) {
const auto rect = read_rect(call, call[2] + 32 + uint64_t(i) * 16);
if (rect.right > rect.left && rect.bottom > rect.top)
region.add(rect);
}
adopt(std::move(region), call);
});
});
registry.add("FillRgn", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const auto *region = objects.region(call[1]);
const auto *brush = objects.brush(call[2]);
if (!region || !brush)
throw uint32_t(6);
Painter painter(objects, dc);
const auto bounds = region->bounds();
for (int32_t y = bounds.top; y < bounds.bottom; ++y)
for (int32_t x = bounds.left; x < bounds.right; ++x)
if (region->contains(x, y))
painter.fill(x, y, x + 1, y + 1, *brush);
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("FrameRgn", 5, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const auto *region = objects.region(call[1]);
const auto *brush = objects.brush(call[2]);
if (!region || !brush)
throw uint32_t(6);
Painter painter(objects, dc);
const int32_t w = std::max(1, call.i32(3)), h = std::max(1, call.i32(4));
const auto bounds = region->bounds();
for (int32_t y = bounds.top; y < bounds.bottom; ++y)
for (int32_t x = bounds.left; x < bounds.right; ++x) {
if (!region->contains(x, y))
continue;
const bool edge = !region->contains(x - w, y) || !region->contains(x + w, y) || !region->contains(x, y - h) || !region->contains(x, y + h);
if (edge)
painter.fill(x, y, x + 1, y + 1, *brush);
}
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("RectVisible", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const auto rect = read_rect(call, call[1]);
Painter painter(objects, dc);
bool any = false;
for (int32_t y = rect.top; y < rect.bottom && !any; ++y)
for (int32_t x = rect.left; x < rect.right && !any; ++x)
any = painter.visible(int64_t(x) + dc.origin_x, int64_t(y) + dc.origin_y);
call.ret(any);
});
});
// ---- shapes ----
registry.add("Rectangle", 5, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
Painter painter(objects, dc);
int64_t left = call.i32(1), top = call.i32(2), right = call.i32(3), bottom = call.i32(4);
if (right < left) std::swap(left, right);
if (bottom < top) std::swap(top, bottom);
const auto &brush = selected_brush(objects, dc);
const auto &pen = selected_pen(objects, dc);
if (right > left && bottom > top) {
if (!brush.hollow)
painter.fill(left + (pen.hollow ? 0 : 1), top + (pen.hollow ? 0 : 1), right - (pen.hollow ? 0 : 1), bottom - (pen.hollow ? 0 : 1), brush);
if (!pen.hollow) {
const std::pair<int32_t, int32_t> corners[4] = {{int32_t(left), int32_t(top)}, {int32_t(right - 1), int32_t(top)},
{int32_t(right - 1), int32_t(bottom - 1)}, {int32_t(left), int32_t(bottom - 1)}};
painter.polyline(corners, pen, true);
}
}
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("RoundRect", 7, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
Painter painter(objects, dc);
painter.ellipse(call.i32(1), call.i32(2), call.i32(3), call.i32(4), std::abs(call.i32(5)), std::abs(call.i32(6)), true);
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("Ellipse", 5, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
Painter painter(objects, dc);
painter.ellipse(call.i32(1), call.i32(2), call.i32(3), call.i32(4), 0, 0, false);
if (painter.changed())
touched(dc);
call.ret(1);
});
});
const auto read_points = [](const ApiCall &call, uint64_t address, int32_t count) {
if (count < 0 || count > 65536)
throw uint32_t(87);
std::vector<std::pair<int32_t, int32_t>> points;
points.reserve(size_t(count));
const auto bytes = call.read(address, size_t(count) * 8);
for (int32_t i = 0; i < count; ++i) {
int32_t x, y;
std::memcpy(&x, bytes.data() + size_t(i) * 8, 4);
std::memcpy(&y, bytes.data() + size_t(i) * 8 + 4, 4);
points.emplace_back(x, y);
}
return points;
};
registry.add("Polygon", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const auto points = read_points(call, call[1], call.i32(2));
if (points.size() < 2)
throw uint32_t(87);
Painter painter(objects, dc);
painter.polygon(points);
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("Polyline", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const auto points = read_points(call, call[1], call.i32(2));
if (points.size() < 2)
throw uint32_t(87);
Painter painter(objects, dc);
painter.polyline(points, selected_pen(objects, dc), false);
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("PolylineTo", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
auto points = read_points(call, call[1], call.i32(2));
if (points.empty())
throw uint32_t(87);
points.insert(points.begin(), {dc.position_x, dc.position_y});
Painter painter(objects, dc);
painter.polyline(points, selected_pen(objects, dc), false);
dc.position_x = points.back().first;
dc.position_y = points.back().second;
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("PolyPolyline", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const uint32_t polylines = call.u32(3);
if (polylines > 4096)
throw uint32_t(87);
const auto counts = call.read(call[2], size_t(polylines) * 4);
Painter painter(objects, dc);
uint64_t cursor = call[1];
for (uint32_t i = 0; i < polylines; ++i) {
uint32_t count;
std::memcpy(&count, counts.data() + size_t(i) * 4, 4);
const auto points = read_points(call, cursor, int32_t(count));
painter.polyline(points, selected_pen(objects, dc), false);
cursor += uint64_t(count) * 8;
}
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("LineTo", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
Painter painter(objects, dc);
Painter::Stroke stroke;
painter.line(dc.position_x, dc.position_y, call.i32(1), call.i32(2), selected_pen(objects, dc), false, stroke);
dc.position_x = call.i32(1);
dc.position_y = call.i32(2);
if (painter.changed())
touched(dc);
call.ret(1);
});
});
// ---- block transfer ----
const auto blit_to=[=, this](DesktopDC &destination, int32_t dx, int32_t dy, int32_t dw, int32_t dh, DesktopDC *source_dc,
int32_t sx, int32_t sy, int32_t sw, int32_t sh, uint32_t rop) {
if (blit(objects, destination, dx, dy, dw, dh, source_dc, sx, sy, sw, sh, rop))
touched(destination);
};
registry.add("BitBlt", 9, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &destination = require_dc(call, 0);
const uint32_t rop = call.u32(8);
DesktopDC *source = call[5] ? objects.dc(call[5]) : nullptr;
if (call[5] && !source)
throw uint32_t(6);
blit_to(destination, call.i32(1), call.i32(2), call.i32(3), call.i32(4), source, call.i32(6), call.i32(7), call.i32(3), call.i32(4), rop);
call.ret(1);
});
});
registry.add("StretchBlt", 11, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &destination = require_dc(call, 0);
DesktopDC *source = call[5] ? objects.dc(call[5]) : nullptr;
if (call[5] && !source)
throw uint32_t(6);
blit_to(destination, call.i32(1), call.i32(2), call.i32(3), call.i32(4), source, call.i32(6), call.i32(7), call.i32(8), call.i32(9), call.u32(10));
call.ret(1);
});
});
// msimg32's AlphaBlend is gdi32's GdiAlphaBlend under its older name.
registry.add("AlphaBlend", 11, [&registry](ApiCall &call) { registry.find("GdiAlphaBlend")->second(call); });
registry.add("PatBlt", 6, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &destination = require_dc(call, 0);
blit_to(destination, call.i32(1), call.i32(2), call.i32(3), call.i32(4), nullptr, 0, 0, call.i32(3), call.i32(4), call.u32(5));
call.ret(1);
});
});
registry.add("FillRect", 3, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const auto rect = read_rect(call, call[1]);
uint64_t handle = call[2];
// Small integers are system color indices plus one.
if (handle && handle <= 31)
handle = objects.system_brush(int32_t(handle - 1));
const auto *brush = objects.brush(handle);
if (!brush)
throw uint32_t(handle > 0 && handle <= 32 ? 120 : 6);
Painter painter(objects, dc);
painter.fill(rect.left, rect.top, rect.right, rect.bottom, *brush);
if (painter.changed())
touched(dc);
call.ret(1);
});
});
// GradientFill(dc, vertices, vertex count, mesh, mesh count, mode): rectangles blend from the first vertex's color to the second's along one axis.
registry.add("GradientFill", 6, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const uint32_t mode = call.u32(5), vertex_count = call.u32(2), mesh_count = call.u32(4);
if (mode > 1 || !call[1] || !call[3] || vertex_count > 4096 || mesh_count > 4096)
throw uint32_t(mode > 2 ? 87 : 120);
// TRIVERTEX: x, y, then red, green, blue and alpha as 16-bit values.
const auto vertices = call.read(call[1], size_t(vertex_count) * 16);
const auto mesh = call.read(call[3], size_t(mesh_count) * 8);
const auto word = [](const std::vector<uint8_t> &bytes, size_t at, size_t width) {
uint32_t value = 0;
std::memcpy(&value, bytes.data() + at, width);
return value;
};
Painter painter(objects, dc);
for (uint32_t index = 0; index < mesh_count; ++index) {
const uint32_t first = word(mesh, index * 8, 4), second = word(mesh, index * 8 + 4, 4);
if (first >= vertex_count || second >= vertex_count)
throw uint32_t(87);
const auto at = [&](uint32_t vertex, size_t field, size_t width) { return word(vertices, vertex * 16 + field, width); };
const int32_t left = std::min<int32_t>(int32_t(at(first, 0, 4)), int32_t(at(second, 0, 4))), right = std::max<int32_t>(int32_t(at(first, 0, 4)), int32_t(at(second, 0, 4)));
const int32_t top = std::min<int32_t>(int32_t(at(first, 4, 4)), int32_t(at(second, 4, 4))), bottom = std::max<int32_t>(int32_t(at(first, 4, 4)), int32_t(at(second, 4, 4)));
const int32_t steps = mode == 0 ? right - left : bottom - top;
for (int32_t step = 0; step < steps; ++step) {
const auto channel = [&](size_t field) {
const double from = at(first, field, 2) >> 8, to = at(second, field, 2) >> 8;
return uint32_t(from + (to - from) * (steps > 1 ? double(step) / (steps - 1) : 0.0) + 0.5);
};
DesktopBrush brush;
brush.color = channel(8) | channel(10) << 8 | channel(12) << 16;
if (mode == 0)
painter.fill(left + step, top, left + step + 1, bottom, brush);
else
painter.fill(left, top + step, right, top + step + 1, brush);
}
}
if (painter.changed())
touched(dc);
call.ret(1);
});
});
registry.add("FrameRect", 3, [=, this](ApiCall &call) {
auto *dc = objects.dc(call[0]);
const auto *brush = objects.brush(call[2]);
if (!dc || !brush) {
call.ret(0);
return;
}
guarded(call, 0, [&] {
const auto rect = read_rect(call, call[1]);
if (rect.right <= rect.left || rect.bottom <= rect.top) {
call.ret(0);
return;
}
Painter painter(objects, *dc);
painter.fill(rect.left, rect.top, rect.right, rect.top + 1, *brush);
painter.fill(rect.left, rect.bottom - 1, rect.right, rect.bottom, *brush);
painter.fill(rect.left, rect.top + 1, rect.left + 1, rect.bottom - 1, *brush);
painter.fill(rect.right - 1, rect.top + 1, rect.right, rect.bottom - 1, *brush);
if (painter.changed())
touched(*dc);
call.ret(1);
});
});
registry.add("GdiAlphaBlend", 11, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &destination = require_dc(call, 0);
auto &source_dc = require_dc(call, 5);
Painter painter(objects, destination);
auto *source = objects.bitmap(source_dc.bitmap);
if (!source || source->depth != 32)
throw uint32_t(120);
const uint32_t blend = call.u32(10);
const uint32_t constant = (blend >> 16) & 0xff, format = (blend >> 24) & 0xff;
const int32_t dx = call.i32(1), dy = call.i32(2), dw = call.i32(3), dh = call.i32(4);
const int32_t sx = call.i32(6), sy = call.i32(7), sw = call.i32(8), sh = call.i32(9);
if (dw <= 0 || dh <= 0 || sw <= 0 || sh <= 0)
throw uint32_t(87);
const auto pixels = source->pixels();
for (int32_t y = 0; y < dh; ++y)
for (int32_t x = 0; x < dw; ++x) {
const int64_t device_x = int64_t(dx) + x + destination.origin_x, device_y = int64_t(dy) + y + destination.origin_y;
if (!painter.visible(device_x, device_y))
continue;
const int64_t source_x = sx + int64_t(x) * sw / dw, source_y = sy + int64_t(y) * sh / dh;
if (source_x < 0 || source_y < 0 || source_x >= source->width || source_y >= source->height)
continue;
const size_t row = source->top_down ? size_t(source_y) : source->height - 1 - size_t(source_y);
const auto *p = &pixels[(row * source->width + size_t(source_x)) * 4];
uint32_t alpha = constant;
uint32_t blue = p[0], green = p[1], red = p[2];
if (format & 1) {
// Premultiplied source: scale by the constant alpha, then composite with the pixel's own alpha.
const uint32_t pixel_alpha = p[3];
blue = blue * constant / 255; green = green * constant / 255; red = red * constant / 255;
alpha = pixel_alpha * constant / 255;
const uint32_t destination_color = painter.read(device_x, device_y);
const uint32_t keep = 255 - alpha;
const uint32_t out_blue = blue + color_blue(destination_color) * keep / 255;
const uint32_t out_green = green + color_green(destination_color) * keep / 255;
const uint32_t out_red = red + color_red(destination_color) * keep / 255;
painter.plot(device_x, device_y, std::min(out_red, 255u) | std::min(out_green, 255u) << 8 | std::min(out_blue, 255u) << 16, 13);
continue;
}
const uint32_t destination_color = painter.read(device_x, device_y);
const uint32_t out_blue = (blue * alpha + color_blue(destination_color) * (255 - alpha)) / 255;
const uint32_t out_green = (green * alpha + color_green(destination_color) * (255 - alpha)) / 255;
const uint32_t out_red = (red * alpha + color_red(destination_color) * (255 - alpha)) / 255;
painter.plot(device_x, device_y, out_red | out_green << 8 | out_blue << 16, 13);
}
if (painter.changed())
touched(destination);
call.ret(1);
});
});
// ---- device-independent bitmaps ----
registry.add("StretchDIBits", 13, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto &dc = require_dc(call, 0);
const int32_t dx = call.i32(1), dy = call.i32(2), dw = call.i32(3), dh = call.i32(4);
const int32_t sx = call.i32(5), sy = call.i32(6), sw = call.i32(7), sh = call.i32(8);
const auto image = decode_dib(call, call[10], call[9], call.u32(11));
Painter painter(objects, dc);
if (!dw || !dh || !sw || !sh) {
call.ret(0);
return;
}
const int64_t abs_dw = std::abs(int64_t(dw)), abs_dh = std::abs(int64_t(dh)), abs_sw = std::abs(int64_t(sw)), abs_sh = std::abs(int64_t(sh));
const bool flip_x = (dw < 0) != (sw < 0), flip_y = (dh < 0) != (sh < 0);
const int64_t dest_left = dw < 0 ? int64_t(dx) + dw + 1 : dx, dest_top = dh < 0 ? int64_t(dy) + dh + 1 : dy;
// DIB source rows count from the bottom: the origin is the lower-left corner for bottom-up images.
const bool top_down = call.load<int32_t>(call[10] + 8) < 0;
for (int64_t row = 0; row < abs_dh; ++row)
for (int64_t column = 0; column < abs_dw; ++column) {
const int64_t device_x = dest_left + column + dc.origin_x, device_y = dest_top + row + dc.origin_y;
if (!painter.visible(device_x, device_y))
continue;
const int64_t scaled_x = abs_dw == abs_sw ? column : column * abs_sw / abs_dw;
const int64_t scaled_y = abs_dh == abs_sh ? row : row * abs_sh / abs_dh;
const int64_t image_x = sx + (flip_x ? abs_sw - 1 - scaled_x : scaled_x);
int64_t image_row = flip_y ? abs_sh - 1 - scaled_y : scaled_y;
// Rows of a top-down DIB use sy as the first line; rows of a bottom-up DIB count up from the bottom.
const int64_t image_y = top_down ? sy + image_row : image.height - 1 - (sy + (abs_sh - 1 - image_row));
if (image_x < 0 || image_x >= image.width || image_y < 0 || image_y >= image.height)
continue;
const uint32_t source_pixel = image.pixels[size_t(image_y) * image.width + size_t(image_x)];
painter.plot(device_x, device_y, colorref(source_pixel & 0xffffff), 13);
// A DIB section keeps the alpha channel of what is copied into it.
if (painter.bitmap.dib_section && painter.bitmap.depth == 32 && image.has_alpha)
if (auto *target = painter.pixel_pointer(device_x, device_y))
target[3] = uint8_t(source_pixel >> 24);
}
if (painter.changed())
touched(dc);
call.ret(uint64_t(abs_dh));
});
});
// CreateDIBitmap: a device bitmap of the header's size, filled from the bits when CBM_INIT asks for it.
registry.add("CreateDIBitmap", 6, [&registry, this](ApiCall &call) {
if (!call[1]) {
call.fail(87);
return;
}
const int32_t width = call.load<int32_t>(call[1] + 4), height = call.load<int32_t>(call[1] + 8);
if (width <= 0 || !height) {
call.fail(87);
return;
}
const uint32_t rows = uint32_t(height < 0 ? -height : height);
const uint64_t bitmap = allocate_bitmap(uint32_t(width), rows, 32, false, true);
if (!bitmap) {
call.fail(8);
return;
}
if ((call.u32(2) & 4) && call[3] && call[4]) {
ApiCall fill(call.process, call.environment, {call[0], bitmap, 0, rows, call[3], call[4], call[5]});
registry.find("SetDIBits")->second(fill);
}
call.ret(bitmap);
});
registry.add("SetDIBits", 7, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto *bitmap = objects.bitmap(call[1]);
if (!bitmap || bitmap->depth != 32)
throw uint32_t(6);
const uint32_t start = call.u32(2), lines = call.u32(3);
int32_t rows = 0;
const auto image = decode_dib(call, call[5], call[4], call.u32(6), lines, &rows);
auto pixels = bitmap->pixels();
const bool top_down = call.load<int32_t>(call[5] + 8) < 0;
uint32_t done = 0;
for (uint32_t row = 0; row < lines && row + start < uint32_t(rows) && row + start < bitmap->height; ++row, ++done) {
// Storage line start+row of the DIB lands on the bitmap row with the same top-to-bottom position.
const uint32_t image_row = top_down ? start + row : uint32_t(rows) - 1 - (start + row);
const size_t memory_row = bitmap->top_down ? image_row : size_t(bitmap->height) - 1 - image_row;
if (image_row >= uint32_t(image.height) || image_row >= bitmap->height)
continue;
for (int32_t x = 0; x < std::min<int32_t>(image.width, int32_t(bitmap->width)); ++x) {
auto *p = &pixels[(memory_row * bitmap->width + size_t(x)) * 4];
const uint32_t value = image.pixels[size_t(image_row) * image.width + size_t(x)];
p[0] = uint8_t(value); p[1] = uint8_t(value >> 8); p[2] = uint8_t(value >> 16); p[3] = uint8_t(value >> 24);
}
}
call.ret(done);
});
});
registry.add("GetDIBits", 7, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
auto *bitmap = objects.bitmap(call[1]);
if (!bitmap)
throw uint32_t(6);
const auto header_size = call.load<uint32_t>(call[5]);
if (header_size < 40)
throw uint32_t(87);
auto bit_count = call.load<uint16_t>(call[5] + 14);
if (!bit_count) {
// A query fills in the format: width, height, planes and bit count of the selected bitmap.
call.store<int32_t>(call[5] + 4, int32_t(bitmap->width));
call.store<int32_t>(call[5] + 8, int32_t(bitmap->height));
call.store<uint16_t>(call[5] + 12, 1);
call.store<uint16_t>(call[5] + 14, uint16_t(bitmap->depth == 1 ? 1 : 32));
call.store<uint32_t>(call[5] + 16, 0);
call.store<uint32_t>(call[5] + 20, uint32_t(((size_t(bitmap->width) * (bitmap->depth == 1 ? 1 : 32) + 31) / 32) * 4 * bitmap->height));
call.ret(1);
return;
}
if (!call[4]) {
call.ret(1);
return;
}
if (bit_count != 32 && bit_count != 24 && bit_count != 8 && bit_count != 1)
throw uint32_t(120);
const uint32_t start = call.u32(2), lines = call.u32(3);
const int32_t height_field = call.load<int32_t>(call[5] + 8);
const bool top_down = height_field < 0;
const size_t stride = ((size_t(bitmap->width) * bit_count + 31) / 32) * 4;
if (start > bitmap->height)
throw uint32_t(87);
const uint32_t take = std::min<uint32_t>(lines, bitmap->height - start);
std::vector<uint8_t> output(stride * take, 0);
const auto pixels = bitmap->pixels();
for (uint32_t row = 0; row < take; ++row) {
const uint32_t image_row = start + row;
const size_t memory_row = bitmap->top_down ? image_row : bitmap->height - 1 - image_row;
// A bottom-up DIB stores the image's last row first.
const size_t out_row = top_down ? row : take - 1 - row;
for (uint32_t x = 0; x < bitmap->width; ++x) {
uint32_t color, alpha = 0;
if (bitmap->depth == 1) {
const size_t source_stride = ((size_t(bitmap->width) + 15) / 16) * 2;
color = ((pixels[memory_row * source_stride + x / 8] >> (7 - x % 8)) & 1) ? 0xffffff : 0;
} else {
const auto *p = &pixels[(memory_row * bitmap->width + x) * 4];
color = uint32_t(p[2]) | uint32_t(p[1]) << 8 | uint32_t(p[0]) << 16;
alpha = p[3];
}
auto *target = &output[out_row * stride];
if (bit_count == 32) {
// A bitmap that carries an alpha channel hands it back, which image lists use to tell ARGB images from plain ones.
target[x * 4] = uint8_t(color >> 16); target[x * 4 + 1] = uint8_t(color >> 8); target[x * 4 + 2] = uint8_t(color); target[x * 4 + 3] = uint8_t(alpha);
} else if (bit_count == 24) {
target[x * 3] = uint8_t(color >> 16); target[x * 3 + 1] = uint8_t(color >> 8); target[x * 3 + 2] = uint8_t(color);
} else if (bit_count == 8) {
target[x] = uint8_t((color_red(color) * 30 + color_green(color) * 59 + color_blue(color) * 11) / 100);
} else {
target[x / 8] = uint8_t(target[x / 8] | ((color_red(color) + color_green(color) + color_blue(color) >= 384) ? (0x80 >> (x % 8)) : 0));
}
}
}
call.write(call[4], output);
// The colour table of an indexed result is part of the answer: black and white, or the grey ramp the indices stand for.
if (bit_count <= 8) {
const uint32_t entries = bit_count == 1 ? 2 : 256;
std::vector<uint8_t> table(entries * 4);
for (uint32_t entry = 0; entry < entries; ++entry) {
const uint8_t level = bit_count == 1 ? (entry ? 255 : 0) : uint8_t(entry);
table[entry * 4] = table[entry * 4 + 1] = table[entry * 4 + 2] = level;
}
call.write(call[5] + header_size, table);
}
call.ret(take);
});
});
registry.add("GetDIBColorTable", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0);
call.ret(0);
});
});
registry.add("SetDIBColorTable", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
require_dc(call, 0);
call.ret(0);
});
});
registry.add("PlayEnhMetaFile", 3, [=, this](ApiCall &call) {
call.fail(120, 0);
});
// ---- printing is not provided ----
for (const auto *name : {"StartDocW", "StartDocA", "EndDoc", "StartPage", "EndPage", "AbortDoc"})
registry.add(name, 2, [](ApiCall &call) { call.fail(120, 0); });
registry.add("GdiGetCodePage", 1, [](ApiCall &call) { call.ret(1252); });
}
void NativeDesktop::register_image_api(ApiRegistry &registry)
{
const auto guarded = [](ApiCall &call, uint64_t failure, const std::function<void()> &body) {
try {
body();
} catch (const uint32_t &error) {
call.fail(error, failure);
} catch (const std::bad_alloc &) {
call.fail(8, failure);
}
};
// A persistent guest page for names and small buffers that must be passed to resource lookups.
const auto page = [this]() {
if (!scratch)
scratch = process.map_memory(8192, PROT_READ | PROT_WRITE);
return scratch + 4096;
};
// Resource names are integers or strings; an ANSI string is widened into the scratch page first.
const auto wide_name = [=, this](ApiCall &call, uint64_t name, bool ansi) -> uint64_t {
if (name < 0x10000 || !ansi)
return name;
const auto text = from_ansi(call.narrow(name, 512), 1252);
std::vector<uint8_t> bytes((text.size() + 1) * 2, 0);
std::memcpy(bytes.data(), text.data(), text.size() * 2);
call.write(page(), bytes);
return page();
};
const auto make_bitmap = [this](const ApiCall &call, uint64_t info, uint64_t bits, bool keep_alpha) -> uint64_t {
const auto image = decode_dib(call, info, bits, 0);
const auto handle = allocate_bitmap(uint32_t(image.width), uint32_t(image.height), 32, false, true);
if (!handle)
throw uint32_t(8);
auto *bitmap = objects.bitmap(handle);
auto pixels = bitmap->pixels();
for (size_t i = 0; i < image.pixels.size(); ++i) {
const uint32_t value = image.pixels[i];
pixels[i * 4] = uint8_t(value); pixels[i * 4 + 1] = uint8_t(value >> 8); pixels[i * 4 + 2] = uint8_t(value >> 16);
pixels[i * 4 + 3] = keep_alpha && image.has_alpha ? uint8_t(value >> 24) : 0;
}
return handle;
};
// Locates the pixel data of a packed DIB (header, optional masks, palette, then bits).
const auto dib_bits = [](const ApiCall &call, uint64_t info) -> uint64_t {
const auto header = call.load<uint32_t>(info);
const auto bit_count = call.load<uint16_t>(info + 14);
const auto compression = call.load<uint32_t>(info + 16);
auto colors = call.load<uint32_t>(info + 32);
if (bit_count <= 8 && (!colors || colors > (1U << bit_count)))
colors = 1U << bit_count;
return info + header + (bit_count <= 8 ? uint64_t(colors) * 4 : 0) + (compression == 3 && header == 40 ? 12 : 0);
};
const auto bitmap_resource = [=, this](ApiCall &call, uint64_t instance, uint64_t name, bool keep_alpha) -> uint64_t {
if (!instance && name >= 32700 && name < 32800)
instance = oem_module;
const auto view = resources.view(instance, 2, name);
if (!view)
throw uint32_t(1814);
return make_bitmap(call, view->address, dib_bits(call, view->address), keep_alpha);
};
const auto host_file = [=, this](const ApiCall &call, uint64_t name, bool ansi) -> std::vector<uint8_t> {
const auto path = ansi ? from_ansi(call.narrow(name, 1024), 1252) : call.wide(name, 1024);
if (!read_host_file)
throw uint32_t(2);
const auto bytes = read_host_file(path);
if (!bytes)
throw uint32_t(2);
return *bytes;
};
const auto icon_resource = [=, this](ApiCall &call, uint64_t instance, uint64_t name, uint32_t cx, uint32_t cy) -> uint64_t {
if (!scratch)
scratch = process.map_memory(8192, PROT_READ | PROT_WRITE);
const uint64_t forwarded[] = {instance, name, cx, cy, scratch};
const auto status = load_icon(forwarded);
if (status) {
throw uint32_t((status & 0xffff0000U) == 0x80070000U ? status & 0xffffU : 1814);
}
return call.load<uint64_t>(scratch);
};
// ICO file: directory of images, each a DIB (without file header) or PNG.
const auto icon_file = [=, this](const std::vector<uint8_t> &bytes, uint32_t cx, uint32_t cy) -> uint64_t {
if (bytes.size() < 22 || bytes[2] != 1)
throw uint32_t(13);
const unsigned count = bytes[4] | bytes[5] << 8;
size_t best = 0;
uint32_t best_distance = UINT32_MAX;
for (unsigned i = 0; i < count && 6 + (i + 1) * 16 <= bytes.size(); ++i) {
const uint32_t width = bytes[6 + i * 16] ? bytes[6 + i * 16] : 256, height = bytes[7 + i * 16] ? bytes[7 + i * 16] : 256;
const uint32_t distance = cx ? uint32_t(std::abs(int(width) - int(cx)) + std::abs(int(height) - int(cy))) : 1000 - width;
if (distance < best_distance) {
best_distance = distance;
best = i;
}
}
const uint32_t size = bytes[6 + best * 16 + 8] | bytes[6 + best * 16 + 9] << 8 | bytes[6 + best * 16 + 10] << 16 | uint32_t(bytes[6 + best * 16 + 11]) << 24;
const uint32_t offset = bytes[6 + best * 16 + 12] | bytes[6 + best * 16 + 13] << 8 | bytes[6 + best * 16 + 14] << 16 | uint32_t(bytes[6 + best * 16 + 15]) << 24;
if (offset > bytes.size() || size > bytes.size() - offset)
throw uint32_t(13);
const auto handle = create_icon(std::span<const uint8_t>(bytes.data() + offset, size), cx, cy, 0);
if (!handle)
throw uint32_t(environment.last_error());
return handle;
};
const auto load_image = [=, this](ApiCall &call, bool ansi) {
guarded(call, 0, [&] {
const uint32_t type = call.u32(2), flags = call.u32(5);
uint32_t cx = call.u32(3), cy = call.u32(4);
if (flags & 0x40)
cx = cy = 0;
if (flags & 0x10) {
const auto bytes = host_file(call, call[1], ansi);
if (type == 0) {
if (bytes.size() < 54 || bytes[0] != 'B')
throw uint32_t(13);
const auto buffer = process.map_memory((bytes.size() + 4095) & ~size_t(4095), PROT_READ | PROT_WRITE);
uint64_t handle = 0;
try {
process.write_memory(buffer, bytes);
handle = make_bitmap(call, buffer + 14, buffer + 14 + (dib_bits(call, buffer + 14) - (buffer + 14)), (flags & 0x2000) != 0);
} catch (...) {
process.unmap_memory(buffer);
throw;
}
process.unmap_memory(buffer);
call.ret(handle);
} else if (type == 1) {
call.ret(icon_file(bytes, cx, cy));
} else {
call.ret(desktop_stock_cursor);
}
return;
}
const auto name = wide_name(call, call[1], ansi);
if (type == 0)
call.ret(bitmap_resource(call, call[0], name, (flags & 0x2000) != 0));
else if (type == 1)
call.ret(icon_resource(call, call[0], name, cx, cy));
else if (call[0] == 0 && name >= 32512 && name < 32512 + desktop_stock_cursor_count)
call.ret(desktop_stock_cursor + (name - 32512));
else
// Module cursors are not rendered by the host; callers receive the arrow.
call.ret(desktop_stock_cursor);
});
};
registry.add("LoadImageW", 6, [=](ApiCall &call) { load_image(call, false); });
registry.add("LoadImageA", 6, [=](ApiCall &call) { load_image(call, true); });
const auto load_bitmap = [=, this](ApiCall &call, bool ansi) {
guarded(call, 0, [&] { call.ret(bitmap_resource(call, call[0], wide_name(call, call[1], ansi), false)); });
};
registry.add("LoadBitmapW", 2, [=](ApiCall &call) { load_bitmap(call, false); });
registry.add("LoadBitmapA", 2, [=](ApiCall &call) { load_bitmap(call, true); });
registry.add("LoadIconA", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
if (!call[0])
throw uint32_t(120);
call.ret(icon_resource(call, call[0], wide_name(call, call[1], true), 0, 0));
});
});
registry.add("LoadCursorA", 2, [=, this](ApiCall &call) {
if (!call[0] && call[1] >= 32512 && call[1] < 32512 + desktop_stock_cursor_count)
call.ret(desktop_stock_cursor + (call[1] - 32512));
else
call.ret(desktop_stock_cursor);
});
registry.add("LoadStringA", 4, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const int32_t capacity = call.i32(3);
if (capacity <= 0 || capacity > 2040) {
call.ret(0);
return;
}
const uint64_t forwarded[] = {call[0], call[1], page(), uint64_t(capacity)};
const auto length = load_string(forwarded);
if (!length) {
call.ret(0);
return;
}
const auto text = call.wide(page(), size_t(capacity));
auto narrow = to_ansi(text, 1252);
call.put_narrow(call[2], narrow, size_t(capacity));
call.ret(std::min<size_t>(narrow.size(), size_t(capacity) - 1));
});
});
registry.add("LoadMenuA", 2, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
if (call[1] >= 0x10000)
throw uint32_t(120);
call.ret(menu_resource(call[0], call[1]));
});
});
registry.add("CopyImage", 5, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const uint32_t type = call.u32(1);
if (type == 0) {
const auto *source = objects.bitmap(call[0]);
if (!source)
throw uint32_t(1409);
const uint32_t width = call.u32(2) ? call.u32(2) : source->width, height = call.u32(3) ? call.u32(3) : source->height;
const auto handle = allocate_bitmap(width, height, source->depth, false, true);
if (!handle)
throw uint32_t(8);
auto *copy = objects.bitmap(handle);
if (source->depth == 32) {
const auto from = source->pixels();
auto to = copy->pixels();
for (uint32_t y = 0; y < height; ++y)
for (uint32_t x = 0; x < width; ++x) {
const size_t sy = source->top_down ? size_t(y) * source->height / height : source->height - 1 - size_t(y) * source->height / height;
const size_t sx = size_t(x) * source->width / width;
std::memcpy(&to[(size_t(y) * width + x) * 4], &from[(sy * source->width + sx) * 4], 4);
}
} else if (width == source->width && height == source->height) {
std::copy(source->pixels().begin(), source->pixels().end(), copy->pixels().begin());
}
call.ret(handle);
} else {
const auto *icon = objects.icon(call[0]);
if (!icon && !(call[0] >= desktop_stock_cursor && call[0] < desktop_stock_cursor + desktop_stock_cursor_count))
throw uint32_t(1402);
if (!icon) {
call.ret(call[0]);
return;
}
const auto handle = objects.add(*icon);
if (!handle)
throw uint32_t(8);
call.ret(handle);
}
});
});
// CreateIcon(instance, width, height, planes, bits per pixel, AND bits, XOR bits): a monochrome mask whose rows are padded to words,
// and the color image in the same top-down rows, at 32 bits per pixel or as a second monochrome plane.
registry.add("CreateIcon", 7, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
const uint32_t width = call.u32(1), height = call.u32(2), depth = uint32_t(uint8_t(call.u32(3))) * uint32_t(uint8_t(call.u32(4)));
if (!width || !height || width > 1024 || height > 1024 || !call[5] || !call[6] || (depth != 1 && depth != 32))
throw uint32_t(87);
const size_t mask_stride = ((size_t(width) + 15) / 16) * 2;
const auto and_bits = call.read(call[5], mask_stride * height);
const auto xor_bits = call.read(call[6], depth == 32 ? size_t(width) * height * 4 : mask_stride * height);
DesktopIcon icon{};
icon.monochrome = depth == 1;
icon.shared = false;
auto &image = icon.image;
image.color.width = width;
image.color.height = height;
image.color.rgba.assign(size_t(width) * height * 4, 0);
image.and_mask.assign(size_t(width) * height, 0);
bool any_alpha = false;
for (uint32_t y = 0; y < height; ++y)
for (uint32_t x = 0; x < width; ++x) {
const bool transparent = (and_bits[y * mask_stride + x / 8] >> (7 - x % 8)) & 1;
const size_t at = (size_t(y) * width + x) * 4;
if (depth == 32) {
const auto *p = &xor_bits[at];
image.color.rgba[at] = p[2];
image.color.rgba[at + 1] = p[1];
image.color.rgba[at + 2] = p[0];
image.color.rgba[at + 3] = p[3];
any_alpha = any_alpha || p[3];
} else {
const uint8_t level = ((xor_bits[y * mask_stride + x / 8] >> (7 - x % 8)) & 1) ? 255 : 0;
image.color.rgba[at] = image.color.rgba[at + 1] = image.color.rgba[at + 2] = level;
}
image.and_mask[size_t(y) * width + x] = transparent;
}
image.has_alpha = any_alpha;
if (!any_alpha)
for (size_t i = 0; i < image.and_mask.size(); ++i)
image.color.rgba[i * 4 + 3] = image.and_mask[i] ? 0 : 255;
const auto handle = objects.add(std::move(icon));
if (!handle)
throw uint32_t(8);
call.ret(handle);
});
});
registry.add("CreateIconIndirect", 1, [=, this](ApiCall &call) {
guarded(call, 0, [&] {
// ICONINFO: fIcon, the cursor hotspot, then the mask and color bitmaps at the program's pointer width.
const auto is_icon = call.load<uint32_t>(call[0]);
const size_t width = call.pointer_width();
const auto mask_handle = call.load_pointer(call[0] + (width == 8 ? 16 : 12)), color_handle = call.load_pointer(call[0] + (width == 8 ? 24 : 16));
const auto *mask = objects.bitmap(mask_handle);
const auto *color = objects.bitmap(color_handle);
if (!mask || !color || color->depth != 32)
throw uint32_t(120);
DesktopIcon icon{};
icon.monochrome = false;
icon.shared = false;
icon.cursor = !is_icon;
icon.hotspot_x = int32_t(call.load<uint32_t>(call[0] + 4));
icon.hotspot_y = int32_t(call.load<uint32_t>(call[0] + 8));
auto &image = icon.image;
image.color.width = color->width;
image.color.height = color->height;
image.color.rgba.assign(size_t(color->width) * color->height * 4, 0);
image.and_mask.assign(size_t(color->width) * color->height, 0);
image.xor_mask.clear();
const auto from = color->pixels();
const auto bits = mask->pixels();
const size_t stride = ((size_t(mask->width) + 15) / 16) * 2;
bool any_alpha = false;
for (uint32_t y = 0; y < color->height; ++y)
for (uint32_t x = 0; x < color->width; ++x) {
const size_t row = color->top_down ? y : color->height - 1 - y;
const auto *p = &from[(row * color->width + x) * 4];
const size_t mrow = mask->top_down ? y : mask->height - 1 - y;
const bool transparent = x < mask->width && y < mask->height && ((bits[mrow * stride + x / 8] >> (7 - x % 8)) & 1);
const size_t at = (size_t(y) * color->width + x) * 4;
image.color.rgba[at] = p[2]; image.color.rgba[at + 1] = p[1]; image.color.rgba[at + 2] = p[0];
image.color.rgba[at + 3] = p[3];
any_alpha = any_alpha || p[3];
image.and_mask[size_t(y) * color->width + x] = transparent;
}
image.has_alpha = any_alpha;
if (!any_alpha)
for (size_t i = 0; i < image.and_mask.size(); ++i)
image.color.rgba[i * 4 + 3] = image.and_mask[i] ? 0 : 255;
const auto handle = objects.add(std::move(icon));
if (!handle)
throw uint32_t(8);
call.ret(handle);
});
});
}
}
Reference in new issue View Git Blame Copy Permalink