init_view.c

Go to the documentation of this file.

/** @file init_view.c
    @brief Initialize C-Menu View Screen IO and Input
    @ingroup init_view
    @author Bill Waller
    Copyright (c) 2025
    MIT License
    billxwaller@gmail.com
    @date 2026-02-09
 */
 
/**
   @defgroup init_view Initializing View I/O
   @brief Populate the C-Menu View Struct and Connect Input
 */
#include <common.h>
#include <errno.h>
#include <fcntl.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <unistd.h>
#include <wait.h>
 
void view_calc_full_screen_dimensions(Init *);
void view_full_screen_resize(Init *);
void view_calc_boxwin_dimensions(Init *);
void view_boxwin_resize(Init *);
 
ViewStack view_stack;
 
/** @brief Initialize C-Menu View in full screen mode.
    @ingroup init_view
   @param init Pointer to the Init structure containing view settings.
   @return 0 on success, -1 on failure.
   @details This function sets up the view structure for full screen mode and
   creates a new pad for the view.
   @verbatim
   The function creates the following windows:
   1. view->cmdln_win: Status or Command Line
   2. view->lnno_win: Line Number Window
   3. view->pad: Main Content Pad
   @endverbatim
 */
int init_view_full_screen(Init *init) {
    View *view = init->view;
    view->f_full_screen = true;
    // -------------------> 1. WIN <-------------------
    view_calc_full_screen_dimensions(init);
    ui_log(INFO, _("lines=%d, cols=%d"), view->lines, view->cols);
    view->sfc = ui_surface_new(WIN, NULL, 0, view->lines, view->cols, 0, 0);
    if (!view->sfc) {
        ssnprintf(em0, MAXLEN - 1, _("newwin(LINES, COLS, 0, 0) failed in init_view_full_screen"));
        ui_log(INFO, "%s", em0);
        exit(EXIT_FAILURE);
        return -1;
    }
    ui_log(INFO, _("created view->sfc"));
    ui_bkgd(view->sfc, WIN, &cell_nt);
    // -------------------> 2. LNNO <-------------------
    if (view->f_ln) {
        ui_surface_addwin(view->sfc, LNNO, WIN, view->scroll_lines, view->ln_win_cols, 0, 0);
        if (view->sfc->lnno == nullptr) {
            ssnprintf(em0, MAXLEN - 1, _("ui_sfc_addwin(LNNO, LINES - 1, COLS, 0, 0) failed in init_view_full_screen"));
            ui_log(INFO, "%s", em0);
            exit(EXIT_FAILURE);
        }
        ui_log(INFO, _("created view->sfc->lnno"));
        ui_bkgd(view->sfc, LNNO, &cell_ln);
        ui_bkgdset(view->sfc, LNNO, &cell_ln);
        ui_scrollok(view->sfc, LNNO, true);
        ui_setscrreg(view->sfc, LNNO, 0, view->scroll_lines);
    }
    // -------------------> 3. CMDLN <-------------------
    ui_surface_addwin(view->sfc, CMDLN, WIN, 1, view->cols, view->scroll_lines, 0);
    if (view->sfc->cmdln == nullptr) {
        ssnprintf(em0, MAXLEN - 1, _("ui_sfc_addwin(CMDLN, 1, COLS, LINES - 1, 0) failed in init_view_full_screen"));
        ui_log(INFO, "%s", em0);
        exit(EXIT_FAILURE);
    }
    ui_log(INFO, _("created view->sfc->cmdln"));
    ui_bkgd(view->sfc, CMDLN, &cell_nt);
    ui_keypad(view->sfc, CMDLN, true);
    ui_idlok(view->sfc, CMDLN, false);
    ui_idcok(view->sfc, CMDLN, false);
    ui_scrollok(view->sfc, CMDLN, false);
    // -------------------> 4. PAD <-------------------
 
    ui_surface_addpad(view->sfc, PAD, WIN, view->lines - 1, PAD_COLS - 1, 0, view->ln_win_cols);
    ui_log(INFO, _("created view->sfc->mplane[PAD]"));
    if (view->sfc->pad == nullptr) {
        ssnprintf(em0, MAXLEN - 1, _("ui_sfc_addpan(CMDLN, 1, COLS, LINES - 1, 0) failed in init_view_full_screen"));
        ui_log(INFO, "%s", em0);
        exit(EXIT_FAILURE);
    }
    ui_scrollok(view->sfc, PAD, true);
 
    // ------------------------------------------------
    return 0;
}
/** @brief Resize the full screen view and its components.
    @ingroup window_support
    @param init Pointer to the Init structure containing view settings.
    @details This function resizes the full screen view and its components,
   including the command line window, line number window, and main content pad.
   It also recalculates the dimensions for the full screen mode and updates the
   scroll regions accordingly.
 */
void view_full_screen_resize(Init *init) {
    ui_erase();
    view_calc_full_screen_dimensions(init);
    ui_log(INFO, _("view_full_screen_resize: lines=%d, cols=%d, ln_win_lines=%d, ln_win_cols=%d, scroll_lines=%d"), init->view->lines, init->view->cols, init->view->ln_win_lines, init->view->ln_win_cols, init->view->scroll_lines);
    View *view = init->view;
    ui_surface_destroy(view->sfc);
    ui_render();
    init_view_full_screen(init);
}
/** @brief Calculate the dimensions for full screen mode.
    @ingroup init_view
    @details This function calculates the dimensions for the full screen mode of
   the C-Menu View. It retrieves the maximum dimensions of the standard screen
   and sets the view parameters accordingly. It also resizes the line number
   window and command line window based on the new dimensions.
    @param init Pointer to the Init structure containing view settings.
 */
void view_calc_full_screen_dimensions(Init *init) {
    View *view = init->view;
    ui_get_screen_size(&view->lines, &view->cols);
    view->ln_win_lines = view->lines;
    view->ln_win_cols = 8;
    view->scroll_lines = view->lines - 1;
    view->h_shift = view->cols / 3;
#ifdef DEBUG_RESIZE
    char file[MAXLEN];
    ssnprintf(
        em0, MAXLEN - 1,
        _("%s:%d view->lines=%d, view->cols=%d, view->maxrows=%d, view->maxcols=%d"),
        __FILE__, __LINE__,
        view->lines, view->cols, view->smaxrow, view->smaxcol);
    write_cmenu_log(em0);
#endif
    view->cmd_line = 0;
    view->pminrow = 0;
    view->pmincol = 0;
    view->sminrow = 0;
    view->smincol = view->ln_win_cols;
    view->smaxrow = view->lines - 1;
    view->smaxcol = view->cols - 1;
    view->ln_no = view->page_top_ln_no + view->scroll_lines;
    view->page_bot_ln_no = view->ln_no;
}
/** @brief Initialize the C-Menu View in box window mode.
    @ingroup init_view
    @param init Pointer to the Init structure containing view settings.
    @return 0 on success, -1 on failure.
    @details sets up the view structure for box window mode, adjusts dimensions
   based on screen size, and creates a new pad for the view. It also configures
   various parameters such as scroll lines, command line position, and tab size.
 */
int init_view_boxwin(Init *init) {
    View *view = init->view;
    view->f_full_screen = false;
    // -------------------> 1. BOX / WIN <-------------------
    view_calc_boxwin_dimensions(init);
 
    view->sfc = ui_surface_box(NULL, 0, view->lines + 2, view->cols + 2, view->begy, view->begx, NULL);
 
    ui_surface_addwin(view->sfc, WIN, BOX, view->lines, view->cols, 1, 1);
    // -------------------> 2. LNNO <-------------------
    if (view->f_ln) {
        ui_surface_addwin(view->sfc, LNNO, WIN, view->lines - 1, view->ln_win_cols, 0, 0);
        ui_bkgd(view->sfc, LNNO, &cell_ln);
        ui_bkgdset(view->sfc, LNNO, &cell_ln);
        ui_scrollok(view->sfc, LNNO, true);
        ui_setscrreg(view->sfc, LNNO, 0, view->scroll_lines);
    }
    // -------------------> 3. CMDLN <-------------------
    ui_surface_addwin(view->sfc, CMDLN, WIN, 1, view->cols, view->lines - 1, 0);
    ui_bkgd(view->sfc, CMDLN, &cell_nt);
    ui_keypad(view->sfc, CMDLN, true);
    ui_idlok(view->sfc, CMDLN, false);
    ui_idcok(view->sfc, CMDLN, false);
    ui_scrollok(view->sfc, CMDLN, false);
    // -------------------> 4. PAD <-------------------
    ui_surface_addpad(view->sfc, PAD, WIN, view->lines - 1, PAD_COLS - 1, 0, view->ln_win_cols);
    ui_scrollok(view->sfc, PAD, true);
    // ------------------------------------------------
    return (0);
}
//------------------------------------------------------------------------------
/** @brief Resize the current window and its box
    @ingroup window_support
    @param init Pointer to the Init structure containing view settings.
    @details This function resizes the current window and its associated box
   window to the specified number of lines and columns. */
void view_boxwin_resize(Init *init) {
    View *view = init->view;
    ui_surface_destroy(view->sfc);
    ui_render();
    init_view_boxwin(init);
    ui_border_title(init->view->sfc, init->view->title);
    // initialize_line_table(init->view);
}
/** @brief Calculate the dimensions and position of the box window for C-Menu
   View.
    @ingroup init_view
    @details This function calculates the dimensions and position of the box
   window for the C-Menu View based on the screen size and any specified
   parameters in the Init structure. It ensures that the box window fits within
   the screen dimensions and adjusts its size and position accordingly.
    @param init Pointer to the Init structure containing view settings.
 */
void view_calc_boxwin_dimensions(Init *init) {
    View *view = init->view;
 
    /** Use view->lines and view->cols if set, otherwise calculate based on
     * screen size with some padding. Ensure the view fits within the screen
     * dimensions. */
    uint scr_lines, scr_cols;
    ui_get_screen_size(&scr_lines, &scr_cols);
#ifdef DEBUG_RESIZE
    ssnprintf(em0, MAXLEN - 1,
              _("%s:%d=%d calc lines=%d, cols=%d, begy=%d, begx=%d"),
              __FILE__, __LINE__, 526, view->lines, view->cols, view->begy, view->begx);
    write_cmenu_log(em0);
#endif
    if (view->lines == 0 && view->cols == 0 && view->begy == 0 && view->begx == 0) {
        view->lines = scr_lines - 3;
        view->cols = scr_cols - 2;
        view->begy = 0;
        view->begx = 0;
    }
    uint lines = max(scr_lines / 10, 8);
    view->lines = max(view->lines, lines);
    if (view->lines > scr_lines - 3)
        view->lines = scr_lines - 3;
    if (view->lines + view->begy > scr_lines - 3)
        view->begy = scr_lines - (view->lines + 3);
 
    uint cols = max(scr_cols / 3, 40);
    view->cols = max(view->cols, cols);
    if (view->cols > scr_cols - 2)
        view->cols = scr_cols - 2;
    if (view->cols + view->begx > scr_cols - 2)
        view->begx = scr_cols - (view->cols + 2);
 
    view->h_shift = view->cols / 3;
    view->ln_win_lines = view->lines - 1;
    if (view->f_ln)
        view->ln_win_cols = 8;
    else
        view->ln_win_cols = 0;
    view->scroll_lines = view->lines - 1;
    view->cmd_line = 0;
    view->pminrow = 0;
    view->pmincol = 0;
    view->sminrow = view->begy + 1;
    view->smincol = view->begx + view->ln_win_cols + 1;
    view->smaxrow = view->begy + view->lines;
    view->smaxcol = view->begx + view->cols;
    view->ln_no = view->page_top_ln_no + view->scroll_lines;
    view->page_bot_ln_no = view->ln_no;
#ifdef DEBUG_RESIZE
    ssnprintf(em0, MAXLEN - 1,
              _("%s:%d calc BOX lines=%d, cols=%d, begy=%d, begx=%d"),
              __FILE__, __LINE__, view->lines + 2, view->cols + 2, view->begy, view->begx);
    write_cmenu_log(em0);
    ssnprintf(em0, MAXLEN - 1,
              _("%s:%d calc WIN lines=%d, cols=%d, begy=%d, begx=%d"),
              __FILE__, __LINE__, view->lines, view->cols, 1, 1);
    write_cmenu_log(em0);
    ssnprintf(em0, MAXLEN - 1,
              _("%s:%d calc CMDLN lines=%d, cols=%d, begy=%d, begx=%d"),
              __FILE__, __LINE__, 1, view->cols, view->lines - 1, 1);
    write_cmenu_log(em0);
    ssnprintf(em0, MAXLEN - 1,
              _("%s:%d calc LNNO lines=%d, cols=%d, begy=%d, begx=%d"),
              __FILE__, __LINE__, view->lines - 1, view->ln_win_cols, 0, 0);
    write_cmenu_log(em0);
    ssnprintf(em0, MAXLEN - 1,
              _("%s:%d calc PAD lines=%d, cols=%d, begy=%d, begx=%d"),
              __FILE__, __LINE__, view->lines - 1, view->cols - view->ln_win_cols, 0, view->ln_win_cols);
    write_cmenu_log(em0);
 
#endif
}
/** @brief Initialize the input for the C-Menu View.
    @ingroup init_view
    @param init Pointer to the Init structure containing view settings.
    @param file_name Name of the input file or "-" for standard input.
    @return 0 on success, -1 on failure.
    @details This function initializes the input for the C-Menu View. It handles
   both regular files and standard input, setting up pipes if necessary. It also
   memory-maps the input file for efficient access and sets up the view structure
   accordingly.
 */
int view_init_input(Init *init, char *file_name) {
    struct stat sb;
    int idx = 0;
    pid_t pid = -1;
    int pipe_fd[2];
    int s_argc = 0;
    char *s_argv[MAXARGS];
    char tmp_str[MAXLEN];
    View *view = init->view;
    view->f_in_pipe = false;
    if (strcmp(file_name, "-") == 0) {
        file_name = _("/dev/stdin");
        view->f_in_pipe = true;
    }
    if (view->provider_cmd[0] != '\0') {
        s_argc = str_to_args(s_argv, view->provider_cmd, MAXARGS - 1);
        if (pipe(pipe_fd) == -1) {
            ui_perror(_("pipe(pipe_fd) failed in init_view"));
            return -1;
        }
        // endwin();
        if ((pid = fork()) == -1) {
            ui_perror(_("fork() failed in init_view"));
            return -1;
        }
        if (pid == 0) { // Child
            /** Prevent child process from writing to terminal */
            int dev_null = open(_("/dev/null"), O_WRONLY);
            if (dev_null == -1) {
                ui_perror(_("open(/dev/null) failed in init_pick child process"));
                exit(EXIT_FAILURE);
            }
            dup2(dev_null, STDERR_FILENO);
            close(dev_null);
            close(pipe_fd[P_READ]);
            dup2(pipe_fd[P_WRITE], STDOUT_FILENO);
            close(pipe_fd[P_WRITE]);
            execvp(s_argv[0], s_argv);
            strnz__cpy(tmp_str, _("Can't exec view start cmd: "), MAXLEN - 1);
            strnz__cat(tmp_str, s_argv[0], MAXLEN - 1);
            ui_perror(tmp_str);
            exit(EXIT_FAILURE);
        }
        // Back to parent
        destroy_argv(s_argc, s_argv);
        sig_prog_mode();
        ui_restore_wins();
        close(pipe_fd[P_WRITE]);
        view->in_fd = dup(pipe_fd[P_READ]);
        view->f_in_pipe = true;
    } else {
        if (view->f_in_pipe)
            view->in_fd = dup(STDIN_FILENO);
        else {
            /*----------------------------------------------------------------------*/
            /* Open the input file for reading and get its size. */
            expand_tilde(file_name, MAXLEN - 1);
            view->in_fd = open(file_name, O_RDONLY);
            if (view->in_fd == -1) {
                ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__,
                          __LINE__ - 3);
                ssnprintf(em1, MAXLEN - 1, _("open %s"), file_name);
                strerror__r(errno, em2, MAXLEN);
                ui_display_error(em0, em1, em2,
                                 nullptr);
                return -1;
            }
            if (fstat(view->in_fd, &sb) == -1) {
                ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__,
                          __LINE__ - 1);
                ssnprintf(em1, MAXLEN - 1, _("fstat %s"), file_name);
                strerror__r(errno, em2, MAXLEN);
                ui_display_error(em0, em1, em2, nullptr);
                close(view->in_fd);
                return -1;
            }
            view->file_size = sb.st_size;
            if (view->file_size == 0) {
                close(view->in_fd);
                ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__,
                          __LINE__ - 1);
                ssnprintf(em1, MAXLEN - 1, _("file %s is empty"), file_name);
                strerror__r(errno, em2, MAXLEN);
                ui_display_error(em0, em1, em2, nullptr);
                return -1;
            }
            if (!S_ISREG(sb.st_mode))
                view->f_in_pipe = true;
        }
        /*----------------------------------------------------------------------*/
    }
    if (view->f_in_pipe) {
        errno = 0;
        view->tmp_fd = memfd_create(_("view_input"), MFD_CLOEXEC);
        if (view->in_fd < 0 || errno != 0) {
            ssnprintf(em0, MAXLEN - 1, "memfd_create failed\n");
            ssnprintf(em1, MAXLEN - 1, "%s", strerror(errno));
            ssnprintf(em2, MAXLEN - 1, _("%s, line: %d, errno: %d"), __FILE__,
                      __LINE__ - 4, errno);
            ui_display_error(em0, em1, em2, nullptr);
            exit(EXIT_FAILURE);
        }
        // ------------------------------------------------------
        // transfer view->in_fd to view->tmp_fd
        // ------------------------------------------------------
        char buf[VBUFSIZ];
        ssize_t bytes_read = 0;
        // ------------------------------------------------------
        // countdown to timeout if view->in_fd not ready
        // ------------------------------------------------------
        ui_flush_input();
        ui_register_read_fd(view->in_fd, UIKEY_STREAM_DATA);
        int status = ui_poll_reg_read_fd(500);
        if (status == 0) {
            int timeout_ms = init->timeout_secs * 1000;
            status = ui_timeout_prompt(_("Waiting for input..."), _("from view_input"), timeout_ms, init->timeout_secs);
            ui_unregister_read_fd(view->in_fd);
            if (status != UIKEY_STREAM_DATA) {
                if (status == UIKEY_F09)
                    cmenu_abend(init, -1, _("view: user pressed F9"));
                if (status == UIKEY_TIMEOUT)
                    cmenu_abend(init, -1, _("view: timed out waiting for input"));
                cmenu_abend(init, -1, _("view: no input data"));
            }
        }
        // ------------------------------------------------------
        // end wait
        // ------------------------------------------------------
        bytes_read = read(view->in_fd, buf, sizeof(buf));
        if (bytes_read > 0) {
            if (write(view->tmp_fd, buf, bytes_read) != bytes_read)
                cmenu_abend(init, EXIT_FAILURE, _("view: unable to write view->tmp_fd"));
        } else if (bytes_read == 0)
            cmenu_abend(init, EXIT_FAILURE, _("view: unable to read view->tmp_fd"));
        // ------------------------------------------------------
        // end transfer
        // ------------------------------------------------------
        if (fstat(view->tmp_fd, &sb) == -1) {
            ssnprintf(em0, MAXLEN - 1, "fstat(view->in_fd) failed\n");
            ssnprintf(em1, MAXLEN - 1, "%s", strerror(errno));
            ssnprintf(em2, MAXLEN - 1, _("%s, line: %d, errno: %d"), __FILE__,
                      __LINE__ - 4, errno);
            ui_display_error(em0, em1, em2, nullptr);
            exit(EXIT_FAILURE);
        }
        view->file_size = sb.st_size;
        if (view->file_size == 0) {
            close(view->tmp_fd);
            strnz__cpy(tmp_str, _("view: no standard input"), MAXLEN - 1);
            ui_abend(-1, tmp_str);
            exit(EXIT_FAILURE);
        }
        waitpid(-1, nullptr, 0);
        view->in_fd = view->tmp_fd;
    }
    view->buf =
        mmap(nullptr, view->file_size, PROT_READ, MAP_PRIVATE, view->in_fd, 0);
    if (view->buf == MAP_FAILED) {
        ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__, __LINE__ - 2);
        ssnprintf(em1, MAXLEN - 1, _("mmap %s"), file_name);
        strerror__r(errno, em2, MAXLEN);
        ui_display_error(em0, em1, em2, nullptr);
        close(view->in_fd);
        return -1;
    }
    close(view->in_fd);
    stdio_fdnames(stdio_names_str, _("init_view.c 422"));
    view->file_size = sb.st_size;
    view->prev_file_pos = NULL_POSITION;
    view->buf_curr_ptr = view->buf;
    if (view->cmd_all[0] != '\0')
        strnz__cpy(view->cmd, view->cmd_all, MAXLEN - 1);
    for (idx = 0; idx < NMARKS; idx++)
        view->mark_tbl[idx] = NULL_POSITION;
    strnz__cpy(view->cur_file_str, file_name, MAXLEN - 1);
    base_name(view->file_name, view->cur_file_str);
    return 0;
}