ui_ncurses_input.c

Go to the documentation of this file.

/** @file ui_ncurses_input.c
   @ingroup ui_ncurses
   @brief NCurses UI backend — input handling.
 
   Translates raw NCurses key codes and mouse events into the portable
   UiEvent representation defined in ui_backend.h.
*/
 
#include "cm.h"
#include "ui_backend.h"
#include "ui_ncurses_internal.h"
#include <poll.h>
#include <stddef.h>
#include <string.h>
#include <termios.h>
/* -------------------------------------------------------------------------
   Key translation
   ------------------------------------------------------------------------- */
/** @brief Translate a raw NCurses key code into a UiKey.
   @param ch Raw NCurses key code.
   @return Corresponding UiKey, or UIKEY_NONE if unrecognized.
*/
static UiKey translate_key(int ch) {
    switch (ch) {
    case ERR:
        return UIKEY_NONE;
    case '\n':
    case '\r':
        return UIKEY_ENTER;
    case 27:
        return UIKEY_ESCAPE;
    case '\t':
        return UIKEY_TAB;
#ifdef KEY_BTAB
    case KEY_BTAB:
        return UIKEY_BTAB;
#endif
    case KEY_UP:
        return UIKEY_UP;
    case KEY_DOWN:
        return UIKEY_DOWN;
    case KEY_LEFT:
        return UIKEY_LEFT;
    case KEY_RIGHT:
        return UIKEY_RIGHT;
    case KEY_HOME:
        return UIKEY_HOME;
    case KEY_END:
        return UIKEY_END;
    case KEY_PPAGE:
        return UIKEY_PPAGE;
    case KEY_NPAGE:
        return UIKEY_NPAGE;
    case KEY_IC:
        return UIKEY_IC;
    case KEY_DC:
        return UIKEY_DC;
    case KEY_BACKSPACE:
        return UIKEY_BACKSPACE;
#ifdef KEY_RESIZE
    case KEY_RESIZE:
        return UIKEY_RESIZE;
#endif
    case KEY_MOUSE:
        return UIKEY_MOUSE;
    case KEY_F(1):
        return UIKEY_F01;
    case KEY_F(2):
        return UIKEY_F02;
    case KEY_F(3):
        return UIKEY_F03;
    case KEY_F(4):
        return UIKEY_F04;
    case KEY_F(5):
        return UIKEY_F05;
    case KEY_F(6):
        return UIKEY_F06;
    case KEY_F(7):
        return UIKEY_F07;
    case KEY_F(8):
        return UIKEY_F08;
    case KEY_F(9):
        return UIKEY_F09;
    case KEY_F(10):
        return UIKEY_F10;
    case KEY_F(11):
        return UIKEY_F11;
    case KEY_F(12):
        return UIKEY_F12;
    case UIKEY_BUTTON1_CLICKED:
        return UIKEY_BUTTON1;
    default:
        if (ch >= 32 && ch <= 126)
            return UIKEY_CHAR;
        return UIKEY_NONE;
    }
}
 
/* -------------------------------------------------------------------------
   Event retrieval
   ------------------------------------------------------------------------- */
void ui_flush_input() {
    if (ui && ui->tty_fd >= 0) {
        tcflush(ui->tty_fd, TCIFLUSH);
    }
}
 
