Annotation of src/usr.bin/tmux/popup.c, Revision 1.51
1.51 ! nicm 1: /* $OpenBSD: popup.c,v 1.50 2023/06/21 06:28:18 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2020 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: #include <sys/wait.h>
21:
1.17 nicm 22: #include <paths.h>
1.1 nicm 23: #include <signal.h>
24: #include <stdlib.h>
25: #include <string.h>
1.17 nicm 26: #include <unistd.h>
1.1 nicm 27:
28: #include "tmux.h"
29:
30: struct popup_data {
31: struct client *c;
32: struct cmdq_item *item;
33: int flags;
1.39 nicm 34: char *title;
1.1 nicm 35:
1.41 nicm 36: struct grid_cell border_cell;
37: enum box_lines border_lines;
38:
1.1 nicm 39: struct screen s;
1.41 nicm 40: struct grid_cell defaults;
1.25 nicm 41: struct colour_palette palette;
1.41 nicm 42:
1.1 nicm 43: struct job *job;
44: struct input_ctx *ictx;
45: int status;
1.14 nicm 46: popup_close_cb cb;
47: void *arg;
1.1 nicm 48:
1.27 nicm 49: struct menu *menu;
50: struct menu_data *md;
51: int close;
52:
1.23 nicm 53: /* Current position and size. */
1.1 nicm 54: u_int px;
55: u_int py;
56: u_int sx;
57: u_int sy;
58:
1.23 nicm 59: /* Preferred position and size. */
60: u_int ppx;
61: u_int ppy;
62: u_int psx;
63: u_int psy;
64:
1.1 nicm 65: enum { OFF, MOVE, SIZE } dragging;
66: u_int dx;
67: u_int dy;
68:
69: u_int lx;
70: u_int ly;
71: u_int lb;
72: };
73:
1.17 nicm 74: struct popup_editor {
75: char *path;
76: popup_finish_edit_cb cb;
77: void *arg;
78: };
79:
1.27 nicm 80: static const struct menu_item popup_menu_items[] = {
81: { "Close", 'q', NULL },
82: { "#{?buffer_name,Paste #[underscore]#{buffer_name},}", 'p', NULL },
83: { "", KEYC_NONE, NULL },
84: { "Fill Space", 'F', NULL },
85: { "Centre", 'C', NULL },
1.29 nicm 86: { "", KEYC_NONE, NULL },
1.30 nicm 87: { "To Horizontal Pane", 'h', NULL },
88: { "To Vertical Pane", 'v', NULL },
1.29 nicm 89:
90: { NULL, KEYC_NONE, NULL }
91: };
92:
93: static const struct menu_item popup_internal_menu_items[] = {
94: { "Close", 'q', NULL },
95: { "", KEYC_NONE, NULL },
96: { "Fill Space", 'F', NULL },
97: { "Centre", 'C', NULL },
1.27 nicm 98:
99: { NULL, KEYC_NONE, NULL }
100: };
101:
1.1 nicm 102: static void
1.15 nicm 103: popup_redraw_cb(const struct tty_ctx *ttyctx)
104: {
105: struct popup_data *pd = ttyctx->arg;
106:
107: pd->c->flags |= CLIENT_REDRAWOVERLAY;
108: }
109:
110: static int
111: popup_set_client_cb(struct tty_ctx *ttyctx, struct client *c)
112: {
113: struct popup_data *pd = ttyctx->arg;
114:
1.16 nicm 115: if (c != pd->c)
116: return (0);
1.15 nicm 117: if (pd->c->flags & CLIENT_REDRAWOVERLAY)
1.16 nicm 118: return (0);
1.15 nicm 119:
120: ttyctx->bigger = 0;
121: ttyctx->wox = 0;
122: ttyctx->woy = 0;
123: ttyctx->wsx = c->tty.sx;
124: ttyctx->wsy = c->tty.sy;
125:
1.41 nicm 126: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 127: ttyctx->xoff = ttyctx->rxoff = pd->px;
128: ttyctx->yoff = ttyctx->ryoff = pd->py;
129: } else {
130: ttyctx->xoff = ttyctx->rxoff = pd->px + 1;
131: ttyctx->yoff = ttyctx->ryoff = pd->py + 1;
132: }
1.15 nicm 133:
134: return (1);
135: }
136:
137: static void
138: popup_init_ctx_cb(struct screen_write_ctx *ctx, struct tty_ctx *ttyctx)
139: {
140: struct popup_data *pd = ctx->arg;
141:
1.41 nicm 142: memcpy(&ttyctx->defaults, &pd->defaults, sizeof ttyctx->defaults);
1.25 nicm 143: ttyctx->palette = &pd->palette;
1.15 nicm 144: ttyctx->redraw_cb = popup_redraw_cb;
145: ttyctx->set_client_cb = popup_set_client_cb;
146: ttyctx->arg = pd;
147: }
148:
149: static struct screen *
1.27 nicm 150: popup_mode_cb(__unused struct client *c, void *data, u_int *cx, u_int *cy)
1.1 nicm 151: {
1.27 nicm 152: struct popup_data *pd = data;
153:
154: if (pd->md != NULL)
155: return (menu_mode_cb(c, pd->md, cx, cy));
1.1 nicm 156:
1.41 nicm 157: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 158: *cx = pd->px + pd->s.cx;
159: *cy = pd->py + pd->s.cy;
160: } else {
161: *cx = pd->px + 1 + pd->s.cx;
162: *cy = pd->py + 1 + pd->s.cy;
163: }
1.15 nicm 164: return (&pd->s);
1.1 nicm 165: }
166:
1.36 nicm 167: /* Return parts of the input range which are not obstructed by the popup. */
168: static void
169: popup_check_cb(struct client* c, void *data, u_int px, u_int py, u_int nx,
170: struct overlay_ranges *r)
1.1 nicm 171: {
1.27 nicm 172: struct popup_data *pd = data;
1.36 nicm 173: struct overlay_ranges or[2];
174: u_int i, j, k = 0;
175:
176: if (pd->md != NULL) {
177: /* Check each returned range for the menu against the popup. */
178: menu_check_cb(c, pd->md, px, py, nx, r);
179: for (i = 0; i < 2; i++) {
180: server_client_overlay_range(pd->px, pd->py, pd->sx,
181: pd->sy, r->px[i], py, r->nx[i], &or[i]);
182: }
183:
184: /*
185: * or has up to OVERLAY_MAX_RANGES non-overlapping ranges,
186: * ordered from left to right. Collect them in the output.
187: */
188: for (i = 0; i < 2; i++) {
189: /* Each or[i] only has 2 ranges. */
190: for (j = 0; j < 2; j++) {
191: if (or[i].nx[j] > 0) {
192: r->px[k] = or[i].px[j];
193: r->nx[k] = or[i].nx[j];
194: k++;
195: }
196: }
197: }
198:
199: /* Zero remaining ranges if any. */
200: for (i = k; i < OVERLAY_MAX_RANGES; i++) {
201: r->px[i] = 0;
202: r->nx[i] = 0;
203: }
1.1 nicm 204:
1.36 nicm 205: return;
206: }
207:
208: server_client_overlay_range(pd->px, pd->py, pd->sx, pd->sy, px, py, nx,
209: r);
1.1 nicm 210: }
211:
212: static void
1.27 nicm 213: popup_draw_cb(struct client *c, void *data, struct screen_redraw_ctx *rctx)
1.1 nicm 214: {
1.27 nicm 215: struct popup_data *pd = data;
1.1 nicm 216: struct tty *tty = &c->tty;
217: struct screen s;
218: struct screen_write_ctx ctx;
219: u_int i, px = pd->px, py = pd->py;
1.25 nicm 220: struct colour_palette *palette = &pd->palette;
1.41 nicm 221: struct grid_cell defaults;
1.1 nicm 222:
223: screen_init(&s, pd->sx, pd->sy, 0);
1.15 nicm 224: screen_write_start(&ctx, &s);
1.1 nicm 225: screen_write_clearscreen(&ctx, 8);
1.23 nicm 226:
1.41 nicm 227: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 228: screen_write_cursormove(&ctx, 0, 0, 0);
229: screen_write_fast_copy(&ctx, &pd->s, 0, 0, pd->sx, pd->sy);
230: } else if (pd->sx > 2 && pd->sy > 2) {
1.41 nicm 231: screen_write_box(&ctx, pd->sx, pd->sy, pd->border_lines,
232: &pd->border_cell, pd->title);
1.23 nicm 233: screen_write_cursormove(&ctx, 1, 1, 0);
234: screen_write_fast_copy(&ctx, &pd->s, 0, 0, pd->sx - 2,
235: pd->sy - 2);
236: }
1.1 nicm 237: screen_write_stop(&ctx);
238:
1.41 nicm 239: memcpy(&defaults, &pd->defaults, sizeof defaults);
1.42 nicm 240: if (defaults.fg == 8)
1.41 nicm 241: defaults.fg = palette->fg;
1.42 nicm 242: if (defaults.bg == 8)
1.41 nicm 243: defaults.bg = palette->bg;
1.25 nicm 244:
1.27 nicm 245: if (pd->md != NULL) {
246: c->overlay_check = menu_check_cb;
247: c->overlay_data = pd->md;
248: } else {
249: c->overlay_check = NULL;
250: c->overlay_data = NULL;
251: }
1.41 nicm 252: for (i = 0; i < pd->sy; i++) {
253: tty_draw_line(tty, &s, 0, i, pd->sx, px, py + i, &defaults,
254: palette);
255: }
1.48 nicm 256: screen_free(&s);
1.27 nicm 257: if (pd->md != NULL) {
258: c->overlay_check = NULL;
259: c->overlay_data = NULL;
260: menu_draw_cb(c, pd->md, rctx);
261: }
1.1 nicm 262: c->overlay_check = popup_check_cb;
1.27 nicm 263: c->overlay_data = pd;
1.1 nicm 264: }
265:
266: static void
1.27 nicm 267: popup_free_cb(struct client *c, void *data)
1.1 nicm 268: {
1.27 nicm 269: struct popup_data *pd = data;
1.1 nicm 270: struct cmdq_item *item = pd->item;
271:
1.27 nicm 272: if (pd->md != NULL)
273: menu_free_cb(c, pd->md);
274:
1.14 nicm 275: if (pd->cb != NULL)
276: pd->cb(pd->status, pd->arg);
277:
1.1 nicm 278: if (item != NULL) {
1.22 nicm 279: if (cmdq_get_client(item) != NULL &&
1.8 nicm 280: cmdq_get_client(item)->session == NULL)
281: cmdq_get_client(item)->retval = pd->status;
1.1 nicm 282: cmdq_continue(item);
283: }
284: server_client_unref(pd->c);
285:
286: if (pd->job != NULL)
287: job_free(pd->job);
1.22 nicm 288: input_free(pd->ictx);
1.1 nicm 289:
290: screen_free(&pd->s);
1.25 nicm 291: colour_palette_free(&pd->palette);
1.27 nicm 292:
1.39 nicm 293: free(pd->title);
1.1 nicm 294: free(pd);
295: }
296:
297: static void
1.27 nicm 298: popup_resize_cb(__unused struct client *c, void *data)
1.23 nicm 299: {
1.27 nicm 300: struct popup_data *pd = data;
1.23 nicm 301: struct tty *tty = &c->tty;
302:
303: if (pd == NULL)
304: return;
1.27 nicm 305: if (pd->md != NULL)
306: menu_free_cb(c, pd->md);
1.23 nicm 307:
308: /* Adjust position and size. */
309: if (pd->psy > tty->sy)
310: pd->sy = tty->sy;
311: else
312: pd->sy = pd->psy;
313: if (pd->psx > tty->sx)
314: pd->sx = tty->sx;
315: else
316: pd->sx = pd->psx;
317: if (pd->ppy + pd->sy > tty->sy)
318: pd->py = tty->sy - pd->sy;
319: else
320: pd->py = pd->ppy;
321: if (pd->ppx + pd->sx > tty->sx)
322: pd->px = tty->sx - pd->sx;
323: else
324: pd->px = pd->ppx;
325:
326: /* Avoid zero size screens. */
1.41 nicm 327: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 328: screen_resize(&pd->s, pd->sx, pd->sy, 0);
329: if (pd->job != NULL)
330: job_resize(pd->job, pd->sx, pd->sy );
331: } else if (pd->sx > 2 && pd->sy > 2) {
1.23 nicm 332: screen_resize(&pd->s, pd->sx - 2, pd->sy - 2, 0);
333: if (pd->job != NULL)
334: job_resize(pd->job, pd->sx - 2, pd->sy - 2);
335: }
336: }
337:
338: static void
1.29 nicm 339: popup_make_pane(struct popup_data *pd, enum layout_type type)
340: {
341: struct client *c = pd->c;
342: struct session *s = c->session;
343: struct window *w = s->curw->window;
344: struct layout_cell *lc;
345: struct window_pane *wp = w->active, *new_wp;
346: u_int hlimit;
1.30 nicm 347: const char *shell;
1.29 nicm 348:
349: window_unzoom(w);
350:
351: lc = layout_split_pane(wp, type, -1, 0);
352: hlimit = options_get_number(s->options, "history-limit");
353: new_wp = window_add_pane(wp->window, NULL, hlimit, 0);
354: layout_assign_pane(lc, new_wp, 0);
355:
1.30 nicm 356: new_wp->fd = job_transfer(pd->job, &new_wp->pid, new_wp->tty,
357: sizeof new_wp->tty);
1.29 nicm 358: pd->job = NULL;
359:
1.30 nicm 360: screen_set_title(&pd->s, new_wp->base.title);
1.29 nicm 361: screen_free(&new_wp->base);
362: memcpy(&new_wp->base, &pd->s, sizeof wp->base);
363: screen_resize(&new_wp->base, new_wp->sx, new_wp->sy, 1);
364: screen_init(&pd->s, 1, 1, 0);
365:
1.30 nicm 366: shell = options_get_string(s->options, "default-shell");
367: if (!checkshell(shell))
368: shell = _PATH_BSHELL;
369: new_wp->shell = xstrdup(shell);
370:
1.29 nicm 371: window_pane_set_event(new_wp);
372: window_set_active_pane(w, new_wp, 1);
1.30 nicm 373: new_wp->flags |= PANE_CHANGED;
1.29 nicm 374:
375: pd->close = 1;
376: }
377:
378: static void
1.27 nicm 379: popup_menu_done(__unused struct menu *menu, __unused u_int choice,
380: key_code key, void *data)
381: {
382: struct popup_data *pd = data;
383: struct client *c = pd->c;
384: struct paste_buffer *pb;
385: const char *buf;
386: size_t len;
387:
388: pd->md = NULL;
389: pd->menu = NULL;
390: server_redraw_client(pd->c);
391:
392: switch (key) {
393: case 'p':
394: pb = paste_get_top(NULL);
395: if (pb != NULL) {
396: buf = paste_buffer_data(pb, &len);
397: bufferevent_write(job_get_event(pd->job), buf, len);
398: }
399: break;
400: case 'F':
401: pd->sx = c->tty.sx;
402: pd->sy = c->tty.sy;
403: pd->px = 0;
404: pd->py = 0;
405: server_redraw_client(c);
406: break;
407: case 'C':
408: pd->px = c->tty.sx / 2 - pd->sx / 2;
409: pd->py = c->tty.sy / 2 - pd->sy / 2;
410: server_redraw_client(c);
411: break;
1.29 nicm 412: case 'h':
413: popup_make_pane(pd, LAYOUT_LEFTRIGHT);
414: break;
415: case 'v':
416: popup_make_pane(pd, LAYOUT_TOPBOTTOM);
417: break;
1.27 nicm 418: case 'q':
419: pd->close = 1;
420: break;
421: }
422: }
423:
424: static void
1.1 nicm 425: popup_handle_drag(struct client *c, struct popup_data *pd,
426: struct mouse_event *m)
427: {
428: u_int px, py;
429:
430: if (!MOUSE_DRAG(m->b))
431: pd->dragging = OFF;
432: else if (pd->dragging == MOVE) {
433: if (m->x < pd->dx)
434: px = 0;
435: else if (m->x - pd->dx + pd->sx > c->tty.sx)
436: px = c->tty.sx - pd->sx;
437: else
438: px = m->x - pd->dx;
439: if (m->y < pd->dy)
440: py = 0;
441: else if (m->y - pd->dy + pd->sy > c->tty.sy)
442: py = c->tty.sy - pd->sy;
443: else
444: py = m->y - pd->dy;
445: pd->px = px;
446: pd->py = py;
447: pd->dx = m->x - pd->px;
448: pd->dy = m->y - pd->py;
1.23 nicm 449: pd->ppx = px;
450: pd->ppy = py;
1.1 nicm 451: server_redraw_client(c);
452: } else if (pd->dragging == SIZE) {
1.41 nicm 453: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 454: if (m->x < pd->px + 1)
455: return;
456: if (m->y < pd->py + 1)
457: return;
458: } else {
459: if (m->x < pd->px + 3)
460: return;
461: if (m->y < pd->py + 3)
462: return;
463: }
1.1 nicm 464: pd->sx = m->x - pd->px;
465: pd->sy = m->y - pd->py;
1.23 nicm 466: pd->psx = pd->sx;
467: pd->psy = pd->sy;
1.1 nicm 468:
1.41 nicm 469: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 470: screen_resize(&pd->s, pd->sx, pd->sy, 0);
471: if (pd->job != NULL)
472: job_resize(pd->job, pd->sx, pd->sy);
473: } else {
474: screen_resize(&pd->s, pd->sx - 2, pd->sy - 2, 0);
475: if (pd->job != NULL)
476: job_resize(pd->job, pd->sx - 2, pd->sy - 2);
477: }
1.1 nicm 478: server_redraw_client(c);
479: }
480: }
481:
482: static int
1.27 nicm 483: popup_key_cb(struct client *c, void *data, struct key_event *event)
1.1 nicm 484: {
1.27 nicm 485: struct popup_data *pd = data;
1.1 nicm 486: struct mouse_event *m = &event->m;
1.22 nicm 487: const char *buf;
1.6 nicm 488: size_t len;
1.27 nicm 489: u_int px, py, x;
1.32 nicm 490: enum { NONE, LEFT, RIGHT, TOP, BOTTOM } border = NONE;
1.27 nicm 491:
492: if (pd->md != NULL) {
493: if (menu_key_cb(c, pd->md, event) == 1) {
494: pd->md = NULL;
495: pd->menu = NULL;
496: if (pd->close)
497: server_client_clear_overlay(c);
498: else
499: server_redraw_client(c);
500: }
501: return (0);
502: }
1.1 nicm 503:
504: if (KEYC_IS_MOUSE(event->key)) {
505: if (pd->dragging != OFF) {
506: popup_handle_drag(c, pd, m);
507: goto out;
508: }
509: if (m->x < pd->px ||
510: m->x > pd->px + pd->sx - 1 ||
511: m->y < pd->py ||
512: m->y > pd->py + pd->sy - 1) {
1.45 nicm 513: if (MOUSE_BUTTONS(m->b) == MOUSE_BUTTON_3)
1.27 nicm 514: goto menu;
1.1 nicm 515: return (0);
516: }
1.41 nicm 517: if (pd->border_lines != BOX_LINES_NONE) {
1.32 nicm 518: if (m->x == pd->px)
519: border = LEFT;
520: else if (m->x == pd->px + pd->sx - 1)
521: border = RIGHT;
522: else if (m->y == pd->py)
523: border = TOP;
524: else if (m->y == pd->py + pd->sy - 1)
525: border = BOTTOM;
526: }
527: if ((m->b & MOUSE_MASK_MODIFIERS) == 0 &&
1.45 nicm 528: MOUSE_BUTTONS(m->b) == MOUSE_BUTTON_3 &&
1.32 nicm 529: (border == LEFT || border == TOP))
1.27 nicm 530: goto menu;
1.32 nicm 531: if (((m->b & MOUSE_MASK_MODIFIERS) == MOUSE_MASK_META) ||
532: border != NONE) {
1.1 nicm 533: if (!MOUSE_DRAG(m->b))
534: goto out;
1.45 nicm 535: if (MOUSE_BUTTONS(m->lb) == MOUSE_BUTTON_1)
1.1 nicm 536: pd->dragging = MOVE;
1.45 nicm 537: else if (MOUSE_BUTTONS(m->lb) == MOUSE_BUTTON_3)
1.1 nicm 538: pd->dragging = SIZE;
539: pd->dx = m->lx - pd->px;
540: pd->dy = m->ly - pd->py;
541: goto out;
542: }
543: }
1.22 nicm 544: if ((((pd->flags & (POPUP_CLOSEEXIT|POPUP_CLOSEEXITZERO)) == 0) ||
545: pd->job == NULL) &&
546: (event->key == '\033' || event->key == '\003'))
547: return (1);
548: if (pd->job != NULL) {
1.6 nicm 549: if (KEYC_IS_MOUSE(event->key)) {
550: /* Must be inside, checked already. */
1.41 nicm 551: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 552: px = m->x - pd->px;
553: py = m->y - pd->py;
554: } else {
555: px = m->x - pd->px - 1;
556: py = m->y - pd->py - 1;
557: }
558: if (!input_key_get_mouse(&pd->s, m, px, py, &buf, &len))
1.6 nicm 559: return (0);
560: bufferevent_write(job_get_event(pd->job), buf, len);
561: return (0);
562: }
1.18 nicm 563: input_key(&pd->s, job_get_event(pd->job), event->key);
1.1 nicm 564: }
1.22 nicm 565: return (0);
1.27 nicm 566:
567: menu:
568: pd->menu = menu_create("");
1.29 nicm 569: if (pd->flags & POPUP_INTERNAL) {
1.44 nicm 570: menu_add_items(pd->menu, popup_internal_menu_items, NULL, c,
1.29 nicm 571: NULL);
572: } else
1.44 nicm 573: menu_add_items(pd->menu, popup_menu_items, NULL, c, NULL);
1.27 nicm 574: if (m->x >= (pd->menu->width + 4) / 2)
575: x = m->x - (pd->menu->width + 4) / 2;
576: else
577: x = 0;
1.51 ! nicm 578: pd->md = menu_prepare(pd->menu, 0, 0, NULL, x, m->y, c,
! 579: BOX_LINES_DEFAULT, NULL, NULL, NULL, popup_menu_done, pd);
1.27 nicm 580: c->flags |= CLIENT_REDRAWOVERLAY;
1.1 nicm 581:
582: out:
583: pd->lx = m->x;
584: pd->ly = m->y;
585: pd->lb = m->b;
586: return (0);
587: }
588:
589: static void
590: popup_job_update_cb(struct job *job)
591: {
592: struct popup_data *pd = job_get_data(job);
593: struct evbuffer *evb = job_get_event(job)->input;
1.15 nicm 594: struct client *c = pd->c;
1.1 nicm 595: struct screen *s = &pd->s;
596: void *data = EVBUFFER_DATA(evb);
597: size_t size = EVBUFFER_LENGTH(evb);
598:
1.15 nicm 599: if (size == 0)
600: return;
601:
1.28 nicm 602: if (pd->md != NULL) {
603: c->overlay_check = menu_check_cb;
604: c->overlay_data = pd->md;
605: } else {
606: c->overlay_check = NULL;
607: c->overlay_data = NULL;
608: }
1.15 nicm 609: input_parse_screen(pd->ictx, s, popup_init_ctx_cb, pd, data, size);
610: c->overlay_check = popup_check_cb;
1.28 nicm 611: c->overlay_data = pd;
1.15 nicm 612:
613: evbuffer_drain(evb, size);
1.1 nicm 614: }
615:
616: static void
617: popup_job_complete_cb(struct job *job)
618: {
619: struct popup_data *pd = job_get_data(job);
620: int status;
621:
622: status = job_get_status(pd->job);
623: if (WIFEXITED(status))
624: pd->status = WEXITSTATUS(status);
625: else if (WIFSIGNALED(status))
626: pd->status = WTERMSIG(status);
627: else
628: pd->status = 0;
629: pd->job = NULL;
630:
1.4 nicm 631: if ((pd->flags & POPUP_CLOSEEXIT) ||
632: ((pd->flags & POPUP_CLOSEEXITZERO) && pd->status == 0))
1.1 nicm 633: server_client_clear_overlay(pd->c);
634: }
635:
636: int
1.38 nicm 637: popup_display(int flags, enum box_lines lines, struct cmdq_item *item, u_int px,
638: u_int py, u_int sx, u_int sy, struct environ *env, const char *shellcmd,
1.39 nicm 639: int argc, char **argv, const char *cwd, const char *title, struct client *c,
1.49 nicm 640: struct session *s, const char *style, const char *border_style,
1.42 nicm 641: popup_close_cb cb, void *arg)
1.1 nicm 642: {
643: struct popup_data *pd;
1.26 nicm 644: u_int jx, jy;
1.38 nicm 645: struct options *o;
1.42 nicm 646: struct style sytmp;
1.1 nicm 647:
1.41 nicm 648: if (s != NULL)
649: o = s->curw->window->options;
650: else
651: o = c->session->curw->window->options;
652:
653: if (lines == BOX_LINES_DEFAULT)
1.38 nicm 654: lines = options_get_number(o, "popup-border-lines");
655: if (lines == BOX_LINES_NONE) {
1.26 nicm 656: if (sx < 1 || sy < 1)
657: return (-1);
658: jx = sx;
659: jy = sy;
660: } else {
661: if (sx < 3 || sy < 3)
662: return (-1);
663: jx = sx - 2;
664: jy = sy - 2;
665: }
1.1 nicm 666: if (c->tty.sx < sx || c->tty.sy < sy)
667: return (-1);
668:
669: pd = xcalloc(1, sizeof *pd);
670: pd->item = item;
671: pd->flags = flags;
1.43 nicm 672: if (title != NULL)
673: pd->title = xstrdup(title);
1.1 nicm 674:
675: pd->c = c;
676: pd->c->references++;
677:
1.14 nicm 678: pd->cb = cb;
679: pd->arg = arg;
1.1 nicm 680: pd->status = 128 + SIGHUP;
681:
1.41 nicm 682: pd->border_lines = lines;
683: memcpy(&pd->border_cell, &grid_default_cell, sizeof pd->border_cell);
684: style_apply(&pd->border_cell, o, "popup-border-style", NULL);
1.42 nicm 685: if (border_style != NULL) {
686: style_set(&sytmp, &grid_default_cell);
687: if (style_parse(&sytmp, &pd->border_cell, border_style) == 0) {
688: pd->border_cell.fg = sytmp.gc.fg;
689: pd->border_cell.bg = sytmp.gc.bg;
690: }
691: }
1.41 nicm 692: pd->border_cell.attr = 0;
693:
1.46 nicm 694: screen_init(&pd->s, jx, jy, 0);
1.25 nicm 695: colour_palette_init(&pd->palette);
696: colour_palette_from_option(&pd->palette, global_w_options);
1.41 nicm 697:
698: memcpy(&pd->defaults, &grid_default_cell, sizeof pd->defaults);
699: style_apply(&pd->defaults, o, "popup-style", NULL);
1.42 nicm 700: if (style != NULL) {
701: style_set(&sytmp, &grid_default_cell);
702: if (style_parse(&sytmp, &pd->defaults, style) == 0) {
703: pd->defaults.fg = sytmp.gc.fg;
704: pd->defaults.bg = sytmp.gc.bg;
705: }
706: }
1.41 nicm 707: pd->defaults.attr = 0;
1.1 nicm 708:
709: pd->px = px;
710: pd->py = py;
711: pd->sx = sx;
712: pd->sy = sy;
713:
1.23 nicm 714: pd->ppx = px;
715: pd->ppy = py;
716: pd->psx = sx;
717: pd->psy = sy;
718:
1.35 nicm 719: pd->job = job_run(shellcmd, argc, argv, env, s, cwd,
1.22 nicm 720: popup_job_update_cb, popup_job_complete_cb, NULL, pd,
1.26 nicm 721: JOB_NOWAIT|JOB_PTY|JOB_KEEPWRITE, jx, jy);
1.25 nicm 722: pd->ictx = input_init(NULL, job_get_event(pd->job), &pd->palette);
1.1 nicm 723:
724: server_client_set_overlay(c, 0, popup_check_cb, popup_mode_cb,
1.23 nicm 725: popup_draw_cb, popup_key_cb, popup_free_cb, popup_resize_cb, pd);
1.17 nicm 726: return (0);
727: }
728:
729: static void
730: popup_editor_free(struct popup_editor *pe)
731: {
732: unlink(pe->path);
733: free(pe->path);
734: free(pe);
735: }
736:
737: static void
738: popup_editor_close_cb(int status, void *arg)
739: {
740: struct popup_editor *pe = arg;
741: FILE *f;
742: char *buf = NULL;
743: off_t len = 0;
744:
745: if (status != 0) {
746: pe->cb(NULL, 0, pe->arg);
747: popup_editor_free(pe);
748: return;
749: }
750:
751: f = fopen(pe->path, "r");
752: if (f != NULL) {
753: fseeko(f, 0, SEEK_END);
754: len = ftello(f);
755: fseeko(f, 0, SEEK_SET);
756:
757: if (len == 0 ||
758: (uintmax_t)len > (uintmax_t)SIZE_MAX ||
759: (buf = malloc(len)) == NULL ||
760: fread(buf, len, 1, f) != 1) {
761: free(buf);
762: buf = NULL;
763: len = 0;
764: }
765: fclose(f);
766: }
767: pe->cb(buf, len, pe->arg); /* callback now owns buffer */
768: popup_editor_free(pe);
769: }
770:
771: int
772: popup_editor(struct client *c, const char *buf, size_t len,
773: popup_finish_edit_cb cb, void *arg)
774: {
775: struct popup_editor *pe;
776: int fd;
777: FILE *f;
778: char *cmd;
779: char path[] = _PATH_TMP "tmux.XXXXXXXX";
780: const char *editor;
781: u_int px, py, sx, sy;
782:
783: editor = options_get_string(global_options, "editor");
784: if (*editor == '\0')
785: return (-1);
786:
787: fd = mkstemp(path);
788: if (fd == -1)
789: return (-1);
790: f = fdopen(fd, "w");
1.50 nicm 791: if (f == NULL)
792: return (-1);
1.17 nicm 793: if (fwrite(buf, len, 1, f) != 1) {
794: fclose(f);
795: return (-1);
796: }
797: fclose(f);
798:
799: pe = xcalloc(1, sizeof *pe);
800: pe->path = xstrdup(path);
801: pe->cb = cb;
802: pe->arg = arg;
803:
804: sx = c->tty.sx * 9 / 10;
805: sy = c->tty.sy * 9 / 10;
806: px = (c->tty.sx / 2) - (sx / 2);
807: py = (c->tty.sy / 2) - (sy / 2);
808:
809: xasprintf(&cmd, "%s %s", editor, path);
1.38 nicm 810: if (popup_display(POPUP_INTERNAL|POPUP_CLOSEEXIT, BOX_LINES_DEFAULT,
1.39 nicm 811: NULL, px, py, sx, sy, NULL, cmd, 0, NULL, _PATH_TMP, NULL, c, NULL,
1.42 nicm 812: NULL, NULL, popup_editor_close_cb, pe) != 0) {
1.17 nicm 813: popup_editor_free(pe);
814: free(cmd);
815: return (-1);
816: }
817: free(cmd);
1.1 nicm 818: return (0);
819: }
![[BACK]](/icons/back.gif){kind=icon}
Return to popup.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux