/* $OpenBSD: window-customize.c,v 1.36 2026/07/28 10:35:31 nicm Exp $ */

/*
 * Copyright (c) 2020 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 <ctype.h>
#include <stdlib.h>
#include <string.h>

#include "tmux.h"

static struct screen    *window_customize_init(struct window_mode_entry *,
                             struct cmdq_item *, struct cmd_find_state *,
                             struct args *);
static void              window_customize_free(struct window_mode_entry *);
static void              window_customize_resize(struct window_mode_entry *,
                              u_int, u_int);
static void              window_customize_update(struct window_mode_entry *);
static void              window_customize_key(struct window_mode_entry *,
                             struct client *, struct session *,
                             struct winlink *, key_code, struct mouse_event *);

#define WINDOW_CUSTOMIZE_DEFAULT_FORMAT \
        "#{?is_option," \
                "#{?option_is_global,,#[reverse](#{option_scope})#[default] }" \
                "#[fg=themelightgrey]#[ignore]#{option_value}" \
                "#{?option_unit, #{option_unit},}" \
        "," \
                "#{?is_environment," \
                        "#[fg=themelightgrey]#[ignore]#{environment_value}" \
                "," \
                        "#{key}" \
                "}" \
        "}"

static const struct menu_item window_customize_menu_items[] = {
        { "Select", '\r', NULL },
        { "Edit", 'e', NULL },
        { "Expand", KEYC_RIGHT, NULL },
        { "", KEYC_NONE, NULL },
        { "Tag", 't', NULL },
        { "Tag All", '\024', NULL },
        { "Tag None", 'T', NULL },
        { "", KEYC_NONE, NULL },
        { "Changed Only", 'C', NULL },
        { "", KEYC_NONE, NULL },
        { "Cancel", 'q', NULL },

        { NULL, KEYC_NONE, NULL }
};

const struct window_mode window_customize_mode = {
        .name = "options-mode",
        .default_format = WINDOW_CUSTOMIZE_DEFAULT_FORMAT,

        .init = window_customize_init,
        .free = window_customize_free,
        .resize = window_customize_resize,
        .update = window_customize_update,
        .key = window_customize_key,
};

enum window_customize_scope {
        WINDOW_CUSTOMIZE_NONE,
        WINDOW_CUSTOMIZE_KEY,
        WINDOW_CUSTOMIZE_SERVER,
        WINDOW_CUSTOMIZE_GLOBAL_SESSION,
        WINDOW_CUSTOMIZE_SESSION,
        WINDOW_CUSTOMIZE_GLOBAL_WINDOW,
        WINDOW_CUSTOMIZE_WINDOW,
        WINDOW_CUSTOMIZE_PANE,
        WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT,
        WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT
};

enum window_customize_change {
        WINDOW_CUSTOMIZE_UNSET,
        WINDOW_CUSTOMIZE_RESET,
};

enum window_customize_option_type {
        WINDOW_CUSTOMIZE_OPTIONS,
        WINDOW_CUSTOMIZE_HOOKS
};

enum window_customize_item_type {
        WINDOW_CUSTOMIZE_ITEM_OPTION,
        WINDOW_CUSTOMIZE_ITEM_KEY,
        WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT
};

enum window_customize_edit_type {
        WINDOW_CUSTOMIZE_EDIT_OPTION,
        WINDOW_CUSTOMIZE_EDIT_KEY_COMMAND,
        WINDOW_CUSTOMIZE_EDIT_KEY_NOTE,
        WINDOW_CUSTOMIZE_EDIT_ENVIRONMENT
};

struct window_customize_itemdata {
        struct window_customize_modedata         *data;
        enum window_customize_item_type   type;
        enum window_customize_option_type  option_type;
        enum window_customize_scope               scope;

        char                                     *table;
        key_code                                  key;

        struct options                           *oo;
        struct environ                           *environ;
        int                                       environ_flags;
        char                                     *name;
        char                                     *array_key;
};

struct window_customize_modedata {
        struct window_pane                       *wp;
        int                                       dead;
        int                                       references;

        struct mode_tree_data                    *data;
        struct spawn_editor_state                *editor;
        struct window_customize_editdata         *edit;
        char                                     *format;
        int                                       hide_global;
        int                                       hide_default;
        int                                       prompt_flags;

        struct window_customize_itemdata        **item_list;
        u_int                                     item_size;

        struct cmd_find_state                     fs;
        enum window_customize_change              change;
};

struct window_customize_editdata {
        u_int                                     wp_id;
        enum window_customize_edit_type           edit_type;
        struct window_customize_itemdata         *item;
        struct spawn_editor_state                *editor;
};

static uint64_t
window_customize_get_tag(struct options_entry *o, struct options_array_item *a,
    const struct options_table_entry *oe)
{
        uint64_t        offset;

        if (a != NULL)
                return ((uint64_t)(uintptr_t)a);
        if (oe == NULL)
                return ((uint64_t)o);
        offset = ((char *)oe - (char *)options_table) / sizeof *options_table;
        return ((2ULL << 62)|(offset << 32)|1);
}

static struct options *
window_customize_get_tree(enum window_customize_scope scope,
    struct cmd_find_state *fs)
{
        switch (scope) {
        case WINDOW_CUSTOMIZE_NONE:
        case WINDOW_CUSTOMIZE_KEY:
                return (NULL);
        case WINDOW_CUSTOMIZE_SERVER:
                return (global_options);
        case WINDOW_CUSTOMIZE_GLOBAL_SESSION:
                return (global_s_options);
        case WINDOW_CUSTOMIZE_SESSION:
                return (fs->s->options);
        case WINDOW_CUSTOMIZE_GLOBAL_WINDOW:
                return (global_w_options);
        case WINDOW_CUSTOMIZE_WINDOW:
                return (fs->w->options);
        case WINDOW_CUSTOMIZE_PANE:
                return (fs->wp->options);
        case WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT:
        case WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT:
                return (NULL);
        }
        return (NULL);
}

static struct environ *
window_customize_get_environment(enum window_customize_scope scope,
    struct cmd_find_state *fs)
{
        switch (scope) {
        case WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT:
                return (global_environ);
        case WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT:
                return (fs->s->environ);
        default:
                return (NULL);
        }
}

static int
window_customize_check_item(struct window_customize_modedata *data,
    struct window_customize_itemdata *item, struct cmd_find_state *fsp)
{
        struct cmd_find_state   fs;

        if (fsp == NULL)
                fsp = &fs;

        if (cmd_find_valid_state(&data->fs))
                cmd_find_copy_state(fsp, &data->fs);
        else
                cmd_find_from_pane(fsp, data->wp, 0);
        if (item->type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT) {
                return (item->environ ==
                    window_customize_get_environment(item->scope, fsp));
        }
        return (item->oo == window_customize_get_tree(item->scope, fsp));
}

static int
window_customize_get_key(struct window_customize_itemdata *item,
    struct key_table **ktp, struct key_binding **bdp)
{
        struct key_table        *kt;
        struct key_binding      *bd;

        kt = key_bindings_get_table(item->table, 0);
        if (kt == NULL)
                return (0);
        bd = key_bindings_get(kt, item->key);
        if (bd == NULL)
                return (0);

        if (ktp != NULL)
                *ktp = kt;
        if (bdp != NULL)
                *bdp = bd;
        return (1);
}

static char *
window_customize_scope_text(enum window_customize_scope scope,
    struct cmd_find_state *fs)
{
        char    *s;
        u_int    idx;

        switch (scope) {
        case WINDOW_CUSTOMIZE_PANE:
                window_pane_index(fs->wp, &idx);
                xasprintf(&s, "pane %u", idx);
                break;
        case WINDOW_CUSTOMIZE_SESSION:
        case WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT:
                xasprintf(&s, "session %s", fs->s->name);
                break;
        case WINDOW_CUSTOMIZE_WINDOW:
                xasprintf(&s, "window %u", fs->wl->idx);
                break;
        default:
                s = xstrdup("");
                break;
        }
        return (s);
}

static int
window_customize_write_hook_fire(struct screen_write_ctx *ctx, u_int cx,
    u_int sx, u_int sy, struct options_entry *o)
{
        char    *fire_time_string;
        u_int    fire_count;
        time_t   fire_time;

        if (options_get_monitor_data(o) != NULL) {
                fire_count = hooks_monitor_get_fire_count(o);
                fire_time = hooks_monitor_get_fire_time(o);
        } else {
                fire_count = options_get_fire_count(o);
                fire_time = options_get_fire_time(o);
        }
        if (fire_time != 0) {
                fire_time_string = format_pretty_time(fire_time, 0);
                if (!screen_write_text(ctx, cx, sx, sy, 0, &grid_default_cell,
                    "This hook has been fired %u times, last %s.", fire_count,
                    fire_time_string)) {
                        free(fire_time_string);
                        return (0);
                }
                free(fire_time_string);
                return (1);
        }
        return (screen_write_text(ctx, cx, sx, sy, 0, &grid_default_cell,
            "This hook has been fired %u times.", fire_count));
}

static struct window_customize_itemdata *
window_customize_add_item(struct window_customize_modedata *data)
{
        struct window_customize_itemdata        *item;

        data->item_list = xreallocarray(data->item_list, data->item_size + 1,
            sizeof *data->item_list);
        item = data->item_list[data->item_size++] = xcalloc(1, sizeof *item);
        return (item);
}

static int printflike(7, 8)
window_customize_write_value(struct screen_write_ctx *ctx, u_int cx,
    u_int sx, u_int sy, int more, const char *label, const char *fmt, ...)
{
        struct screen           *s = ctx->s;
        struct grid_cell         gc;
        va_list                  ap;
        char                    *value;
        u_int                    cy = s->cy;
        int                      retval;

        if (sy == 0)
                return (0);
        if (!screen_write_text(ctx, cx, sx, sy, 1, &grid_default_cell, "%s",
            label))
                return (0);
        if (s->cy - cy >= sy)
                return (0);
        sy -= s->cy - cy;

        memcpy(&gc, &grid_default_cell, sizeof gc);
        gc.fg = COLOUR_THEME_LIGHT_GREY|COLOUR_FLAG_THEME;

        va_start(ap, fmt);
        xvasprintf(&value, fmt, ap);
        va_end(ap);

        retval = screen_write_text(ctx, cx, sx, sy, more, &gc, "%s", value);
        free(value);
        return (retval);
}

static void
window_customize_free_item(struct window_customize_itemdata *item)
{
        free(item->table);
        free(item->name);
        free(item->array_key);
        free(item);
}

static struct window_customize_itemdata *
window_customize_copy_item(struct window_customize_itemdata *item)
{
        struct window_customize_itemdata        *new_item;

        new_item = xcalloc(1, sizeof *new_item);
        new_item->data = item->data;
        new_item->type = item->type;
        new_item->option_type = item->option_type;
        new_item->scope = item->scope;
        new_item->key = item->key;
        new_item->oo = item->oo;
        new_item->environ = item->environ;
        new_item->environ_flags = item->environ_flags;
        if (item->table != NULL)
                new_item->table = xstrdup(item->table);
        if (item->name != NULL)
                new_item->name = xstrdup(item->name);
        if (item->array_key != NULL)
                new_item->array_key = xstrdup(item->array_key);
        return (new_item);
}

static void
window_customize_finish_edit(struct window_customize_editdata *ed)
{
        window_customize_free_item(ed->item);
        free(ed);
}

static void
window_customize_draw_waiting(struct window_customize_modedata *data)
{
        struct screen_write_ctx  ctx;
        struct screen           *s = data->wp->screen;
        struct grid_cell         gc;
        char                     text[128];
        u_int                    sx, sy, box_w, box_h, x, y, text_x;
        size_t                   textlen;
        pid_t                    pid;

        if (data->editor == NULL)
                return;
        sx = screen_size_x(s);
        sy = screen_size_y(s);
        if (sx == 0 || sy == 0)
                return;

        pid = spawn_get_editor_pid(data->editor);
        if (pid == -1)
                xsnprintf(text, sizeof text, "WAITING FOR EDITOR");
        else {
                xsnprintf(text, sizeof text, "WAITING FOR EDITOR (PID %ld)",
                    (long)pid);
        }

        textlen = strlen(text);
        box_w = textlen + 4;
        box_h = 3;
        if (sx < box_w || sy < box_h)
                return;
        x = (sx - box_w) / 2;
        y = (sy - box_h) / 2;
        text_x = x + (box_w - textlen) / 2;

        memcpy(&gc, &grid_default_cell, sizeof gc);
        screen_write_start(&ctx, s);
        screen_write_cursormove(&ctx, x, y, 0);
        screen_write_box(&ctx, box_w, box_h, BOX_LINES_DEFAULT, &gc, NULL);
        screen_write_cursormove(&ctx, x + 1, y + 1, 0);
        screen_write_clearcharacter(&ctx, box_w - 2, gc.bg);
        screen_write_cursormove(&ctx, text_x, y + 1, 0);
        screen_write_nputs(&ctx, box_w - 2, &gc, "%s", text);
        screen_write_stop(&ctx);
}

static int
window_customize_set_option_value(struct window_customize_itemdata *item,
    const char *s, char **cause)
{
        struct options_entry                    *o;
        const struct options_table_entry        *oe;
        struct options                          *oo = item->oo;
        const char                              *name = item->name;
        const char                              *array_key = item->array_key;
        u_int                                    idx;
        char                                     keybuf[32];

        o = options_get(oo, name);
        if (o == NULL)
                return (-1);
        oe = options_table_entry(o);

        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_ARRAY)) {
                if (array_key == NULL) {
                        for (idx = 0; idx < INT_MAX; idx++) {
                                if (options_array_getv(o, "%u", idx) == NULL)
                                        break;
                        }
                        xsnprintf(keybuf, sizeof keybuf, "%u", idx);
                        array_key = keybuf;
                }
                if (options_array_set(o, array_key, s, 0, cause) != 0)
                        return (-1);
        } else {
                if (options_from_string(oo, oe, name, s, 0, cause) != 0)
                        return (-1);
        }
        if (item->option_type == WINDOW_CUSTOMIZE_HOOKS && *name == '@')
                hooks_add_event(name);

        options_push_changes(item->name);
        return (0);
}

static int
window_customize_option_editable(struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        struct options_entry                    *o;
        const struct options_table_entry        *oe;

        if (item->type != WINDOW_CUSTOMIZE_ITEM_OPTION ||
            !window_customize_check_item(data, item, NULL))
                return (0);

        o = options_get(item->oo, item->name);
        if (o == NULL)
                return (0);
        oe = options_table_entry(o);
        if (oe == NULL)
                return (1);
        if (oe->type == OPTIONS_TABLE_FLAG || oe->type == OPTIONS_TABLE_CHOICE)
                return (0);
        return (1);
}

static int
window_customize_set_command_value(struct window_customize_itemdata *item,
    const char *s, char **cause)
{
        struct key_binding              *bd;
        struct cmd_parse_result         *pr;

        if (!window_customize_get_key(item, NULL, &bd))
                return (-1);

        pr = cmd_parse_from_string(s, NULL);
        switch (pr->status) {
        case CMD_PARSE_ERROR:
                *cause = pr->error;
                return (-1);
        case CMD_PARSE_SUCCESS:
                break;
        }
        cmd_list_free(bd->cmdlist);
        bd->cmdlist = pr->cmdlist;
        return (0);
}

static int
window_customize_set_note_value(struct window_customize_itemdata *item,
    const char *s)
{
        struct key_binding      *bd;

        if (!window_customize_get_key(item, NULL, &bd))
                return (-1);

        free((void *)bd->note);
        if (*s == '\0')
                bd->note = NULL;
        else
                bd->note = xstrdup(s);
        return (0);
}

static void
window_customize_set_environment_value(struct window_customize_itemdata *item,
    const char *s)
{
        struct environ_entry    *envent;
        int                      flags;

        flags = item->environ_flags;
        envent = environ_find(item->environ, item->name);
        if (envent != NULL)
                flags = envent->flags;
        environ_set(item->environ, item->name, flags, "%s", s);
}

static int
window_customize_option_is_changed(struct options_entry *o,
    const char *array_key)
{
        const struct options_table_entry        *oe = options_table_entry(o);
        struct options                  *oo;
        struct options_entry            *defaults;
        union options_value             *ov, *default_ov;
        char                            *value, *default_value;
        int                              changed;

        if (oe == NULL || options_get_monitor_data(o) != NULL)
                return (1);
        if (*options_name(o) == '@' && hooks_is_event(options_name(o)))
                return (1);

        if (oe->flags & OPTIONS_TABLE_IS_ARRAY) {
                oo = options_create(NULL);
                defaults = options_default(oo, oe);
                if (array_key != NULL) {
                        ov = options_array_get(o, array_key);
                        default_ov = options_array_get(defaults, array_key);
                        if (ov == NULL || default_ov == NULL) {
                                changed = (ov != default_ov);
                                options_free(oo);
                                return (changed);
                        }
                }
                value = options_to_string(o, array_key, 0);
                default_value = options_to_string(defaults, array_key, 0);
                changed = (strcmp(value, default_value) != 0);
                free(value);
                free(default_value);
                options_free(oo);
                return (changed);
        }

        value = options_to_string(o, NULL, 0);
        default_value = options_default_to_string(oe);
        changed = (strcmp(value, default_value) != 0);
        free(value);
        free(default_value);
        return (changed);
}

static int
window_customize_key_is_changed(struct key_table *kt, struct key_binding *bd)
{
        struct key_binding      *default_bd;
        char                    *cmd, *default_cmd;
        int                      changed;

        default_bd = key_bindings_get_default(kt, bd->key);
        if (default_bd == NULL)
                return (1);
        if (bd->flags != default_bd->flags)
                return (1);
        if ((bd->note == NULL) != (default_bd->note == NULL))
                return (1);
        if (bd->note != NULL && strcmp(bd->note, default_bd->note) != 0)
                return (1);

        cmd = cmd_list_print(bd->cmdlist, 0);
        default_cmd = cmd_list_print(default_bd->cmdlist, 0);
        changed = (strcmp(cmd, default_cmd) != 0);
        free(cmd);
        free(default_cmd);
        return (changed);
}

static u_int
window_customize_build_array(struct window_customize_modedata *data,
    struct mode_tree_item *top, enum window_customize_scope scope,
    struct options_entry *o, struct format_tree *ft)
{
        const struct options_table_entry        *oe = options_table_entry(o);
        struct options                          *oo = options_owner(o);
        struct window_customize_itemdata        *item;
        struct options_array_item               *ai;
        char                                    *name, *value, *text;
        uint64_t                                 tag;
        const char                              *array_key;
        u_int                                    count = 0;

        ai = options_array_first(o);
        while (ai != NULL) {
                array_key = options_array_item_key(ai);
                if (data->hide_default &&
                    !window_customize_option_is_changed(o, array_key)) {
                        ai = options_array_next(ai);
                        continue;
                }

                xasprintf(&name, "%s[%s]", options_name(o), array_key);
                format_add(ft, "option_name", "%s", name);
                value = options_to_string(o, array_key, 0);
                format_add(ft, "option_value", "%s", value);

                item = window_customize_add_item(data);
                item->type = WINDOW_CUSTOMIZE_ITEM_OPTION;
                if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_HOOK))
                        item->option_type = WINDOW_CUSTOMIZE_HOOKS;
                item->scope = scope;
                item->oo = oo;
                item->name = xstrdup(options_name(o));
                item->array_key = xstrdup(array_key);

                text = format_expand(ft, data->format);
                tag = window_customize_get_tag(o, ai, oe);
                mode_tree_add(data->data, top, item, tag, name, text, -1);
                free(text);

                free(name);
                free(value);
                count++;

                ai = options_array_next(ai);
        }
        return (count);
}

static u_int
window_customize_build_option(struct window_customize_modedata *data,
    struct mode_tree_item *top, enum window_customize_scope scope,
    struct options_entry *o, struct format_tree *ft,
    const char *filter, struct cmd_find_state *fs,
    enum window_customize_option_type type)
{
        const struct options_table_entry        *oe = options_table_entry(o);
        struct options                          *oo = options_owner(o);
        const char                              *name = options_name(o);
        struct window_customize_itemdata        *item;
        char                                    *text, *expanded, *value;
        int                                      global = 0, array = 0;
        int                                      is_hook = 0, is_monitor = 0;
        int                                      is_user_hook = 0, is_any_hook;
        uint64_t                                 tag;

        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_HOOK))
                is_hook = 1;
        if (options_get_monitor_data(o) != NULL)
                is_monitor = 1;
        if (*name == '@' && hooks_is_event(name))
                is_user_hook = 1;
        is_any_hook = (is_hook || is_monitor || is_user_hook);
        switch (type) {
        case WINDOW_CUSTOMIZE_OPTIONS:
                if (is_any_hook)
                        return (0);
                break;
        case WINDOW_CUSTOMIZE_HOOKS:
                if (!is_any_hook)
                        return (0);
                break;
        }
        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_ARRAY))
                array = 1;

        if (scope == WINDOW_CUSTOMIZE_SERVER ||
            scope == WINDOW_CUSTOMIZE_GLOBAL_SESSION ||
            scope == WINDOW_CUSTOMIZE_GLOBAL_WINDOW)
                global = 1;
        if (data->hide_global && global)
                return (0);
        if (data->hide_default && !window_customize_option_is_changed(o, NULL))
                return (0);

        format_add(ft, "option_name", "%s", name);
        format_add(ft, "option_is_global", "%d", global);
        format_add(ft, "option_is_array", "%d", array);
        format_add(ft, "option_is_hook", "%d", is_hook);
        format_add(ft, "option_is_monitor", "%d", is_monitor);

        text = window_customize_scope_text(scope, fs);
        format_add(ft, "option_scope", "%s", text);
        free(text);

        if (oe != NULL && oe->unit != NULL)
                format_add(ft, "option_unit", "%s", oe->unit);
        else
                format_add(ft, "option_unit", "%s", "");

        if (is_monitor) {
                value = hooks_monitor_to_string(o);
                if (value != NULL) {
                        format_add(ft, "option_monitor", "%s", value);
                        free(value);
                } else
                        format_add(ft, "option_monitor", "%s", "");
        } else
                format_add(ft, "option_monitor", "%s", "");

        if (!array) {
                value = options_to_string(o, NULL, 0);
                format_add(ft, "option_value", "%s", value);
                free(value);
        }

        if (filter != NULL) {
                expanded = format_expand(ft, filter);
                if (!format_true(expanded)) {
                        free(expanded);
                        return (0);
                }
                free(expanded);
        }
        item = window_customize_add_item(data);
        item->type = WINDOW_CUSTOMIZE_ITEM_OPTION;
        item->option_type = type;
        item->oo = oo;
        item->scope = scope;
        item->name = xstrdup(name);

        if (array)
                text = NULL;
        else
                text = format_expand(ft, data->format);
        tag = window_customize_get_tag(o, NULL, oe);
        top = mode_tree_add(data->data, top, item, tag, name, text, 0);
        free(text);

        if (!array)
                return (1);
        return (1 + window_customize_build_array(data, top, scope, o, ft));
}

static void
window_customize_find_user_options(struct options *oo, const char ***list,
    u_int *size)
{
        struct options_entry    *o;
        const char              *name;
        u_int                    i;

        o = options_first(oo);
        while (o != NULL) {
                name = options_name(o);
                if (*name != '@') {
                        o = options_next(o);
                        continue;
                }
                for (i = 0; i < *size; i++) {
                        if (strcmp((*list)[i], name) == 0)
                                break;
                }
                if (i != *size) {
                        o = options_next(o);
                        continue;
                }
                *list = xreallocarray(*list, (*size) + 1, sizeof **list);
                (*list)[(*size)++] = name;

                o = options_next(o);
        }
}

static void
window_customize_build_options(struct window_customize_modedata *data,
    const char *title, uint64_t tag,
    enum window_customize_scope scope0, struct options *oo0,
    enum window_customize_scope scope1, struct options *oo1,
    enum window_customize_scope scope2, struct options *oo2,
    struct format_tree *ft, const char *filter, struct cmd_find_state *fs,
    enum window_customize_option_type type)
{
        struct mode_tree_item            *top;
        struct options_entry             *o = NULL, *loop;
        const char                      **list = NULL, *name;
        u_int                             size = 0, i, count = 0;
        enum window_customize_scope       scope;

        top = mode_tree_add(data->data, NULL, NULL, tag, title, NULL, 0);
        mode_tree_no_tag(top);

        /*
         * We get the options from the first tree, but build it using the
         * values from the other two. Any tree can have user options so we need
         * to build a separate list of them.
         */

        window_customize_find_user_options(oo0, &list, &size);
        if (oo1 != NULL)
                window_customize_find_user_options(oo1, &list, &size);
        if (oo2 != NULL)
                window_customize_find_user_options(oo2, &list, &size);

        for (i = 0; i < size; i++) {
                o = NULL;
                if (oo2 != NULL)
                        o = options_get(oo2, list[i]);
                if (o == NULL && oo1 != NULL)
                        o = options_get(oo1, list[i]);
                if (o == NULL)
                        o = options_get(oo0, list[i]);
                if (options_owner(o) == oo2)
                        scope = scope2;
                else if (options_owner(o) == oo1)
                        scope = scope1;
                else
                        scope = scope0;
                count += window_customize_build_option(data, top, scope, o, ft,
                    filter, fs, type);
        }
        free(list);

        loop = options_first(oo0);
        while (loop != NULL) {
                name = options_name(loop);
                if (*name == '@') {
                        loop = options_next(loop);
                        continue;
                }
                if (oo2 != NULL)
                        o = options_get(oo2, name);
                else if (oo1 != NULL)
                        o = options_get(oo1, name);
                else
                        o = loop;
                if (options_owner(o) == oo2)
                        scope = scope2;
                else if (options_owner(o) == oo1)
                        scope = scope1;
                else
                        scope = scope0;
                count += window_customize_build_option(data, top, scope, o, ft,
                    filter, fs, type);
                loop = options_next(loop);
        }
        if (data->hide_default && count == 0)
                mode_tree_remove(data->data, top);
}

