/src/tmux/status.c

Source
/* $OpenBSD: status.c,v 1.275 2026/10/16 07:59:06 nicm Exp $ */

/*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/time.h>

#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "tmux.h"

static void  status_message_area(struct client *, u_int *, u_int *);
static void  status_message_callback(int, short, void *);
static void  status_timer_callback(int, short, void *);

/* Status timer callback. */
static void
status_timer_callback(__unused int fd, __unused short events, void *arg)
{
  struct client *c = arg;
  struct session  *s = c->session;
  struct timeval   tv;

  evtimer_del(&c->status.timer);

  if (s == NULL)
    return;

  if (c->message_string == NULL && c->prompt == NULL)
    c->flags |= CLIENT_REDRAWSTATUS;

  timerclear(&tv);
  tv.tv_sec = options_get_number(s->options, "status-interval");

  if (tv.tv_sec != 0)
    evtimer_add(&c->status.timer, &tv);
  log_debug("client %p, status interval %d", c, (int)tv.tv_sec);
}

/* Start status timer for client. */
void
status_timer_start(struct client *c)
{
  struct session  *s = c->session;

  if (event_initialized(&c->status.timer))
    evtimer_del(&c->status.timer);
  else
    evtimer_set(&c->status.timer, status_timer_callback, c);

  if (s != NULL &&
      (options_get_number(s->options, "status") ||
      options_get_number(s->options, "side-status")))
    status_timer_callback(-1, 0, c);
}

/* Start status timer for all clients. */
void
status_timer_start_all(void)
{
  struct client *c;

  TAILQ_FOREACH(c, &clients, entry)
    status_timer_start(c);
}

/* Update status cache. */
void
status_update_cache(struct session *s)
{
  struct options  *oo = s->options;

  s->statuslines = options_get_number(oo, "status");
  if (s->statuslines == 0)
    s->statusat = -1;
  else if (options_get_number(oo, "status-position") == 0)
    s->statusat = 0;
  else
    s->statusat = 1;

  switch (options_get_number(oo, "side-status")) {
  case 1:
    s->sidestatusat = 0;
    break;
  case 2:
    s->sidestatusat = 1;
    break;
  default:
    s->sidestatusat = -1;
    break;
  }
  s->sidestatuswidth = options_get_number(oo, "side-status-width");
}

/* Get screen line of status line. -1 means off. */
int
status_at_line(struct client *c)
{
  struct session  *s = c->session;

  if (c->flags & (CLIENT_STATUSOFF|CLIENT_CONTROL))
    return (-1);
  if (s->statusat != 1)
    return (s->statusat);
  return (c->tty.sy - status_line_size(c));
}

/* Get size of status line for client's session. 0 means off. */
u_int
status_line_size(struct client *c)
{
  struct session  *s = c->session;

  if (c->flags & (CLIENT_STATUSOFF|CLIENT_CONTROL))
    return (0);
  if (s == NULL)
    return (options_get_number(global_s_options, "status"));
  return (s->statuslines);
}

/* Get width of side status line for client's session. 0 means off. */
u_int
status_side_size(struct client *c)
{
  struct session  *s = c->session;

  if (c->flags & (CLIENT_SIDESTATUSOFF|CLIENT_CONTROL))
    return (0);
  if (s == NULL || s->sidestatusat == -1)
    return (0);
  return (s->sidestatuswidth);
}

/* Get starting column of side status line. -1 means off. */
int
status_side_at_column(struct client *c)
{
  struct session  *s = c->session;
  u_int    width = status_side_size(c);

  if (width == 0)
    return (-1);
  if (s->sidestatusat == 0)
    return (0);
  return (c->tty.sx - width);
}

/* Get number of rows of side status line for client. */
u_int
status_side_rows(struct client *c)
{
  u_int lines = status_line_size(c);

  if (status_side_size(c) == 0 || c->tty.sy <= lines)
    return (0);
  return (c->tty.sy - lines);
}

/* Get the prompt line number for client's session. 1 means at the bottom. */
u_int
status_prompt_line_at(struct client *c)
{
  struct session  *s = c->session;
  u_int    line, lines;

  lines = status_line_size(c);
  if (lines == 0)
    return (0);
  line = options_get_number(s->options, "message-line");
  if (line >= lines)
    return (lines - 1);
  return (line);
}

/* Get window at window list position. */
struct style_range *
status_get_range(struct client *c, u_int x, u_int y)
{
  struct status_line  *sl = &c->status;

  if (y >= nitems(sl->entries))
    return (NULL);
  return (style_ranges_get_range(&sl->entries[y].ranges, x));
}

/* Save old status line. */
static void
status_push_screen(struct client *c)
{
  struct status_line *sl = &c->status;

  if (sl->active == &sl->screen) {
    sl->active = xmalloc(sizeof *sl->active);
    screen_init(sl->active, c->tty.sx, status_line_size(c), 0);
  }
  sl->references++;
}

/* Restore old status line. */
static void
status_pop_screen(struct client *c)
{
  struct status_line *sl = &c->status;

  if (--sl->references == 0) {
    screen_free(sl->active);
    free(sl->active);
    sl->active = &sl->screen;
  }
}

/* Initialize status line. */
void
status_init(struct client *c)
{
  struct status_line  *sl = &c->status;
  u_int      i;

  for (i = 0; i < nitems(sl->entries); i++)
    style_ranges_init(&sl->entries[i].ranges);

  screen_init(&sl->screen, c->tty.sx, 1, 0);
  sl->active = &sl->screen;
}

/* Free status line. */
void
status_free(struct client *c)
{
  struct status_line  *sl = &c->status;
  u_int      i;

  for (i = 0; i < nitems(sl->entries); i++) {
    style_ranges_free(&sl->entries[i].ranges);
    free((void *)sl->entries[i].expanded);
  }

  if (event_initialized(&sl->timer))
    evtimer_del(&sl->timer);

  if (sl->active != &sl->screen) {
    screen_free(sl->active);
    free(sl->active);
  }
  screen_free(&sl->screen);
}

/* Draw status line for client. */
int
status_redraw(struct client *c)
{
  struct status_line    *sl = &c->status;
  struct style_line_entry   *sle;
  struct session      *s = c->session;
  struct screen_write_ctx    ctx;
  struct grid_cell     gc;
  u_int        lines, i, n, width = c->tty.sx;
  int        flags, force = 0, changed = 0, fg, bg;
  struct options_entry    *o;
  union options_value   *ov;
  struct format_tree    *ft;
  char        *expanded;

  log_debug("%s enter", __func__);

  /* Shouldn't get here if not the active screen. */
  if (sl->active != &sl->screen)
    fatalx("not the active screen");

  /* No status line? */
  lines = status_line_size(c);
  if (c->tty.sy == 0 || lines == 0)
    return (1);

  /* Create format tree. */
  flags = FORMAT_STATUS;
  if (c->flags & CLIENT_STATUSFORCE)
    flags |= FORMAT_FORCE;
  ft = format_create(c, NULL, FORMAT_NONE, flags);
  format_defaults(ft, c, NULL, NULL, NULL);

  /* Set up default colour. */
  style_apply(&gc, s->options, "status-style", ft);
  fg = options_get_number(s->options, "status-fg");
  if (!COLOUR_DEFAULT(fg))
    gc.fg = fg;
  bg = options_get_number(s->options, "status-bg");
  if (!COLOUR_DEFAULT(bg))
    gc.bg = bg;
  if (!grid_cells_equal(&gc, &sl->style)) {
    force = 1;
    memcpy(&sl->style, &gc, sizeof sl->style);
  }

  /* Resize the target screen. */
  if (screen_size_x(&sl->screen) != width ||
      screen_size_y(&sl->screen) != lines) {
    screen_resize(&sl->screen, width, lines, 0);
    changed = force = 1;
  }
  screen_write_start(&ctx, &sl->screen);

  /* Write the status lines. */
  o = options_get(s->options, "status-format");
  if (o == NULL) {
    for (n = 0; n < width * lines; n++)
      screen_write_putc(&ctx, &gc, ' ');
  } else {
    for (i = 0; i < lines; i++) {
      screen_write_cursormove(&ctx, 0, i, 0);

      ov = options_array_getv(o, "%u", i);
      if (ov == NULL) {
        for (n = 0; n < width; n++)
          screen_write_putc(&ctx, &gc, ' ');
        continue;
      }
      sle = &sl->entries[i];

      expanded = format_expand_time(ft, ov->string);
      if (!force &&
          sle->expanded != NULL &&
          strcmp(expanded, sle->expanded) == 0) {
        free(expanded);
        continue;
      }
      changed = 1;

      for (n = 0; n < width; n++)
        screen_write_putc(&ctx, &gc, ' ');
      screen_write_cursormove(&ctx, 0, i, 0);

      style_ranges_free(&sle->ranges);
      format_draw(&ctx, &gc, width, expanded, &sle->ranges,
          0);

      free(sle->expanded);
      sle->expanded = expanded;
    }
  }
  screen_write_stop(&ctx);

  /* Free the format tree. */
  format_free(ft);

  /* Return if the status line has changed. */
  log_debug("%s exit: force=%d, changed=%d", __func__, force, changed);
  return (force || changed);
}

