pick_engine.c

Go to the documentation of this file.

/** @file pick_engine.c
    @brief pick from a list of choices
    @author Bill Waller
    Copyright (c) 2025
    MIT License
    billxwaller@gmail.com
    @date 2026-02-09
 */
 
/** @defgroup pick_engine Object Selection
    @brief Functions to Navigate, Select, and Perform Action on Objects
 */
 
#include <common.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <termios.h>
#include <unistd.h>
 
int tbl_col, tbl_line, tbl_page, tbl_cols, pg_lines, tbl_pages;
int obj_idx, calculated_idx;
int pick_engine(Init *);
void save_object(Pick *, char *);
int picker(Init *);
void display_page(Pick *);
void reverse_object(Pick *);
void unreverse_object(Pick *);
void toggle_object(Pick *);
int output_objects(Pick *);
int exec_objects(Init *);
int open_pick_win(Init *);
void display_pick_help(Init *);
int read_pick_input(Init *);
void deselect_object(Pick *);
 
int pipe_fd[2];
 
char const pagers_editors[12][10] = {"view", "view",  "less", "more",
                                     "vi",   "vim",   "nano", "nvim",
                                     "pico", "emacs", "edit", ""};
 
/** @brief Initializes pick structure and opens pick input file or pipe
 *  @ingroup pick_engine
    @param init Pointer to Init structure
    @param argc Argument count
    @param argv Argument vector
    @param begy Beginning y coordinate for pick window
    @param begx Beginning x coordinate for pick window
    @note If provider_cmd is specified, it takes precedence over in_spec and
    input file arguments
    @note provider_cmd is executed and its output is read as pick input
    @note If provider_cmd is not specified, in_spec is used to read pick
    input from a file or stdin
    @note If provider_cmd is specified, it is executed and its output is
    read as pick input */
int init_pick(Init *init, int argc, char **argv, int begy, int begx) {
    struct stat sb;
    char *s_argv[MAXARGS];
    int s_argc;
    char tmp_str[MAXLEN];
    int m;
    pid_t pid = 0;
 
    if (init->pick != nullptr)
        destroy_pick(init);
    Pick *pick = new_pick(init, argc, argv, begy, begx);
    if (init->pick != pick)
        abend(-1, "init->pick != pick\n");
    SIO *sio = init->sio;
    if (pick->provider_cmd[0] != '\0') {
        s_argc = str_to_args(s_argv, pick->provider_cmd, MAXARGS - 1);
        if (pipe(pipe_fd) == -1) {
            Perror("pipe(pipe_fd) failed in init_pick");
            return (1);
        }
        if ((pid = fork()) == -1) {
            Perror("fork() failed in init_pick");
            return (1);
        }
        if (pid == 0) {
            /** Spawn Child to execute provider_cmd
                Close read end of pipe as Child only needs to write to pipe */
            close(pipe_fd[P_READ]);
            /** Connect CHILD STDOUT to write end of pipe */
            dup2(pipe_fd[P_WRITE], STDOUT_FILENO);
            dup2(pipe_fd[P_WRITE], STDERR_FILENO);
            /** STDOUT attached to write end of pipe, so close pipe fd */
            close(pipe_fd[P_WRITE]);
            execvp(s_argv[0], s_argv);
            m = MAXLEN - 24;
            strnz__cpy(tmp_str, "Can't exec pick start cmd: ", m);
            m -= strlen(s_argv[0]);
            strnz__cat(tmp_str, s_argv[0], m);
            Perror(tmp_str);
            exit(EXIT_FAILURE);
        }
        /** Return to Parent
            Close write end of pipe as Parent only needs to read from pipe */
        close(pipe_fd[P_WRITE]);
        /** Open a file pointer on read end of pipe */
        pick->in_fp = fdopen(pipe_fd[P_READ], "rb");
        pick->f_in_pipe = true;
        destroy_argv(s_argc, s_argv);
    } else {
        if ((pick->in_spec[0] == '\0') || strcmp(pick->in_spec, "-") == 0 ||
            strcmp(pick->in_spec, "/dev/stdin") == 0) {
            strnz__cpy(pick->in_spec, "/dev/stdin", MAXLEN - 1);
            pick->in_fp = fdopen(STDIN_FILENO, "rb");
            pick->f_in_pipe = true;
        }
    }
    if (!pick->f_in_pipe) {
        /** No provider_cmd specified, so read pick input from file or stdin */
        if (lstat(pick->in_spec, &sb) == -1) {
            m = MAXLEN - 29;
            strnz__cpy(tmp_str, "Can\'t stat pick input file: ", m);
            m -= strlen(pick->in_spec);
            strnz__cat(tmp_str, pick->in_spec, m);
            Perror(tmp_str);
            return (1);
        }
        if (sb.st_size == 0) {
            m = MAXLEN - 24;
            strnz__cpy(tmp_str, "Pick input file empty: ", m);
            m -= strlen(pick->in_spec);
            strnz__cat(tmp_str, pick->in_spec, m);
            Perror(tmp_str);
            return (1);
        }
        if ((pick->in_fp = fopen(pick->in_spec, "rb")) == nullptr) {
            m = MAXLEN - 29;
            strnz__cpy(tmp_str, "Can't open pick input file: ", m);
            m -= strlen(pick->in_spec);
            strnz__cat(tmp_str, pick->in_spec, m);
            Perror(tmp_str);
            return (1);
        }
    }
    /*------------------------------------------------------------*/
    bool f_wait = false;
    int ready;
    fd_set read_fds;
    struct timeval timeout;
    Chyron *wait_chyron;
    WINDOW *wait_win;
    int remaining;
    if (pick->in_fp == nullptr) {
        Perror("No pick input available");
        destroy_pick(init);
        return (1);
    }
    int in_fd = fileno(pick->in_fp);
    FD_ZERO(&read_fds);
    FD_SET(in_fd, &read_fds);
    timeout.tv_sec = 0;
    timeout.tv_usec =
        200000; /**< Initial timeout of 200ms to check for pick input */
    ready = select(in_fd + 1, &read_fds, nullptr, nullptr, &timeout);
    if (ready == 0) {
        f_wait = true;
        remaining = wait_timeout;
        wait_chyron = wait_mk_chyron();
        wait_win = wait_mk_win(wait_chyron, "WAITING for PICK INPUT");
    }
    cmd_key = 0;
    while (ready == 0 && remaining > 0 && cmd_key != KEY_F(9)) {
        cmd_key = wait_continue(wait_win, wait_chyron, remaining);
        if (cmd_key == KEY_F(9))
            break;
        FD_ZERO(&read_fds);
        FD_SET(in_fd, &read_fds);
        timeout.tv_sec = 0;
        timeout.tv_usec = 0;
        ready = select(in_fd + 1, &read_fds, nullptr, nullptr, &timeout);
        remaining--;
    }
    if (f_wait) {
        if (wait_chyron != nullptr)
            wait_destroy(wait_chyron);
    }
    if (cmd_key == KEY_F(9)) {
        if (pick->f_in_pipe && pid > 0) {
            /** If user cancels while waiting for pick input, kill provider_cmd
             * child process and close pipe */
            kill(pid, SIGKILL);
            waitpid(pid, nullptr, 0);
            close(pipe_fd[P_READ]);
        }
        Perror("No pick input available");
        destroy_pick(init);
        return (1);
    }
    if (ready == -1) {
        Perror("Error waiting for pick input");
        if (pick->f_in_pipe && pid > 0) {
            /** If error occurs while waiting for pick input, kill provider_cmd
             * child process and close pipe */
            kill(pid, SIGKILL);
            waitpid(pid, nullptr, 0);
            close(pipe_fd[P_READ]);
        }
        destroy_pick(init);
        return (1);
    }
    if (ready == 0) {
        Perror("Timeout waiting for pick input");
        if (pick->f_in_pipe && pid > 0) {
            /** If timeout occurs while waiting for pick input, kill
             * provider_cmd child process and close pipe */
            kill(pid, SIGKILL);
            waitpid(pid, nullptr, 0);
            close(pipe_fd[P_READ]);
        }
        destroy_pick(init);
        return (1);
    }
    if (ready == 1 && !FD_ISSET(in_fd, &read_fds)) {
        Perror("Unexpected error waiting for pick input");
        if (pick->f_in_pipe && pid > 0) {
            /** If unexpected error occurs while waiting for pick input, kill
             * provider_cmd child process and close pipe */
            kill(pid, SIGKILL);
            waitpid(pid, nullptr, 0);
            close(pipe_fd[P_READ]);
        }
        destroy_pick(init);
        return (1);
    }
    /*------------------------------------------------------------*/
    read_pick_input(init);
    if (pick->f_in_pipe && pid > 0) {
        /** Wait for provider_cmd child process to finish before proceeding */
        waitpid_with_timeout(pid, wait_timeout);
        // waitpid(pid, nullptr, 0);
        close(pipe_fd[P_READ]);
        dup2(sio->stdin_fd, STDIN_FILENO);
        dup2(sio->stdout_fd, STDOUT_FILENO);
        restore_curses_tioctl();
        sig_prog_mode();
        keypad(pick->win, true);
    }
    if (pick->obj_cnt == 0) {
        Perror("No pick objects available");
        destroy_pick(init);
        return (1);
    }
    /** Enter pick_engine */
    pick_engine(init);
    win_del();
    destroy_pick(init);
    return 0;
}
/** @brief Reads pick input from file pointer and saves objects into pick
 structure
 *  @ingroup pick_engine
    @param init Pointer to Init structure containing pick information
    @return 0 on success, -1 if no objects were read
    @note Reads lines from pick->in_fp and saves them as objects in the pick
   structure using save_object function. If no objects are read, returns -1.
   Otherwise, sets obj_cnt to the number of objects read and resets obj_idx to 0
   before returning 0. */
int read_pick_input(Init *init) {
    int i;
 
    Pick *pick = init->pick;
    pick->select_cnt = 0;
    pick->obj_cnt = pick->pg_lines = pick->tbl_cols = 0;
    pick->obj_idx = pick->tbl_page = pick->y = pick->tbl_col = pick->x = 0;
    pick->tbl_pages = 1;
 
    if (pick->in_fp) {
        while (fgets(pick->in_buf, sizeof(pick->in_buf), pick->in_fp) !=
               nullptr)
            save_object(pick, pick->in_buf);
    } else
        for (i = 1; i < pick->argc; i++)
            save_object(pick, pick->argv[i]);
    if (pick->in_fp != nullptr)
        fclose(pick->in_fp);
    if (!pick->obj_idx)
        return (-1);
    pick->obj_cnt = pick->obj_idx;
    pick->obj_idx = 0;
    return 0;
}
/** @brief Initializes pick interface, calculates window size and position, and
   enters picker loop
 *  @ingroup pick_engine
    @param init Pointer to Init structure containing pick information
    @return Count of selected objects on success, -1 if user cancels
    @note Initializes key command strings for chyron display and calculates pick
   window size and position based on terminal size and pick parameters.
    @note Opens pick window and displays first page of objects. Enters picker
   loop to handle user input and interactions. If user cancels selection,
   returns -1.
    @note If user accepts selection, returns count of selected objects. */
int pick_engine(Init *init) {
    /** Initialize window and data structures */
    int rc;
    int maxy, maxx, win_maxy, win_maxx;
    int tbl_max_cols, pg_max_objs;
    /** Initialize key command strings for chyron display */
 
    getmaxyx(stdscr, maxy, maxx);
    /** Calculate pick window size and position based on terminal size and pick
        parameters */
    win_maxy = min(((maxy * 8) / 10), (maxy - pick->begy - 1));
    win_maxx = min(((maxx * 9) / 10), (maxx - pick->begx - 1));
    pick->tbl_col_width = max(pick->tbl_col_width, 4);
    pick->tbl_col_width = min(pick->tbl_col_width, win_maxx - 2);
    if (pick->obj_cnt <= win_maxy) {
        pick->tbl_lines = pick->obj_cnt;
        pick->tbl_cols = 1;
    } else {
        tbl_max_cols = (win_maxx / (pick->tbl_col_width + 1));
        pg_max_objs = win_maxy * tbl_max_cols;
        if (pick->obj_cnt > pg_max_objs)
            pick->tbl_cols = tbl_max_cols;
        else
            pick->tbl_cols = pick->obj_cnt / win_maxy;
        pick->tbl_lines = pick->obj_cnt / tbl_max_cols;
    }
    pick->tbl_pages = (pick->tbl_lines / (win_maxy - 1)) + 1;
    pick->pg_lines = (pick->tbl_lines / pick->tbl_pages);
    pick->win_lines = pick->pg_lines + 1;
    pick->tbl_page = 0;
    if (pick->begy == 0)
        pick->begy = (LINES - pick->win_lines) / 5;
    else if (pick->begy + pick->win_lines > LINES - 4)
        pick->begy = LINES - pick->win_lines - 2;
    pick->win_width = (pick->tbl_col_width + 1) * pick->tbl_cols;
 
    pick->chyron = new_chyron();
    set_chyron_key(pick->chyron, 1, "F1 Help", KEY_F(1));
    set_chyron_key(pick->chyron, 9, "F9 Cancel", KEY_F(9));
    set_chyron_key(pick->chyron, 10, "F10 Continue", KEY_F(10));
    if (pick->tbl_pages > 1) {
        set_chyron_key(pick->chyron, 11, "PgUp", KEY_PPAGE);
        set_chyron_key(pick->chyron, 12, "PgDn", KEY_NPAGE);
    }
    set_chyron_key(pick->chyron, 13, "Toggle", 't');
    compile_chyron(pick->chyron);
    if (pick->chyron->l > win_maxx)
        pick->chyron->l = strnz(pick->chyron->s, win_maxx);
    if (pick->win_width < pick->chyron->l)
        pick->win_width = pick->chyron->l;
    pick->win_width = max(pick->win_width, pick->chyron->l) + 1;
    if (pick->begx + pick->win_width > COLS - 2)
        pick->begx = COLS - pick->win_width - 2;
    else if (pick->begx == 0)
        pick->begx = (COLS - pick->win_width) / 2;
 
    rc = open_pick_win(init);
    if (rc)
        return (rc);
    /** Enter picker loop to handle user input and interactions */
    pick->obj_idx = 0;
    pick->x = 1;
    do {
        display_page(pick);
        reverse_object(pick);
        mousemask(BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED, nullptr);
        rc = picker(init);
        if (rc == -1)
            break;
        else {
            if (pick->select_cnt > 0) {
                if (pick->f_out_spec && pick->out_spec[0])
                    output_objects(pick);
                if (pick->f_cmd && pick->cmd[0])
                    exec_objects(init);
            }
        }
        deselect_object(pick);
    } while (1);
    destroy_chyron(pick->chyron);
    return (rc);
}
/** @brief Saves a string as an object in the pick structure
 *  @ingroup pick_engine
    @param pick Pointer to Pick structure
    @param s String to save as an object
    @note If the current object index is less than the maximum allowed, saves
   the string as an object in the pick structure. Updates the column width if
   necessary and marks the object as not selected. Increments the object index
   for the next object to be saved. */
