/* $OpenBSD: window-copy.c,v 1.421 2026/07/14 17:17:18 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 <ctype.h>

#include <regex.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include "tmux.h"

struct window_copy_mode_data;

static const char *window_copy_key_table(struct window_mode_entry *);

static void window_copy_command(struct window_mode_entry *, struct client *,

        struct session *, struct winlink *, struct args *,

        struct mouse_event *);

static struct screen *window_copy_init(struct window_mode_entry *,

        struct cmdq_item *, struct cmd_find_state *, struct args *);

static struct screen *window_copy_view_init(struct window_mode_entry *,

        struct cmdq_item *, struct cmd_find_state *, struct args *);

static void window_copy_free(struct window_mode_entry *);

static void window_copy_resize(struct window_mode_entry *, u_int, u_int);

static void window_copy_formats(struct window_mode_entry *,

        struct format_tree *);

static struct screen *window_copy_get_screen(struct window_mode_entry *);

static void window_copy_scroll1(struct window_mode_entry *,

        struct window_pane *, int, u_int, u_int, int);

static void window_copy_pageup1(struct window_mode_entry *, int);

static int  window_copy_pagedown1(struct window_mode_entry *, int, int);

static void window_copy_next_paragraph(struct window_mode_entry *);

static void window_copy_previous_paragraph(struct window_mode_entry *);

static void window_copy_redraw_selection(struct window_mode_entry *, u_int);

static void window_copy_redraw_lines(struct window_mode_entry *, u_int,

        u_int);

static void window_copy_redraw_screen(struct window_mode_entry *);

static void window_copy_do_refresh(struct window_mode_entry *, int);

static void window_copy_refresh_timer(int, short, void *);

static void window_copy_refresh_arm(struct window_mode_entry *);

static void window_copy_refresh_start(struct window_mode_entry *);

static void window_copy_refresh_stop(struct window_mode_entry *);

static void window_copy_style_changed(struct window_mode_entry *);

static void window_copy_set_line_numbers1(struct window_mode_entry *, int,

        int);

static int  window_copy_line_number_mode(struct window_mode_entry *);

static int  window_copy_line_number_is_absolute(struct window_mode_entry *);

static int  window_copy_line_numbers_active(struct window_mode_entry *);

static u_int  window_copy_line_number_width(struct window_mode_entry *);

static u_int  window_copy_cursor_offset(struct window_mode_entry *, u_int,

        u_int);

static u_int  window_copy_cursor_unoffset(struct window_mode_entry *, u_int,

        u_int);

static void window_copy_write_line(struct window_mode_entry *,

        struct screen_write_ctx *, u_int);

static void window_copy_write_lines(struct window_mode_entry *,

        struct screen_write_ctx *, u_int, u_int);

static char    *window_copy_match_at_cursor(struct window_copy_mode_data *);

static void window_copy_scroll_to(struct window_mode_entry *, u_int, u_int,

        int);

static int  window_copy_search_compare(struct grid *, u_int, u_int,

        struct grid *, u_int, int);

static int  window_copy_search_lr(struct grid *, struct grid *, u_int *,

        u_int, u_int, u_int, int);

static int  window_copy_search_rl(struct grid *, struct grid *, u_int *,

        u_int, u_int, u_int, int);

static int  window_copy_last_regex(struct grid *, u_int, u_int, u_int,

        u_int, u_int *, u_int *, const char *, const regex_t *,

        int);

static int  window_copy_search_mark_at(struct window_copy_mode_data *,

        u_int, u_int, u_int *);

static char    *window_copy_stringify(struct grid *, u_int, u_int, u_int,

        char *, u_int *);

static void window_copy_cstrtocellpos(struct grid *, u_int, u_int *,

        u_int *, const char *);

static int  window_copy_search_marks(struct window_mode_entry *,

        struct screen *, int, int);

static void window_copy_clear_marks(struct window_mode_entry *);

static int  window_copy_is_lowercase(const char *);

static void window_copy_search_back_overlap(struct grid *, regex_t *,

        u_int *, u_int *, u_int *, u_int);

static int  window_copy_search_jump(struct window_mode_entry *,

        struct grid *, struct grid *, u_int, u_int, u_int, int, int,

        int, int);

static int  window_copy_search(struct window_mode_entry *, int, int);

static int  window_copy_search_up(struct window_mode_entry *, int);

static int  window_copy_search_down(struct window_mode_entry *, int);

static void window_copy_goto_line(struct window_mode_entry *, const char *);

static void window_copy_update_cursor(struct window_mode_entry *, u_int,

        u_int);

static void window_copy_start_selection(struct window_mode_entry *);

static int  window_copy_mouse_in_selection(struct window_mode_entry *,

        u_int, u_int, int *, int *);

static int  window_copy_adjust_selection(struct window_mode_entry *,

        u_int *, u_int *);

static int  window_copy_update_selection_view(struct window_mode_entry *,

        int, int);

static int  window_copy_set_selection(struct window_mode_entry *, int, int);

static int  window_copy_update_selection(struct window_mode_entry *, int,

        int);

static void window_copy_synchronize_cursor(struct window_mode_entry *, int);

static void    *window_copy_get_selection(struct window_mode_entry *, size_t *);

static void window_copy_copy_buffer(struct window_mode_entry *,

        const char *, void *, size_t, int, int);

static void window_copy_pipe(struct window_mode_entry *,

        struct session *, const char *);

static void window_copy_copy_pipe(struct window_mode_entry *,

        struct session *, const char *, const char *,

        int, int);

static void window_copy_copy_selection(struct window_mode_entry *,

        const char *, int, int);

static void window_copy_append_selection(struct window_mode_entry *);

static void window_copy_clear_selection(struct window_mode_entry *);

static void window_copy_copy_line(struct window_mode_entry *, char **,

        size_t *, u_int, u_int, u_int);

static int  window_copy_in_set(struct window_mode_entry *, u_int, u_int,

        const char *);

static u_int  window_copy_find_length(struct window_mode_entry *, u_int);

static u_int  window_copy_cursor_limit(struct window_mode_entry *, u_int,

        int);

static void window_copy_cursor_start_of_line(struct window_mode_entry *);

static void window_copy_cursor_back_to_indentation(

        struct window_mode_entry *);

static void window_copy_cursor_end_of_line(struct window_mode_entry *);

static void window_copy_other_end(struct window_mode_entry *);

static void window_copy_cursor_left(struct window_mode_entry *);

static void window_copy_cursor_right(struct window_mode_entry *, int);

static void window_copy_cursor_up(struct window_mode_entry *, int);

static void window_copy_cursor_down(struct window_mode_entry *, int);

static void window_copy_cursor_jump(struct window_mode_entry *);

static void window_copy_cursor_jump_back(struct window_mode_entry *);

static void window_copy_cursor_jump_to(struct window_mode_entry *);

static void window_copy_cursor_jump_to_back(struct window_mode_entry *);

static void window_copy_cursor_next_word(struct window_mode_entry *,

        const char *);

static void window_copy_cursor_next_word_end_pos(struct window_mode_entry *,

        const char *, u_int *, u_int *);

static void window_copy_cursor_next_word_end(struct window_mode_entry *,

        const char *, int);

static void window_copy_cursor_previous_word_pos(struct window_mode_entry *,

        const char *, u_int *, u_int *);

static void window_copy_cursor_previous_word(struct window_mode_entry *,

        const char *, int);

static void window_copy_cursor_prompt(struct window_mode_entry *, int,

        int);

static void window_copy_scroll_up(struct window_mode_entry *, u_int);

static void window_copy_scroll_down(struct window_mode_entry *, u_int);

static void window_copy_rectangle_set(struct window_mode_entry *, int);

static void window_copy_move_mouse(struct mouse_event *);

static void window_copy_drag_update(struct client *, struct mouse_event *);

static void window_copy_drag_release(struct client *, struct mouse_event *);

static void window_copy_jump_to_mark(struct window_mode_entry *);

static void window_copy_acquire_cursor_up(struct window_mode_entry *,

        u_int, u_int, u_int, u_int, u_int);

static void window_copy_acquire_cursor_down(struct window_mode_entry *,

        u_int, u_int, u_int, u_int, u_int, u_int, int);

static u_int  window_copy_clip_width(u_int, u_int, u_int, u_int);

static u_int  window_copy_search_mark_match(struct window_copy_mode_data *,

        u_int , u_int, u_int, int);

const struct window_mode window_copy_mode = {

  .name = "copy-mode",

  .init = window_copy_init,

  .free = window_copy_free,

  .resize = window_copy_resize,

  .style_changed = window_copy_style_changed,

  .key_table = window_copy_key_table,

  .command = window_copy_command,

  .formats = window_copy_formats,

  .get_screen = window_copy_get_screen

};

const struct window_mode window_view_mode = {

  .name = "view-mode",

  .init = window_copy_view_init,

  .free = window_copy_free,

  .resize = window_copy_resize,

  .style_changed = window_copy_style_changed,

  .key_table = window_copy_key_table,

  .command = window_copy_command,

  .formats = window_copy_formats,

  .get_screen = window_copy_get_screen

};

enum {

  WINDOW_COPY_OFF,

  WINDOW_COPY_SEARCHUP,

  WINDOW_COPY_SEARCHDOWN,

  WINDOW_COPY_JUMPFORWARD,

  WINDOW_COPY_JUMPBACKWARD,

  WINDOW_COPY_JUMPTOFORWARD,

  WINDOW_COPY_JUMPTOBACKWARD,

};

enum {

  WINDOW_COPY_REL_POS_ABOVE,

  WINDOW_COPY_REL_POS_ON_SCREEN,

  WINDOW_COPY_REL_POS_BELOW,

};

enum window_copy_cmd_action {

  WINDOW_COPY_CMD_NOTHING,

  WINDOW_COPY_CMD_MOVE,

  WINDOW_COPY_CMD_REDRAW,

  WINDOW_COPY_CMD_CANCEL,

};

enum window_copy_cmd_clear {

  WINDOW_COPY_CMD_CLEAR_ALWAYS,

  WINDOW_COPY_CMD_CLEAR_NEVER,

  WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,

};

enum window_copy_line_numbers {

  WINDOW_COPY_LINE_NUMBERS_OFF,

  WINDOW_COPY_LINE_NUMBERS_DEFAULT,

  WINDOW_COPY_LINE_NUMBERS_ABSOLUTE,

  WINDOW_COPY_LINE_NUMBERS_RELATIVE,

  WINDOW_COPY_LINE_NUMBERS_HYBRID,

};

struct window_copy_cmd_state {

  struct window_mode_entry  *wme;

  struct args     *args;

  struct args     *wargs;

  struct mouse_event    *m;

  struct client     *c;

  struct session      *s;

  struct winlink      *wl;

};

/*

 * Copy mode's visible screen (the "screen" field) is filled from one of two

 * sources: the original contents of the pane (used when we actually enter via

 * the "copy-mode" command, to copy the contents of the current pane), or else

 * a series of lines containing the output from an output-writing tmux command

 * (such as any of the "show-*" or "list-*" commands).

 *

 * In either case, the full content of the copy-mode grid is pointed at by the

 * "backing" field, and is copied into "screen" as needed (that is, when

 * scrolling occurs). When copy-mode is backed by a pane, backing points

 * directly at that pane's screen structure (&wp->base); when backed by a list

 * of output-lines from a command, it points at a newly-allocated screen

 * structure (which is deallocated when the mode ends).

 */