/* Prepare side status line. */
void
status_side_init(struct client *c)
{
  struct side_status_line *ss = &c->side_status;

  screen_init(&ss->screen, 1, 1, 0);
  ss->linex = -1;
  style_ranges_init(&ss->ranges);
}

/* Free side status line. */
void
status_side_free(struct client *c)
{
  struct side_status_line *ss = &c->side_status;

  style_ranges_free(&ss->ranges);
  free(ss->expanded);
  screen_free(&ss->screen);
}

/*
 * Get the column of the ACS line separating the side status line from the
 * window area, or -1 if there is none. The line takes the edge column
 * nearest the window area out of the side status width.
 */
static int
status_side_line_at(struct client *c)
{
  struct session  *s = c->session;
  u_int    width = status_side_size(c);

  if (width < 2)
    return (-1);
  if (s->sidestatusat == 0)
    return (width - 1);
  return (0);
}

/* Get side status range for position. */
struct style_range *
status_side_get_range(struct client *c, u_int x, u_int y)
{
  struct side_status_line *ss = &c->side_status;

  /* On a right side status line, content starts after the line. */
  if (status_side_line_at(c) == 0) {
    if (x == 0)
      return (NULL);
    x--;
  }
  return (style_ranges_get_range_at(&ss->ranges, x, y));
}

/* Draw side status line for client. Returns 1 if changed. */
int
status_side_redraw(struct client *c)
{
  struct side_status_line   *ss = &c->side_status;
  struct session      *s = c->session;
  struct screen_write_ctx    ctx;
  struct grid_cell     gc, lgc;
  struct format_tree    *ft;
  char        *expanded;
  u_int        width, rows, n;
  int        flags, force = 0, linex;

  log_debug("%s enter", __func__);

  /* No side status line? */
  width = status_side_size(c);
  rows = status_side_rows(c);
  if (width == 0 || rows == 0)
    return (0);

  /* Create format tree. */
  flags = FORMAT_STATUS;
  if (c->flags & CLIENT_STATUSFORCE)
    flags |= FORMAT_FORCE;
  ft = format_create(c, NULL, FORMAT_NONE, flags);
  format_defaults(ft, c, NULL, NULL, NULL);

  /* Set up default colour. */
  style_apply(&gc, s->options, "side-status-style", ft);
  if (!grid_cells_equal(&gc, &ss->style)) {
    force = 1;
    memcpy(&ss->style, &gc, sizeof ss->style);
  }

  /* Resize the target screen. */
  if (screen_size_x(&ss->screen) != width ||
      screen_size_y(&ss->screen) != rows) {
    screen_resize(&ss->screen, width, rows, 0);
    force = 1;
  }

  /* The line moves if the side status line changes side. */
  linex = status_side_line_at(c);
  if (linex != ss->linex) {
    force = 1;
    ss->linex = linex;
  }

  /* Expand the format. */
  expanded = format_expand_time(ft,
      options_get_string(s->options, "side-status-format"));
  format_free(ft);

  /* Skip the redraw if nothing has changed. */
  if (!force &&
      ss->expanded != NULL &&
      strcmp(expanded, ss->expanded) == 0) {
    free(expanded);
    log_debug("%s exit: unchanged", __func__);
    return (0);
  }

  /* Draw the rows over a blank background. */
  screen_write_start(&ctx, &ss->screen);
  screen_write_cursormove(&ctx, 0, 0, 0);
  for (n = 0; n < width * rows; n++)
    screen_write_putc(&ctx, &gc, ' ');
  style_ranges_free(&ss->ranges);

  /* Draw the line on the edge next to the window area. */
  if (linex != -1) {
    memcpy(&lgc, &gc, sizeof lgc);
    lgc.attr |= GRID_ATTR_CHARSET;
    for (n = 0; n < rows; n++) {
      screen_write_cursormove(&ctx, linex, n, 0);
      screen_write_putc(&ctx, &lgc, 'x');
    }
    width--;
  }

  screen_write_cursormove(&ctx, 0, 0, 0);
  format_draw_lines(&ctx, &gc, linex == 0 ? 1 : 0, width, rows, expanded,
      &ss->ranges, 0);
  screen_write_stop(&ctx);

  free(ss->expanded);
  ss->expanded = expanded;

  log_debug("%s exit: changed", __func__);
  return (1);
}