void save_object(Pick *pick, char *s) {
    int l;
 
    if (pick->obj_idx < OBJ_MAXCNT - 1) {
        l = strlen(s);
        if (l > OBJ_MAXLEN - 1)
            s[OBJ_MAXLEN - 1] = '\0';
        pick->tbl_col_width = max(pick->tbl_col_width, l);
        l = max(l, 1);
        pick->object[pick->obj_idx] = (char *)calloc(l + 1, sizeof(char));
        strnz__cpy(pick->object[pick->obj_idx], s, l);
        pick->f_selected[pick->obj_idx] = false;
        pick->obj_idx++;
    }
}
 
/** @brief Main loop to handle user input and interactions for pick interface
 *  @ingroup pick_engine
    @param init Pointer to Init structure
    @return Number of selected objects or -1 if user cancels
    @note Handles user input for navigating and selecting objects in the pick
   interface.
    @note Supports various key commands for navigation, selection, and
   accepting/canceling the selection.
    @note Updates the display accordingly based on user interactions.
    @note If the user cancels the selection, returns -1.
    @note If the user accepts the selection, returns the count of selected
   objects. */
int picker(Init *init) {
    int cmd_key;
    int display_tbl_page;
    bool f_no_reset_cmd_key;
    pick = init->pick;
    click_y = click_x = -1;
    cmd_key = 0;
    while (1) {
        tcflush(tty_fd, TCIFLUSH);
        f_no_reset_cmd_key = false;
        if (cmd_key == 0)
            cmd_key = xwgetch(pick->win, pick->chyron, -1);
        switch (
            cmd_key) { /** 'q', or KEY_F(9) cancel selection and exit picker */
        case 'q':
        case 'Q':
        case KEY_F(9):
            deselect_object(pick);
            return -1;
            /** KEY_F(1) or 'H' Displays help screen for pick interface */
        case KEY_F(1):
        case 'H':
            display_pick_help(init);
            display_page(pick);
            reverse_object(pick);
            break;
            /** 't' or Space Toggles selection of current object */
        case ' ':
        case 't':
        case 'T':
            reverse_object(pick);
            toggle_object(pick);
            if (pick->select_max > 0 && pick->select_cnt == pick->select_max)
                return pick->select_cnt;
            break;
            /** Enter or KEY_F(10) Accepts current selection and exits picker,
             * returning count of selected objects */
        case KEY_F(10):
        case '\n':
        case KEY_ENTER:
            return pick->select_cnt;
            /** KEY_END Moves selection to last object in list */
        case KEY_END:
            mvwaddstr_fill(pick->win, pick->y, pick->x,
                           pick->object[pick->obj_idx], pick->tbl_col_width);
            display_tbl_page = pick->tbl_page;
            pick->obj_idx = pick->obj_cnt - 1;
            pick->tbl_page = pick->obj_idx / (pick->pg_lines * pick->tbl_cols);
            pick->tbl_line = (pick->obj_idx / pick->tbl_cols) % pick->pg_lines;
            pick->tbl_col = pick->obj_idx % pick->tbl_cols;
            pick->y = pick->tbl_line;
            if (display_tbl_page != pick->tbl_page) {
                display_page(pick);
            }
            reverse_object(pick);
            break;
        /** 'l' or KEY_RIGHT Moves selection to next object in list */
        case 'l':
        case KEY_RIGHT:
            mvwaddstr_fill(pick->win, pick->y, pick->x,
                           pick->object[pick->obj_idx], pick->tbl_col_width);
            /** pick->obj_idx += pick->tbl_lines -> next column */
            if (pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                        (pick->tbl_col + 1) * pick->pg_lines + pick->tbl_line <
                    pick->obj_cnt - 1 &&
                pick->tbl_col < pick->tbl_cols - 1)
                pick->tbl_col++;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_col * pick->pg_lines + pick->tbl_line;
            reverse_object(pick);
            break;
            /** 'h' or KEY_LEFT or Backspace Moves selection to previous object
             * in list */
        case 'h':
        case KEY_LEFT:
        case KEY_BACKSPACE:
            mvwaddstr_fill(pick->win, pick->y, pick->x,
                           pick->object[pick->obj_idx], pick->tbl_col_width);
            if (pick->tbl_col > 0)
                pick->tbl_col--;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_col * pick->pg_lines + pick->tbl_line;
            reverse_object(pick);
            break;
            /** 'j' or KEY_DOWN Moves selection to next object in list, 'k' or
             * KEY_UP Moves selection to previous object in list */
        case 'j':
        case KEY_DOWN:
            mvwaddstr_fill(pick->win, pick->y, pick->x,
                           pick->object[pick->obj_idx], pick->tbl_col_width);
            if (pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                        pick->tbl_col * pick->pg_lines + pick->tbl_line <
                    pick->obj_cnt - 1 &&
                pick->tbl_line < pick->pg_lines - 1)
                pick->tbl_line++;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_col * pick->pg_lines + pick->tbl_line;
            reverse_object(pick);
            break;
            /** 'k' or KEY_UP Moves selection to previous object in list */
        case 'k':
        case KEY_UP:
            mvwaddstr_fill(pick->win, pick->y, pick->x,
                           pick->object[pick->obj_idx], pick->tbl_col_width);
            if (pick->tbl_line > 0)
                pick->tbl_line--;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_col * pick->pg_lines + pick->tbl_line;
            reverse_object(pick);
            break;
        /** KEY_NPAGE or 'Ctrl+f' Moves selection to next page of objects, */
        case KEY_NPAGE:
        case '\06':
            if (pick->tbl_pages == 1)
                break;
            if (pick->tbl_page < pick->tbl_pages - 1) {
                pick->tbl_page++;
                pick->pg_line = 0;
                pick->tbl_col = 0;
            }
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_cols * pick->pg_line + pick->tbl_col;
            display_page(pick);
            reverse_object(pick);
            break;
            /**   KEY_PPAGE or 'Ctrl+b' Moves selection to previous page of
             * objects */
        case KEY_PPAGE:
        case '\02':
            if (pick->tbl_pages == 1)
                break;
            if (pick->tbl_page > 0)
                pick->tbl_page--;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_cols * pick->pg_line + pick->tbl_col;
            display_page(pick);
            reverse_object(pick);
            break;
            /** KEY_HOME Moves selection to first object in list */
        case KEY_HOME:
            pick->tbl_page = 0;
            pick->tbl_line = 0;
            pick->tbl_col = 0;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_cols * pick->pg_line + pick->tbl_col;
            display_page(pick);
            reverse_object(pick);
            break;
            /** KEY_LL (lower left of numeric pad) Moves selection to last
                object in list */
        case KEY_LL:
            pick->tbl_page = pick->tbl_pages - 1;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_cols * pick->pg_line + pick->tbl_col;
            display_page(pick);
            reverse_object(pick);
            break;
            /** KEY_MOUSE Handles mouse events for selection and chyron key
             * activation */
        case KEY_MOUSE:
            if (click_y == -1 || click_x == -1)
                break;
            unreverse_object(pick);
            pick->y = click_y;
            pick->tbl_col = (click_x - 1) / (pick->tbl_col_width + 1);
            if (pick->tbl_col < 0 || pick->tbl_col >= pick->tbl_cols)
                break;
            pick->obj_idx = pick->tbl_page * pick->pg_lines * pick->tbl_cols +
                            pick->tbl_col * pick->pg_lines + pick->y;
            cmd_key =
                't'; /** Set cmdkey to 't' to toggle selection on mouse click */
            f_no_reset_cmd_key = true;
            click_y = click_x = -1;
            break;
        default:
            break;
        }
        if (!f_no_reset_cmd_key)
            cmd_key = 0;
    }
    return 0;
}
/** @brief Displays current page of objects in pick window
 *  @ingroup pick_engine
    @param pick Pointer to Pick structure containing objects and display
   information
    @note Clears the pick window and displays the current page of objects based
   on the current table page, line, and column. Marks selected objects with an
   asterisk. Updates the chyron with page information at the bottom of the pick
   window. */
