ui_notcurses_input.c

Go to the documentation of this file.

/** @file ui_notcurses_input.c
   @ingroup ui_notcurses
   @brief NotCurses UI backend — input handling.
 
   Translates NotCurses @c ncinput events into the portable UiEvent
   representation defined in ui_backend.h.
*/
 
#include "ui_backend.h"
#include "ui_notcurses_internal.h"
#include <errno.h>
#include <notcurses/notcurses.h>
#include <poll.h>
#include <string.h>
#include <termios.h>
 
/* -------------------------------------------------------------------------
   Key translation
   ------------------------------------------------------------------------- */
/** @brief Translate a NotCurses key code into a UiKey.
   @param id  NotCurses key code.
   @param ni  NotCurses input event (for context).
   @return    Corresponding UiKey value.
*/
static UiKey translate_nckey(uint32_t id, const ncinput *ni) {
    if (id == NCKEY_INVALID || id == (uint32_t)NCKEY_EOF)
        return UIKEY_NONE;
 
    /* Mouse buttons — handled separately in ui_get_event(). */
    if (nckey_mouse_p(id))
        return UIKEY_MOUSE;
 
    switch (id) {
    case NCKEY_RESIZE:
        return UIKEY_RESIZE;
    case NCKEY_ENTER:
        return UIKEY_ENTER;
    case NCKEY_ESC:
        return UIKEY_ESCAPE;
    case NCKEY_BACKSPACE:
        return UIKEY_BACKSPACE;
    case NCKEY_TAB:
        return UIKEY_TAB;
    case NCKEY_UP:
        return UIKEY_UP;
    case NCKEY_DOWN:
        return UIKEY_DOWN;
    case NCKEY_LEFT:
        return UIKEY_LEFT;
    case NCKEY_RIGHT:
        return UIKEY_RIGHT;
    case NCKEY_HOME:
        return UIKEY_HOME;
    case NCKEY_END:
        return UIKEY_END;
    case NCKEY_PGUP:
        return UIKEY_PPAGE;
    case NCKEY_PGDOWN:
        return UIKEY_NPAGE;
    case NCKEY_INS:
        return UIKEY_IC;
    case NCKEY_DEL:
        return UIKEY_DC;
    case NCKEY_F01:
        return UIKEY_F01;
    case NCKEY_F02:
        return UIKEY_F02;
    case NCKEY_F03:
        return UIKEY_F03;
    case NCKEY_F04:
        return UIKEY_F04;
    case NCKEY_F05:
        return UIKEY_F05;
    case NCKEY_F06:
        return UIKEY_F06;
    case NCKEY_F07:
        return UIKEY_F07;
    case NCKEY_F08:
        return UIKEY_F08;
    case NCKEY_F09:
        return UIKEY_F09;
    case NCKEY_F10:
        return UIKEY_F10;
    case NCKEY_F11:
        return UIKEY_F11;
    case NCKEY_F12:
        return UIKEY_F12;
    default:
        if (ni && ni->evtype == NCTYPE_UNKNOWN)
            return UIKEY_NONE;
        /* Printable Unicode codepoint. */
        if (id >= 0x20 && id < NCKEY_INVALID)
            return UIKEY_CHAR;
        return UIKEY_NONE;
    }
}
 
/* -------------------------------------------------------------------------
   Event retrieval
   ------------------------------------------------------------------------- */
 
/** @brief Flush any pending input events from the NotCurses context.
   This function discards any input events that have been queued but not yet processed.
*/
void ui_flush_input() {
    int fd = notcurses_inputready_fd(ui->nc);
    tcflush(fd, TCIOFLUSH);
}
 
/** @brief Wait for an input event from the NotCurses context.
   @param ui         UI runtime context.
   @param target     Unused for NotCurses (events are global to the context).
   @param ev         Output UiEvent structure.
   @param timeout_ms Milliseconds to wait; -1 = block indefinitely.
   @return 0 on success, -1 if @p ui or @p ev is NULL.
*/
int ui_get_event(UiSurface *s, ss_t w, UiChyron *chyron, UiEvent *ev, int timeout_ms) {
    if (!ui || !ev)
        return -1;
    memset(ev, 0, sizeof(*ev));
    ncinput ni;
    memset(&ni, 0, sizeof(ni));
    ui_render();
    ui_flush_input();
    if (timeout_ms < 0)
        timeout_ms = -1;
    if (timeout_ms > 1) {
        // ------------------------------------------------------------
        // Poll for input on the TTY and any registered external files
        // ------------------------------------------------------------
        struct pollfd fds[1 + MAX_EXT_FDS];
        int token_id;
        int reg_idx;
        memset(fds, 0, sizeof(fds));
        fds[0].fd = notcurses_inputready_fd(ui->nc);
        fds[0].events = POLLIN;
        nfds_t nfds = 1;
        nfds_t ext_start_idx = nfds;
        for (nfds_t i = 0; i < ui_ctx.ext_nfds; i++) {
            fds[nfds].fd = ui_ctx.ext_fds[i].fd;
            fds[nfds].events = POLLIN;
            nfds++;
        }
        int poll_rc = poll(fds, nfds, timeout_ms);
        if (poll_rc < 0) {
            if (errno == EINTR)
                return 0; // continue
            return -1;
        }
        if (poll_rc == 0) { // timed out with no input
            ni.id = UIKEY_TIMEOUT;
            return ni.id;
        }
        bool ui_ready = (fds[0].revents & POLLIN);
        if (!ui_ready) {
            for (nfds_t i = ext_start_idx; i < nfds; i++) {
                if (fds[i].revents & (POLLIN | POLLHUP | POLLERR)) {
                    reg_idx = i - ext_start_idx;
                    token_id = ui_ctx.ext_fds[reg_idx].token_id;
                    return token_id;
                }
            }
        } else {
            timeout_ms = 0;
        }
    }
    memset(ev, 0, sizeof(*ev));
    ui_render();
    if (timeout_ms < 0) {
        do {
            notcurses_get_blocking(ui->nc, &ni);
        } while (ni.evtype == NCTYPE_RELEASE ||
                 ni.id == NCKEY_INVALID || ni.id == NCKEY_MOTION || ni.id == NCKEY_SIGNAL);
    } else {
        struct timespec ts = {
            .tv_sec = timeout_ms / 1000,
            .tv_nsec = (long)(timeout_ms % 1000) * 1000000L,
        };
        do {
            notcurses_get(ui->nc, &ts, &ni);
        } while (ni.evtype == NCTYPE_RELEASE || ni.id == NCKEY_MOTION || ni.id == NCKEY_INVALID);
    }
    ev->key = translate_nckey(ni.id, &ni);
    ev->alt = ncinput_alt_p(&ni);
    ev->ctrl = ncinput_ctrl_p(&ni);
    ev->shift = ncinput_shift_p(&ni);
    if (ev->key == UIKEY_CHAR)
        ev->ch = ni.id; /* Unicode codepoint */
    else if (ev->key == UIKEY_MOUSE) {
        if (ni.id == NCKEY_BUTTON4)
            ev->mouse_action = UIKEY_SCROLL_UP;
        else if (ni.id == NCKEY_BUTTON5)
            ev->mouse_action = UIKEY_SCROLL_DOWN;
        else if (ni.id == NCKEY_BUTTON1 && ni.evtype == NCTYPE_PRESS) {
            ev->mouse_action = UIKEY_BUTTON1_PRESSED;
            struct ncplane *clicked = ui_ncplane_clicked(s, w, &ni);
            ev->y = ni.y;
            ev->x = ni.x;
            ev->in_win = ui_get_plane_idx(s, clicked);
            if (chyron) {
                if (ev->in_win == chyron->w && ev->y == chyron->y) {
                    ev->mouse_action = UIKEY_BUTTON1_CLICKED;
                    ev->key = ui_get_chyron_key(chyron, ev->x);
                    return ev->key;
                } else
                    return 0;
            } else {
                if (ev->in_win == w) {
                    ev->mouse_action = UIKEY_BUTTON1_CLICKED;
                    ev->key = ev->y;
                    return ev->key;
                } else
                    return 0;
            }
        }
    }
    return ni.id;
}
/** @brief Wait for a single input character from the NotCurses context.
   @return The NotCurses key code, or -1 if @p ui is NULL.
*/
int ui_getch() {
    if (!ui)
        return -1;
    ncinput ni;
    do {
        notcurses_get(ui->nc, NULL, &ni);
    } while (ni.evtype == NCTYPE_RELEASE ||
             ni.id == NCKEY_INVALID ||
             ni.id == NCKEY_MOTION ||
             ni.id == NCKEY_SIGNAL);
    return ni.id;
}
/** @brief Wait for an input event from the NotCurses context, ignoring mouse events.
   @param target Unused for NotCurses (events are global to the context).
   @param ev     Output UiEvent structure.
   @return The NotCurses key code, or -1 if @p ui or @p ev is NULL.
*/
int ui_get_event_no_mouse(UiSurface *target, ss_t w, UiEvent *ev) {
    (void)target;
    (void)w;
    if (!ui || !ev)
        return -1;
    memset(ev, 0, sizeof(*ev));
    ncinput ni;
    notcurses_mice_disable(ui->nc);
    do {
        notcurses_get(ui->nc, NULL, &ni);
    } while (ni.id == NCKEY_INVALID);
    ev->key = translate_nckey(ni.id, &ni);
    ev->alt = ncinput_alt_p(&ni);
    ev->ctrl = ncinput_ctrl_p(&ni);
    ev->shift = ncinput_shift_p(&ni);
    if (ev->key == UIKEY_CHAR)
        ev->ch = ni.id;
    return ni.id;
}
/** @brief Get the index of a given ncplane in the UiSurface's plane array.
   @param s     The UiSurface containing the planes.
   @param plane The ncplane to find.
   @return The index of the plane in the UiSurface's mplane array, or -1 if not found.
*/
uint ui_get_plane_idx(UiSurface *s, struct ncplane *plane) {
    for (ss_t w = BOX; w < SUB_SFC_MAX; ++w) {
        if (s->mplane[w] == plane)
            return w;
    }
    return -1;
}
/** @brief Determine which ncplane was clicked based on the mouse event coordinates.
   @param s  The UiSurface containing the planes.
   @param w  The index of the plane to check for clicks.
   @param ni The NotCurses input event containing mouse coordinates.
   @return The ncplane that was clicked, or NULL if no plane was clicked.
*/
NcPlane *ui_ncplane_clicked(UiSurface *s, ss_t w, ncinput *ni) {
    NcPlane *pile_member = s->mplane[w];
    struct ncplane *cur = ncpile_top(pile_member);
    while (cur != NULL) {
        int y = ni->y, x = ni->x;
        if (ncplane_translate_abs(cur, &y, &x)) {
            ni->y = y;
            ni->x = x;
            return cur;
        }
        cur = ncplane_below(cur);
    }
    return NULL;
}
// -------------------------------------------------------------------------
// Mice
// -------------------------------------------------------------------------
/** @brief Set the mouse event mask for the NotCurses context.
   @param mask The mouse event mask to set. If 0, all mouse events are enabled.
   @return 0 on success, or -1 if @p ui is NULL.
*/
int ui_mousemask(int mask) {
    if (!ui)
        return 0;
    if (mask)
        notcurses_mice_enable(ui->nc, mask);
    else
        notcurses_mice_enable(ui->nc, NCMICE_BUTTON_EVENT);
    return 0;
}
/** @brief Enable or disable mouse events for the NotCurses context.
   @param mask The mouse event mask to enable. If 0, all mouse events are enabled.
   @return 0 on success, or -1 if @p ui is NULL.
*/
int ui_mice_enable(int mask) {
    if (mask)
        notcurses_mice_enable(ui->nc, mask);
    else {
        notcurses_mice_enable(ui->nc, NCMICE_BUTTON_EVENT);
    }
    return 0;
}