/** @brief Read input events
   @param s          Surface - may contain multiple widgets (planes/panels)
   @param w          Widget index (A surface may contain multilple widgets)
   @param chyron     A zoned group of Actions or Commands
   @param ev         Event data structure
   @param timeout_ms Timeout in milliseconds (0 for no wait, -1 for infinite wait).
   @return 0 on success, -1 if @p ev is NULL.
*/
int ui_get_event(UiSurface *s, ss_t w, UiChyron *chyron, UiEvent *ev, int timeout_ms) {
    if (!ev)
        return -1;
    int ch;
    ui_flush_input();
    ui_render();
    if (timeout_ms < 0)
        timeout_ms = -1; // Block waiting for input
    if (timeout_ms > 0) {
        // ------------------------------------------------------------
        // 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 = ui->tty_fd;
        fds[0].events = POLLIN; // also POLLERR | POLLHUP | POLLNVAL
        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; // also POLLERR | POLLHUP | POLLNVAL
            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
            token_id = UIKEY_TIMEOUT;
            return token_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 = -1;
    }
    memset(ev, 0, sizeof(*ev));
    mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, NULL);
    wtimeout(s->mwin[w], timeout_ms);
    do {
        curs_set(2);
        ch = wgetch(s->mwin[w]);
        if (sig_received != 0) {
            if (handle_signal(sig_received))
                ch = ui_display_error(em0, em1, em2, nullptr);
            if (ch == 'q' || ch == 'Q' || ch == UIKEY_F09)
                exit(EXIT_FAILURE);
            sig_received = 0;
            return 0;
        }
        if (timeout_ms > 0 && ch == ERR) {
            ch = 0;
            break;
        }
        if (ch == ERR)
            continue;
        ev->key = translate_key(ch);
        if (ev->key == UIKEY_CHAR)
            ev->ch = (uint32_t)ch; /* Unicode codepoint */
        else if (ev->key == UIKEY_MOUSE) {
            MEVENT me;
            if (getmouse(&me) != OK) {
                ch = 0;
                continue;
            }
            ev->bstate = me.bstate;
            ev->y = me.y;
            ev->x = me.x;
            if (me.bstate == UIKEY_BUTTON4_PRESSED)
                ev->mouse_action = UIKEY_SCROLL_UP;
            else if (me.bstate == UIKEY_BUTTON5_PRESSED)
                ev->mouse_action = UIKEY_SCROLL_DOWN;
            else if (me.bstate == UIKEY_BUTTON1_CLICKED)
                ev->mouse_action = UIKEY_BUTTON1_CLICKED;
            for (ss_t i = WIN; i < SUB_SFC_MAX; i++) {
                if (s->mwin[i] != NULL &&
                    wenclose(s->mwin[i], me.y, me.x) &&
                    wmouse_trafo(s->mwin[i], &me.y, &me.x, false)) {
                    ch = ev->mouse_action;
                    ev->bstate = me.bstate;
                    ev->in_win = i;
                    ev->y = me.y;
                    ev->x = me.x;
                    break;
                }
            }
            if (ev->in_win == w)
                ev->mouse_inside = true;
            if (chyron && ev->mouse_action == UIKEY_BUTTON1_CLICKED) {
                if (ev->in_win == chyron->w && ev->y == chyron->y) {
                    ev->key = ui_get_chyron_key(chyron, ev->x);
                    return ev->key;
                } else
                    return 0;
            }
        }
    } while (ch == ERR);
    curs_set(0);
    return ch;
}
/** @brief
 *  Wait for an input event on @p target (or stdscr if NULL) without mouse support.
   @param ui         UI runtime context (unused — event comes from the window).
   @param target     Surface to read from, or NULL for stdscr.
   @param ev         Output UiEvent structure.
   @return 0 on success, -1 if @p ev is NULL.
*/
int ui_get_event_no_mouse(UiSurface *s, ss_t w, UiEvent *ev) {
    int ch;
    mousemask(0, NULL);
    curs_set(2);
    ui_flush_input();
    cbreak();
    do {
        curs_set(2);
        ch = wgetch(s->mwin[w]);
        curs_set(0);
        ev->key = translate_key(ch);
        if (ev->key == UIKEY_CHAR) {
            ev->ch = (uint32_t)ch;
            break;
        }
    } while (ch == ERR);
    curs_set(0);
    return ch;
}
// ui_ncplane_clicked(UiSurface *s, ss_t w, UiEvent *ev);
/* -------------------------------------------------------------------------
   Mice
   ------------------------------------------------------------------------- */
/** @brief Enable or disable mouse support.
   @param mask Mouse event mask (0 to disable, non-zero to enable).
   @return 0 on success, -1 if UI is not initialized.
*/
int ui_mousemask(int mask) {
    if (!ui)
        return -1;
    if (mask)
        mousemask(mask, nullptr);
    else
        mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, nullptr);
    return 0;
}
/** @brief Enable or disable mouse support.
   @param mask Mouse event mask (0 to disable, non-zero to enable).
   @return 0 on success, -1 if UI is not initialized.
*/
int ui_mice_enable(int mask) {
    if (!ui)
        return -1;
    if (mask)
        mousemask(mask, nullptr);
    else
        mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, nullptr);
    return 0;
}