mirror of
https://github.com/tmux/tmux.git
synced 2024-12-13 10:08:47 +00:00
3f7f9a0e20
clearer about whether the client is the target client (must have a session) or not.
364 lines
9.1 KiB
C
364 lines
9.1 KiB
C
/* $OpenBSD$ */
|
|
|
|
/*
|
|
* Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
|
|
*
|
|
* 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"
|
|
|
|
/*
|
|
* List key bindings.
|
|
*/
|
|
|
|
static enum cmd_retval cmd_list_keys_exec(struct cmd *, struct cmdq_item *);
|
|
|
|
static enum cmd_retval cmd_list_keys_commands(struct cmd *,
|
|
struct cmdq_item *);
|
|
|
|
const struct cmd_entry cmd_list_keys_entry = {
|
|
.name = "list-keys",
|
|
.alias = "lsk",
|
|
|
|
.args = { "1aNP:T:", 0, 1 },
|
|
.usage = "[-1aN] [-P prefix-string] [-T key-table] [key]",
|
|
|
|
.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
|
|
.exec = cmd_list_keys_exec
|
|
};
|
|
|
|
const struct cmd_entry cmd_list_commands_entry = {
|
|
.name = "list-commands",
|
|
.alias = "lscm",
|
|
|
|
.args = { "F:", 0, 1 },
|
|
.usage = "[-F format] [command]",
|
|
|
|
.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
|
|
.exec = cmd_list_keys_exec
|
|
};
|
|
|
|
static u_int
|
|
cmd_list_keys_get_width(const char *tablename, key_code only)
|
|
{
|
|
struct key_table *table;
|
|
struct key_binding *bd;
|
|
u_int width, keywidth = 0;
|
|
|
|
table = key_bindings_get_table(tablename, 0);
|
|
if (table == NULL)
|
|
return (0);
|
|
bd = key_bindings_first(table);
|
|
while (bd != NULL) {
|
|
if ((only != KEYC_UNKNOWN && bd->key != only) ||
|
|
KEYC_IS_MOUSE(bd->key) ||
|
|
bd->note == NULL) {
|
|
bd = key_bindings_next(table, bd);
|
|
continue;
|
|
}
|
|
width = utf8_cstrwidth(key_string_lookup_key(bd->key));
|
|
if (width > keywidth)
|
|
keywidth = width;
|
|
|
|
bd = key_bindings_next(table, bd);
|
|
}
|
|
return (keywidth);
|
|
}
|
|
|
|
static int
|
|
cmd_list_keys_print_notes(struct cmdq_item *item, struct args *args,
|
|
const char *tablename, u_int keywidth, key_code only, const char *prefix)
|
|
{
|
|
struct client *tc = cmdq_get_target_client(item);
|
|
struct key_table *table;
|
|
struct key_binding *bd;
|
|
const char *key;
|
|
char *tmp, *note;
|
|
int found = 0;
|
|
|
|
table = key_bindings_get_table(tablename, 0);
|
|
if (table == NULL)
|
|
return (0);
|
|
bd = key_bindings_first(table);
|
|
while (bd != NULL) {
|
|
if ((only != KEYC_UNKNOWN && bd->key != only) ||
|
|
KEYC_IS_MOUSE(bd->key) ||
|
|
(bd->note == NULL && !args_has(args, 'a'))) {
|
|
bd = key_bindings_next(table, bd);
|
|
continue;
|
|
}
|
|
found = 1;
|
|
key = key_string_lookup_key(bd->key);
|
|
|
|
if (bd->note == NULL)
|
|
note = cmd_list_print(bd->cmdlist, 1);
|
|
else
|
|
note = xstrdup(bd->note);
|
|
tmp = utf8_padcstr(key, keywidth + 1);
|
|
if (args_has(args, '1') && tc != NULL)
|
|
status_message_set(tc, "%s%s%s", prefix, tmp, note);
|
|
else
|
|
cmdq_print(item, "%s%s%s", prefix, tmp, note);
|
|
free(tmp);
|
|
free(note);
|
|
|
|
if (args_has(args, '1'))
|
|
break;
|
|
bd = key_bindings_next(table, bd);
|
|
}
|
|
return (found);
|
|
}
|
|
|
|
static char *
|
|
cmd_list_keys_get_prefix(struct args *args, key_code *prefix)
|
|
{
|
|
char *s;
|
|
|
|
*prefix = options_get_number(global_s_options, "prefix");
|
|
if (!args_has(args, 'P')) {
|
|
if (*prefix != KEYC_NONE)
|
|
xasprintf(&s, "%s ", key_string_lookup_key(*prefix));
|
|
else
|
|
s = xstrdup("");
|
|
} else
|
|
s = xstrdup(args_get(args, 'P'));
|
|
return (s);
|
|
}
|
|
|
|
static enum cmd_retval
|
|
cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
|
|
{
|
|
struct args *args = cmd_get_args(self);
|
|
struct key_table *table;
|
|
struct key_binding *bd;
|
|
const char *tablename, *r;
|
|
char *key, *cp, *tmp, *start, *empty;
|
|
key_code prefix, only = KEYC_UNKNOWN;
|
|
int repeat, width, tablewidth, keywidth, found = 0;
|
|
size_t tmpsize, tmpused, cplen;
|
|
|
|
if (cmd_get_entry(self) == &cmd_list_commands_entry)
|
|
return (cmd_list_keys_commands(self, item));
|
|
|
|
if (args->argc != 0) {
|
|
only = key_string_lookup_string(args->argv[0]);
|
|
if (only == KEYC_UNKNOWN) {
|
|
cmdq_error(item, "invalid key: %s", args->argv[0]);
|
|
return (CMD_RETURN_ERROR);
|
|
}
|
|
}
|
|
|
|
tablename = args_get(args, 'T');
|
|
if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
|
|
cmdq_error(item, "table %s doesn't exist", tablename);
|
|
return (CMD_RETURN_ERROR);
|
|
}
|
|
|
|
if (args_has(args, 'N')) {
|
|
if (tablename == NULL) {
|
|
start = cmd_list_keys_get_prefix(args, &prefix);
|
|
keywidth = cmd_list_keys_get_width("root", only);
|
|
if (prefix != KEYC_NONE) {
|
|
width = cmd_list_keys_get_width("prefix", only);
|
|
if (width == 0)
|
|
prefix = KEYC_NONE;
|
|
else if (width > keywidth)
|
|
keywidth = width;
|
|
}
|
|
empty = utf8_padcstr("", utf8_cstrwidth(start));
|
|
|
|
found = cmd_list_keys_print_notes(item, args, "root",
|
|
keywidth, only, empty);
|
|
if (prefix != KEYC_NONE) {
|
|
if (cmd_list_keys_print_notes(item, args,
|
|
"prefix", keywidth, only, start))
|
|
found = 1;
|
|
}
|
|
free(empty);
|
|
} else {
|
|
if (args_has(args, 'P'))
|
|
start = xstrdup(args_get(args, 'P'));
|
|
else
|
|
start = xstrdup("");
|
|
keywidth = cmd_list_keys_get_width(tablename, only);
|
|
found = cmd_list_keys_print_notes(item, args, tablename,
|
|
keywidth, only, start);
|
|
|
|
}
|
|
free(start);
|
|
goto out;
|
|
}
|
|
|
|
repeat = 0;
|
|
tablewidth = keywidth = 0;
|
|
table = key_bindings_first_table ();
|
|
while (table != NULL) {
|
|
if (tablename != NULL && strcmp(table->name, tablename) != 0) {
|
|
table = key_bindings_next_table(table);
|
|
continue;
|
|
}
|
|
bd = key_bindings_first(table);
|
|
while (bd != NULL) {
|
|
if (only != KEYC_UNKNOWN && bd->key != only) {
|
|
bd = key_bindings_next(table, bd);
|
|
continue;
|
|
}
|
|
key = args_escape(key_string_lookup_key(bd->key));
|
|
|
|
if (bd->flags & KEY_BINDING_REPEAT)
|
|
repeat = 1;
|
|
|
|
width = utf8_cstrwidth(table->name);
|
|
if (width > tablewidth)
|
|
tablewidth = width;
|
|
width = utf8_cstrwidth(key);
|
|
if (width > keywidth)
|
|
keywidth = width;
|
|
|
|
free(key);
|
|
bd = key_bindings_next(table, bd);
|
|
}
|
|
table = key_bindings_next_table(table);
|
|
}
|
|
|
|
tmpsize = 256;
|
|
tmp = xmalloc(tmpsize);
|
|
|
|
table = key_bindings_first_table ();
|
|
while (table != NULL) {
|
|
if (tablename != NULL && strcmp(table->name, tablename) != 0) {
|
|
table = key_bindings_next_table(table);
|
|
continue;
|
|
}
|
|
bd = key_bindings_first(table);
|
|
while (bd != NULL) {
|
|
if (only != KEYC_UNKNOWN && bd->key != only) {
|
|
bd = key_bindings_next(table, bd);
|
|
continue;
|
|
}
|
|
found = 1;
|
|
key = args_escape(key_string_lookup_key(bd->key));
|
|
|
|
if (!repeat)
|
|
r = "";
|
|
else if (bd->flags & KEY_BINDING_REPEAT)
|
|
r = "-r ";
|
|
else
|
|
r = " ";
|
|
tmpused = xsnprintf(tmp, tmpsize, "%s-T ", r);
|
|
|
|
cp = utf8_padcstr(table->name, tablewidth);
|
|
cplen = strlen(cp) + 1;
|
|
while (tmpused + cplen + 1 >= tmpsize) {
|
|
tmpsize *= 2;
|
|
tmp = xrealloc(tmp, tmpsize);
|
|
}
|
|
strlcat(tmp, cp, tmpsize);
|
|
tmpused = strlcat(tmp, " ", tmpsize);
|
|
free(cp);
|
|
|
|
cp = utf8_padcstr(key, keywidth);
|
|
cplen = strlen(cp) + 1;
|
|
while (tmpused + cplen + 1 >= tmpsize) {
|
|
tmpsize *= 2;
|
|
tmp = xrealloc(tmp, tmpsize);
|
|
}
|
|
strlcat(tmp, cp, tmpsize);
|
|
tmpused = strlcat(tmp, " ", tmpsize);
|
|
free(cp);
|
|
|
|
cp = cmd_list_print(bd->cmdlist, 1);
|
|
cplen = strlen(cp);
|
|
while (tmpused + cplen + 1 >= tmpsize) {
|
|
tmpsize *= 2;
|
|
tmp = xrealloc(tmp, tmpsize);
|
|
}
|
|
strlcat(tmp, cp, tmpsize);
|
|
free(cp);
|
|
|
|
cmdq_print(item, "bind-key %s", tmp);
|
|
|
|
free(key);
|
|
bd = key_bindings_next(table, bd);
|
|
}
|
|
table = key_bindings_next_table(table);
|
|
}
|
|
|
|
free(tmp);
|
|
|
|
out:
|
|
if (only != KEYC_UNKNOWN && !found) {
|
|
cmdq_error(item, "unknown key: %s", args->argv[0]);
|
|
return (CMD_RETURN_ERROR);
|
|
}
|
|
return (CMD_RETURN_NORMAL);
|
|
}
|
|
|
|
static enum cmd_retval
|
|
cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
|
|
{
|
|
struct args *args = cmd_get_args(self);
|
|
const struct cmd_entry **entryp;
|
|
const struct cmd_entry *entry;
|
|
struct format_tree *ft;
|
|
const char *template, *s, *command = NULL;
|
|
char *line;
|
|
|
|
if (args->argc != 0)
|
|
command = args->argv[0];
|
|
|
|
if ((template = args_get(args, 'F')) == NULL) {
|
|
template = "#{command_list_name}"
|
|
"#{?command_list_alias, (#{command_list_alias}),} "
|
|
"#{command_list_usage}";
|
|
}
|
|
|
|
ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
|
|
format_defaults(ft, NULL, NULL, NULL, NULL);
|
|
|
|
for (entryp = cmd_table; *entryp != NULL; entryp++) {
|
|
entry = *entryp;
|
|
if (command != NULL &&
|
|
(strcmp(entry->name, command) != 0 &&
|
|
(entry->alias == NULL ||
|
|
strcmp(entry->alias, command) != 0)))
|
|
continue;
|
|
|
|
format_add(ft, "command_list_name", "%s", entry->name);
|
|
if (entry->alias != NULL)
|
|
s = entry->alias;
|
|
else
|
|
s = "";
|
|
format_add(ft, "command_list_alias", "%s", s);
|
|
if (entry->usage != NULL)
|
|
s = entry->usage;
|
|
else
|
|
s = "";
|
|
format_add(ft, "command_list_usage", "%s", s);
|
|
|
|
line = format_expand(ft, template);
|
|
if (*line != '\0')
|
|
cmdq_print(item, "%s", line);
|
|
free(line);
|
|
}
|
|
|
|
format_free(ft);
|
|
return (CMD_RETURN_NORMAL);
|
|
}
|