?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add an option (scroll-on-clear) to control if tmux scrolls into history
[tmux-openbsd.git] / window-tree.c
blobb594edd939a45dd36746da433c4d67e4f2416e49
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2017 Nicholas Marriott <nicholas.marriott@gmail.com>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/types.h>
20
21 #include <ctype.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include "tmux.h"
26
27 static struct screen *window_tree_init(struct window_mode_entry *,
28 struct cmd_find_state *, struct args *);
29 static void window_tree_free(struct window_mode_entry *);
30 static void window_tree_resize(struct window_mode_entry *, u_int,
31 u_int);
32 static void window_tree_update(struct window_mode_entry *);
33 static void window_tree_key(struct window_mode_entry *,
34 struct client *, struct session *,
35 struct winlink *, key_code, struct mouse_event *);
36
37 #define WINDOW_TREE_DEFAULT_COMMAND "switch-client -Zt '%%'"
38
39 #define WINDOW_TREE_DEFAULT_FORMAT \
40 "#{?pane_format," \
41 "#{?pane_marked,#[reverse],}" \
42 "#{pane_current_command}#{?pane_active,*,}#{?pane_marked,M,}" \
43 "#{?#{&&:#{pane_title},#{!=:#{pane_title},#{host_short}}},: \"#{pane_title}\",}" \
44 "," \
45 "#{?window_format," \
46 "#{?window_marked_flag,#[reverse],}" \
47 "#{window_name}#{window_flags}" \
48 "#{?#{&&:#{==:#{window_panes},1},#{&&:#{pane_title},#{!=:#{pane_title},#{host_short}}}},: \"#{pane_title}\",}" \
49 "," \
50 "#{session_windows} windows" \
51 "#{?session_grouped, " \
52 "(group #{session_group}: " \
53 "#{session_group_list})," \
54 "}" \
55 "#{?session_attached, (attached),}" \
56 "}" \
57 "}"
58
59 #define WINDOW_TREE_DEFAULT_KEY_FORMAT \
60 "#{?#{e|<:#{line},10}," \
61 "#{line}" \
62 "," \
63 "#{?#{e|<:#{line},36}," \
64 "M-#{a:#{e|+:97,#{e|-:#{line},10}}}" \
65 "," \
66 "" \
67 "}" \
68 "}"
69
70 static const struct menu_item window_tree_menu_items[] = {
71 { "Select", '\r', NULL },
72 { "Expand", KEYC_RIGHT, NULL },
73 { "Mark", 'm', NULL },
74 { "", KEYC_NONE, NULL },
75 { "Tag", 't', NULL },
76 { "Tag All", '\024', NULL },
77 { "Tag None", 'T', NULL },
78 { "", KEYC_NONE, NULL },
79 { "Kill", 'x', NULL },
80 { "Kill Tagged", 'X', NULL },
81 { "", KEYC_NONE, NULL },
82 { "Cancel", 'q', NULL },
83
84 { NULL, KEYC_NONE, NULL }
85 };
86
87 const struct window_mode window_tree_mode = {
88 .name = "tree-mode",
89 .default_format = WINDOW_TREE_DEFAULT_FORMAT,
90
91 .init = window_tree_init,
92 .free = window_tree_free,
93 .resize = window_tree_resize,
94 .update = window_tree_update,
95 .key = window_tree_key,
96 };
97
98 enum window_tree_sort_type {
99 WINDOW_TREE_BY_INDEX,
100 WINDOW_TREE_BY_NAME,
101 WINDOW_TREE_BY_TIME,
102 };
103 static const char *window_tree_sort_list[] = {
104 "index",
105 "name",
106 "time"
107 };
108 static struct mode_tree_sort_criteria *window_tree_sort;
109
110 enum window_tree_type {
111 WINDOW_TREE_NONE,
112 WINDOW_TREE_SESSION,
113 WINDOW_TREE_WINDOW,
114 WINDOW_TREE_PANE,
115 };
116
117 struct window_tree_itemdata {
118 enum window_tree_type type;
119 int session;
120 int winlink;
121 int pane;
122 };
123
124 struct window_tree_modedata {
125 struct window_pane *wp;
126 int dead;
127 int references;
128
129 struct mode_tree_data *data;
130 char *format;
131 char *key_format;
132 char *command;
133 int squash_groups;
134
135 struct window_tree_itemdata **item_list;
136 u_int item_size;
137
138 const char *entered;
139
140 struct cmd_find_state fs;
141 enum window_tree_type type;
142
143 int offset;
144
145 int left;
146 int right;
147 u_int start;
148 u_int end;
149 u_int each;
150 };
151
152 static void
153 window_tree_pull_item(struct window_tree_itemdata *item, struct session **sp,
154 struct winlink **wlp, struct window_pane **wp)
155 {
156 *wp = NULL;
157 *wlp = NULL;
158 *sp = session_find_by_id(item->session);
159 if (*sp == NULL)
160 return;
161 if (item->type == WINDOW_TREE_SESSION) {
162 *wlp = (*sp)->curw;
163 *wp = (*wlp)->window->active;
164 return;
165 }
166
167 *wlp = winlink_find_by_index(&(*sp)->windows, item->winlink);
168 if (*wlp == NULL) {
169 *sp = NULL;
170 return;
171 }
172 if (item->type == WINDOW_TREE_WINDOW) {
173 *wp = (*wlp)->window->active;
174 return;
175 }
176
177 *wp = window_pane_find_by_id(item->pane);
178 if (!window_has_pane((*wlp)->window, *wp))
179 *wp = NULL;
180 if (*wp == NULL) {
181 *sp = NULL;
182 *wlp = NULL;
183 return;
184 }
185 }
186
187 static struct window_tree_itemdata *
188 window_tree_add_item(struct window_tree_modedata *data)
189 {
190 struct window_tree_itemdata *item;
191
192 data->item_list = xreallocarray(data->item_list, data->item_size + 1,
193 sizeof *data->item_list);
194 item = data->item_list[data->item_size++] = xcalloc(1, sizeof *item);
195 return (item);
196 }
197
198 static void
199 window_tree_free_item(struct window_tree_itemdata *item)
200 {
201 free(item);
202 }
203
204 static int
205 window_tree_cmp_session(const void *a0, const void *b0)
206 {
207 const struct session *const *a = a0;
208 const struct session *const *b = b0;
209 const struct session *sa = *a;
210 const struct session *sb = *b;
211 int result = 0;
212
213 switch (window_tree_sort->field) {
214 case WINDOW_TREE_BY_INDEX:
215 result = sa->id - sb->id;
216 break;
217 case WINDOW_TREE_BY_TIME:
218 if (timercmp(&sa->activity_time, &sb->activity_time, >)) {
219 result = -1;
220 break;
221 }
222 if (timercmp(&sa->activity_time, &sb->activity_time, <)) {
223 result = 1;
224 break;
225 }
226 /* FALLTHROUGH */
227 case WINDOW_TREE_BY_NAME:
228 result = strcmp(sa->name, sb->name);
229 break;
230 }
231
232 if (window_tree_sort->reversed)
233 result = -result;
234 return (result);
235 }
236
237 static int
238 window_tree_cmp_window(const void *a0, const void *b0)
239 {
240 const struct winlink *const *a = a0;
241 const struct winlink *const *b = b0;
242 const struct winlink *wla = *a;
243 const struct winlink *wlb = *b;
244 struct window *wa = wla->window;
245 struct window *wb = wlb->window;
246 int result = 0;
247
248 switch (window_tree_sort->field) {
249 case WINDOW_TREE_BY_INDEX:
250 result = wla->idx - wlb->idx;
251 break;
252 case WINDOW_TREE_BY_TIME:
253 if (timercmp(&wa->activity_time, &wb->activity_time, >)) {
254 result = -1;
255 break;
256 }
257 if (timercmp(&wa->activity_time, &wb->activity_time, <)) {
258 result = 1;
259 break;
260 }
261 /* FALLTHROUGH */
262 case WINDOW_TREE_BY_NAME:
263 result = strcmp(wa->name, wb->name);
264 break;
265 }
266
267 if (window_tree_sort->reversed)
268 result = -result;
269 return (result);
270 }
271
272 static int
273 window_tree_cmp_pane(const void *a0, const void *b0)
274 {
275 const struct window_pane *const *a = a0;
276 const struct window_pane *const *b = b0;
277 int result;
278
279 if (window_tree_sort->field == WINDOW_TREE_BY_TIME)
280 result = (*a)->active_point - (*b)->active_point;
281 else {
282 /*
283 * Panes don't have names, so use number order for any other
284 * sort field.
285 */
286 result = (*a)->id - (*b)->id;
287 }
288 if (window_tree_sort->reversed)
289 result = -result;
290 return (result);
291 }
292
293 static void
294 window_tree_build_pane(struct session *s, struct winlink *wl,
295 struct window_pane *wp, void *modedata, struct mode_tree_item *parent)
296 {
297 struct window_tree_modedata *data = modedata;
298 struct window_tree_itemdata *item;
299 char *name, *text;
300 u_int idx;
301
302 window_pane_index(wp, &idx);
303
304 item = window_tree_add_item(data);
305 item->type = WINDOW_TREE_PANE;
306 item->session = s->id;
307 item->winlink = wl->idx;
308 item->pane = wp->id;
309
310 text = format_single(NULL, data->format, NULL, s, wl, wp);
311 xasprintf(&name, "%u", idx);
312
313 mode_tree_add(data->data, parent, item, (uint64_t)wp, name, text, -1);
314 free(text);
315 free(name);
316 }
317
318 static int
319 window_tree_filter_pane(struct session *s, struct winlink *wl,
320 struct window_pane *wp, const char *filter)
321 {
322 char *cp;
323 int result;
324
325 if (filter == NULL)
326 return (1);
327
328 cp = format_single(NULL, filter, NULL, s, wl, wp);
329 result = format_true(cp);
330 free(cp);
331
332 return (result);
333 }
334
335 static int
336 window_tree_build_window(struct session *s, struct winlink *wl,
337 void *modedata, struct mode_tree_sort_criteria *sort_crit,
338 struct mode_tree_item *parent, const char *filter)
339 {
340 struct window_tree_modedata *data = modedata;
341 struct window_tree_itemdata *item;
342 struct mode_tree_item *mti;
343 char *name, *text;
344 struct window_pane *wp, **l;
345 u_int n, i;
346 int expanded;
347
348 item = window_tree_add_item(data);
349 item->type = WINDOW_TREE_WINDOW;
350 item->session = s->id;
351 item->winlink = wl->idx;
352 item->pane = -1;
353
354 text = format_single(NULL, data->format, NULL, s, wl, NULL);
355 xasprintf(&name, "%u", wl->idx);
356
357 if (data->type == WINDOW_TREE_SESSION ||
358 data->type == WINDOW_TREE_WINDOW)
359 expanded = 0;
360 else
361 expanded = 1;
362 mti = mode_tree_add(data->data, parent, item, (uint64_t)wl, name, text,
363 expanded);
364 free(text);
365 free(name);
366
367 if ((wp = TAILQ_FIRST(&wl->window->panes)) == NULL)
368 goto empty;
369 if (TAILQ_NEXT(wp, entry) == NULL) {
370 if (!window_tree_filter_pane(s, wl, wp, filter))
371 goto empty;
372 return (1);
373 }
374
375 l = NULL;
376 n = 0;
377
378 TAILQ_FOREACH(wp, &wl->window->panes, entry) {
379 if (!window_tree_filter_pane(s, wl, wp, filter))
380 continue;
381 l = xreallocarray(l, n + 1, sizeof *l);
382 l[n++] = wp;
383 }
384 if (n == 0)
385 goto empty;
386
387 window_tree_sort = sort_crit;
388 qsort(l, n, sizeof *l, window_tree_cmp_pane);
389
390 for (i = 0; i < n; i++)
391 window_tree_build_pane(s, wl, l[i], modedata, mti);
392 free(l);
393 return (1);
394
395 empty:
396 window_tree_free_item(item);
397 data->item_size--;
398 mode_tree_remove(data->data, mti);
399 return (0);
400 }
401
402 static void
403 window_tree_build_session(struct session *s, void *modedata,
404 struct mode_tree_sort_criteria *sort_crit, const char *filter)
405 {
406 struct window_tree_modedata *data = modedata;
407 struct window_tree_itemdata *item;
408 struct mode_tree_item *mti;
409 char *text;
410 struct winlink *wl, **l;
411 u_int n, i, empty;
412 int expanded;
413
414 item = window_tree_add_item(data);
415 item->type = WINDOW_TREE_SESSION;
416 item->session = s->id;
417 item->winlink = -1;
418 item->pane = -1;
419
420 text = format_single(NULL, data->format, NULL, s, NULL, NULL);
421
422 if (data->type == WINDOW_TREE_SESSION)
423 expanded = 0;
424 else
425 expanded = 1;
426 mti = mode_tree_add(data->data, NULL, item, (uint64_t)s, s->name, text,
427 expanded);
428 free(text);
429
430 l = NULL;
431 n = 0;
432 RB_FOREACH(wl, winlinks, &s->windows) {
433 l = xreallocarray(l, n + 1, sizeof *l);
434 l[n++] = wl;
435 }
436 window_tree_sort = sort_crit;
437 qsort(l, n, sizeof *l, window_tree_cmp_window);
438
439 empty = 0;
440 for (i = 0; i < n; i++) {
441 if (!window_tree_build_window(s, l[i], modedata, sort_crit, mti,
442 filter))
443 empty++;
444 }
445 if (empty == n) {
446 window_tree_free_item(item);
447 data->item_size--;
448 mode_tree_remove(data->data, mti);
449 }
450 free(l);
451 }
452
453 static void
454 window_tree_build(void *modedata, struct mode_tree_sort_criteria *sort_crit,
455 uint64_t *tag, const char *filter)
456 {
457 struct window_tree_modedata *data = modedata;
458 struct session *s, **l;
459 struct session_group *sg, *current;
460 u_int n, i;
461
462 current = session_group_contains(data->fs.s);
463
464 for (i = 0; i < data->item_size; i++)
465 window_tree_free_item(data->item_list[i]);
466 free(data->item_list);
467 data->item_list = NULL;
468 data->item_size = 0;
469
470 l = NULL;
471 n = 0;
472 RB_FOREACH(s, sessions, &sessions) {
473 if (data->squash_groups &&
474 (sg = session_group_contains(s)) != NULL) {
475 if ((sg == current && s != data->fs.s) ||
476 (sg != current && s != TAILQ_FIRST(&sg->sessions)))
477 continue;
478 }
479 l = xreallocarray(l, n + 1, sizeof *l);
480 l[n++] = s;
481 }
482 window_tree_sort = sort_crit;
483 qsort(l, n, sizeof *l, window_tree_cmp_session);
484
485 for (i = 0; i < n; i++)
486 window_tree_build_session(l[i], modedata, sort_crit, filter);
487 free(l);
488
489 switch (data->type) {
490 case WINDOW_TREE_NONE:
491 break;
492 case WINDOW_TREE_SESSION:
493 *tag = (uint64_t)data->fs.s;
494 break;
495 case WINDOW_TREE_WINDOW:
496 *tag = (uint64_t)data->fs.wl;
497 break;
498 case WINDOW_TREE_PANE:
499 if (window_count_panes(data->fs.wl->window) == 1)
500 *tag = (uint64_t)data->fs.wl;
501 else
502 *tag = (uint64_t)data->fs.wp;
503 break;
504 }
505 }
506
507 static void
508 window_tree_draw_label(struct screen_write_ctx *ctx, u_int px, u_int py,
509 u_int sx, u_int sy, const struct grid_cell *gc, const char *label)
510 {
511 size_t len;
512 u_int ox, oy;
513
514 len = strlen(label);
515 if (sx == 0 || sy == 1 || len > sx)
516 return;
517 ox = (sx - len + 1) / 2;
518 oy = (sy + 1) / 2;
519
520 if (ox > 1 && ox + len < sx - 1 && sy >= 3) {
521 screen_write_cursormove(ctx, px + ox - 1, py + oy - 1, 0);
522 screen_write_box(ctx, len + 2, 3, BOX_LINES_DEFAULT, NULL,
523 NULL);
524 }
525 screen_write_cursormove(ctx, px + ox, py + oy, 0);
526 screen_write_puts(ctx, gc, "%s", label);
527 }
528
529 static void
530 window_tree_draw_session(struct window_tree_modedata *data, struct session *s,
531 struct screen_write_ctx *ctx, u_int sx, u_int sy)
532 {
533 struct options *oo = s->options;
534 struct winlink *wl;
535 struct window *w;
536 u_int cx = ctx->s->cx, cy = ctx->s->cy;
537 u_int loop, total, visible, each, width, offset;
538 u_int current, start, end, remaining, i;
539 struct grid_cell gc;
540 int colour, active_colour, left, right;
541 char *label;
542
543 total = winlink_count(&s->windows);
544
545 memcpy(&gc, &grid_default_cell, sizeof gc);
546 colour = options_get_number(oo, "display-panes-colour");
547 active_colour = options_get_number(oo, "display-panes-active-colour");
548
549 if (sx / total < 24) {
550 visible = sx / 24;
551 if (visible == 0)
552 visible = 1;
553 } else
554 visible = total;
555
556 current = 0;
557 RB_FOREACH(wl, winlinks, &s->windows) {
558 if (wl == s->curw)
559 break;
560 current++;
561 }
562
563 if (current < visible) {
564 start = 0;
565 end = visible;
566 } else if (current >= total - visible) {
567 start = total - visible;
568 end = total;
569 } else {
570 start = current - (visible / 2);
571 end = start + visible;
572 }
573
574 if (data->offset < -(int)start)
575 data->offset = -(int)start;
576 if (data->offset > (int)(total - end))
577 data->offset = (int)(total - end);
578 start += data->offset;
579 end += data->offset;
580
581 left = (start != 0);
582 right = (end != total);
583 if (((left && right) && sx <= 6) || ((left || right) && sx <= 3))
584 left = right = 0;
585 if (left && right) {
586 each = (sx - 6) / visible;
587 remaining = (sx - 6) - (visible * each);
588 } else if (left || right) {
589 each = (sx - 3) / visible;
590 remaining = (sx - 3) - (visible * each);
591 } else {
592 each = sx / visible;
593 remaining = sx - (visible * each);
594 }
595 if (each == 0)
596 return;
597
598 if (left) {
599 data->left = cx + 2;
600 screen_write_cursormove(ctx, cx + 2, cy, 0);
601 screen_write_vline(ctx, sy, 0, 0);
602 screen_write_cursormove(ctx, cx, cy + sy / 2, 0);
603 screen_write_puts(ctx, &grid_default_cell, "<");
604 } else
605 data->left = -1;
606 if (right) {
607 data->right = cx + sx - 3;
608 screen_write_cursormove(ctx, cx + sx - 3, cy, 0);
609 screen_write_vline(ctx, sy, 0, 0);
610 screen_write_cursormove(ctx, cx + sx - 1, cy + sy / 2, 0);
611 screen_write_puts(ctx, &grid_default_cell, ">");
612 } else
613 data->right = -1;
614
615 data->start = start;
616 data->end = end;
617 data->each = each;
618
619 i = loop = 0;
620 RB_FOREACH(wl, winlinks, &s->windows) {
621 if (loop == end)
622 break;
623 if (loop < start) {
624 loop++;
625 continue;
626 }
627 w = wl->window;
628
629 if (wl == s->curw)
630 gc.fg = active_colour;
631 else
632 gc.fg = colour;
633
634 if (left)
635 offset = 3 + (i * each);
636 else
637 offset = (i * each);
638 if (loop == end - 1)
639 width = each + remaining;
640 else
641 width = each - 1;
642
643 screen_write_cursormove(ctx, cx + offset, cy, 0);
644 screen_write_preview(ctx, &w->active->base, width, sy);
645
646 xasprintf(&label, " %u:%s ", wl->idx, w->name);
647 if (strlen(label) > width)
648 xasprintf(&label, " %u ", wl->idx);
649 window_tree_draw_label(ctx, cx + offset, cy, width, sy, &gc,
650 label);
651 free(label);
652
653 if (loop != end - 1) {
654 screen_write_cursormove(ctx, cx + offset + width, cy, 0);
655 screen_write_vline(ctx, sy, 0, 0);
656 }
657 loop++;
658
659 i++;
660 }
661 }
662
663 static void
664 window_tree_draw_window(struct window_tree_modedata *data, struct session *s,
665 struct window *w, struct screen_write_ctx *ctx, u_int sx, u_int sy)
666 {
667 struct options *oo = s->options;
668 struct window_pane *wp;
669 u_int cx = ctx->s->cx, cy = ctx->s->cy;
670 u_int loop, total, visible, each, width, offset;
671 u_int current, start, end, remaining, i;
672 struct grid_cell gc;
673 int colour, active_colour, left, right, pane_idx;
674 char *label;
675
676 total = window_count_panes(w);
677
678 memcpy(&gc, &grid_default_cell, sizeof gc);
679 colour = options_get_number(oo, "display-panes-colour");
680 active_colour = options_get_number(oo, "display-panes-active-colour");
681
682 if (sx / total < 24) {
683 visible = sx / 24;
684 if (visible == 0)
685 visible = 1;
686 } else
687 visible = total;
688
689 current = 0;
690 TAILQ_FOREACH(wp, &w->panes, entry) {
691 if (wp == w->active)
692 break;
693 current++;
694 }
695
696 if (current < visible) {
697 start = 0;
698 end = visible;
699 } else if (current >= total - visible) {
700 start = total - visible;
701 end = total;
702 } else {
703 start = current - (visible / 2);
704 end = start + visible;
705 }
706
707 if (data->offset < -(int)start)
708 data->offset = -(int)start;
709 if (data->offset > (int)(total - end))
710 data->offset = (int)(total - end);
711 start += data->offset;
712 end += data->offset;
713
714 left = (start != 0);
715 right = (end != total);
716 if (((left && right) && sx <= 6) || ((left || right) && sx <= 3))
717 left = right = 0;
718 if (left && right) {
719 each = (sx - 6) / visible;
720 remaining = (sx - 6) - (visible * each);
721 } else if (left || right) {
722 each = (sx - 3) / visible;
723 remaining = (sx - 3) - (visible * each);
724 } else {
725 each = sx / visible;
726 remaining = sx - (visible * each);
727 }
728 if (each == 0)
729 return;
730
731 if (left) {
732 data->left = cx + 2;
733 screen_write_cursormove(ctx, cx + 2, cy, 0);
734 screen_write_vline(ctx, sy, 0, 0);
735 screen_write_cursormove(ctx, cx, cy + sy / 2, 0);
736 screen_write_puts(ctx, &grid_default_cell, "<");
737 } else
738 data->left = -1;
739 if (right) {
740 data->right = cx + sx - 3;
741 screen_write_cursormove(ctx, cx + sx - 3, cy, 0);
742 screen_write_vline(ctx, sy, 0, 0);
743 screen_write_cursormove(ctx, cx + sx - 1, cy + sy / 2, 0);
744 screen_write_puts(ctx, &grid_default_cell, ">");
745 } else
746 data->right = -1;
747
748 data->start = start;
749 data->end = end;
750 data->each = each;
751
752 i = loop = 0;
753 TAILQ_FOREACH(wp, &w->panes, entry) {
754 if (loop == end)
755 break;
756 if (loop < start) {
757 loop++;
758 continue;
759 }
760
761 if (wp == w->active)
762 gc.fg = active_colour;
763 else
764 gc.fg = colour;
765
766 if (left)
767 offset = 3 + (i * each);
768 else
769 offset = (i * each);
770 if (loop == end - 1)
771 width = each + remaining;
772 else
773 width = each - 1;
774
775 screen_write_cursormove(ctx, cx + offset, cy, 0);
776 screen_write_preview(ctx, &wp->base, width, sy);
777
778 if (window_pane_index(wp, &pane_idx) != 0)
779 pane_idx = loop;
780 xasprintf(&label, " %u ", pane_idx);
781 window_tree_draw_label(ctx, cx + offset, cy, each, sy, &gc,
782 label);
783 free(label);
784
785 if (loop != end - 1) {
786 screen_write_cursormove(ctx, cx + offset + width, cy, 0);
787 screen_write_vline(ctx, sy, 0, 0);
788 }
789 loop++;
790
791 i++;
792 }
793 }
794
795 static void
796 window_tree_draw(void *modedata, void *itemdata, struct screen_write_ctx *ctx,
797 u_int sx, u_int sy)
798 {
799 struct window_tree_itemdata *item = itemdata;
800 struct session *sp;
801 struct winlink *wlp;
802 struct window_pane *wp;
803
804 window_tree_pull_item(item, &sp, &wlp, &wp);
805 if (wp == NULL)
806 return;
807
808 switch (item->type) {
809 case WINDOW_TREE_NONE:
810 break;
811 case WINDOW_TREE_SESSION:
812 window_tree_draw_session(modedata, sp, ctx, sx, sy);
813 break;
814 case WINDOW_TREE_WINDOW:
815 window_tree_draw_window(modedata, sp, wlp->window, ctx, sx, sy);
816 break;
817 case WINDOW_TREE_PANE:
818 screen_write_preview(ctx, &wp->base, sx, sy);
819 break;
820 }
821 }
822
823 static int
824 window_tree_search(__unused void *modedata, void *itemdata, const char *ss)
825 {
826 struct window_tree_itemdata *item = itemdata;
827 struct session *s;
828 struct winlink *wl;
829 struct window_pane *wp;
830 char *cmd;
831 int retval;
832
833 window_tree_pull_item(item, &s, &wl, &wp);
834
835 switch (item->type) {
836 case WINDOW_TREE_NONE:
837 return (0);
838 case WINDOW_TREE_SESSION:
839 if (s == NULL)
840 return (0);
841 return (strstr(s->name, ss) != NULL);
842 case WINDOW_TREE_WINDOW:
843 if (s == NULL || wl == NULL)
844 return (0);
845 return (strstr(wl->window->name, ss) != NULL);
846 case WINDOW_TREE_PANE:
847 if (s == NULL || wl == NULL || wp == NULL)
848 break;
849 cmd = get_proc_name(wp->fd, wp->tty);
850 if (cmd == NULL || *cmd == '\0')
851 return (0);
852 retval = (strstr(cmd, ss) != NULL);
853 free(cmd);
854 return (retval);
855 }
856 return (0);
857 }
858
859 static void
860 window_tree_menu(void *modedata, struct client *c, key_code key)
861 {
862 struct window_tree_modedata *data = modedata;
863 struct window_pane *wp = data->wp;
864 struct window_mode_entry *wme;
865
866 wme = TAILQ_FIRST(&wp->modes);
867 if (wme == NULL || wme->data != modedata)
868 return;
869 window_tree_key(wme, c, NULL, NULL, key, NULL);
870 }
871
872 static key_code
873 window_tree_get_key(void *modedata, void *itemdata, u_int line)
874 {
875 struct window_tree_modedata *data = modedata;
876 struct window_tree_itemdata *item = itemdata;
877 struct format_tree *ft;
878 struct session *s;
879 struct winlink *wl;
880 struct window_pane *wp;
881 char *expanded;
882 key_code key;
883
884 ft = format_create(NULL, NULL, FORMAT_NONE, 0);
885 window_tree_pull_item(item, &s, &wl, &wp);
886 if (item->type == WINDOW_TREE_SESSION)
887 format_defaults(ft, NULL, s, NULL, NULL);
888 else if (item->type == WINDOW_TREE_WINDOW)
889 format_defaults(ft, NULL, s, wl, NULL);
890 else
891 format_defaults(ft, NULL, s, wl, wp);
892 format_add(ft, "line", "%u", line);
893
894 expanded = format_expand(ft, data->key_format);
895 key = key_string_lookup_string(expanded);
896 free(expanded);
897 format_free(ft);
898 return key;
899 }
900
901 static struct screen *
902 window_tree_init(struct window_mode_entry *wme, struct cmd_find_state *fs,
903 struct args *args)
904 {
905 struct window_pane *wp = wme->wp;
906 struct window_tree_modedata *data;
907 struct screen *s;
908
909 wme->data = data = xcalloc(1, sizeof *data);
910 data->wp = wp;
911 data->references = 1;
912
913 if (args_has(args, 's'))
914 data->type = WINDOW_TREE_SESSION;
915 else if (args_has(args, 'w'))
916 data->type = WINDOW_TREE_WINDOW;
917 else
918 data->type = WINDOW_TREE_PANE;
919 memcpy(&data->fs, fs, sizeof data->fs);
920
921 if (args == NULL || !args_has(args, 'F'))
922 data->format = xstrdup(WINDOW_TREE_DEFAULT_FORMAT);
923 else
924 data->format = xstrdup(args_get(args, 'F'));
925 if (args == NULL || !args_has(args, 'K'))
926 data->key_format = xstrdup(WINDOW_TREE_DEFAULT_KEY_FORMAT);
927 else
928 data->key_format = xstrdup(args_get(args, 'K'));
929 if (args == NULL || args_count(args) == 0)
930 data->command = xstrdup(WINDOW_TREE_DEFAULT_COMMAND);
931 else
932 data->command = xstrdup(args_string(args, 0));
933 data->squash_groups = !args_has(args, 'G');
934
935 data->data = mode_tree_start(wp, args, window_tree_build,
936 window_tree_draw, window_tree_search, window_tree_menu, NULL,
937 window_tree_get_key, data, window_tree_menu_items,
938 window_tree_sort_list, nitems(window_tree_sort_list), &s);
939 mode_tree_zoom(data->data, args);
940
941 mode_tree_build(data->data);
942 mode_tree_draw(data->data);
943
944 data->type = WINDOW_TREE_NONE;
945
946 return (s);
947 }
948
949 static void
950 window_tree_destroy(struct window_tree_modedata *data)
951 {
952 u_int i;
953
954 if (--data->references != 0)
955 return;
956
957 for (i = 0; i < data->item_size; i++)
958 window_tree_free_item(data->item_list[i]);
959 free(data->item_list);
960
961 free(data->format);
962 free(data->key_format);
963 free(data->command);
964
965 free(data);
966 }
967
968 static void
969 window_tree_free(struct window_mode_entry *wme)
970 {
971 struct window_tree_modedata *data = wme->data;
972
973 if (data == NULL)
974 return;
975
976 data->dead = 1;
977 mode_tree_free(data->data);
978 window_tree_destroy(data);
979 }
980
981 static void
982 window_tree_resize(struct window_mode_entry *wme, u_int sx, u_int sy)
983 {
984 struct window_tree_modedata *data = wme->data;
985
986 mode_tree_resize(data->data, sx, sy);
987 }
988
989 static void
990 window_tree_update(struct window_mode_entry *wme)
991 {
992 struct window_tree_modedata *data = wme->data;
993
994 mode_tree_build(data->data);
995 mode_tree_draw(data->data);
996 data->wp->flags |= PANE_REDRAW;
997 }
998
999 static char *
1000 window_tree_get_target(struct window_tree_itemdata *item,
1001 struct cmd_find_state *fs)
1002 {
1003 struct session *s;
1004 struct winlink *wl;
1005 struct window_pane *wp;
1006 char *target;
1007
1008 window_tree_pull_item(item, &s, &wl, &wp);
1009
1010 target = NULL;
1011 switch (item->type) {
1012 case WINDOW_TREE_NONE:
1013 break;
1014 case WINDOW_TREE_SESSION:
1015 if (s == NULL)
1016 break;
1017 xasprintf(&target, "=%s:", s->name);
1018 break;
1019 case WINDOW_TREE_WINDOW:
1020 if (s == NULL || wl == NULL)
1021 break;
1022 xasprintf(&target, "=%s:%u.", s->name, wl->idx);
1023 break;
1024 case WINDOW_TREE_PANE:
1025 if (s == NULL || wl == NULL || wp == NULL)
1026 break;
1027 xasprintf(&target, "=%s:%u.%%%u", s->name, wl->idx, wp->id);
1028 break;
1029 }
1030 if (target == NULL)
1031 cmd_find_clear_state(fs, 0);
1032 else
1033 cmd_find_from_winlink_pane(fs, wl, wp, 0);
1034 return (target);
1035 }
1036
1037 static void
1038 window_tree_command_each(void *modedata, void *itemdata, struct client *c,
1039 __unused key_code key)
1040 {
1041 struct window_tree_modedata *data = modedata;
1042 struct window_tree_itemdata *item = itemdata;
1043 char *name;
1044 struct cmd_find_state fs;
1045
1046 name = window_tree_get_target(item, &fs);
1047 if (name != NULL)
1048 mode_tree_run_command(c, &fs, data->entered, name);
1049 free(name);
1050 }
1051
1052 static enum cmd_retval
1053 window_tree_command_done(__unused struct cmdq_item *item, void *modedata)
1054 {
1055 struct window_tree_modedata *data = modedata;
1056
1057 if (!data->dead) {
1058 mode_tree_build(data->data);
1059 mode_tree_draw(data->data);
1060 data->wp->flags |= PANE_REDRAW;
1061 }
1062 window_tree_destroy(data);
1063 return (CMD_RETURN_NORMAL);
1064 }
1065
1066 static int
1067 window_tree_command_callback(struct client *c, void *modedata, const char *s,
1068 __unused int done)
1069 {
1070 struct window_tree_modedata *data = modedata;
1071
1072 if (s == NULL || *s == '\0' || data->dead)
1073 return (0);
1074
1075 data->entered = s;
1076 mode_tree_each_tagged(data->data, window_tree_command_each, c,
1077 KEYC_NONE, 1);
1078 data->entered = NULL;
1079
1080 data->references++;
1081 cmdq_append(c, cmdq_get_callback(window_tree_command_done, data));
1082
1083 return (0);
1084 }
1085
1086 static void
1087 window_tree_command_free(void *modedata)
1088 {
1089 struct window_tree_modedata *data = modedata;
1090
1091 window_tree_destroy(data);
1092 }
1093
1094 static void
1095 window_tree_kill_each(__unused void *modedata, void *itemdata,
1096 __unused struct client *c, __unused key_code key)
1097 {
1098 struct window_tree_itemdata *item = itemdata;
1099 struct session *s;
1100 struct winlink *wl;
1101 struct window_pane *wp;
1102
1103 window_tree_pull_item(item, &s, &wl, &wp);
1104
1105 switch (item->type) {
1106 case WINDOW_TREE_NONE:
1107 break;
1108 case WINDOW_TREE_SESSION:
1109 if (s != NULL) {
1110 server_destroy_session(s);
1111 session_destroy(s, 1, __func__);
1112 }
1113 break;
1114 case WINDOW_TREE_WINDOW:
1115 if (wl != NULL)
1116 server_kill_window(wl->window, 0);
1117 break;
1118 case WINDOW_TREE_PANE:
1119 if (wp != NULL)
1120 server_kill_pane(wp);
1121 break;
1122 }
1123 }
1124
1125 static int
1126 window_tree_kill_current_callback(struct client *c, void *modedata,
1127 const char *s, __unused int done)
1128 {
1129 struct window_tree_modedata *data = modedata;
1130 struct mode_tree_data *mtd = data->data;
1131
1132 if (s == NULL || *s == '\0' || data->dead)
1133 return (0);
1134 if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
1135 return (0);
1136
1137 window_tree_kill_each(data, mode_tree_get_current(mtd), c, KEYC_NONE);
1138 server_renumber_all();
1139
1140 data->references++;
1141 cmdq_append(c, cmdq_get_callback(window_tree_command_done, data));
1142
1143 return (0);
1144 }
1145
1146 static int
1147 window_tree_kill_tagged_callback(struct client *c, void *modedata,
1148 const char *s, __unused int done)
1149 {
1150 struct window_tree_modedata *data = modedata;
1151 struct mode_tree_data *mtd = data->data;
1152
1153 if (s == NULL || *s == '\0' || data->dead)
1154 return (0);
1155 if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
1156 return (0);
1157
1158 mode_tree_each_tagged(mtd, window_tree_kill_each, c, KEYC_NONE, 1);
1159 server_renumber_all();
1160
1161 data->references++;
1162 cmdq_append(c, cmdq_get_callback(window_tree_command_done, data));
1163
1164 return (0);
1165 }
1166
1167 static key_code
1168 window_tree_mouse(struct window_tree_modedata *data, key_code key, u_int x,
1169 struct window_tree_itemdata *item)
1170 {
1171 struct session *s;
1172 struct winlink *wl;
1173 struct window_pane *wp;
1174 u_int loop;
1175
1176 if (key != KEYC_MOUSEDOWN1_PANE)
1177 return (KEYC_NONE);
1178
1179 if (data->left != -1 && x <= (u_int)data->left)
1180 return ('<');
1181 if (data->right != -1 && x >= (u_int)data->right)
1182 return ('>');
1183
1184 if (data->left != -1)
1185 x -= data->left;
1186 else if (x != 0)
1187 x--;
1188 if (x == 0 || data->end == 0)
1189 x = 0;
1190 else {
1191 x = x / data->each;
1192 if (data->start + x >= data->end)
1193 x = data->end - 1;
1194 }
1195
1196 window_tree_pull_item(item, &s, &wl, &wp);
1197 if (item->type == WINDOW_TREE_SESSION) {
1198 if (s == NULL)
1199 return (KEYC_NONE);
1200 mode_tree_expand_current(data->data);
1201 loop = 0;
1202 RB_FOREACH(wl, winlinks, &s->windows) {
1203 if (loop == data->start + x)
1204 break;
1205 loop++;
1206 }
1207 if (wl != NULL)
1208 mode_tree_set_current(data->data, (uint64_t)wl);
1209 return ('\r');
1210 }
1211 if (item->type == WINDOW_TREE_WINDOW) {
1212 if (wl == NULL)
1213 return (KEYC_NONE);
1214 mode_tree_expand_current(data->data);
1215 loop = 0;
1216 TAILQ_FOREACH(wp, &wl->window->panes, entry) {
1217 if (loop == data->start + x)
1218 break;
1219 loop++;
1220 }
1221 if (wp != NULL)
1222 mode_tree_set_current(data->data, (uint64_t)wp);
1223 return ('\r');
1224 }
1225 return (KEYC_NONE);
1226 }
1227
1228 static void
1229 window_tree_key(struct window_mode_entry *wme, struct client *c,
1230 __unused struct session *s, __unused struct winlink *wl, key_code key,
1231 struct mouse_event *m)
1232 {
1233 struct window_pane *wp = wme->wp;
1234 struct window_tree_modedata *data = wme->data;
1235 struct window_tree_itemdata *item, *new_item;
1236 char *name, *prompt = NULL;
1237 struct cmd_find_state fs, *fsp = &data->fs;
1238 int finished;
1239 u_int tagged, x, y, idx;
1240 struct session *ns;
1241 struct winlink *nwl;
1242 struct window_pane *nwp;
1243
1244 item = mode_tree_get_current(data->data);
1245 finished = mode_tree_key(data->data, c, &key, m, &x, &y);
1246 if (item != (new_item = mode_tree_get_current(data->data))) {
1247 item = new_item;
1248 data->offset = 0;
1249 }
1250 if (KEYC_IS_MOUSE(key) && m != NULL)
1251 key = window_tree_mouse(data, key, x, item);
1252 switch (key) {
1253 case '<':
1254 data->offset--;
1255 break;
1256 case '>':
1257 data->offset++;
1258 break;
1259 case 'H':
1260 mode_tree_expand(data->data, (uint64_t)fsp->s);
1261 mode_tree_expand(data->data, (uint64_t)fsp->wl);
1262 if (!mode_tree_set_current(data->data, (uint64_t)wme->wp))
1263 mode_tree_set_current(data->data, (uint64_t)fsp->wl);
1264 break;
1265 case 'm':
1266 window_tree_pull_item(item, &ns, &nwl, &nwp);
1267 server_set_marked(ns, nwl, nwp);
1268 mode_tree_build(data->data);
1269 break;
1270 case 'M':
1271 server_clear_marked();
1272 mode_tree_build(data->data);
1273 break;
1274 case 'x':
1275 window_tree_pull_item(item, &ns, &nwl, &nwp);
1276 switch (item->type) {
1277 case WINDOW_TREE_NONE:
1278 break;
1279 case WINDOW_TREE_SESSION:
1280 if (ns == NULL)
1281 break;
1282 xasprintf(&prompt, "Kill session %s? ", ns->name);
1283 break;
1284 case WINDOW_TREE_WINDOW:
1285 if (nwl == NULL)
1286 break;
1287 xasprintf(&prompt, "Kill window %u? ", nwl->idx);
1288 break;
1289 case WINDOW_TREE_PANE:
1290 if (nwp == NULL || window_pane_index(nwp, &idx) != 0)
1291 break;
1292 xasprintf(&prompt, "Kill pane %u? ", idx);
1293 break;
1294 }
1295 if (prompt == NULL)
1296 break;
1297 data->references++;
1298 status_prompt_set(c, NULL, prompt, "",
1299 window_tree_kill_current_callback, window_tree_command_free,
1300 data, PROMPT_SINGLE|PROMPT_NOFORMAT, PROMPT_TYPE_COMMAND);
1301 free(prompt);
1302 break;
1303 case 'X':
1304 tagged = mode_tree_count_tagged(data->data);
1305 if (tagged == 0)
1306 break;
1307 xasprintf(&prompt, "Kill %u tagged? ", tagged);
1308 data->references++;
1309 status_prompt_set(c, NULL, prompt, "",
1310 window_tree_kill_tagged_callback, window_tree_command_free,
1311 data, PROMPT_SINGLE|PROMPT_NOFORMAT, PROMPT_TYPE_COMMAND);
1312 free(prompt);
1313 break;
1314 case ':':
1315 tagged = mode_tree_count_tagged(data->data);
1316 if (tagged != 0)
1317 xasprintf(&prompt, "(%u tagged) ", tagged);
1318 else
1319 xasprintf(&prompt, "(current) ");
1320 data->references++;
1321 status_prompt_set(c, NULL, prompt, "",
1322 window_tree_command_callback, window_tree_command_free,
1323 data, PROMPT_NOFORMAT, PROMPT_TYPE_COMMAND);
1324 free(prompt);
1325 break;
1326 case '\r':
1327 name = window_tree_get_target(item, &fs);
1328 if (name != NULL)
1329 mode_tree_run_command(c, NULL, data->command, name);
1330 finished = 1;
1331 free(name);
1332 break;
1333 }
1334 if (finished)
1335 window_pane_reset_mode(wp);
1336 else {
1337 mode_tree_draw(data->data);
1338 wp->flags |= PANE_REDRAW;
1339 }
1340 }