struct window_copy_mode_data {

  struct screen  screen;

  struct screen *backing;

  int    backing_written; /* backing display started */

  struct input_ctx *ictx;

  u_int    sync_added;  /* snapshot of backing grid counters */

  u_int    sync_collected;

  u_int    sync_generation;

  int    viewmode;  /* view mode entered */

  u_int    oy;    /* number of lines scrolled up */

  u_int    selx;    /* beginning of selection */

  u_int    sely;

  u_int    endselx; /* end of selection */

  u_int    endsely;

  enum {

    CURSORDRAG_NONE,  /* selection is independent of cursor */

    CURSORDRAG_ENDSEL,  /* end is synchronized with cursor */

    CURSORDRAG_SEL,   /* start is synchronized with cursor */

  } cursordrag;

  int    modekeys;

  enum {

    LINE_SEL_NONE,

    LINE_SEL_LEFT_RIGHT,

    LINE_SEL_RIGHT_LEFT,

  } lineflag;     /* line selection mode */

  int    rectflag;  /* in rectangle copy mode? */

  int    scroll_exit; /* exit on scroll to end? */

  int    hide_position; /* hide position marker */

  int    line_numbers;  /* 0 off, 1 from option, 2 default */

  enum {

    SEL_CHAR,   /* select one char at a time */

