/* $OpenBSD: window-tree.c,v 1.94 2026/07/14 17:17:18 nicm Exp $ */

/*

 * Copyright (c) 2017 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 <stdlib.h>

#include <string.h>

#include "tmux.h"

static struct screen  *window_tree_init(struct window_mode_entry *,

           struct cmdq_item *, struct cmd_find_state *,

           struct args *);

static void    window_tree_free(struct window_mode_entry *);

static void    window_tree_resize(struct window_mode_entry *, u_int,

           u_int);

static void    window_tree_update(struct window_mode_entry *);

static void    window_tree_key(struct window_mode_entry *,

           struct client *, struct session *,

           struct winlink *, key_code, struct mouse_event *);

#define WINDOW_TREE_DEFAULT_COMMAND "switch-client -Zt '%%'"

#define WINDOW_TREE_DEFAULT_FORMAT \

  "#{?pane_format," \

    "#{?pane_marked,#[fg=thememagenta],}#{?pane_floating_flag,#[underscore],}" \

    "#{pane_current_command}#[fg=themelightgrey]#{pane_flags}" \

    "#{?#{&&:#{pane_title},#{!=:#{pane_title},#{host_short}}},: \"#{pane_title}\",}" \

  ",window_format," \

    "#{?window_marked_flag,#[fg=thememagenta],}" \

    "#{window_name}#[fg=themelightgrey]#{window_flags}" \

    "#{?#{&&:#{==:#{window_panes},1},#{&&:#{pane_title},#{!=:#{pane_title},#{host_short}}}},: \"#{pane_title}\",}" \

  "," \

    "#[fg=themelightgrey]#{session_windows} windows" \

    "#{?session_grouped, " \

      "(group #{session_group}: " \

      "#{session_group_list})," \

    "}" \

    "#{?session_attached, (attached),}" \

  "}"

#define WINDOW_TREE_DEFAULT_KEY_FORMAT \

  "#{?#{e|<:#{line},10}," \

    "#{line}" \

  ",#{e|<:#{line},36}," \

          "M-#{a:#{e|+:97,#{e|-:#{line},10}}}" \

  "}"

static const struct menu_item window_tree_menu_items[] = {

  { "Select", '\r', NULL },

  { "Expand", KEYC_RIGHT, NULL },

  { "Mark", 'm', NULL },

  { "", KEYC_NONE, NULL },

  { "Tag", 't', NULL },

  { "Tag All", '\024', NULL },

  { "Tag None", 'T', NULL },

  { "", KEYC_NONE, NULL },

  { "Kill", 'x', NULL },

  { "Kill Tagged", 'X', NULL },

  { "", KEYC_NONE, NULL },

  { "Cancel", 'q', NULL },

  { NULL, KEYC_NONE, NULL }

};

const struct window_mode window_tree_mode = {

  .name = "tree-mode",

  .default_format = WINDOW_TREE_DEFAULT_FORMAT,

  .init = window_tree_init,

  .free = window_tree_free,

  .resize = window_tree_resize,

  .update = window_tree_update,

  .key = window_tree_key,

};

enum window_tree_type {

  WINDOW_TREE_NONE,

  WINDOW_TREE_SESSION,

  WINDOW_TREE_WINDOW,

  WINDOW_TREE_PANE,

};

struct window_tree_itemdata {

  enum window_tree_type type;

  int     session;

  int     winlink;

  int     pane;

};

struct window_tree_modedata {

  struct window_pane     *wp;

  int         dead;

  int         references;

  struct mode_tree_data    *data;

  char         *format;

  char         *key_format;

  char         *command;

  int         squash_groups;

  int         hide_preview_this_pane;

  int         preview_is_info;

  int         prompt_flags;

  struct window_tree_itemdata **item_list;

  u_int         item_size;

  const char       *entered;

  struct cmd_find_state     fs;

  enum window_tree_type     type;

  int         offset;

  int         left;

  int         right;

  u_int         start;

  u_int         end;

  u_int         each;

};

static enum sort_order window_tree_order_seq[] = {

  SORT_INDEX,

  SORT_NAME,

  SORT_ACTIVITY,

  SORT_Z,

  SORT_END,

};

#define WINDOW_TREE_FLAG(label, cond) \

  "#{?" cond ",#[fg=themegreen],#[fg=themelightgrey]}" label "#[default]"

static const char *window_tree_pane_info_lines[] = {

  "#[fg=themelightgrey]Pane          #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{pane_index} #[fg=themelightgrey](#{pane_id})#[default]",

  "#[fg=themelightgrey]Title         #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{pane_title}",

  "#[fg=themelightgrey]Command       #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{pane_current_command} #[fg=themelightgrey](PID #{pane_pid})#[default]",

  "#[fg=themelightgrey]Path          #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{pane_current_path}",

  "#[fg=themelightgrey]TTY           #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{pane_tty}",

  "#[fg=themelightgrey]Position      #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{pane_x},#{pane_y} #{pane_width}x#{pane_height}",

  "#[fg=themelightgrey]Mode          #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{?pane_in_mode,#{pane_mode},none}",

  "#[fg=themelightgrey]Flags         #[#{E:tree-mode-border-style},acs]x#[default] "

  WINDOW_TREE_FLAG("active", "pane_active") " "

  WINDOW_TREE_FLAG("zoomed", "window_zoomed_flag") " "

  WINDOW_TREE_FLAG("marked", "pane_marked") " "

  WINDOW_TREE_FLAG("sync", "pane_synchronized") " "

  WINDOW_TREE_FLAG("dead", "pane_dead") " "

  WINDOW_TREE_FLAG("piped", "pane_pipe"),

};

static const char *window_tree_window_info_lines[] = {

  "#[fg=themelightgrey]Window        #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{window_index}: #{window_name} #[fg=themelightgrey](#{window_id})#[default]",

  "#[fg=themelightgrey]Size          #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{window_width}x#{window_height}",

  "#[fg=themelightgrey]Panes         #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{window_panes}",

  "#[fg=themelightgrey]Activity Time #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{t:window_activity} #[fg=themelightgrey](#{t/r:window_activity})#[default]",

  "#[fg=themelightgrey]Sessions      #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{s/,/ /:window_linked_sessions_list}",

  "#[fg=themelightgrey]Flags         #[#{E:tree-mode-border-style},acs]x#[default] "

  WINDOW_TREE_FLAG("active", "window_active") " "

  WINDOW_TREE_FLAG("last", "window_last_flag") " "

  WINDOW_TREE_FLAG("bell", "window_bell_flag") " "

  WINDOW_TREE_FLAG("activity", "window_activity_flag") " "

  WINDOW_TREE_FLAG("silence", "window_silence_flag") " "

  WINDOW_TREE_FLAG("zoomed", "window_zoomed_flag") " "

  WINDOW_TREE_FLAG("marked", "window_marked_flag"),

};

static const char *window_tree_session_info_lines[] = {

  "#[fg=themelightgrey]Session       #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{session_name} #[fg=themelightgrey](#{session_id})#[default]",

  "#[fg=themelightgrey]Created Time  #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{t:session_created} #[fg=themelightgrey](#{t/r:session_created})#[default]",

  "#[fg=themelightgrey]Activity Time #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{t:session_activity} #[fg=themelightgrey](#{t/r:session_activity})#[default]",

  "#[fg=themelightgrey]Attached Time #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{?#{t:session_last_attached},#{t:session_last_attached} #[fg=themelightgrey](#{t/r:session_last_attached})#[default],never}",

  "#[fg=themelightgrey]Clients       #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{s/,/ /:session_attached_list}",

  "#[fg=themelightgrey]Windows       #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{session_windows}",

  "#[fg=themelightgrey]Path          #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{session_path}",

  "#[fg=themelightgrey]Group         #[#{E:tree-mode-border-style},acs]x#[default] "

  "#{?session_grouped,#{session_group} (#{session_group_size}),none}",

  "#[fg=themelightgrey]Flags         #[#{E:tree-mode-border-style},acs]x#[default] "

  WINDOW_TREE_FLAG("attached", "session_attached") " "

  WINDOW_TREE_FLAG("grouped", "session_grouped") " "

  WINDOW_TREE_FLAG("marked", "session_marked") " "

  WINDOW_TREE_FLAG("bell", "session_bell_flag") " "

  WINDOW_TREE_FLAG("activity", "session_activity_flag") " "

  WINDOW_TREE_FLAG("silence", "session_silence_flag"),

};

static void

window_tree_pull_item(struct window_tree_itemdata *item, struct session **sp,

    struct winlink **wlp, struct window_pane **wp)

{

  *wp = NULL;

  *wlp = NULL;

  *sp = session_find_by_id(item->session);

  if (*sp == NULL)

    return;

  if (item->type == WINDOW_TREE_SESSION) {

    *wlp = (*sp)->curw;

    *wp = (*wlp)->window->active;

    return;

  }

  *wlp = winlink_find_by_index(&(*sp)->windows, item->winlink);

  if (*wlp == NULL) {

    *sp = NULL;

    return;

  }

  if (item->type == WINDOW_TREE_WINDOW) {

    *wp = (*wlp)->window->active;

    return;

  }

  *wp = window_pane_find_by_id(item->pane);

  if (!window_has_pane((*wlp)->window, *wp))

    *wp = NULL;

  if (*wp == NULL) {

    *sp = NULL;

    *wlp = NULL;

    return;

  }

}

static struct window_tree_itemdata *

window_tree_add_item(struct window_tree_modedata *data)

{

  struct window_tree_itemdata *item;

  data->item_list = xreallocarray(data->item_list, data->item_size + 1,

      sizeof *data->item_list);

  item = data->item_list[data->item_size++] = xcalloc(1, sizeof *item);

  return (item);

}

static void

window_tree_free_item(struct window_tree_itemdata *item)

{

  free(item);

}

static void

window_tree_build_pane(struct session *s, struct winlink *wl,

    struct window_pane *wp, void *modedata, struct mode_tree_item *parent)

{

  struct window_tree_modedata *data = modedata;

  struct window_tree_itemdata *item;

  struct mode_tree_item   *mti;

  char        *name, *text;

  u_int        idx;

  struct format_tree    *ft;

  window_pane_index(wp, &idx);

  item = window_tree_add_item(data);

  item->type = WINDOW_TREE_PANE;

  item->session = s->id;

  item->winlink = wl->idx;

  item->pane = wp->id;

  ft = format_create(NULL, NULL, FORMAT_PANE|wp->id, 0);

  format_defaults(ft, NULL, s, wl, wp);

  text = format_expand(ft, data->format);

  xasprintf(&name, "%u", idx);

  format_free(ft);

  mti = mode_tree_add(data->data, parent, item, (uint64_t)wp, name, text,

      -1);

  free(text);

  free(name);

  mode_tree_align(mti, 1);

}

static int

window_tree_filter_pane(struct session *s, struct winlink *wl,

    struct window_pane *wp, const char *filter)

{

  char  *cp;

  int  result;

  if (filter == NULL)

    return (1);

  cp = format_single(NULL, filter, NULL, s, wl, wp);

  result = format_true(cp);

  free(cp);

  return (result);

}

static int

window_tree_build_window(struct session *s, struct winlink *wl,

    void *modedata, struct sort_criteria *sort_crit,

    struct mode_tree_item *parent, const char *filter)

{

  struct window_tree_modedata *data = modedata;

  struct window_tree_itemdata *item;

  struct mode_tree_item   *mti;

  char        *name, *text;

  struct window_pane    **l;

  u_int        n, i, found;

  int        expanded;

  struct format_tree    *ft;

  uint64_t       tag = FORMAT_NONE;

  item = window_tree_add_item(data);

  item->type = WINDOW_TREE_WINDOW;

  item->session = s->id;

  item->winlink = wl->idx;

  item->pane = -1;

  if (wl->window != NULL && wl->window->active != NULL)

    tag = FORMAT_PANE|wl->window->active->id;

  ft = format_create(NULL, NULL, tag, 0);

  format_defaults(ft, NULL, s, wl, NULL);

  text = format_expand(ft, data->format);

  xasprintf(&name, "%u", wl->idx);

  format_free(ft);

  if (data->type == WINDOW_TREE_SESSION ||

      data->type == WINDOW_TREE_WINDOW)

    expanded = 0;

  else

    expanded = 1;

  mti = mode_tree_add(data->data, parent, item, (uint64_t)wl, name, text,

      expanded);

  free(text);

  free(name);

  mode_tree_align(mti, 1);

  l = sort_get_panes_window(wl->window, &n, sort_crit);

  found = 0;

  for (i = 0; i < n; i++) {

    if (!window_tree_filter_pane(s, wl, l[i], filter))

      continue;

    found++;

    if (data->hide_preview_this_pane && l[i] == data->wp)

      continue;

    window_tree_build_pane(s, wl, l[i], modedata, mti);

  }

  if (found == 0) {

    window_tree_free_item(item);

    data->item_size--;

    mode_tree_remove(data->data, mti);

    return (0);

  }

  return (1);

}

static void

window_tree_build_session(struct session *s, void *modedata,

    struct sort_criteria *sort_crit, const char *filter)

{

  struct window_tree_modedata *data = modedata;

  struct window_tree_itemdata *item;

  struct mode_tree_item   *mti;

  char        *text;

  struct winlink      *wl = s->curw, **l;

  u_int        n, i, empty;

  int        expanded;

  struct format_tree    *ft;

  uint64_t       tag = FORMAT_NONE;

  item = window_tree_add_item(data);

  item->type = WINDOW_TREE_SESSION;

  item->session = s->id;

  item->winlink = -1;

  item->pane = -1;

  if (wl != NULL && wl->window != NULL && wl->window->active != NULL)

    tag = FORMAT_PANE|wl->window->active->id;

  ft = format_create(NULL, NULL, tag, 0);

  format_defaults(ft, NULL, s, NULL, NULL);

  text = format_expand(ft, data->format);

  format_free(ft);

  if (data->type == WINDOW_TREE_SESSION)

    expanded = 0;

  else

    expanded = 1;

  mti = mode_tree_add(data->data, NULL, item, (uint64_t)s, s->name, text,

      expanded);

  free(text);

  l = sort_get_winlinks_session(s, &n, sort_crit);

  empty = 0;

  for (i = 0; i < n; i++) {

    if (!window_tree_build_window(s, l[i], modedata, sort_crit, mti,

        filter))

      empty++;

  }

  if (empty == n) {

    window_tree_free_item(item);

    data->item_size--;

    mode_tree_remove(data->data, mti);

  }

}

static void

window_tree_build(void *modedata, struct sort_criteria *sort_crit,

    uint64_t *tag, const char *filter)

{

  struct window_tree_modedata *data = modedata;

  int        squash_groups = data->squash_groups;

  struct session      *s, **l;

  struct session_group    *sg, *current;

  u_int        n, i;

  current = session_group_contains(data->fs.s);

  for (i = 0; i < data->item_size; i++)

    window_tree_free_item(data->item_list[i]);

  free(data->item_list);

  data->item_list = NULL;

  data->item_size = 0;

  l = sort_get_sessions(&n, sort_crit);

  if (n == 0)

    return;

  for (i = 0; i < n; i++) {

    s = l[i];

    if (squash_groups && (sg = session_group_contains(s)) != NULL) {

      if ((sg == current && s != data->fs.s) ||

          (sg != current && s != TAILQ_FIRST(&sg->sessions)))

        continue;

    }

    window_tree_build_session(s, modedata, sort_crit, filter);

  }

  switch (data->type) {

  case WINDOW_TREE_NONE:

    break;

  case WINDOW_TREE_SESSION:

    *tag = (uint64_t)data->fs.s;

    break;

  case WINDOW_TREE_WINDOW:

    *tag = (uint64_t)data->fs.wl;

    break;

  case WINDOW_TREE_PANE:

    if (window_count_panes(data->fs.wl->window, 1) == 1)

      *tag = (uint64_t)data->fs.wl;

    else

      *tag = (uint64_t)data->fs.wp;

    break;

  }

}

static void

window_tree_draw_label(struct screen_write_ctx *ctx, u_int px, u_int py,

    u_int sx, u_int sy, const struct grid_cell *border_gc,

    const struct grid_cell *label_gc, const char *label)

{

  u_int  width, ox, oy;

  char  *new_label = NULL;

  if (sx < 5 || sy < 3)

    return;

  width = format_width(label);

  if (width > sx - 4) {

    label = new_label = format_trim_left(label, sx - 4);

    width = format_width(new_label);

  }

  if (width == 0)

    return;

  ox = (sx - width + 1) / 2;

  oy = (sy + 1) / 2;

  screen_write_cursormove(ctx, px + ox - 2, py + oy - 1, 0);

  screen_write_box(ctx, width + 4, 3, BOX_LINES_DEFAULT,

      border_gc, NULL);

  screen_write_cursormove(ctx, px + ox - 1, py + oy, 0);

  screen_write_clearcharacter(ctx, width + 2, border_gc->bg);

  screen_write_cursormove(ctx, px + ox, py + oy, 0);

  format_draw(ctx, label_gc, width, label, NULL, 0);

  free(new_label);

}

static void

window_tree_border_cell(struct grid_cell *gc, struct options *oo,

    struct format_tree *ft)

{

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

  style_apply(gc, oo, "tree-mode-border-style", ft);

}

static void

window_tree_draw_session(struct window_tree_modedata *data, struct session *s,

    struct screen_write_ctx *ctx, u_int sx, u_int sy)

{

  struct winlink    *wl;

  struct window   *w;

  u_int      cx = ctx->s->cx, cy = ctx->s->cy;

  u_int      loop, total, visible, each, width, offset;

  u_int      current, start, end, remaining, i;

  struct grid_cell   gc, label_gc;

  int      left, right;

  char      *label;

  const char    *format;

  struct format_tree  *ft;

  struct options    *oo;

  total = winlink_count(&s->windows);

  if (sx / total < 24) {

    visible = sx / 24;

    if (visible == 0)

      visible = 1;

  } else

    visible = total;

  current = 0;

  RB_FOREACH(wl, winlinks, &s->windows) {

    if (wl == s->curw)

      break;

    current++;

  }

  if (current < visible) {

    start = 0;

    end = visible;

  } else if (current >= total - visible) {

    start = total - visible;

    end = total;

  } else {

    start = current - (visible / 2);

    end = start + visible;

  }

  if (data->offset < -(int)start)

    data->offset = -(int)start;

  if (data->offset > (int)(total - end))

    data->offset = (int)(total - end);

  start += data->offset;

  end += data->offset;

  left = (start != 0);

  right = (end != total);

  if (((left && right) && sx <= 6) || ((left || right) && sx <= 3))

    left = right = 0;

  if (left && right) {

    each = (sx - 6) / visible;

    remaining = (sx - 6) - (visible * each);

  } else if (left || right) {

    each = (sx - 3) / visible;

    remaining = (sx - 3) - (visible * each);

  } else {

    each = sx / visible;

    remaining = sx - (visible * each);

  }

  if (each == 0)

    return;

  window_tree_border_cell(&gc, data->wp->window->options, NULL);

  if (left) {

    data->left = cx + 2;

    screen_write_cursormove(ctx, cx + 2, cy, 0);

    screen_write_vline(ctx, sy, 0, 0, &gc);

    screen_write_cursormove(ctx, cx, cy + sy / 2, 0);

    screen_write_puts(ctx, &gc, "<");

  } else

    data->left = -1;

  if (right) {

    data->right = cx + sx - 3;

    screen_write_cursormove(ctx, cx + sx - 3, cy, 0);

    screen_write_vline(ctx, sy, 0, 0, &gc);

    screen_write_cursormove(ctx, cx + sx - 1, cy + sy / 2, 0);

    screen_write_puts(ctx, &gc, ">");

  } else

    data->right = -1;

  data->start = start;

  data->end = end;

  data->each = each;

  i = loop = 0;

  RB_FOREACH(wl, winlinks, &s->windows) {

    if (loop == end)

      break;

    if (loop < start) {

      loop++;

      continue;

    }

    w = wl->window;

    oo = w->options;

    ft = format_create(NULL, NULL, FORMAT_WINDOW|w->id, 0);

    format_defaults(ft, NULL, s, wl, NULL);

    window_tree_border_cell(&gc, oo, ft);

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

    style_apply(&label_gc, oo, "tree-mode-preview-style", ft);

    label_gc.bg = gc.bg;

    if (left)

      offset = 3 + (i * each);

    else

      offset = (i * each);

    if (loop == end - 1)

      width = each + remaining;

    else

      width = each - 1;

    screen_write_cursormove(ctx, cx + offset, cy, 0);

    screen_write_preview(ctx, &w->active->base, width, sy);

    format = options_get_string(oo, "tree-mode-preview-format");

    if (*format != '\0') {

      label = format_expand(ft, format);

      if (*label != '\0') {

        window_tree_draw_label(ctx, cx + offset, cy,

            width, sy, &gc, &label_gc, label);

      }

      free(label);

    }

    if (loop != end - 1) {

      screen_write_cursormove(ctx, cx + offset + width, cy,

          0);

      screen_write_vline(ctx, sy, 0, 0, &gc);

    }

    loop++;

    i++;

  }

}

static void

window_tree_draw_window(struct window_tree_modedata *data, struct session *s,

    struct winlink *wl, struct screen_write_ctx *ctx, u_int sx, u_int sy)

{

  struct window   *w = wl->window;

  struct window_pane  *wp;

  u_int      cx = ctx->s->cx, cy = ctx->s->cy;

  u_int      loop, total, visible, each, width, offset;

  u_int      current, start, end, remaining, i;

  struct grid_cell   gc, label_gc;

  int      left, right;

  char      *label;

  const char    *format;

  struct format_tree  *ft;

  struct options    *oo;

  total = window_count_panes(w, 1);

  if (data->hide_preview_this_pane && data->wp->window == w)

    total--;

  if (total == 0)

    return;

  if (sx / total < 24) {

    visible = sx / 24;

    if (visible == 0)

      visible = 1;

  } else

    visible = total;

  current = 0;

  TAILQ_FOREACH(wp, &w->panes, entry) {

    if (data->hide_preview_this_pane && wp == data->wp)

      continue;

    if (wp == w->active)

      break;

    current++;

  }

  if (current < visible) {

    start = 0;

    end = visible;

  } else if (current >= total - visible) {

    start = total - visible;

    end = total;

  } else {

    start = current - (visible / 2);

    end = start + visible;

  }

  if (data->offset < -(int)start)

    data->offset = -(int)start;

  if (data->offset > (int)(total - end))

    data->offset = (int)(total - end);

  start += data->offset;

  end += data->offset;

  left = (start != 0);

  right = (end != total);

  if (((left && right) && sx <= 6) || ((left || right) && sx <= 3))

    left = right = 0;

  if (left && right) {

    each = (sx - 6) / visible;

    remaining = (sx - 6) - (visible * each);

  } else if (left || right) {

    each = (sx - 3) / visible;

    remaining = (sx - 3) - (visible * each);

  } else {

    each = sx / visible;

    remaining = sx - (visible * each);

  }

  if (each == 0)

    return;

  window_tree_border_cell(&gc, data->wp->window->options, NULL);

  if (left) {

    data->left = cx + 2;

    screen_write_cursormove(ctx, cx + 2, cy, 0);

    screen_write_vline(ctx, sy, 0, 0, &gc);

    screen_write_cursormove(ctx, cx, cy + sy / 2, 0);

    screen_write_puts(ctx, &gc, "<");

  } else

    data->left = -1;

  if (right) {

    data->right = cx + sx - 3;

    screen_write_cursormove(ctx, cx + sx - 3, cy, 0);

    screen_write_vline(ctx, sy, 0, 0, &gc);

    screen_write_cursormove(ctx, cx + sx - 1, cy + sy / 2, 0);

    screen_write_puts(ctx, &gc, ">");

  } else

    data->right = -1;

  data->start = start;

  data->end = end;

  data->each = each;

  i = loop = 0;

  TAILQ_FOREACH(wp, &w->panes, entry) {

    if (data->hide_preview_this_pane && wp == data->wp)

      continue;

    if (loop == end)

      break;

    if (loop < start) {

      loop++;

      continue;

    }

    oo = wp->options;

    ft = format_create(NULL, NULL, FORMAT_PANE|wp->id, 0);

    format_defaults(ft, NULL, s, wl, wp);

    window_tree_border_cell(&gc, oo, ft);

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

    style_apply(&label_gc, oo, "tree-mode-preview-style", ft);

    label_gc.bg = gc.bg;

    if (left)

      offset = 3 + (i * each);

    else

      offset = (i * each);

    if (loop == end - 1)

      width = each + remaining;

    else

      width = each - 1;

    screen_write_cursormove(ctx, cx + offset, cy, 0);

    screen_write_preview(ctx, &wp->base, width, sy);

    format = options_get_string(oo, "tree-mode-preview-format");

    if (*format != '\0') {

      label = format_expand(ft, format);

      if (*label != '\0') {

        window_tree_draw_label(ctx, cx + offset, cy,

            width, sy, &gc, &label_gc, label);

      }

      free(label);

    }

    if (loop != end - 1) {

      screen_write_cursormove(ctx, cx + offset + width, cy,

          0);

      screen_write_vline(ctx, sy, 0, 0, &gc);

    }

    loop++;

    i++;

  }

}

static void

window_tree_draw_info(struct window_tree_modedata *data, void *itemdata,

    struct screen_write_ctx *ctx, u_int sx, u_int sy)

{

  struct window_tree_itemdata *item = itemdata;

  struct screen     *s = ctx->s;

  struct session      *sp;

  struct winlink      *wl;

  struct window_pane    *wp;

  struct grid_cell     gc;

  u_int        cx = s->cx, cy = s->cy, i, j, k;

  struct format_tree    *ft;

  char        *expanded;

  const char *const   *lines[3];

  u_int        count[3], n = 0;

  window_tree_pull_item(item, &sp, &wl, &wp);

  if (sp == NULL || wp == NULL)

    return;

  if (item->type == WINDOW_TREE_PANE) {

    lines[n] = window_tree_pane_info_lines;

    count[n++] = nitems(window_tree_pane_info_lines);

  }

  if (item->type == WINDOW_TREE_PANE ||

      item->type == WINDOW_TREE_WINDOW) {

    lines[n] = window_tree_window_info_lines;

    count[n++] = nitems(window_tree_window_info_lines);

  }

  lines[n] = window_tree_session_info_lines;

  count[n++] = nitems(window_tree_session_info_lines);

  ft = format_create(NULL, NULL, FORMAT_NONE, 0);

  format_defaults(ft, NULL, sp, wl, wp);

  i = 0;

  for (j = 0; j < n; j++) {

    if (j != 0) {

      if (i == sy)

        break;

      window_tree_border_cell(&gc, data->wp->window->options,

          NULL);

      screen_write_cursormove(ctx, cx, cy + i, 0);

      screen_write_hline(ctx, sx, 0, 0, BOX_LINES_DEFAULT,

          &gc);

      if (sx > 14) {

        gc.attr |= GRID_ATTR_CHARSET;

        screen_write_cursormove(ctx, cx + 14, cy + i,

            0);

        screen_write_putc(ctx, &gc, 'n');

      }

      i++;

    }

    for (k = 0; k < count[j]; k++) {

      if (i == sy)

        break;

      expanded = format_expand(ft, lines[j][k]);

      screen_write_cursormove(ctx, cx, cy + i, 0);

      format_draw(ctx, &grid_default_cell, sx, expanded, NULL,

          0);

      free(expanded);

      i++;

    }

    if (i == sy)

      break;

  }

  if (sx > 14 && i < sy) {

    window_tree_border_cell(&gc, data->wp->window->options, NULL);

    screen_write_cursormove(ctx, cx + 14, cy + i, 0);

    screen_write_vline(ctx, sy - i, 0, 0, &gc);

  }

  format_free(ft);

}

static void

window_tree_draw(void *modedata, void *itemdata, struct screen_write_ctx *ctx,

    u_int sx, u_int sy)

{

  struct window_tree_modedata *data = modedata;

  struct window_tree_itemdata *item = itemdata;

  struct session      *sp;

  struct winlink      *wl;

  struct window_pane    *wp;

  window_tree_pull_item(item, &sp, &wl, &wp);