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