/* $OpenBSD$ */

/*

 * 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 cmd_find_state *, struct args *);

static struct screen *window_copy_view_init(struct window_mode_entry *,

        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 *wp, 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_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_adjust_selection(struct window_mode_entry *,

        u_int *, u_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 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,

  .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,

  .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_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,

};

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 screen *writing;

  struct input_ctx *ictx;

  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 */

  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;

  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

};

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

}

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;

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

  return (data);

}

static struct screen *

window_copy_init(struct window_mode_entry *wme,

    __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);

  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)

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

  data->screen.cx = data->cx;

  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, data->cx, data->cy, 0);

  screen_write_stop(&ctx);

  return (&data->screen);

}

static struct screen *

window_copy_view_init(struct window_mode_entry *wme,

    __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->backing = xmalloc(sizeof *data->backing);

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

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

  screen_init(data->writing, sx, screen_size_y(base), 0);

  data->ictx = input_init(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);

  free(data->searchmark);

  free(data->searchstr);

  free(data->jumpchar);

  if (data->writing != NULL) {

    screen_free(data->writing);

    free(data->writing);

  }

  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,

    struct tty_ctx *ttyctx)

{

  memcpy(&ttyctx->defaults, &grid_default_cell, sizeof ttyctx->defaults);

  ttyctx->palette = NULL;

  ttyctx->redraw_cb = NULL;

  ttyctx->set_client_cb = NULL;

  ttyctx->arg = NULL;

}

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     *writing = data->writing;

  struct screen_write_ctx    writing_ctx, backing_ctx, ctx;

  struct grid_cell     gc;

  u_int        old_hsize, old_cy;

  u_int        sx = screen_size_x(backing);

  char        *text;

  if (parse) {

    vasprintf(&text, fmt, ap);

    screen_write_start(&writing_ctx, writing);

    screen_write_reset(&writing_ctx);

    input_parse_screen(data->ictx, writing, window_copy_init_ctx_cb,

        data, text, strlen(text));

    free(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)

    screen_write_fast_copy(&backing_ctx, writing, 0, 0, sx, 1);

  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,

    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, scroll_exit);

  }

}

static void

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

    int sl_mpos, u_int my, 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);

  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.

   */

  if (my <= sb_top + sl_mpos) {

    /* Slider banged into top. */

    new_slider_y = sb_top - wp->yoff;

  } else if (my - 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 - wp->yoff - sl_mpos + 1;

  }

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

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

    return;

  /*

   * See screen_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) {

    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(wme, 1, 0);

  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_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;

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

    data->oy = 0;

    if (data->cy + (n - data->oy) >= screen_size_y(data->backing))

      data->cy = screen_size_y(data->backing) - 1;

    else

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

  } 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 (scroll_exit && data->oy == 0)

    return (1);

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

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

  window_copy_update_selection(wme, 1, 0);

  window_copy_redraw_screen(wme);

  return (0);

}

static void

window_copy_previous_paragraph(struct window_mode_entry *wme)

{

  struct window_copy_mode_data  *data = wme->data;

  u_int        oy;

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

  while (oy > 0 && window_copy_find_length(wme, oy) == 0)

    oy--;

  while (oy > 0 && window_copy_find_length(wme, oy) > 0)

    oy--;

  window_copy_scroll_to(wme, 0, oy, 0);

}

static void

window_copy_next_paragraph(struct window_mode_entry *wme)

{

  struct window_copy_mode_data  *data = wme->data;

  struct screen     *s = &data->screen;

  u_int        maxy, ox, oy;

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

  maxy = screen_hsize(data->backing) + screen_size_y(s) - 1;

  while (oy < maxy && window_copy_find_length(wme, oy) == 0)

    oy++;

  while (oy < maxy && window_copy_find_length(wme, oy) > 0)

    oy++;

  ox = window_copy_find_length(wme, oy);

  window_copy_scroll_to(wme, ox, oy, 0);

}

char *

window_copy_get_word(struct window_pane *wp, u_int x, u_int y)

{

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

  struct window_copy_mode_data  *data = wme->data;

  struct grid     *gd = data->backing->grid;

  return (format_grid_word(gd, x, gd->hsize + y - data->oy));

}

char *

window_copy_get_line(struct window_pane *wp, u_int y)

{

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

  struct window_copy_mode_data  *data = wme->data;

  struct grid     *gd = data->screen.grid;

  return (format_grid_line(gd, gd->hsize + y));

}

char *

window_copy_get_hyperlink(struct window_pane *wp, u_int x, u_int y)

{

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

  struct window_copy_mode_data  *data = wme->data;

  struct grid     *gd = data->screen.grid;

  return (format_grid_hyperlink(gd, x, gd->hsize + y, wp->screen));

}

static void *

window_copy_cursor_hyperlink_cb(struct format_tree *ft)

{

  struct window_pane    *wp = format_get_pane(ft);

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

  struct window_copy_mode_data  *data = wme->data;

  struct grid     *gd = data->screen.grid;

  return (format_grid_hyperlink(gd, data->cx, gd->hsize + data->cy,

      &data->screen));

}

static void *

window_copy_cursor_word_cb(struct format_tree *ft)

{

  struct window_pane    *wp = format_get_pane(ft);

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

  struct window_copy_mode_data  *data = wme->data;

  return (window_copy_get_word(wp, data->cx, data->cy));

}

static void *

window_copy_cursor_line_cb(struct format_tree *ft)

{

  struct window_pane    *wp = format_get_pane(ft);

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

  struct window_copy_mode_data  *data = wme->data;

  return (window_copy_get_line(wp, data->cy));

}

static void *

window_copy_search_match_cb(struct format_tree *ft)

{

  struct window_pane    *wp = format_get_pane(ft);

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

  struct window_copy_mode_data  *data = wme->data;

  return (window_copy_match_at_cursor(data));

}

static void

window_copy_formats(struct window_mode_entry *wme, struct format_tree *ft)

{

  struct window_copy_mode_data  *data = wme->data;

  u_int        hsize = screen_hsize(data->backing);