/* Escape # characters in a string so format_draw treats them as literal. */
static char *
status_message_escape(const char *s)
{
  const char  *cp;
  char    *out, *p;
  size_t     n = 0;

  for (cp = s; *cp != '\0'; cp++) {
    if (*cp == '#')
      n++;
  }
  p = out = xmalloc(strlen(s) + n + 1);
  for (cp = s; *cp != '\0'; cp++) {
    if (*cp == '#')
      *p++ = '#';
    *p++ = *cp;
  }
  *p = '\0';
  return (out);
}

/* Set a status line message. */
void
status_message_set(struct client *c, int delay, int ignore_styles,
    int ignore_keys, int no_freeze, const char *fmt, ...)
{
  struct timeval   tv;
  va_list    ap;
  char    *s;

  va_start(ap, fmt);
  xvasprintf(&s, fmt, ap);
  va_end(ap);

  log_debug("%s: %s", __func__, s);

  if (c == NULL) {
    server_add_message("message: %s", s);
    free(s);
    return;
  }

  status_message_clear(c);
  status_push_screen(c);
  c->message_string = s;
  server_add_message("%s message: %s", c->name, s);

  /*
   * With delay -1, the display-time option is used; zero means wait for
   * key press; more than zero is the actual delay time in milliseconds.
   */
  if (delay == -1)
    delay = options_get_number(c->session->options, "display-time");
  if (delay > 0) {
    tv.tv_sec = delay / 1000;
    tv.tv_usec = (delay % 1000) * 1000L;

    if (event_initialized(&c->message_timer))
      evtimer_del(&c->message_timer);
    evtimer_set(&c->message_timer, status_message_callback, c);

    evtimer_add(&c->message_timer, &tv);
  }

  if (delay != 0)
    c->message_ignore_keys = ignore_keys;
  c->message_ignore_styles = ignore_styles;

  if (!no_freeze)
    c->tty.flags |= TTY_FREEZE;
  c->tty.flags |= TTY_NOCURSOR;
  c->flags |= CLIENT_REDRAWSTATUS;
}

/* Clear status line message. */
void
status_message_clear(struct client *c)
{
  if (c->message_string == NULL)
    return;

  free(c->message_string);
  c->message_string = NULL;

  if (c->prompt == NULL)
    c->tty.flags &= ~(TTY_NOCURSOR|TTY_FREEZE);
  c->flags |= CLIENT_ALLREDRAWFLAGS; /* was frozen and may have changed */

  status_pop_screen(c);
}

/*
 * Calculate prompt/message area geometry from the style's width and align
 * directives: x offset and available width within the status line.
 */
static void
status_message_area(struct client *c, u_int *area_x, u_int *area_w)
{
  struct session    *s = c->session;
  struct style    *sy;
  u_int      w;

  /* Get width from message-style's width directive. */
  sy = options_string_to_style(s->options, "message-style", NULL);
  if (sy != NULL && sy->width >= 0) {
    if (sy->width_percentage)
      w = (c->tty.sx * (u_int)sy->width) / 100;
    else
      w = (u_int)sy->width;
  } else
    w = c->tty.sx;
  if (w == 0 || w > c->tty.sx)
    w = c->tty.sx;

  /* Get horizontal position from message-style's align directive. */
  if (sy != NULL) {
    switch (sy->align) {
    case STYLE_ALIGN_CENTRE:
    case STYLE_ALIGN_ABSOLUTE_CENTRE:
      *area_x = (c->tty.sx - w) / 2;
      break;
    case STYLE_ALIGN_RIGHT:
      *area_x = c->tty.sx - w;
      break;
    default:
      *area_x = 0;
      break;
    }
  } else
    *area_x = 0;

  *area_w = w;
}

