path: root/examples/tablet.c

/* Pressure-sensitive drawing using only YASL's portable API. */
#include <yasl/yasl.h>

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PAPER 0xfff5f2eau
#define INK   0xff315fadu
#define PANEL 0xff172338u
#define TEXT  0xffe5edf8u
#define ACCENT 0xff59d5b6u
#define HEADER 104

struct app {
    bool running, smoke_test, failed, tablet_supported;
    bool down, visible, previous;
    enum yasl_backend backend;
    struct yasl_mouse_event pointer;
    double last_x, last_y, last_radius;
    uint32_t *canvas;
    struct yasl_geometry geometry;
};

static const char *backend_name(enum yasl_backend backend)
{
    switch (backend) {
    case YASL_BACKEND_WAYLAND: return "WAYLAND";
    case YASL_BACKEND_X11: return "X11";
    case YASL_BACKEND_COCOA: return "COCOA";
    default: return "AUTO";
    }
}

static const char *device_name(enum yasl_pointer_device device)
{
    switch (device) {
    case YASL_PTR_DEV_PEN: return "PEN";
    case YASL_PTR_DEV_ERASER: return "ERASER";
    case YASL_PTR_DEV_TOUCH: return "TOUCH";
    default: return "MOUSE";
    }
}

static void cancel_stroke(struct app *app)
{
    app->down = app->previous = app->visible = false;
    app->pointer.pen = (struct yasl_pointer_pen){0};
}

static bool resize_canvas(struct app *app, struct yasl_geometry geometry)
{
    int w = geometry.size.x, h = geometry.size.y;
    if (w <= 0 || h <= 0 || !geometry.scale_120 ||
        (size_t)w > SIZE_MAX / sizeof(uint32_t) / (size_t)h) return false;
    if (app->canvas && w == app->geometry.size.x && h == app->geometry.size.y &&
        geometry.scale_120 == app->geometry.scale_120) return true;
    uint32_t *pixels = malloc((size_t)w * h * sizeof(*pixels));
    if (!pixels) return false;
    double ratio = (double)app->geometry.scale_120 / geometry.scale_120;
    for (int y = 0; y < h; y++) {
        int old_y = (int)(y * ratio);
        for (int x = 0; x < w; x++) {
            int old_x = (int)(x * ratio);
            pixels[(size_t)y * w + x] = app->canvas &&
                old_x < app->geometry.size.x && old_y < app->geometry.size.y ?
                app->canvas[(size_t)old_y * app->geometry.size.x + old_x] : PAPER;
        }
    }
    free(app->canvas);
    app->canvas = pixels;
    app->geometry = geometry;
    cancel_stroke(app);
    return true;
}

static void clear_canvas(struct app *app)
{
    for (size_t i = 0, n = (size_t)app->geometry.size.x * app->geometry.size.y; i < n; i++)
        app->canvas[i] = PAPER;
    app->previous = false;
}

static double brush_radius(const struct app *app)
{
    return ((double)app->geometry.scale_120 / YASL_SCALE_UNIT) *
        ((app->pointer.device == YASL_PTR_DEV_PEN ||
          app->pointer.device == YASL_PTR_DEV_ERASER) ?
        2 + 24 * ((double)app->pointer.pen.pressure / 65535) : 6);
}

static void stamp(struct app *app, double cx, double cy, double radius)
{
    int w = app->geometry.size.x, h = app->geometry.size.y;
    int top = yasl_scale_to_device(HEADER, app->geometry.scale_120);
    int x0 = (int)fmax(0, fmin(w, floor(cx - radius)));
    int y0 = (int)fmax(top, fmin(h, floor(cy - radius)));
    int x1 = (int)fmax(0, fmin(w, ceil(cx + radius)));
    int y1 = (int)fmax(0, fmin(h, ceil(cy + radius)));
    uint32_t color = app->pointer.device == YASL_PTR_DEV_ERASER ? PAPER : INK;
    for (int y = y0; y < y1; y++)
        for (int x = x0; x < x1; x++) {
            double dx = x + 0.5 - cx, dy = y + 0.5 - cy;
            if (dx * dx + dy * dy <= radius * radius)
                app->canvas[(size_t)y * w + x] = color;
        }
}

