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