    SEL_WORD,   /* select one word at a time */

    SEL_LINE,   /* select one line at a time */

  } selflag;

  enum {

    RECENTRE_TOP,

    RECENTRE_MIDDLE,

    RECENTRE_BOTTOM,

  } recentre_state;

  u_int    recentre_line;

  const char  *separators;  /* word separators */

  u_int    dx;    /* drag start position */

  u_int    dy;

  u_int    selrx;   /* selection reset positions */

  u_int    selry;

  u_int    endselrx;

  u_int    endselry;

  u_int    cx;

  u_int    cy;

  u_int    lastcx;  /* position in last line w/ content */

  u_int    lastsx;  /* size of last line w/ content */

  u_int    mx;    /* mark position */

  u_int    my;

  int    showmark;

  int    searchtype;

  int    searchdirection;

  int    searchregex;

  char    *searchstr;

  u_char    *searchmark;

  int    searchcount;

  int    searchmore;

  int    searchall;

  int    searchx;

  int    searchy;

  int    searcho;

  u_char     searchgen;

  int    timeout; /* search has timed out */

#define WINDOW_COPY_SEARCH_TIMEOUT 10000

#define WINDOW_COPY_SEARCH_ALL_TIMEOUT 200

#define WINDOW_COPY_SEARCH_MAX_LINE 2000

  int      jumptype;

  struct utf8_data  *jumpchar;

  struct event   dragtimer;

#define WINDOW_COPY_DRAG_REPEAT_TIME 50000

  struct event   refresh_timer;

#define WINDOW_COPY_REFRESH_INTERVAL 50000

  int    refresh_active;

};

static void

window_copy_scroll_timer(__unused int fd, __unused short events, void *arg)

{

  struct window_mode_entry  *wme = arg;

  struct window_pane    *wp = wme->wp;

  struct window_copy_mode_data  *data = wme->data;

  struct timeval       tv = {

    .tv_usec = WINDOW_COPY_DRAG_REPEAT_TIME

  };

  evtimer_del(&data->dragtimer);

  if (TAILQ_FIRST(&wp->modes) != wme)

    return;

  if (data->cy == 0) {

    evtimer_add(&data->dragtimer, &tv);

    window_copy_cursor_up(wme, 1);

  } else if (data->cy == screen_size_y(&data->screen) - 1) {

    evtimer_add(&data->dragtimer, &tv);

    window_copy_cursor_down(wme, 1);

  }

}

static struct screen *

window_copy_clone_screen(struct screen *src, struct screen *hint, u_int *cx,

    u_int *cy, int trim)

{

  struct screen   *dst;

  const struct grid_line  *gl;

  u_int      sy, wx, wy;

  int      reflow;

  dst = xcalloc(1, sizeof *dst);

  sy = screen_hsize(src) + screen_size_y(src);

  if (trim) {

    while (sy > screen_hsize(src)) {

      gl = grid_peek_line(src->grid, sy - 1);

      if (gl == NULL || gl->cellused != 0)

        break;

      sy--;

    }

  }

  log_debug("%s: target screen is %ux%u, source %ux%u", __func__,

      screen_size_x(src), sy, screen_size_x(hint),

      screen_hsize(src) + screen_size_y(src));

  screen_init(dst, screen_size_x(src), sy, screen_hlimit(src));

  /*

   * Ensure history is on for the backing grid so lines are not deleted

   * during resizing.

   */

  dst->grid->flags |= GRID_HISTORY;

  grid_duplicate_lines(dst->grid, 0, src->grid, 0, sy);

  dst->grid->sy = sy - screen_hsize(src);

  dst->grid->hsize = screen_hsize(src);

  dst->grid->hscrolled = src->grid->hscrolled;

  if (src->cy > dst->grid->sy - 1) {

    dst->cx = 0;

    dst->cy = dst->grid->sy - 1;

  } else {

    dst->cx = src->cx;

    dst->cy = src->cy;

  }

  if (cx != NULL && cy != NULL) {

    *cx = dst->cx;

    *cy = screen_hsize(dst) + dst->cy;

    reflow = (screen_size_x(hint) != screen_size_x(dst));

  }

  else

    reflow = 0;

  if (reflow)

    grid_wrap_position(dst->grid, *cx, *cy, &wx, &wy);

  screen_resize_cursor(dst, screen_size_x(hint), screen_size_y(hint), 1,

      0, 0);

  if (reflow)

    grid_unwrap_position(dst->grid, cx, cy, wx, wy);

  return (dst);

}

/*

 * Snapshot the source grid's monotonic scroll counters so the next incremental

 * sync can tell how much history was added or collected since this point.

 */

static void

window_copy_sync_snapshot(struct window_copy_mode_data *data, struct grid *src)

{

  data->sync_added = src->scroll_added;

  data->sync_collected = src->scroll_collected;

  data->sync_generation = src->scroll_generation;

}

/*

 * Reconcile the backing screen with the live pane grid in place, copying only

 * the history that scrolled in or was collected since the last snapshot rather

 * than cloning the whole scrollback. The result is identical to a fresh

 * window_copy_clone_screen, so the caller repositions and redraws the same way

 * for both paths. Returns 1 on success, or 0 if the caller must fall back to a

 * full clone (different source pane, geometry or generation change, or counter

 * deltas that do not add up).

 */

static int

window_copy_sync_backing(struct window_mode_entry *wme)

{

  struct window_copy_mode_data  *data = wme->data;

  struct window_pane    *wp = wme->swp;

  struct screen     *src = &wp->base;

  struct screen     *dst = data->backing;

  struct grid     *sg = src->grid;

  struct grid     *dg = dst->grid;

  u_int        sy = sg->sy;

  u_int        old_hsize = dg->hsize;

  u_int        new_hsize = sg->hsize;

  u_int        added, collected, kept;

  /*

   * Only a pane's own live grid is tracked incrementally. A different

   * source pane (copy-mode -s) goes through clone_screen, which also

   * trims trailing blank lines that this path does not.

   */

  if (data->viewmode || wme->swp != wme->wp)

    return (0);

  /* Indices only line up at the same size and generation. */

  if (sg->sx != dg->sx || sg->sy != dg->sy ||

      sg->scroll_generation != data->sync_generation)

    return (0);

  added = sg->scroll_added - data->sync_added;

  collected = sg->scroll_collected - data->sync_collected;

  /*

   * Reject anything that does not balance: counter wrap, a history-limit

   * change that collected past the snapshot, or arithmetic that does not

   * reproduce the new history size.

   */

  if (added > (u_int)INT_MAX || collected > (u_int)INT_MAX ||

      collected > old_hsize || old_hsize + added < collected ||

      old_hsize + added - collected != new_hsize)

    return (0);

  kept = old_hsize - collected;

  if (added == 0 && collected == 0) {

    /* History is unchanged; only the viewport can have mutated. */

    grid_duplicate_lines(dg, dg->hsize, sg, sg->hsize, sy);

  } else {

    /* Drop the oldest lines and shift the rest down. */

    if (collected > 0) {

      grid_free_lines(dg, 0, collected);

      memmove(&dg->linedata[0], &dg->linedata[collected],

          (old_hsize + sy - collected) * sizeof *dg->linedata);

      memset(&dg->linedata[old_hsize + sy - collected], 0,

          collected * sizeof *dg->linedata);

    }

    /* Resize linedata to the new history plus viewport. */

    if (new_hsize + sy != old_hsize + sy - collected) {

      dg->linedata = xreallocarray(dg->linedata,

          new_hsize + sy, sizeof *dg->linedata);

      memset(&dg->linedata[old_hsize + sy - collected], 0,

          (new_hsize - kept) * sizeof *dg->linedata);

    }

    /*

     * Set hsize before copying so grid_duplicate_lines does not

     * clamp the count to the old, smaller grid size.

     */

    dg->hsize = new_hsize;

    /* Copy the newly scrolled history, then refresh the viewport. */

    if (added > 0)

      grid_duplicate_lines(dg, kept, sg, kept, added);

    grid_duplicate_lines(dg, new_hsize, sg, new_hsize, sy);

  }

  dg->hscrolled = sg->hscrolled;

  /* Match clone_screen's backing cursor placement. */

  if (src->cy > dg->sy - 1) {

    dst->cx = 0;

    dst->cy = dg->sy - 1;

  } else {

    dst->cx = src->cx;

    dst->cy = src->cy;

  }

  return (1);

}

static struct window_copy_mode_data *

window_copy_common_init(struct window_mode_entry *wme)

{

  struct window_pane    *wp = wme->wp;

  struct window_copy_mode_data  *data;

  struct screen     *base = &wp->base;

  wme->data = data = xcalloc(1, sizeof *data);

  data->cursordrag = CURSORDRAG_NONE;

  data->lineflag = LINE_SEL_NONE;

  data->selflag = SEL_CHAR;

  if (wp->searchstr != NULL) {

    data->searchtype = WINDOW_COPY_SEARCHUP;

    data->searchregex = wp->searchregex;

    data->searchstr = xstrdup(wp->searchstr);

  } else {

    data->searchtype = WINDOW_COPY_OFF;

    data->searchregex = 0;

    data->searchstr = NULL;

  }

  data->searchx = data->searchy = data->searcho = -1;

  data->searchall = 1;

  data->jumptype = WINDOW_COPY_OFF;

  data->jumpchar = NULL;

  data->line_numbers = 1;

  screen_init(&data->screen, screen_size_x(base), screen_size_y(base), 0);

  screen_set_default_cursor(&data->screen, global_w_options);

  data->modekeys = options_get_number(wp->window->options, "mode-keys");

  evtimer_set(&data->dragtimer, window_copy_scroll_timer, wme);

  evtimer_set(&data->refresh_timer, window_copy_refresh_timer, wme);

  return (data);

}

static struct screen *

window_copy_init(struct window_mode_entry *wme,

    __unused struct cmdq_item *item, __unused struct cmd_find_state *fs,

    struct args *args)

{

  struct window_pane    *wp = wme->swp;

  struct window_copy_mode_data  *data;

  struct screen     *base = &wp->base;

  struct screen_write_ctx    ctx;

  u_int        i, cx, cy;

  data = window_copy_common_init(wme);

  data->backing = window_copy_clone_screen(base, &data->screen, &cx, &cy,

      wme->swp != wme->wp);

  window_copy_sync_snapshot(data, base->grid);

  data->cx = cx;

  if (cy < screen_hsize(data->backing)) {

    data->cy = 0;

    data->oy = screen_hsize(data->backing) - cy;

  } else {

    data->cy = cy - screen_hsize(data->backing);

    data->oy = 0;

  }

  data->scroll_exit = args_has(args, 'e');

  data->hide_position = args_has(args, 'H');

  if (base->hyperlinks != NULL) {

    hyperlinks_free(data->screen.hyperlinks);

    data->screen.hyperlinks = hyperlinks_copy(base->hyperlinks);

  }

  data->screen.cx = window_copy_cursor_offset(wme, data->cx,

      screen_size_x(&data->screen));

  data->screen.cy = data->cy;

  data->mx = data->cx;

  data->my = screen_hsize(data->backing) + data->cy - data->oy;

  data->showmark = 0;

  screen_write_start(&ctx, &data->screen);

  for (i = 0; i < screen_size_y(&data->screen); i++)

    window_copy_write_line(wme, &ctx, i);

  screen_write_cursormove(&ctx, window_copy_cursor_offset(wme, data->cx,

      screen_size_x(&data->screen)), data->cy, 0);

  screen_write_stop(&ctx);

  data->recentre_state = RECENTRE_MIDDLE;

  data->recentre_line = 0;

  return (&data->screen);

}

static struct screen *

window_copy_view_init(struct window_mode_entry *wme,

    __unused struct cmdq_item *item, __unused struct cmd_find_state *fs,

    __unused struct args *args)

{

  struct window_pane    *wp = wme->wp;

  struct window_copy_mode_data  *data;

  struct screen     *base = &wp->base;

  u_int        sx = screen_size_x(base);

  data = window_copy_common_init(wme);

  data->viewmode = 1;

  data->line_numbers = 0;

  data->backing = xmalloc(sizeof *data->backing);

  screen_init(data->backing, sx, screen_size_y(base), UINT_MAX);

  data->ictx = input_init(NULL, NULL, NULL, NULL);

  data->mx = data->cx;

  data->my = screen_hsize(data->backing) + data->cy - data->oy;

  data->showmark = 0;

  return (&data->screen);

}

static void

window_copy_free(struct window_mode_entry *wme)

{

  struct window_copy_mode_data  *data = wme->data;

  evtimer_del(&data->dragtimer);

  evtimer_del(&data->refresh_timer);

  free(data->searchmark);

  free(data->searchstr);

  free(data->jumpchar);

  if (data->ictx != NULL)

    input_free(data->ictx);

  screen_free(data->backing);

  free(data->backing);

  screen_free(&data->screen);

  free(data);

}

void

window_copy_add(struct window_pane *wp, int parse, const char *fmt, ...)