static void stroke(struct app *app)
{
    double x = app->pointer.pos.x, y = app->pointer.pos.y;
    double radius = brush_radius(app);
    /* Leaving the canvas breaks the line so re-entry cannot bridge the UI. */
    if (x < 0 || x >= app->geometry.size.x ||
        y < HEADER * ((double)app->geometry.scale_120 / YASL_SCALE_UNIT) ||
        y >= app->geometry.size.y) {
        app->previous = false;
        return;
    }
    if (app->previous) {
        double dx = x - app->last_x, dy = y - app->last_y;
        int steps = (int)ceil(hypot(dx, dy));
        for (int i = 1; i <= steps; i++) {
            double t = (double)i / steps;
            stamp(app, app->last_x + dx * t, app->last_y + dy * t,
                  app->last_radius + (radius - app->last_radius) * t);
        }
    }
    /* Also stamp pressure-only motion, even when position has not changed. */
    stamp(app, x, y, radius);
    app->last_x = x;
    app->last_y = y;
    app->last_radius = radius;
    app->previous = true;
}

static void input(struct app *app, const struct yasl_input_event *event)
{
    if (event->kind == YASL_INPUT_RESET ||
        (event->kind == YASL_INPUT_FOCUS && !event->focus.focused)) {
        cancel_stroke(app);
    } else if (event->kind == YASL_INPUT_KEY && event->key.action == YASL_KEY_PRESS) {
        if (event->key.key == YASL_KEY_ESCAPE) app->running = false;
        if (event->key.key == YASL_KEY_C || event->key.key == YASL_KEY_SPACE)
            clear_canvas(app);
    } else if (event->kind == YASL_INPUT_MOUSE) {
        const struct yasl_mouse_event *pointer = &event->mouse;
        if (pointer->kind == YASL_PTR_SCROLL) return;
        if (app->pointer.device != pointer->device) cancel_stroke(app);
        app->pointer = *pointer;
        app->visible = pointer->kind != YASL_PTR_LEAVE;
        if (pointer->kind == YASL_PTR_LEAVE) cancel_stroke(app);
        else if (pointer->kind == YASL_PTR_PRESS && pointer->button == 0) {
            app->down = true;
            app->previous = false;
            stroke(app);
        } else if (pointer->kind == YASL_PTR_RELEASE && pointer->button == 0) {
            app->down = app->previous = false;
            app->pointer.pen.pressure = 0;
        } else if (pointer->kind == YASL_PTR_MOTION && app->down) stroke(app);
    }
}

/* Tiny built-in 5x7 font keeps this example independent of a text library. */
static const uint8_t glyphs[128][7] = {
    ['A']={14,17,17,31,17,17,17}, ['B']={30,17,17,30,17,17,30},
    ['C']={14,17,16,16,16,17,14}, ['D']={30,17,17,17,17,17,30},
    ['E']={31,16,16,30,16,16,31}, ['F']={31,16,16,30,16,16,16},
    ['G']={14,17,16,23,17,17,14}, ['H']={17,17,17,31,17,17,17},
    ['I']={14,4,4,4,4,4,14}, ['J']={7,2,2,2,2,18,12},
    ['K']={17,18,20,24,20,18,17}, ['L']={16,16,16,16,16,16,31},
    ['M']={17,27,21,21,17,17,17}, ['N']={17,25,21,19,17,17,17},
    ['O']={14,17,17,17,17,17,14}, ['P']={30,17,17,30,16,16,16},
    ['Q']={14,17,17,17,21,18,13}, ['R']={30,17,17,30,20,18,17},
    ['S']={15,16,16,14,1,1,30}, ['T']={31,4,4,4,4,4,4},
    ['U']={17,17,17,17,17,17,14}, ['V']={17,17,17,17,17,10,4},
    ['W']={17,17,17,21,21,21,10}, ['X']={17,17,10,4,10,17,17},
    ['Y']={17,17,10,4,4,4,4}, ['Z']={31,1,2,4,8,16,31},
    ['0']={14,17,19,21,25,17,14}, ['1']={4,12,4,4,4,4,14},
    ['2']={14,17,1,2,4,8,31}, ['3']={30,1,1,14,1,1,30},
    ['4']={2,6,10,18,31,2,2}, ['5']={31,16,16,30,1,1,30},
    ['6']={14,16,16,30,17,17,14}, ['7']={31,1,2,4,8,8,8},
    ['8']={14,17,17,14,17,17,14}, ['9']={14,17,17,15,1,1,14},
    ['-']={0,0,0,31,0,0,0}, ['+']={0,4,4,31,4,4,0},
    ['/']={1,1,2,4,8,16,16}, [':']={0,4,4,0,4,4,0},
    ['.']={0,0,0,0,0,4,4}, ['%']={17,2,4,4,8,16,17},
};

