Object Selection

Functions to Navigate, Select, and Perform Action on Objects. More...

Functions
int	init_pick (Init *init, int argc, char **argv, int begy, int begx)
	Initializes pick structure and opens pick input file or pipe.
int	read_pick_input (Init *init)
	Reads pick input from file pointer and saves objects into pick structure.
int	pick_engine (Init *init)
	Initializes pick interface, calculates window size and position, and enters picker loop.
void	save_object (Pick *pick, char *s)
	Saves a string as an object in the pick structure.
int	picker (Init *init)
	Main loop to handle user input and interactions for pick interface.
void	display_page (Pick *pick)
	Displays current page of objects in pick window.
void	reverse_object (Pick *pick)
	Reverses the display of the currently selected object in pick window.
void	unreverse_object (Pick *pick)
	Unreverses the display of the currently selected object in pick window.
void	toggle_object (Pick *pick)
	Toggles the selection state of the currently selected object in pick window.
void	deselect_object (Pick *pick)
	Deselects the currently selected object in pick window.
int	output_objects (Pick *pick)
	Outputs selected objects to specified output file.
int	exec_objects (Init *init)
	Executes specified command with selected objects as arguments.
int	open_pick_win (Init *init)
	Initializes the pick window based on the parameters specified in the Pick structure.
void	display_pick_help (Init *init)
	Displays the help screen for the pick interface using view.

Detailed Description

Functions to Navigate, Select, and Perform Action on Objects.

Function Documentation

deselect_object()

void deselect_object

(

Pick *

pick

)

Deselects the currently selected object in pick window.

like toggle, but only deselects object

Definition at line 696 of file pick_engine.c.

                                 {
    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, " ");
    }
}

References Pick::f_selected, Pick::obj_idx, Pick::select_cnt, Pick::tbl_col, Pick::tbl_col_width, Pick::win, Pick::x, and Pick::y.

Referenced by pick_engine(), and picker().

Here is the caller graph for this function:

display_page()

void display_page

(

Pick *

pick

)

Displays current page of objects in pick window.

Parameters

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.

Definition at line 608 of file pick_engine.c.

                              {
    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);
}

References Pick::chyron, compile_chyron(), display_chyron(), Pick::f_selected, Chyron::l, mvwaddstr_fill(), Pick::obj_cnt, Pick::object, Pick::pg_lines, Pick::tbl_col_width, Pick::tbl_cols, Pick::tbl_page, Pick::win, and Pick::x.

Referenced by pick_engine(), and picker().

Here is the call graph for this function:

Here is the caller graph for this function:

display_pick_help()

void display_pick_help

(

Init *

init

)

Displays the help screen for the pick interface using view.

Parameters

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.

Definition at line 953 of file pick_engine.c.

                                   {
    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;
}

References Init::begx, Pick::begx, Init::begy, Pick::begy, Init::cols, destroy_argv(), eargc, eargv, Pick::f_help_spec, Pick::help_spec, Init::lines, Init::mapp_help, pick, popup_view(), strnz__cat(), strnz__cpy(), and Init::title.

Referenced by picker().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_objects()

int exec_objects

(

Init *

init

)

Executes specified command with selected objects as arguments.

Parameters

init	Pointer to Init structure

Returns

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.

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.

eargv should be null-terminated to indicate the end of arguments for execvp

Memory allocated for arguments is freed after execution to prevent memory leaks.

If execvp fails, an error message is printed and the child process exits with failure status

The parent process waits for the child process to finish before proceeding and restores terminal settings

If the command is a pager or editor, it is executed within the pick interface using popup_view instead of execvp

The base name of the command is extracted to check if it is a pager or editor

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.

If the command is not a pager or editor, it is executed in a separate terminal and the pick interface is restored after execution

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

This is the line that gets the selected objects

append arguments onto tmp_str

initialize popup_view arguments and execute popup_view to display command output within pick interface

fork failed, free eargv and return error

Child process to execute command

If execvp returns, it means execution failed, so free eargv and print error message before exiting

Definition at line 765 of file pick_engine.c.

                             {
    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) {
            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++) {
            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)) {
        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) {
            i = 0;
            while (i < eargc) {
                if (eargv[i] != nullptr)
                    free(eargv[i]);
                i++;
            }
            Perror("fork() failed in exec_objects");
            return (1);
        }
        if (pid == 0) {
            execvp(eargv[0], eargv);
            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;
}

References base_name(), Init::begx, Pick::begx, Init::begy, Pick::begy, Pick::cmd, Init::cols, destroy_argv(), Pick::f_multiple_cmd_args, Pick::f_selected, Init::lines, Pick::obj_cnt, Pick::object, Perror(), pick, popup_view(), rep_substring(), restore_curses_tioctl(), restore_wins(), sig_prog_mode(), str_to_args(), strnz__cat(), strnz__cpy(), and Init::title.

Referenced by pick_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

init_pick()

int init_pick	(	Init *	init,
		int	argc,
		char **	argv,
		int	begy,
		int	begx )

Initializes pick structure and opens pick input file or pipe.

Parameters

init	Pointer to Init structure
argc	Argument count
argv	Argument vector
begy	Beginning y coordinate for pick window
begx	Beginning x coordinate for pick window

Note

If provider_cmd is specified, it takes precedence over in_spec and input file arguments

provider_cmd is executed and its output is read as pick input

If provider_cmd is not specified, in_spec is used to read pick input from a file or stdin

If provider_cmd is specified, it is executed and its output is read as pick input

Spawn Child to execute provider_cmd Close read end of pipe as Child only needs to write to pipe

Connect CHILD STDOUT to write end of pipe

STDOUT attached to write end of pipe, so close pipe fd

Return to Parent Close write end of pipe as Parent only needs to read from pipe

Open a file pointer on read end of pipe

No provider_cmd specified, so read pick input from file or stdin

< Initial timeout of 200ms to check for pick input

If user cancels while waiting for pick input, kill provider_cmd child process and close pipe

If error occurs while waiting for pick input, kill provider_cmd child process and close pipe

If timeout occurs while waiting for pick input, kill provider_cmd child process and close pipe

If unexpected error occurs while waiting for pick input, kill provider_cmd child process and close pipe

Wait for provider_cmd child process to finish before proceeding

Enter pick_engine

Definition at line 59 of file pick_engine.c.

                                                                     {
    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) {
            close(pipe_fd[P_READ]);
            dup2(pipe_fd[P_WRITE], STDOUT_FILENO);
            dup2(pipe_fd[P_WRITE], STDERR_FILENO);
            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);
        }
        close(pipe_fd[P_WRITE]);
        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) {
        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; 
    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) {
            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) {
            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) {
            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) {
            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) {
        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);
    }
    pick_engine(init);
    win_del();
    destroy_pick(init);
    return 0;
}

References abend(), cmd_key, destroy_argv(), destroy_pick(), Pick::f_in_pipe, Pick::in_fp, Pick::in_spec, new_pick(), Pick::obj_cnt, Perror(), Init::pick, pick_engine(), pipe_fd, Pick::provider_cmd, read_pick_input(), restore_curses_tioctl(), sig_prog_mode(), Init::sio, SIO::stdin_fd, SIO::stdout_fd, str_to_args(), strnz__cat(), strnz__cpy(), wait_continue(), wait_destroy(), wait_mk_chyron(), wait_mk_win(), wait_timeout, waitpid_with_timeout(), Pick::win, and win_del().

Referenced by main(), and popup_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

open_pick_win()

int open_pick_win

(

Init *

init

)

Initializes the pick window based on the parameters specified in the Pick structure.

Parameters

init	Pointer to Init structure containing pick information

Returns

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.