/* Clear status line message after timer expires. */
static void
status_message_callback(__unused int fd, __unused short event, void *data)
{
  struct client *c = data;

  status_message_clear(c);
}

/* Draw client message on status line of present else on last line. */
int
status_message_redraw(struct client *c)
{
  struct status_line  *sl = &c->status;
  struct screen_write_ctx  ctx;
  struct session    *s = c->session;
  struct screen    old_screen;
  u_int      lines, messageline;
  u_int      ax, aw;
  struct grid_cell   gc;
  struct format_tree  *ft;
  const char    *msgfmt;
  char      *expanded, *msg;

  if (c->tty.sx == 0 || c->tty.sy == 0)
    return (0);
  memcpy(&old_screen, sl->active, sizeof old_screen);

  lines = status_line_size(c);
  if (lines <= 1)
    lines = 1;
  screen_init(sl->active, c->tty.sx, lines, 0);

  messageline = status_prompt_line_at(c);
  if (messageline > lines - 1)
    messageline = lines - 1;

  status_message_area(c, &ax, &aw);

  ft = format_create_defaults(NULL, c, NULL, NULL, NULL);
  style_apply(&gc, s->options, "message-style", ft);

  /*
   * Set #{message} in the format tree. If styles should be ignored in
   * the message content, escape # characters so format_draw treats them
   * as literal text.
   */
  if (c->message_ignore_styles) {
    msg = status_message_escape(c->message_string);
    format_add(ft, "message", "%s", msg);
    free(msg);
  } else
    format_add(ft, "message", "%s", c->message_string);
  format_add(ft, "command_prompt", "%d", 0);

  msgfmt = options_get_string(s->options, "message-format");
  expanded = format_expand_time(ft, msgfmt);
  format_free(ft);

  screen_write_start(&ctx, sl->active);
  screen_write_fast_copy(&ctx, &sl->screen, 0, 0, c->tty.sx, lines);
  screen_write_cursormove(&ctx, ax, messageline, 0);
  format_draw(&ctx, &gc, aw, expanded, NULL, 0);
  screen_write_stop(&ctx);

  free(expanded);

  if (grid_compare(sl->active->grid, old_screen.grid) == 0) {
    screen_free(&old_screen);
    return (0);
  }
  screen_free(&old_screen);
  return (1);
}


struct status_prompt_data {
  struct client   *c;
  status_prompt_input_cb   inputcb;
  prompt_free_cb     freecb;
  void      *data;
};

static enum prompt_result
status_prompt_input_callback(void *data, const char *s,
    enum prompt_key_result key)
{
  struct status_prompt_data *spd = data;
  struct client     *c = spd->c;
  status_prompt_input_cb     inputcb = spd->inputcb;
  void        *arg = spd->data;

  if (inputcb != NULL)
    return (inputcb(c, arg, s, key));
  return (PROMPT_CLOSE);
}

static void
status_prompt_free_callback(void *data)
{
  struct status_prompt_data *spd = data;
  prompt_free_cb       freecb = spd->freecb;
  void        *arg = spd->data;

  if (freecb != NULL)
    freecb(arg);
  free(spd);
}

/* Accept prompt immediately. */
static enum cmd_retval
status_prompt_accept(__unused struct cmdq_item *item, void *data)
{
  struct client *c = data;

  if (c->prompt != NULL)
    status_prompt_key(c, 'y', NULL);
  return (CMD_RETURN_NORMAL);
}

/* Enable status line prompt. */
void
status_prompt_set(struct client *c, struct cmd_find_state *fs,
    const char *msg, const char *input, status_prompt_input_cb inputcb,
    prompt_free_cb freecb, void *data, int flags, enum prompt_type prompt_type)
{
  struct prompt_create_data pd;
  struct status_prompt_data *spd;

  status_message_clear(c);
  status_prompt_clear(c);
  status_push_screen(c);

  spd = xcalloc(1, sizeof *spd);
  spd->c = c;
  spd->inputcb = inputcb;
  spd->freecb = freecb;
  spd->data = data;

  memset(&pd, 0, sizeof pd);
  prompt_set_options(&pd, c->session);
  pd.fs = fs;
  pd.prompt = msg;
  pd.input = input;
  pd.type = prompt_type;
  pd.flags = flags;
  pd.inputcb = status_prompt_input_callback;
  pd.freecb = status_prompt_free_callback;
  pd.data = spd;
  c->prompt = prompt_create(&pd);

  if ((~flags & PROMPT_INCREMENTAL) && (~flags & PROMPT_NOFREEZE))
    c->tty.flags |= TTY_FREEZE;
  c->flags |= CLIENT_REDRAWSTATUS;

  prompt_incremental_start(c->prompt);

  if ((flags & PROMPT_SINGLE) && (flags & PROMPT_ACCEPT))
    cmdq_append(c, cmdq_get_callback(status_prompt_accept, c));
}

/* Remove status line prompt. */
void
status_prompt_clear(struct client *c)
{
  if (c->prompt == NULL)
    return;

  prompt_free(c->prompt);
  c->prompt = NULL;

  c->tty.flags &= ~(TTY_NOCURSOR|TTY_FREEZE);
  c->flags |= CLIENT_ALLREDRAWFLAGS; /* was frozen and may have changed */

  status_pop_screen(c);
}

/* Update status line prompt with a new prompt string. */
void
status_prompt_update(struct client *c, const char *msg, const char *input)
{
  if (c->prompt == NULL)
    return;
  prompt_update(c->prompt, msg, input);
  c->flags |= CLIENT_REDRAWSTATUS;
}

/* Get the screen line on which the prompt is drawn. */
static u_int
status_prompt_screen_line(struct client *c)
{
  struct tty  *tty = &c->tty;
  u_int    n;

  if (options_get_number(c->session->options, "status-position") == 0)
    return (status_prompt_line_at(c));
  n = status_line_size(c) - status_prompt_line_at(c);
  if (n <= tty->sy)
    return (tty->sy - n);
  return (tty->sy - 1);
}

/* Draw client prompt on status line of present else on last line. */
int
status_prompt_redraw(struct client *c)
{
  struct status_line  *sl = &c->status;
  struct screen_write_ctx  ctx;
  struct screen    old_screen;
  struct prompt_draw_data  pdd;
  u_int      lines, ax, aw, promptline;

  if (c->tty.sx == 0 || c->tty.sy == 0)
    return (0);
  memcpy(&old_screen, sl->active, sizeof old_screen);

  lines = status_line_size(c);
  if (lines <= 1)
    lines = 1;
  screen_init(sl->active, c->tty.sx, lines, 0);

  promptline = status_prompt_line_at(c);
  if (promptline > lines - 1)
    promptline = lines - 1;

  status_message_area(c, &ax, &aw);

  screen_write_start(&ctx, sl->active);
  screen_write_fast_copy(&ctx, &sl->screen, 0, 0, c->tty.sx, lines);

  pdd.ctx = &ctx;
  pdd.area_x = ax;
  pdd.area_width = aw;
  pdd.prompt_line = promptline;
  pdd.cursor_x = &sl->prompt_cx;
  prompt_draw(c->prompt, &pdd);

  screen_write_stop(&ctx);

  if (grid_compare(sl->active->grid, old_screen.grid) == 0) {
    screen_free(&old_screen);
    return (0);
  }
  screen_free(&old_screen);
  return (1);
}

/* Work out the tty cursor position for the prompt. */
void
status_prompt_cursor(struct client *c, u_int *cx, u_int *cy)
{
  *cy = status_prompt_screen_line(c);
  *cx = c->status.prompt_cx;
}

/* Handle keys in prompt. */
enum prompt_key_result
status_prompt_key(struct client *c, key_code key, struct mouse_event *m)
{
  enum prompt_key_result  result;
  u_int     ax, aw;
  int     redraw = 0;

  if (KEYC_IS_MOUSE(key)) {
    if (m == NULL || MOUSE_BUTTONS(m->b) != MOUSE_BUTTON_1 ||
        MOUSE_DRAG(m->b) || MOUSE_RELEASE(m->b) ||
        m->y != status_prompt_screen_line(c))
      return (PROMPT_KEY_NOT_HANDLED);
    status_message_area(c, &ax, &aw);
    result = prompt_mouse(c->prompt, m->x, ax, aw, &redraw);
  } else
    result = prompt_key(c->prompt, key, &redraw);
  if (redraw && c->prompt != NULL)
    c->flags |= CLIENT_REDRAWSTATUS;
  if (c->prompt != NULL && prompt_closed(c->prompt))
    status_prompt_clear(c);
  return (result);
}

Coverage Report

Created: 2026-10-17 06:19