static void rect(struct yasl_framebuffer *fb, int x, int y, int w, int h, uint32_t color)
{
    int right = x + w < fb->size.x ? x + w : fb->size.x;
    int bottom = y + h < fb->size.y ? y + h : fb->size.y;
    for (int j = y > 0 ? y : 0; j < bottom; j++)
        for (int i = x > 0 ? x : 0; i < right; i++)
            fb->pixels[(size_t)j * fb->size.x + i] = color;
}

static void text(struct yasl_framebuffer *fb, double dpi, int x, int y,
                 const char *str, uint32_t color)
{
    for (; *str; str++, x += 12) {
        unsigned ch = (unsigned char)*str;
        if (ch >= 128) continue;
        for (int row = 0; row < 7; row++)
            for (int col = 0; col < 5; col++) {
                if (!(glyphs[ch][row] & (1 << (4 - col)))) continue;
                int left = (int)lround((x + col * 2) * dpi);
                int top = (int)lround((y + row * 2) * dpi);
                rect(fb, left, top,
                     (int)lround((x + col * 2 + 2) * dpi) - left,
                     (int)lround((y + row * 2 + 2) * dpi) - top, color);
            }
    }
}

static void draw(struct yasl_surface *surface, struct yasl_frame *frame, void *ud)
{
    struct app *app = ud;
    struct yasl_geometry geometry = yasl_surface_geometry(surface);
    geometry.size = frame->target.size;
    if (!resize_canvas(app, geometry)) {
        fprintf(stderr, "Cannot allocate drawing canvas\n");
        app->running = false;
        app->failed = true;
        return;
    }
    struct yasl_framebuffer *fb = &frame->target;
    memcpy(fb->pixels, app->canvas, (size_t)geometry.size.x * geometry.size.y * sizeof(uint32_t));
    double dpi = (double)app->geometry.scale_120 / YASL_SCALE_UNIT;
    rect(fb, 0, 0, fb->size.x, (int)lround(HEADER * dpi), PANEL);
    char line[128];
    snprintf(line, sizeof(line), "YASL TABLET / %s / %s / %s", backend_name(app->backend),
             device_name(app->pointer.device), app->down ? "CONTACT" : "HOVER");
    text(fb, dpi, 16, 12, line, TEXT);
    if (app->tablet_supported)
        snprintf(line, sizeof(line), "PRESSURE %5u / 65535   %5.1f%%", app->pointer.pen.pressure,
                 app->pointer.pen.pressure * 100.0 / 65535);
    else snprintf(line, sizeof(line), "TABLET PROTOCOL UNAVAILABLE / MOUSE DRAWING");
    text(fb, dpi, 16, 36, line, ACCENT);
    int bar_width = (int)lround(220 * dpi);
    rect(fb, (int)(16 * dpi), (int)(58 * dpi), bar_width, (int)(6 * dpi), 0xff34455eu);
    rect(fb, (int)(16 * dpi), (int)(58 * dpi),
         (int)((uint32_t)app->pointer.pen.pressure * (uint64_t)bar_width / 65535), (int)(6 * dpi), ACCENT);
    snprintf(line, sizeof(line), "TILT X %+d / Y %+d", app->pointer.pen.tilt_x, app->pointer.pen.tilt_y);
    text(fb, dpi, 260, 54, line, TEXT);
    text(fb, dpi, 16, 82, "DRAW WITH TIP / FLIP TO ERASE / C CLEAR / ESC QUIT", TEXT);
    if (app->visible && app->pointer.pos.x >= 0 && app->pointer.pos.x < fb->size.x &&
        app->pointer.pos.y >= HEADER * dpi && app->pointer.pos.y < fb->size.y) {
        double radius = brush_radius(app);
        double cx = app->pointer.pos.x, cy = app->pointer.pos.y;
        /* Brush outline and tilt vector are overlays, never stored in canvas. */
        for (int i = 0; i < 180; i++) {
            double angle = i * (6.283185307179586 / 180);
            rect(fb, (int)lround(cx + cos(angle) * radius),
                 (int)lround(cy + sin(angle) * radius), 1, 1, PANEL);
        }
        double tx = app->pointer.pen.tilt_x * dpi / 2;
        double ty = app->pointer.pen.tilt_y * dpi / 2;
        for (int i = 0; i <= 64; i++)
            rect(fb, (int)lround(cx + tx * i / 64), (int)lround(cy + ty * i / 64), 2, 2, ACCENT);
    }
    struct yasl_damage_list damage = {.n = -1};
    if (!yasl_surface_present(surface, fb, &damage)) {
        app->failed = true;
        app->running = false;
    }
    if (app->smoke_test) app->running = false;
}