Definition at line 928 of file pick_engine.c.

                              {
    char tmp_str[MAXLEN];
    pick = init->pick;
    if (box_new(pick->win_lines, pick->win_width, pick->begy, pick->begx,
                pick->title, true)) {
        ssnprintf(tmp_str, MAXLEN - 1, "box_new(%d, %d, %d, %d, %s) failed",
                  pick->win_lines, pick->win_width, pick->begy, pick->begx,
                  pick->title);
        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;
}

References Pick::begx, Pick::begy, Pick::box, box_new(), Perror(), Init::pick, pick, ssnprintf(), Pick::title, Pick::win, win_box, Pick::win_lines, win_ptr, Pick::win_width, and win_win.

Referenced by pick_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

output_objects()

int output_objects

(

Pick *

pick

)

Outputs selected objects to specified output file.

Parameters

pick	Pointer to Pick structure containing selected objects and output file information

Returns

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.

Definition at line 713 of file pick_engine.c.

                               {
    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);
}

References Pick::f_selected, Pick::in_spec, Pick::obj_cnt, Pick::obj_idx, Pick::object, Pick::out_fp, Pick::out_spec, strnz__cat(), and strnz__cpy().

Referenced by pick_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

pick_engine()

int pick_engine

(

Init *

init

)

Initializes pick interface, calculates window size and position, and enters picker loop.

Parameters

init	Pointer to Init structure containing pick information

Returns

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.

Opens pick window and displays first page of objects. Enters picker loop to handle user input and interactions. If user cancels selection, returns -1.

If user accepts selection, returns count of selected objects.

Initialize window and data structures

Initialize key command strings for chyron display

Calculate pick window size and position based on terminal size and pick parameters

Enter picker loop to handle user input and interactions

Definition at line 300 of file pick_engine.c.

                            {
    int rc;
    int maxy, maxx, win_maxy, win_maxx;
    int tbl_max_cols, pg_max_objs;
 
    getmaxyx(stdscr, maxy, maxx);
    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);
    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);
}

References Pick::begx, Pick::begy, Pick::chyron, Pick::cmd, compile_chyron(), deselect_object(), destroy_chyron(), display_page(), exec_objects(), Pick::f_cmd, Pick::f_out_spec, Chyron::l, new_chyron(), Pick::obj_cnt, Pick::obj_idx, open_pick_win(), Pick::out_spec, output_objects(), Pick::pg_lines, pick, picker(), reverse_object(), Chyron::s, Pick::select_cnt, set_chyron_key(), strnz(), Pick::tbl_col_width, Pick::tbl_cols, Pick::tbl_lines, Pick::tbl_page, Pick::tbl_pages, Pick::win_lines, Pick::win_width, and Pick::x.

Referenced by init_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

picker()

int picker

(

Init *

init

)

Main loop to handle user input and interactions for pick interface.

Parameters

init	Pointer to Init structure

Returns

Number of selected objects or -1 if user cancels

Note

Handles user input for navigating and selecting objects in the pick interface.

Supports various key commands for navigation, selection, and accepting/canceling the selection.

Updates the display accordingly based on user interactions.

If the user cancels the selection, returns -1.

If the user accepts the selection, returns the count of selected objects.

'q', or KEY_F(9) cancel selection and exit picker

KEY_F(1) or 'H' Displays help screen for pick interface

't' or Space Toggles selection of current object

Enter or KEY_F(10) Accepts current selection and exits picker, returning count of selected objects

KEY_END Moves selection to last object in list

'l' or KEY_RIGHT Moves selection to next object in list

pick->obj_idx += pick->tbl_lines -> next column

'h' or KEY_LEFT or Backspace Moves selection to previous object in list

'j' or KEY_DOWN Moves selection to next object in list, 'k' or KEY_UP Moves selection to previous object in list

'k' or KEY_UP Moves selection to previous object in list

KEY_NPAGE or 'Ctrl+f' Moves selection to next page of objects,

KEY_PPAGE or 'Ctrl+b' Moves selection to previous page of objects

KEY_HOME Moves selection to first object in list

KEY_LL (lower left of numeric pad) Moves selection to last object in list

