Annotation of src/usr.bin/tmux/window-buffer.c, Revision 1.8
1.8 ! nicm 1: /* $OpenBSD: window-buffer.c,v 1.7 2017/06/09 15:29:15 nicm Exp $ */
1.1 nicm 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>
1.2 nicm 23: #include <time.h>
1.1 nicm 24: #include <vis.h>
25:
26: #include "tmux.h"
27:
28: static struct screen *window_buffer_init(struct window_pane *,
29: struct cmd_find_state *, struct args *);
30: static void window_buffer_free(struct window_pane *);
31: static void window_buffer_resize(struct window_pane *, u_int,
32: u_int);
33: static void window_buffer_key(struct window_pane *,
34: struct client *, struct session *, key_code,
35: struct mouse_event *);
36:
37: #define WINDOW_BUFFER_DEFAULT_COMMAND "paste-buffer -b '%%'"
38:
39: const struct window_mode window_buffer_mode = {
40: .name = "buffer-mode",
41:
42: .init = window_buffer_init,
43: .free = window_buffer_free,
44: .resize = window_buffer_resize,
45: .key = window_buffer_key,
46: };
47:
48: enum window_buffer_sort_type {
1.6 nicm 49: WINDOW_BUFFER_BY_TIME,
1.1 nicm 50: WINDOW_BUFFER_BY_NAME,
51: WINDOW_BUFFER_BY_SIZE,
52: };
53: static const char *window_buffer_sort_list[] = {
1.6 nicm 54: "time",
1.1 nicm 55: "name",
56: "size"
57: };
58:
59: struct window_buffer_itemdata {
60: const char *name;
61: time_t created;
62: u_int order;
63: size_t size;
64: };
65:
66: struct window_buffer_modedata {
67: struct mode_tree_data *data;
68: char *command;
69:
70: struct window_buffer_itemdata **item_list;
71: u_int item_size;
72: };
73:
74: static struct window_buffer_itemdata *
75: window_buffer_add_item(struct window_buffer_modedata *data)
76: {
77: struct window_buffer_itemdata *item;
78:
79: data->item_list = xreallocarray(data->item_list, data->item_size + 1,
80: sizeof *data->item_list);
81: item = data->item_list[data->item_size++] = xcalloc(1, sizeof *item);
82: return (item);
83: }
84:
85: static void
86: window_buffer_free_item(struct window_buffer_itemdata *item)
87: {
88: free((void *)item->name);
89: free(item);
90: }
91:
92: static int
93: window_buffer_cmp_name(const void *a0, const void *b0)
94: {
95: const struct window_buffer_itemdata *const *a = a0;
96: const struct window_buffer_itemdata *const *b = b0;
97:
98: return (strcmp((*a)->name, (*b)->name));
99: }
100:
101: static int
102: window_buffer_cmp_time(const void *a0, const void *b0)
103: {
104: const struct window_buffer_itemdata *const *a = a0;
105: const struct window_buffer_itemdata *const *b = b0;
106:
107: if ((*a)->order > (*b)->order)
108: return (-1);
109: if ((*a)->order < (*b)->order)
110: return (1);
111: return (strcmp((*a)->name, (*b)->name));
112: }
113:
114: static int
115: window_buffer_cmp_size(const void *a0, const void *b0)
116: {
117: const struct window_buffer_itemdata *const *a = a0;
118: const struct window_buffer_itemdata *const *b = b0;
119:
120: if ((*a)->size > (*b)->size)
121: return (-1);
122: if ((*a)->size < (*b)->size)
123: return (1);
124: return (strcmp((*a)->name, (*b)->name));
125: }
126:
127: static void
1.8 ! nicm 128: window_buffer_build(void *modedata, u_int sort_type, __unused uint64_t *tag,
! 129: const char *filter)
1.1 nicm 130: {
131: struct window_buffer_modedata *data = modedata;
132: struct window_buffer_itemdata *item;
133: u_int i;
134: struct paste_buffer *pb;
1.8 ! nicm 135: char *tim, *text, *cp;
! 136: struct format_tree *ft;
1.1 nicm 137:
138: for (i = 0; i < data->item_size; i++)
139: window_buffer_free_item(data->item_list[i]);
140: free(data->item_list);
141: data->item_list = NULL;
142: data->item_size = 0;
143:
144: pb = NULL;
145: while ((pb = paste_walk(pb)) != NULL) {
146: item = window_buffer_add_item(data);
147: item->name = xstrdup(paste_buffer_name(pb));
148: item->created = paste_buffer_created(pb);
149: paste_buffer_data(pb, &item->size);
150: item->order = paste_buffer_order(pb);
151: }
152:
153: switch (sort_type) {
154: case WINDOW_BUFFER_BY_NAME:
155: qsort(data->item_list, data->item_size, sizeof *data->item_list,
156: window_buffer_cmp_name);
157: break;
158: case WINDOW_BUFFER_BY_TIME:
159: qsort(data->item_list, data->item_size, sizeof *data->item_list,
160: window_buffer_cmp_time);
161: break;
162: case WINDOW_BUFFER_BY_SIZE:
163: qsort(data->item_list, data->item_size, sizeof *data->item_list,
164: window_buffer_cmp_size);
165: break;
166: }
167:
168: for (i = 0; i < data->item_size; i++) {
169: item = data->item_list[i];
1.8 ! nicm 170:
! 171: if (filter != NULL) {
! 172: pb = paste_get_name(item->name);
! 173: if (pb == NULL)
! 174: continue;
! 175: ft = format_create(NULL, NULL, FORMAT_NONE, 0);
! 176: format_defaults_paste_buffer(ft, pb);
! 177: cp = format_expand(ft, filter);
! 178: if (!format_true(cp)) {
! 179: free(cp);
! 180: format_free(ft);
! 181: continue;
! 182: }
! 183: free(cp);
! 184: format_free(ft);
! 185: }
1.1 nicm 186:
187: tim = ctime(&item->created);
188: *strchr(tim, '\n') = '\0';
189:
190: xasprintf(&text, "%zu bytes (%s)", item->size, tim);
191: mode_tree_add(data->data, NULL, item, item->order, item->name,
192: text, -1);
193: free(text);
194: }
195:
196: }
197:
198: static struct screen *
199: window_buffer_draw(__unused void *modedata, void *itemdata, u_int sx, u_int sy)
200: {
201: struct window_buffer_itemdata *item = itemdata;
202: struct paste_buffer *pb;
203: static struct screen s;
204: struct screen_write_ctx ctx;
205: char line[1024];
206: const char *pdata, *end, *cp;
207: size_t psize, at;
208: u_int i;
209:
210: pb = paste_get_name(item->name);
211: if (pb == NULL)
212: return (NULL);
213:
214: screen_init(&s, sx, sy, 0);
215:
216: screen_write_start(&ctx, NULL, &s);
217: screen_write_clearscreen(&ctx, 8);
218:
1.3 nicm 219: pdata = end = paste_buffer_data(pb, &psize);
1.1 nicm 220: for (i = 0; i < sy; i++) {
221: at = 0;
222: while (end != pdata + psize && *end != '\n') {
223: if ((sizeof line) - at > 5) {
224: cp = vis(line + at, *end, VIS_TAB|VIS_OCTAL, 0);
225: at = cp - line;
226: }
227: end++;
228: }
229: if (at > sx)
230: at = sx;
231: line[at] = '\0';
232:
233: if (*line != '\0') {
234: screen_write_cursormove(&ctx, 0, i);
235: screen_write_puts(&ctx, &grid_default_cell, "%s", line);
236: }
237:
238: if (end == pdata + psize)
239: break;
240: end++;
241: }
242:
243: screen_write_stop(&ctx);
244: return (&s);
245: }
246:
1.4 nicm 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)
1.5 nicm 258: return (1);
1.4 nicm 259: bufdata = paste_buffer_data(pb, &bufsize);
260: return (memmem(bufdata, bufsize, ss, strlen(ss)) != NULL);
261: }
262:
1.1 nicm 263: static struct screen *
264: window_buffer_init(struct window_pane *wp, __unused struct cmd_find_state *fs,
265: struct args *args)
266: {
267: struct window_buffer_modedata *data;
268: struct screen *s;
269:
270: wp->modedata = data = xcalloc(1, sizeof *data);
271:
272: if (args == NULL || args->argc == 0)
273: data->command = xstrdup(WINDOW_BUFFER_DEFAULT_COMMAND);
274: else
275: data->command = xstrdup(args->argv[0]);
276:
1.7 nicm 277: data->data = mode_tree_start(wp, args, window_buffer_build,
1.4 nicm 278: window_buffer_draw, window_buffer_search, data,
279: window_buffer_sort_list, nitems(window_buffer_sort_list), &s);
1.1 nicm 280:
281: mode_tree_build(data->data);
282: mode_tree_draw(data->data);
283:
284: return (s);
285: }
286:
287: static void
288: window_buffer_free(struct window_pane *wp)
289: {
290: struct window_buffer_modedata *data = wp->modedata;
291: u_int i;
292:
293: if (data == NULL)
294: return;
295:
296: mode_tree_free(data->data);
297:
298: for (i = 0; i < data->item_size; i++)
299: window_buffer_free_item(data->item_list[i]);
300: free(data->item_list);
301:
302: free(data->command);
303: free(data);
304: }
305:
306: static void
307: window_buffer_resize(struct window_pane *wp, u_int sx, u_int sy)
308: {
309: struct window_buffer_modedata *data = wp->modedata;
310:
311: mode_tree_resize(data->data, sx, sy);
312: }
313:
314: static void
315: window_buffer_do_delete(void* modedata, void *itemdata, __unused key_code key)
316: {
317: struct window_buffer_modedata *data = modedata;
318: struct window_buffer_itemdata *item = itemdata;
319: struct paste_buffer *pb;
320:
321: if (item == mode_tree_get_current(data->data))
322: mode_tree_down(data->data, 0);
323: if ((pb = paste_get_name(item->name)) != NULL)
324: paste_free(pb);
325: }
326:
327: static void
328: window_buffer_key(struct window_pane *wp, struct client *c,
329: __unused struct session *s, key_code key, struct mouse_event *m)
330: {
331: struct window_buffer_modedata *data = wp->modedata;
332: struct window_buffer_itemdata *item;
333: char *command, *name;
334: int finished;
335:
336: /*
337: * t = toggle tag
338: * T = tag none
339: * C-t = tag all
340: * q = exit
341: * O = change sort order
342: *
343: * d = delete buffer
344: * D = delete tagged buffers
345: * Enter = paste buffer
346: */
347:
1.4 nicm 348: finished = mode_tree_key(data->data, c, &key, m);
1.1 nicm 349: switch (key) {
350: case 'd':
351: item = mode_tree_get_current(data->data);
352: window_buffer_do_delete(data, item, key);
353: mode_tree_build(data->data);
354: break;
355: case 'D':
356: mode_tree_each_tagged(data->data, window_buffer_do_delete, key,
357: 0);
358: mode_tree_build(data->data);
359: break;
360: case '\r':
361: item = mode_tree_get_current(data->data);
362: command = xstrdup(data->command);
363: name = xstrdup(item->name);
364: window_pane_reset_mode(wp);
365: mode_tree_run_command(c, NULL, command, name);
366: free(name);
367: free(command);
368: return;
369: }
370: if (finished || paste_get_top(NULL) == NULL)
371: window_pane_reset_mode(wp);
372: else {
373: mode_tree_draw(data->data);
374: wp->flags |= PANE_REDRAW;
375: }
376: }
![[BACK]](/icons/back.gif){kind=icon}
Return to window-buffer.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux