/* TUI window generic functions. Copyright (C) 1998-2020 Free Software Foundation, Inc. Contributed by Hewlett-Packard Company. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /* This module contains procedures for handling tui window functions like resize, scrolling, scrolling, changing focus, etc. Author: Susan B. Macchia */ #include "defs.h" #include "command.h" #include "symtab.h" #include "breakpoint.h" #include "frame.h" #include "cli/cli-cmds.h" #include "cli/cli-style.h" #include "top.h" #include "source.h" #include "gdbsupport/event-loop.h" #include "gdbcmd.h" #include "async-event.h" #include "tui/tui.h" #include "tui/tui-io.h" #include "tui/tui-command.h" #include "tui/tui-data.h" #include "tui/tui-layout.h" #include "tui/tui-wingeneral.h" #include "tui/tui-stack.h" #include "tui/tui-regs.h" #include "tui/tui-disasm.h" #include "tui/tui-source.h" #include "tui/tui-winsource.h" #include "tui/tui-win.h" #include "gdb_curses.h" #include #include "readline/readline.h" #include "gdbsupport/gdb_string_view.h" #include static void tui_set_tab_width_command (const char *, int); static void tui_refresh_all_command (const char *, int); static void tui_all_windows_info (const char *, int); static void tui_scroll_forward_command (const char *, int); static void tui_scroll_backward_command (const char *, int); static void tui_scroll_left_command (const char *, int); static void tui_scroll_right_command (const char *, int); static void parse_scrolling_args (const char *, struct tui_win_info **, int *); #ifndef ACS_LRCORNER # define ACS_LRCORNER '+' #endif #ifndef ACS_LLCORNER # define ACS_LLCORNER '+' #endif #ifndef ACS_ULCORNER # define ACS_ULCORNER '+' #endif #ifndef ACS_URCORNER # define ACS_URCORNER '+' #endif #ifndef ACS_HLINE # define ACS_HLINE '-' #endif #ifndef ACS_VLINE # define ACS_VLINE '|' #endif /* Possible values for tui-border-kind variable. */ static const char *const tui_border_kind_enums[] = { "space", "ascii", "acs", NULL }; /* Possible values for tui-border-mode and tui-active-border-mode. */ static const char *const tui_border_mode_enums[] = { "normal", "standout", "reverse", "half", "half-standout", "bold", "bold-standout", NULL }; struct tui_translate { const char *name; int value; }; /* Translation table for border-mode variables. The list of values must be terminated by a NULL. After the NULL value, an entry defines the default. */ static struct tui_translate tui_border_mode_translate[] = { { "normal", A_NORMAL }, { "standout", A_STANDOUT }, { "reverse", A_REVERSE }, { "half", A_DIM }, { "half-standout", A_DIM | A_STANDOUT }, { "bold", A_BOLD }, { "bold-standout", A_BOLD | A_STANDOUT }, { 0, 0 }, { "normal", A_NORMAL } }; /* Translation tables for border-kind, one for each border character (see wborder, border curses operations). -1 is used to indicate the ACS because ACS characters are determined at run time by curses (depends on terminal). */ static struct tui_translate tui_border_kind_translate_vline[] = { { "space", ' ' }, { "ascii", '|' }, { "acs", -1 }, { 0, 0 }, { "ascii", '|' } }; static struct tui_translate tui_border_kind_translate_hline[] = { { "space", ' ' }, { "ascii", '-' }, { "acs", -1 }, { 0, 0 }, { "ascii", '-' } }; static struct tui_translate tui_border_kind_translate_ulcorner[] = { { "space", ' ' }, { "ascii", '+' }, { "acs", -1 }, { 0, 0 }, { "ascii", '+' } }; static struct tui_translate tui_border_kind_translate_urcorner[] = { { "space", ' ' }, { "ascii", '+' }, { "acs", -1 }, { 0, 0 }, { "ascii", '+' } }; static struct tui_translate tui_border_kind_translate_llcorner[] = { { "space", ' ' }, { "ascii", '+' }, { "acs", -1 }, { 0, 0 }, { "ascii", '+' } }; static struct tui_translate tui_border_kind_translate_lrcorner[] = { { "space", ' ' }, { "ascii", '+' }, { "acs", -1 }, { 0, 0 }, { "ascii", '+' } }; /* Tui configuration variables controlled with set/show command. */ static const char *tui_active_border_mode = "bold-standout"; static void show_tui_active_border_mode (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("\ The attribute mode to use for the active TUI window border is \"%s\".\n"), value); } static const char *tui_border_mode = "normal"; static void show_tui_border_mode (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("\ The attribute mode to use for the TUI window borders is \"%s\".\n"), value); } static const char *tui_border_kind = "acs"; static void show_tui_border_kind (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("The kind of border for TUI windows is \"%s\".\n"), value); } /* Tui internal configuration variables. These variables are updated by tui_update_variables to reflect the tui configuration variables. */ chtype tui_border_vline; chtype tui_border_hline; chtype tui_border_ulcorner; chtype tui_border_urcorner; chtype tui_border_llcorner; chtype tui_border_lrcorner; int tui_border_attrs; int tui_active_border_attrs; /* Identify the item in the translation table. When the item is not recognized, use the default entry. */ static struct tui_translate * translate (const char *name, struct tui_translate *table) { while (table->name) { if (name && strcmp (table->name, name) == 0) return table; table++; } /* Not found, return default entry. */ table++; return table; } /* Update the tui internal configuration according to gdb settings. Returns 1 if the configuration has changed and the screen should be redrawn. */ bool tui_update_variables () { bool need_redraw = false; struct tui_translate *entry; entry = translate (tui_border_mode, tui_border_mode_translate); if (tui_border_attrs != entry->value) { tui_border_attrs = entry->value; need_redraw = true; } entry = translate (tui_active_border_mode, tui_border_mode_translate); if (tui_active_border_attrs != entry->value) { tui_active_border_attrs = entry->value; need_redraw = true; } /* If one corner changes, all characters are changed. Only check the first one. The ACS characters are determined at run time by curses terminal management. */ entry = translate (tui_border_kind, tui_border_kind_translate_lrcorner); if (tui_border_lrcorner != (chtype) entry->value) { tui_border_lrcorner = (entry->value < 0) ? ACS_LRCORNER : entry->value; need_redraw = true; } entry = translate (tui_border_kind, tui_border_kind_translate_llcorner); tui_border_llcorner = (entry->value < 0) ? ACS_LLCORNER : entry->value; entry = translate (tui_border_kind, tui_border_kind_translate_ulcorner); tui_border_ulcorner = (entry->value < 0) ? ACS_ULCORNER : entry->value; entry = translate (tui_border_kind, tui_border_kind_translate_urcorner); tui_border_urcorner = (entry->value < 0) ? ACS_URCORNER : entry->value; entry = translate (tui_border_kind, tui_border_kind_translate_hline); tui_border_hline = (entry->value < 0) ? ACS_HLINE : entry->value; entry = translate (tui_border_kind, tui_border_kind_translate_vline); tui_border_vline = (entry->value < 0) ? ACS_VLINE : entry->value; return need_redraw; } static struct cmd_list_element *tuilist; struct cmd_list_element ** tui_get_cmd_list (void) { if (tuilist == 0) add_basic_prefix_cmd ("tui", class_tui, _("Text User Interface commands."), &tuilist, "tui ", 0, &cmdlist); return &tuilist; } /* The set_func hook of "set tui ..." commands that affect the window borders on the TUI display. */ static void tui_set_var_cmd (const char *null_args, int from_tty, struct cmd_list_element *c) { if (tui_update_variables () && tui_active) tui_rehighlight_all (); } /* True if TUI resizes should print a message. This is used by the test suite. */ static bool resize_message; static void show_tui_resize_message (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("TUI resize messaging is %s.\n"), value); } /* Generic window name completion function. Complete window name pointed to by TEXT and WORD. If INCLUDE_NEXT_PREV_P is true then the special window names 'next' and 'prev' will also be considered as possible completions of the window name. */ static void window_name_completer (completion_tracker &tracker, int include_next_prev_p, const char *text, const char *word) { std::vector completion_name_vec; for (tui_win_info *win_info : all_tui_windows ()) { const char *completion_name = NULL; /* We can't focus on an invisible window. */ if (!win_info->is_visible ()) continue; completion_name = win_info->name (); gdb_assert (completion_name != NULL); completion_name_vec.push_back (completion_name); } /* If no windows are considered visible then the TUI has not yet been initialized. But still "focus src" and "focus cmd" will work because invoking the focus command will entail initializing the TUI which sets the default layout to "src". */ if (completion_name_vec.empty ()) { completion_name_vec.push_back (SRC_NAME); completion_name_vec.push_back (CMD_NAME); } if (include_next_prev_p) { completion_name_vec.push_back ("next"); completion_name_vec.push_back ("prev"); } completion_name_vec.push_back (NULL); complete_on_enum (tracker, completion_name_vec.data (), text, word); } /* Complete possible window names to focus on. TEXT is the complete text entered so far, WORD is the word currently being completed. */ static void focus_completer (struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word) { window_name_completer (tracker, 1, text, word); } /* Complete possible window names for winheight command. TEXT is the complete text entered so far, WORD is the word currently being completed. */ static void winheight_completer (struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word) { /* The first word is the window name. That we can complete. Subsequent words can't be completed. */ if (word != text) return; window_name_completer (tracker, 0, text, word); } /* Update gdb's knowledge of the terminal size. */ void tui_update_gdb_sizes (void) { int width, height; if (tui_active) { width = TUI_CMD_WIN->width; height = TUI_CMD_WIN->height; } else { width = tui_term_width (); height = tui_term_height (); } set_screen_width_and_height (width, height); } void tui_win_info::forward_scroll (int num_to_scroll) { if (num_to_scroll == 0) num_to_scroll = height - 3; do_scroll_vertical (num_to_scroll); } void tui_win_info::backward_scroll (int num_to_scroll) { if (num_to_scroll == 0) num_to_scroll = height - 3; do_scroll_vertical (-num_to_scroll); } void tui_win_info::left_scroll (int num_to_scroll) { if (num_to_scroll == 0) num_to_scroll = 1; do_scroll_horizontal (num_to_scroll); } void tui_win_info::right_scroll (int num_to_scroll) { if (num_to_scroll == 0) num_to_scroll = 1; do_scroll_horizontal (-num_to_scroll); } void tui_refresh_all_win (void) { clearok (curscr, TRUE); tui_refresh_all (); } void tui_rehighlight_all (void) { for (tui_win_info *win_info : all_tui_windows ()) win_info->check_and_display_highlight_if_needed (); } /* Resize all the windows based on the terminal size. This function gets called from within the readline SIGWINCH handler. */ void tui_resize_all (void) { int height_diff, width_diff; int screenheight, screenwidth; rl_get_screen_size (&screenheight, &screenwidth); width_diff = screenwidth - tui_term_width (); height_diff = screenheight - tui_term_height (); if (height_diff || width_diff) { struct tui_win_info *win_with_focus = tui_win_with_focus (); #ifdef HAVE_RESIZE_TERM resize_term (screenheight, screenwidth); #endif /* Turn keypad off while we resize. */ if (win_with_focus != TUI_CMD_WIN) keypad (TUI_CMD_WIN->handle.get (), FALSE); tui_update_gdb_sizes (); tui_set_term_height_to (screenheight); tui_set_term_width_to (screenwidth); /* erase + clearok are used instead of a straightforward clear as AIX 5.3 does not define clear. */ erase (); clearok (curscr, TRUE); tui_apply_current_layout (); /* Turn keypad back on, unless focus is in the command window. */ if (win_with_focus != TUI_CMD_WIN) keypad (TUI_CMD_WIN->handle.get (), TRUE); } } #ifdef SIGWINCH /* Token for use by TUI's asynchronous SIGWINCH handler. */ static struct async_signal_handler *tui_sigwinch_token; /* TUI's SIGWINCH signal handler. */ static void tui_sigwinch_handler (int signal) { mark_async_signal_handler (tui_sigwinch_token); tui_set_win_resized_to (true); } /* Callback for asynchronously resizing TUI following a SIGWINCH signal. */ static void tui_async_resize_screen (gdb_client_data arg) { rl_resize_terminal (); if (!tui_active) { int screen_height, screen_width; rl_get_screen_size (&screen_height, &screen_width); set_screen_width_and_height (screen_width, screen_height); /* win_resized is left set so that the next call to tui_enable() resizes the TUI windows. */ } else { tui_set_win_resized_to (false); tui_resize_all (); tui_refresh_all_win (); tui_update_gdb_sizes (); if (resize_message) { static int count; printf_unfiltered ("@@ resize done %d, size = %dx%d\n", count, tui_term_width (), tui_term_height ()); ++count; } tui_redisplay_readline (); } } #endif /* Initialize TUI's SIGWINCH signal handler. Note that the handler is not uninstalled when we exit TUI, so the handler should not assume that TUI is always active. */ void tui_initialize_win (void) { #ifdef SIGWINCH tui_sigwinch_token = create_async_signal_handler (tui_async_resize_screen, NULL); { #ifdef HAVE_SIGACTION struct sigaction old_winch; memset (&old_winch, 0, sizeof (old_winch)); old_winch.sa_handler = &tui_sigwinch_handler; #ifdef SA_RESTART old_winch.sa_flags = SA_RESTART; #endif sigaction (SIGWINCH, &old_winch, NULL); #else signal (SIGWINCH, &tui_sigwinch_handler); #endif } #endif } static void tui_scroll_forward_command (const char *arg, int from_tty) { int num_to_scroll = 1; struct tui_win_info *win_to_scroll; /* Make sure the curses mode is enabled. */ tui_enable (); if (arg == NULL) parse_scrolling_args (arg, &win_to_scroll, NULL); else parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll); win_to_scroll->forward_scroll (num_to_scroll); } static void tui_scroll_backward_command (const char *arg, int from_tty) { int num_to_scroll = 1; struct tui_win_info *win_to_scroll; /* Make sure the curses mode is enabled. */ tui_enable (); if (arg == NULL) parse_scrolling_args (arg, &win_to_scroll, NULL); else parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll); win_to_scroll->backward_scroll (num_to_scroll); } static void tui_scroll_left_command (const char *arg, int from_tty) { int num_to_scroll; struct tui_win_info *win_to_scroll; /* Make sure the curses mode is enabled. */ tui_enable (); parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll); win_to_scroll->left_scroll (num_to_scroll); } static void tui_scroll_right_command (const char *arg, int from_tty) { int num_to_scroll; struct tui_win_info *win_to_scroll; /* Make sure the curses mode is enabled. */ tui_enable (); parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll); win_to_scroll->right_scroll (num_to_scroll); } /* Answer the window represented by name. */ static struct tui_win_info * tui_partial_win_by_name (gdb::string_view name) { struct tui_win_info *best = nullptr; for (tui_win_info *item : all_tui_windows ()) { const char *cur_name = item->name (); if (name == cur_name) return item; if (startswith (cur_name, name)) { if (best != nullptr) error (_("Window name \"%*s\" is ambiguous"), (int) name.size (), name.data ()); best = item; } } return best; } /* Set focus to the window named by 'arg'. */ static void tui_set_focus_command (const char *arg, int from_tty) { tui_enable (); if (arg == NULL) error_no_arg (_("name of window to focus")); struct tui_win_info *win_info = NULL; if (subset_compare (arg, "next")) win_info = tui_next_win (tui_win_with_focus ()); else if (subset_compare (arg, "prev")) win_info = tui_prev_win (tui_win_with_focus ()); else win_info = tui_partial_win_by_name (arg); if (win_info == NULL) error (_("Unrecognized window name \"%s\""), arg); if (!win_info->is_visible ()) error (_("Window \"%s\" is not visible"), arg); tui_set_win_focus_to (win_info); keypad (TUI_CMD_WIN->handle.get (), win_info != TUI_CMD_WIN); printf_filtered (_("Focus set to %s window.\n"), tui_win_with_focus ()->name ()); } static void tui_all_windows_info (const char *arg, int from_tty) { if (!tui_active) { printf_filtered (_("The TUI is not active.\n")); return; } struct tui_win_info *win_with_focus = tui_win_with_focus (); struct ui_out *uiout = current_uiout; ui_out_emit_table table_emitter (uiout, 3, -1, "tui-windows"); uiout->table_header (10, ui_left, "name", "Name"); uiout->table_header (5, ui_right, "lines", "Lines"); uiout->table_header (10, ui_left, "focus", "Focus"); uiout->table_body (); for (tui_win_info *win_info : all_tui_windows ()) if (win_info->is_visible ()) { ui_out_emit_tuple tuple_emitter (uiout, nullptr); uiout->field_string ("name", win_info->name ()); uiout->field_signed ("lines", win_info->height); if (win_with_focus == win_info) uiout->field_string ("focus", _("(has focus)")); else uiout->field_skip ("focus"); uiout->text ("\n"); } } static void tui_refresh_all_command (const char *arg, int from_tty) { /* Make sure the curses mode is enabled. */ tui_enable (); tui_refresh_all_win (); } #define DEFAULT_TAB_LEN 8 /* The tab width that should be used by the TUI. */ unsigned int tui_tab_width = DEFAULT_TAB_LEN; /* The tab width as set by the user. */ static unsigned int internal_tab_width = DEFAULT_TAB_LEN; /* After the tab width is set, call this to update the relevant windows. */ static void update_tab_width () { for (tui_win_info *win_info : all_tui_windows ()) { if (win_info->is_visible ()) win_info->update_tab_width (); } } /* Callback for "set tui tab-width". */ static void tui_set_tab_width (const char *ignore, int from_tty, struct cmd_list_element *c) { if (internal_tab_width == 0) { internal_tab_width = tui_tab_width; error (_("Tab width must not be 0")); } tui_tab_width = internal_tab_width; update_tab_width (); } /* Callback for "show tui tab-width". */ static void tui_show_tab_width (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (gdb_stdout, _("TUI tab width is %s spaces.\n"), value); } /* See tui-win.h. */ bool compact_source = false; /* Callback for "set tui compact-source". */ static void tui_set_compact_source (const char *ignore, int from_tty, struct cmd_list_element *c) { if (TUI_SRC_WIN != nullptr) TUI_SRC_WIN->refill (); } /* Callback for "show tui compact-source". */ static void tui_show_compact_source (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { printf_filtered (_("TUI source window compactness is %s.\n"), value); } /* Set the tab width of the specified window. */ static void tui_set_tab_width_command (const char *arg, int from_tty) { /* Make sure the curses mode is enabled. */ tui_enable (); if (arg != NULL) { int ts; ts = atoi (arg); if (ts <= 0) warning (_("Tab widths greater than 0 must be specified.")); else { internal_tab_width = ts; tui_tab_width = ts; update_tab_width (); } } } /* Set the height of the specified window. */ static void tui_set_win_height_command (const char *arg, int from_tty) { /* Make sure the curses mode is enabled. */ tui_enable (); if (arg == NULL) error_no_arg (_("name of window")); const char *buf = arg; const char *buf_ptr = buf; int new_height; struct tui_win_info *win_info; buf_ptr = skip_to_space (buf_ptr); /* Validate the window name. */ gdb::string_view wname (buf, buf_ptr - buf); win_info = tui_partial_win_by_name (wname); if (win_info == NULL) error (_("Unrecognized window name \"%s\""), arg); if (!win_info->is_visible ()) error (_("Window \"%s\" is not visible"), arg); /* Process the size. */ buf_ptr = skip_spaces (buf_ptr); if (*buf_ptr != '\0') { bool negate = false; bool fixed_size = true; int input_no;; if (*buf_ptr == '+' || *buf_ptr == '-') { if (*buf_ptr == '-') negate = true; fixed_size = false; buf_ptr++; } input_no = atoi (buf_ptr); if (input_no > 0) { if (negate) input_no *= (-1); if (fixed_size) new_height = input_no; else new_height = win_info->height + input_no; /* Now change the window's height, and adjust all other windows around it. */ tui_adjust_window_height (win_info, new_height); tui_update_gdb_sizes (); } else error (_("Invalid window height specified")); } } /* See tui-data.h. */ int tui_win_info::max_height () const { return tui_term_height () - 2; } /* See tui-data.h. */ int tui_win_info::max_width () const { return tui_term_width () - 2; } static void parse_scrolling_args (const char *arg, struct tui_win_info **win_to_scroll, int *num_to_scroll) { if (num_to_scroll) *num_to_scroll = 0; *win_to_scroll = tui_win_with_focus (); /* First set up the default window to scroll, in case there is no window name arg. */ if (arg != NULL) { char *buf_ptr; /* Process the number of lines to scroll. */ std::string copy = arg; buf_ptr = ©[0]; if (isdigit (*buf_ptr)) { char *num_str; num_str = buf_ptr; buf_ptr = strchr (buf_ptr, ' '); if (buf_ptr != NULL) { *buf_ptr = '\0'; if (num_to_scroll) *num_to_scroll = atoi (num_str); buf_ptr++; } else if (num_to_scroll) *num_to_scroll = atoi (num_str); } /* Process the window name if one is specified. */ if (buf_ptr != NULL) { const char *wname; wname = skip_spaces (buf_ptr); if (*wname != '\0') { *win_to_scroll = tui_partial_win_by_name (wname); if (*win_to_scroll == NULL) error (_("Unrecognized window `%s'"), wname); if (!(*win_to_scroll)->is_visible ()) error (_("Window is not visible")); else if (*win_to_scroll == TUI_CMD_WIN) *win_to_scroll = *(tui_source_windows ().begin ()); } } } } /* Function to initialize gdb commands, for tui window manipulation. */ void _initialize_tui_win (); void _initialize_tui_win () { static struct cmd_list_element *tui_setlist; static struct cmd_list_element *tui_showlist; struct cmd_list_element *cmd; /* Define the classes of commands. They will appear in the help list in the reverse of this order. */ add_basic_prefix_cmd ("tui", class_tui, _("TUI configuration variables."), &tui_setlist, "set tui ", 0 /* allow-unknown */, &setlist); add_show_prefix_cmd ("tui", class_tui, _("TUI configuration variables."), &tui_showlist, "show tui ", 0 /* allow-unknown */, &showlist); add_com ("refresh", class_tui, tui_refresh_all_command, _("Refresh the terminal display.")); cmd = add_com ("tabset", class_tui, tui_set_tab_width_command, _("\ Set the width (in characters) of tab stops.\n\ Usage: tabset N")); deprecate_cmd (cmd, "set tui tab-width"); cmd = add_com ("winheight", class_tui, tui_set_win_height_command, _("\ Set or modify the height of a specified window.\n\ Usage: winheight WINDOW-NAME [+ | -] NUM-LINES\n\ Use \"info win\" to see the names of the windows currently being displayed.")); add_com_alias ("wh", "winheight", class_tui, 0); set_cmd_completer (cmd, winheight_completer); add_info ("win", tui_all_windows_info, _("List of all displayed windows.\n\ Usage: info win")); cmd = add_com ("focus", class_tui, tui_set_focus_command, _("\ Set focus to named window or next/prev window.\n\ Usage: focus [WINDOW-NAME | next | prev]\n\ Use \"info win\" to see the names of the windows currently being displayed.")); add_com_alias ("fs", "focus", class_tui, 0); set_cmd_completer (cmd, focus_completer); add_com ("+", class_tui, tui_scroll_forward_command, _("\ Scroll window forward.\n\ Usage: + [N] [WIN]\n\ Scroll window WIN N lines forwards. Both WIN and N are optional, N\n\ defaults to 1, and WIN defaults to the currently focused window.")); add_com ("-", class_tui, tui_scroll_backward_command, _("\ Scroll window backward.\n\ Usage: - [N] [WIN]\n\ Scroll window WIN N lines backwards. Both WIN and N are optional, N\n\ defaults to 1, and WIN defaults to the currently focused window.")); add_com ("<", class_tui, tui_scroll_left_command, _("\ Scroll window text to the left.\n\ Usage: < [N] [WIN]\n\ Scroll window WIN N characters left. Both WIN and N are optional, N\n\ defaults to 1, and WIN defaults to the currently focused window.")); add_com (">", class_tui, tui_scroll_right_command, _("\ Scroll window text to the right.\n\ Usage: > [N] [WIN]\n\ Scroll window WIN N characters right. Both WIN and N are optional, N\n\ defaults to 1, and WIN defaults to the currently focused window.")); /* Define the tui control variables. */ add_setshow_enum_cmd ("border-kind", no_class, tui_border_kind_enums, &tui_border_kind, _("\ Set the kind of border for TUI windows."), _("\ Show the kind of border for TUI windows."), _("\ This variable controls the border of TUI windows:\n\ space use a white space\n\ ascii use ascii characters + - | for the border\n\ acs use the Alternate Character Set"), tui_set_var_cmd, show_tui_border_kind, &tui_setlist, &tui_showlist); add_setshow_enum_cmd ("border-mode", no_class, tui_border_mode_enums, &tui_border_mode, _("\ Set the attribute mode to use for the TUI window borders."), _("\ Show the attribute mode to use for the TUI window borders."), _("\ This variable controls the attributes to use for the window borders:\n\ normal normal display\n\ standout use highlight mode of terminal\n\ reverse use reverse video mode\n\ half use half bright\n\ half-standout use half bright and standout mode\n\ bold use extra bright or bold\n\ bold-standout use extra bright or bold with standout mode"), tui_set_var_cmd, show_tui_border_mode, &tui_setlist, &tui_showlist); add_setshow_enum_cmd ("active-border-mode", no_class, tui_border_mode_enums, &tui_active_border_mode, _("\ Set the attribute mode to use for the active TUI window border."), _("\ Show the attribute mode to use for the active TUI window border."), _("\ This variable controls the attributes to use for the active window border:\n\ normal normal display\n\ standout use highlight mode of terminal\n\ reverse use reverse video mode\n\ half use half bright\n\ half-standout use half bright and standout mode\n\ bold use extra bright or bold\n\ bold-standout use extra bright or bold with standout mode"), tui_set_var_cmd, show_tui_active_border_mode, &tui_setlist, &tui_showlist); add_setshow_zuinteger_cmd ("tab-width", no_class, &internal_tab_width, _("\ Set the tab width, in characters, for the TUI."), _("\ Show the tab witdh, in characters, for the TUI."), _("\ This variable controls how many spaces are used to display a tab character."), tui_set_tab_width, tui_show_tab_width, &tui_setlist, &tui_showlist); add_setshow_boolean_cmd ("tui-resize-message", class_maintenance, &resize_message, _("\ Set TUI resize messaging."), _("\ Show TUI resize messaging."), _("\ When enabled GDB will print a message when the terminal is resized."), nullptr, show_tui_resize_message, &maintenance_set_cmdlist, &maintenance_show_cmdlist); add_setshow_boolean_cmd ("compact-source", class_tui, &compact_source, _("\ Set whether the TUI source window is compact."), _("\ Show whether the TUI source window is compact."), _("\ This variable controls whether the TUI source window is shown\n\ in a compact form. The compact form puts the source closer to\n\ the line numbers and uses less horizontal space."), tui_set_compact_source, tui_show_compact_source, &tui_setlist, &tui_showlist); tui_border_style.changed.attach (tui_rehighlight_all); tui_active_border_style.changed.attach (tui_rehighlight_all); }