1 /* $OpenBSD: window-buffer.c,v 1.31 2020/05/16 16:13:09 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2017 Nicholas Marriott <nicholas.marriott@gmail.com> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER 15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 21 #include <stdlib.h> 22 #include <string.h> 23 #include <time.h> 24 #include <unistd.h> 25 #include <vis.h> 26 27 #include "tmux.h" 28 29 static struct screen *window_buffer_init(struct window_mode_entry *, 30 struct cmd_find_state *, struct args *); 31 static void window_buffer_free(struct window_mode_entry *); 32 static void window_buffer_resize(struct window_mode_entry *, u_int, 33 u_int); 34 static void window_buffer_key(struct window_mode_entry *, 35 struct client *, struct session *, 36 struct winlink *, key_code, struct mouse_event *); 37 38 #define WINDOW_BUFFER_DEFAULT_COMMAND "paste-buffer -b '%%'" 39 40 #define WINDOW_BUFFER_DEFAULT_FORMAT \ 41 "#{t/p:buffer_created}: #{buffer_sample}" 42 43 static const struct menu_item window_buffer_menu_items[] = { 44 { "Paste", 'p', NULL }, 45 { "Paste Tagged", 'P', NULL }, 46 { "", KEYC_NONE, NULL }, 47 { "Tag", 't', NULL }, 48 { "Tag All", '\024', NULL }, 49 { "Tag None", 'T', NULL }, 50 { "", KEYC_NONE, NULL }, 51 { "Delete", 'd', NULL }, 52 { "Delete Tagged", 'D', NULL }, 53 { "", KEYC_NONE, NULL }, 54 { "Cancel", 'q', NULL }, 55 56 { NULL, KEYC_NONE, NULL } 57 }; 58 59 const struct window_mode window_buffer_mode = { 60 .name = "buffer-mode", 61 .default_format = WINDOW_BUFFER_DEFAULT_FORMAT, 62 63 .init = window_buffer_init, 64 .free = window_buffer_free, 65 .resize = window_buffer_resize, 66 .key = window_buffer_key, 67 }; 68 69 enum window_buffer_sort_type { 70 WINDOW_BUFFER_BY_TIME, 71 WINDOW_BUFFER_BY_NAME, 72 WINDOW_BUFFER_BY_SIZE, 73 }; 74 static const char *window_buffer_sort_list[] = { 75 "time", 76 "name", 77 "size" 78 }; 79 static struct mode_tree_sort_criteria *window_buffer_sort; 80 81 struct window_buffer_itemdata { 82 const char *name; 83 u_int order; 84 size_t size; 85 }; 86 87 struct window_buffer_modedata { 88 struct window_pane *wp; 89 struct cmd_find_state fs; 90 91 struct mode_tree_data *data; 92 char *command; 93 char *format; 94 95 struct window_buffer_itemdata **item_list; 96 u_int item_size; 97 }; 98 99 struct window_buffer_editdata { 100 u_int wp_id; 101 char *name; 102 struct paste_buffer *pb; 103 }; 104 105 static struct window_buffer_itemdata * 106 window_buffer_add_item(struct window_buffer_modedata *data) 107 { 108 struct window_buffer_itemdata *item; 109 110 data->item_list = xreallocarray(data->item_list, data->item_size + 1, 111 sizeof *data->item_list); 112 item = data->item_list[data->item_size++] = xcalloc(1, sizeof *item); 113 return (item); 114 } 115 116 static void 117 window_buffer_free_item(struct window_buffer_itemdata *item) 118 { 119 free((void *)item->name); 120 free(item); 121 } 122 123 static int 124 window_buffer_cmp(const void *a0, const void *b0) 125 { 126 const struct window_buffer_itemdata *const *a = a0; 127 const struct window_buffer_itemdata *const *b = b0; 128 int result = 0; 129 130 if (window_buffer_sort->field == WINDOW_BUFFER_BY_TIME) 131 result = (*b)->order - (*a)->order; 132 else if (window_buffer_sort->field == WINDOW_BUFFER_BY_SIZE) 133 result = (*b)->size - (*a)->size; 134 135 /* Use WINDOW_BUFFER_BY_NAME as default order and tie breaker. */ 136 if (result == 0) 137 result = strcmp((*a)->name, (*b)->name); 138 139 if (window_buffer_sort->reversed) 140 result = -result; 141 return (result); 142 } 143 144 static void 145 window_buffer_build(void *modedata, struct mode_tree_sort_criteria *sort_crit, 146 __unused uint64_t *tag, const char *filter) 147 { 148 struct window_buffer_modedata *data = modedata; 149 struct window_buffer_itemdata *item; 150 u_int i; 151 struct paste_buffer *pb; 152 char *text, *cp; 153 struct format_tree *ft; 154 struct session *s = NULL; 155 struct winlink *wl = NULL; 156 struct window_pane *wp = NULL; 157 158 for (i = 0; i < data->item_size; i++) 159 window_buffer_free_item(data->item_list[i]); 160 free(data->item_list); 161 data->item_list = NULL; 162 data->item_size = 0; 163 164 pb = NULL; 165 while ((pb = paste_walk(pb)) != NULL) { 166 item = window_buffer_add_item(data); 167 item->name = xstrdup(paste_buffer_name(pb)); 168 paste_buffer_data(pb, &item->size); 169 item->order = paste_buffer_order(pb); 170 } 171 172 window_buffer_sort = sort_crit; 173 qsort(data->item_list, data->item_size, sizeof *data->item_list, 174 window_buffer_cmp); 175 176 if (cmd_find_valid_state(&data->fs)) { 177 s = data->fs.s; 178 wl = data->fs.wl; 179 wp = data->fs.wp; 180 } 181 182 for (i = 0; i < data->item_size; i++) { 183 item = data->item_list[i]; 184 185 pb = paste_get_name(item->name); 186 if (pb == NULL) 187 continue; 188 ft = format_create(NULL, NULL, FORMAT_NONE, 0); 189 format_defaults(ft, NULL, s, wl, wp); 190 format_defaults_paste_buffer(ft, pb); 191 192 if (filter != NULL) { 193 cp = format_expand(ft, filter); 194 if (!format_true(cp)) { 195 free(cp); 196 format_free(ft); 197 continue; 198 } 199 free(cp); 200 } 201 202 text = format_expand(ft, data->format); 203 mode_tree_add(data->data, NULL, item, item->order, item->name, 204 text, -1); 205 free(text); 206 207 format_free(ft); 208 } 209 210 } 211 212 static void 213 window_buffer_draw(__unused void *modedata, void *itemdata, 214 struct screen_write_ctx *ctx, u_int sx, u_int sy) 215 { 216 struct window_buffer_itemdata *item = itemdata; 217 struct paste_buffer *pb; 218 const char *pdata, *start, *end; 219 char *buf = NULL; 220 size_t psize; 221 u_int i, cx = ctx->s->cx, cy = ctx->s->cy; 222 223 pb = paste_get_name(item->name); 224 if (pb == NULL) 225 return; 226 227 pdata = end = paste_buffer_data(pb, &psize); 228 for (i = 0; i < sy; i++) { 229 start = end; 230 while (end != pdata + psize && *end != '\n') 231 end++; 232 buf = xreallocarray(buf, 4, end - start + 1); 233 utf8_strvis(buf, start, end - start, VIS_OCTAL|VIS_CSTYLE|VIS_TAB); 234 if (*buf != '\0') { 235 screen_write_cursormove(ctx, cx, cy + i, 0); 236 screen_write_nputs(ctx, sx, &grid_default_cell, "%s", 237 buf); 238 } 239 240 if (end == pdata + psize) 241 break; 242 end++; 243 } 244 free(buf); 245 } 246 247 static int 248 window_buffer_search(__unused void *modedata, void *itemdata, const char *ss) 249 { 250 struct window_buffer_itemdata *item = itemdata; 251 struct paste_buffer *pb; 252 const char *bufdata; 253 size_t bufsize; 254 255 if ((pb = paste_get_name(item->name)) == NULL) 256 return (0); 257 if (strstr(item->name, ss) != NULL) 258 return (1); 259 bufdata = paste_buffer_data(pb, &bufsize); 260 return (memmem(bufdata, bufsize, ss, strlen(ss)) != NULL); 261 } 262 263 static void 264 window_buffer_menu(void *modedata, struct client *c, key_code key) 265 { 266 struct window_buffer_modedata *data = modedata; 267 struct window_pane *wp = data->wp; 268 struct window_mode_entry *wme; 269 270 wme = TAILQ_FIRST(&wp->modes); 271 if (wme == NULL || wme->data != modedata) 272 return; 273 window_buffer_key(wme, c, NULL, NULL, key, NULL); 274 } 275 276 static struct screen * 277 window_buffer_init(struct window_mode_entry *wme, struct cmd_find_state *fs, 278 struct args *args) 279 { 280 struct window_pane *wp = wme->wp; 281 struct window_buffer_modedata *data; 282 struct screen *s; 283 284 wme->data = data = xcalloc(1, sizeof *data); 285 data->wp = wp; 286 cmd_find_copy_state(&data->fs, fs); 287 288 if (args == NULL || !args_has(args, 'F')) 289 data->format = xstrdup(WINDOW_BUFFER_DEFAULT_FORMAT); 290 else 291 data->format = xstrdup(args_get(args, 'F')); 292 if (args == NULL || args->argc == 0) 293 data->command = xstrdup(WINDOW_BUFFER_DEFAULT_COMMAND); 294 else 295 data->command = xstrdup(args->argv[0]); 296 297 data->data = mode_tree_start(wp, args, window_buffer_build, 298 window_buffer_draw, window_buffer_search, window_buffer_menu, NULL, 299 data, window_buffer_menu_items, window_buffer_sort_list, 300 nitems(window_buffer_sort_list), &s); 301 mode_tree_zoom(data->data, args); 302 303 mode_tree_build(data->data); 304 mode_tree_draw(data->data); 305 306 return (s); 307 } 308 309 static void 310 window_buffer_free(struct window_mode_entry *wme) 311 { 312 struct window_buffer_modedata *data = wme->data; 313 u_int i; 314 315 if (data == NULL) 316 return; 317 318 mode_tree_free(data->data); 319 320 for (i = 0; i < data->item_size; i++) 321 window_buffer_free_item(data->item_list[i]); 322 free(data->item_list); 323 324 free(data->format); 325 free(data->command); 326 327 free(data); 328 } 329 330 static void 331 window_buffer_resize(struct window_mode_entry *wme, u_int sx, u_int sy) 332 { 333 struct window_buffer_modedata *data = wme->data; 334 335 mode_tree_resize(data->data, sx, sy); 336 } 337 338 static void 339 window_buffer_do_delete(void *modedata, void *itemdata, 340 __unused struct client *c, __unused key_code key) 341 { 342 struct window_buffer_modedata *data = modedata; 343 struct window_buffer_itemdata *item = itemdata; 344 struct paste_buffer *pb; 345 346 if (item == mode_tree_get_current(data->data)) 347 mode_tree_down(data->data, 0); 348 if ((pb = paste_get_name(item->name)) != NULL) 349 paste_free(pb); 350 } 351 352 static void 353 window_buffer_do_paste(void *modedata, void *itemdata, struct client *c, 354 __unused key_code key) 355 { 356 struct window_buffer_modedata *data = modedata; 357 struct window_buffer_itemdata *item = itemdata; 358 359 if (paste_get_name(item->name) != NULL) 360 mode_tree_run_command(c, NULL, data->command, item->name); 361 } 362 363 static void 364 window_buffer_finish_edit(struct window_buffer_editdata *ed) 365 { 366 free(ed->name); 367 free(ed); 368 } 369 370 static void 371 window_buffer_edit_close_cb(char *buf, size_t len, void *arg) 372 { 373 struct window_buffer_editdata *ed = arg; 374 size_t oldlen; 375 const char *oldbuf; 376 struct paste_buffer *pb; 377 struct window_pane *wp; 378 struct window_buffer_modedata *data; 379 struct window_mode_entry *wme; 380 381 if (buf == NULL || len == 0) { 382 window_buffer_finish_edit(ed); 383 return; 384 } 385 386 pb = paste_get_name(ed->name); 387 if (pb == NULL || pb != ed->pb) { 388 window_buffer_finish_edit(ed); 389 return; 390 } 391 392 oldbuf = paste_buffer_data(pb, &oldlen); 393 if (oldlen != '\0' && 394 oldbuf[oldlen - 1] != '\n' && 395 buf[len - 1] == '\n') 396 len--; 397 if (len != 0) 398 paste_replace(pb, buf, len); 399 400 wp = window_pane_find_by_id(ed->wp_id); 401 if (wp != NULL) { 402 wme = TAILQ_FIRST(&wp->modes); 403 if (wme->mode == &window_buffer_mode) { 404 data = wme->data; 405 mode_tree_build(data->data); 406 mode_tree_draw(data->data); 407 } 408 wp->flags |= PANE_REDRAW; 409 } 410 window_buffer_finish_edit(ed); 411 } 412 413 static void 414 window_buffer_start_edit(struct window_buffer_modedata *data, 415 struct window_buffer_itemdata *item, struct client *c) 416 { 417 struct paste_buffer *pb; 418 const char *buf; 419 size_t len; 420 struct window_buffer_editdata *ed; 421 422 if ((pb = paste_get_name(item->name)) == NULL) 423 return; 424 buf = paste_buffer_data(pb, &len); 425 426 ed = xcalloc(1, sizeof *ed); 427 ed->wp_id = data->wp->id; 428 ed->name = xstrdup(paste_buffer_name(pb)); 429 ed->pb = pb; 430 431 if (popup_editor(c, buf, len, window_buffer_edit_close_cb, ed) != 0) 432 window_buffer_finish_edit(ed); 433 } 434 435 static void 436 window_buffer_key(struct window_mode_entry *wme, struct client *c, 437 __unused struct session *s, __unused struct winlink *wl, key_code key, 438 struct mouse_event *m) 439 { 440 struct window_pane *wp = wme->wp; 441 struct window_buffer_modedata *data = wme->data; 442 struct mode_tree_data *mtd = data->data; 443 struct window_buffer_itemdata *item; 444 int finished; 445 446 finished = mode_tree_key(mtd, c, &key, m, NULL, NULL); 447 switch (key) { 448 case 'e': 449 item = mode_tree_get_current(mtd); 450 window_buffer_start_edit(data, item, c); 451 break; 452 case 'd': 453 item = mode_tree_get_current(mtd); 454 window_buffer_do_delete(data, item, c, key); 455 mode_tree_build(mtd); 456 break; 457 case 'D': 458 mode_tree_each_tagged(mtd, window_buffer_do_delete, c, key, 0); 459 mode_tree_build(mtd); 460 break; 461 case 'P': 462 mode_tree_each_tagged(mtd, window_buffer_do_paste, c, key, 0); 463 finished = 1; 464 break; 465 case 'p': 466 case '\r': 467 item = mode_tree_get_current(mtd); 468 window_buffer_do_paste(data, item, c, key); 469 finished = 1; 470 break; 471 } 472 if (finished || paste_get_top(NULL) == NULL) 473 window_pane_reset_mode(wp); 474 else { 475 mode_tree_draw(mtd); 476 wp->flags |= PANE_REDRAW; 477 } 478 } 479