{

  va_list ap;

  va_start(ap, fmt);

  window_copy_vadd(wp, parse, fmt, ap);

  va_end(ap);

}

static void

window_copy_init_ctx_cb(__unused struct screen_write_ctx *ctx,

    __unused struct tty_ctx *ttyctx)

{

}

void

window_copy_vadd(struct window_pane *wp, int parse, const char *fmt, va_list ap)

{

  struct window_mode_entry  *wme = TAILQ_FIRST(&wp->modes);

  struct window_copy_mode_data  *data = wme->data;

  struct screen     *backing = data->backing;

  struct screen_write_ctx    backing_ctx, ctx;

  struct grid_cell     gc;

  u_int        old_hsize, old_cy;

  char        *text;

  old_hsize = screen_hsize(data->backing);

  screen_write_start(&backing_ctx, backing);

  if (data->backing_written) {

    /*

     * On the second or later line, do a CRLF before writing

     * (so it's on a new line).

     */

    screen_write_carriagereturn(&backing_ctx);

    screen_write_linefeed(&backing_ctx, 0, 8);

  } else

    data->backing_written = 1;

  old_cy = backing->cy;

  if (parse) {

    vasprintf(&text, fmt, ap);

    input_parse_screen(data->ictx, backing, window_copy_init_ctx_cb,

        data, text, strlen(text));

    free(text);

  } else {

    memcpy(&gc, &grid_default_cell, sizeof gc);

    screen_write_vnputs(&backing_ctx, 0, &gc, fmt, ap);

  }

  screen_write_stop(&backing_ctx);

  data->oy += screen_hsize(data->backing) - old_hsize;

  screen_write_start_pane(&ctx, wp, &data->screen);

  /*

   * If the history has changed, draw the top line.

   * (If there's any history at all, it has changed.)

   */

  if (screen_hsize(data->backing))

    window_copy_redraw_lines(wme, 0, 1);

  /* Write the new lines. */

  window_copy_redraw_lines(wme, old_cy, backing->cy - old_cy + 1);

  screen_write_stop(&ctx);

}

void

window_copy_scroll(struct window_pane *wp, int sl_mpos, u_int my,

    u_int tty_oy, int scroll_exit)

{

  struct window_mode_entry  *wme = TAILQ_FIRST(&wp->modes);

  if (wme != NULL) {

    window_set_active_pane(wp->window, wp, 0);

    window_copy_scroll1(wme, wp, sl_mpos, my, tty_oy, scroll_exit);

  }

}

static void

window_copy_scroll1(struct window_mode_entry *wme, struct window_pane *wp,

    int sl_mpos, u_int my, u_int tty_oy, int scroll_exit)

