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