static void configure(struct yasl_surface *surface, struct yasl_geometry geometry, void *ud)
{
    struct app *app = ud;
    if (!resize_canvas(app, geometry)) {
        app->failed = true;
        app->running = false;
    }
    yasl_surface_schedule_redraw(surface);
}

static void close_window(struct yasl_surface *surface, void *ud)
{
    (void)surface;
    ((struct app *)ud)->running = false;
}

static void quit(void *ud) { ((struct app *)ud)->running = false; }
static void lost(void *ud)
{
    struct app *app = ud;
    app->failed = true;
    app->running = false;
}

int main(int argc, char **argv)
{
    struct app app = {.running = true};
    enum yasl_backend backend = YASL_BACKEND_AUTO;
    for (int i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "--smoke-test")) app.smoke_test = true;
        else if (!strcmp(argv[i], "--backend") && i + 1 < argc) {
            const char *name = argv[++i];
            if (!strcmp(name, "auto")) backend = YASL_BACKEND_AUTO;
            else if (!strcmp(name, "wayland")) backend = YASL_BACKEND_WAYLAND;
            else if (!strcmp(name, "x11")) backend = YASL_BACKEND_X11;
            else if (!strcmp(name, "cocoa")) backend = YASL_BACKEND_COCOA;
            else { fprintf(stderr, "Unknown backend: %s\n", name); return 1; }
        } else {
            bool help = !strcmp(argv[i], "--help");
            fprintf(help ? stdout : stderr,
                "Usage: %s [--backend auto|wayland|x11|cocoa] [--smoke-test]\n", argv[0]);
            return help ? 0 : 1;
        }
    }
    struct yasl_display_cbs display_cbs = {.quit = quit, .lost = lost};
    struct yasl_display_spec display_spec = {
        .app_id = "org.yasl.tablet", .backend = backend, .cbs = &display_cbs, .ud = &app,
    };
    struct yasl_display *display = yasl_display_open(NULL, &display_spec);
    if (!display) { perror("Cannot open display"); return 1; }
    app.backend = yasl_display_backend(display);
    app.tablet_supported = (yasl_display_caps(display) & YASL_CAP_TABLET) != 0;
    struct yasl_window_cbs callbacks = {.draw = draw, .configure = configure, .close = close_window};
    struct yasl_window_spec spec = {
        .title = "YASL Tablet - pressure and tilt", .size = {900, 640},
        .cbs = &callbacks, .ud = &app,
    };
    struct yasl_surface *surface = yasl_surface_create_toplevel(display, &spec);
    if (!surface) { perror("Cannot create surface"); yasl_display_close(display); return 1; }
    yasl_surface_set_cursor(surface, YASL_CURSOR_HIDDEN);
    yasl_surface_schedule_redraw(surface);
    printf("YASL tablet on %s: pressure changes brush width; eraser removes ink.\n"
           "Mouse: fixed-width drawing. C/Space: clear. Escape: quit.\n",
           backend_name(app.backend));
    if (!app.tablet_supported)
        printf("This display server does not expose tablet input.\n");
    while (app.running) {
        if (yasl_display_dispatch(display, -1) < 0) { app.failed = true; break; }
        struct yasl_input_event event;
        while (yasl_surface_input_poll(surface, &event)) {
            input(&app, &event);
            yasl_surface_schedule_redraw(surface);
        }
        yasl_display_flush(display);
    }
    free(app.canvas);
    yasl_surface_destroy(surface);
    yasl_display_close(display);
    return app.failed ? 1 : 0;
}