void display_page(Pick *pick) {
    int y, col, pidx;
    for (y = 0; y < pick->pg_lines; y++) {
        wmove(pick->win, y, 0);
        wclrtoeol(pick->win);
    }
    pidx = pick->tbl_page * pick->pg_lines * pick->tbl_cols;
    for (col = 0; col < pick->tbl_cols; col++) {
        pick->x = col * (pick->tbl_col_width + 1) + 1;
        for (y = 0; y < pick->pg_lines; y++, pidx++) {
            if (pidx < pick->obj_cnt) {
                if (pick->f_selected[pidx])
                    mvwaddstr(pick->win, y, pick->x - 1, "*");
                mvwaddstr_fill(pick->win, y, pick->x, pick->object[pidx],
                               pick->tbl_col_width);
            }
        }
    }
    compile_chyron(pick->chyron);
    display_chyron(pick->win, pick->chyron, pick->pg_lines, pick->chyron->l);
}
/** @brief Reverses the display of the currently selected object in pick window
 *  @ingroup pick_engine
    @param pick Pointer to Pick structure containing object and display
   information
    @note Calculates the x coordinate for the currently selected object based on
   the current table column and column width. Moves the cursor to the object's
   position in the pick window, turns on reverse video attribute, and displays
   the object's text. Turns off reverse video attribute and refreshes the pick
   window to show the updated display. Moves the cursor back to the position
   before the object text for potential further interactions. */
