gdb/tui/tui-win.c

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