Annotation of src/usr.bin/tmux/popup.c, Revision 1.47
1.47 ! nicm 1: /* $OpenBSD: popup.c,v 1.46 2022/02/22 11:01:57 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.27 nicm 256: if (pd->md != NULL) {
257: c->overlay_check = NULL;
258: c->overlay_data = NULL;
259: menu_draw_cb(c, pd->md, rctx);
260: }
1.1 nicm 261: c->overlay_check = popup_check_cb;
1.27 nicm 262: c->overlay_data = pd;
1.1 nicm 263: }
264:
265: static void
1.27 nicm 266: popup_free_cb(struct client *c, void *data)
1.1 nicm 267: {
1.27 nicm 268: struct popup_data *pd = data;
1.1 nicm 269: struct cmdq_item *item = pd->item;
270:
1.27 nicm 271: if (pd->md != NULL)
272: menu_free_cb(c, pd->md);
273:
1.14 nicm 274: if (pd->cb != NULL)
275: pd->cb(pd->status, pd->arg);
276:
1.1 nicm 277: if (item != NULL) {
1.22 nicm 278: if (cmdq_get_client(item) != NULL &&
1.8 nicm 279: cmdq_get_client(item)->session == NULL)
280: cmdq_get_client(item)->retval = pd->status;
1.1 nicm 281: cmdq_continue(item);
282: }
283: server_client_unref(pd->c);
284:
285: if (pd->job != NULL)
286: job_free(pd->job);
1.22 nicm 287: input_free(pd->ictx);
1.1 nicm 288:
289: screen_free(&pd->s);
1.25 nicm 290: colour_palette_free(&pd->palette);
1.27 nicm 291:
1.39 nicm 292: free(pd->title);
1.1 nicm 293: free(pd);
294: }
295:
296: static void
1.27 nicm 297: popup_resize_cb(__unused struct client *c, void *data)
1.23 nicm 298: {
1.27 nicm 299: struct popup_data *pd = data;
1.23 nicm 300: struct tty *tty = &c->tty;
301:
302: if (pd == NULL)
303: return;
1.27 nicm 304: if (pd->md != NULL)
305: menu_free_cb(c, pd->md);
1.23 nicm 306:
307: /* Adjust position and size. */
308: if (pd->psy > tty->sy)
309: pd->sy = tty->sy;
310: else
311: pd->sy = pd->psy;
312: if (pd->psx > tty->sx)
313: pd->sx = tty->sx;
314: else
315: pd->sx = pd->psx;
316: if (pd->ppy + pd->sy > tty->sy)
317: pd->py = tty->sy - pd->sy;
318: else
319: pd->py = pd->ppy;
320: if (pd->ppx + pd->sx > tty->sx)
321: pd->px = tty->sx - pd->sx;
322: else
323: pd->px = pd->ppx;
324:
325: /* Avoid zero size screens. */
1.41 nicm 326: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 327: screen_resize(&pd->s, pd->sx, pd->sy, 0);
328: if (pd->job != NULL)
329: job_resize(pd->job, pd->sx, pd->sy );
330: } else if (pd->sx > 2 && pd->sy > 2) {
1.23 nicm 331: screen_resize(&pd->s, pd->sx - 2, pd->sy - 2, 0);
332: if (pd->job != NULL)
333: job_resize(pd->job, pd->sx - 2, pd->sy - 2);
334: }
335: }
336:
337: static void
1.29 nicm 338: popup_make_pane(struct popup_data *pd, enum layout_type type)
339: {
340: struct client *c = pd->c;
341: struct session *s = c->session;
342: struct window *w = s->curw->window;
343: struct layout_cell *lc;
344: struct window_pane *wp = w->active, *new_wp;
345: u_int hlimit;
1.30 nicm 346: const char *shell;
1.29 nicm 347:
348: window_unzoom(w);
349:
350: lc = layout_split_pane(wp, type, -1, 0);
351: hlimit = options_get_number(s->options, "history-limit");
352: new_wp = window_add_pane(wp->window, NULL, hlimit, 0);
353: layout_assign_pane(lc, new_wp, 0);
354:
1.30 nicm 355: new_wp->fd = job_transfer(pd->job, &new_wp->pid, new_wp->tty,
356: sizeof new_wp->tty);
1.29 nicm 357: pd->job = NULL;
358:
1.30 nicm 359: screen_set_title(&pd->s, new_wp->base.title);
1.29 nicm 360: screen_free(&new_wp->base);
361: memcpy(&new_wp->base, &pd->s, sizeof wp->base);
362: screen_resize(&new_wp->base, new_wp->sx, new_wp->sy, 1);
363: screen_init(&pd->s, 1, 1, 0);
364:
1.30 nicm 365: shell = options_get_string(s->options, "default-shell");
366: if (!checkshell(shell))
367: shell = _PATH_BSHELL;
368: new_wp->shell = xstrdup(shell);
369:
1.29 nicm 370: window_pane_set_event(new_wp);
371: window_set_active_pane(w, new_wp, 1);
1.30 nicm 372: new_wp->flags |= PANE_CHANGED;
1.29 nicm 373:
374: pd->close = 1;
375: }
376:
377: static void
1.27 nicm 378: popup_menu_done(__unused struct menu *menu, __unused u_int choice,
379: key_code key, void *data)
380: {
381: struct popup_data *pd = data;
382: struct client *c = pd->c;
383: struct paste_buffer *pb;
384: const char *buf;
385: size_t len;
386:
387: pd->md = NULL;
388: pd->menu = NULL;
389: server_redraw_client(pd->c);
390:
391: switch (key) {
392: case 'p':
393: pb = paste_get_top(NULL);
394: if (pb != NULL) {
395: buf = paste_buffer_data(pb, &len);
396: bufferevent_write(job_get_event(pd->job), buf, len);
397: }
398: break;
399: case 'F':
400: pd->sx = c->tty.sx;
401: pd->sy = c->tty.sy;
402: pd->px = 0;
403: pd->py = 0;
404: server_redraw_client(c);
405: break;
406: case 'C':
407: pd->px = c->tty.sx / 2 - pd->sx / 2;
408: pd->py = c->tty.sy / 2 - pd->sy / 2;
409: server_redraw_client(c);
410: break;
1.29 nicm 411: case 'h':
412: popup_make_pane(pd, LAYOUT_LEFTRIGHT);
413: break;
414: case 'v':
415: popup_make_pane(pd, LAYOUT_TOPBOTTOM);
416: break;
1.27 nicm 417: case 'q':
418: pd->close = 1;
419: break;
420: }
421: }
422:
423: static void
1.1 nicm 424: popup_handle_drag(struct client *c, struct popup_data *pd,
425: struct mouse_event *m)
426: {
427: u_int px, py;
428:
429: if (!MOUSE_DRAG(m->b))
430: pd->dragging = OFF;
431: else if (pd->dragging == MOVE) {
432: if (m->x < pd->dx)
433: px = 0;
434: else if (m->x - pd->dx + pd->sx > c->tty.sx)
435: px = c->tty.sx - pd->sx;
436: else
437: px = m->x - pd->dx;
438: if (m->y < pd->dy)
439: py = 0;
440: else if (m->y - pd->dy + pd->sy > c->tty.sy)
441: py = c->tty.sy - pd->sy;
442: else
443: py = m->y - pd->dy;
444: pd->px = px;
445: pd->py = py;
446: pd->dx = m->x - pd->px;
447: pd->dy = m->y - pd->py;
1.23 nicm 448: pd->ppx = px;
449: pd->ppy = py;
1.1 nicm 450: server_redraw_client(c);
451: } else if (pd->dragging == SIZE) {
1.41 nicm 452: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 453: if (m->x < pd->px + 1)
454: return;
455: if (m->y < pd->py + 1)
456: return;
457: } else {
458: if (m->x < pd->px + 3)
459: return;
460: if (m->y < pd->py + 3)
461: return;
462: }
1.1 nicm 463: pd->sx = m->x - pd->px;
464: pd->sy = m->y - pd->py;
1.23 nicm 465: pd->psx = pd->sx;
466: pd->psy = pd->sy;
1.1 nicm 467:
1.41 nicm 468: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 469: screen_resize(&pd->s, pd->sx, pd->sy, 0);
470: if (pd->job != NULL)
471: job_resize(pd->job, pd->sx, pd->sy);
472: } else {
473: screen_resize(&pd->s, pd->sx - 2, pd->sy - 2, 0);
474: if (pd->job != NULL)
475: job_resize(pd->job, pd->sx - 2, pd->sy - 2);
476: }
1.1 nicm 477: server_redraw_client(c);
478: }
479: }
480:
481: static int
1.27 nicm 482: popup_key_cb(struct client *c, void *data, struct key_event *event)
1.1 nicm 483: {
1.27 nicm 484: struct popup_data *pd = data;
1.1 nicm 485: struct mouse_event *m = &event->m;
1.22 nicm 486: const char *buf;
1.6 nicm 487: size_t len;
1.27 nicm 488: u_int px, py, x;
1.32 nicm 489: enum { NONE, LEFT, RIGHT, TOP, BOTTOM } border = NONE;
1.27 nicm 490:
491: if (pd->md != NULL) {
492: if (menu_key_cb(c, pd->md, event) == 1) {
493: pd->md = NULL;
494: pd->menu = NULL;
495: if (pd->close)
496: server_client_clear_overlay(c);
497: else
498: server_redraw_client(c);
499: }
500: return (0);
501: }
1.1 nicm 502:
503: if (KEYC_IS_MOUSE(event->key)) {
504: if (pd->dragging != OFF) {
505: popup_handle_drag(c, pd, m);
506: goto out;
507: }
508: if (m->x < pd->px ||
509: m->x > pd->px + pd->sx - 1 ||
510: m->y < pd->py ||
511: m->y > pd->py + pd->sy - 1) {
1.45 nicm 512: if (MOUSE_BUTTONS(m->b) == MOUSE_BUTTON_3)
1.27 nicm 513: goto menu;
1.1 nicm 514: return (0);
515: }
1.41 nicm 516: if (pd->border_lines != BOX_LINES_NONE) {
1.32 nicm 517: if (m->x == pd->px)
518: border = LEFT;
519: else if (m->x == pd->px + pd->sx - 1)
520: border = RIGHT;
521: else if (m->y == pd->py)
522: border = TOP;
523: else if (m->y == pd->py + pd->sy - 1)
524: border = BOTTOM;
525: }
526: if ((m->b & MOUSE_MASK_MODIFIERS) == 0 &&
1.45 nicm 527: MOUSE_BUTTONS(m->b) == MOUSE_BUTTON_3 &&
1.32 nicm 528: (border == LEFT || border == TOP))
1.27 nicm 529: goto menu;
1.32 nicm 530: if (((m->b & MOUSE_MASK_MODIFIERS) == MOUSE_MASK_META) ||
531: border != NONE) {
1.1 nicm 532: if (!MOUSE_DRAG(m->b))
533: goto out;
1.45 nicm 534: if (MOUSE_BUTTONS(m->lb) == MOUSE_BUTTON_1)
1.1 nicm 535: pd->dragging = MOVE;
1.45 nicm 536: else if (MOUSE_BUTTONS(m->lb) == MOUSE_BUTTON_3)
1.1 nicm 537: pd->dragging = SIZE;
538: pd->dx = m->lx - pd->px;
539: pd->dy = m->ly - pd->py;
540: goto out;
541: }
542: }
1.22 nicm 543: if ((((pd->flags & (POPUP_CLOSEEXIT|POPUP_CLOSEEXITZERO)) == 0) ||
544: pd->job == NULL) &&
545: (event->key == '\033' || event->key == '\003'))
546: return (1);
547: if (pd->job != NULL) {
1.6 nicm 548: if (KEYC_IS_MOUSE(event->key)) {
549: /* Must be inside, checked already. */
1.41 nicm 550: if (pd->border_lines == BOX_LINES_NONE) {
1.26 nicm 551: px = m->x - pd->px;
552: py = m->y - pd->py;
553: } else {
554: px = m->x - pd->px - 1;
555: py = m->y - pd->py - 1;
556: }
557: if (!input_key_get_mouse(&pd->s, m, px, py, &buf, &len))
1.6 nicm 558: return (0);
559: bufferevent_write(job_get_event(pd->job), buf, len);
560: return (0);
561: }
1.18 nicm 562: input_key(&pd->s, job_get_event(pd->job), event->key);
1.1 nicm 563: }
1.22 nicm 564: return (0);
1.27 nicm 565:
566: menu:
567: pd->menu = menu_create("");
1.29 nicm 568: if (pd->flags & POPUP_INTERNAL) {
1.44 nicm 569: menu_add_items(pd->menu, popup_internal_menu_items, NULL, c,
1.29 nicm 570: NULL);
571: } else
1.44 nicm 572: menu_add_items(pd->menu, popup_menu_items, NULL, c, NULL);
1.27 nicm 573: if (m->x >= (pd->menu->width + 4) / 2)
574: x = m->x - (pd->menu->width + 4) / 2;
575: else
576: x = 0;
1.47 ! nicm 577: pd->md = menu_prepare(pd->menu, 0, 0, NULL, x, m->y, c, NULL,
1.27 nicm 578: popup_menu_done, pd);
579: c->flags |= CLIENT_REDRAWOVERLAY;
1.1 nicm 580:
581: out:
582: pd->lx = m->x;
583: pd->ly = m->y;
584: pd->lb = m->b;
585: return (0);
586: }
587:
588: static void
589: popup_job_update_cb(struct job *job)
590: {
591: struct popup_data *pd = job_get_data(job);
592: struct evbuffer *evb = job_get_event(job)->input;
1.15 nicm 593: struct client *c = pd->c;
1.1 nicm 594: struct screen *s = &pd->s;
595: void *data = EVBUFFER_DATA(evb);
596: size_t size = EVBUFFER_LENGTH(evb);
597:
1.15 nicm 598: if (size == 0)
599: return;
600:
1.28 nicm 601: if (pd->md != NULL) {
602: c->overlay_check = menu_check_cb;
603: c->overlay_data = pd->md;
604: } else {
605: c->overlay_check = NULL;
606: c->overlay_data = NULL;
607: }
1.15 nicm 608: input_parse_screen(pd->ictx, s, popup_init_ctx_cb, pd, data, size);
609: c->overlay_check = popup_check_cb;
1.28 nicm 610: c->overlay_data = pd;
1.15 nicm 611:
612: evbuffer_drain(evb, size);
1.1 nicm 613: }
614:
615: static void
616: popup_job_complete_cb(struct job *job)
617: {
618: struct popup_data *pd = job_get_data(job);
619: int status;
620:
621: status = job_get_status(pd->job);
622: if (WIFEXITED(status))
623: pd->status = WEXITSTATUS(status);
624: else if (WIFSIGNALED(status))
625: pd->status = WTERMSIG(status);
626: else
627: pd->status = 0;
628: pd->job = NULL;
629:
1.4 nicm 630: if ((pd->flags & POPUP_CLOSEEXIT) ||
631: ((pd->flags & POPUP_CLOSEEXITZERO) && pd->status == 0))
1.1 nicm 632: server_client_clear_overlay(pd->c);
633: }
634:
635: int
1.38 nicm 636: popup_display(int flags, enum box_lines lines, struct cmdq_item *item, u_int px,
637: u_int py, u_int sx, u_int sy, struct environ *env, const char *shellcmd,
1.39 nicm 638: int argc, char **argv, const char *cwd, const char *title, struct client *c,
1.42 nicm 639: struct session *s, const char* style, const char* border_style,
640: popup_close_cb cb, void *arg)
1.1 nicm 641: {
642: struct popup_data *pd;
1.26 nicm 643: u_int jx, jy;
1.38 nicm 644: struct options *o;
1.42 nicm 645: struct style sytmp;
1.1 nicm 646:
1.41 nicm 647: if (s != NULL)
648: o = s->curw->window->options;
649: else
650: o = c->session->curw->window->options;
651:
652: if (lines == BOX_LINES_DEFAULT)
1.38 nicm 653: lines = options_get_number(o, "popup-border-lines");
654: if (lines == BOX_LINES_NONE) {
1.26 nicm 655: if (sx < 1 || sy < 1)
656: return (-1);
657: jx = sx;
658: jy = sy;
659: } else {
660: if (sx < 3 || sy < 3)
661: return (-1);
662: jx = sx - 2;
663: jy = sy - 2;
664: }
1.1 nicm 665: if (c->tty.sx < sx || c->tty.sy < sy)
666: return (-1);
667:
668: pd = xcalloc(1, sizeof *pd);
669: pd->item = item;
670: pd->flags = flags;
1.43 nicm 671: if (title != NULL)
672: pd->title = xstrdup(title);
1.1 nicm 673:
674: pd->c = c;
675: pd->c->references++;
676:
1.14 nicm 677: pd->cb = cb;
678: pd->arg = arg;
1.1 nicm 679: pd->status = 128 + SIGHUP;
680:
1.41 nicm 681: pd->border_lines = lines;
682: memcpy(&pd->border_cell, &grid_default_cell, sizeof pd->border_cell);
683: style_apply(&pd->border_cell, o, "popup-border-style", NULL);
1.42 nicm 684: if (border_style != NULL) {
685: style_set(&sytmp, &grid_default_cell);
686: if (style_parse(&sytmp, &pd->border_cell, border_style) == 0) {
687: pd->border_cell.fg = sytmp.gc.fg;
688: pd->border_cell.bg = sytmp.gc.bg;
689: }
690: }
1.41 nicm 691: pd->border_cell.attr = 0;
692:
1.46 nicm 693: screen_init(&pd->s, jx, jy, 0);
1.25 nicm 694: colour_palette_init(&pd->palette);
695: colour_palette_from_option(&pd->palette, global_w_options);
1.41 nicm 696:
697: memcpy(&pd->defaults, &grid_default_cell, sizeof pd->defaults);
698: style_apply(&pd->defaults, o, "popup-style", NULL);
1.42 nicm 699: if (style != NULL) {
700: style_set(&sytmp, &grid_default_cell);
701: if (style_parse(&sytmp, &pd->defaults, style) == 0) {
702: pd->defaults.fg = sytmp.gc.fg;
703: pd->defaults.bg = sytmp.gc.bg;
704: }
705: }
1.41 nicm 706: pd->defaults.attr = 0;
1.1 nicm 707:
708: pd->px = px;
709: pd->py = py;
710: pd->sx = sx;
711: pd->sy = sy;
712:
1.23 nicm 713: pd->ppx = px;
714: pd->ppy = py;
715: pd->psx = sx;
716: pd->psy = sy;
717:
1.35 nicm 718: pd->job = job_run(shellcmd, argc, argv, env, s, cwd,
1.22 nicm 719: popup_job_update_cb, popup_job_complete_cb, NULL, pd,
1.26 nicm 720: JOB_NOWAIT|JOB_PTY|JOB_KEEPWRITE, jx, jy);
1.25 nicm 721: pd->ictx = input_init(NULL, job_get_event(pd->job), &pd->palette);
1.1 nicm 722:
723: server_client_set_overlay(c, 0, popup_check_cb, popup_mode_cb,
1.23 nicm 724: popup_draw_cb, popup_key_cb, popup_free_cb, popup_resize_cb, pd);
1.17 nicm 725: return (0);
726: }
727:
728: static void
729: popup_editor_free(struct popup_editor *pe)
730: {
731: unlink(pe->path);
732: free(pe->path);
733: free(pe);
734: }
735:
736: static void
737: popup_editor_close_cb(int status, void *arg)
738: {
739: struct popup_editor *pe = arg;
740: FILE *f;
741: char *buf = NULL;
742: off_t len = 0;
743:
744: if (status != 0) {
745: pe->cb(NULL, 0, pe->arg);
746: popup_editor_free(pe);
747: return;
748: }
749:
750: f = fopen(pe->path, "r");
751: if (f != NULL) {
752: fseeko(f, 0, SEEK_END);
753: len = ftello(f);
754: fseeko(f, 0, SEEK_SET);
755:
756: if (len == 0 ||
757: (uintmax_t)len > (uintmax_t)SIZE_MAX ||
758: (buf = malloc(len)) == NULL ||
759: fread(buf, len, 1, f) != 1) {
760: free(buf);
761: buf = NULL;
762: len = 0;
763: }
764: fclose(f);
765: }
766: pe->cb(buf, len, pe->arg); /* callback now owns buffer */
767: popup_editor_free(pe);
768: }
769:
770: int
771: popup_editor(struct client *c, const char *buf, size_t len,
772: popup_finish_edit_cb cb, void *arg)
773: {
774: struct popup_editor *pe;
775: int fd;
776: FILE *f;
777: char *cmd;
778: char path[] = _PATH_TMP "tmux.XXXXXXXX";
779: const char *editor;
780: u_int px, py, sx, sy;
781:
782: editor = options_get_string(global_options, "editor");
783: if (*editor == '\0')
784: return (-1);
785:
786: fd = mkstemp(path);
787: if (fd == -1)
788: return (-1);
789: f = fdopen(fd, "w");
790: if (fwrite(buf, len, 1, f) != 1) {
791: fclose(f);
792: return (-1);
793: }
794: fclose(f);
795:
796: pe = xcalloc(1, sizeof *pe);
797: pe->path = xstrdup(path);
798: pe->cb = cb;
799: pe->arg = arg;
800:
801: sx = c->tty.sx * 9 / 10;
802: sy = c->tty.sy * 9 / 10;
803: px = (c->tty.sx / 2) - (sx / 2);
804: py = (c->tty.sy / 2) - (sy / 2);
805:
806: xasprintf(&cmd, "%s %s", editor, path);
1.38 nicm 807: if (popup_display(POPUP_INTERNAL|POPUP_CLOSEEXIT, BOX_LINES_DEFAULT,
1.39 nicm 808: NULL, px, py, sx, sy, NULL, cmd, 0, NULL, _PATH_TMP, NULL, c, NULL,
1.42 nicm 809: NULL, NULL, popup_editor_close_cb, pe) != 0) {
1.17 nicm 810: popup_editor_free(pe);
811: free(cmd);
812: return (-1);
813: }
814: free(cmd);
1.1 nicm 815: return (0);
816: }
![[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