static uint64_t
window_customize_key_tag(const void *ptr, u_int type)
{
        return ((uint64_t)(uintptr_t)ptr|type);
}

static void
window_customize_build_keys(struct window_customize_modedata *data,
    struct key_table *kt, struct format_tree *ft, const char *filter,
    struct cmd_find_state *fs)
{
        struct mode_tree_item                   *top, *child, *mti;
        struct window_customize_itemdata        *item;
        struct key_binding                      *bd;
        char                                    *title, *text, *tmp, *expanded;
        const char                              *flag;
        u_int                                    count = 0;

        xasprintf(&title, "Key Table - %s", kt->name);
        top = mode_tree_add(data->data, NULL, NULL,
            window_customize_key_tag(kt, 0), title, NULL, 0);
        mode_tree_no_tag(top);
        free(title);

        ft = format_create_from_state(NULL, NULL, fs);
        format_add(ft, "is_option", "0");
        format_add(ft, "is_key", "1");
        format_add(ft, "is_environment", "0");

        bd = key_bindings_first(kt);
        while (bd != NULL) {
                if (data->hide_default &&
                    !window_customize_key_is_changed(kt, bd)) {
                        bd = key_bindings_next(kt, bd);
                        continue;
                }

                format_add(ft, "key", "%s", key_string_lookup_key(bd->key, 0));
                if (bd->note != NULL)
                        format_add(ft, "key_note", "%s", bd->note);
                if (filter != NULL) {
                        expanded = format_expand(ft, filter);
                        if (!format_true(expanded)) {
                                free(expanded);
                                bd = key_bindings_next(kt, bd);
                                continue;
                        }
                        free(expanded);
                }

                item = window_customize_add_item(data);
                item->type = WINDOW_CUSTOMIZE_ITEM_KEY;
                item->scope = WINDOW_CUSTOMIZE_KEY;
                item->table = xstrdup(kt->name);
                item->key = bd->key;
                item->name = xstrdup(key_string_lookup_key(item->key, 0));

                expanded = format_expand(ft, data->format);
                child = mode_tree_add(data->data, top, item,
                    window_customize_key_tag(bd, 0), expanded, NULL, 0);
                free(expanded);

                tmp = cmd_list_print(bd->cmdlist, 0);
                xasprintf(&text, "#[fg=themelightgrey]#[ignore]%s", tmp);
                free(tmp);
                mti = mode_tree_add(data->data, child, item,
                    window_customize_key_tag(bd, 1), "Command", text, -1);
                mode_tree_draw_as_parent(mti);
                mode_tree_no_tag(mti);
                free(text);

                if (bd->note != NULL) {
                        xasprintf(&text, "#[fg=themelightgrey]#[ignore]%s",
                            bd->note);
                } else
                        text = xstrdup("");
                mti = mode_tree_add(data->data, child, item,
                    window_customize_key_tag(bd, 2), "Note", text, -1);
                mode_tree_draw_as_parent(mti);
                mode_tree_no_tag(mti);
                free(text);

                if (bd->flags & KEY_BINDING_REPEAT)
                        flag = "on";
                else
                        flag = "off";
                xasprintf(&text, "#[fg=themelightgrey]#[ignore]%s", flag);
                mti = mode_tree_add(data->data, child, item,
                    window_customize_key_tag(bd, 3), "Repeat", text, -1);
                mode_tree_draw_as_parent(mti);
                mode_tree_no_tag(mti);
                free(text);

                count++;
                bd = key_bindings_next(kt, bd);
        }