{

  struct window_copy_mode_data  *data = wme->data;

  u_int        ox, oy, px, py, n, offset, size;

  u_int        new_offset;

  u_int        slider_height = wp->sb_slider_h;

  u_int        sb_height = wp->sy, sb_top = wp->yoff;

  u_int        sy = screen_size_y(data->backing);

  u_int        my_w;

  int        new_slider_y, delta;

  /*

   * sl_mpos is where in the slider the user is dragging, mouse is

   * dragging this y point relative to top of slider.

   *

   * my is a raw tty y coordinate; sb_top (= wp->yoff) is a window

   * coordinate. Convert my to window coordinates by adding tty_oy (the

   * window pan offset). sl_mpos already has the status lines adjustment

   * baked in (see server_client_check_mouse), so no further status lines

   * correction is needed here.

   */

  my_w = my + tty_oy;

  if (my_w <= sb_top + (u_int)sl_mpos) {

    /* Slider banged into top. */

    new_slider_y = sb_top - wp->yoff;

  } else if (my_w - sl_mpos > sb_top + sb_height - slider_height) {

    /* Slider banged into bottom. */

    new_slider_y = sb_top - wp->yoff + (sb_height - slider_height);

  } else {

    /* Slider is somewhere in the middle. */

    new_slider_y = my_w - wp->yoff - sl_mpos;

  }

  if (TAILQ_FIRST(&wp->modes) == NULL ||

      window_copy_get_current_offset(wp, &offset, &size) == 0)

    return;

  /*

   * See redraw_draw_pane_scrollbar - this is the inverse of the

   * formula used there.

   */

  new_offset = new_slider_y * ((float)(size + sb_height) / sb_height);

  delta = (int)offset - new_offset;

  /*

   * Move pane view around based on delta relative to the cursor,

   * maintaining the selection.

   */

  oy = screen_hsize(data->backing) + data->cy - data->oy;

  ox = window_copy_find_length(wme, oy);

  if (data->cx != ox) {

    data->lastcx = data->cx;

    data->lastsx = ox;

  }

  data->cx = data->lastcx;

  if (delta >= 0) {

    n = (u_int)delta;

    if (data->oy + n > screen_hsize(data->backing)) {

      data->oy = screen_hsize(data->backing);

      if (data->cy < n)

        data->cy = 0;

      else

        data->cy -= n;

    } else

      data->oy += n;

  } else {

    n = (u_int)-delta;

    if (data->oy < n) {

      data->oy = 0;

      if (data->cy + (n - data->oy) >= sy)

        data->cy = sy - 1;

      else

        data->cy += n - data->oy;

    } else

      data->oy -= n;

  }

  /* Don't also drag tail when dragging a scrollbar, it looks weird. */

  data->cursordrag = CURSORDRAG_NONE;

  if (data->screen.sel == NULL || !data->rectflag) {

    py = screen_hsize(data->backing) + data->cy - data->oy;

    px = window_copy_find_length(wme, py);

    if ((data->cx >= data->lastsx && data->cx != px) ||

        data->cx > px)

      window_copy_cursor_end_of_line(wme);

  }

  if (scroll_exit && data->oy == 0 && data->screen.sel == NULL) {

    window_pane_reset_mode(wp);

    return;

  }

  if (data->searchmark != NULL && !data->timeout)

    window_copy_search_marks(wme, NULL, data->searchregex, 1);

  window_copy_update_selection_view(wme, 1, 0);

  window_pane_scrollbar_show(wp, 1);

  window_copy_redraw_screen(wme);

}

void

window_copy_pageup(struct window_pane *wp, int half_page)

{

  window_copy_pageup1(TAILQ_FIRST(&wp->modes), half_page);

}

static void

window_copy_pageup1(struct window_mode_entry *wme, int half_page)

{

  struct window_copy_mode_data  *data = wme->data;

  struct screen     *s = &data->screen;

  u_int        n, ox, oy, px, py;

  oy = screen_hsize(data->backing) + data->cy - data->oy;

  ox = window_copy_find_length(wme, oy);

  if (data->cx != ox) {

    data->lastcx = data->cx;

    data->lastsx = ox;

  }

  data->cx = data->lastcx;

  n = 1;

  if (screen_size_y(s) > 2) {

    if (half_page)

      n = screen_size_y(s) / 2;

    else

      n = screen_size_y(s) - 2;

  }

  if (data->oy + n > screen_hsize(data->backing)) {

    data->oy = screen_hsize(data->backing);

    if (data->cy < n)

      data->cy = 0;

    else

      data->cy -= n;

  } else

    data->oy += n;

  if (data->screen.sel == NULL || !data->rectflag) {

    py = screen_hsize(data->backing) + data->cy - data->oy;

    px = window_copy_find_length(wme, py);

    if ((data->cx >= data->lastsx && data->cx != px) ||

        data->cx > px)

      window_copy_cursor_end_of_line(wme);

  }

  if (data->searchmark != NULL && !data->timeout)

    window_copy_search_marks(wme, NULL, data->searchregex, 1);

  window_copy_update_selection(wme, 1, 0);

  window_pane_scrollbar_show(wme->wp, 1);

  window_copy_redraw_screen(wme);

}

void

window_copy_pagedown(struct window_pane *wp, int half_page, int scroll_exit)

{

  if (window_copy_pagedown1(TAILQ_FIRST(&wp->modes), half_page,

      scroll_exit)) {

    window_pane_reset_mode(wp);

    return;

  }

}

static int

window_copy_pagedown1(struct window_mode_entry *wme, int half_page,

    int scroll_exit)

{

  struct window_copy_mode_data  *data = wme->data;

  struct screen     *s = &data->screen;

  u_int        n, ox, oy, px, py;

  oy = screen_hsize(data->backing) + data->cy - data->oy;

  ox = window_copy_find_length(wme, oy);

  if (data->cx != ox) {

    data->lastcx = data->cx;

    data->lastsx = ox;

  }

  data->cx = data->lastcx;

  n = 1;