?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Report error if creating socket fails with -D.
[tmux-openbsd.git] / window-client.c
blob00f36c7c2760d2b8dc9d1c850cc08e3e882420bf
1 /* $OpenBSD$ */
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 #include <sys/time.h>
21
22 #include <stdlib.h>
23 #include <string.h>
24 #include <time.h>
25
26 #include "tmux.h"
27
28 static struct screen *window_client_init(struct window_mode_entry *,
29 struct cmd_find_state *, struct args *);
30 static void window_client_free(struct window_mode_entry *);
31 static void window_client_resize(struct window_mode_entry *, u_int,
32 u_int);
33 static void window_client_update(struct window_mode_entry *);
34 static void window_client_key(struct window_mode_entry *,
35 struct client *, struct session *,
36 struct winlink *, key_code, struct mouse_event *);
37
38 #define WINDOW_CLIENT_DEFAULT_COMMAND "detach-client -t '%%'"
39
40 #define WINDOW_CLIENT_DEFAULT_FORMAT \
41 "#{t/p:client_activity}: session #{session_name}"
42
43 #define WINDOW_CLIENT_DEFAULT_KEY_FORMAT \
44 "#{?#{e|<:#{line},10}," \
45 "#{line}" \
46 "," \
47 "#{?#{e|<:#{line},36}," \
48 "M-#{a:#{e|+:97,#{e|-:#{line},10}}}" \
49 "," \
50 "" \
51 "}" \
52 "}"
53
54 static const struct menu_item window_client_menu_items[] = {
55 { "Detach", 'd', NULL },
56 { "Detach Tagged", 'D', NULL },
57 { "", KEYC_NONE, NULL },
58 { "Tag", 't', NULL },
59 { "Tag All", '\024', NULL },
60 { "Tag None", 'T', NULL },
61 { "", KEYC_NONE, NULL },
62 { "Cancel", 'q', NULL },
63
64 { NULL, KEYC_NONE, NULL }
65 };
66
67 const struct window_mode window_client_mode = {
68 .name = "client-mode",
69 .default_format = WINDOW_CLIENT_DEFAULT_FORMAT,
70
71 .init = window_client_init,
72 .free = window_client_free,
73 .resize = window_client_resize,
74 .update = window_client_update,
75 .key = window_client_key,
76 };
77
78 enum window_client_sort_type {
79 WINDOW_CLIENT_BY_NAME,
80 WINDOW_CLIENT_BY_SIZE,
81 WINDOW_CLIENT_BY_CREATION_TIME,
82 WINDOW_CLIENT_BY_ACTIVITY_TIME,
83 };
84 static const char *window_client_sort_list[] = {
85 "name",
86 "size",
87 "creation",
88 "activity"
89 };
90 static struct mode_tree_sort_criteria *window_client_sort;
91
92 struct window_client_itemdata {
93 struct client *c;
94 };
95
96 struct window_client_modedata {
97 struct window_pane *wp;
98
99 struct mode_tree_data *data;
100 char *format;
101 char *key_format;
102 char *command;
103
104 struct window_client_itemdata **item_list;
105 u_int item_size;
106 };
107
108 static struct window_client_itemdata *
109 window_client_add_item(struct window_client_modedata *data)
110 {
111 struct window_client_itemdata *item;
112
113 data->item_list = xreallocarray(data->item_list, data->item_size + 1,
114 sizeof *data->item_list);
115 item = data->item_list[data->item_size++] = xcalloc(1, sizeof *item);
116 return (item);
117 }
118
119 static void
120 window_client_free_item(struct window_client_itemdata *item)
121 {
122 server_client_unref(item->c);
123 free(item);
124 }
125
126 static int
127 window_client_cmp(const void *a0, const void *b0)
128 {
129 const struct window_client_itemdata *const *a = a0;
130 const struct window_client_itemdata *const *b = b0;
131 const struct window_client_itemdata *itema = *a;
132 const struct window_client_itemdata *itemb = *b;
133 struct client *ca = itema->c;
134 struct client *cb = itemb->c;
135 int result = 0;
136
137 switch (window_client_sort->field) {
138 case WINDOW_CLIENT_BY_SIZE:
139 result = ca->tty.sx - cb->tty.sx;
140 if (result == 0)
141 result = ca->tty.sy - cb->tty.sy;
142 break;
143 case WINDOW_CLIENT_BY_CREATION_TIME:
144 if (timercmp(&ca->creation_time, &cb->creation_time, >))
145 result = -1;
146 else if (timercmp(&ca->creation_time, &cb->creation_time, <))
147 result = 1;
148 break;
149 case WINDOW_CLIENT_BY_ACTIVITY_TIME:
150 if (timercmp(&ca->activity_time, &cb->activity_time, >))
151 result = -1;
152 else if (timercmp(&ca->activity_time, &cb->activity_time, <))
153 result = 1;
154 break;
155 }
156
157 /* Use WINDOW_CLIENT_BY_NAME as default order and tie breaker. */
158 if (result == 0)
159 result = strcmp(ca->name, cb->name);
160
161 if (window_client_sort->reversed)
162 result = -result;
163 return (result);
164 }
165
166 static void
167 window_client_build(void *modedata, struct mode_tree_sort_criteria *sort_crit,
168 __unused uint64_t *tag, const char *filter)
169 {
170 struct window_client_modedata *data = modedata;
171 struct window_client_itemdata *item;
172 u_int i;
173 struct client *c;
174 char *text, *cp;
175
176 for (i = 0; i < data->item_size; i++)
177 window_client_free_item(data->item_list[i]);
178 free(data->item_list);
179 data->item_list = NULL;
180 data->item_size = 0;
181
182 TAILQ_FOREACH(c, &clients, entry) {
183 if (c->session == NULL || (c->flags & CLIENT_UNATTACHEDFLAGS))
184 continue;
185
186 item = window_client_add_item(data);
187 item->c = c;
188
189 c->references++;
190 }
191
192 window_client_sort = sort_crit;
193 qsort(data->item_list, data->item_size, sizeof *data->item_list,
194 window_client_cmp);
195
196 for (i = 0; i < data->item_size; i++) {
197 item = data->item_list[i];
198 c = item->c;
199
200 if (filter != NULL) {
201 cp = format_single(NULL, filter, c, NULL, NULL, NULL);
202 if (!format_true(cp)) {
203 free(cp);
204 continue;
205 }
206 free(cp);
207 }
208
209 text = format_single(NULL, data->format, c, NULL, NULL, NULL);
210 mode_tree_add(data->data, NULL, item, (uint64_t)c, c->name,
211 text, -1);
212 free(text);
213 }
214 }
215
216 static void
217 window_client_draw(__unused void *modedata, void *itemdata,
218 struct screen_write_ctx *ctx, u_int sx, u_int sy)
219 {
220 struct window_client_itemdata *item = itemdata;
221 struct client *c = item->c;
222 struct screen *s = ctx->s;
223 struct window_pane *wp;
224 u_int cx = s->cx, cy = s->cy, lines, at;
225
226 if (c->session == NULL || (c->flags & CLIENT_UNATTACHEDFLAGS))
227 return;
228 wp = c->session->curw->window->active;
229
230 lines = status_line_size(c);
231 if (lines >= sy)
232 lines = 0;
233 if (status_at_line(c) == 0)
234 at = lines;
235 else
236 at = 0;
237
238 screen_write_cursormove(ctx, cx, cy + at, 0);
239 screen_write_preview(ctx, &wp->base, sx, sy - 2 - lines);
240
241 if (at != 0)
242 screen_write_cursormove(ctx, cx, cy + 2, 0);
243 else
244 screen_write_cursormove(ctx, cx, cy + sy - 1 - lines, 0);
245 screen_write_hline(ctx, sx, 0, 0);
246
247 if (at != 0)
248 screen_write_cursormove(ctx, cx, cy, 0);
249 else
250 screen_write_cursormove(ctx, cx, cy + sy - lines, 0);
251 screen_write_fast_copy(ctx, &c->status.screen, 0, 0, sx, lines);
252 }
253
254 static void
255 window_client_menu(void *modedata, struct client *c, key_code key)
256 {
257 struct window_client_modedata *data = modedata;
258 struct window_pane *wp = data->wp;
259 struct window_mode_entry *wme;
260
261 wme = TAILQ_FIRST(&wp->modes);
262 if (wme == NULL || wme->data != modedata)
263 return;
264 window_client_key(wme, c, NULL, NULL, key, NULL);
265 }
266
267 static key_code
268 window_client_get_key(void *modedata, void *itemdata, u_int line)
269 {
270 struct window_client_modedata *data = modedata;
271 struct window_client_itemdata *item = itemdata;
272 struct format_tree *ft;
273 char *expanded;
274 key_code key;
275
276 ft = format_create(NULL, NULL, FORMAT_NONE, 0);
277 format_defaults(ft, item->c, NULL, 0, NULL);
278 format_add(ft, "line", "%u", line);
279
280 expanded = format_expand(ft, data->key_format);
281 key = key_string_lookup_string(expanded);
282 free(expanded);
283 format_free(ft);
284 return key;
285 }
286
287 static struct screen *
288 window_client_init(struct window_mode_entry *wme,
289 __unused struct cmd_find_state *fs, struct args *args)
290 {
291 struct window_pane *wp = wme->wp;
292 struct window_client_modedata *data;
293 struct screen *s;
294
295 wme->data = data = xcalloc(1, sizeof *data);
296 data->wp = wp;
297
298 if (args == NULL || !args_has(args, 'F'))
299 data->format = xstrdup(WINDOW_CLIENT_DEFAULT_FORMAT);
300 else
301 data->format = xstrdup(args_get(args, 'F'));
302 if (args == NULL || !args_has(args, 'K'))
303 data->key_format = xstrdup(WINDOW_CLIENT_DEFAULT_KEY_FORMAT);
304 else
305 data->key_format = xstrdup(args_get(args, 'K'));
306 if (args == NULL || args_count(args) == 0)
307 data->command = xstrdup(WINDOW_CLIENT_DEFAULT_COMMAND);
308 else
309 data->command = xstrdup(args_string(args, 0));
310
311 data->data = mode_tree_start(wp, args, window_client_build,
312 window_client_draw, NULL, window_client_menu, NULL,
313 window_client_get_key, data, window_client_menu_items,
314 window_client_sort_list, nitems(window_client_sort_list), &s);
315 mode_tree_zoom(data->data, args);
316
317 mode_tree_build(data->data);
318 mode_tree_draw(data->data);
319
320 return (s);
321 }
322
323 static void
324 window_client_free(struct window_mode_entry *wme)
325 {
326 struct window_client_modedata *data = wme->data;
327 u_int i;
328
329 if (data == NULL)
330 return;
331
332 mode_tree_free(data->data);
333
334 for (i = 0; i < data->item_size; i++)
335 window_client_free_item(data->item_list[i]);
336 free(data->item_list);
337
338 free(data->format);
339 free(data->key_format);
340 free(data->command);
341
342 free(data);
343 }
344
345 static void
346 window_client_resize(struct window_mode_entry *wme, u_int sx, u_int sy)
347 {
348 struct window_client_modedata *data = wme->data;
349
350 mode_tree_resize(data->data, sx, sy);
351 }
352
353 static void
354 window_client_update(struct window_mode_entry *wme)
355 {
356 struct window_client_modedata *data = wme->data;
357
358 mode_tree_build(data->data);
359 mode_tree_draw(data->data);
360 data->wp->flags |= PANE_REDRAW;
361 }
362
363 static void
364 window_client_do_detach(void *modedata, void *itemdata,
365 __unused struct client *c, key_code key)
366 {
367 struct window_client_modedata *data = modedata;
368 struct window_client_itemdata *item = itemdata;
369
370 if (item == mode_tree_get_current(data->data))
371 mode_tree_down(data->data, 0);
372 if (key == 'd' || key == 'D')
373 server_client_detach(item->c, MSG_DETACH);
374 else if (key == 'x' || key == 'X')
375 server_client_detach(item->c, MSG_DETACHKILL);
376 else if (key == 'z' || key == 'Z')
377 server_client_suspend(item->c);
378 }
379
380 static void
381 window_client_key(struct window_mode_entry *wme, struct client *c,
382 __unused struct session *s, __unused struct winlink *wl, key_code key,
383 struct mouse_event *m)
384 {
385 struct window_pane *wp = wme->wp;
386 struct window_client_modedata *data = wme->data;
387 struct mode_tree_data *mtd = data->data;
388 struct window_client_itemdata *item;
389 int finished;
390
391 finished = mode_tree_key(mtd, c, &key, m, NULL, NULL);
392 switch (key) {
393 case 'd':
394 case 'x':
395 case 'z':
396 item = mode_tree_get_current(mtd);
397 window_client_do_detach(data, item, c, key);
398 mode_tree_build(mtd);
399 break;
400 case 'D':
401 case 'X':
402 case 'Z':
403 mode_tree_each_tagged(mtd, window_client_do_detach, c, key, 0);
404 mode_tree_build(mtd);
405 break;
406 case '\r':
407 item = mode_tree_get_current(mtd);
408 mode_tree_run_command(c, NULL, data->command, item->c->ttyname);
409 finished = 1;
410 break;
411 }
412 if (finished || server_client_how_many() == 0)
413 window_pane_reset_mode(wp);
414 else {
415 mode_tree_draw(mtd);
416 wp->flags |= PANE_REDRAW;
417 }
418 }