gdb/tui/tui-win.c

   1 /* TUI window generic functions.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
   4    Foundation, Inc.
   5
   6    Contributed by Hewlett-Packard Company.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 /* This module contains procedures for handling tui window functions
  26    like resize, scrolling, scrolling, changing focus, etc.
  27
  28    Author: Susan B. Macchia  */
  29
  30 #include "defs.h"
  31 #include "command.h"
  32 #include "symtab.h"
  33 #include "breakpoint.h"
  34 #include "frame.h"
  35 #include "cli/cli-cmds.h"
  36 #include "top.h"
  37 #include "source.h"
  38
  39 #include "tui/tui.h"
  40 #include "tui/tui-data.h"
  41 #include "tui/tui-wingeneral.h"
  42 #include "tui/tui-stack.h"
  43 #include "tui/tui-regs.h"
  44 #include "tui/tui-disasm.h"
  45 #include "tui/tui-source.h"
  46 #include "tui/tui-winsource.h"
  47 #include "tui/tui-windata.h"
  48
  49 #include "gdb_curses.h"
  50
  51 #include "gdb_string.h"
  52 #include <ctype.h>
  53 #include "readline/readline.h"
  54
  55 /*******************************
  56 ** Static Local Decls
  57 ********************************/
  58 static void make_visible_with_new_height (struct tui_win_info *);
  59 static void make_invisible_and_set_new_height (struct tui_win_info *, int);
  60 static enum tui_status tui_adjust_win_heights (struct tui_win_info *, int);
  61 static int new_height_ok (struct tui_win_info *, int);
  62 static void tui_set_tab_width_command (char *, int);
  63 static void tui_refresh_all_command (char *, int);
  64 static void tui_set_win_height_command (char *, int);
  65 static void tui_xdb_set_win_height_command (char *, int);
  66 static void tui_all_windows_info (char *, int);
  67 static void tui_set_focus_command (char *, int);
  68 static void tui_scroll_forward_command (char *, int);
  69 static void tui_scroll_backward_command (char *, int);
  70 static void tui_scroll_left_command (char *, int);
  71 static void tui_scroll_right_command (char *, int);
  72 static void parse_scrolling_args (char *, struct tui_win_info * *, int *);
  73
  74
  75 /***************************************
  76 ** DEFINITIONS
  77 ***************************************/
  78 #define WIN_HEIGHT_USAGE      "Usage: winheight <win_name> [+ | -] <#lines>\n"
  79 #define XDBWIN_HEIGHT_USAGE   "Usage: w <#lines>\n"
  80 #define FOCUS_USAGE           "Usage: focus {<win> | next | prev}\n"
  81
  82 /***************************************
  83 ** PUBLIC FUNCTIONS
  84 ***************************************/
  85
  86 #ifndef ACS_LRCORNER
  87 #  define ACS_LRCORNER '+'
  88 #endif
  89 #ifndef ACS_LLCORNER
  90 #  define ACS_LLCORNER '+'
  91 #endif
  92 #ifndef ACS_ULCORNER
  93 #  define ACS_ULCORNER '+'
  94 #endif
  95 #ifndef ACS_URCORNER
  96 #  define ACS_URCORNER '+'
  97 #endif
  98 #ifndef ACS_HLINE
  99 #  define ACS_HLINE '-'
 100 #endif
 101 #ifndef ACS_VLINE
 102 #  define ACS_VLINE '|'
 103 #endif
 104
 105 /* Possible values for tui-border-kind variable.  */
 106 static const char *tui_border_kind_enums[] = {
 107   "space",
 108   "ascii",
 109   "acs",
 110   NULL
 111 };
 112
 113 /* Possible values for tui-border-mode and tui-active-border-mode.  */
 114 static const char *tui_border_mode_enums[] = {
 115   "normal",
 116   "standout",
 117   "reverse",
 118   "half",
 119   "half-standout",
 120   "bold",
 121   "bold-standout",
 122   NULL
 123 };
 124
 125 struct tui_translate
 126 {
 127   const char *name;
 128   int value;
 129 };
 130
 131 /* Translation table for border-mode variables.
 132    The list of values must be terminated by a NULL.
 133    After the NULL value, an entry defines the default.  */
 134 struct tui_translate tui_border_mode_translate[] = {
 135   { "normal",           A_NORMAL },
 136   { "standout",         A_STANDOUT },
 137   { "reverse",          A_REVERSE },
 138   { "half",             A_DIM },
 139   { "half-standout",    A_DIM | A_STANDOUT },
 140   { "bold",             A_BOLD },
 141   { "bold-standout",    A_BOLD | A_STANDOUT },
 142   { 0, 0 },
 143   { "normal",           A_NORMAL }
 144 };
 145
 146 /* Translation tables for border-kind, one for each border
 147    character (see wborder, border curses operations).
 148    -1 is used to indicate the ACS because ACS characters
 149    are determined at run time by curses (depends on terminal).  */
 150 struct tui_translate tui_border_kind_translate_vline[] = {
 151   { "space",    ' ' },
 152   { "ascii",    '|' },
 153   { "acs",      -1 },
 154   { 0, 0 },
 155   { "ascii",    '|' }
 156 };
 157
 158 struct tui_translate tui_border_kind_translate_hline[] = {
 159   { "space",    ' ' },
 160   { "ascii",    '-' },
 161   { "acs",      -1 },
 162   { 0, 0 },
 163   { "ascii",    '-' }
 164 };
 165
 166 struct tui_translate tui_border_kind_translate_ulcorner[] = {
 167   { "space",    ' ' },
 168   { "ascii",    '+' },
 169   { "acs",      -1 },
 170   { 0, 0 },
 171   { "ascii",    '+' }
 172 };
 173
 174 struct tui_translate tui_border_kind_translate_urcorner[] = {
 175   { "space",    ' ' },
 176   { "ascii",    '+' },
 177   { "acs",      -1 },
 178   { 0, 0 },
 179   { "ascii",    '+' }
 180 };
 181
 182 struct tui_translate tui_border_kind_translate_llcorner[] = {
 183   { "space",    ' ' },
 184   { "ascii",    '+' },
 185   { "acs",      -1 },
 186   { 0, 0 },
 187   { "ascii",    '+' }
 188 };
 189
 190 struct tui_translate tui_border_kind_translate_lrcorner[] = {
 191   { "space",    ' ' },
 192   { "ascii",    '+' },
 193   { "acs",      -1 },
 194   { 0, 0 },
 195   { "ascii",    '+' }
 196 };
 197
 198
 199 /* Tui configuration variables controlled with set/show command.  */
 200 const char *tui_active_border_mode = "bold-standout";
 201 static void
 202 show_tui_active_border_mode (struct ui_file *file, int from_tty,
 203                              struct cmd_list_element *c, const char *value)
 204 {
 205   fprintf_filtered (file, _("\
 206 The attribute mode to use for the active TUI window border is \"%s\".\n"),
 207                     value);
 208 }
 209
 210 const char *tui_border_mode = "normal";
 211 static void
 212 show_tui_border_mode (struct ui_file *file, int from_tty,
 213                       struct cmd_list_element *c, const char *value)
 214 {
 215   fprintf_filtered (file, _("\
 216 The attribute mode to use for the TUI window borders is \"%s\".\n"),
 217                     value);
 218 }
 219
 220 const char *tui_border_kind = "acs";
 221 static void
 222 show_tui_border_kind (struct ui_file *file, int from_tty,
 223                       struct cmd_list_element *c, const char *value)
 224 {
 225   fprintf_filtered (file, _("The kind of border for TUI windows is \"%s\".\n"),
 226                     value);
 227 }
 228
 229
 230 /* Tui internal configuration variables.  These variables are
 231    updated by tui_update_variables to reflect the tui configuration
 232    variables.  */
 233 chtype tui_border_vline;
 234 chtype tui_border_hline;
 235 chtype tui_border_ulcorner;
 236 chtype tui_border_urcorner;
 237 chtype tui_border_llcorner;
 238 chtype tui_border_lrcorner;
 239
 240 int tui_border_attrs;
 241 int tui_active_border_attrs;
 242
 243 /* Identify the item in the translation table.
 244    When the item is not recognized, use the default entry.  */
 245 static struct tui_translate *
 246 translate (const char *name, struct tui_translate *table)
 247 {
 248   while (table->name)
 249     {
 250       if (name && strcmp (table->name, name) == 0)
 251         return table;
 252       table++;
 253     }
 254
 255   /* Not found, return default entry.  */
 256   table++;
 257   return table;
 258 }
 259
 260 /* Update the tui internal configuration according to gdb settings.
 261    Returns 1 if the configuration has changed and the screen should
 262    be redrawn.  */
 263 int
 264 tui_update_variables (void)
 265 {
 266   int need_redraw = 0;
 267   struct tui_translate *entry;
 268
 269   entry = translate (tui_border_mode, tui_border_mode_translate);
 270   if (tui_border_attrs != entry->value)
 271     {
 272       tui_border_attrs = entry->value;
 273       need_redraw = 1;
 274     }
 275   entry = translate (tui_active_border_mode, tui_border_mode_translate);
 276   if (tui_active_border_attrs != entry->value)
 277     {
 278       tui_active_border_attrs = entry->value;
 279       need_redraw = 1;
 280     }
 281
 282   /* If one corner changes, all characters are changed.
 283      Only check the first one.  The ACS characters are determined at
 284      run time by curses terminal management.  */
 285   entry = translate (tui_border_kind, tui_border_kind_translate_lrcorner);
 286   if (tui_border_lrcorner != (chtype) entry->value)
 287     {
 288       tui_border_lrcorner = (entry->value < 0) ? ACS_LRCORNER : entry->value;
 289       need_redraw = 1;
 290     }
 291   entry = translate (tui_border_kind, tui_border_kind_translate_llcorner);
 292   tui_border_llcorner = (entry->value < 0) ? ACS_LLCORNER : entry->value;
 293
 294   entry = translate (tui_border_kind, tui_border_kind_translate_ulcorner);
 295   tui_border_ulcorner = (entry->value < 0) ? ACS_ULCORNER : entry->value;
 296
 297   entry = translate (tui_border_kind, tui_border_kind_translate_urcorner);
 298   tui_border_urcorner = (entry->value < 0) ? ACS_URCORNER : entry->value;
 299
 300   entry = translate (tui_border_kind, tui_border_kind_translate_hline);
 301   tui_border_hline = (entry->value < 0) ? ACS_HLINE : entry->value;
 302
 303   entry = translate (tui_border_kind, tui_border_kind_translate_vline);
 304   tui_border_vline = (entry->value < 0) ? ACS_VLINE : entry->value;
 305
 306   return need_redraw;
 307 }
 308
 309 static void
 310 set_tui_cmd (char *args, int from_tty)
 311 {
 312 }
 313
 314 static void
 315 show_tui_cmd (char *args, int from_tty)
 316 {
 317 }
 318
 319 static struct cmd_list_element *tuilist;
 320
 321 static void
 322 tui_command (char *args, int from_tty)
 323 {
 324   printf_unfiltered (_("\"tui\" must be followed by the name of a "
 325                      "tui command.\n"));
 326   help_list (tuilist, "tui ", -1, gdb_stdout);
 327 }
 328
 329 struct cmd_list_element **
 330 tui_get_cmd_list (void)
 331 {
 332   if (tuilist == 0)
 333     add_prefix_cmd ("tui", class_tui, tui_command,
 334                     _("Text User Interface commands."),
 335                     &tuilist, "tui ", 0, &cmdlist);
 336   return &tuilist;
 337 }
 338
 339 /* Function to initialize gdb commands, for tui window manipulation.  */
 340 void
 341 _initialize_tui_win (void)
 342 {
 343   struct cmd_list_element *c;
 344   static struct cmd_list_element *tui_setlist;
 345   static struct cmd_list_element *tui_showlist;
 346
 347   /* Define the classes of commands.
 348      They will appear in the help list in the reverse of this order.  */
 349   add_prefix_cmd ("tui", class_tui, set_tui_cmd,
 350                   _("TUI configuration variables"),
 351                   &tui_setlist, "set tui ",
 352                   0/*allow-unknown*/, &setlist);
 353   add_prefix_cmd ("tui", class_tui, show_tui_cmd,
 354                   _("TUI configuration variables"),
 355                   &tui_showlist, "show tui ",
 356                   0/*allow-unknown*/, &showlist);
 357
 358   add_com ("refresh", class_tui, tui_refresh_all_command,
 359            _("Refresh the terminal display.\n"));
 360   if (xdb_commands)
 361     add_com_alias ("U", "refresh", class_tui, 0);
 362   add_com ("tabset", class_tui, tui_set_tab_width_command, _("\
 363 Set the width (in characters) of tab stops.\n\
 364 Usage: tabset <n>\n"));
 365   add_com ("winheight", class_tui, tui_set_win_height_command, _("\
 366 Set the height of a specified window.\n\
 367 Usage: winheight <win_name> [+ | -] <#lines>\n\
 368 Window names are:\n\
 369 src  : the source window\n\
 370 cmd  : the command window\n\
 371 asm  : the disassembly window\n\
 372 regs : the register display\n"));
 373   add_com_alias ("wh", "winheight", class_tui, 0);
 374   add_info ("win", tui_all_windows_info,
 375             _("List of all displayed windows.\n"));
 376   add_com ("focus", class_tui, tui_set_focus_command, _("\
 377 Set focus to named window or next/prev window.\n\
 378 Usage: focus {<win> | next | prev}\n\
 379 Valid Window names are:\n\
 380 src  : the source window\n\
 381 asm  : the disassembly window\n\
 382 regs : the register display\n\
 383 cmd  : the command window\n"));
 384   add_com_alias ("fs", "focus", class_tui, 0);
 385   add_com ("+", class_tui, tui_scroll_forward_command, _("\
 386 Scroll window forward.\n\
 387 Usage: + [win] [n]\n"));
 388   add_com ("-", class_tui, tui_scroll_backward_command, _("\
 389 Scroll window backward.\n\
 390 Usage: - [win] [n]\n"));
 391   add_com ("<", class_tui, tui_scroll_left_command, _("\
 392 Scroll window forward.\n\
 393 Usage: < [win] [n]\n"));
 394   add_com (">", class_tui, tui_scroll_right_command, _("\
 395 Scroll window backward.\n\
 396 Usage: > [win] [n]\n"));
 397   if (xdb_commands)
 398     add_com ("w", class_xdb, tui_xdb_set_win_height_command, _("\
 399 XDB compatibility command for setting the height of a command window.\n\
 400 Usage: w <#lines>\n"));
 401
 402   /* Define the tui control variables.  */
 403   add_setshow_enum_cmd ("border-kind", no_class, tui_border_kind_enums,
 404                         &tui_border_kind, _("\
 405 Set the kind of border for TUI windows."), _("\
 406 Show the kind of border for TUI windows."), _("\
 407 This variable controls the border of TUI windows:\n\
 408 space           use a white space\n\
 409 ascii           use ascii characters + - | for the border\n\
 410 acs             use the Alternate Character Set"),
 411                         NULL,
 412                         show_tui_border_kind,
 413                         &tui_setlist, &tui_showlist);
 414
 415   add_setshow_enum_cmd ("border-mode", no_class, tui_border_mode_enums,
 416                         &tui_border_mode, _("\
 417 Set the attribute mode to use for the TUI window borders."), _("\
 418 Show the attribute mode to use for the TUI window borders."), _("\
 419 This variable controls the attributes to use for the window borders:\n\
 420 normal          normal display\n\
 421 standout        use highlight mode of terminal\n\
 422 reverse         use reverse video mode\n\
 423 half            use half bright\n\
 424 half-standout   use half bright and standout mode\n\
 425 bold            use extra bright or bold\n\
 426 bold-standout   use extra bright or bold with standout mode"),
 427                         NULL,
 428                         show_tui_border_mode,
 429                         &tui_setlist, &tui_showlist);
 430
 431   add_setshow_enum_cmd ("active-border-mode", no_class, tui_border_mode_enums,
 432                         &tui_active_border_mode, _("\
 433 Set the attribute mode to use for the active TUI window border."), _("\
 434 Show the attribute mode to use for the active TUI window border."), _("\
 435 This variable controls the attributes to use for the active window border:\n\
 436 normal          normal display\n\
 437 standout        use highlight mode of terminal\n\
 438 reverse         use reverse video mode\n\
 439 half            use half bright\n\
 440 half-standout   use half bright and standout mode\n\
 441 bold            use extra bright or bold\n\
 442 bold-standout   use extra bright or bold with standout mode"),
 443                         NULL,
 444                         show_tui_active_border_mode,
 445                         &tui_setlist, &tui_showlist);
 446 }
 447
 448 /* Update gdb's knowledge of the terminal size.  */
 449 void
 450 tui_update_gdb_sizes (void)
 451 {
 452   char cmd[50];
 453
 454   /* Set to TUI command window dimension or use readline values.  */
 455   sprintf (cmd, "set width %d",
 456            tui_active ? TUI_CMD_WIN->generic.width : tui_term_width());
 457   execute_command (cmd, 0);
 458   sprintf (cmd, "set height %d",
 459            tui_active ? TUI_CMD_WIN->generic.height : tui_term_height());
 460   execute_command (cmd, 0);
 461 }
 462
 463
 464 /* Set the logical focus to win_info.    */
 465 void
 466 tui_set_win_focus_to (struct tui_win_info * win_info)
 467 {
 468   if (win_info != NULL)
 469     {
 470       struct tui_win_info * win_with_focus = tui_win_with_focus ();
 471
 472       if (win_with_focus != NULL
 473           && win_with_focus->generic.type != CMD_WIN)
 474         tui_unhighlight_win (win_with_focus);
 475       tui_set_win_with_focus (win_info);
 476       if (win_info->generic.type != CMD_WIN)
 477         tui_highlight_win (win_info);
 478     }
 479 }
 480
 481
 482 void
 483 tui_scroll_forward (struct tui_win_info * win_to_scroll, int num_to_scroll)
 484 {
 485   if (win_to_scroll != TUI_CMD_WIN)
 486     {
 487       int _num_to_scroll = num_to_scroll;
 488
 489       if (num_to_scroll == 0)
 490         _num_to_scroll = win_to_scroll->generic.height - 3;
 491       /*
 492          ** If we are scrolling the source or disassembly window, do a
 493          ** "psuedo" scroll since not all of the source is in memory,
 494          ** only what is in the viewport.  If win_to_scroll is the
 495          ** command window do nothing since the term should handle it.
 496        */
 497       if (win_to_scroll == TUI_SRC_WIN)
 498         tui_vertical_source_scroll (FORWARD_SCROLL, _num_to_scroll);
 499       else if (win_to_scroll == TUI_DISASM_WIN)
 500         tui_vertical_disassem_scroll (FORWARD_SCROLL, _num_to_scroll);
 501       else if (win_to_scroll == TUI_DATA_WIN)
 502         tui_vertical_data_scroll (FORWARD_SCROLL, _num_to_scroll);
 503     }
 504 }
 505
 506 void
 507 tui_scroll_backward (struct tui_win_info * win_to_scroll, int num_to_scroll)
 508 {
 509   if (win_to_scroll != TUI_CMD_WIN)
 510     {
 511       int _num_to_scroll = num_to_scroll;
 512
 513       if (num_to_scroll == 0)
 514         _num_to_scroll = win_to_scroll->generic.height - 3;
 515       /*
 516          ** If we are scrolling the source or disassembly window, do a
 517          ** "psuedo" scroll since not all of the source is in memory,
 518          ** only what is in the viewport.  If win_to_scroll is the
 519          ** command window do nothing since the term should handle it.
 520        */
 521       if (win_to_scroll == TUI_SRC_WIN)
 522         tui_vertical_source_scroll (BACKWARD_SCROLL, _num_to_scroll);
 523       else if (win_to_scroll == TUI_DISASM_WIN)
 524         tui_vertical_disassem_scroll (BACKWARD_SCROLL, _num_to_scroll);
 525       else if (win_to_scroll == TUI_DATA_WIN)
 526         tui_vertical_data_scroll (BACKWARD_SCROLL, _num_to_scroll);
 527     }
 528 }
 529
 530
 531 void
 532 tui_scroll_left (struct tui_win_info * win_to_scroll, int num_to_scroll)
 533 {
 534   if (win_to_scroll != TUI_CMD_WIN)
 535     {
 536       int _num_to_scroll = num_to_scroll;
 537
 538       if (_num_to_scroll == 0)
 539         _num_to_scroll = 1;
 540       /*
 541          ** If we are scrolling the source or disassembly window, do a
 542          ** "psuedo" scroll since not all of the source is in memory,
 543          ** only what is in the viewport. If win_to_scroll is the
 544          ** command window do nothing since the term should handle it.
 545        */
 546       if (win_to_scroll == TUI_SRC_WIN || win_to_scroll == TUI_DISASM_WIN)
 547         tui_horizontal_source_scroll (win_to_scroll, LEFT_SCROLL, _num_to_scroll);
 548     }
 549 }
 550
 551
 552 void
 553 tui_scroll_right (struct tui_win_info * win_to_scroll, int num_to_scroll)
 554 {
 555   if (win_to_scroll != TUI_CMD_WIN)
 556     {
 557       int _num_to_scroll = num_to_scroll;
 558
 559       if (_num_to_scroll == 0)
 560         _num_to_scroll = 1;
 561       /*
 562          ** If we are scrolling the source or disassembly window, do a
 563          ** "psuedo" scroll since not all of the source is in memory,
 564          ** only what is in the viewport. If win_to_scroll is the
 565          ** command window do nothing since the term should handle it.
 566        */
 567       if (win_to_scroll == TUI_SRC_WIN || win_to_scroll == TUI_DISASM_WIN)
 568         tui_horizontal_source_scroll (win_to_scroll, RIGHT_SCROLL, _num_to_scroll);
 569     }
 570 }
 571
 572
 573 /* Scroll a window.  Arguments are passed through a va_list.    */
 574 void
 575 tui_scroll (enum tui_scroll_direction direction,
 576             struct tui_win_info * win_to_scroll,
 577             int num_to_scroll)
 578 {
 579   switch (direction)
 580     {
 581     case FORWARD_SCROLL:
 582       tui_scroll_forward (win_to_scroll, num_to_scroll);
 583       break;
 584     case BACKWARD_SCROLL:
 585       tui_scroll_backward (win_to_scroll, num_to_scroll);
 586       break;
 587     case LEFT_SCROLL:
 588       tui_scroll_left (win_to_scroll, num_to_scroll);
 589       break;
 590     case RIGHT_SCROLL:
 591       tui_scroll_right (win_to_scroll, num_to_scroll);
 592       break;
 593     default:
 594       break;
 595     }
 596 }
 597
 598
 599 void
 600 tui_refresh_all_win (void)
 601 {
 602   enum tui_win_type type;
 603
 604   clearok (curscr, TRUE);
 605   tui_refresh_all (tui_win_list);
 606   for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
 607     {
 608       if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
 609         {
 610           switch (type)
 611             {
 612             case SRC_WIN:
 613             case DISASSEM_WIN:
 614               tui_show_source_content (tui_win_list[type]);
 615               tui_check_and_display_highlight_if_needed (tui_win_list[type]);
 616               tui_erase_exec_info_content (tui_win_list[type]);
 617               tui_update_exec_info (tui_win_list[type]);
 618               break;
 619             case DATA_WIN:
 620               tui_refresh_data_win ();
 621               break;
 622             default:
 623               break;
 624             }
 625         }
 626     }
 627   tui_show_locator_content ();
 628 }
 629
 630
 631 /* Resize all the windows based on the the terminal size.  This
 632    function gets called from within the readline sinwinch handler.  */
 633 void
 634 tui_resize_all (void)
 635 {
 636   int height_diff, width_diff;
 637   int screenheight, screenwidth;
 638
 639   rl_get_screen_size (&screenheight, &screenwidth);
 640   width_diff = screenwidth - tui_term_width ();
 641   height_diff = screenheight - tui_term_height ();
 642   if (height_diff || width_diff)
 643     {
 644       enum tui_layout_type cur_layout = tui_current_layout ();
 645       struct tui_win_info * win_with_focus = tui_win_with_focus ();
 646       struct tui_win_info *first_win;
 647       struct tui_win_info *second_win;
 648       struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
 649       enum tui_win_type win_type;
 650       int new_height, split_diff, cmd_split_diff, num_wins_displayed = 2;
 651
 652 #ifdef HAVE_RESIZE_TERM
 653       resize_term (screenheight, screenwidth);
 654 #endif
 655       /* turn keypad off while we resize */
 656       if (win_with_focus != TUI_CMD_WIN)
 657         keypad (TUI_CMD_WIN->generic.handle, FALSE);
 658       tui_update_gdb_sizes ();
 659       tui_set_term_height_to (screenheight);
 660       tui_set_term_width_to (screenwidth);
 661       if (cur_layout == SRC_DISASSEM_COMMAND ||
 662         cur_layout == SRC_DATA_COMMAND || cur_layout == DISASSEM_DATA_COMMAND)
 663         num_wins_displayed++;
 664       split_diff = height_diff / num_wins_displayed;
 665       cmd_split_diff = split_diff;
 666       if (height_diff % num_wins_displayed)
 667         {
 668           if (height_diff < 0)
 669             cmd_split_diff--;
 670           else
 671             cmd_split_diff++;
 672         }
 673       /* now adjust each window */
 674       clear ();
 675       refresh ();
 676       switch (cur_layout)
 677         {
 678         case SRC_COMMAND:
 679         case DISASSEM_COMMAND:
 680           first_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
 681           first_win->generic.width += width_diff;
 682           locator->width += width_diff;
 683           /* check for invalid heights */
 684           if (height_diff == 0)
 685             new_height = first_win->generic.height;
 686           else if ((first_win->generic.height + split_diff) >=
 687                    (screenheight - MIN_CMD_WIN_HEIGHT - 1))
 688             new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
 689           else if ((first_win->generic.height + split_diff) <= 0)
 690             new_height = MIN_WIN_HEIGHT;
 691           else
 692             new_height = first_win->generic.height + split_diff;
 693
 694           make_invisible_and_set_new_height (first_win, new_height);
 695           TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
 696           TUI_CMD_WIN->generic.width += width_diff;
 697           new_height = screenheight - TUI_CMD_WIN->generic.origin.y;
 698           make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
 699           make_visible_with_new_height (first_win);
 700           make_visible_with_new_height (TUI_CMD_WIN);
 701           if (first_win->generic.content_size <= 0)
 702             tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
 703           break;
 704         default:
 705           if (cur_layout == SRC_DISASSEM_COMMAND)
 706             {
 707               first_win = TUI_SRC_WIN;
 708               first_win->generic.width += width_diff;
 709               second_win = TUI_DISASM_WIN;
 710               second_win->generic.width += width_diff;
 711             }
 712           else
 713             {
 714               first_win = TUI_DATA_WIN;
 715               first_win->generic.width += width_diff;
 716               second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
 717               second_win->generic.width += width_diff;
 718             }
 719           /* Change the first window's height/width */
 720           /* check for invalid heights */
 721           if (height_diff == 0)
 722             new_height = first_win->generic.height;
 723           else if ((first_win->generic.height +
 724                     second_win->generic.height + (split_diff * 2)) >=
 725                    (screenheight - MIN_CMD_WIN_HEIGHT - 1))
 726             new_height = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
 727           else if ((first_win->generic.height + split_diff) <= 0)
 728             new_height = MIN_WIN_HEIGHT;
 729           else
 730             new_height = first_win->generic.height + split_diff;
 731           make_invisible_and_set_new_height (first_win, new_height);
 732
 733           locator->width += width_diff;
 734
 735           /* Change the second window's height/width */
 736           /* check for invalid heights */
 737           if (height_diff == 0)
 738             new_height = second_win->generic.height;
 739           else if ((first_win->generic.height +
 740                     second_win->generic.height + (split_diff * 2)) >=
 741                    (screenheight - MIN_CMD_WIN_HEIGHT - 1))
 742             {
 743               new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
 744               if (new_height % 2)
 745                 new_height = (new_height / 2) + 1;
 746               else
 747                 new_height /= 2;
 748             }
 749           else if ((second_win->generic.height + split_diff) <= 0)
 750             new_height = MIN_WIN_HEIGHT;
 751           else
 752             new_height = second_win->generic.height + split_diff;
 753           second_win->generic.origin.y = first_win->generic.height - 1;
 754           make_invisible_and_set_new_height (second_win, new_height);
 755
 756           /* Change the command window's height/width */
 757           TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
 758           make_invisible_and_set_new_height (
 759                              TUI_CMD_WIN, TUI_CMD_WIN->generic.height + cmd_split_diff);
 760           make_visible_with_new_height (first_win);
 761           make_visible_with_new_height (second_win);
 762           make_visible_with_new_height (TUI_CMD_WIN);
 763           if (first_win->generic.content_size <= 0)
 764             tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
 765           if (second_win->generic.content_size <= 0)
 766             tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
 767           break;
 768         }
 769       /*
 770          ** Now remove all invisible windows, and their content so that they get
 771          ** created again when called for with the new size
 772        */
 773       for (win_type = SRC_WIN; (win_type < MAX_MAJOR_WINDOWS); win_type++)
 774         {
 775           if (win_type != CMD_WIN && (tui_win_list[win_type] != NULL)
 776               && !tui_win_list[win_type]->generic.is_visible)
 777             {
 778               tui_free_window (tui_win_list[win_type]);
 779               tui_win_list[win_type] = (struct tui_win_info *) NULL;
 780             }
 781         }
 782       tui_set_win_resized_to (TRUE);
 783       /* turn keypad back on, unless focus is in the command window */
 784       if (win_with_focus != TUI_CMD_WIN)
 785         keypad (TUI_CMD_WIN->generic.handle, TRUE);
 786     }
 787 }
 788
 789
 790 /* SIGWINCH signal handler for the tui.  This signal handler is always
 791    called, even when the readline package clears signals because it is
 792    set as the old_sigwinch() (TUI only).  */
 793 void
 794 tui_sigwinch_handler (int signal)
 795 {
 796   /*
 797      ** Say that a resize was done so that the readline can do it
 798      ** later when appropriate.
 799    */
 800   tui_set_win_resized_to (TRUE);
 801 }
 802
 803
 804
 805 /*************************
 806 ** STATIC LOCAL FUNCTIONS
 807 **************************/
 808
 809
 810 static void
 811 tui_scroll_forward_command (char *arg, int from_tty)
 812 {
 813   int num_to_scroll = 1;
 814   struct tui_win_info * win_to_scroll;
 815
 816   /* Make sure the curses mode is enabled.  */
 817   tui_enable ();
 818   if (arg == (char *) NULL)
 819     parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
 820   else
 821     parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 822   tui_scroll (FORWARD_SCROLL, win_to_scroll, num_to_scroll);
 823 }
 824
 825
 826 static void
 827 tui_scroll_backward_command (char *arg, int from_tty)
 828 {
 829   int num_to_scroll = 1;
 830   struct tui_win_info * win_to_scroll;
 831
 832   /* Make sure the curses mode is enabled.  */
 833   tui_enable ();
 834   if (arg == (char *) NULL)
 835     parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
 836   else
 837     parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 838   tui_scroll (BACKWARD_SCROLL, win_to_scroll, num_to_scroll);
 839 }
 840
 841
 842 static void
 843 tui_scroll_left_command (char *arg, int from_tty)
 844 {
 845   int num_to_scroll;
 846   struct tui_win_info * win_to_scroll;
 847
 848   /* Make sure the curses mode is enabled.  */
 849   tui_enable ();
 850   parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 851   tui_scroll (LEFT_SCROLL, win_to_scroll, num_to_scroll);
 852 }
 853
 854
 855 static void
 856 tui_scroll_right_command (char *arg, int from_tty)
 857 {
 858   int num_to_scroll;
 859   struct tui_win_info * win_to_scroll;
 860
 861   /* Make sure the curses mode is enabled.  */
 862   tui_enable ();
 863   parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
 864   tui_scroll (RIGHT_SCROLL, win_to_scroll, num_to_scroll);
 865 }
 866
 867
 868 /* Set focus to the window named by 'arg'.  */
 869 static void
 870 tui_set_focus (char *arg, int from_tty)
 871 {
 872   if (arg != (char *) NULL)
 873     {
 874       char *buf_ptr = (char *) xstrdup (arg);
 875       int i;
 876       struct tui_win_info * win_info = (struct tui_win_info *) NULL;
 877
 878       for (i = 0; (i < strlen (buf_ptr)); i++)
 879         buf_ptr[i] = toupper (arg[i]);
 880
 881       if (subset_compare (buf_ptr, "NEXT"))
 882         win_info = tui_next_win (tui_win_with_focus ());
 883       else if (subset_compare (buf_ptr, "PREV"))
 884         win_info = tui_prev_win (tui_win_with_focus ());
 885       else
 886         win_info = tui_partial_win_by_name (buf_ptr);
 887
 888       if (win_info == (struct tui_win_info *) NULL || !win_info->generic.is_visible)
 889         warning (_("Invalid window specified. \n\
 890 The window name specified must be valid and visible.\n"));
 891       else
 892         {
 893           tui_set_win_focus_to (win_info);
 894           keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
 895         }
 896
 897       if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
 898         tui_refresh_data_win ();
 899       xfree (buf_ptr);
 900       printf_filtered (_("Focus set to %s window.\n"),
 901                        tui_win_name ((struct tui_gen_win_info *) tui_win_with_focus ()));
 902     }
 903   else
 904     warning (_("Incorrect Number of Arguments.\n%s"), FOCUS_USAGE);
 905 }
 906
 907 static void
 908 tui_set_focus_command (char *arg, int from_tty)
 909 {
 910   /* Make sure the curses mode is enabled.  */
 911   tui_enable ();
 912   tui_set_focus (arg, from_tty);
 913 }
 914
 915
 916 static void
 917 tui_all_windows_info (char *arg, int from_tty)
 918 {
 919   enum tui_win_type type;
 920   struct tui_win_info * win_with_focus = tui_win_with_focus ();
 921
 922   for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
 923     if (tui_win_list[type] && tui_win_list[type]->generic.is_visible)
 924       {
 925         if (win_with_focus == tui_win_list[type])
 926           printf_filtered ("        %s\t(%d lines)  <has focus>\n",
 927                            tui_win_name (&tui_win_list[type]->generic),
 928                            tui_win_list[type]->generic.height);
 929         else
 930           printf_filtered ("        %s\t(%d lines)\n",
 931                            tui_win_name (&tui_win_list[type]->generic),
 932                            tui_win_list[type]->generic.height);
 933       }
 934 }
 935
 936
 937 static void
 938 tui_refresh_all_command (char *arg, int from_tty)
 939 {
 940   /* Make sure the curses mode is enabled.  */
 941   tui_enable ();
 942
 943   tui_refresh_all_win ();
 944 }
 945
 946
 947 /* Set the height of the specified window.   */
 948 static void
 949 tui_set_tab_width_command (char *arg, int from_tty)
 950 {
 951   /* Make sure the curses mode is enabled.  */
 952   tui_enable ();
 953   if (arg != (char *) NULL)
 954     {
 955       int ts;
 956
 957       ts = atoi (arg);
 958       if (ts > 0)
 959         tui_set_default_tab_len (ts);
 960       else
 961         warning (_("Tab widths greater than 0 must be specified."));
 962     }
 963 }
 964
 965
 966 /* Set the height of the specified window.   */
 967 static void
 968 tui_set_win_height (char *arg, int from_tty)
 969 {
 970   /* Make sure the curses mode is enabled.  */
 971   tui_enable ();
 972   if (arg != (char *) NULL)
 973     {
 974       char *buf = xstrdup (arg);
 975       char *buf_ptr = buf;
 976       char *wname = (char *) NULL;
 977       int new_height, i;
 978       struct tui_win_info * win_info;
 979
 980       wname = buf_ptr;
 981       buf_ptr = strchr (buf_ptr, ' ');
 982       if (buf_ptr != (char *) NULL)
 983         {
 984           *buf_ptr = (char) 0;
 985
 986           /*
 987              ** Validate the window name
 988            */
 989           for (i = 0; i < strlen (wname); i++)
 990             wname[i] = toupper (wname[i]);
 991           win_info = tui_partial_win_by_name (wname);
 992
 993           if (win_info == (struct tui_win_info *) NULL || !win_info->generic.is_visible)
 994             warning (_("Invalid window specified. \n\
 995 The window name specified must be valid and visible.\n"));
 996           else
 997             {
 998               /* Process the size */
 999               while (*(++buf_ptr) == ' ')
1000                 ;
1001
1002               if (*buf_ptr != (char) 0)
1003                 {
1004                   int negate = FALSE;
1005                   int fixed_size = TRUE;
1006                   int input_no;;
1007
1008                   if (*buf_ptr == '+' || *buf_ptr == '-')
1009                     {
1010                       if (*buf_ptr == '-')
1011                         negate = TRUE;
1012                       fixed_size = FALSE;
1013                       buf_ptr++;
1014                     }
1015                   input_no = atoi (buf_ptr);
1016                   if (input_no > 0)
1017                     {
1018                       if (negate)
1019                         input_no *= (-1);
1020                       if (fixed_size)
1021                         new_height = input_no;
1022                       else
1023                         new_height = win_info->generic.height + input_no;
1024                       /*
1025                          ** Now change the window's height, and adjust all
1026                          ** other windows around it
1027                        */
1028                       if (tui_adjust_win_heights (win_info,
1029                                                 new_height) == TUI_FAILURE)
1030                         warning (_("Invalid window height specified.\n%s"),
1031                                  WIN_HEIGHT_USAGE);
1032                       else
1033                         tui_update_gdb_sizes ();
1034                     }
1035                   else
1036                     warning (_("Invalid window height specified.\n%s"),
1037                              WIN_HEIGHT_USAGE);
1038                 }
1039             }
1040         }
1041       else
1042         printf_filtered (WIN_HEIGHT_USAGE);
1043
1044       if (buf != (char *) NULL)
1045         xfree (buf);
1046     }
1047   else
1048     printf_filtered (WIN_HEIGHT_USAGE);
1049 }
1050
1051 /* Set the height of the specified window, with va_list.    */
1052 static void
1053 tui_set_win_height_command (char *arg, int from_tty)
1054 {
1055   /* Make sure the curses mode is enabled.  */
1056   tui_enable ();
1057   tui_set_win_height (arg, from_tty);
1058 }
1059
1060
1061 /* XDB Compatibility command for setting the window height.  This will
1062    increase or decrease the command window by the specified amount.  */
1063 static void
1064 tui_xdb_set_win_height (char *arg, int from_tty)
1065 {
1066   /* Make sure the curses mode is enabled.  */
1067   tui_enable ();
1068   if (arg != (char *) NULL)
1069     {
1070       int input_no = atoi (arg);
1071
1072       if (input_no > 0)
1073         {                       /* Add 1 for the locator */
1074           int new_height = tui_term_height () - (input_no + 1);
1075
1076           if (!new_height_ok (tui_win_list[CMD_WIN], new_height) ||
1077               tui_adjust_win_heights (tui_win_list[CMD_WIN],
1078                                     new_height) == TUI_FAILURE)
1079             warning (_("Invalid window height specified.\n%s"),
1080                      XDBWIN_HEIGHT_USAGE);
1081         }
1082       else
1083         warning (_("Invalid window height specified.\n%s"),
1084                  XDBWIN_HEIGHT_USAGE);
1085     }
1086   else
1087     warning (_("Invalid window height specified.\n%s"), XDBWIN_HEIGHT_USAGE);
1088 }
1089
1090 /* Set the height of the specified window, with va_list.  */
1091 static void
1092 tui_xdb_set_win_height_command (char *arg, int from_tty)
1093 {
1094   tui_xdb_set_win_height (arg, from_tty);
1095 }
1096
1097
1098 /* Function to adjust all window heights around the primary.   */
1099 static enum tui_status
1100 tui_adjust_win_heights (struct tui_win_info * primary_win_info, int new_height)
1101 {
1102   enum tui_status status = TUI_FAILURE;
1103
1104   if (new_height_ok (primary_win_info, new_height))
1105     {
1106       status = TUI_SUCCESS;
1107       if (new_height != primary_win_info->generic.height)
1108         {
1109           int diff;
1110           struct tui_win_info * win_info;
1111           struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
1112           enum tui_layout_type cur_layout = tui_current_layout ();
1113
1114           diff = (new_height - primary_win_info->generic.height) * (-1);
1115           if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
1116             {
1117               struct tui_win_info * src_win_info;
1118
1119               make_invisible_and_set_new_height (primary_win_info, new_height);
1120               if (primary_win_info->generic.type == CMD_WIN)
1121                 {
1122                   win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
1123                   src_win_info = win_info;
1124                 }
1125               else
1126                 {
1127                   win_info = tui_win_list[CMD_WIN];
1128                   src_win_info = primary_win_info;
1129                 }
1130               make_invisible_and_set_new_height (win_info,
1131                                              win_info->generic.height + diff);
1132               TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
1133               make_visible_with_new_height (win_info);
1134               make_visible_with_new_height (primary_win_info);
1135               if (src_win_info->generic.content_size <= 0)
1136                 tui_erase_source_content (src_win_info, EMPTY_SOURCE_PROMPT);
1137             }
1138           else
1139             {
1140               struct tui_win_info *first_win;
1141               struct tui_win_info *second_win;
1142
1143               if (cur_layout == SRC_DISASSEM_COMMAND)
1144                 {
1145                   first_win = TUI_SRC_WIN;
1146                   second_win = TUI_DISASM_WIN;
1147                 }
1148               else
1149                 {
1150                   first_win = TUI_DATA_WIN;
1151                   second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
1152                 }
1153               if (primary_win_info == TUI_CMD_WIN)
1154                 {               /*
1155                                    ** Split the change in height accross the 1st & 2nd windows
1156                                    ** adjusting them as well.
1157                                  */
1158                   int first_split_diff = diff / 2;      /* subtract the locator */
1159                   int second_split_diff = first_split_diff;
1160
1161                   if (diff % 2)
1162                     {
1163                       if (first_win->generic.height >
1164                           second_win->generic.height)
1165                         if (diff < 0)
1166                           first_split_diff--;
1167                         else
1168                           first_split_diff++;
1169                       else
1170                         {
1171                           if (diff < 0)
1172                             second_split_diff--;
1173                           else
1174                             second_split_diff++;
1175                         }
1176                     }
1177                   /* make sure that the minimum hieghts are honored */
1178                   while ((first_win->generic.height + first_split_diff) < 3)
1179                     {
1180                       first_split_diff++;
1181                       second_split_diff--;
1182                     }
1183                   while ((second_win->generic.height + second_split_diff) < 3)
1184                     {
1185                       second_split_diff++;
1186                       first_split_diff--;
1187                     }
1188                   make_invisible_and_set_new_height (
1189                                                   first_win,
1190                                  first_win->generic.height + first_split_diff);
1191                   second_win->generic.origin.y = first_win->generic.height - 1;
1192                   make_invisible_and_set_new_height (
1193                     second_win, second_win->generic.height + second_split_diff);
1194                   TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
1195                   make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
1196                 }
1197               else
1198                 {
1199                   if ((TUI_CMD_WIN->generic.height + diff) < 1)
1200                     {           /*
1201                                    ** If there is no way to increase the command window
1202                                    ** take real estate from the 1st or 2nd window.
1203                                  */
1204                       if ((TUI_CMD_WIN->generic.height + diff) < 1)
1205                         {
1206                           int i;
1207                           for (i = TUI_CMD_WIN->generic.height + diff;
1208                                (i < 1); i++)
1209                             if (primary_win_info == first_win)
1210                               second_win->generic.height--;
1211                             else
1212                               first_win->generic.height--;
1213                         }
1214                     }
1215                   if (primary_win_info == first_win)
1216                     make_invisible_and_set_new_height (first_win, new_height);
1217                   else
1218                     make_invisible_and_set_new_height (
1219                                                     first_win,
1220                                                   first_win->generic.height);
1221                   second_win->generic.origin.y = first_win->generic.height - 1;
1222                   if (primary_win_info == second_win)
1223                     make_invisible_and_set_new_height (second_win, new_height);
1224                   else
1225                     make_invisible_and_set_new_height (
1226                                       second_win, second_win->generic.height);
1227                   TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
1228                   if ((TUI_CMD_WIN->generic.height + diff) < 1)
1229                     make_invisible_and_set_new_height (TUI_CMD_WIN, 1);
1230                   else
1231                     make_invisible_and_set_new_height (
1232                                      TUI_CMD_WIN, TUI_CMD_WIN->generic.height + diff);
1233                 }
1234               make_visible_with_new_height (TUI_CMD_WIN);
1235               make_visible_with_new_height (second_win);
1236               make_visible_with_new_height (first_win);
1237               if (first_win->generic.content_size <= 0)
1238                 tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
1239               if (second_win->generic.content_size <= 0)
1240                 tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
1241             }
1242         }
1243     }
1244
1245   return status;
1246 }
1247
1248
1249 /* Function make the target window (and auxillary windows associated
1250    with the targer) invisible, and set the new height and location.  */
1251 static void
1252 make_invisible_and_set_new_height (struct tui_win_info * win_info, int height)
1253 {
1254   int i;
1255   struct tui_gen_win_info * gen_win_info;
1256
1257   tui_make_invisible (&win_info->generic);
1258   win_info->generic.height = height;
1259   if (height > 1)
1260     win_info->generic.viewport_height = height - 1;
1261   else
1262     win_info->generic.viewport_height = height;
1263   if (win_info != TUI_CMD_WIN)
1264     win_info->generic.viewport_height--;
1265
1266   /* Now deal with the auxillary windows associated with win_info */
1267   switch (win_info->generic.type)
1268     {
1269     case SRC_WIN:
1270     case DISASSEM_WIN:
1271       gen_win_info = win_info->detail.source_info.execution_info;
1272       tui_make_invisible (gen_win_info);
1273       gen_win_info->height = height;
1274       gen_win_info->origin.y = win_info->generic.origin.y;
1275       if (height > 1)
1276         gen_win_info->viewport_height = height - 1;
1277       else
1278         gen_win_info->viewport_height = height;
1279       if (win_info != TUI_CMD_WIN)
1280         gen_win_info->viewport_height--;
1281
1282       if (tui_win_has_locator (win_info))
1283         {
1284           gen_win_info = tui_locator_win_info_ptr ();
1285           tui_make_invisible (gen_win_info);
1286           gen_win_info->origin.y = win_info->generic.origin.y + height;
1287         }
1288       break;
1289     case DATA_WIN:
1290       /* delete all data item windows */
1291       for (i = 0; i < win_info->generic.content_size; i++)
1292         {
1293           gen_win_info = (struct tui_gen_win_info *) & ((struct tui_win_element *)
1294                       win_info->generic.content[i])->which_element.data_window;
1295           tui_delete_win (gen_win_info->handle);
1296           gen_win_info->handle = (WINDOW *) NULL;
1297         }
1298       break;
1299     default:
1300       break;
1301     }
1302 }
1303
1304
1305 /* Function to make the windows with new heights visible.  This means
1306    re-creating the windows' content since the window had to be
1307    destroyed to be made invisible.  */
1308 static void
1309 make_visible_with_new_height (struct tui_win_info * win_info)
1310 {
1311   struct symtab *s;
1312
1313   tui_make_visible (&win_info->generic);
1314   tui_check_and_display_highlight_if_needed (win_info);
1315   switch (win_info->generic.type)
1316     {
1317     case SRC_WIN:
1318     case DISASSEM_WIN:
1319       tui_free_win_content (win_info->detail.source_info.execution_info);
1320       tui_make_visible (win_info->detail.source_info.execution_info);
1321       if (win_info->generic.content != NULL)
1322         {
1323           struct tui_line_or_address line_or_addr;
1324           struct symtab_and_line cursal
1325             = get_current_source_symtab_and_line ();
1326
1327           line_or_addr = win_info->detail.source_info.start_line_or_addr;
1328           tui_free_win_content (&win_info->generic);
1329           tui_update_source_window (win_info, cursal.symtab, line_or_addr, TRUE);
1330         }
1331       else if (deprecated_selected_frame != (struct frame_info *) NULL)
1332         {
1333           struct tui_line_or_address line;
1334           struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1335
1336
1337           s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
1338           if (win_info->generic.type == SRC_WIN)
1339             {
1340               line.loa = LOA_LINE;
1341               line.u.line_no = cursal.line;
1342             }
1343           else
1344             {
1345               line.loa = LOA_ADDRESS;
1346               find_line_pc (s, cursal.line, &line.u.addr);
1347             }
1348           tui_update_source_window (win_info, s, line, TRUE);
1349         }
1350       if (tui_win_has_locator (win_info))
1351         {
1352           tui_make_visible (tui_locator_win_info_ptr ());
1353           tui_show_locator_content ();
1354         }
1355       break;
1356     case DATA_WIN:
1357       tui_display_all_data ();
1358       break;
1359     case CMD_WIN:
1360       win_info->detail.command_info.cur_line = 0;
1361       win_info->detail.command_info.curch = 0;
1362       wmove (win_info->generic.handle,
1363              win_info->detail.command_info.cur_line,
1364              win_info->detail.command_info.curch);
1365       break;
1366     default:
1367       break;
1368     }
1369 }
1370
1371
1372 static int
1373 new_height_ok (struct tui_win_info * primary_win_info, int new_height)
1374 {
1375   int ok = (new_height < tui_term_height ());
1376
1377   if (ok)
1378     {
1379       int diff;
1380       enum tui_layout_type cur_layout = tui_current_layout ();
1381
1382       diff = (new_height - primary_win_info->generic.height) * (-1);
1383       if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
1384         {
1385           ok = ((primary_win_info->generic.type == CMD_WIN &&
1386                  new_height <= (tui_term_height () - 4) &&
1387                  new_height >= MIN_CMD_WIN_HEIGHT) ||
1388                 (primary_win_info->generic.type != CMD_WIN &&
1389                  new_height <= (tui_term_height () - 2) &&
1390                  new_height >= MIN_WIN_HEIGHT));
1391           if (ok)
1392             {                   /* check the total height */
1393               struct tui_win_info * win_info;
1394
1395               if (primary_win_info == TUI_CMD_WIN)
1396                 win_info = (struct tui_win_info *) (tui_source_windows ())->list[0];
1397               else
1398                 win_info = TUI_CMD_WIN;
1399               ok = ((new_height +
1400                      (win_info->generic.height + diff)) <= tui_term_height ());
1401             }
1402         }
1403       else
1404         {
1405           int cur_total_height, total_height, min_height = 0;
1406           struct tui_win_info *first_win;
1407           struct tui_win_info *second_win;
1408
1409           if (cur_layout == SRC_DISASSEM_COMMAND)
1410             {
1411               first_win = TUI_SRC_WIN;
1412               second_win = TUI_DISASM_WIN;
1413             }
1414           else
1415             {
1416               first_win = TUI_DATA_WIN;
1417               second_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
1418             }
1419           /*
1420              ** We could simply add all the heights to obtain the same result
1421              ** but below is more explicit since we subtract 1 for the
1422              ** line that the first and second windows share, and add one
1423              ** for the locator.
1424            */
1425           total_height = cur_total_height =
1426             (first_win->generic.height + second_win->generic.height - 1)
1427             + TUI_CMD_WIN->generic.height + 1 /*locator */ ;
1428           if (primary_win_info == TUI_CMD_WIN)
1429             {
1430               /* locator included since first & second win share a line */
1431               ok = ((first_win->generic.height +
1432                      second_win->generic.height + diff) >=
1433                     (MIN_WIN_HEIGHT * 2) &&
1434                     new_height >= MIN_CMD_WIN_HEIGHT);
1435               if (ok)
1436                 {
1437                   total_height = new_height + (first_win->generic.height +
1438                                           second_win->generic.height + diff);
1439                   min_height = MIN_CMD_WIN_HEIGHT;
1440                 }
1441             }
1442           else
1443             {
1444               min_height = MIN_WIN_HEIGHT;
1445               /*
1446                  ** First see if we can increase/decrease the command
1447                  ** window.  And make sure that the command window is
1448                  ** at least 1 line
1449                */
1450               ok = ((TUI_CMD_WIN->generic.height + diff) > 0);
1451               if (!ok)
1452                 {               /*
1453                                    ** Looks like we have to increase/decrease one of
1454                                    ** the other windows
1455                                  */
1456                   if (primary_win_info == first_win)
1457                     ok = (second_win->generic.height + diff) >= min_height;
1458                   else
1459                     ok = (first_win->generic.height + diff) >= min_height;
1460                 }
1461               if (ok)
1462                 {
1463                   if (primary_win_info == first_win)
1464                     total_height = new_height +
1465                       second_win->generic.height +
1466                       TUI_CMD_WIN->generic.height + diff;
1467                   else
1468                     total_height = new_height +
1469                       first_win->generic.height +
1470                       TUI_CMD_WIN->generic.height + diff;
1471                 }
1472             }
1473           /*
1474              ** Now make sure that the proposed total height doesn't exceed
1475              ** the old total height.
1476            */
1477           if (ok)
1478             ok = (new_height >= min_height && total_height <= cur_total_height);
1479         }
1480     }
1481
1482   return ok;
1483 }
1484
1485
1486 static void
1487 parse_scrolling_args (char *arg, struct tui_win_info * * win_to_scroll,
1488                       int *num_to_scroll)
1489 {
1490   if (num_to_scroll)
1491     *num_to_scroll = 0;
1492   *win_to_scroll = tui_win_with_focus ();
1493
1494   /*
1495      ** First set up the default window to scroll, in case there is no
1496      ** window name arg
1497    */
1498   if (arg != (char *) NULL)
1499     {
1500       char *buf, *buf_ptr;
1501
1502       /* process the number of lines to scroll */
1503       buf = buf_ptr = xstrdup (arg);
1504       if (isdigit (*buf_ptr))
1505         {
1506           char *num_str;
1507
1508           num_str = buf_ptr;
1509           buf_ptr = strchr (buf_ptr, ' ');
1510           if (buf_ptr != (char *) NULL)
1511             {
1512               *buf_ptr = (char) 0;
1513               if (num_to_scroll)
1514                 *num_to_scroll = atoi (num_str);
1515               buf_ptr++;
1516             }
1517           else if (num_to_scroll)
1518             *num_to_scroll = atoi (num_str);
1519         }
1520
1521       /* process the window name if one is specified */
1522       if (buf_ptr != (char *) NULL)
1523         {
1524           char *wname;
1525           int i;
1526
1527           if (*buf_ptr == ' ')
1528             while (*(++buf_ptr) == ' ')
1529               ;
1530
1531           if (*buf_ptr != (char) 0)
1532             wname = buf_ptr;
1533           else
1534             wname = "?";
1535
1536           /* Validate the window name */
1537           for (i = 0; i < strlen (wname); i++)
1538             wname[i] = toupper (wname[i]);
1539           *win_to_scroll = tui_partial_win_by_name (wname);
1540
1541           if (*win_to_scroll == (struct tui_win_info *) NULL ||
1542               !(*win_to_scroll)->generic.is_visible)
1543             error (_("Invalid window specified. \n\
1544 The window name specified must be valid and visible.\n"));
1545           else if (*win_to_scroll == TUI_CMD_WIN)
1546             *win_to_scroll = (struct tui_win_info *) (tui_source_windows ())->list[0];
1547         }
1548       xfree (buf);
1549     }
1550 }