/*
- * Copyright (C) 1998-2014 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 1998 Andre Noll <maan@tuebingen.mpg.de>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
static struct gui_window {
WINDOW *win;
+ bool needs_update;
} top, bot, sb, in, sep;
+/** How many lines of output to remember. */
#define RINGBUFFER_SIZE 512
+
struct rb_entry {
char *msg;
size_t len;
static struct gui_args_info conf;
static int loglevel;
+/** Type of the process currently being executed. */
enum exec_status {
- EXEC_IDLE, /* no command running */
- EXEC_DCMD, /* para or display command running */
- EXEC_XCMD, /* external command running */
+ EXEC_IDLE, /**< No process running. */
+ EXEC_DCMD, /**< para or display process running. */
+ EXEC_XCMD, /**< External process running. */
};
/**
static struct gui_command command_list[] = {GUI_COMMANDS {.name = NULL}};
struct input_task {
- struct task task;
+ struct task *task;
};
struct status_task {
- struct task task;
+ struct task *task;
+ pid_t pid;
char *buf;
int bufsize, loaded;
struct timeval next_exec;
int fd;
};
+/** Stdout/stderr of the executing process is read in chunks of this size. */
#define COMMAND_BUF_SIZE 32768
struct exec_task {
- struct task task;
+ struct task *task;
char command_buf[2][COMMAND_BUF_SIZE]; /* stdout/stderr of command */
int cbo[2]; /* command buf offsets */
unsigned flags[2]; /* passed to for_each_line() */
waddstr(win, str);
} else {
add_spaces(win, num / 2);
- waddstr(win, str[0]? str: "");
+ waddstr(win, str);
add_spaces(win, num - num / 2);
}
return 1;
}
+static void refresh_window(struct gui_window *gw)
+{
+ gw->needs_update = true;
+}
+
+static bool window_update_needed(void)
+{
+ return top.needs_update || bot.needs_update || sb.needs_update ||
+ in.needs_update || sep.needs_update;
+}
+
__printf_2_3 static void print_in_bar(int color, const char *fmt,...)
{
char *msg;
wmove(in.win, 0, 0);
align_str(in.win, msg, get_num_cols(&in), LEFT);
free(msg);
- wrefresh(in.win);
+ refresh_window(&in);
}
static void print_status_bar(void)
waddstr(bot.win, rbe->msg);
}
out:
- wrefresh(bot.win);
+ refresh_window(&bot);
}
static void rb_add_entry(int color, char *msg)
xvasprintf(&msg, fmt, ap);
va_end(ap);
rb_add_entry(color, msg);
- wrefresh(bot.win);
+ refresh_window(&bot);
}
static int add_output_line(char *line, void *data)
if (bytes > 0 && msg[bytes - 1] == '\n')
msg[bytes - 1] = '\0'; /* cut trailing newline */
rb_add_entry(color, msg);
- wrefresh(bot.win);
+ refresh_window(&bot);
} else if (exec_pid <= 0) /* no external command running */
vfprintf(stderr, fmt, ap);
va_end(ap);
}
+/** The log function of para_gui, always set to curses_log(). */
__printf_2_3 void (*para_log)(int, const char*, ...) = curses_log;
static void shutdown_curses(void)
return;
tmp = make_message("%s%s%s", d.prefix, c, d.postfix);
wmove(top.win, d.y * top_lines / 100, d.x * COLS / 100);
- wrefresh(top.win);
wattron(top.win, COLOR_PAIR(i + 1));
align_str(top.win, tmp, d.len * COLS / 100, d.align);
free(tmp);
- wrefresh(top.win);
+ refresh_window(&top);
}
static int update_item(int item_num, char *buf)
}
}
-static void status_pre_select(struct sched *s, struct task *t)
+static void status_pre_select(struct sched *s, void *context)
{
- struct status_task *st = container_of(t, struct status_task, task);
+ struct status_task *st = context;
if (st->fd >= 0)
- return para_fd_set(st->fd, &s->rfds, &s->max_fileno);
- sched_request_barrier_or_min_delay(&st->next_exec, s);
+ para_fd_set(st->fd, &s->rfds, &s->max_fileno);
+ if (task_get_notification(st->task) < 0)
+ return sched_min_delay(s);
+ if (st->fd < 0)
+ sched_request_barrier_or_min_delay(&st->next_exec, s);
}
-static int status_post_select(struct sched *s, struct task *t)
+static int status_post_select(struct sched *s, void *context)
{
- struct status_task *st = container_of(t, struct status_task, task);
+ struct status_task *st = context;
size_t sz;
- pid_t pid;
int ret, ret2;
+ ret = task_get_notification(st->task);
+ if (ret == -E_GUI_SIGCHLD && st->pid > 0) {
+ int exit_status;
+ if (waitpid(st->pid, &exit_status, WNOHANG) == st->pid) {
+ st->pid = 0;
+ PARA_ERROR_LOG("stat command exit status: %d",
+ exit_status);
+ }
+ }
if (st->fd < 0) {
int fds[3] = {0, 1, 0};
+ if (st->pid > 0)
+ return 0;
/* Avoid busy loop */
if (tv_diff(&st->next_exec, now, NULL) > 0)
return 0;
st->next_exec.tv_sec = now->tv_sec + 2;
- ret = para_exec_cmdline_pid(&pid, conf.stat_cmd_arg, fds);
+ ret = para_exec_cmdline_pid(&st->pid, conf.stat_cmd_arg, fds);
if (ret < 0)
return 0;
ret = mark_fd_nonblocking(fds[1]);
ret2 = for_each_stat_item(st->buf, st->loaded, update_item);
if (ret < 0 || ret2 < 0) {
st->loaded = 0;
- PARA_NOTICE_LOG("closing stat pipe: %s\n", para_strerror(-ret));
+ PARA_NOTICE_LOG("closing stat pipe: %s\n",
+ para_strerror(ret < 0? -ret : -ret2));
close(st->fd);
st->fd = -1;
clear_all_items();
int bot_lines = LINES - top_lines - 3, sb_lines = 1, in_lines = 1,
sep_lines = 1;
- assume_default_colors(theme.default_fg, theme.default_bg);
+ assume_default_colors(theme.dflt.fg, theme.dflt.bg);
if (top.win) {
wresize(top.win, top_lines, COLS);
mvwin(top.win, top_y, 0);
die(EXIT_FAILURE, "fatal: failed to start colors\n");
FOR_EACH_STATUS_ITEM(i)
if (theme.data[i].len)
- init_pair_or_die(i + 1, theme.data[i].fg,
- theme.data[i].bg);
- init_pair_or_die(COLOR_STATUSBAR, theme.sb_fg, theme.sb_bg);
- init_pair_or_die(COLOR_COMMAND, theme.cmd_fg, theme.cmd_bg);
- init_pair_or_die(COLOR_OUTPUT, theme.output_fg, theme.output_bg);
- init_pair_or_die(COLOR_MSG, theme.msg_fg, theme.msg_bg);
- init_pair_or_die(COLOR_ERRMSG, theme.err_msg_fg, theme.err_msg_bg);
- init_pair_or_die(COLOR_SEPARATOR, theme.sep_fg, theme.sep_bg);
- init_pair_or_die(COLOR_TOP, theme.default_fg, theme.default_bg);
- init_pair_or_die(COLOR_BOT, theme.default_fg, theme.default_bg);
+ init_pair_or_die(i + 1, theme.data[i].color.fg,
+ theme.data[i].color.bg);
+ init_pair_or_die(COLOR_STATUSBAR, theme.sb.fg, theme.sb.bg);
+ init_pair_or_die(COLOR_COMMAND, theme.cmd.fg, theme.cmd.bg);
+ init_pair_or_die(COLOR_OUTPUT, theme.output.fg, theme.output.bg);
+ init_pair_or_die(COLOR_MSG, theme.msg.fg, theme.msg.bg);
+ init_pair_or_die(COLOR_ERRMSG, theme.err_msg.fg, theme.err_msg.bg);
+ init_pair_or_die(COLOR_SEPARATOR, theme.sep.fg, theme.sep.bg);
+ init_pair_or_die(COLOR_TOP, theme.dflt.fg, theme.dflt.bg);
+ init_pair_or_die(COLOR_BOT, theme.dflt.fg, theme.dflt.bg);
}
/* (Re-)initialize the curses library. */
{
if (curses_active())
return;
- if (top.win && refresh() == ERR) /* refresh is really needed */
+ if (refresh() == ERR) /* refresh is really needed */
die(EXIT_FAILURE, "refresh() failed\n");
if (LINES < theme.lines_min || COLS < theme.cols_min)
die(EXIT_FAILURE, "Terminal (%dx%d) too small"
// noecho(); /* don't echo input */
}
-static void check_sigchld(void)
-{
- int ret;
- pid_t pid;
-
-reap_next_child:
- ret = para_reap_child(&pid);
- if (ret <= 0)
- return;
- if (pid == exec_pid) {
- exec_pid = 0;
- init_curses();
- print_in_bar(COLOR_MSG, " ");
- }
- goto reap_next_child;
-}
-
/*
* This sucker modifies its first argument. *handler and *arg are
* pointers to 0-terminated strings (inside line). Crap.
}
goto out;
}
+ /*
+ * When the gengetopt config file parser is called more than once, any
+ * key map arguments found in the config file are _appended_ to the old
+ * values, even though we turn on ->override. We want the new arguments
+ * to replace the old ones, so we must empty the key_map_arg array
+ * first. Unfortunately, this also clears any key map arguments given
+ * at the command line.
+ */
+ if (override) {
+ int i;
+ for (i = 0; i < conf.key_map_given; i++) {
+ free(conf.key_map_arg[i]);
+ conf.key_map_arg[i] = NULL;
+ }
+ conf.key_map_given = 0;
+ }
+
gui_cmdline_parser_config_file(config_file, &conf, ¶ms);
loglevel = get_loglevel_by_name(conf.loglevel_arg);
check_key_map_args_or_die();
- theme_init(conf.theme_arg, &theme);
err = false;
out:
free(config_file);
if (err)
exit(EXIT_FAILURE);
+ theme_init(conf.theme_arg, &theme);
}
/* reread configuration, terminate on errors */
/*
* React to various signal-related events
*/
-static int signal_post_select(struct sched *s, __a_unused struct task *t)
+static int signal_post_select(struct sched *s, __a_unused void *context)
{
int ret = para_next_signal(&s->rfds);
case SIGTERM:
die(EXIT_FAILURE, "only the good die young (caught SIGTERM)\n");
return 1;
- case SIGWINCH:
- if (curses_active()) {
- shutdown_curses();
- init_curses();
- redraw_bot_win();
- }
- return 1;
case SIGINT:
PARA_WARNING_LOG("caught SIGINT, reset\n");
/* Nothing to do. SIGINT killed our child which gets noticed
reread_conf();
return 1;
case SIGCHLD:
- check_sigchld();
+ task_notify_all(s, E_GUI_SIGCHLD);
return 1;
}
return 1;
return EXEC_IDLE;
}
-static void exec_pre_select(struct sched *s, __a_unused struct task *t)
+static void exec_pre_select(struct sched *s, void *context)
{
- enum exec_status es = exec_status();
-
- if (es != EXEC_DCMD)
- return;
+ struct exec_task *et = context;
if (exec_fds[0] >= 0)
para_fd_set(exec_fds[0], &s->rfds, &s->max_fileno);
if (exec_fds[1] >= 0)
para_fd_set(exec_fds[1], &s->rfds, &s->max_fileno);
+ if (task_get_notification(et->task) < 0)
+ sched_min_delay(s);
}
-static int exec_post_select(struct sched *s, struct task *t)
+static int exec_post_select(struct sched *s, void *context)
{
- struct exec_task *ct = container_of(t, struct exec_task, task);
+ struct exec_task *ct = context;
int i, ret;
- enum exec_status es = exec_status();
- if (es != EXEC_DCMD)
- return 0;
+ ret = task_get_notification(ct->task);
+ if (ret == -E_GUI_SIGCHLD && exec_pid > 0) {
+ int exit_status;
+ if (waitpid(exec_pid, &exit_status, WNOHANG) == exec_pid) {
+ exec_pid = 0;
+ init_curses();
+ PARA_INFO_LOG("command exit status: %d", exit_status);
+ print_in_bar(COLOR_MSG, " ");
+ }
+ }
for (i = 0; i < 2; i++) {
size_t sz;
if (exec_fds[i] < 0)
ct->cbo[i] = for_each_line(ct->flags[i], ct->command_buf[i],
ct->cbo[i], add_output_line, &i);
if (sz != ct->cbo[i]) { /* at least one line found */
- wrefresh(bot.win);
+ refresh_window(&bot);
ct->flags[i] = 0;
}
if (ret < 0 || exec_pid == 0) {
return 0;
}
-static void input_pre_select(struct sched *s, __a_unused struct task *t)
+static void input_pre_select(struct sched *s, __a_unused void *context)
{
if (exec_status() != EXEC_XCMD)
para_fd_set(STDIN_FILENO, &s->rfds, &s->max_fileno);
+ if (window_update_needed())
+ sched_min_delay(s);
}
/* read from command pipe and print data to bot window */
km_keyname(c));
}
-static int input_post_select(__a_unused struct sched *s, __a_unused struct task *t)
+static int input_post_select(__a_unused struct sched *s, __a_unused void *context)
{
int ret;
enum exec_status exs = exec_status();
if (exs == EXEC_XCMD)
return 0;
+ if (window_update_needed()) {
+ if (top.needs_update)
+ assert(wnoutrefresh(top.win) == OK);
+ if (bot.needs_update)
+ assert(wnoutrefresh(bot.win) == OK);
+ if (sep.needs_update)
+ assert(wnoutrefresh(sep.win) == OK);
+ if (sb.needs_update)
+ assert(wnoutrefresh(sb.win) == OK);
+ if (in.needs_update)
+ assert(wnoutrefresh(in.win) == OK);
+ doupdate();
+ top.needs_update = bot.needs_update = sb.needs_update =
+ in.needs_update = sep.needs_update = false;
+ }
ret = wgetch(top.win);
- if (ret == ERR || ret == KEY_RESIZE)
+ if (ret == ERR)
return 0;
- if (exs == EXEC_IDLE) {
- handle_command(ret);
+ if (ret == KEY_RESIZE) {
+ if (curses_active()) {
+ shutdown_curses();
+ init_curses();
+ redraw_bot_win();
+ }
return 0;
}
- if (exec_pid != 0)
+ if (exs == EXEC_IDLE)
+ handle_command(ret);
+ else if (exec_pid > 0)
kill(exec_pid, SIGTERM);
return 0;
}
-static void signal_pre_select(struct sched *s, struct task *t)
-{
- struct signal_task *st = container_of(t, struct signal_task, task);
- para_fd_set(st->fd, &s->rfds, &s->max_fileno);
-}
-
static void print_scroll_msg(void)
{
unsigned lines_total, filled = ringbuffer_filled(bot_win_rb);
wmove(bot.win, bot_lines - rbe_lines, 0);
wattron(bot.win, COLOR_PAIR(rbe->color));
waddstr(bot.win, rbe->msg);
- wrefresh(bot.win);
+ refresh_window(&bot);
print_scroll_msg();
}
break;
i--;
}
- wrefresh(bot.win);
+ refresh_window(&bot);
print_scroll_msg();
return;
err_out:
static int setup_tasks_and_schedule(void)
{
+ int ret;
+ struct exec_task exec_task = {.task = NULL};
+ struct status_task status_task = {.fd = -1};
+ struct input_task input_task = {.task = NULL};
+ struct signal_task *signal_task;
struct sched sched = {
.default_timeout = {
.tv_sec = conf.timeout_arg / 1000,
.tv_usec = (conf.timeout_arg % 1000) * 1000,
},
};
- struct exec_task exec_task = {
- .task = {
- .status = "exec",
- .pre_select = exec_pre_select,
- .post_select = exec_post_select,
- },
- };
- struct status_task status_task = {
- .task = {
- .status = "status",
- .pre_select = status_pre_select,
- .post_select = status_post_select,
- },
- .fd = -1
- };
- struct input_task input_task = {
- .task = {
- .status = "input",
- .pre_select = input_pre_select,
- .post_select = input_post_select,
- },
- };
- struct signal_task signal_task = {
- .task = {
- .status = "signal",
- .pre_select = signal_pre_select,
- .post_select = signal_post_select,
- },
- };
- signal_task.fd = para_signal_init();
+
+ exec_task.task = task_register(&(struct task_info) {
+ .name = "exec",
+ .pre_select = exec_pre_select,
+ .post_select = exec_post_select,
+ .context = &exec_task,
+ }, &sched);
+
+ status_task.task = task_register(&(struct task_info) {
+ .name = "status",
+ .pre_select = status_pre_select,
+ .post_select = status_post_select,
+ .context = &status_task,
+ }, &sched);
+
+ input_task.task = task_register(&(struct task_info) {
+ .name = "input",
+ .pre_select = input_pre_select,
+ .post_select = input_post_select,
+ .context = &input_task,
+ }, &sched);
+
+ signal_task = signal_init_or_die();
para_install_sighandler(SIGINT);
para_install_sighandler(SIGTERM);
para_install_sighandler(SIGCHLD);
- para_install_sighandler(SIGWINCH);
para_install_sighandler(SIGUSR1);
-
- register_task(&sched, &exec_task.task);
- register_task(&sched, &status_task.task);
- register_task(&sched, &input_task.task);
- register_task(&sched, &signal_task.task);
- return schedule(&sched);
+ signal_task->task = task_register(&(struct task_info) {
+ .name = "signal",
+ .pre_select = signal_pre_select,
+ .post_select = signal_post_select,
+ .context = signal_task,
+ }, &sched);
+ ret = schedule(&sched);
+ sched_shutdown(&sched);
+ signal_shutdown(signal_task);
+ return ret;
}
+/**
+ * The main function of para_gui.
+ *
+ * \param argc Usual argument count.
+ * \param argv Usual argument vector.
+ *
+ * After initialization para_gui registers the following tasks to the paraslash
+ * scheduler: status, exec, signal, input.
+ *
+ * The status task executes the para_audioc stat command to obtain the status
+ * of para_server and para_audiod, and displays this information in the top
+ * window of para_gui.
+ *
+ * The exec task is responsible for printing the output of the currently
+ * running executable to the bottom window.
+ *
+ * The signal task performs suitable actions according to any signals received.
+ * For example it refreshes all windows on terminal size changes and resets the
+ * terminal on \p SIGTERM.
+ *
+ * The input task reads single key strokes from stdin. For each key pressed, it
+ * executes the command handler associated with this key.
+ *
+ * \return \p EXIT_SUCCESS or \p EXIT_FAILURE.
+ */
int main(int argc, char *argv[])
{
gui_cmdline_parser(argc, argv, &conf); /* exits on errors */
projects / paraslash.git / blobdiff