        format_free(ft);
        if (data->hide_default && count == 0)
                mode_tree_remove(data->data, top);
}

static void
window_customize_build_environment(struct window_customize_modedata *data,
    const char *title, uint64_t tag, enum window_customize_scope scope,
    struct environ *env, struct format_tree *ft, const char *filter,
    struct cmd_find_state *fs)
{
        struct mode_tree_item           *top;
        struct window_customize_itemdata        *item;
        struct environ_entry            *envent;
        char                            *name, *text, *expanded, *value;
        uint64_t                         item_tag;
        int                              global;

        if (data->hide_default)
                return;

        top = mode_tree_add(data->data, NULL, NULL, tag, title, NULL, 0);
        mode_tree_no_tag(top);

        global = (scope == WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT);
        format_add(ft, "is_option", "0");
        format_add(ft, "is_key", "0");
        format_add(ft, "is_environment", "1");
        format_add(ft, "environment_is_global", "%d", global);

        text = window_customize_scope_text(scope, fs);
        format_add(ft, "environment_scope", "%s", text);
        free(text);

        envent = environ_first(env);
        while (envent != NULL) {
                format_add(ft, "environment_name", "%s", envent->name);
                format_add(ft, "environment_hidden", "%d",
                    !!(envent->flags & ENVIRON_HIDDEN));
                format_add(ft, "environment_removed", "%d",
                    envent->value == NULL);
                if (envent->value == NULL)
                        value = xstrdup("");
                else
                        value = xstrdup(envent->value);
                format_add(ft, "environment_value", "%s", value);

                if (filter != NULL) {
                        expanded = format_expand(ft, filter);
                        if (!format_true(expanded)) {
                                free(expanded);
                                free(value);
                                envent = environ_next(envent);
                                continue;
                        }
                        free(expanded);
                }

                item = window_customize_add_item(data);
                item->type = WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT;
                item->scope = scope;
                item->environ = env;
                item->environ_flags = envent->flags;
                item->name = xstrdup(envent->name);

                if (envent->value == NULL) {
                        xasprintf(&name, "-%s", envent->name);
                        text = NULL;
                } else {
                        name = xstrdup(envent->name);
                        text = format_expand(ft, data->format);
                }
                item_tag = (2ULL << 62)|((uint64_t)(uintptr_t)envent);
                mode_tree_add(data->data, top, item, item_tag, name, text, 0);
                free(name);
                free(text);
                free(value);

                envent = environ_next(envent);
        }
}

static void
window_customize_build(void *modedata,
    __unused struct sort_criteria *sort_crit, __unused uint64_t *tag,
    const char *filter)
{
        struct window_customize_modedata        *data = modedata;
        struct cmd_find_state                    fs;
        struct format_tree                      *ft;
        u_int                                    i;
        struct key_table                        *kt;

        for (i = 0; i < data->item_size; i++)
                window_customize_free_item(data->item_list[i]);
        free(data->item_list);
        data->item_list = NULL;
        data->item_size = 0;

        if (cmd_find_valid_state(&data->fs))
                cmd_find_copy_state(&fs, &data->fs);
        else
                cmd_find_from_pane(&fs, data->wp, 0);

        ft = format_create_from_state(NULL, NULL, &fs);
        format_add(ft, "is_option", "1");
        format_add(ft, "is_key", "0");
        format_add(ft, "is_environment", "0");

        window_customize_build_options(data, "Server Options",
            (3ULL << 62)|(OPTIONS_TABLE_SERVER << 1)|1,
            WINDOW_CUSTOMIZE_SERVER, global_options,
            WINDOW_CUSTOMIZE_NONE, NULL,
            WINDOW_CUSTOMIZE_NONE, NULL,
            ft, filter, &fs, WINDOW_CUSTOMIZE_OPTIONS);
        window_customize_build_options(data, "Session Options",
            (3ULL << 62)|(OPTIONS_TABLE_SESSION << 1)|1,
            WINDOW_CUSTOMIZE_GLOBAL_SESSION, global_s_options,
            WINDOW_CUSTOMIZE_SESSION, fs.s->options,
            WINDOW_CUSTOMIZE_NONE, NULL,
            ft, filter, &fs, WINDOW_CUSTOMIZE_OPTIONS);
        window_customize_build_options(data, "Window & Pane Options",
            (3ULL << 62)|(OPTIONS_TABLE_WINDOW << 1)|1,
            WINDOW_CUSTOMIZE_GLOBAL_WINDOW, global_w_options,
            WINDOW_CUSTOMIZE_WINDOW, fs.w->options,
            WINDOW_CUSTOMIZE_PANE, fs.wp->options,
            ft, filter, &fs, WINDOW_CUSTOMIZE_OPTIONS);
        window_customize_build_options(data, "Session Hooks",
            (3ULL << 62)|(1ULL << 8)|(OPTIONS_TABLE_SESSION << 1)|1,
            WINDOW_CUSTOMIZE_GLOBAL_SESSION, global_s_options,
            WINDOW_CUSTOMIZE_SESSION, fs.s->options,
            WINDOW_CUSTOMIZE_NONE, NULL,
            ft, filter, &fs, WINDOW_CUSTOMIZE_HOOKS);
        window_customize_build_options(data, "Window & Pane Hooks",
            (3ULL << 62)|(1ULL << 8)|(OPTIONS_TABLE_WINDOW << 1)|1,
            WINDOW_CUSTOMIZE_GLOBAL_WINDOW, global_w_options,
            WINDOW_CUSTOMIZE_WINDOW, fs.w->options,
            WINDOW_CUSTOMIZE_PANE, fs.wp->options,
            ft, filter, &fs, WINDOW_CUSTOMIZE_HOOKS);
        window_customize_build_environment(data, "Global Environment",
            (3ULL << 62)|(2ULL << 8)|1,
            WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT, global_environ, ft, filter,
            &fs);
        window_customize_build_environment(data, "Session Environment",
            (3ULL << 62)|(2ULL << 8)|3,
            WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT, fs.s->environ, ft, filter,
            &fs);

        format_free(ft);
        ft = format_create_from_state(NULL, NULL, &fs);
        format_add(ft, "is_environment", "0");

        kt = key_bindings_first_table();
        while (kt != NULL) {
                if (!RB_EMPTY(&kt->key_bindings))
                        window_customize_build_keys(data, kt, ft, filter, &fs);
                kt = key_bindings_next_table(kt);
        }

        format_free(ft);
}

static void
window_customize_draw_key(__unused struct window_customize_modedata *data,
    struct window_customize_itemdata *item, struct screen_write_ctx *ctx,
    u_int sx, u_int sy)
{
        struct screen           *s = ctx->s;
        u_int                    cx = s->cx, cy = s->cy;
        struct key_table        *kt;
        struct key_binding      *bd, *default_bd;
        const char              *note, *period = "";
        char                    *cmd, *default_cmd;

        if (item == NULL || !window_customize_get_key(item, &kt, &bd))
                return;

        note = bd->note;
        if (note == NULL)
                note = "There is no note for this key.";
        if (*note != '\0' && note[strlen (note) - 1] != '.')
                period = ".";
        if (!screen_write_text(ctx, cx, sx, sy, 0, &grid_default_cell, "%s%s",
            note, period))
                return;
        screen_write_cursormove(ctx, cx, s->cy + 1, 0); /* skip line */
        if (s->cy >= cy + sy - 1)
                return;

        if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
            &grid_default_cell, "This key is in the %s table.", kt->name))
                return;
        if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy), 0,
            "Repeat: ", "%s", (bd->flags & KEY_BINDING_REPEAT) ? "on" : "off"))
                return;
        screen_write_cursormove(ctx, cx, s->cy + 1, 0); /* skip line */
        if (s->cy >= cy + sy - 1)
                return;

        cmd = cmd_list_print(bd->cmdlist, 0);
        if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy), 0,
            "Command: ", "%s", cmd)) {
                free(cmd);
                return;
        }
        default_bd = key_bindings_get_default(kt, bd->key);
        if (default_bd != NULL) {
                default_cmd = cmd_list_print(default_bd->cmdlist, 0);
                if (strcmp(cmd, default_cmd) != 0 &&
                    !window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy),
                    0, "The default is: ", "%s", default_cmd)) {
                        free(default_cmd);
                        free(cmd);
                        return;
                }
                free(default_cmd);
        }
        free(cmd);
}

static void
window_customize_draw_option(struct window_customize_modedata *data,
    struct window_customize_itemdata *item, struct screen_write_ctx *ctx,
    u_int sx, u_int sy)
{
        struct screen                            *s = ctx->s;
        u_int                                     cx = s->cx, cy = s->cy;
        struct options_entry                     *o, *parent;
        struct options                           *go, *wo;
        const struct options_table_entry         *oe;
        struct grid_cell                          gc;
        const char                              **choice, *text, *name;
        const char                               *array_key;
        const char                               *space = "", *unit = "";
        char                                     *value = NULL, *expanded;
        char                                     *monitor, label[64];
        char                                     *default_value = NULL;
        char                                      choices[256] = "";
        struct cmd_find_state                     fs;
        struct format_tree                       *ft;
        int                                       is_hook, is_monitor, is_user_hook;
        int                                       is_any_hook;

        if (!window_customize_check_item(data, item, &fs))
                return;
        name = item->name;
        array_key = item->array_key;

        o = options_get(item->oo, name);
        if (o == NULL)
                return;
        oe = options_table_entry(o);
        is_hook = (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_HOOK));
        is_monitor = (options_get_monitor_data(o) != NULL);
        is_user_hook = (*name == '@' && hooks_is_event(name));
        is_any_hook = (is_hook || is_monitor || is_user_hook);

        if (oe != NULL && oe->unit != NULL) {
                space = " ";
                unit = oe->unit;
        }
        ft = format_create_from_state(NULL, NULL, &fs);

        if (oe == NULL || oe->text == NULL) {
                if (is_monitor)
                        text = "This hook runs when a monitor changes.";
                else if (is_user_hook)
                        text = "This hook doesn't have a description.";
                else
                        text = "This option doesn't have a description.";
        } else
                text = oe->text;
        if (!screen_write_text(ctx, cx, sx, sy, 0, &grid_default_cell, "%s",
            text))
                goto out;
        screen_write_cursormove(ctx, cx, s->cy + 1, 0); /* skip line */
        if (s->cy >= cy + sy - 1)
                goto out;

        if (is_monitor) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
                    &grid_default_cell, "This is a monitor hook."))
                        goto out;
                goto monitor;
        }
        if (oe == NULL)
                text = "user";
        else if ((oe->scope & (OPTIONS_TABLE_WINDOW|OPTIONS_TABLE_PANE)) ==
            (OPTIONS_TABLE_WINDOW|OPTIONS_TABLE_PANE))
                text = "window and pane";
        else if (oe->scope & OPTIONS_TABLE_WINDOW)
                text = "window";
        else if (oe->scope & OPTIONS_TABLE_SESSION)
                text = "session";
        else
                text = "server";
        if (is_user_hook) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
                    &grid_default_cell, "This is a user hook."))
                        goto out;
        } else if (is_hook) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
                    &grid_default_cell, "This is a %s hook.", text))
                        goto out;
        } else {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
                    &grid_default_cell, "This is a %s option.", text))
                        goto out;
        }

monitor:
        monitor = hooks_monitor_to_string(o);
        if (monitor != NULL) {
                if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy),
                    0, "Monitor: ", "%s", monitor)) {
                        free(monitor);
                        goto out;
                }
                free(monitor);
        }
        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_ARRAY)) {
                if (is_hook) {
                        if (array_key == NULL) {
                                if (!screen_write_text(ctx, cx, sx,
                                    sy - (s->cy - cy), 0, &grid_default_cell,
                                    "This is an array hook."))
                                        goto out;
                                if (!window_customize_write_hook_fire(ctx, cx,
                                    sx, sy - (s->cy - cy), o))
                                        goto out;
                                goto out;
                        }
                } else if (array_key != NULL) {
                        if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy),
                            0, &grid_default_cell,
                            "This is an array option, key %s.", array_key))
                                goto out;
                } else {
                        if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy),
                            0, &grid_default_cell, "This is an array option."))
                                goto out;
                }
                if (array_key == NULL)
                        goto out;
        }
        screen_write_cursormove(ctx, cx, s->cy + 1, 0); /* skip line */
        if (s->cy >= cy + sy - 1)
                goto out;

        value = options_to_string(o, array_key, 0);
        if (oe != NULL && array_key == NULL) {
                default_value = options_default_to_string(oe);
                if (strcmp(default_value, value) == 0) {
                        free(default_value);
                        default_value = NULL;
                }
        }
        if (is_any_hook) {
                if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy),
                    0, "Hook command: ", "%s%s%s", value, space, unit))
                        goto out;
                if (!window_customize_write_hook_fire(ctx, cx, sx,
                    sy - (s->cy - cy), o))
                        goto out;
        } else {
                if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy),
                    0, "Option value: ", "%s%s%s", value, space, unit))
                        goto out;
        }
        if (oe == NULL || oe->type == OPTIONS_TABLE_STRING) {
                expanded = format_expand(ft, value);
                if (strcmp(expanded, value) != 0) {
                        if (!window_customize_write_value(ctx, cx, sx,
                            sy - (s->cy - cy), 0, "This expands to: ", "%s",
                            expanded)) {
                                free(expanded);
                                goto out;
                        }
                }
                free(expanded);
        }
        if (oe != NULL && oe->type == OPTIONS_TABLE_CHOICE) {
                for (choice = oe->choices; *choice != NULL; choice++) {
                        strlcat(choices, *choice, sizeof choices);
                        strlcat(choices, ", ", sizeof choices);
                }
                choices[strlen(choices) - 2] = '\0';
                if (!window_customize_write_value(ctx, cx, sx,
                    sy - (s->cy - cy), 0, "Available values are: ", "%s",
                    choices))
                        goto out;
        }
        if (oe != NULL && oe->type == OPTIONS_TABLE_COLOUR) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 1,
                    &grid_default_cell, "This is a colour option: "))
                        goto out;
                memcpy(&gc, &grid_default_cell, sizeof gc);
                gc.fg = options_get_number(item->oo, name);
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0, &gc,
                    "EXAMPLE"))
                        goto out;
        }
        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_COLOUR)) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 1,
                    &grid_default_cell, "This is a colour option: "))
                        goto out;
                style_apply(&gc, item->oo, name, ft);
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0, &gc,
                    "EXAMPLE"))
                        goto out;
        }
        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_STYLE)) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 1,
                    &grid_default_cell, "This is a style option: "))
                        goto out;
                style_apply(&gc, item->oo, name, ft);
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0, &gc,
                    "EXAMPLE"))
                        goto out;
        }
        if (default_value != NULL) {
                if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy),
                    0, "The default is: ", "%s%s%s", default_value, space, unit))
                        goto out;
        }

        screen_write_cursormove(ctx, cx, s->cy + 1, 0); /* skip line */
        if (s->cy > cy + sy - 1)
                goto out;
        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_ARRAY)) {
                wo = NULL;
                go = NULL;
        } else {
                switch (item->scope) {
                case WINDOW_CUSTOMIZE_PANE:
                        wo = options_get_parent(item->oo);
                        go = options_get_parent(wo);
                        break;
                case WINDOW_CUSTOMIZE_WINDOW:
                case WINDOW_CUSTOMIZE_SESSION:
                        wo = NULL;
                        go = options_get_parent(item->oo);
                        break;
                default:
                        wo = NULL;
                        go = NULL;
                        break;
                }
        }
        if (wo != NULL && options_owner(o) != wo) {
                parent = options_get_only(wo, name);
                if (parent != NULL) {
                        value = options_to_string(parent, NULL, 0);
                        xsnprintf(label, sizeof label,
                            "Window value (from window %u): ", fs.wl->idx);
                        if (!window_customize_write_value(ctx, s->cx, sx,
                            sy - (s->cy - cy), 0, label, "%s%s%s", value, space,
                            unit))
                                goto out;
                }
        }
        if (go != NULL && options_owner(o) != go) {
                parent = options_get_only(go, name);
                if (parent != NULL) {
                        value = options_to_string(parent, NULL, 0);
                        if (!window_customize_write_value(ctx, s->cx, sx,
                            sy - (s->cy - cy), 0, "Global value: ", "%s%s%s",
                            value, space, unit))
                                goto out;
                }
        }

