gdb/tui/tui-win.c

   1 /* TUI window generic functions.
   2
   3    Copyright (C) 1998-2020 Free Software Foundation, Inc.
   4
   5    Contributed by Hewlett-Packard Company.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 /* This module contains procedures for handling tui window functions
  23    like resize, scrolling, scrolling, changing focus, etc.
  24
  25    Author: Susan B. Macchia  */
  26
  27 #include "defs.h"
  28 #include "command.h"
  29 #include "symtab.h"
  30 #include "breakpoint.h"
  31 #include "frame.h"
  32 #include "cli/cli-cmds.h"
  33 #include "cli/cli-style.h"
  34 #include "top.h"
  35 #include "source.h"
  36 #include "event-loop.h"
  37 #include "gdbcmd.h"
  38
  39 #include "tui/tui.h"
  40 #include "tui/tui-io.h"
  41 #include "tui/tui-command.h"
  42 #include "tui/tui-data.h"
  43 #include "tui/tui-layout.h"
  44 #include "tui/tui-wingeneral.h"
  45 #include "tui/tui-stack.h"
  46 #include "tui/tui-regs.h"
  47 #include "tui/tui-disasm.h"
  48 #include "tui/tui-source.h"
  49 #include "tui/tui-winsource.h"
  50 #include "tui/tui-win.h"
  51
  52 #include "gdb_curses.h"
  53 #include <ctype.h>
  54 #include "readline/readline.h"
  55 #include "gdbsupport/gdb_string_view.h"
  56
  57 #include <signal.h>
  58
  59 static void tui_set_tab_width_command (const char *, int);
  60 static void tui_refresh_all_command (const char *, int);
  61 static void tui_all_windows_info (const char *, int);
  62 static void tui_scroll_forward_command (const char *, int);
  63 static void tui_scroll_backward_command (const char *, int);
  64 static void tui_scroll_left_command (const char *, int);
  65 static void tui_scroll_right_command (const char *, int);
  66 static void parse_scrolling_args (const char *,
  67                                   struct tui_win_info **,
  68                                   int *);
  69
  70
  71 #ifndef ACS_LRCORNER
  72 #  define ACS_LRCORNER '+'
  73 #endif
  74 #ifndef ACS_LLCORNER
  75 #  define ACS_LLCORNER '+'
  76 #endif
  77 #ifndef ACS_ULCORNER
  78 #  define ACS_ULCORNER '+'
  79 #endif
  80 #ifndef ACS_URCORNER
  81 #  define ACS_URCORNER '+'
  82 #endif
  83 #ifndef ACS_HLINE
  84 #  define ACS_HLINE '-'
  85 #endif
  86 #ifndef ACS_VLINE
  87 #  define ACS_VLINE '|'
  88 #endif
  89
  90 /* Possible values for tui-border-kind variable.  */
  91 static const char *const tui_border_kind_enums[] = {
  92   "space",
  93   "ascii",
  94   "acs",
  95   NULL
  96 };
  97
  98 /* Possible values for tui-border-mode and tui-active-border-mode.  */
  99 static const char *const tui_border_mode_enums[] = {
 100   "normal",
 101   "standout",
 102   "reverse",
 103   "half",
 104   "half-standout",
 105   "bold",
 106   "bold-standout",
 107   NULL
 108 };
 109
 110 struct tui_translate
 111 {
 112   const char *name;
 113   int value;
 114 };
 115
 116 /* Translation table for border-mode variables.
 117    The list of values must be terminated by a NULL.
 118    After the NULL value, an entry defines the default.  */
 119 static struct tui_translate tui_border_mode_translate[] = {
 120   { "normal",           A_NORMAL },
 121   { "standout",         A_STANDOUT },
 122   { "reverse",          A_REVERSE },
 123   { "half",             A_DIM },
 124   { "half-standout",    A_DIM | A_STANDOUT },
 125   { "bold",             A_BOLD },
 126   { "bold-standout",    A_BOLD | A_STANDOUT },
 127   { 0, 0 },
 128   { "normal",           A_NORMAL }
 129 };
 130
 131 /* Translation tables for border-kind, one for each border
 132    character (see wborder, border curses operations).
 133    -1 is used to indicate the ACS because ACS characters
 134    are determined at run time by curses (depends on terminal).  */
 135 static struct tui_translate tui_border_kind_translate_vline[] = {
 136   { "space",    ' ' },
 137   { "ascii",    '|' },
 138   { "acs",      -1 },
 139   { 0, 0 },
 140   { "ascii",    '|' }
 141 };
 142
 143 static struct tui_translate tui_border_kind_translate_hline[] = {
 144   { "space",    ' ' },
 145   { "ascii",    '-' },
 146   { "acs",      -1 },
 147   { 0, 0 },
 148   { "ascii",    '-' }
 149 };
 150
 151 static struct tui_translate tui_border_kind_translate_ulcorner[] = {
 152   { "space",    ' ' },
 153   { "ascii",    '+' },
 154   { "acs",      -1 },
 155   { 0, 0 },
 156   { "ascii",    '+' }
 157 };
 158
 159 static struct tui_translate tui_border_kind_translate_urcorner[] = {
 160   { "space",    ' ' },
 161   { "ascii",    '+' },
 162   { "acs",      -1 },
 163   { 0, 0 },
 164   { "ascii",    '+' }
 165 };
 166
 167 static struct tui_translate tui_border_kind_translate_llcorner[] = {
 168   { "space",    ' ' },
 169   { "ascii",    '+' },
 170   { "acs",      -1 },
 171   { 0, 0 },
 172   { "ascii",    '+' }
 173 };
 174
 175 static struct tui_translate tui_border_kind_translate_lrcorner[] = {
 176   { "space",    ' ' },
 177   { "ascii",    '+' },
 178   { "acs",      -1 },
 179   { 0, 0 },
 180   { "ascii",    '+' }
 181 };
 182
 183
 184 /* Tui configuration variables controlled with set/show command.  */
 185 static const char *tui_active_border_mode = "bold-standout";
 186 static void
 187 show_tui_active_border_mode (struct ui_file *file,
 188                              int from_tty,
 189                              struct cmd_list_element *c,
 190                              const char *value)
 191 {
 192   fprintf_filtered (file, _("\
 193 The attribute mode to use for the active TUI window border is \"%s\".\n"),
 194                     value);
 195 }
 196
 197 static const char *tui_border_mode = "normal";
 198 static void
 199 show_tui_border_mode (struct ui_file *file,
 200                       int from_tty,
 201                       struct cmd_list_element *c,
 202                       const char *value)
 203 {
 204   fprintf_filtered (file, _("\
 205 The attribute mode to use for the TUI window borders is \"%s\".\n"),
 206                     value);
 207 }
 208
 209 static const char *tui_border_kind = "acs";
 210 static void
 211 show_tui_border_kind (struct ui_file *file,
 212                       int from_tty,
 213                       struct cmd_list_element *c,
 214                       const char *value)
 215 {
 216   fprintf_filtered (file, _("The kind of border for TUI windows is \"%s\".\n"),
 217                     value);
 218 }
 219
 220
 221 /* Tui internal configuration variables.  These variables are updated
 222    by tui_update_variables to reflect the tui configuration
 223    variables.  */
 224 chtype tui_border_vline;
 225 chtype tui_border_hline;
 226 chtype tui_border_ulcorner;
 227 chtype tui_border_urcorner;
 228 chtype tui_border_llcorner;
 229 chtype tui_border_lrcorner;
 230
 231 int tui_border_attrs;
 232 int tui_active_border_attrs;
 233
 234 /* Identify the item in the translation table.
 235    When the item is not recognized, use the default entry.  */
 236 static struct tui_translate *
 237 translate (const char *name, struct tui_translate *table)
 238 {
 239   while (table->name)
 240     {
 241       if (name && strcmp (table->name, name) == 0)
 242         return table;
 243       table++;
 244     }
 245
 246   /* Not found, return default entry.  */
 247   table++;
 248   return table;
 249 }
 250
 251 /* Update the tui internal configuration according to gdb settings.
 252    Returns 1 if the configuration has changed and the screen should
 253    be redrawn.  */
 254 bool
 255 tui_update_variables ()
 256 {
 257   bool need_redraw = false;
 258   struct tui_translate *entry;
 259
 260   entry = translate (tui_border_mode, tui_border_mode_translate);
 261   if (tui_border_attrs != entry->value)
 262     {
 263       tui_border_attrs = entry->value;
 264       need_redraw = true;
 265     }
 266   entry = translate (tui_active_border_mode, tui_border_mode_translate);
 267   if (tui_active_border_attrs != entry->value)
 268     {
 269       tui_active_border_attrs = entry->value;
 270       need_redraw = true;
 271     }
 272
 273   /* If one corner changes, all characters are changed.
 274      Only check the first one.  The ACS characters are determined at
 275      run time by curses terminal management.  */
 276   entry = translate (tui_border_kind, tui_border_kind_translate_lrcorner);
 277   if (tui_border_lrcorner != (chtype) entry->value)
 278     {
 279       tui_border_lrcorner = (entry->value < 0) ? ACS_LRCORNER : entry->value;
 280       need_redraw = true;
 281     }
 282   entry = translate (tui_border_kind, tui_border_kind_translate_llcorner);
 283   tui_border_llcorner = (entry->value < 0) ? ACS_LLCORNER : entry->value;
 284
 285   entry = translate (tui_border_kind, tui_border_kind_translate_ulcorner);
 286   tui_border_ulcorner = (entry->value < 0) ? ACS_ULCORNER : entry->value;
 287
 288   entry = translate (tui_border_kind, tui_border_kind_translate_urcorner);
 289   tui_border_urcorner = (entry->value < 0) ? ACS_URCORNER : entry->value;
 290
 291   entry = translate (tui_border_kind, tui_border_kind_translate_hline);
 292   tui_border_hline = (entry->value < 0) ? ACS_HLINE : entry->value;
 293
 294   entry = translate (tui_border_kind, tui_border_kind_translate_vline);
 295   tui_border_vline = (entry->value < 0) ? ACS_VLINE : entry->value;
 296
 297   return need_redraw;
 298 }
 299
 300 static void
 301 set_tui_cmd (const char *args, int from_tty)
 302 {
 303 }
 304
 305 static void
 306 show_tui_cmd (const char *args, int from_tty)
 307 {
 308 }
 309
 310 static struct cmd_list_element *tuilist;
 311
 312 static void
 313 tui_command (const char *args, int from_tty)
 314 {
 315   printf_unfiltered (_("\"tui\" must be followed by the name of a "
 316                      "tui command.\n"));
 317   help_list (tuilist, "tui ", all_commands, gdb_stdout);
 318 }
 319
 320 struct cmd_list_element **
 321 tui_get_cmd_list (void)
 322 {
 323   if (tuilist == 0)
 324     add_prefix_cmd ("tui", class_tui, tui_command,
 325                     _("Text User Interface commands."),
 326                     &tuilist, "tui ", 0, &cmdlist);
 327   return &tuilist;
 328 }
 329
 330 /* The set_func hook of "set tui ..." commands that affect the window
 331    borders on the TUI display.  */
 332
 333 static void
 334 tui_set_var_cmd (const char *null_args,
 335                  int from_tty, struct cmd_list_element *c)
 336 {
 337   if (tui_update_variables () && tui_active)
 338     tui_rehighlight_all ();
 339 }
 340
 341 \f
 342
 343 /* True if TUI resizes should print a message.  This is used by the
 344    test suite.  */
 345
 346 static bool resize_message;
 347
 348 static void
 349 show_tui_resize_message (struct ui_file *file, int from_tty,
 350                          struct cmd_list_element *c, const char *value)
 351 {
 352   fprintf_filtered (file, _("TUI resize messaging is %s.\n"), value);
 353 }
 354
 355 \f
 356
 357 /* Generic window name completion function.  Complete window name pointed
 358    to by TEXT and WORD.  If INCLUDE_NEXT_PREV_P is true then the special
 359    window names 'next' and 'prev' will also be considered as possible
 360    completions of the window name.  */
 361
 362 static void
 363 window_name_completer (completion_tracker &tracker,
 364                        int include_next_prev_p,
 365                        const char *text, const char *word)
 366 {
 367   std::vector<const char *> completion_name_vec;
 368
 369   for (tui_win_info *win_info : all_tui_windows ())
 370     {
 371       const char *completion_name = NULL;
 372
 373       /* We can't focus on an invisible window.  */
 374       if (!win_info->is_visible ())
 375         continue;
 376
 377       completion_name = win_info->name ();
 378       gdb_assert (completion_name != NULL);
 379       completion_name_vec.push_back (completion_name);
 380     }
 381
 382   /* If no windows are considered visible then the TUI has not yet been
 383      initialized.  But still "focus src" and "focus cmd" will work because
 384      invoking the focus command will entail initializing the TUI which sets the
 385      default layout to "src".  */
 386   if (completion_name_vec.empty ())
 387     {
 388       completion_name_vec.push_back (SRC_NAME);
 389       completion_name_vec.push_back (CMD_NAME);
 390     }
 391
 392   if (include_next_prev_p)
 393     {
 394       completion_name_vec.push_back ("next");
 395       completion_name_vec.push_back ("prev");
 396     }
 397
 398
 399   completion_name_vec.push_back (NULL);
 400   complete_on_enum (tracker, completion_name_vec.data (), text, word);
 401 }
 402
 403 /* Complete possible window names to focus on.  TEXT is the complete text
 404    entered so far, WORD is the word currently being completed.  */
 405
 406 static void
 407 focus_completer (struct cmd_list_element *ignore,
 408                  completion_tracker &tracker,
 409                  const char *text, const char *word)
 410 {
 411   window_name_completer (tracker, 1, text, word);
 412 }
 413
 414 /* Complete possible window names for winheight command.  TEXT is the
 415    complete text entered so far, WORD is the word currently being
 416    completed.  */
 417
 418 static void
 419 winheight_completer (struct cmd_list_element *ignore,
 420                      completion_tracker &tracker,
 421                      const char *text, const char *word)
 422 {
 423   /* The first word is the window name.  That we can complete.  Subsequent
 424      words can't be completed.  */
 425   if (word != text)
 426     return;
 427
 428   window_name_completer (tracker, 0, text, word);
 429 }
 430
 431 /* Update gdb's knowledge of the terminal size.  */
 432 void
 433 tui_update_gdb_sizes (void)
 434 {
 435   int width, height;
 436
 437   if (tui_active)
 438     {
 439       width = TUI_CMD_WIN->width;
 440       height = TUI_CMD_WIN->height;
 441     }
 442   else
 443     {
 444       width = tui_term_width ();
 445       height = tui_term_height ();
 446     }
 447
 448   set_screen_width_and_height (width, height);
 449 }
 450
 451
 452 void
 453 tui_win_info::forward_scroll (int num_to_scroll)
 454 {
 455   if (num_to_scroll == 0)
 456     num_to_scroll = height - 3;
 457
 458   do_scroll_vertical (num_to_scroll);
 459 }
 460
 461 void
 462 tui_win_info::backward_scroll (int num_to_scroll)
 463 {
 464   if (num_to_scroll == 0)
 465     num_to_scroll = height - 3;
 466
 467   do_scroll_vertical (-num_to_scroll);
 468 }
 469
 470
 471 void
 472 tui_win_info::left_scroll (int num_to_scroll)
 473 {
 474   if (num_to_scroll == 0)
 475     num_to_scroll = 1;
 476
 477   do_scroll_horizontal (num_to_scroll);
 478 }
 479
 480
 481 void
 482 tui_win_info::right_scroll (int num_to_scroll)
 483 {
 484   if (num_to_scroll == 0)
 485     num_to_scroll = 1;
 486
 487   do_scroll_horizontal (-num_to_scroll);
 488 }
 489
 490
 491 void
 492 tui_refresh_all_win (void)
 493 {
 494   clearok (curscr, TRUE);
 495   tui_refresh_all ();
 496 }
 497
 498 void
 499 tui_rehighlight_all (void)
 500 {
 501   for (tui_win_info *win_info : all_tui_windows ())
 502     win_info->check_and_display_highlight_if_needed ();
 503 }
 504
 505 /* Resize all the windows based on the terminal size.  This function
 506    gets called from within the readline SIGWINCH handler.  */
 507 void
 508 tui_resize_all (void)
 509 {
 510   int height_diff, width_diff;
 511   int screenheight, screenwidth;
 512
 513   rl_get_screen_size (&screenheight, &screenwidth);
 514   width_diff = screenwidth - tui_term_width ();
 515   height_diff = screenheight - tui_term_height ();
 516   if (height_diff || width_diff)
 517     {
 518       struct tui_win_info *win_with_focus = tui_win_with_focus ();
 519
 520 #ifdef HAVE_RESIZE_TERM
 521       resize_term (screenheight, screenwidth);
 522 #endif
 523       /* Turn keypad off while we resize.  */
 524       if (win_with_focus != TUI_CMD_WIN)
 525         keypad (TUI_CMD_WIN->handle.get (), FALSE);
 526       tui_update_gdb_sizes ();
 527       tui_set_term_height_to (screenheight);
 528       tui_set_term_width_to (screenwidth);
 529
 530       /* erase + clearok are used instead of a straightforward clear as
 531          AIX 5.3 does not define clear.  */
 532       erase ();
 533       clearok (curscr, TRUE);
 534       tui_apply_current_layout ();
 535       /* Turn keypad back on, unless focus is in the command
 536          window.  */
 537       if (win_with_focus != TUI_CMD_WIN)
 538         keypad (TUI_CMD_WIN->handle.get (), TRUE);
 539     }
 540 }
 541
 542 #ifdef SIGWINCH
 543 /* Token for use by TUI's asynchronous SIGWINCH handler.  */
 544 static struct async_signal_handler *tui_sigwinch_token;
 545
 546 /* TUI's SIGWINCH signal handler.  */
 547 static void
 548 tui_sigwinch_handler (int signal)
 549 {
 550   mark_async_signal_handler (tui_sigwinch_token);
 551   tui_set_win_resized_to (true);
 552 }
 553
 554 /* Callback for asynchronously resizing TUI following a SIGWINCH signal.  */
 555 static void
 556 tui_async_resize_screen (gdb_client_data arg)
 557 {
 558   rl_resize_terminal ();
 559
 560   if (!tui_active)
 561     {
 562       int screen_height, screen_width;
 563
 564       rl_get_screen_size (&screen_height, &screen_width);
 565       set_screen_width_and_height (screen_width, screen_height);
 566
 567       /* win_resized is left set so that the next call to tui_enable()
 568          resizes the TUI windows.  */
 569     }
 570   else
 571     {
 572       tui_set_win_resized_to (false);
 573       tui_resize_all ();
 574       tui_refresh_all_win ();
 575       tui_update_gdb_sizes ();
 576       if (resize_message)
 577         {
 578           static int count;
 579           printf_unfiltered ("@@ resize done %d, size = %dx%d\n", count,
 580                              tui_term_width (), tui_term_height ());
 581           ++count;
 582         }
 583       tui_redisplay_readline ();
 584     }
 585 }
 586 #endif
 587
 588 /* Initialize TUI's SIGWINCH signal handler.  Note that the handler is not
 589    uninstalled when we exit TUI, so the handler should not assume that TUI is
 590    always active.  */
 591 void
 592 tui_initialize_win (void)
 593 {
 594 #ifdef SIGWINCH
 595   tui_sigwinch_token
 596     = create_async_signal_handler (tui_async_resize_screen, NULL);
 597
 598   {
 599 #ifdef HAVE_SIGACTION
 600     struct sigaction old_winch;
 601
 602     memset (&old_winch, 0, sizeof (old_winch));
 603     old_winch.sa_handler = &tui_sigwinch_handler;
 604 #ifdef SA_RESTART
 605     old_winch.sa_flags = SA_RESTART;
 606 #endif
 607     sigaction (SIGWINCH, &old_winch, NULL);
 608 #else
 609     signal (SIGWINCH, &tui_sigwinch_handler);
 610 #endif
 611   }
 612 #endif
 613 }
 614
 615
 616 static void
 617 tui_scroll_forward_command (const char *arg, int from_tty)
 618 {
 619   int num_to_scroll = 1;
 620   struct tui_win_info *win_to_scroll;
 621
 622   /* Make sure the curses mode is enabled.  */
 623   tui_enable ();
 624   if (arg == NULL)
 625     parse_scrolling_args (arg, &win_to_scroll, NULL);
 626   else
 627     parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 628   win_to_scroll->forward_scroll (num_to_scroll);
 629 }
 630
 631
 632 static void
 633 tui_scroll_backward_command (const char *arg, int from_tty)
 634 {
 635   int num_to_scroll = 1;
 636   struct tui_win_info *win_to_scroll;
 637
 638   /* Make sure the curses mode is enabled.  */
 639   tui_enable ();
 640   if (arg == NULL)
 641     parse_scrolling_args (arg, &win_to_scroll, NULL);
 642   else
 643     parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 644   win_to_scroll->backward_scroll (num_to_scroll);
 645 }
 646
 647
 648 static void
 649 tui_scroll_left_command (const char *arg, int from_tty)
 650 {
 651   int num_to_scroll;
 652   struct tui_win_info *win_to_scroll;
 653
 654   /* Make sure the curses mode is enabled.  */
 655   tui_enable ();
 656   parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 657   win_to_scroll->left_scroll (num_to_scroll);
 658 }
 659
 660
 661 static void
 662 tui_scroll_right_command (const char *arg, int from_tty)
 663 {
 664   int num_to_scroll;
 665   struct tui_win_info *win_to_scroll;
 666
 667   /* Make sure the curses mode is enabled.  */
 668   tui_enable ();
 669   parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 670   win_to_scroll->right_scroll (num_to_scroll);
 671 }
 672
 673
 674 /* Answer the window represented by name.  */
 675 static struct tui_win_info *
 676 tui_partial_win_by_name (gdb::string_view name)
 677 {
 678   struct tui_win_info *best = nullptr;
 679
 680   if (name != NULL)
 681     {
 682       for (tui_win_info *item : all_tui_windows ())
 683         {
 684           const char *cur_name = item->name ();
 685
 686           if (name == cur_name)
 687             return item;
 688           if (startswith (cur_name, name))
 689             {
 690               if (best != nullptr)
 691                 error (_("Window name \"%*s\" is ambiguous"),
 692                        (int) name.size (), name.data ());
 693               best = item;
 694             }
 695         }
 696     }
 697
 698   return best;
 699 }
 700
 701 /* Set focus to the window named by 'arg'.  */
 702 static void
 703 tui_set_focus_command (const char *arg, int from_tty)
 704 {
 705   tui_enable ();
 706
 707   if (arg == NULL)
 708     error_no_arg (_("name of window to focus"));
 709
 710   struct tui_win_info *win_info = NULL;
 711
 712   if (subset_compare (arg, "next"))
 713     win_info = tui_next_win (tui_win_with_focus ());
 714   else if (subset_compare (arg, "prev"))
 715     win_info = tui_prev_win (tui_win_with_focus ());
 716   else
 717     win_info = tui_partial_win_by_name (arg);
 718
 719   if (win_info == NULL)
 720     error (_("Unrecognized window name \"%s\""), arg);
 721   if (!win_info->is_visible ())
 722     error (_("Window \"%s\" is not visible"), arg);
 723
 724   tui_set_win_focus_to (win_info);
 725   keypad (TUI_CMD_WIN->handle.get (), win_info != TUI_CMD_WIN);
 726   printf_filtered (_("Focus set to %s window.\n"),
 727                    tui_win_with_focus ()->name ());
 728 }
 729
 730 static void
 731 tui_all_windows_info (const char *arg, int from_tty)
 732 {
 733   if (!tui_active)
 734     {
 735       printf_filtered (_("The TUI is not active.\n"));
 736       return;
 737     }
 738
 739   struct tui_win_info *win_with_focus = tui_win_with_focus ();
 740   struct ui_out *uiout = current_uiout;
 741
 742   ui_out_emit_table table_emitter (uiout, 3, -1, "tui-windows");
 743   uiout->table_header (10, ui_left, "name", "Name");
 744   uiout->table_header (5, ui_right, "lines", "Lines");
 745   uiout->table_header (10, ui_left, "focus", "Focus");
 746   uiout->table_body ();
 747
 748   for (tui_win_info *win_info : all_tui_windows ())
 749     if (win_info->is_visible ())
 750       {
 751         ui_out_emit_tuple tuple_emitter (uiout, nullptr);
 752
 753         uiout->field_string ("name", win_info->name ());
 754         uiout->field_signed ("lines", win_info->height);
 755         if (win_with_focus == win_info)
 756           uiout->field_string ("focus", _("(has focus)"));
 757         else
 758           uiout->field_skip ("focus");
 759         uiout->text ("\n");
 760       }
 761 }
 762
 763
 764 static void
 765 tui_refresh_all_command (const char *arg, int from_tty)
 766 {
 767   /* Make sure the curses mode is enabled.  */
 768   tui_enable ();
 769
 770   tui_refresh_all_win ();
 771 }
 772
 773 /* The tab width that should be used by the TUI.  */
 774
 775 unsigned int tui_tab_width = DEFAULT_TAB_LEN;
 776
 777 /* The tab width as set by the user.  */
 778
 779 static unsigned int internal_tab_width = DEFAULT_TAB_LEN;
 780
 781 /* After the tab width is set, call this to update the relevant
 782    windows.  */
 783
 784 static void
 785 update_tab_width ()
 786 {
 787   for (tui_win_info *win_info : all_tui_windows ())
 788     {
 789       if (win_info->is_visible ())
 790         win_info->update_tab_width ();
 791     }
 792 }
 793
 794 /* Callback for "set tui tab-width".  */
 795
 796 static void
 797 tui_set_tab_width (const char *ignore,
 798                    int from_tty, struct cmd_list_element *c)
 799 {
 800   if (internal_tab_width == 0)
 801     {
 802       internal_tab_width = tui_tab_width;
 803       error (_("Tab width must not be 0"));
 804     }
 805
 806   tui_tab_width = internal_tab_width;
 807   update_tab_width ();
 808 }
 809
 810 /* Callback for "show tui tab-width".  */
 811
 812 static void
 813 tui_show_tab_width (struct ui_file *file, int from_tty,
 814                     struct cmd_list_element *c, const char *value)
 815 {
 816   fprintf_filtered (gdb_stdout, _("TUI tab width is %s spaces.\n"), value);
 817
 818 }
 819
 820 /* See tui-win.h.  */
 821
 822 bool compact_source = false;
 823
 824 /* Callback for "set tui compact-source".  */
 825
 826 static void
 827 tui_set_compact_source (const char *ignore, int from_tty,
 828                         struct cmd_list_element *c)
 829 {
 830   if (TUI_SRC_WIN != nullptr)
 831     TUI_SRC_WIN->refill ();
 832 }
 833
 834 /* Callback for "show tui compact-source".  */
 835
 836 static void
 837 tui_show_compact_source (struct ui_file *file, int from_tty,
 838                          struct cmd_list_element *c, const char *value)
 839 {
 840   printf_filtered (_("TUI source window compactness is %s.\n"), value);
 841 }
 842
 843 /* Set the tab width of the specified window.  */
 844 static void
 845 tui_set_tab_width_command (const char *arg, int from_tty)
 846 {
 847   /* Make sure the curses mode is enabled.  */
 848   tui_enable ();
 849   if (arg != NULL)
 850     {
 851       int ts;
 852
 853       ts = atoi (arg);
 854       if (ts <= 0)
 855         warning (_("Tab widths greater than 0 must be specified."));
 856       else
 857         {
 858           internal_tab_width = ts;
 859           tui_tab_width = ts;
 860
 861           update_tab_width ();
 862         }
 863     }
 864 }
 865
 866
 867 /* Set the height of the specified window.  */
 868 static void
 869 tui_set_win_height_command (const char *arg, int from_tty)
 870 {
 871   /* Make sure the curses mode is enabled.  */
 872   tui_enable ();
 873   if (arg == NULL)
 874     error_no_arg (_("name of window"));
 875
 876   const char *buf = arg;
 877   const char *buf_ptr = buf;
 878   int new_height;
 879   struct tui_win_info *win_info;
 880
 881   buf_ptr = skip_to_space (buf_ptr);
 882
 883   /* Validate the window name.  */
 884   gdb::string_view wname (buf, buf_ptr - buf);
 885   win_info = tui_partial_win_by_name (wname);
 886
 887   if (win_info == NULL)
 888     error (_("Unrecognized window name \"%s\""), arg);
 889   if (!win_info->is_visible ())
 890     error (_("Window \"%s\" is not visible"), arg);
 891
 892   /* Process the size.  */
 893   buf_ptr = skip_spaces (buf_ptr);
 894
 895   if (*buf_ptr != '\0')
 896     {
 897       bool negate = false;
 898       bool fixed_size = true;
 899       int input_no;;
 900
 901       if (*buf_ptr == '+' || *buf_ptr == '-')
 902         {
 903           if (*buf_ptr == '-')
 904             negate = true;
 905           fixed_size = false;
 906           buf_ptr++;
 907         }
 908       input_no = atoi (buf_ptr);
 909       if (input_no > 0)
 910         {
 911           if (negate)
 912             input_no *= (-1);
 913           if (fixed_size)
 914             new_height = input_no;
 915           else
 916             new_height = win_info->height + input_no;
 917
 918           /* Now change the window's height, and adjust
 919              all other windows around it.  */
 920           tui_adjust_window_height (win_info, new_height);
 921           tui_update_gdb_sizes ();
 922         }
 923       else
 924         error (_("Invalid window height specified"));
 925     }
 926 }
 927
 928 /* See tui-data.h.  */
 929
 930 int
 931 tui_win_info::max_height () const
 932 {
 933   return tui_term_height () - 2;
 934 }
 935
 936 /* See tui-data.h.  */
 937
 938 int
 939 tui_gen_win_info::max_width () const
 940 {
 941   return tui_term_width () - 2;
 942 }
 943
 944 static void
 945 parse_scrolling_args (const char *arg,
 946                       struct tui_win_info **win_to_scroll,
 947                       int *num_to_scroll)
 948 {
 949   if (num_to_scroll)
 950     *num_to_scroll = 0;
 951   *win_to_scroll = tui_win_with_focus ();
 952
 953   /* First set up the default window to scroll, in case there is no
 954      window name arg.  */
 955   if (arg != NULL)
 956     {
 957       char *buf_ptr;
 958
 959       /* Process the number of lines to scroll.  */
 960       std::string copy = arg;
 961       buf_ptr = &copy[0];
 962       if (isdigit (*buf_ptr))
 963         {
 964           char *num_str;
 965
 966           num_str = buf_ptr;
 967           buf_ptr = strchr (buf_ptr, ' ');
 968           if (buf_ptr != NULL)
 969             {
 970               *buf_ptr = '\0';
 971               if (num_to_scroll)
 972                 *num_to_scroll = atoi (num_str);
 973               buf_ptr++;
 974             }
 975           else if (num_to_scroll)
 976             *num_to_scroll = atoi (num_str);
 977         }
 978
 979       /* Process the window name if one is specified.  */
 980       if (buf_ptr != NULL)
 981         {
 982           const char *wname;
 983
 984           wname = skip_spaces (buf_ptr);
 985
 986           if (*wname != '\0')
 987             {
 988               *win_to_scroll = tui_partial_win_by_name (wname);
 989
 990               if (*win_to_scroll == NULL)
 991                 error (_("Unrecognized window `%s'"), wname);
 992               if (!(*win_to_scroll)->is_visible ())
 993                 error (_("Window is not visible"));
 994               else if (*win_to_scroll == TUI_CMD_WIN)
 995                 *win_to_scroll = *(tui_source_windows ().begin ());
 996             }
 997         }
 998     }
 999 }
1000
1001 /* Function to initialize gdb commands, for tui window
1002    manipulation.  */
1003
1004 void _initialize_tui_win ();
1005 void
1006 _initialize_tui_win ()
1007 {
1008   static struct cmd_list_element *tui_setlist;
1009   static struct cmd_list_element *tui_showlist;
1010   struct cmd_list_element *cmd;
1011
1012   /* Define the classes of commands.
1013      They will appear in the help list in the reverse of this order.  */
1014   add_prefix_cmd ("tui", class_tui, set_tui_cmd,
1015                   _("TUI configuration variables."),
1016                   &tui_setlist, "set tui ",
1017                   0 /* allow-unknown */, &setlist);
1018   add_prefix_cmd ("tui", class_tui, show_tui_cmd,
1019                   _("TUI configuration variables."),
1020                   &tui_showlist, "show tui ",
1021                   0 /* allow-unknown */, &showlist);
1022
1023   add_com ("refresh", class_tui, tui_refresh_all_command,
1024            _("Refresh the terminal display."));
1025
1026   cmd = add_com ("tabset", class_tui, tui_set_tab_width_command, _("\
1027 Set the width (in characters) of tab stops.\n\
1028 Usage: tabset N"));
1029   deprecate_cmd (cmd, "set tui tab-width");
1030
1031   cmd = add_com ("winheight", class_tui, tui_set_win_height_command, _("\
1032 Set or modify the height of a specified window.\n\
1033 Usage: winheight WINDOW-NAME [+ | -] NUM-LINES\n\
1034 Use \"info win\" to see the names of the windows currently being displayed."));
1035   add_com_alias ("wh", "winheight", class_tui, 0);
1036   set_cmd_completer (cmd, winheight_completer);
1037   add_info ("win", tui_all_windows_info,
1038             _("List of all displayed windows.\n\
1039 Usage: info win"));
1040   cmd = add_com ("focus", class_tui, tui_set_focus_command, _("\
1041 Set focus to named window or next/prev window.\n\
1042 Usage: focus [WINDOW-NAME | next | prev]\n\
1043 Use \"info win\" to see the names of the windows currently being displayed."));
1044   add_com_alias ("fs", "focus", class_tui, 0);
1045   set_cmd_completer (cmd, focus_completer);
1046   add_com ("+", class_tui, tui_scroll_forward_command, _("\
1047 Scroll window forward.\n\
1048 Usage: + [N] [WIN]\n\
1049 Scroll window WIN N lines forwards.  Both WIN and N are optional, N\n\
1050 defaults to 1, and WIN defaults to the currently focused window."));
1051   add_com ("-", class_tui, tui_scroll_backward_command, _("\
1052 Scroll window backward.\n\
1053 Usage: - [N] [WIN]\n\
1054 Scroll window WIN N lines backwards.  Both WIN and N are optional, N\n\
1055 defaults to 1, and WIN defaults to the currently focused window."));
1056   add_com ("<", class_tui, tui_scroll_left_command, _("\
1057 Scroll window text to the left.\n\
1058 Usage: < [N] [WIN]\n\
1059 Scroll window WIN N characters left.  Both WIN and N are optional, N\n\
1060 defaults to 1, and WIN defaults to the currently focused window."));
1061   add_com (">", class_tui, tui_scroll_right_command, _("\
1062 Scroll window text to the right.\n\
1063 Usage: > [N] [WIN]\n\
1064 Scroll window WIN N characters right.  Both WIN and N are optional, N\n\
1065 defaults to 1, and WIN defaults to the currently focused window."));
1066
1067   /* Define the tui control variables.  */
1068   add_setshow_enum_cmd ("border-kind", no_class, tui_border_kind_enums,
1069                         &tui_border_kind, _("\
1070 Set the kind of border for TUI windows."), _("\
1071 Show the kind of border for TUI windows."), _("\
1072 This variable controls the border of TUI windows:\n\
1073    space           use a white space\n\
1074    ascii           use ascii characters + - | for the border\n\
1075    acs             use the Alternate Character Set"),
1076                         tui_set_var_cmd,
1077                         show_tui_border_kind,
1078                         &tui_setlist, &tui_showlist);
1079
1080   add_setshow_enum_cmd ("border-mode", no_class, tui_border_mode_enums,
1081                         &tui_border_mode, _("\
1082 Set the attribute mode to use for the TUI window borders."), _("\
1083 Show the attribute mode to use for the TUI window borders."), _("\
1084 This variable controls the attributes to use for the window borders:\n\
1085    normal          normal display\n\
1086    standout        use highlight mode of terminal\n\
1087    reverse         use reverse video mode\n\
1088    half            use half bright\n\
1089    half-standout   use half bright and standout mode\n\
1090    bold            use extra bright or bold\n\
1091    bold-standout   use extra bright or bold with standout mode"),
1092                         tui_set_var_cmd,
1093                         show_tui_border_mode,
1094                         &tui_setlist, &tui_showlist);
1095
1096   add_setshow_enum_cmd ("active-border-mode", no_class, tui_border_mode_enums,
1097                         &tui_active_border_mode, _("\
1098 Set the attribute mode to use for the active TUI window border."), _("\
1099 Show the attribute mode to use for the active TUI window border."), _("\
1100 This variable controls the attributes to use for the active window border:\n\
1101    normal          normal display\n\
1102    standout        use highlight mode of terminal\n\
1103    reverse         use reverse video mode\n\
1104    half            use half bright\n\
1105    half-standout   use half bright and standout mode\n\
1106    bold            use extra bright or bold\n\
1107    bold-standout   use extra bright or bold with standout mode"),
1108                         tui_set_var_cmd,
1109                         show_tui_active_border_mode,
1110                         &tui_setlist, &tui_showlist);
1111
1112   add_setshow_zuinteger_cmd ("tab-width", no_class,
1113                              &internal_tab_width, _("\
1114 Set the tab width, in characters, for the TUI."), _("\
1115 Show the tab witdh, in characters, for the TUI."), _("\
1116 This variable controls how many spaces are used to display a tab character."),
1117                              tui_set_tab_width, tui_show_tab_width,
1118                              &tui_setlist, &tui_showlist);
1119
1120   add_setshow_boolean_cmd ("tui-resize-message", class_maintenance,
1121                            &resize_message, _("\
1122 Set TUI resize messaging."), _("\
1123 Show TUI resize messaging."), _("\
1124 When enabled GDB will print a message when the terminal is resized."),
1125                            nullptr,
1126                            show_tui_resize_message,
1127                            &maintenance_set_cmdlist,
1128                            &maintenance_show_cmdlist);
1129
1130   add_setshow_boolean_cmd ("compact-source", class_tui,
1131                            &compact_source, _("\
1132 Set whether the TUI source window is compact."), _("\
1133 Show whether the TUI source window is compact."), _("\
1134 This variable controls whether the TUI source window is shown\n\
1135 in a compact form.  The compact form puts the source closer to\n\
1136 the line numbers and uses less horizontal space."),
1137                            tui_set_compact_source, tui_show_compact_source,
1138                            &tui_setlist, &tui_showlist);
1139
1140   tui_border_style.changed.attach (tui_rehighlight_all);
1141   tui_active_border_style.changed.attach (tui_rehighlight_all);
1142 }