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