out:
        free(value);
        free(default_value);
        format_free(ft);
}

static void
window_customize_draw_environment(struct window_customize_modedata *data,
    struct window_customize_itemdata *item, struct screen_write_ctx *ctx,
    u_int sx, u_int sy)
{
        struct screen            *s = ctx->s;
        u_int                     cx = s->cx, cy = s->cy;
        struct environ_entry     *envent, *parent;
        struct cmd_find_state     fs;
        const char               *text;

        if (!window_customize_check_item(data, item, &fs))
                return;
        envent = environ_find(item->environ, item->name);
        if (envent == NULL)
                return;

        if (item->scope == WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT)
                text = "global";
        else
                text = "session";
        if (!screen_write_text(ctx, cx, sx, sy, 0, &grid_default_cell,
            "This is a %s environment variable.", text))
                return;
        if (envent->flags & ENVIRON_HIDDEN) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
                    &grid_default_cell, "This variable is hidden."))
                        return;
        }

        screen_write_cursormove(ctx, cx, s->cy + 1, 0); /* skip line */
        if (s->cy >= cy + sy - 1)
                return;

        if (envent->value == NULL) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
                    &grid_default_cell, "Variable is removed."))
                        return;
        } else {
                if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy),
                    0, "Variable value: ", "%s", envent->value))
                        return;
        }

        if (item->scope != WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT)
                return;

        parent = environ_find(global_environ, item->name);
        if (parent == NULL)
                return;
        if (parent->value == NULL) {
                if (!screen_write_text(ctx, cx, sx, sy - (s->cy - cy), 0,
                    &grid_default_cell, "Global variable is removed."))
                        return;
        } else {
                if (!window_customize_write_value(ctx, cx, sx, sy - (s->cy - cy),
                    0, "Global value: ", "%s", parent->value))
                        return;
        }
}

static void
window_customize_draw(void *modedata, void *itemdata,
    struct screen_write_ctx *ctx, u_int sx, u_int sy)
{
        struct window_customize_modedata        *data = modedata;
        struct window_customize_itemdata        *item = itemdata;

        if (item == NULL)
                return;

        if (item->type == WINDOW_CUSTOMIZE_ITEM_KEY)
                window_customize_draw_key(data, item, ctx, sx, sy);
        else if (item->type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT)
                window_customize_draw_environment(data, item, ctx, sx, sy);
        else
                window_customize_draw_option(data, item, ctx, sx, sy);
}

static void
window_customize_menu(void *modedata, struct client *c, key_code key)
{
        struct window_customize_modedata        *data = modedata;
        struct window_pane                      *wp = data->wp;
        struct window_mode_entry                *wme;

        wme = TAILQ_FIRST(&wp->modes);
        if (wme == NULL || wme->data != modedata)
                return;
        window_customize_key(wme, c, NULL, NULL, key, NULL);
}

static u_int
window_customize_height(__unused void *modedata, __unused u_int height)
{
        return (12);
}

static const char* window_customize_help_lines[] = {
        "#[fg=themelightgrey]"
        "   Enter, s #[#{E:tree-mode-border-style},acs]x#[default] Set %1 value",
        "#[fg=themelightgrey]"
        "          S #[#{E:tree-mode-border-style},acs]x#[default] Set global %1 value",
        "#[fg=themelightgrey]"
        "          w #[#{E:tree-mode-border-style},acs]x#[default] Set window %1 value",
        "#[fg=themelightgrey]"
        "          d #[#{E:tree-mode-border-style},acs]x#[default] Set to default value",
        "#[fg=themelightgrey]"
        "          D #[#{E:tree-mode-border-style},acs]x#[default] Set tagged %1s to default value",
        "#[fg=themelightgrey]"
        "          u #[#{E:tree-mode-border-style},acs]x#[default] Unset an %1",
        "#[fg=themelightgrey]"
        "          U #[#{E:tree-mode-border-style},acs]x#[default] Unset tagged %1s",
        "#[fg=themelightgrey]"
        "          a #[#{E:tree-mode-border-style},acs]x#[default] Change array key",
        "#[fg=themelightgrey]"
        "          e #[#{E:tree-mode-border-style},acs]x#[default] Open %1 value in editor",
        "#[fg=themelightgrey]"
        "          f #[#{E:tree-mode-border-style},acs]x#[default] Enter a filter",
        "#[fg=themelightgrey]"
        "          C #[#{E:tree-mode-border-style},acs]x#[default] Toggle only changed items",
        "#[fg=themelightgrey]"
        "          v #[#{E:tree-mode-border-style},acs]x#[default] Toggle information",
        NULL
};

static const char**
window_customize_help(u_int *width, const char **item)
{
        *width = 52;
        *item = "item";
        return (window_customize_help_lines);
}

static struct screen *
window_customize_init(struct window_mode_entry *wme,
    __unused struct cmdq_item *item, struct cmd_find_state *fs,
    struct args *args)
{
        struct window_pane                      *wp = wme->wp;
        struct window_customize_modedata        *data;
        struct screen                           *s;

        wme->data = data = xcalloc(1, sizeof *data);
        data->wp = wp;
        data->references = 1;

        memcpy(&data->fs, fs, sizeof data->fs);

        if (args == NULL || !args_has(args, 'F'))
                data->format = xstrdup(WINDOW_CUSTOMIZE_DEFAULT_FORMAT);
        else
                data->format = xstrdup(args_get(args, 'F'));
        if (args_has(args, 'y'))
                data->prompt_flags = PROMPT_ACCEPT;

        data->data = mode_tree_start(wp, args, window_customize_build,
            window_customize_draw, NULL, window_customize_menu,
            window_customize_height, NULL, NULL, NULL, window_customize_help,
            data, window_customize_menu_items, &s);
        mode_tree_zoom(data->data, args);

        mode_tree_build(data->data);
        mode_tree_draw(data->data);

        return (s);
}

static void
window_customize_destroy(struct window_customize_modedata *data)
{
        u_int   i;

        if (--data->references != 0)
                return;

        for (i = 0; i < data->item_size; i++)
                window_customize_free_item(data->item_list[i]);
        free(data->item_list);

        free(data->format);

        free(data);
}

static void
window_customize_free(struct window_mode_entry *wme)
{
        struct window_customize_modedata *data = wme->data;

        if (data == NULL)
                return;

        data->dead = 1;
        if (data->editor != NULL) {
                spawn_cancel_editor(data->editor);
                window_customize_finish_edit(data->edit);
        }
        mode_tree_free(data->data);
        window_customize_destroy(data);
}

static void
window_customize_resize(struct window_mode_entry *wme, u_int sx, u_int sy)
{
        struct window_customize_modedata        *data = wme->data;

        mode_tree_resize(data->data, sx, sy);
}

static void
window_customize_update(struct window_mode_entry *wme)
{
        struct window_customize_modedata        *data = wme->data;

        window_customize_draw_waiting(data);
}

static void
window_customize_free_callback(void *modedata)
{
        window_customize_destroy(modedata);
}

static void
window_customize_free_item_callback(void *itemdata)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;

        window_customize_free_item(item);
        window_customize_destroy(data);
}

static enum prompt_result
window_customize_set_option_callback(struct client *c, void *itemdata,
    const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;
        struct options_entry                    *o;
        const struct options_table_entry        *oe;
        struct options                          *oo = item->oo;
        const char                              *name = item->name;
        const char                              *array_key = item->array_key;
        char                                    *cause;
        u_int                                    idx;
        char                                     keybuf[32];

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        if (item == NULL || !window_customize_check_item(data, item, NULL))
                return (PROMPT_CLOSE);
        o = options_get(oo, name);
        if (o == NULL)
                return (PROMPT_CLOSE);
        oe = options_table_entry(o);

        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_ARRAY)) {
                if (array_key == NULL) {
                        for (idx = 0; idx < INT_MAX; idx++) {
                                if (options_array_getv(o, "%u", idx) == NULL)
                                        break;
                        }
                        xsnprintf(keybuf, sizeof keybuf, "%u", idx);
                        array_key = keybuf;
                }
                if (options_array_set(o, array_key, s, 0, &cause) != 0)
                        goto fail;
        } else {
                if (options_from_string(oo, oe, name, s, 0, &cause) != 0)
                        goto fail;
        }
        if (item->option_type == WINDOW_CUSTOMIZE_HOOKS && *name == '@')
                hooks_add_event(name);

        options_push_changes(item->name);
        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);

fail:
        *cause = toupper((u_char)*cause);
        status_message_set(c, -1, 1, 0, 0, "%s", cause);
        free(cause);
        return (PROMPT_CLOSE);
}

static enum prompt_result
window_customize_set_environment_callback(__unused struct client *c,
    void *itemdata, const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;
        struct environ_entry            *envent;
        int                              flags;

        if (s == NULL || data->dead)
                return (PROMPT_CLOSE);
        if (item == NULL || !window_customize_check_item(data, item, NULL))
                return (PROMPT_CLOSE);

        flags = item->environ_flags;
        envent = environ_find(item->environ, item->name);
        if (envent != NULL)
                flags = envent->flags;
        environ_set(item->environ, item->name, flags, "%s", s);

        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);
}

static void
window_customize_set_environment(struct client *c,
    struct window_customize_modedata *data,
    struct window_customize_itemdata *item, int global)
{
        struct window_customize_itemdata        *new_item;
        struct environ_entry            *envent;
        struct environ                  *env;
        enum window_customize_scope      scope;
        struct cmd_find_state            fs;
        const char                      *space = "";
        char                            *prompt, *text;

        if (item == NULL || !window_customize_check_item(data, item, &fs))
                return;
        envent = environ_find(item->environ, item->name);
        if (envent == NULL)
                return;

        if (global) {
                scope = WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT;
                env = global_environ;
        } else {
                scope = item->scope;
                env = item->environ;
        }

        text = window_customize_scope_text(scope, &fs);
        if (*text != '\0')
                space = ", for ";
        else if (scope == WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT)
                space = ", global";
        xasprintf(&prompt, "(%s%s%s) ", item->name, space, text);
        free(text);

        new_item = xcalloc(1, sizeof *new_item);
        new_item->data = data;
        new_item->type = WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT;
        new_item->scope = scope;
        new_item->environ = env;
        new_item->environ_flags = envent->flags;
        new_item->name = xstrdup(item->name);

        data->references++;
        mode_tree_set_prompt(data->data, c, prompt,
            envent->value == NULL ? "" : envent->value, PROMPT_TYPE_COMMAND,
            PROMPT_NOFORMAT, window_customize_set_environment_callback,
            window_customize_free_item_callback, new_item);

        free(prompt);
}

static enum prompt_result
window_customize_add_option_callback(struct client *c, void *itemdata,
    const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;
        char                            *copy, *name, *array_key;
        const char                      *value;
        const char                      *what;
        int                              ambiguous;
        size_t                           namelen;

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        if (item == NULL || !window_customize_check_item(data, item, NULL))
                return (PROMPT_CLOSE);

        namelen = strcspn(s, " \t");
        if (namelen == 0 || s[namelen] == '\0') {
                status_message_set(c, -1, 1, 0, 0,
                    "User option must be @name value");
                return (PROMPT_CLOSE);
        }

        value = s + namelen;
        while (*value == ' ' || *value == '\t')
                value++;
        if (*value == '\0') {
                status_message_set(c, -1, 1, 0, 0,
                    "User option must be @name value");
                return (PROMPT_CLOSE);
        }

        copy = xstrndup(s, namelen);
        name = options_match(copy, &array_key, &ambiguous);
        free(copy);
        if (name == NULL || *name != '@' || array_key != NULL) {
                what = (item->option_type == WINDOW_CUSTOMIZE_HOOKS) ?
                    "hook" : "option";
                status_message_set(c, -1, 1, 0, 0,
                    "User %s name must start with @", what);
                free(name);
                free(array_key);
                return (PROMPT_CLOSE);
        }

        options_set_string(item->oo, name, 0, "%s", value);
        if (item->option_type == WINDOW_CUSTOMIZE_HOOKS)
                hooks_add_event(name);
        options_push_changes(name);

        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        free(name);
        free(array_key);
        return (PROMPT_CLOSE);
}

static void
window_customize_add_option(struct client *c,
    struct window_customize_modedata *data, enum window_customize_scope scope,
    struct options *oo, enum window_customize_option_type type)
{
        struct window_customize_itemdata        *new_item;
        char                            *prompt;
        const char                      *what;

        what = (type == WINDOW_CUSTOMIZE_HOOKS) ? "hook" : "option";
        xasprintf(&prompt, "New user %s: ", what);

        new_item = xcalloc(1, sizeof *new_item);
        new_item->data = data;
        new_item->type = WINDOW_CUSTOMIZE_ITEM_OPTION;
        new_item->option_type = type;
        new_item->scope = scope;
        new_item->oo = oo;

        data->references++;
        mode_tree_set_prompt(data->data, c, prompt, "@", PROMPT_TYPE_COMMAND,
            PROMPT_NOFORMAT, window_customize_add_option_callback,
            window_customize_free_item_callback, new_item);

        free(prompt);
}

static enum prompt_result
window_customize_add_environment_callback(struct client *c, void *itemdata,
    const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;
        char                            *name;
        const char                      *value;

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        if (item == NULL || !window_customize_check_item(data, item, NULL))
                return (PROMPT_CLOSE);

        if (*s == '-') {
                if (s[1] == '\0' || strchr(s + 1, '=') != NULL) {
                        status_message_set(c, -1, 1, 0, 0,
                            "Bad environment variable: %s", s);
                        return (PROMPT_CLOSE);
                }
                environ_clear(item->environ, s + 1);
        } else {
                value = strchr(s, '=');
                if (value == NULL || value == s) {
                        status_message_set(c, -1, 1, 0, 0,
                            "Environment variable must be NAME=value");
                        return (PROMPT_CLOSE);
                }

                name = xstrdup(s);
                name[strcspn(name, "=")] = '\0';
                environ_set(item->environ, name, 0, "%s", value + 1);
                free(name);
        }

        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);
}

static void
window_customize_add_environment(struct client *c,
    struct window_customize_modedata *data, enum window_customize_scope scope,
    struct environ *env)
{
        struct window_customize_itemdata        *new_item;

        new_item = xcalloc(1, sizeof *new_item);
        new_item->data = data;
        new_item->type = WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT;
        new_item->scope = scope;
        new_item->environ = env;

        data->references++;
        mode_tree_set_prompt(data->data, c, "New environment: ", "",
            PROMPT_TYPE_COMMAND, PROMPT_NOFORMAT,
            window_customize_add_environment_callback,
            window_customize_free_item_callback, new_item);
}

static void
window_customize_edit_close_cb(char *buf, size_t len, void *arg)
{
        struct window_customize_editdata                *ed = arg;
        struct window_customize_itemdata                *item = ed->item;
        struct window_pane                      *wp;
        struct window_mode_entry                *wme;
        struct window_customize_modedata        *data = NULL;
        char                                    *value, *cause = NULL;

        wp = window_pane_find_by_id(ed->wp_id);
        if (wp != NULL) {
                wme = TAILQ_FIRST(&wp->modes);
                if (wme != NULL && wme->mode == &window_customize_mode) {
                        data = wme->data;
                        if (data->editor == ed->editor) {
                                data->editor = NULL;
                                data->edit = NULL;
                        }
                }
        }

        if (buf == NULL || len == 0 || data == NULL || data->dead) {
                free(buf);
                window_customize_finish_edit(ed);
                return;
        }
        if (buf[len - 1] == '\n')
                len--;
        value = xmalloc(len + 1);
        memcpy(value, buf, len);
        value[len] = '\0';
        free(buf);

        switch (ed->edit_type) {
        case WINDOW_CUSTOMIZE_EDIT_OPTION:
                if (window_customize_option_editable(data, item) &&
                    window_customize_set_option_value(item, value, &cause) != 0) {
                        free(cause);
                        goto out;
                }
                break;
        case WINDOW_CUSTOMIZE_EDIT_KEY_COMMAND:
                if (window_customize_set_command_value(item, value, &cause) != 0) {
                        free(cause);
                        goto out;
                }
                break;
        case WINDOW_CUSTOMIZE_EDIT_KEY_NOTE:
                if (window_customize_set_note_value(item, value) != 0)
                        goto out;
                break;
        case WINDOW_CUSTOMIZE_EDIT_ENVIRONMENT:
                if (!window_customize_check_item(data, item, NULL))
                        goto out;
                window_customize_set_environment_value(item, value);
                break;
        }

        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        wp->flags |= PANE_REDRAW;

out:
        free(value);
        window_customize_finish_edit(ed);
}

static void
window_customize_start_edit(struct window_customize_modedata *data,
    struct window_customize_itemdata *item, struct client *c)
{
        struct window_customize_editdata        *ed;
        struct options_entry            *o;
        struct environ_entry            *envent;
        struct key_binding              *bd;
        const char                      *name;
        const char                      *buf;
        char                            *value;
        size_t                           len;
        enum window_customize_edit_type  edit_type;

        if (data->editor != NULL || item == NULL)
                return;

        if (item->type == WINDOW_CUSTOMIZE_ITEM_OPTION) {
                if (!window_customize_option_editable(data, item))
                        return;
                o = options_get(item->oo, item->name);
                if (o == NULL)
                        return;
                value = options_to_string(o, item->array_key, 0);
                edit_type = WINDOW_CUSTOMIZE_EDIT_OPTION;
        } else if (item->type == WINDOW_CUSTOMIZE_ITEM_KEY) {
                name = mode_tree_get_current_name(data->data);
                if (!window_customize_get_key(item, NULL, &bd))
                        return;
                if (strcmp(name, "Command") == 0) {
                        value = cmd_list_print(bd->cmdlist, 0);
                        edit_type = WINDOW_CUSTOMIZE_EDIT_KEY_COMMAND;
                } else if (strcmp(name, "Note") == 0) {
                        if (bd->note == NULL)
                                value = xstrdup("");
                        else
                                value = xstrdup(bd->note);
                        edit_type = WINDOW_CUSTOMIZE_EDIT_KEY_NOTE;
                } else
                        return;
        } else if (item->type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT) {
                if (!window_customize_check_item(data, item, NULL))
                        return;
                envent = environ_find(item->environ, item->name);
                if (envent == NULL || envent->value == NULL)
                        return;
                value = xstrdup(envent->value);
                edit_type = WINDOW_CUSTOMIZE_EDIT_ENVIRONMENT;
        } else
                return;

        ed = xcalloc(1, sizeof *ed);
        ed->wp_id = data->wp->id;
        ed->edit_type = edit_type;
        ed->item = window_customize_copy_item(item);

        buf = value;
        len = strlen(value);
        if (len == 0) {
                buf = "\n";
                len = 1;
        }
        ed->editor = spawn_editor(c, buf, len, window_customize_edit_close_cb,
            ed);
        free(value);
        if (ed->editor == NULL)
                window_customize_finish_edit(ed);
        else {
                data->editor = ed->editor;
                data->edit = ed;
        }
}

static void
window_customize_set_option(struct client *c,
    struct window_customize_modedata *data,
    struct window_customize_itemdata *item, int global, int pane)
{
        struct options_entry                    *o;
        const struct options_table_entry        *oe;
        struct options                          *oo;
        struct window_customize_itemdata        *new_item;
        int                                      flag;
        enum window_customize_scope              scope = WINDOW_CUSTOMIZE_NONE;
        u_int                                    choice;
        const char                              *name = item->name, *space = "";
        const char                              *array_key = item->array_key;
        char                                    *prompt, *value, *text;
        struct cmd_find_state                    fs;

        if (item == NULL || !window_customize_check_item(data, item, &fs))
                return;
        o = options_get(item->oo, name);
        if (o == NULL)
                return;