void reverse_object(Pick *pick) {
    pick->x = pick->tbl_col * (pick->tbl_col_width + 1) + 1;
    pick->tbl_line = (pick->obj_idx / pick->tbl_cols) % pick->pg_lines;
    pick->y = pick->tbl_line;
    wmove(pick->win, pick->y, pick->x);
    wattron(pick->win, WA_REVERSE);
    mvwaddstr_fill(pick->win, pick->y, pick->x, pick->object[pick->obj_idx],
                   pick->tbl_col_width);
    wattroff(pick->win, WA_REVERSE);
    wmove(pick->win, pick->y, pick->x - 1);
}
/** @brief Unreverses the display of the currently selected object in pick
   window
   @ingroup pick_engine
    @param pick Pointer to Pick structure containing object and display
   information
    @note Calculates the x coordinate for the currently selected object based on
   the current table column and column width. Moves the cursor to the object's
   position in the pick window and displays the object's text without reverse
   video attribute. Refreshes the pick window to show the updated display. Moves
   the cursor back to the position before the object text for potential further
   interactions. */
void unreverse_object(Pick *pick) {
    pick->x = pick->tbl_col * (pick->tbl_col_width + 1) + 1;
    wmove(pick->win, pick->y, pick->x);
    mvwaddstr_fill(pick->win, pick->y, pick->x, pick->object[pick->obj_idx],
                   pick->tbl_col_width);
    wmove(pick->win, pick->y, pick->x - 1);
}
/** @brief Toggles the selection state of the currently selected object in pick
   window
   @ingroup pick_engine
    @param pick Pointer to Pick structure containing object and selection
   information
    @note Calculates the x coordinate for the currently selected object based on
   the current table column and column width. If the object is currently
   selected, it is deselected by updating the selection count, marking it as not
   selected, and displaying a space before the object text. If the object is not
   currently selected, it is selected by updating the selection count, marking
   it as selected, and displaying an asterisk before the object text. Refreshes
   the pick window to show the updated display. Moves the cursor back to the
   position before the object text for potential further interactions. */
void toggle_object(Pick *pick) {
    pick->x = pick->tbl_col * (pick->tbl_col_width + 1) + 1;
    if (pick->f_selected[pick->obj_idx]) {
        pick->select_cnt--;
        pick->f_selected[pick->obj_idx] = false;
        mvwaddstr(pick->win, pick->y, pick->x - 1, " ");
    } else {
        pick->select_cnt++;
        pick->f_selected[pick->obj_idx] = true;
        mvwaddstr(pick->win, pick->y, pick->x - 1, "*");
    }
}
/** @brief Deselects the currently selected object in pick window
   @ingroup pick_engine
    @details like toggle, but only deselects object */