KEY_MOUSE Handles mouse events for selection and chyron key activation

Set cmdkey to 't' to toggle selection on mouse click

Definition at line 418 of file pick_engine.c.

                       {
    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) { 
        case 'q':
        case 'Q':
        case KEY_F(9):
            deselect_object(pick);
            return -1;
        case KEY_F(1):
        case 'H':
            display_pick_help(init);
            display_page(pick);
            reverse_object(pick);
            break;
        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;
        case KEY_F(10):
        case '\n':
        case KEY_ENTER:
            return pick->select_cnt;
        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;
        case 'l':
        case KEY_RIGHT:
            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 + 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;
        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;
        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;
        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;
        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;
        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;
        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;
        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;
        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'; 
            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;
}

References Pick::chyron, click_x, click_y, deselect_object(), display_page(), display_pick_help(), mvwaddstr_fill(), Pick::obj_cnt, Pick::obj_idx, Pick::object, Pick::pg_line, Pick::pg_lines, Init::pick, pick, reverse_object(), Pick::select_cnt, Pick::select_max, Pick::tbl_col, Pick::tbl_col_width, Pick::tbl_cols, Pick::tbl_line, Pick::tbl_page, Pick::tbl_pages, toggle_object(), tty_fd, unreverse_object(), Pick::win, Pick::x, xwgetch(), and Pick::y.

Referenced by pick_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

read_pick_input()

int read_pick_input

(

Init *

init

)

Reads pick input from file pointer and saves objects into pick structure.

Parameters

init	Pointer to Init structure containing pick information

Returns

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.

Definition at line 265 of file pick_engine.c.

                                {
    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;
}

References Pick::argc, Pick::argv, Pick::in_buf, Pick::in_fp, Pick::obj_cnt, Pick::obj_idx, Pick::pg_lines, Init::pick, save_object(), Pick::select_cnt, Pick::tbl_col, Pick::tbl_cols, Pick::tbl_page, Pick::tbl_pages, Pick::x, and Pick::y.

Referenced by init_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

reverse_object()

void reverse_object

(

Pick *

pick

)

Reverses the display of the currently selected object in pick window.

Parameters

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.

Definition at line 639 of file pick_engine.c.

                                {
    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);
}

References mvwaddstr_fill(), Pick::obj_idx, Pick::object, Pick::pg_lines, Pick::tbl_col, Pick::tbl_col_width, Pick::tbl_cols, Pick::tbl_line, Pick::win, Pick::x, and Pick::y.

Referenced by pick_engine(), and picker().

Here is the call graph for this function:

Here is the caller graph for this function:

save_object()

void save_object	(	Pick *	pick,
		char *	s )

Saves a string as an object in the pick structure.

Parameters

pick	Pointer to Pick structure
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.

Definition at line 390 of file pick_engine.c.

                                      {
    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++;
    }
}

References Pick::f_selected, Pick::obj_idx, Pick::object, strnz__cpy(), and Pick::tbl_col_width.

Referenced by read_pick_input().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_object()

void toggle_object

(

Pick *

pick

)

Toggles the selection state of the currently selected object in pick window.

Parameters

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.

Definition at line 681 of file pick_engine.c.

                               {
    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, "*");
    }
}

References Pick::f_selected, Pick::obj_idx, Pick::select_cnt, Pick::tbl_col, Pick::tbl_col_width, Pick::win, Pick::x, and Pick::y.

Referenced by picker().

Here is the caller graph for this function:

unreverse_object()

void unreverse_object

(

Pick *

pick

)

Unreverses the display of the currently selected object in pick window.

Parameters

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.

Definition at line 661 of file pick_engine.c.

                                  {
    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);
}

References mvwaddstr_fill(), Pick::obj_idx, Pick::object, Pick::tbl_col, Pick::tbl_col_width, Pick::win, Pick::x, and Pick::y.

Referenced by picker().

Here is the call graph for this function:

Here is the caller graph for this function: