mirror of
https://github.com/tmux/tmux.git
synced 2026-06-24 04:47:57 +00:00
95afd7549c
is generated and cached in the client: it holds positions and sizes of panes, borders and so on. The scene is invalidated when a pane is moved or resized or relevant option is changed. This scene is then drawn to the client as needed and text and colours are filled in. With Michael Grant.
363 lines
8.9 KiB
C
363 lines
8.9 KiB
C
/* $OpenBSD$ */
|
|
|
|
/*
|
|
* Copyright (c) 2009 Jonathan Alvarado <radobobo@users.sourceforge.net>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
|
|
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "tmux.h"
|
|
|
|
/*
|
|
* Write the entire contents of a pane to a buffer or stdout.
|
|
*/
|
|
|
|
static enum cmd_retval cmd_capture_pane_exec(struct cmd *, struct cmdq_item *);
|
|
|
|
static char *cmd_capture_pane_append(char *, size_t *, const char *,
|
|
size_t);
|
|
static char *cmd_capture_pane_pending(struct args *, struct window_pane *,
|
|
size_t *);
|
|
static char *cmd_capture_pane_history(struct args *, struct cmdq_item *,
|
|
struct window_pane *, size_t *);
|
|
static char *cmd_capture_pane_hyperlinks(struct grid *, struct screen *,
|
|
u_int, u_int *, u_int *, size_t *);
|
|
|
|
const struct cmd_entry cmd_capture_pane_entry = {
|
|
.name = "capture-pane",
|
|
.alias = "capturep",
|
|
|
|
.args = { "ab:CeE:FHJLMNpPqS:Tt:", 0, 0, NULL },
|
|
.usage = "[-aCeFHJLMNpPqT] " CMD_BUFFER_USAGE " [-E end-line] "
|
|
"[-S start-line] " CMD_TARGET_PANE_USAGE,
|
|
|
|
.target = { 't', CMD_FIND_PANE, 0 },
|
|
|
|
.flags = CMD_AFTERHOOK,
|
|
.exec = cmd_capture_pane_exec
|
|
};
|
|
|
|
const struct cmd_entry cmd_clear_history_entry = {
|
|
.name = "clear-history",
|
|
.alias = "clearhist",
|
|
|
|
.args = { "Ht:", 0, 0, NULL },
|
|
.usage = "[-H] " CMD_TARGET_PANE_USAGE,
|
|
|
|
.target = { 't', CMD_FIND_PANE, 0 },
|
|
|
|
.flags = CMD_AFTERHOOK,
|
|
.exec = cmd_capture_pane_exec
|
|
};
|
|
|
|
static char *
|
|
cmd_capture_pane_append(char *buf, size_t *len, const char *line,
|
|
size_t linelen)
|
|
{
|
|
buf = xrealloc(buf, *len + linelen + 1);
|
|
memcpy(buf + *len, line, linelen);
|
|
*len += linelen;
|
|
return (buf);
|
|
}
|
|
|
|
static char *
|
|
cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
|
|
size_t *len)
|
|
{
|
|
struct evbuffer *pending;
|
|
char *buf, *line, tmp[5];
|
|
size_t linelen;
|
|
u_int i;
|
|
|
|
pending = input_pending(wp->ictx);
|
|
if (pending == NULL)
|
|
return (xstrdup(""));
|
|
|
|
line = EVBUFFER_DATA(pending);
|
|
linelen = EVBUFFER_LENGTH(pending);
|
|
|
|
buf = xstrdup("");
|
|
if (args_has(args, 'C')) {
|
|
for (i = 0; i < linelen; i++) {
|
|
if (line[i] >= ' ' && line[i] != '\\') {
|
|
tmp[0] = line[i];
|
|
tmp[1] = '\0';
|
|
} else
|
|
xsnprintf(tmp, sizeof tmp, "\\%03hho", line[i]);
|
|
buf = cmd_capture_pane_append(buf, len, tmp,
|
|
strlen(tmp));
|
|
}
|
|
} else
|
|
buf = cmd_capture_pane_append(buf, len, line, linelen);
|
|
return (buf);
|
|
}
|
|
|
|
static char *
|
|
cmd_capture_pane_hyperlinks(struct grid *gd, struct screen *s, u_int py,
|
|
u_int *links, u_int *nlinks, size_t *len)
|
|
{
|
|
const struct grid_line *gl = grid_peek_line(gd, py);
|
|
struct grid_cell gc;
|
|
const char *uri;
|
|
char *line = xstrdup("");
|
|
u_int i, j;
|
|
|
|
*len = 0;
|
|
|
|
if (s->hyperlinks == NULL || (~gl->flags & GRID_LINE_HYPERLINK))
|
|
return (line);
|
|
|
|
for (i = 0; i < gl->cellused; i++) {
|
|
grid_get_cell(gd, i, py, &gc);
|
|
if (gc.link == 0)
|
|
continue;
|
|
for (j = 0; j < *nlinks; j++) {
|
|
if (links[j] == gc.link)
|
|
break;
|
|
}
|
|
if (j != *nlinks)
|
|
continue;
|
|
|
|
if (!hyperlinks_get(s->hyperlinks, gc.link, &uri, NULL, NULL))
|
|
continue;
|
|
|
|
if (*nlinks == gd->sx)
|
|
break;
|
|
links[(*nlinks)++] = gc.link;
|
|
|
|
if (*len != 0)
|
|
line = cmd_capture_pane_append(line, len, " ", 1);
|
|
line = cmd_capture_pane_append(line, len, uri, strlen(uri));
|
|
}
|
|
return (line);
|
|
}
|
|
|
|
static char *
|
|
cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
|
|
struct window_pane *wp, size_t *len)
|
|
{
|
|
struct grid *gd;
|
|
const struct grid_line *gl;
|
|
struct screen *s;
|
|
struct grid_cell *gc = NULL;
|
|
struct window_mode_entry *wme;
|
|
int n, join_lines, number_lines, flags = 0;
|
|
int show_flags, hyperlinks;
|
|
u_int *links = NULL, nlinks = 0;
|
|
u_int i, sx, top, bottom, tmp;
|
|
char *cause, *buf = NULL, *line, b[64], *cp;
|
|
const char *Sflag, *Eflag;
|
|
size_t linelen;
|
|
|
|
sx = screen_size_x(&wp->base);
|
|
if (args_has(args, 'a')) {
|
|
gd = wp->base.saved_grid;
|
|
if (gd == NULL) {
|
|
if (!args_has(args, 'q')) {
|
|
cmdq_error(item, "no alternate screen");
|
|
return (NULL);
|
|
}
|
|
return (xstrdup(""));
|
|
}
|
|
s = &wp->base;
|
|
} else if (args_has(args, 'M')) {
|
|
wme = TAILQ_FIRST(&wp->modes);
|
|
if (wme != NULL && wme->mode->get_screen != NULL) {
|
|
s = wme->mode->get_screen (wme);
|
|
gd = s->grid;
|
|
} else {
|
|
s = &wp->base;
|
|
gd = wp->base.grid;
|
|
}
|
|
} else {
|
|
s = &wp->base;
|
|
gd = wp->base.grid;
|
|
}
|
|
|
|
Sflag = args_get(args, 'S');
|
|
if (Sflag != NULL && strcmp(Sflag, "-") == 0)
|
|
top = 0;
|
|
else {
|
|
n = args_strtonum_and_expand(args, 'S', INT_MIN, SHRT_MAX,
|
|
item, &cause);
|
|
if (cause != NULL) {
|
|
top = gd->hsize;
|
|
free(cause);
|
|
} else if (n < 0 && (u_int)-n > gd->hsize)
|
|
top = 0;
|
|
else
|
|
top = gd->hsize + n;
|
|
if (top > gd->hsize + gd->sy - 1)
|
|
top = gd->hsize + gd->sy - 1;
|
|
}
|
|
|
|
Eflag = args_get(args, 'E');
|
|
if (Eflag != NULL && strcmp(Eflag, "-") == 0)
|
|
bottom = gd->hsize + gd->sy - 1;
|
|
else {
|
|
n = args_strtonum_and_expand(args, 'E', INT_MIN, SHRT_MAX,
|
|
item, &cause);
|
|
if (cause != NULL) {
|
|
bottom = gd->hsize + gd->sy - 1;
|
|
free(cause);
|
|
} else if (n < 0 && (u_int)-n > gd->hsize)
|
|
bottom = 0;
|
|
else
|
|
bottom = gd->hsize + n;
|
|
if (bottom > gd->hsize + gd->sy - 1)
|
|
bottom = gd->hsize + gd->sy - 1;
|
|
}
|
|
|
|
if (bottom < top) {
|
|
tmp = bottom;
|
|
bottom = top;
|
|
top = tmp;
|
|
}
|
|
|
|
join_lines = args_has(args, 'J');
|
|
if (args_has(args, 'e'))
|
|
flags |= GRID_STRING_WITH_SEQUENCES;
|
|
if (args_has(args, 'C'))
|
|
flags |= GRID_STRING_ESCAPE_SEQUENCES;
|
|
if (!join_lines && !args_has(args, 'T'))
|
|
flags |= GRID_STRING_EMPTY_CELLS;
|
|
if (!join_lines && !args_has(args, 'N'))
|
|
flags |= GRID_STRING_TRIM_SPACES;
|
|
number_lines = args_has(args, 'L');
|
|
show_flags = args_has(args, 'F');
|
|
hyperlinks = args_has(args, 'H');
|
|
if (hyperlinks)
|
|
links = xreallocarray(NULL, gd->sx, sizeof *links);
|
|
|
|
for (i = top; i <= bottom; i++) {
|
|
if (hyperlinks) {
|
|
line = cmd_capture_pane_hyperlinks(gd, s, i, links,
|
|
&nlinks, &linelen);
|
|
} else {
|
|
line = grid_string_cells(gd, 0, i, sx, &gc, flags, s);
|
|
linelen = strlen(line);
|
|
}
|
|
if (hyperlinks && linelen == 0) {
|
|
free(line);
|
|
continue;
|
|
}
|
|
|
|
if (number_lines) {
|
|
if (i >= gd->hsize)
|
|
n = i - gd->hsize;
|
|
else
|
|
n = (int)i - (int)gd->hsize;
|
|
n = snprintf(b, sizeof b, "%d ", n);
|
|
if (n >= 0)
|
|
buf = cmd_capture_pane_append(buf, len, b, n);
|
|
}
|
|
if (show_flags) {
|
|
cp = b;
|
|
*cp = '\0';
|
|
|
|
gl = grid_peek_line(gd, i);
|
|
if (gl->flags & GRID_LINE_DEAD)
|
|
*cp++ = 'D';
|
|
if (gl->flags & GRID_LINE_HYPERLINK)
|
|
*cp++ = 'H';
|
|
if (gl->flags & GRID_LINE_START_OUTPUT)
|
|
*cp++ = 'O';
|
|
if (gl->flags & GRID_LINE_START_PROMPT)
|
|
*cp++ = 'P';
|
|
if (gl->flags & GRID_LINE_WRAPPED)
|
|
*cp++ = 'W';
|
|
if (gl->flags & GRID_LINE_EXTENDED)
|
|
*cp++ = 'X';
|
|
if (b == cp)
|
|
*cp++ = '-';
|
|
*cp++ = ' ';
|
|
*cp = '\0';
|
|
buf = cmd_capture_pane_append(buf, len, b, strlen (b));
|
|
}
|
|
buf = cmd_capture_pane_append(buf, len, line, linelen);
|
|
|
|
gl = grid_peek_line(gd, i);
|
|
if (!join_lines || !(gl->flags & GRID_LINE_WRAPPED))
|
|
buf[(*len)++] = '\n';
|
|
|
|
free(line);
|
|
}
|
|
free(links);
|
|
if (buf == NULL)
|
|
buf = xstrdup("");
|
|
return (buf);
|
|
}
|
|
|
|
static enum cmd_retval
|
|
cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
|
|
{
|
|
struct args *args = cmd_get_args(self);
|
|
struct client *c = cmdq_get_client(item);
|
|
struct window_pane *wp = cmdq_get_target(item)->wp;
|
|
char *buf, *cause;
|
|
const char *bufname;
|
|
size_t len;
|
|
|
|
if (cmd_get_entry(self) == &cmd_clear_history_entry) {
|
|
window_pane_reset_mode_all(wp);
|
|
grid_clear_history(wp->base.grid);
|
|
if (args_has(args, 'H'))
|
|
screen_reset_hyperlinks(wp->screen);
|
|
server_redraw_window(wp->window);
|
|
return (CMD_RETURN_NORMAL);
|
|
}
|
|
|
|
len = 0;
|
|
if (args_has(args, 'P') && !args_has(args, 'H'))
|
|
buf = cmd_capture_pane_pending(args, wp, &len);
|
|
else
|
|
buf = cmd_capture_pane_history(args, item, wp, &len);
|
|
if (buf == NULL)
|
|
return (CMD_RETURN_ERROR);
|
|
|
|
if (args_has(args, 'p')) {
|
|
if (len > 0 && buf[len - 1] == '\n')
|
|
len--;
|
|
if (c->flags & CLIENT_CONTROL)
|
|
control_write(c, "%.*s", (int)len, buf);
|
|
else {
|
|
if (!file_can_print(c)) {
|
|
cmdq_error(item, "can't write to client");
|
|
free(buf);
|
|
return (CMD_RETURN_ERROR);
|
|
}
|
|
file_print_buffer(c, buf, len);
|
|
file_print(c, "\n");
|
|
}
|
|
free(buf);
|
|
} else {
|
|
bufname = NULL;
|
|
if (args_has(args, 'b'))
|
|
bufname = args_get(args, 'b');
|
|
|
|
if (paste_set(buf, len, bufname, &cause) != 0) {
|
|
cmdq_error(item, "%s", cause);
|
|
free(cause);
|
|
free(buf);
|
|
return (CMD_RETURN_ERROR);
|
|
}
|
|
}
|
|
|
|
return (CMD_RETURN_NORMAL);
|
|
}
|