void deselect_object(Pick *pick) {
    pick->x = pick->tbl_col * (pick->tbl_col_width + 1) + 1;
    if (pick->f_selected[pick->obj_idx]) {
        pick->select_cnt--;
        pick->f_selected[pick->obj_idx] = false;
        mvwaddstr(pick->win, pick->y, pick->x - 1, " ");
    }
}
/** @brief Outputs selected objects to specified output file
   @ingroup pick_engine
    @param pick Pointer to Pick structure containing selected objects and
   output file information
    @return 0 on success, 1 on failure
    @note If output file cannot be opened, an error message is printed and
   the function returns 1. Otherwise, selected objects are written to the
   output file, one per line, and the file is closed before returning 0.
*/
int output_objects(Pick *pick) {
    char tmp_str[MAXLEN];
    int m;
    if ((pick->out_fp = fopen(pick->out_spec, "w")) == nullptr) {
        m = MAXLEN - 30;
        strnz__cpy(tmp_str, "Can't open pick output file: ", m);
        m -= strlen(pick->in_spec);
        strnz__cat(tmp_str, pick->out_spec, m);
    }
    for (pick->obj_idx = 0; pick->obj_idx < pick->obj_cnt; pick->obj_idx++) {
        if (pick->f_selected[pick->obj_idx])
            fprintf(stdout, "%s\n", pick->object[pick->obj_idx]);
    }
    fflush(stdout);
    if (pick->out_fp != nullptr)
        fclose(pick->out_fp);
    return (0);
}
/** @brief Executes specified command with selected objects as arguments
   @ingroup pick_engine
   @param init Pointer to Init structure
   @return 0 on success, 1 on failure
   @note Parses command string and appends selected objects as arguments to the
   command. If command contains "%%", it is replaced with a space- separated
   list of selected objects. Executes the command using execvp in a child
   process and waits for it to finish. If the command is a pager or editor, it
   is executed within the pick interface using popup_view instead of execvp.
   @note If f_append_args is true, the argument containing %% is replaced with
   the concatenated selected objects. If f_append_args is false, selected
   objects are added as separate arguments and the original command arguments
   remain unchanged.
   @note eargv should be null-terminated to indicate the end of arguments for
   execvp
   @note Memory allocated for arguments is freed after execution to prevent
   memory leaks.
   @note If execvp fails, an error message is printed and the child process
   exits with failure status
   @note The parent process waits for the child process to finish before
   proceeding and restores terminal settings
   @note If the command is a pager or editor, it is executed within the pick
   interface using popup_view instead of execvp
   @note The base name of the command is extracted to check if it is a pager or
   editor
   @note If the command is a pager or editor, the pick interface is used to
   display the command output instead of executing it in a separate terminal
   This allows the user to view the command output without leaving the pick
   interface and provides a more seamless user experience.
   @note If the command is not a pager or editor, it is executed in a separate
   terminal and the pick interface is restored after execution
   @note If the command to be executed is view, an external command is not
   needed, instead the popup_view function can be used to display the output
   within the pick interface */
int exec_objects(Init *init) {
    int rc = -1;
    int eargc;
    char *eargv[MAXARGS];
    char tmp_str[MAXLEN];
    char title[MAXLEN];
    char sav_arg[MAXLEN];
    char *out_s;
    int eargx = 0;
    int i = 0;
    pid_t pid = 0;
    bool f_append_args = false;
    // char *s1;
 
    title[0] = '\0';
    if (pick->cmd[0] == '\0')
        return -1;
    if (pick->cmd[0] == '\\' || pick->cmd[0] == '\"') {
        size_t len = strlen(pick->cmd);
        if (len > 1 && pick->cmd[len - 1] == '\"') {
            memmove(pick->cmd, pick->cmd + 1, len - 2);
            pick->cmd[len - 2] = '\0';
        }
    }
    eargc = str_to_args(eargv, pick->cmd, MAXARGS - 1);
    tmp_str[0] = '\0';
    if (pick->f_multiple_cmd_args) {
        for (i = 0; i < pick->obj_cnt; i++) {
            if (pick->f_selected[i] && eargc < MAXARGS) {
                if (tmp_str[0] != '\0')
                    strnz__cat(tmp_str, " ", MAXLEN - 1);
                strnz__cat(tmp_str, pick->object[i], MAXLEN - 1);
            }
        }
        eargv[eargc++] = strdup(tmp_str);
    } else {
        f_append_args = false;
        i = 0;
        while (i < eargc) {
            /** This is the line that gets the selected objects */
            if (strstr(eargv[i], "%%") != nullptr) {
                tmp_str[0] = '\0';
                f_append_args = true;
                strnz__cpy(sav_arg, eargv[i], MAXLEN - 1);
                eargx = i;
                break;
            }
            i++;
        }
        for (i = 0; i < pick->obj_cnt; i++) {
            /** append arguments onto tmp_str */
            if (pick->f_selected[i] && eargc < MAXARGS - 1) {
                if (f_append_args == true) {
                    if (tmp_str[0] != '\0')
                        strnz__cat(tmp_str, " ", MAXLEN - 1);
                    strnz__cat(tmp_str, pick->object[i], MAXLEN - 1);
                    continue;
                }
                eargv[eargc++] = strdup(pick->object[i]);
            }
        }
        if (f_append_args == true) {
            if (eargv[eargx] != nullptr) {
                free(eargv[eargx]);
                eargv[eargx] = nullptr;
            }
            out_s = rep_substring(sav_arg, "%%", tmp_str);
            if (out_s == nullptr || out_s[0] == '\0') {
                i = 0;
                while (i < eargc) {
                    if (eargv[i] != nullptr)
                        free(eargv[i]);
                    i++;
                }
                Perror("rep_substring() failed in exec_objects");
                return 1;
            }
            strnz__cpy(title, out_s, MAXLEN - 1);
            eargv[eargx] = strdup(out_s);
            if (out_s != nullptr) {
                free(out_s);
                out_s = nullptr;
            }
        }
    }
    strnz__cpy(tmp_str, eargv[0], MAXLEN - 1);
    eargv[eargc] = nullptr;
    // s1 = tmp_str;
    char *sp;
    // Scan-build false positive: strtok_r modifies the input string, but
    // tmp_str is a local array and is not used after this point, so it is safe
    // to modify it with strtok_r
    char *tok;
    tok = strtok_r(tmp_str, " ", &sp);
    strnz__cpy(sav_arg, tok, MAXLEN - 1);
    base_name(tmp_str, sav_arg);
    if (tmp_str[0] != '\0' &&
        (strcmp(tmp_str, "view") == 0 || strcmp(tmp_str, "view") == 0)) {
        /** initialize popup_view arguments and execute popup_view to display
           command output within pick interface */
        init->lines = 60;
        init->cols = 80;
        init->begy = pick->begy + 1;
        init->begx = pick->begx + 1;
        if (title[0] != '\0')
            strnz__cpy(init->title, title, MAXLEN - 1);
        else
            strnz__cpy(init->title, eargv[eargc], MAXLEN - 1);
        popup_view(init, eargc, eargv, init->lines, init->cols, init->begy,
                   init->begx);
        i = 0;
        while (i < eargc) {
            if (eargv[i] != nullptr)
                free(eargv[i]);
            i++;
        }
        return 0;
    } else {
        if ((pid = fork()) == -1) {
            /** fork failed, free eargv and return error */
            i = 0;
            while (i < eargc) {
                if (eargv[i] != nullptr)
                    free(eargv[i]);
                i++;
            }
            Perror("fork() failed in exec_objects");
            return (1);
        }
        if (pid == 0) {
            /** Child process to execute command */
            execvp(eargv[0], eargv);
            /** If execvp returns, it means execution failed, so free eargv
               and print error message before exiting */
            destroy_argv(eargc, eargv);
            strnz__cpy(tmp_str, "Can't exec pick cmd: ", MAXLEN - 1);
            strnz__cat(tmp_str, eargv[0], MAXLEN - 1);
            Perror(tmp_str);
            exit(EXIT_FAILURE);
        }
    }
    // waitpid_with_timeout(pid, wait_timeout);
    // action_disposition("Notification", "Command executed");
    waitpid(pid, nullptr, 0);
    // win_del();
    destroy_argv(eargc, eargv);
    restore_curses_tioctl();
    sig_prog_mode();
    werase(stdscr);
    wrefresh(stdscr);
    restore_wins();
    return rc;
}
/** @brief Initializes the pick window based on the parameters specified in
the Pick structure
   @ingroup pick_engine
    @param init Pointer to Init structure containing pick information
    @return 0 on success, 1 on failure
    @note Creates a new window for the pick interface using win_new function
with the specified parameters from the Pick structure. If window creation
fails, an error message is printed and the function returns 1. Otherwise,
initializes the window and box pointers in the Pick structure, sets scrollok
and keypad options for the window, and returns 0 on success. */
int open_pick_win(Init *init) {
    char tmp_str[MAXLEN];
    pick = init->pick;
    if (win_new(pick->win_lines, pick->win_width, pick->begy, pick->begx,
                pick->title, 0)) {
        ssnprintf(tmp_str, MAXLEN - 1, "win_new(%d, %d, %d, %d, %s, %b) failed",
                  pick->win_lines, pick->win_width, pick->begy, pick->begx,
                  pick->title, 0);
        Perror(tmp_str);
 
        return (1);
    }
    pick->win = win_win[win_ptr];
    pick->box = win_box[win_ptr];
    scrollok(pick->win, false);
    keypad(pick->win, true);
    return 0;
}
/** @brief Displays the help screen for the pick interface using view
   @ingroup pick_engine
    @param init Pointer to Init structure containing pick information
    @note Initializes the help_spec field in the Pick structure with the
   path to the pick help file. Then, constructs the argument list for
   executing popup_view with the help file as an argument. Finally, calls
   popup_view function to display the help screen within the pick interface. */
void display_pick_help(Init *init) {
    char tmp_str[MAXLEN];
    eargc = 0;
    if (pick->f_help_spec && pick->help_spec[0] != '\0')
        strnz__cpy(tmp_str, pick->help_spec, MAXLEN - 1);
    else {
        strnz__cpy(tmp_str, init->mapp_help, MAXLEN - 1);
        strnz__cat(tmp_str, "/", MAXLEN - 1);
        strnz__cat(tmp_str, PICK_HELP_FILE, MAXLEN - 1);
    }
    eargv[eargc++] = strdup("view");
    eargv[eargc++] = strdup("-N");
    eargv[eargc++] = strdup("f");
    eargv[eargc++] = strdup(tmp_str);
    eargv[eargc] = nullptr;
    init->lines = 30;
    init->cols = 76;
    init->begy = pick->begy + 1;
    init->begx = pick->begx + 1;
    strnz__cpy(init->title, "Pick Help", MAXLEN - 1);
    popup_view(init, eargc, eargv, init->lines, init->cols, init->begy,
               init->begx);
    destroy_argv(eargc, eargv);
    return;
}