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 "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
 581   {
 582 #ifdef HAVE_SIGACTION
 583     struct sigaction old_winch;
 584
 585     memset (&old_winch, 0, sizeof (old_winch));
 586     old_winch.sa_handler = &tui_sigwinch_handler;
 587 #ifdef SA_RESTART
 588     old_winch.sa_flags = SA_RESTART;
 589 #endif
 590     sigaction (SIGWINCH, &old_winch, NULL);
 591 #else
 592     signal (SIGWINCH, &tui_sigwinch_handler);
 593 #endif
 594   }
 595 #endif
 596 }
 597
 598
 599 static void
 600 tui_scroll_forward_command (const char *arg, int from_tty)
 601 {
 602   int num_to_scroll = 1;
 603   struct tui_win_info *win_to_scroll;
 604
 605   /* Make sure the curses mode is enabled.  */
 606   tui_enable ();
 607   if (arg == NULL)
 608     parse_scrolling_args (arg, &win_to_scroll, NULL);
 609   else
 610     parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 611   win_to_scroll->forward_scroll (num_to_scroll);
 612 }
 613
 614
 615 static void
 616 tui_scroll_backward_command (const char *arg, int from_tty)
 617 {
 618   int num_to_scroll = 1;
 619   struct tui_win_info *win_to_scroll;
 620
 621   /* Make sure the curses mode is enabled.  */
 622   tui_enable ();
 623   if (arg == NULL)
 624     parse_scrolling_args (arg, &win_to_scroll, NULL);
 625   else
 626     parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 627   win_to_scroll->backward_scroll (num_to_scroll);
 628 }
 629
 630
 631 static void
 632 tui_scroll_left_command (const char *arg, int from_tty)
 633 {
 634   int num_to_scroll;
 635   struct tui_win_info *win_to_scroll;
 636
 637   /* Make sure the curses mode is enabled.  */
 638   tui_enable ();
 639   parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 640   win_to_scroll->left_scroll (num_to_scroll);
 641 }
 642
 643
 644 static void
 645 tui_scroll_right_command (const char *arg, int from_tty)
 646 {
 647   int num_to_scroll;
 648   struct tui_win_info *win_to_scroll;
 649
 650   /* Make sure the curses mode is enabled.  */
 651   tui_enable ();
 652   parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 653   win_to_scroll->right_scroll (num_to_scroll);
 654 }
 655
 656
 657 /* Answer the window represented by name.  */
 658 static struct tui_win_info *
 659 tui_partial_win_by_name (gdb::string_view name)
 660 {
 661   struct tui_win_info *best = nullptr;
 662
 663   if (name != NULL)
 664     {
 665       for (tui_win_info *item : all_tui_windows ())
 666         {
 667           const char *cur_name = item->name ();
 668
 669           if (name == cur_name)
 670             return item;
 671           if (startswith (cur_name, name))
 672             {
 673               if (best != nullptr)
 674                 error (_("Window name \"%*s\" is ambiguous"),
 675                        (int) name.size (), name.data ());
 676               best = item;
 677             }
 678         }
 679     }
 680
 681   return best;
 682 }
 683
 684 /* Set focus to the window named by 'arg'.  */
 685 static void
 686 tui_set_focus_command (const char *arg, int from_tty)
 687 {
 688   tui_enable ();
 689
 690   if (arg == NULL)
 691     error_no_arg (_("name of window to focus"));
 692
 693   struct tui_win_info *win_info = NULL;
 694
 695   if (subset_compare (arg, "next"))
 696     win_info = tui_next_win (tui_win_with_focus ());
 697   else if (subset_compare (arg, "prev"))
 698     win_info = tui_prev_win (tui_win_with_focus ());
 699   else
 700     win_info = tui_partial_win_by_name (arg);
 701
 702   if (win_info == NULL)
 703     error (_("Unrecognized window name \"%s\""), arg);
 704   if (!win_info->is_visible ())
 705     error (_("Window \"%s\" is not visible"), arg);
 706
 707   tui_set_win_focus_to (win_info);
 708   keypad (TUI_CMD_WIN->handle.get (), win_info != TUI_CMD_WIN);
 709   printf_filtered (_("Focus set to %s window.\n"),
 710                    tui_win_with_focus ()->name ());
 711 }
 712
 713 static void
 714 tui_all_windows_info (const char *arg, int from_tty)
 715 {
 716   if (!tui_active)
 717     {
 718       printf_filtered (_("The TUI is not active.\n"));
 719       return;
 720     }
 721
 722   struct tui_win_info *win_with_focus = tui_win_with_focus ();
 723   struct ui_out *uiout = current_uiout;
 724
 725   ui_out_emit_table table_emitter (uiout, 3, -1, "tui-windows");
 726   uiout->table_header (10, ui_left, "name", "Name");
 727   uiout->table_header (5, ui_right, "lines", "Lines");
 728   uiout->table_header (10, ui_left, "focus", "Focus");
 729   uiout->table_body ();
 730
 731   for (tui_win_info *win_info : all_tui_windows ())
 732     if (win_info->is_visible ())
 733       {
 734         ui_out_emit_tuple tuple_emitter (uiout, nullptr);
 735
 736         uiout->field_string ("name", win_info->name ());
 737         uiout->field_signed ("lines", win_info->height);
 738         if (win_with_focus == win_info)
 739           uiout->field_string ("focus", _("(has focus)"));
 740         else
 741           uiout->field_skip ("focus");
 742         uiout->text ("\n");
 743       }
 744 }
 745
 746
 747 static void
 748 tui_refresh_all_command (const char *arg, int from_tty)
 749 {
 750   /* Make sure the curses mode is enabled.  */
 751   tui_enable ();
 752
 753   tui_refresh_all_win ();
 754 }
 755
 756 #define DEFAULT_TAB_LEN         8
 757
 758 /* The tab width that should be used by the TUI.  */
 759
 760 unsigned int tui_tab_width = DEFAULT_TAB_LEN;
 761
 762 /* The tab width as set by the user.  */
 763
 764 static unsigned int internal_tab_width = DEFAULT_TAB_LEN;
 765
 766 /* After the tab width is set, call this to update the relevant
 767    windows.  */
 768
 769 static void
 770 update_tab_width ()
 771 {
 772   for (tui_win_info *win_info : all_tui_windows ())
 773     {
 774       if (win_info->is_visible ())
 775         win_info->update_tab_width ();
 776     }
 777 }
 778
 779 /* Callback for "set tui tab-width".  */
 780
 781 static void
 782 tui_set_tab_width (const char *ignore,
 783                    int from_tty, struct cmd_list_element *c)
 784 {
 785   if (internal_tab_width == 0)
 786     {
 787       internal_tab_width = tui_tab_width;
 788       error (_("Tab width must not be 0"));
 789     }
 790
 791   tui_tab_width = internal_tab_width;
 792   update_tab_width ();
 793 }
 794
 795 /* Callback for "show tui tab-width".  */
 796
 797 static void
 798 tui_show_tab_width (struct ui_file *file, int from_tty,
 799                     struct cmd_list_element *c, const char *value)
 800 {
 801   fprintf_filtered (gdb_stdout, _("TUI tab width is %s spaces.\n"), value);
 802
 803 }
 804
 805 /* See tui-win.h.  */
 806
 807 bool compact_source = false;
 808
 809 /* Callback for "set tui compact-source".  */
 810
 811 static void
 812 tui_set_compact_source (const char *ignore, int from_tty,
 813                         struct cmd_list_element *c)
 814 {
 815   if (TUI_SRC_WIN != nullptr)
 816     TUI_SRC_WIN->refill ();
 817 }
 818
 819 /* Callback for "show tui compact-source".  */
 820
 821 static void
 822 tui_show_compact_source (struct ui_file *file, int from_tty,
 823                          struct cmd_list_element *c, const char *value)
 824 {
 825   printf_filtered (_("TUI source window compactness is %s.\n"), value);
 826 }
 827
 828 /* Set the tab width of the specified window.  */
 829 static void
 830 tui_set_tab_width_command (const char *arg, int from_tty)
 831 {
 832   /* Make sure the curses mode is enabled.  */
 833   tui_enable ();
 834   if (arg != NULL)
 835     {
 836       int ts;
 837
 838       ts = atoi (arg);
 839       if (ts <= 0)
 840         warning (_("Tab widths greater than 0 must be specified."));
 841       else
 842         {
 843           internal_tab_width = ts;
 844           tui_tab_width = ts;
 845
 846           update_tab_width ();
 847         }
 848     }
 849 }
 850
 851
 852 /* Set the height of the specified window.  */
 853 static void
 854 tui_set_win_height_command (const char *arg, int from_tty)
 855 {
 856   /* Make sure the curses mode is enabled.  */
 857   tui_enable ();
 858   if (arg == NULL)
 859     error_no_arg (_("name of window"));
 860
 861   const char *buf = arg;
 862   const char *buf_ptr = buf;
 863   int new_height;
 864   struct tui_win_info *win_info;
 865
 866   buf_ptr = skip_to_space (buf_ptr);
 867
 868   /* Validate the window name.  */
 869   gdb::string_view wname (buf, buf_ptr - buf);
 870   win_info = tui_partial_win_by_name (wname);
 871
 872   if (win_info == NULL)
 873     error (_("Unrecognized window name \"%s\""), arg);
 874   if (!win_info->is_visible ())
 875     error (_("Window \"%s\" is not visible"), arg);
 876
 877   /* Process the size.  */
 878   buf_ptr = skip_spaces (buf_ptr);
 879
 880   if (*buf_ptr != '\0')
 881     {
 882       bool negate = false;
 883       bool fixed_size = true;
 884       int input_no;;
 885
 886       if (*buf_ptr == '+' || *buf_ptr == '-')
 887         {
 888           if (*buf_ptr == '-')
 889             negate = true;
 890           fixed_size = false;
 891           buf_ptr++;
 892         }
 893       input_no = atoi (buf_ptr);
 894       if (input_no > 0)
 895         {
 896           if (negate)
 897             input_no *= (-1);
 898           if (fixed_size)
 899             new_height = input_no;
 900           else
 901             new_height = win_info->height + input_no;
 902
 903           /* Now change the window's height, and adjust
 904              all other windows around it.  */
 905           tui_adjust_window_height (win_info, new_height);
 906           tui_update_gdb_sizes ();
 907         }
 908       else
 909         error (_("Invalid window height specified"));
 910     }
 911 }
 912
 913 /* See tui-data.h.  */
 914
 915 int
 916 tui_win_info::max_height () const
 917 {
 918   return tui_term_height () - 2;
 919 }
 920
 921 /* See tui-data.h.  */
 922
 923 int
 924 tui_win_info::max_width () const
 925 {
 926   return tui_term_width () - 2;
 927 }
 928
 929 static void
 930 parse_scrolling_args (const char *arg,
 931                       struct tui_win_info **win_to_scroll,
 932                       int *num_to_scroll)
 933 {
 934   if (num_to_scroll)
 935     *num_to_scroll = 0;
 936   *win_to_scroll = tui_win_with_focus ();
 937
 938   /* First set up the default window to scroll, in case there is no
 939      window name arg.  */
 940   if (arg != NULL)
 941     {
 942       char *buf_ptr;
 943
 944       /* Process the number of lines to scroll.  */
 945       std::string copy = arg;
 946       buf_ptr = &copy[0];
 947       if (isdigit (*buf_ptr))
 948         {
 949           char *num_str;
 950
 951           num_str = buf_ptr;
 952           buf_ptr = strchr (buf_ptr, ' ');
 953           if (buf_ptr != NULL)
 954             {
 955               *buf_ptr = '\0';
 956               if (num_to_scroll)
 957                 *num_to_scroll = atoi (num_str);
 958               buf_ptr++;
 959             }
 960           else if (num_to_scroll)
 961             *num_to_scroll = atoi (num_str);
 962         }
 963
 964       /* Process the window name if one is specified.  */
 965       if (buf_ptr != NULL)
 966         {
 967           const char *wname;
 968
 969           wname = skip_spaces (buf_ptr);
 970
 971           if (*wname != '\0')
 972             {
 973               *win_to_scroll = tui_partial_win_by_name (wname);
 974
 975               if (*win_to_scroll == NULL)
 976                 error (_("Unrecognized window `%s'"), wname);
 977               if (!(*win_to_scroll)->is_visible ())
 978                 error (_("Window is not visible"));
 979               else if (*win_to_scroll == TUI_CMD_WIN)
 980                 *win_to_scroll = *(tui_source_windows ().begin ());
 981             }
 982         }
 983     }
 984 }
 985
 986 /* Function to initialize gdb commands, for tui window
 987    manipulation.  */
 988
 989 void _initialize_tui_win ();
 990 void
 991 _initialize_tui_win ()
 992 {
 993   static struct cmd_list_element *tui_setlist;
 994   static struct cmd_list_element *tui_showlist;
 995   struct cmd_list_element *cmd;
 996
 997   /* Define the classes of commands.
 998      They will appear in the help list in the reverse of this order.  */
 999   add_basic_prefix_cmd ("tui", class_tui,
1000                         _("TUI configuration variables."),
1001                         &tui_setlist, "set tui ",
1002                         0 /* allow-unknown */, &setlist);
1003   add_show_prefix_cmd ("tui", class_tui,
1004                        _("TUI configuration variables."),
1005                        &tui_showlist, "show tui ",
1006                        0 /* allow-unknown */, &showlist);
1007
1008   add_com ("refresh", class_tui, tui_refresh_all_command,
1009            _("Refresh the terminal display."));
1010
1011   cmd = add_com ("tabset", class_tui, tui_set_tab_width_command, _("\
1012 Set the width (in characters) of tab stops.\n\
1013 Usage: tabset N"));
1014   deprecate_cmd (cmd, "set tui tab-width");
1015
1016   cmd = add_com ("winheight", class_tui, tui_set_win_height_command, _("\
1017 Set or modify the height of a specified window.\n\
1018 Usage: winheight WINDOW-NAME [+ | -] NUM-LINES\n\
1019 Use \"info win\" to see the names of the windows currently being displayed."));
1020   add_com_alias ("wh", "winheight", class_tui, 0);
1021   set_cmd_completer (cmd, winheight_completer);
1022   add_info ("win", tui_all_windows_info,
1023             _("List of all displayed windows.\n\
1024 Usage: info win"));
1025   cmd = add_com ("focus", class_tui, tui_set_focus_command, _("\
1026 Set focus to named window or next/prev window.\n\
1027 Usage: focus [WINDOW-NAME | next | prev]\n\
1028 Use \"info win\" to see the names of the windows currently being displayed."));
1029   add_com_alias ("fs", "focus", class_tui, 0);
1030   set_cmd_completer (cmd, focus_completer);
1031   add_com ("+", class_tui, tui_scroll_forward_command, _("\
1032 Scroll window forward.\n\
1033 Usage: + [N] [WIN]\n\
1034 Scroll window WIN N lines forwards.  Both WIN and N are optional, N\n\
1035 defaults to 1, and WIN defaults to the currently focused window."));
1036   add_com ("-", class_tui, tui_scroll_backward_command, _("\
1037 Scroll window backward.\n\
1038 Usage: - [N] [WIN]\n\
1039 Scroll window WIN N lines backwards.  Both WIN and N are optional, N\n\
1040 defaults to 1, and WIN defaults to the currently focused window."));
1041   add_com ("<", class_tui, tui_scroll_left_command, _("\
1042 Scroll window text to the left.\n\
1043 Usage: < [N] [WIN]\n\
1044 Scroll window WIN N characters left.  Both WIN and N are optional, N\n\
1045 defaults to 1, and WIN defaults to the currently focused window."));
1046   add_com (">", class_tui, tui_scroll_right_command, _("\
1047 Scroll window text to the right.\n\
1048 Usage: > [N] [WIN]\n\
1049 Scroll window WIN N characters right.  Both WIN and N are optional, N\n\
1050 defaults to 1, and WIN defaults to the currently focused window."));
1051
1052   /* Define the tui control variables.  */
1053   add_setshow_enum_cmd ("border-kind", no_class, tui_border_kind_enums,
1054                         &tui_border_kind, _("\
1055 Set the kind of border for TUI windows."), _("\
1056 Show the kind of border for TUI windows."), _("\
1057 This variable controls the border of TUI windows:\n\
1058    space           use a white space\n\
1059    ascii           use ascii characters + - | for the border\n\
1060    acs             use the Alternate Character Set"),
1061                         tui_set_var_cmd,
1062                         show_tui_border_kind,
1063                         &tui_setlist, &tui_showlist);
1064
1065   add_setshow_enum_cmd ("border-mode", no_class, tui_border_mode_enums,
1066                         &tui_border_mode, _("\
1067 Set the attribute mode to use for the TUI window borders."), _("\
1068 Show the attribute mode to use for the TUI window borders."), _("\
1069 This variable controls the attributes to use for the window borders:\n\
1070    normal          normal display\n\
1071    standout        use highlight mode of terminal\n\
1072    reverse         use reverse video mode\n\
1073    half            use half bright\n\
1074    half-standout   use half bright and standout mode\n\
1075    bold            use extra bright or bold\n\
1076    bold-standout   use extra bright or bold with standout mode"),
1077                         tui_set_var_cmd,
1078                         show_tui_border_mode,
1079                         &tui_setlist, &tui_showlist);
1080
1081   add_setshow_enum_cmd ("active-border-mode", no_class, tui_border_mode_enums,
1082                         &tui_active_border_mode, _("\
1083 Set the attribute mode to use for the active TUI window border."), _("\
1084 Show the attribute mode to use for the active TUI window border."), _("\
1085 This variable controls the attributes to use for the active window border:\n\
1086    normal          normal display\n\
1087    standout        use highlight mode of terminal\n\
1088    reverse         use reverse video mode\n\
1089    half            use half bright\n\
1090    half-standout   use half bright and standout mode\n\
1091    bold            use extra bright or bold\n\
1092    bold-standout   use extra bright or bold with standout mode"),
1093                         tui_set_var_cmd,
1094                         show_tui_active_border_mode,
1095                         &tui_setlist, &tui_showlist);
1096
1097   add_setshow_zuinteger_cmd ("tab-width", no_class,
1098                              &internal_tab_width, _("\
1099 Set the tab width, in characters, for the TUI."), _("\
1100 Show the tab witdh, in characters, for the TUI."), _("\
1101 This variable controls how many spaces are used to display a tab character."),
1102                              tui_set_tab_width, tui_show_tab_width,
1103                              &tui_setlist, &tui_showlist);
1104
1105   add_setshow_boolean_cmd ("tui-resize-message", class_maintenance,
1106                            &resize_message, _("\
1107 Set TUI resize messaging."), _("\
1108 Show TUI resize messaging."), _("\
1109 When enabled GDB will print a message when the terminal is resized."),
1110                            nullptr,
1111                            show_tui_resize_message,
1112                            &maintenance_set_cmdlist,
1113                            &maintenance_show_cmdlist);
1114
1115   add_setshow_boolean_cmd ("compact-source", class_tui,
1116                            &compact_source, _("\
1117 Set whether the TUI source window is compact."), _("\
1118 Show whether the TUI source window is compact."), _("\
1119 This variable controls whether the TUI source window is shown\n\
1120 in a compact form.  The compact form puts the source closer to\n\
1121 the line numbers and uses less horizontal space."),
1122                            tui_set_compact_source, tui_show_compact_source,
1123                            &tui_setlist, &tui_showlist);
1124
1125   tui_border_style.changed.attach (tui_rehighlight_all);
1126   tui_active_border_style.changed.attach (tui_rehighlight_all);
1127 }