        oe = options_table_entry(o);
        if (oe != NULL && ~oe->scope & OPTIONS_TABLE_PANE)
                pane = 0;
        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_ARRAY)) {
                scope = item->scope;
                oo = item->oo;
        } else {
                if (global) {
                        switch (item->scope) {
                        case WINDOW_CUSTOMIZE_NONE:
                        case WINDOW_CUSTOMIZE_KEY:
                        case WINDOW_CUSTOMIZE_SERVER:
                        case WINDOW_CUSTOMIZE_GLOBAL_SESSION:
                        case WINDOW_CUSTOMIZE_GLOBAL_WINDOW:
                        case WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT:
                        case WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT:
                                scope = item->scope;
                                break;
                        case WINDOW_CUSTOMIZE_SESSION:
                                scope = WINDOW_CUSTOMIZE_GLOBAL_SESSION;
                                break;
                        case WINDOW_CUSTOMIZE_WINDOW:
                        case WINDOW_CUSTOMIZE_PANE:
                                scope = WINDOW_CUSTOMIZE_GLOBAL_WINDOW;
                                break;
                        }
                } else {
                        switch (item->scope) {
                        case WINDOW_CUSTOMIZE_NONE:
                        case WINDOW_CUSTOMIZE_KEY:
                        case WINDOW_CUSTOMIZE_SERVER:
                        case WINDOW_CUSTOMIZE_SESSION:
                                scope = item->scope;
                                break;
                        case WINDOW_CUSTOMIZE_WINDOW:
                        case WINDOW_CUSTOMIZE_PANE:
                                if (pane)
                                        scope = WINDOW_CUSTOMIZE_PANE;
                                else
                                        scope = WINDOW_CUSTOMIZE_WINDOW;
                                break;
                        case WINDOW_CUSTOMIZE_GLOBAL_SESSION:
                                scope = WINDOW_CUSTOMIZE_SESSION;
                                break;
                        case WINDOW_CUSTOMIZE_GLOBAL_WINDOW:
                                if (pane)
                                        scope = WINDOW_CUSTOMIZE_PANE;
                                else
                                        scope = WINDOW_CUSTOMIZE_WINDOW;
                                break;
                        case WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT:
                        case WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT:
                                scope = item->scope;
                                break;
                        }
                }
                if (scope == item->scope)
                        oo = item->oo;
                else
                        oo = window_customize_get_tree(scope, &fs);
        }

        if (oe != NULL && oe->type == OPTIONS_TABLE_FLAG) {
                flag = options_get_number(oo, name);
                options_set_number(oo, name, !flag);
        } else if (oe != NULL && oe->type == OPTIONS_TABLE_CHOICE) {
                choice = options_get_number(oo, name);
                if (oe->choices[choice + 1] == NULL)
                        choice = 0;
                else
                        choice++;
                options_set_number(oo, name, choice);
        } else {
                text = window_customize_scope_text(scope, &fs);
                if (*text != '\0')
                        space = ", for ";
                else if (scope != WINDOW_CUSTOMIZE_SERVER)
                        space = ", global";
                if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_ARRAY)) {
                        if (array_key == NULL) {
                                xasprintf(&prompt, "(%s[+]%s%s) ", name, space,
                                    text);
                        } else {
                                xasprintf(&prompt, "(%s[%s]%s%s) ", name,
                                    array_key, space, text);
                        }
                } else
                        xasprintf(&prompt, "(%s%s%s) ", name, space, text);
                free(text);

                value = options_to_string(o, array_key, 0);

                new_item = xcalloc(1, sizeof *new_item);
                new_item->data = data;
                new_item->type = WINDOW_CUSTOMIZE_ITEM_OPTION;
                new_item->option_type = item->option_type;
                new_item->scope = scope;
                new_item->oo = oo;
                new_item->name = xstrdup(name);
                if (array_key != NULL)
                        new_item->array_key = xstrdup(array_key);

                data->references++;
                mode_tree_set_prompt(data->data, c, prompt, value,
                    PROMPT_TYPE_COMMAND, PROMPT_NOFORMAT,
                    window_customize_set_option_callback,
                    window_customize_free_item_callback, new_item);

                free(prompt);
                free(value);
        }
}

static enum prompt_result
window_customize_set_array_key_callback(struct client *c, void *itemdata,
    const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data;
        struct options_entry                    *o;
        const char                              *name, *array_key;
        char                                    *value, *cause;

        if (item == NULL)
                return (PROMPT_CLOSE);
        data = item->data;
        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        name = item->name;
        array_key = item->array_key;
        if (array_key == NULL || !window_customize_check_item(data, item, NULL))
                return (PROMPT_CLOSE);

        o = options_get(item->oo, name);
        if (o == NULL)
                return (PROMPT_CLOSE);
        if (options_array_get(o, s) != NULL)
                return (PROMPT_CLOSE);

        value = options_to_string(o, array_key, 0);
        if (options_array_set(o, s, value, 0, &cause) != 0)
                goto fail;
        free(value);

        options_array_set(o, array_key, NULL, 0, NULL);
        options_push_changes(item->name);
        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);

fail:
        free(value);
        *cause = toupper((u_char)*cause);
        status_message_set(c, -1, 1, 0, 0, "%s", cause);
        free(cause);
        return (PROMPT_CLOSE);
}

static void
window_customize_set_array_key(struct client *c,
    struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        struct window_customize_itemdata        *new_item;
        char                            *prompt;

        if (item == NULL ||
            item->array_key == NULL ||
            !window_customize_check_item(data, item, NULL))
                return;

        xasprintf(&prompt, "(%s[%s]) ", item->name, item->array_key);

        new_item = xcalloc(1, sizeof *new_item);
        new_item->data = data;
        new_item->type = WINDOW_CUSTOMIZE_ITEM_OPTION;
        new_item->option_type = item->option_type;
        new_item->scope = item->scope;
        new_item->oo = item->oo;
        new_item->name = xstrdup(item->name);
        new_item->array_key = xstrdup(item->array_key);

        data->references++;
        mode_tree_set_prompt(data->data, c, prompt, item->array_key,
            PROMPT_TYPE_COMMAND, PROMPT_NOFORMAT,
            window_customize_set_array_key_callback,
            window_customize_free_item_callback, new_item);

        free(prompt);
}

static void
window_customize_unset_environment(struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        if (item == NULL || !window_customize_check_item(data, item, NULL))
                return;
        if (environ_find(item->environ, item->name) == NULL)
                return;
        if (item == mode_tree_get_current(data->data))
                mode_tree_up(data->data, 0);
        environ_unset(item->environ, item->name);
}

static void
window_customize_unset_option(struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        struct options_entry    *o;

        if (item == NULL || !window_customize_check_item(data, item, NULL))
                return;

        o = options_get(item->oo, item->name);
        if (o == NULL)
                return;
        if (item->array_key != NULL &&
            item == mode_tree_get_current(data->data))
                mode_tree_up(data->data, 0);
        options_remove_or_default(o, item->array_key, NULL);
}

static void
window_customize_reset_option(struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        struct options          *oo;
        struct options_entry    *o;

        if (item == NULL || !window_customize_check_item(data, item, NULL))
                return;
        if (item->array_key != NULL)
                return;

        oo = item->oo;
        while (oo != NULL) {
                o = options_get_only(oo, item->name);
                if (o != NULL)
                        options_remove_or_default(o, NULL, NULL);
                oo = options_get_parent(oo);
        }
}

static enum prompt_result
window_customize_set_command_callback(struct client *c, void *itemdata,
    const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;
        struct key_binding                      *bd;
        struct cmd_parse_result                 *pr;
        char                                    *error;

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        if (item == NULL || !window_customize_get_key(item, NULL, &bd))
                return (PROMPT_CLOSE);

        pr = cmd_parse_from_string(s, NULL);
        switch (pr->status) {
        case CMD_PARSE_ERROR:
                error = pr->error;
                goto fail;
        case CMD_PARSE_SUCCESS:
                break;
        }
        cmd_list_free(bd->cmdlist);
        bd->cmdlist = pr->cmdlist;

        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);

fail:
        *error = toupper((u_char)*error);
        status_message_set(c, -1, 1, 0, 0, "%s", error);
        free(error);
        return (PROMPT_CLOSE);
}

static enum prompt_result
window_customize_set_note_callback(__unused struct client *c, void *itemdata,
    const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;
        struct key_binding                      *bd;

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        if (item == NULL || !window_customize_get_key(item, NULL, &bd))
                return (PROMPT_CLOSE);

        free((void *)bd->note);
        bd->note = xstrdup(s);

        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);
}

static void
window_customize_set_key(struct client *c,
    struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        key_code                                 key = item->key;
        struct key_binding                      *bd;
        const char                              *s;
        char                                    *prompt, *value;
        struct window_customize_itemdata        *new_item;

        if (item == NULL || !window_customize_get_key(item, NULL, &bd))
                return;

        s = mode_tree_get_current_name(data->data);
        if (strcmp(s, "Repeat") == 0)
                bd->flags ^= KEY_BINDING_REPEAT;
        else if (strcmp(s, "Command") == 0) {
                xasprintf(&prompt, "(%s) ", key_string_lookup_key(key, 0));
                value = cmd_list_print(bd->cmdlist, 0);

                new_item = xcalloc(1, sizeof *new_item);
                new_item->data = data;
                new_item->type = WINDOW_CUSTOMIZE_ITEM_KEY;
                new_item->scope = item->scope;
                new_item->table = xstrdup(item->table);
                new_item->key = key;

                data->references++;
                mode_tree_set_prompt(data->data, c, prompt, value,
                    PROMPT_TYPE_COMMAND, PROMPT_NOFORMAT,
                    window_customize_set_command_callback,
                    window_customize_free_item_callback, new_item);
                free(prompt);
                free(value);
        } else if (strcmp(s, "Note") == 0) {
                xasprintf(&prompt, "(%s) ", key_string_lookup_key(key, 0));

                new_item = xcalloc(1, sizeof *new_item);
                new_item->data = data;
                new_item->type = WINDOW_CUSTOMIZE_ITEM_KEY;
                new_item->scope = item->scope;
                new_item->table = xstrdup(item->table);
                new_item->key = key;

                data->references++;
                mode_tree_set_prompt(data->data, c, prompt,
                    (bd->note == NULL ? "" : bd->note),
                    PROMPT_TYPE_COMMAND, PROMPT_NOFORMAT,
                    window_customize_set_note_callback,
                    window_customize_free_item_callback, new_item);
                free(prompt);
        }
}

static enum prompt_result
window_customize_add_key_callback(struct client *c, void *itemdata,
    const char *s, __unused enum prompt_key_result key0)
{
        struct window_customize_itemdata        *item = itemdata;
        struct window_customize_modedata        *data = item->data;
        key_code                         key;
        struct cmd_parse_result         *pr;
        const char                      *command;
        char                            *error, *keystr;
        size_t                           keylen;

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);

        keylen = strcspn(s, " \t");
        if (keylen == 0 || s[keylen] == '\0') {
                status_message_set(c, -1, 1, 0, 0,
                    "Key binding must be key command");
                return (PROMPT_CLOSE);
        }

        command = s + keylen;
        while (*command == ' ' || *command == '\t')
                command++;
        if (*command == '\0') {
                status_message_set(c, -1, 1, 0, 0,
                    "Key binding must be key command");
                return (PROMPT_CLOSE);
        }

        keystr = xstrndup(s, keylen);
        key = key_string_lookup_string(keystr);
        if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
                status_message_set(c, -1, 1, 0, 0, "Unknown key: %s", keystr);
                free(keystr);
                return (PROMPT_CLOSE);
        }
        free(keystr);

        pr = cmd_parse_from_string(command, NULL);
        switch (pr->status) {
        case CMD_PARSE_ERROR:
                error = pr->error;
                goto fail;
        case CMD_PARSE_SUCCESS:
                break;
        }
        key_bindings_add(item->table, key, NULL, 0, pr->cmdlist);

        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);

fail:
        *error = toupper((u_char)*error);
        status_message_set(c, -1, 1, 0, 0, "%s", error);
        free(error);
        return (PROMPT_CLOSE);
}

static void
window_customize_add_key(struct client *c,
    struct window_customize_modedata *data, const char *table)
{
        struct window_customize_itemdata        *new_item;
        char                            *prompt;

        xasprintf(&prompt, "New key in %s: ", table);

        new_item = xcalloc(1, sizeof *new_item);
        new_item->data = data;
        new_item->type = WINDOW_CUSTOMIZE_ITEM_KEY;
        new_item->scope = WINDOW_CUSTOMIZE_KEY;
        new_item->table = xstrdup(table);

        data->references++;
        mode_tree_set_prompt(data->data, c, prompt, "", PROMPT_TYPE_COMMAND,
            PROMPT_NOFORMAT, window_customize_add_key_callback,
            window_customize_free_item_callback, new_item);

        free(prompt);
}

static void
window_customize_unset_key(struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        struct key_table        *kt;
        struct key_binding      *bd;

        if (item == NULL || !window_customize_get_key(item, &kt, &bd))
                return;

        if (item == mode_tree_get_current(data->data))
                mode_tree_up(data->data, 0);
        key_bindings_remove(kt->name, bd->key);
}

static void
window_customize_reset_key(struct window_customize_modedata *data,
    struct window_customize_itemdata *item)
{
        struct key_table        *kt;
        struct key_binding      *dd, *bd;

        if (item == NULL || !window_customize_get_key(item, &kt, &bd))
                return;

        dd = key_bindings_get_default(kt, bd->key);
        if (dd != NULL && bd->cmdlist == dd->cmdlist)
                return;
        if (dd == NULL && item == mode_tree_get_current(data->data))
                mode_tree_up(data->data, 0);
        key_bindings_reset(kt->name, bd->key);
}

static void
window_customize_change_each(void *modedata, void *itemdata,
    __unused struct client *c, __unused key_code key)
{
        struct window_customize_modedata        *data = modedata;
        struct window_customize_itemdata        *item = itemdata;
        enum window_customize_item_type  type = item->type;
        char                            *name = NULL;

        if (type == WINDOW_CUSTOMIZE_ITEM_OPTION)
                name = xstrdup(item->name);
        switch (data->change) {
        case WINDOW_CUSTOMIZE_UNSET:
                if (type == WINDOW_CUSTOMIZE_ITEM_KEY)
                        window_customize_unset_key(data, item);
                else if (type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT)
                        window_customize_unset_environment(data, item);
                else
                        window_customize_unset_option(data, item);
                break;
        case WINDOW_CUSTOMIZE_RESET:
                if (type == WINDOW_CUSTOMIZE_ITEM_KEY)
                        window_customize_reset_key(data, item);
                else if (type == WINDOW_CUSTOMIZE_ITEM_OPTION)
                        window_customize_reset_option(data, item);
                break;
        }
        if (type == WINDOW_CUSTOMIZE_ITEM_OPTION)
                options_push_changes(name);
        free(name);
}

static enum prompt_result
window_customize_change_current_callback(__unused struct client *c,
    void *modedata, const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_modedata        *data = modedata;
        struct window_customize_itemdata        *item;
        enum window_customize_item_type  type;
        char                            *name = NULL;

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
                return (PROMPT_CLOSE);

        item = mode_tree_get_current(data->data);
        if (item == NULL)
                return (PROMPT_CLOSE);
        type = item->type;
        if (type == WINDOW_CUSTOMIZE_ITEM_OPTION)
                name = xstrdup(item->name);
        switch (data->change) {
        case WINDOW_CUSTOMIZE_UNSET:
                if (type == WINDOW_CUSTOMIZE_ITEM_KEY)
                        window_customize_unset_key(data, item);
                else if (type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT)
                        window_customize_unset_environment(data, item);
                else
                        window_customize_unset_option(data, item);
                break;
        case WINDOW_CUSTOMIZE_RESET:
                if (type == WINDOW_CUSTOMIZE_ITEM_KEY)
                        window_customize_reset_key(data, item);
                else if (type == WINDOW_CUSTOMIZE_ITEM_OPTION)
                        window_customize_reset_option(data, item);
                break;
        }
        if (type == WINDOW_CUSTOMIZE_ITEM_OPTION)
                options_push_changes(name);
        free(name);
        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);
}

static enum prompt_result
window_customize_change_tagged_callback(struct client *c, void *modedata,
    const char *s, __unused enum prompt_key_result key)
{
        struct window_customize_modedata        *data = modedata;

        if (s == NULL || *s == '\0' || data->dead)
                return (PROMPT_CLOSE);
        if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
                return (PROMPT_CLOSE);

        mode_tree_each_tagged(data->data, window_customize_change_each, c,
            KEYC_NONE, 0);
        mode_tree_build(data->data);
        mode_tree_draw(data->data);
        data->wp->flags |= PANE_REDRAW;

        return (PROMPT_CLOSE);
}

static int
window_customize_add_current(struct client *c,
    struct window_customize_modedata *data)
{
        struct cmd_find_state    fs;
        const char              *name, *table;

        name = mode_tree_get_current_name(data->data);
        if (cmd_find_valid_state(&data->fs))
                cmd_find_copy_state(&fs, &data->fs);
        else
                cmd_find_from_pane(&fs, data->wp, 0);

        if (strcmp(name, "Server Options") == 0) {
                window_customize_add_option(c, data, WINDOW_CUSTOMIZE_SERVER,
                    global_options, WINDOW_CUSTOMIZE_OPTIONS);
                return (1);
        }
        if (strcmp(name, "Session Options") == 0) {
                window_customize_add_option(c, data, WINDOW_CUSTOMIZE_SESSION,
                    fs.s->options, WINDOW_CUSTOMIZE_OPTIONS);
                return (1);
        }
        if (strcmp(name, "Window & Pane Options") == 0) {
                window_customize_add_option(c, data, WINDOW_CUSTOMIZE_PANE,
                    fs.wp->options, WINDOW_CUSTOMIZE_OPTIONS);
                return (1);
        }
        if (strcmp(name, "Session Hooks") == 0) {
                window_customize_add_option(c, data, WINDOW_CUSTOMIZE_SESSION,
                    fs.s->options, WINDOW_CUSTOMIZE_HOOKS);
                return (1);
        }
        if (strcmp(name, "Window & Pane Hooks") == 0) {
                window_customize_add_option(c, data, WINDOW_CUSTOMIZE_PANE,
                    fs.wp->options, WINDOW_CUSTOMIZE_HOOKS);
                return (1);
        }
        if (strcmp(name, "Global Environment") == 0) {
                window_customize_add_environment(c, data,
                    WINDOW_CUSTOMIZE_GLOBAL_ENVIRONMENT, global_environ);
                return (1);
        }
        if (strcmp(name, "Session Environment") == 0) {
                window_customize_add_environment(c, data,
                    WINDOW_CUSTOMIZE_SESSION_ENVIRONMENT, fs.s->environ);
                return (1);
        }

        if (strncmp(name, "Key Table - ", 12) == 0) {
                table = name + 12;
                window_customize_add_key(c, data, table);
                return (1);
        }
        return (0);
}

static void
window_customize_key(struct window_mode_entry *wme, struct client *c,
    __unused struct session *s, __unused struct winlink *wl, key_code key,
    struct mouse_event *m)
{
        struct window_pane                      *wp = wme->wp;
        struct window_customize_modedata        *data = wme->data;
        struct window_customize_itemdata        *item, *new_item;
        int                                      finished;
        char                                    *prompt;
        u_int                                    tagged;

        item = mode_tree_get_current(data->data);
        if (data->editor != NULL) {
                if (key == 'q' || key == '\033' || key == '\003')
                        finished = 1;
                else
                        finished = 0;
                goto out;
        }

        finished = mode_tree_key(data->data, c, &key, m, NULL, NULL);
        if (item != (new_item = mode_tree_get_current(data->data)))
                item = new_item;

        switch (key) {
        case 'e':
                window_customize_start_edit(data, item, c);
                break;
        case 'a':
                if (item == NULL || item->type != WINDOW_CUSTOMIZE_ITEM_OPTION)
                        break;
                window_customize_set_array_key(c, data, item);
                break;
        case '\r':
        case 's':
                if (item == NULL) {
                        if (window_customize_add_current(c, data))
                                mode_tree_build(data->data);
                        break;
                }
                if (item->type == WINDOW_CUSTOMIZE_ITEM_KEY)
                        window_customize_set_key(c, data, item);
                else if (item->type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT)
                        window_customize_set_environment(c, data, item, 0);
                else {
                        window_customize_set_option(c, data, item, 0, 1);
                        options_push_changes(item->name);
                }
                mode_tree_build(data->data);
                break;
        case 'w':
                if (item == NULL || item->type != WINDOW_CUSTOMIZE_ITEM_OPTION)
                        break;
                window_customize_set_option(c, data, item, 0, 0);
                options_push_changes(item->name);
                mode_tree_build(data->data);
                break;
        case 'S':
        case 'W':
                if (item == NULL || item->type == WINDOW_CUSTOMIZE_ITEM_KEY)
                        break;
                if (item->type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT)
                        window_customize_set_environment(c, data, item, 1);
                else {
                        window_customize_set_option(c, data, item, 1, 0);
                        options_push_changes(item->name);
                }
                mode_tree_build(data->data);
                break;
        case 'd':
                if (item == NULL ||
                    (item->type == WINDOW_CUSTOMIZE_ITEM_OPTION &&
                    item->array_key != NULL) ||
                    item->type == WINDOW_CUSTOMIZE_ITEM_ENVIRONMENT)
                        break;
                xasprintf(&prompt, "Reset %s to default? ", item->name);
                data->references++;
                data->change = WINDOW_CUSTOMIZE_RESET;
                mode_tree_set_prompt(data->data, c, prompt, "",
                    PROMPT_TYPE_COMMAND,
                    PROMPT_SINGLE|PROMPT_NOFORMAT|data->prompt_flags,
                    window_customize_change_current_callback,
                    window_customize_free_callback, data);
                free(prompt);
                break;
        case 'D':
                tagged = mode_tree_count_tagged(data->data);
                if (tagged == 0)
                        break;
                xasprintf(&prompt, "Reset %u tagged to default? ", tagged);
                data->references++;
                data->change = WINDOW_CUSTOMIZE_RESET;
                mode_tree_set_prompt(data->data, c, prompt, "",
                    PROMPT_TYPE_COMMAND,
                    PROMPT_SINGLE|PROMPT_NOFORMAT|data->prompt_flags,
                    window_customize_change_tagged_callback,
                    window_customize_free_callback, data);
                free(prompt);
                break;
        case 'u':
                if (item == NULL)
                        break;
                if (item->array_key != NULL) {
                        xasprintf(&prompt, "Unset %s[%s]? ", item->name,
                            item->array_key);
                } else
                        xasprintf(&prompt, "Unset %s? ", item->name);
                data->references++;
                data->change = WINDOW_CUSTOMIZE_UNSET;
                mode_tree_set_prompt(data->data, c, prompt, "",
                    PROMPT_TYPE_COMMAND,
                    PROMPT_SINGLE|PROMPT_NOFORMAT|data->prompt_flags,
                    window_customize_change_current_callback,
                    window_customize_free_callback, data);
                free(prompt);
                break;
        case 'U':
                tagged = mode_tree_count_tagged(data->data);
                if (tagged == 0)
                        break;
                xasprintf(&prompt, "Unset %u tagged? ", tagged);
                data->references++;
                data->change = WINDOW_CUSTOMIZE_UNSET;
                mode_tree_set_prompt(data->data, c, prompt, "",
                    PROMPT_TYPE_COMMAND,
                    PROMPT_SINGLE|PROMPT_NOFORMAT|data->prompt_flags,
                    window_customize_change_tagged_callback,
                    window_customize_free_callback, data);
                free(prompt);
                break;
        case 'H':
                data->hide_global = !data->hide_global;
                mode_tree_build(data->data);
                break;
        case 'C':
                data->hide_default = !data->hide_default;
                mode_tree_build(data->data);
                break;
        }

out:
        if (finished)
                window_pane_reset_mode(wp);
        else {
                mode_tree_draw(data->data);
                window_customize_draw_waiting(data);
                wp->flags |= PANE_REDRAW;
        }
}