GDB (xrefs)
tui-win.c
Go to the documentation of this file.
1 /* TUI window generic functions.
2 
3  Copyright (C) 1998-2015 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 "top.h"
34 #include "source.h"
35 #include "event-loop.h"
36 
37 #include "tui/tui.h"
38 #include "tui/tui-io.h"
39 #include "tui/tui-data.h"
40 #include "tui/tui-wingeneral.h"
41 #include "tui/tui-stack.h"
42 #include "tui/tui-regs.h"
43 #include "tui/tui-disasm.h"
44 #include "tui/tui-source.h"
45 #include "tui/tui-winsource.h"
46 #include "tui/tui-windata.h"
47 #include "tui/tui-win.h"
48 
49 #include "gdb_curses.h"
50 #include <ctype.h>
51 #include "readline/readline.h"
52 
53 #include <signal.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 *,
60  int);
61 static enum tui_status tui_adjust_win_heights (struct tui_win_info *,
62  int);
63 static int new_height_ok (struct tui_win_info *, int);
64 static void tui_set_tab_width_command (char *, int);
65 static void tui_refresh_all_command (char *, int);
66 static void tui_set_win_height_command (char *, int);
67 static void tui_all_windows_info (char *, int);
68 static void tui_set_focus_command (char *, int);
69 static void tui_scroll_forward_command (char *, int);
70 static void tui_scroll_backward_command (char *, int);
71 static void tui_scroll_left_command (char *, int);
72 static void tui_scroll_right_command (char *, int);
73 static void parse_scrolling_args (char *,
74  struct tui_win_info **,
75  int *);
76 
77 
78 /***************************************
79 ** DEFINITIONS
80 ***************************************/
81 #define WIN_HEIGHT_USAGE "Usage: winheight <win_name> [+ | -] <#lines>\n"
82 #define XDBWIN_HEIGHT_USAGE "Usage: w <#lines>\n"
83 #define FOCUS_USAGE "Usage: focus {<win> | next | prev}\n"
84 
85 /***************************************
86 ** PUBLIC FUNCTIONS
87 ***************************************/
88 
89 #ifndef ACS_LRCORNER
90 # define ACS_LRCORNER '+'
91 #endif
92 #ifndef ACS_LLCORNER
93 # define ACS_LLCORNER '+'
94 #endif
95 #ifndef ACS_ULCORNER
96 # define ACS_ULCORNER '+'
97 #endif
98 #ifndef ACS_URCORNER
99 # define ACS_URCORNER '+'
100 #endif
101 #ifndef ACS_HLINE
102 # define ACS_HLINE '-'
103 #endif
104 #ifndef ACS_VLINE
105 # define ACS_VLINE '|'
106 #endif
107 
108 /* Possible values for tui-border-kind variable. */
109 static const char *const tui_border_kind_enums[] = {
110  "space",
111  "ascii",
112  "acs",
113  NULL
114 };
115 
116 /* Possible values for tui-border-mode and tui-active-border-mode. */
117 static const char *const tui_border_mode_enums[] = {
118  "normal",
119  "standout",
120  "reverse",
121  "half",
122  "half-standout",
123  "bold",
124  "bold-standout",
125  NULL
126 };
127 
129 {
130  const char *name;
131  int value;
132 };
133 
134 /* Translation table for border-mode variables.
135  The list of values must be terminated by a NULL.
136  After the NULL value, an entry defines the default. */
137 struct tui_translate tui_border_mode_translate[] = {
138  { "normal", A_NORMAL },
139  { "standout", A_STANDOUT },
140  { "reverse", A_REVERSE },
141  { "half", A_DIM },
142  { "half-standout", A_DIM | A_STANDOUT },
143  { "bold", A_BOLD },
144  { "bold-standout", A_BOLD | A_STANDOUT },
145  { 0, 0 },
146  { "normal", A_NORMAL }
147 };
148 
149 /* Translation tables for border-kind, one for each border
150  character (see wborder, border curses operations).
151  -1 is used to indicate the ACS because ACS characters
152  are determined at run time by curses (depends on terminal). */
153 struct tui_translate tui_border_kind_translate_vline[] = {
154  { "space", ' ' },
155  { "ascii", '|' },
156  { "acs", -1 },
157  { 0, 0 },
158  { "ascii", '|' }
159 };
160 
161 struct tui_translate tui_border_kind_translate_hline[] = {
162  { "space", ' ' },
163  { "ascii", '-' },
164  { "acs", -1 },
165  { 0, 0 },
166  { "ascii", '-' }
167 };
168 
169 struct tui_translate tui_border_kind_translate_ulcorner[] = {
170  { "space", ' ' },
171  { "ascii", '+' },
172  { "acs", -1 },
173  { 0, 0 },
174  { "ascii", '+' }
175 };
176 
177 struct tui_translate tui_border_kind_translate_urcorner[] = {
178  { "space", ' ' },
179  { "ascii", '+' },
180  { "acs", -1 },
181  { 0, 0 },
182  { "ascii", '+' }
183 };
184 
185 struct tui_translate tui_border_kind_translate_llcorner[] = {
186  { "space", ' ' },
187  { "ascii", '+' },
188  { "acs", -1 },
189  { 0, 0 },
190  { "ascii", '+' }
191 };
192 
193 struct tui_translate tui_border_kind_translate_lrcorner[] = {
194  { "space", ' ' },
195  { "ascii", '+' },
196  { "acs", -1 },
197  { 0, 0 },
198  { "ascii", '+' }
199 };
200 
201 
202 /* Tui configuration variables controlled with set/show command. */
203 const char *tui_active_border_mode = "bold-standout";
204 static void
206  int from_tty,
207  struct cmd_list_element *c,
208  const char *value)
209 {
210  fprintf_filtered (file, _("\
211 The attribute mode to use for the active TUI window border is \"%s\".\n"),
212  value);
213 }
214 
215 const char *tui_border_mode = "normal";
216 static void
218  int from_tty,
219  struct cmd_list_element *c,
220  const char *value)
221 {
222  fprintf_filtered (file, _("\
223 The attribute mode to use for the TUI window borders is \"%s\".\n"),
224  value);
225 }
226 
227 const char *tui_border_kind = "acs";
228 static void
230  int from_tty,
231  struct cmd_list_element *c,
232  const char *value)
233 {
234  fprintf_filtered (file, _("The kind of border for TUI windows is \"%s\".\n"),
235  value);
236 }
237 
238 
239 /* Tui internal configuration variables. These variables are updated
240  by tui_update_variables to reflect the tui configuration
241  variables. */
248 
251 
252 /* Identify the item in the translation table.
253  When the item is not recognized, use the default entry. */
254 static struct tui_translate *
255 translate (const char *name, struct tui_translate *table)
256 {
257  while (table->name)
258  {
259  if (name && strcmp (table->name, name) == 0)
260  return table;
261  table++;
262  }
263 
264  /* Not found, return default entry. */
265  table++;
266  return table;
267 }
268 
269 /* Update the tui internal configuration according to gdb settings.
270  Returns 1 if the configuration has changed and the screen should
271  be redrawn. */
272 int
274 {
275  int need_redraw = 0;
276  struct tui_translate *entry;
277 
278  entry = translate (tui_border_mode, tui_border_mode_translate);
279  if (tui_border_attrs != entry->value)
280  {
281  tui_border_attrs = entry->value;
282  need_redraw = 1;
283  }
284  entry = translate (tui_active_border_mode, tui_border_mode_translate);
285  if (tui_active_border_attrs != entry->value)
286  {
287  tui_active_border_attrs = entry->value;
288  need_redraw = 1;
289  }
290 
291  /* If one corner changes, all characters are changed.
292  Only check the first one. The ACS characters are determined at
293  run time by curses terminal management. */
294  entry = translate (tui_border_kind, tui_border_kind_translate_lrcorner);
295  if (tui_border_lrcorner != (chtype) entry->value)
296  {
297  tui_border_lrcorner = (entry->value < 0) ? ACS_LRCORNER : entry->value;
298  need_redraw = 1;
299  }
300  entry = translate (tui_border_kind, tui_border_kind_translate_llcorner);
301  tui_border_llcorner = (entry->value < 0) ? ACS_LLCORNER : entry->value;
302 
303  entry = translate (tui_border_kind, tui_border_kind_translate_ulcorner);
304  tui_border_ulcorner = (entry->value < 0) ? ACS_ULCORNER : entry->value;
305 
306  entry = translate (tui_border_kind, tui_border_kind_translate_urcorner);
307  tui_border_urcorner = (entry->value < 0) ? ACS_URCORNER : entry->value;
308 
309  entry = translate (tui_border_kind, tui_border_kind_translate_hline);
310  tui_border_hline = (entry->value < 0) ? ACS_HLINE : entry->value;
311 
312  entry = translate (tui_border_kind, tui_border_kind_translate_vline);
313  tui_border_vline = (entry->value < 0) ? ACS_VLINE : entry->value;
314 
315  return need_redraw;
316 }
317 
318 static void
319 set_tui_cmd (char *args, int from_tty)
320 {
321 }
322 
323 static void
324 show_tui_cmd (char *args, int from_tty)
325 {
326 }
327 
328 static struct cmd_list_element *tuilist;
329 
330 static void
331 tui_command (char *args, int from_tty)
332 {
333  printf_unfiltered (_("\"tui\" must be followed by the name of a "
334  "tui command.\n"));
335  help_list (tuilist, "tui ", all_commands, gdb_stdout);
336 }
337 
338 struct cmd_list_element **
340 {
341  if (tuilist == 0)
343  _("Text User Interface commands."),
344  &tuilist, "tui ", 0, &cmdlist);
345  return &tuilist;
346 }
347 
348 /* The set_func hook of "set tui ..." commands that affect the window
349  borders on the TUI display. */
350 void
351 tui_set_var_cmd (char *null_args, int from_tty, struct cmd_list_element *c)
352 {
355 }
356 
357 /* Complete possible window names to focus on. TEXT is the complete text
358  entered so far, WORD is the word currently being completed. */
359 
360 static VEC (char_ptr) *
361 focus_completer (struct cmd_list_element *ignore,
362  const char *text, const char *word)
363 {
364  VEC (const_char_ptr) *completion_name_vec = NULL;
365  VEC (char_ptr) *matches_vec;
366  int win_type;
367 
368  for (win_type = SRC_WIN; win_type < MAX_MAJOR_WINDOWS; win_type++)
369  {
370  const char *completion_name = NULL;
371 
372  /* We can't focus on an invisible window. */
373  if (tui_win_list[win_type] == NULL
374  || !tui_win_list[win_type]->generic.is_visible)
375  continue;
376 
377  switch (win_type)
378  {
379  case SRC_WIN:
380  completion_name = "src";
381  break;
382  case DISASSEM_WIN:
383  completion_name = "asm";
384  break;
385  case DATA_WIN:
386  completion_name = "regs";
387  break;
388  case CMD_WIN:
389  completion_name = "cmd";
390  break;
391  default:
392  break;
393  }
394 
395  if (completion_name != NULL)
396  VEC_safe_push (const_char_ptr, completion_name_vec, completion_name);
397  }
398 
399  /* If no windows are considered visible then the TUI has not yet been
400  initialized. But still "focus src" and "focus cmd" will work because
401  invoking the focus command will entail initializing the TUI which sets the
402  default layout to SRC_COMMAND. */
403  if (VEC_length (const_char_ptr, completion_name_vec) == 0)
404  {
405  VEC_safe_push (const_char_ptr, completion_name_vec, "src");
406  VEC_safe_push (const_char_ptr, completion_name_vec, "cmd");
407  }
408 
409  VEC_safe_push (const_char_ptr, completion_name_vec, "next");
410  VEC_safe_push (const_char_ptr, completion_name_vec, "prev");
411  VEC_safe_push (const_char_ptr, completion_name_vec, NULL);
412 
413  matches_vec
414  = complete_on_enum (VEC_address (const_char_ptr, completion_name_vec),
415  text, word);
416 
417  VEC_free (const_char_ptr, completion_name_vec);
418 
419  return matches_vec;
420 }
421 
422 /* Function to initialize gdb commands, for tui window
423  manipulation. */
424 
425 /* Provide a prototype to silence -Wmissing-prototypes. */
427 
428 void
430 {
431  static struct cmd_list_element *tui_setlist;
432  static struct cmd_list_element *tui_showlist;
433  struct cmd_list_element *focus_cmd;
434 
435  /* Define the classes of commands.
436  They will appear in the help list in the reverse of this order. */
438  _("TUI configuration variables"),
439  &tui_setlist, "set tui ",
440  0 /* allow-unknown */, &setlist);
442  _("TUI configuration variables"),
443  &tui_showlist, "show tui ",
444  0 /* allow-unknown */, &showlist);
445 
447  _("Refresh the terminal display.\n"));
449 Set the width (in characters) of tab stops.\n\
450 Usage: tabset <n>\n"));
451  add_com ("winheight", class_tui, tui_set_win_height_command, _("\
452 Set the height of a specified window.\n\
453 Usage: winheight <win_name> [+ | -] <#lines>\n\
454 Window names are:\n\
455 src : the source window\n\
456 cmd : the command window\n\
457 asm : the disassembly window\n\
458 regs : the register display\n"));
459  add_com_alias ("wh", "winheight", class_tui, 0);
461  _("List of all displayed windows.\n"));
462  focus_cmd = add_com ("focus", class_tui, tui_set_focus_command, _("\
463 Set focus to named window or next/prev window.\n\
464 Usage: focus {<win> | next | prev}\n\
465 Valid Window names are:\n\
466 src : the source window\n\
467 asm : the disassembly window\n\
468 regs : the register display\n\
469 cmd : the command window\n"));
470  add_com_alias ("fs", "focus", class_tui, 0);
471  set_cmd_completer (focus_cmd, focus_completer);
473 Scroll window forward.\n\
474 Usage: + [win] [n]\n"));
476 Scroll window backward.\n\
477 Usage: - [win] [n]\n"));
479 Scroll window text to the left.\n\
480 Usage: < [win] [n]\n"));
482 Scroll window text to the right.\n\
483 Usage: > [win] [n]\n"));
484 
485  /* Define the tui control variables. */
486  add_setshow_enum_cmd ("border-kind", no_class, tui_border_kind_enums,
487  &tui_border_kind, _("\
488 Set the kind of border for TUI windows."), _("\
489 Show the kind of border for TUI windows."), _("\
490 This variable controls the border of TUI windows:\n\
491 space use a white space\n\
492 ascii use ascii characters + - | for the border\n\
493 acs use the Alternate Character Set"),
496  &tui_setlist, &tui_showlist);
497 
498  add_setshow_enum_cmd ("border-mode", no_class, tui_border_mode_enums,
499  &tui_border_mode, _("\
500 Set the attribute mode to use for the TUI window borders."), _("\
501 Show the attribute mode to use for the TUI window borders."), _("\
502 This variable controls the attributes to use for the window borders:\n\
503 normal normal display\n\
504 standout use highlight mode of terminal\n\
505 reverse use reverse video mode\n\
506 half use half bright\n\
507 half-standout use half bright and standout mode\n\
508 bold use extra bright or bold\n\
509 bold-standout use extra bright or bold with standout mode"),
512  &tui_setlist, &tui_showlist);
513 
514  add_setshow_enum_cmd ("active-border-mode", no_class, tui_border_mode_enums,
515  &tui_active_border_mode, _("\
516 Set the attribute mode to use for the active TUI window border."), _("\
517 Show the attribute mode to use for the active TUI window border."), _("\
518 This variable controls the attributes to use for the active window border:\n\
519 normal normal display\n\
520 standout use highlight mode of terminal\n\
521 reverse use reverse video mode\n\
522 half use half bright\n\
523 half-standout use half bright and standout mode\n\
524 bold use extra bright or bold\n\
525 bold-standout use extra bright or bold with standout mode"),
528  &tui_setlist, &tui_showlist);
529 }
530 
531 /* Update gdb's knowledge of the terminal size. */
532 void
534 {
535  int width, height;
536 
537  if (tui_active)
538  {
539  width = TUI_CMD_WIN->generic.width;
540  height = TUI_CMD_WIN->generic.height;
541  }
542  else
543  {
544  width = tui_term_width ();
545  height = tui_term_height ();
546  }
547 
548  set_screen_width_and_height (width, height);
549 }
550 
551 
552 /* Set the logical focus to win_info. */
553 void
555 {
556  if (win_info != NULL)
557  {
559 
560  if (win_with_focus != NULL
561  && win_with_focus->generic.type != CMD_WIN)
562  tui_unhighlight_win (win_with_focus);
563  tui_set_win_with_focus (win_info);
564  if (win_info->generic.type != CMD_WIN)
565  tui_highlight_win (win_info);
566  }
567 }
568 
569 
570 void
571 tui_scroll_forward (struct tui_win_info *win_to_scroll,
572  int num_to_scroll)
573 {
574  if (win_to_scroll != TUI_CMD_WIN)
575  {
576  int _num_to_scroll = num_to_scroll;
577 
578  if (num_to_scroll == 0)
579  _num_to_scroll = win_to_scroll->generic.height - 3;
580 
581  /* If we are scrolling the source or disassembly window, do a
582  "psuedo" scroll since not all of the source is in memory,
583  only what is in the viewport. If win_to_scroll is the
584  command window do nothing since the term should handle
585  it. */
586  if (win_to_scroll == TUI_SRC_WIN)
587  tui_vertical_source_scroll (FORWARD_SCROLL, _num_to_scroll);
588  else if (win_to_scroll == TUI_DISASM_WIN)
590  else if (win_to_scroll == TUI_DATA_WIN)
591  tui_vertical_data_scroll (FORWARD_SCROLL, _num_to_scroll);
592  }
593 }
594 
595 void
596 tui_scroll_backward (struct tui_win_info *win_to_scroll,
597  int num_to_scroll)
598 {
599  if (win_to_scroll != TUI_CMD_WIN)
600  {
601  int _num_to_scroll = num_to_scroll;
602 
603  if (num_to_scroll == 0)
604  _num_to_scroll = win_to_scroll->generic.height - 3;
605 
606  /* If we are scrolling the source or disassembly window, do a
607  "psuedo" scroll since not all of the source is in memory,
608  only what is in the viewport. If win_to_scroll is the
609  command window do nothing since the term should handle
610  it. */
611  if (win_to_scroll == TUI_SRC_WIN)
613  else if (win_to_scroll == TUI_DISASM_WIN)
615  else if (win_to_scroll == TUI_DATA_WIN)
616  tui_vertical_data_scroll (BACKWARD_SCROLL, _num_to_scroll);
617  }
618 }
619 
620 
621 void
622 tui_scroll_left (struct tui_win_info *win_to_scroll,
623  int num_to_scroll)
624 {
625  if (win_to_scroll != TUI_CMD_WIN)
626  {
627  int _num_to_scroll = num_to_scroll;
628 
629  if (_num_to_scroll == 0)
630  _num_to_scroll = 1;
631 
632  /* If we are scrolling the source or disassembly window, do a
633  "psuedo" scroll since not all of the source is in memory,
634  only what is in the viewport. If win_to_scroll is the command
635  window do nothing since the term should handle it. */
636  if (win_to_scroll == TUI_SRC_WIN
637  || win_to_scroll == TUI_DISASM_WIN)
639  _num_to_scroll);
640  }
641 }
642 
643 
644 void
645 tui_scroll_right (struct tui_win_info *win_to_scroll,
646  int num_to_scroll)
647 {
648  if (win_to_scroll != TUI_CMD_WIN)
649  {
650  int _num_to_scroll = num_to_scroll;
651 
652  if (_num_to_scroll == 0)
653  _num_to_scroll = 1;
654 
655  /* If we are scrolling the source or disassembly window, do a
656  "psuedo" scroll since not all of the source is in memory,
657  only what is in the viewport. If win_to_scroll is the command
658  window do nothing since the term should handle it. */
659  if (win_to_scroll == TUI_SRC_WIN
660  || win_to_scroll == TUI_DISASM_WIN)
662  _num_to_scroll);
663  }
664 }
665 
666 
667 /* Scroll a window. Arguments are passed through a va_list. */
668 void
670  struct tui_win_info *win_to_scroll,
671  int num_to_scroll)
672 {
673  switch (direction)
674  {
675  case FORWARD_SCROLL:
676  tui_scroll_forward (win_to_scroll, num_to_scroll);
677  break;
678  case BACKWARD_SCROLL:
679  tui_scroll_backward (win_to_scroll, num_to_scroll);
680  break;
681  case LEFT_SCROLL:
682  tui_scroll_left (win_to_scroll, num_to_scroll);
683  break;
684  case RIGHT_SCROLL:
685  tui_scroll_right (win_to_scroll, num_to_scroll);
686  break;
687  default:
688  break;
689  }
690 }
691 
692 
693 void
695 {
696  int type;
697 
698  clearok (curscr, TRUE);
700  for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
701  {
702  if (tui_win_list[type]
703  && tui_win_list[type]->generic.is_visible)
704  {
705  switch (type)
706  {
707  case SRC_WIN:
708  case DISASSEM_WIN:
713  break;
714  case DATA_WIN:
716  break;
717  default:
718  break;
719  }
720  }
721  }
723 }
724 
725 void
727 {
728  int type;
729 
730  for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
732 }
733 
734 /* Resize all the windows based on the terminal size. This function
735  gets called from within the readline sinwinch handler. */
736 void
738 {
739  int height_diff, width_diff;
740  int screenheight, screenwidth;
741 
742  rl_get_screen_size (&screenheight, &screenwidth);
743  width_diff = screenwidth - tui_term_width ();
744  height_diff = screenheight - tui_term_height ();
745  if (height_diff || width_diff)
746  {
747  enum tui_layout_type cur_layout = tui_current_layout ();
749  struct tui_win_info *first_win;
750  struct tui_win_info *second_win;
751  struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
752  int win_type;
753  int new_height, split_diff, cmd_split_diff, num_wins_displayed = 2;
754 
755 #ifdef HAVE_RESIZE_TERM
756  resize_term (screenheight, screenwidth);
757 #endif
758  /* Turn keypad off while we resize. */
759  if (win_with_focus != TUI_CMD_WIN)
760  keypad (TUI_CMD_WIN->generic.handle, FALSE);
762  tui_set_term_height_to (screenheight);
763  tui_set_term_width_to (screenwidth);
764  if (cur_layout == SRC_DISASSEM_COMMAND
765  || cur_layout == SRC_DATA_COMMAND
766  || cur_layout == DISASSEM_DATA_COMMAND)
767  num_wins_displayed++;
768  split_diff = height_diff / num_wins_displayed;
769  cmd_split_diff = split_diff;
770  if (height_diff % num_wins_displayed)
771  {
772  if (height_diff < 0)
773  cmd_split_diff--;
774  else
775  cmd_split_diff++;
776  }
777  /* Now adjust each window. */
778  /* erase + clearok are used instead of a straightforward clear as
779  AIX 5.3 does not define clear. */
780  erase ();
781  clearok (curscr, TRUE);
782  refresh ();
783  switch (cur_layout)
784  {
785  case SRC_COMMAND:
786  case DISASSEM_COMMAND:
787  first_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
788  first_win->generic.width += width_diff;
789  locator->width += width_diff;
790  /* Check for invalid heights. */
791  if (height_diff == 0)
792  new_height = first_win->generic.height;
793  else if ((first_win->generic.height + split_diff) >=
794  (screenheight - MIN_CMD_WIN_HEIGHT - 1))
795  new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
796  else if ((first_win->generic.height + split_diff) <= 0)
797  new_height = MIN_WIN_HEIGHT;
798  else
799  new_height = first_win->generic.height + split_diff;
800 
801  locator->origin.y = new_height + 1;
802  make_invisible_and_set_new_height (first_win, new_height);
803  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
804  TUI_CMD_WIN->generic.width += width_diff;
805  new_height = screenheight - TUI_CMD_WIN->generic.origin.y;
807  make_visible_with_new_height (first_win);
809  if (first_win->generic.content_size <= 0)
811  break;
812  default:
813  if (cur_layout == SRC_DISASSEM_COMMAND)
814  {
815  first_win = TUI_SRC_WIN;
816  first_win->generic.width += width_diff;
817  second_win = TUI_DISASM_WIN;
818  second_win->generic.width += width_diff;
819  }
820  else
821  {
822  first_win = TUI_DATA_WIN;
823  first_win->generic.width += width_diff;
824  second_win = (struct tui_win_info *)
825  (tui_source_windows ())->list[0];
826  second_win->generic.width += width_diff;
827  }
828  /* Change the first window's height/width. */
829  /* Check for invalid heights. */
830  if (height_diff == 0)
831  new_height = first_win->generic.height;
832  else if ((first_win->generic.height +
833  second_win->generic.height + (split_diff * 2)) >=
834  (screenheight - MIN_CMD_WIN_HEIGHT - 1))
835  new_height = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
836  else if ((first_win->generic.height + split_diff) <= 0)
837  new_height = MIN_WIN_HEIGHT;
838  else
839  new_height = first_win->generic.height + split_diff;
840  make_invisible_and_set_new_height (first_win, new_height);
841 
842  locator->width += width_diff;
843 
844  /* Change the second window's height/width. */
845  /* Check for invalid heights. */
846  if (height_diff == 0)
847  new_height = second_win->generic.height;
848  else if ((first_win->generic.height +
849  second_win->generic.height + (split_diff * 2)) >=
850  (screenheight - MIN_CMD_WIN_HEIGHT - 1))
851  {
852  new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
853  if (new_height % 2)
854  new_height = (new_height / 2) + 1;
855  else
856  new_height /= 2;
857  }
858  else if ((second_win->generic.height + split_diff) <= 0)
859  new_height = MIN_WIN_HEIGHT;
860  else
861  new_height = second_win->generic.height + split_diff;
862  second_win->generic.origin.y = first_win->generic.height - 1;
863  make_invisible_and_set_new_height (second_win, new_height);
864 
865  /* Change the command window's height/width. */
866  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
868  TUI_CMD_WIN->generic.height
869  + cmd_split_diff);
870  make_visible_with_new_height (first_win);
871  make_visible_with_new_height (second_win);
873  if (first_win->generic.content_size <= 0)
875  if (second_win->generic.content_size <= 0)
877  break;
878  }
879  /* Now remove all invisible windows, and their content so that
880  they get created again when called for with the new size. */
881  for (win_type = SRC_WIN; (win_type < MAX_MAJOR_WINDOWS); win_type++)
882  {
883  if (win_type != CMD_WIN
884  && (tui_win_list[win_type] != NULL)
885  && !tui_win_list[win_type]->generic.is_visible)
886  {
887  tui_free_window (tui_win_list[win_type]);
888  tui_win_list[win_type] = (struct tui_win_info *) NULL;
889  }
890  }
891  /* Turn keypad back on, unless focus is in the command
892  window. */
893  if (win_with_focus != TUI_CMD_WIN)
894  keypad (TUI_CMD_WIN->generic.handle, TRUE);
895  }
896 }
897 
898 #ifdef SIGWINCH
899 /* Token for use by TUI's asynchronous SIGWINCH handler. */
900 static struct async_signal_handler *tui_sigwinch_token;
901 
902 /* TUI's SIGWINCH signal handler. */
903 static void
904 tui_sigwinch_handler (int signal)
905 {
906  mark_async_signal_handler (tui_sigwinch_token);
907  tui_set_win_resized_to (TRUE);
908 }
909 
910 /* Callback for asynchronously resizing TUI following a SIGWINCH signal. */
911 static void
912 tui_async_resize_screen (gdb_client_data arg)
913 {
914  rl_resize_terminal ();
915 
916  if (!tui_active)
917  {
918  int screen_height, screen_width;
919 
920  rl_get_screen_size (&screen_height, &screen_width);
921  set_screen_width_and_height (screen_width, screen_height);
922 
923  /* win_resized is left set so that the next call to tui_enable()
924  resizes the TUI windows. */
925  }
926  else
927  {
928  tui_set_win_resized_to (FALSE);
929  tui_resize_all ();
933  }
934 }
935 #endif
936 
937 /* Initialize TUI's SIGWINCH signal handler. Note that the handler is not
938  uninstalled when we exit TUI, so the handler should not assume that TUI is
939  always active. */
940 void
942 {
943 #ifdef SIGWINCH
944  tui_sigwinch_token
945  = create_async_signal_handler (tui_async_resize_screen, NULL);
946 
947  {
948 #ifdef HAVE_SIGACTION
949  struct sigaction old_winch;
950 
951  memset (&old_winch, 0, sizeof (old_winch));
952  old_winch.sa_handler = &tui_sigwinch_handler;
953 #ifdef SA_RESTART
954  old_winch.sa_flags = SA_RESTART;
955 #endif
956  sigaction (SIGWINCH, &old_winch, NULL);
957 #else
958  signal (SIGWINCH, &tui_sigwinch_handler);
959 #endif
960  }
961 #endif
962 }
963 
964 
965 /*************************
966 ** STATIC LOCAL FUNCTIONS
967 **************************/
968 
969 
970 static void
971 tui_scroll_forward_command (char *arg, int from_tty)
972 {
973  int num_to_scroll = 1;
974  struct tui_win_info *win_to_scroll;
975 
976  /* Make sure the curses mode is enabled. */
977  tui_enable ();
978  if (arg == (char *) NULL)
979  parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
980  else
981  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
982  tui_scroll (FORWARD_SCROLL, win_to_scroll, num_to_scroll);
983 }
984 
985 
986 static void
987 tui_scroll_backward_command (char *arg, int from_tty)
988 {
989  int num_to_scroll = 1;
990  struct tui_win_info *win_to_scroll;
991 
992  /* Make sure the curses mode is enabled. */
993  tui_enable ();
994  if (arg == (char *) NULL)
995  parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
996  else
997  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
998  tui_scroll (BACKWARD_SCROLL, win_to_scroll, num_to_scroll);
999 }
1000 
1001 
1002 static void
1003 tui_scroll_left_command (char *arg, int from_tty)
1004 {
1005  int num_to_scroll;
1006  struct tui_win_info *win_to_scroll;
1007 
1008  /* Make sure the curses mode is enabled. */
1009  tui_enable ();
1010  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
1011  tui_scroll (LEFT_SCROLL, win_to_scroll, num_to_scroll);
1012 }
1013 
1014 
1015 static void
1016 tui_scroll_right_command (char *arg, int from_tty)
1017 {
1018  int num_to_scroll;
1019  struct tui_win_info *win_to_scroll;
1020 
1021  /* Make sure the curses mode is enabled. */
1022  tui_enable ();
1023  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
1024  tui_scroll (RIGHT_SCROLL, win_to_scroll, num_to_scroll);
1025 }
1026 
1027 
1028 /* Set focus to the window named by 'arg'. */
1029 static void
1030 tui_set_focus (char *arg, int from_tty)
1031 {
1032  if (arg != (char *) NULL)
1033  {
1034  char *buf_ptr = (char *) xstrdup (arg);
1035  int i;
1036  struct tui_win_info *win_info = (struct tui_win_info *) NULL;
1037 
1038  for (i = 0; (i < strlen (buf_ptr)); i++)
1039  buf_ptr[i] = toupper (arg[i]);
1040 
1041  if (subset_compare (buf_ptr, "NEXT"))
1042  win_info = tui_next_win (tui_win_with_focus ());
1043  else if (subset_compare (buf_ptr, "PREV"))
1044  win_info = tui_prev_win (tui_win_with_focus ());
1045  else
1046  win_info = tui_partial_win_by_name (buf_ptr);
1047 
1048  if (win_info == (struct tui_win_info *) NULL
1049  || !win_info->generic.is_visible)
1050  warning (_("Invalid window specified. \n\
1051 The window name specified must be valid and visible.\n"));
1052  else
1053  {
1054  tui_set_win_focus_to (win_info);
1055  keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
1056  }
1057 
1058  if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
1060  xfree (buf_ptr);
1061  printf_filtered (_("Focus set to %s window.\n"),
1062  tui_win_name (&tui_win_with_focus ()->generic));
1063  }
1064  else
1065  warning (_("Incorrect Number of Arguments.\n%s"), FOCUS_USAGE);
1066 }
1067 
1068 static void
1069 tui_set_focus_command (char *arg, int from_tty)
1070 {
1071  /* Make sure the curses mode is enabled. */
1072  tui_enable ();
1073  tui_set_focus (arg, from_tty);
1074 }
1075 
1076 
1077 static void
1078 tui_all_windows_info (char *arg, int from_tty)
1079 {
1080  int type;
1082 
1083  for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
1084  if (tui_win_list[type]
1085  && tui_win_list[type]->generic.is_visible)
1086  {
1087  if (win_with_focus == tui_win_list[type])
1088  printf_filtered (" %s\t(%d lines) <has focus>\n",
1089  tui_win_name (&tui_win_list[type]->generic),
1090  tui_win_list[type]->generic.height);
1091  else
1092  printf_filtered (" %s\t(%d lines)\n",
1093  tui_win_name (&tui_win_list[type]->generic),
1094  tui_win_list[type]->generic.height);
1095  }
1096 }
1097 
1098 
1099 static void
1100 tui_refresh_all_command (char *arg, int from_tty)
1101 {
1102  /* Make sure the curses mode is enabled. */
1103  tui_enable ();
1104 
1106 }
1107 
1108 
1109 /* Set the tab width of the specified window. */
1110 static void
1111 tui_set_tab_width_command (char *arg, int from_tty)
1112 {
1113  /* Make sure the curses mode is enabled. */
1114  tui_enable ();
1115  if (arg != (char *) NULL)
1116  {
1117  int ts;
1118 
1119  ts = atoi (arg);
1120  if (ts > 0)
1121  {
1123  /* We don't really change the height of any windows, but
1124  calling these 2 functions causes a complete regeneration
1125  and redisplay of the window's contents, which will take
1126  the new tab width into account. */
1127  if (tui_win_list[SRC_WIN]
1128  && tui_win_list[SRC_WIN]->generic.is_visible)
1129  {
1131  TUI_SRC_WIN->generic.height);
1133  }
1135  && tui_win_list[DISASSEM_WIN]->generic.is_visible)
1136  {
1138  TUI_DISASM_WIN->generic.height);
1140  }
1141  }
1142  else
1143  warning (_("Tab widths greater than 0 must be specified."));
1144  }
1145 }
1146 
1147 
1148 /* Set the height of the specified window. */
1149 static void
1150 tui_set_win_height (char *arg, int from_tty)
1151 {
1152  /* Make sure the curses mode is enabled. */
1153  tui_enable ();
1154  if (arg != (char *) NULL)
1155  {
1156  char *buf = xstrdup (arg);
1157  char *buf_ptr = buf;
1158  char *wname = (char *) NULL;
1159  int new_height, i;
1160  struct tui_win_info *win_info;
1161 
1162  wname = buf_ptr;
1163  buf_ptr = strchr (buf_ptr, ' ');
1164  if (buf_ptr != (char *) NULL)
1165  {
1166  *buf_ptr = (char) 0;
1167 
1168  /* Validate the window name. */
1169  for (i = 0; i < strlen (wname); i++)
1170  wname[i] = toupper (wname[i]);
1171  win_info = tui_partial_win_by_name (wname);
1172 
1173  if (win_info == (struct tui_win_info *) NULL
1174  || !win_info->generic.is_visible)
1175  warning (_("Invalid window specified. \n\
1176 The window name specified must be valid and visible.\n"));
1177  else
1178  {
1179  /* Process the size. */
1180  while (*(++buf_ptr) == ' ')
1181  ;
1182 
1183  if (*buf_ptr != (char) 0)
1184  {
1185  int negate = FALSE;
1186  int fixed_size = TRUE;
1187  int input_no;;
1188 
1189  if (*buf_ptr == '+' || *buf_ptr == '-')
1190  {
1191  if (*buf_ptr == '-')
1192  negate = TRUE;
1193  fixed_size = FALSE;
1194  buf_ptr++;
1195  }
1196  input_no = atoi (buf_ptr);
1197  if (input_no > 0)
1198  {
1199  if (negate)
1200  input_no *= (-1);
1201  if (fixed_size)
1202  new_height = input_no;
1203  else
1204  new_height = win_info->generic.height + input_no;
1205 
1206  /* Now change the window's height, and adjust
1207  all other windows around it. */
1208  if (tui_adjust_win_heights (win_info,
1209  new_height) == TUI_FAILURE)
1210  warning (_("Invalid window height specified.\n%s"),
1212  else
1214  }
1215  else
1216  warning (_("Invalid window height specified.\n%s"),
1218  }
1219  }
1220  }
1221  else
1223 
1224  if (buf != (char *) NULL)
1225  xfree (buf);
1226  }
1227  else
1229 }
1230 
1231 /* Set the height of the specified window, with va_list. */
1232 static void
1233 tui_set_win_height_command (char *arg, int from_tty)
1234 {
1235  /* Make sure the curses mode is enabled. */
1236  tui_enable ();
1237  tui_set_win_height (arg, from_tty);
1238 }
1239 
1240 /* Function to adjust all window heights around the primary. */
1241 static enum tui_status
1242 tui_adjust_win_heights (struct tui_win_info *primary_win_info,
1243  int new_height)
1244 {
1245  enum tui_status status = TUI_FAILURE;
1246 
1247  if (new_height_ok (primary_win_info, new_height))
1248  {
1249  status = TUI_SUCCESS;
1250  if (new_height != primary_win_info->generic.height)
1251  {
1252  int diff;
1253  struct tui_win_info *win_info;
1254  struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
1255  enum tui_layout_type cur_layout = tui_current_layout ();
1256 
1257  diff = (new_height - primary_win_info->generic.height) * (-1);
1258  if (cur_layout == SRC_COMMAND
1259  || cur_layout == DISASSEM_COMMAND)
1260  {
1261  struct tui_win_info *src_win_info;
1262 
1263  make_invisible_and_set_new_height (primary_win_info, new_height);
1264  if (primary_win_info->generic.type == CMD_WIN)
1265  {
1266  win_info = (tui_source_windows ())->list[0];
1267  src_win_info = win_info;
1268  }
1269  else
1270  {
1271  win_info = tui_win_list[CMD_WIN];
1272  src_win_info = primary_win_info;
1273  }
1275  win_info->generic.height + diff);
1276  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
1277  make_visible_with_new_height (win_info);
1278  make_visible_with_new_height (primary_win_info);
1279  if (src_win_info->generic.content_size <= 0)
1281  }
1282  else
1283  {
1284  struct tui_win_info *first_win;
1285  struct tui_win_info *second_win;
1286 
1287  if (cur_layout == SRC_DISASSEM_COMMAND)
1288  {
1289  first_win = TUI_SRC_WIN;
1290  second_win = TUI_DISASM_WIN;
1291  }
1292  else
1293  {
1294  first_win = TUI_DATA_WIN;
1295  second_win = (tui_source_windows ())->list[0];
1296  }
1297  if (primary_win_info == TUI_CMD_WIN)
1298  { /* Split the change in height accross the 1st & 2nd
1299  windows, adjusting them as well. */
1300  /* Subtract the locator. */
1301  int first_split_diff = diff / 2;
1302  int second_split_diff = first_split_diff;
1303 
1304  if (diff % 2)
1305  {
1306  if (first_win->generic.height >
1307  second_win->generic.height)
1308  if (diff < 0)
1309  first_split_diff--;
1310  else
1311  first_split_diff++;
1312  else
1313  {
1314  if (diff < 0)
1315  second_split_diff--;
1316  else
1317  second_split_diff++;
1318  }
1319  }
1320  /* Make sure that the minimum hieghts are
1321  honored. */
1322  while ((first_win->generic.height + first_split_diff) < 3)
1323  {
1324  first_split_diff++;
1325  second_split_diff--;
1326  }
1327  while ((second_win->generic.height + second_split_diff) < 3)
1328  {
1329  second_split_diff++;
1330  first_split_diff--;
1331  }
1333  first_win,
1334  first_win->generic.height + first_split_diff);
1335  second_win->generic.origin.y = first_win->generic.height - 1;
1337  second_win->generic.height
1338  + second_split_diff);
1339  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
1341  }
1342  else
1343  {
1344  if ((TUI_CMD_WIN->generic.height + diff) < 1)
1345  { /* If there is no way to increase the command
1346  window take real estate from the 1st or 2nd
1347  window. */
1348  if ((TUI_CMD_WIN->generic.height + diff) < 1)
1349  {
1350  int i;
1351 
1352  for (i = TUI_CMD_WIN->generic.height + diff;
1353  (i < 1); i++)
1354  if (primary_win_info == first_win)
1355  second_win->generic.height--;
1356  else
1357  first_win->generic.height--;
1358  }
1359  }
1360  if (primary_win_info == first_win)
1361  make_invisible_and_set_new_height (first_win, new_height);
1362  else
1364  first_win,
1365  first_win->generic.height);
1366  second_win->generic.origin.y = first_win->generic.height - 1;
1367  if (primary_win_info == second_win)
1368  make_invisible_and_set_new_height (second_win, new_height);
1369  else
1371  second_win, second_win->generic.height);
1372  TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
1373  if ((TUI_CMD_WIN->generic.height + diff) < 1)
1375  else
1377  TUI_CMD_WIN->generic.height + diff);
1378  }
1380  make_visible_with_new_height (second_win);
1381  make_visible_with_new_height (first_win);
1382  if (first_win->generic.content_size <= 0)
1384  if (second_win->generic.content_size <= 0)
1386  }
1387  }
1388  }
1389 
1390  return status;
1391 }
1392 
1393 
1394 /* Function make the target window (and auxillary windows associated
1395  with the targer) invisible, and set the new height and
1396  location. */
1397 static void
1399  int height)
1400 {
1401  int i;
1402  struct tui_gen_win_info *gen_win_info;
1403 
1404  tui_make_invisible (&win_info->generic);
1405  win_info->generic.height = height;
1406  if (height > 1)
1407  win_info->generic.viewport_height = height - 1;
1408  else
1409  win_info->generic.viewport_height = height;
1410  if (win_info != TUI_CMD_WIN)
1411  win_info->generic.viewport_height--;
1412 
1413  /* Now deal with the auxillary windows associated with win_info. */
1414  switch (win_info->generic.type)
1415  {
1416  case SRC_WIN:
1417  case DISASSEM_WIN:
1418  gen_win_info = win_info->detail.source_info.execution_info;
1419  tui_make_invisible (gen_win_info);
1420  gen_win_info->height = height;
1421  gen_win_info->origin.y = win_info->generic.origin.y;
1422  if (height > 1)
1423  gen_win_info->viewport_height = height - 1;
1424  else
1425  gen_win_info->viewport_height = height;
1426  if (win_info != TUI_CMD_WIN)
1427  gen_win_info->viewport_height--;
1428 
1429  if (tui_win_has_locator (win_info))
1430  {
1431  gen_win_info = tui_locator_win_info_ptr ();
1432  tui_make_invisible (gen_win_info);
1433  gen_win_info->origin.y = win_info->generic.origin.y + height;
1434  }
1435  break;
1436  case DATA_WIN:
1437  /* Delete all data item windows. */
1438  for (i = 0; i < win_info->generic.content_size; i++)
1439  {
1440  gen_win_info = (struct tui_gen_win_info *)
1441  &((struct tui_win_element *)
1442  win_info->generic.content[i])->which_element.data_window;
1443  tui_delete_win (gen_win_info->handle);
1444  gen_win_info->handle = (WINDOW *) NULL;
1445  }
1446  break;
1447  default:
1448  break;
1449  }
1450 }
1451 
1452 
1453 /* Function to make the windows with new heights visible. This means
1454  re-creating the windows' content since the window had to be
1455  destroyed to be made invisible. */
1456 static void
1458 {
1459  struct symtab *s;
1460 
1461  tui_make_visible (&win_info->generic);
1463  switch (win_info->generic.type)
1464  {
1465  case SRC_WIN:
1466  case DISASSEM_WIN:
1469  if (win_info->generic.content != NULL)
1470  {
1471  struct gdbarch *gdbarch = win_info->detail.source_info.gdbarch;
1472  struct tui_line_or_address line_or_addr;
1473  struct symtab_and_line cursal
1475 
1476  line_or_addr = win_info->detail.source_info.start_line_or_addr;
1477  tui_free_win_content (&win_info->generic);
1478  tui_update_source_window (win_info, gdbarch,
1479  cursal.symtab, line_or_addr, TRUE);
1480  }
1481  else if (deprecated_safe_get_selected_frame () != NULL)
1482  {
1483  struct tui_line_or_address line;
1484  struct symtab_and_line cursal
1487  struct gdbarch *gdbarch = get_frame_arch (frame);
1488 
1489  s = find_pc_line_symtab (get_frame_pc (frame));
1490  if (win_info->generic.type == SRC_WIN)
1491  {
1492  line.loa = LOA_LINE;
1493  line.u.line_no = cursal.line;
1494  }
1495  else
1496  {
1497  line.loa = LOA_ADDRESS;
1498  find_line_pc (s, cursal.line, &line.u.addr);
1499  }
1500  tui_update_source_window (win_info, gdbarch, s, line, TRUE);
1501  }
1502  if (tui_win_has_locator (win_info))
1503  {
1506  }
1507  break;
1508  case DATA_WIN:
1510  break;
1511  case CMD_WIN:
1512  win_info->detail.command_info.cur_line = 0;
1513  win_info->detail.command_info.curch = 0;
1514 #ifdef HAVE_WRESIZE
1515  wresize (TUI_CMD_WIN->generic.handle,
1516  TUI_CMD_WIN->generic.height,
1517  TUI_CMD_WIN->generic.width);
1518 #endif
1519  mvwin (TUI_CMD_WIN->generic.handle,
1520  TUI_CMD_WIN->generic.origin.y,
1521  TUI_CMD_WIN->generic.origin.x);
1522  wmove (win_info->generic.handle,
1523  win_info->detail.command_info.cur_line,
1524  win_info->detail.command_info.curch);
1525  break;
1526  default:
1527  break;
1528  }
1529 }
1530 
1531 
1532 static int
1533 new_height_ok (struct tui_win_info *primary_win_info,
1534  int new_height)
1535 {
1536  int ok = (new_height < tui_term_height ());
1537 
1538  if (ok)
1539  {
1540  int diff;
1541  enum tui_layout_type cur_layout = tui_current_layout ();
1542 
1543  diff = (new_height - primary_win_info->generic.height) * (-1);
1544  if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
1545  {
1546  ok = ((primary_win_info->generic.type == CMD_WIN
1547  && new_height <= (tui_term_height () - 4)
1548  && new_height >= MIN_CMD_WIN_HEIGHT)
1549  || (primary_win_info->generic.type != CMD_WIN
1550  && new_height <= (tui_term_height () - 2)
1551  && new_height >= MIN_WIN_HEIGHT));
1552  if (ok)
1553  { /* Check the total height. */
1554  struct tui_win_info *win_info;
1555 
1556  if (primary_win_info == TUI_CMD_WIN)
1557  win_info = (tui_source_windows ())->list[0];
1558  else
1559  win_info = TUI_CMD_WIN;
1560  ok = ((new_height +
1561  (win_info->generic.height + diff)) <= tui_term_height ());
1562  }
1563  }
1564  else
1565  {
1566  int cur_total_height, total_height, min_height = 0;
1567  struct tui_win_info *first_win;
1568  struct tui_win_info *second_win;
1569 
1570  if (cur_layout == SRC_DISASSEM_COMMAND)
1571  {
1572  first_win = TUI_SRC_WIN;
1573  second_win = TUI_DISASM_WIN;
1574  }
1575  else
1576  {
1577  first_win = TUI_DATA_WIN;
1578  second_win = (tui_source_windows ())->list[0];
1579  }
1580  /* We could simply add all the heights to obtain the same
1581  result but below is more explicit since we subtract 1 for
1582  the line that the first and second windows share, and add
1583  one for the locator. */
1584  total_height = cur_total_height =
1585  (first_win->generic.height + second_win->generic.height - 1)
1586  + TUI_CMD_WIN->generic.height + 1; /* Locator. */
1587  if (primary_win_info == TUI_CMD_WIN)
1588  {
1589  /* Locator included since first & second win share a line. */
1590  ok = ((first_win->generic.height +
1591  second_win->generic.height + diff) >=
1592  (MIN_WIN_HEIGHT * 2)
1593  && new_height >= MIN_CMD_WIN_HEIGHT);
1594  if (ok)
1595  {
1596  total_height = new_height +
1597  (first_win->generic.height +
1598  second_win->generic.height + diff);
1599  min_height = MIN_CMD_WIN_HEIGHT;
1600  }
1601  }
1602  else
1603  {
1604  min_height = MIN_WIN_HEIGHT;
1605 
1606  /* First see if we can increase/decrease the command
1607  window. And make sure that the command window is at
1608  least 1 line. */
1609  ok = ((TUI_CMD_WIN->generic.height + diff) > 0);
1610  if (!ok)
1611  { /* Looks like we have to increase/decrease one of
1612  the other windows. */
1613  if (primary_win_info == first_win)
1614  ok = (second_win->generic.height + diff) >= min_height;
1615  else
1616  ok = (first_win->generic.height + diff) >= min_height;
1617  }
1618  if (ok)
1619  {
1620  if (primary_win_info == first_win)
1621  total_height = new_height +
1622  second_win->generic.height +
1623  TUI_CMD_WIN->generic.height + diff;
1624  else
1625  total_height = new_height +
1626  first_win->generic.height +
1627  TUI_CMD_WIN->generic.height + diff;
1628  }
1629  }
1630  /* Now make sure that the proposed total height doesn't
1631  exceed the old total height. */
1632  if (ok)
1633  ok = (new_height >= min_height
1634  && total_height <= cur_total_height);
1635  }
1636  }
1637 
1638  return ok;
1639 }
1640 
1641 
1642 static void
1644  struct tui_win_info **win_to_scroll,
1645  int *num_to_scroll)
1646 {
1647  if (num_to_scroll)
1648  *num_to_scroll = 0;
1649  *win_to_scroll = tui_win_with_focus ();
1650 
1651  /* First set up the default window to scroll, in case there is no
1652  window name arg. */
1653  if (arg != (char *) NULL)
1654  {
1655  char *buf, *buf_ptr;
1656 
1657  /* Process the number of lines to scroll. */
1658  buf = buf_ptr = xstrdup (arg);
1659  if (isdigit (*buf_ptr))
1660  {
1661  char *num_str;
1662 
1663  num_str = buf_ptr;
1664  buf_ptr = strchr (buf_ptr, ' ');
1665  if (buf_ptr != (char *) NULL)
1666  {
1667  *buf_ptr = (char) 0;
1668  if (num_to_scroll)
1669  *num_to_scroll = atoi (num_str);
1670  buf_ptr++;
1671  }
1672  else if (num_to_scroll)
1673  *num_to_scroll = atoi (num_str);
1674  }
1675 
1676  /* Process the window name if one is specified. */
1677  if (buf_ptr != (char *) NULL)
1678  {
1679  char *wname;
1680  int i;
1681 
1682  if (*buf_ptr == ' ')
1683  while (*(++buf_ptr) == ' ')
1684  ;
1685 
1686  if (*buf_ptr != (char) 0)
1687  {
1688  wname = buf_ptr;
1689 
1690  /* Validate the window name. */
1691  for (i = 0; i < strlen (wname); i++)
1692  wname[i] = toupper (wname[i]);
1693  }
1694  else
1695  wname = "?";
1696 
1697  *win_to_scroll = tui_partial_win_by_name (wname);
1698 
1699  if (*win_to_scroll == (struct tui_win_info *) NULL
1700  || !(*win_to_scroll)->generic.is_visible)
1701  error (_("Invalid window specified. \n\
1702 The window name specified must be valid and visible.\n"));
1703  else if (*win_to_scroll == TUI_CMD_WIN)
1704  *win_to_scroll = (tui_source_windows ())->list[0];
1705  }
1706  xfree (buf);
1707  }
1708 }
static const char *const tui_border_kind_enums[]
Definition: tui-win.c:109
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
void tui_update_gdb_sizes(void)
Definition: tui-win.c:533
void tui_set_term_height_to(int h)
Definition: tui-data.c:270
void tui_vertical_data_scroll(enum tui_scroll_direction scroll_direction, int num_to_scroll)
Definition: tui-windata.c:266
tui_win_content content
Definition: tui-data.h:47
chtype tui_border_vline
Definition: tui-win.c:242
struct tui_command_info command_info
Definition: tui-data.h:282
#define ACS_HLINE
Definition: tui-win.c:102
static void make_visible_with_new_height(struct tui_win_info *)
Definition: tui-win.c:1457
void tui_scroll_backward(struct tui_win_info *win_to_scroll, int num_to_scroll)
Definition: tui-win.c:596
static VEC(char_ptr)
Definition: tui-win.c:360
int tui_win_has_locator(struct tui_win_info *win_info)
Definition: tui-data.c:81
int viewport_height
Definition: tui-data.h:50
enum tui_win_type type
Definition: tui-data.h:43
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
static void tui_refresh_all_command(char *, int)
Definition: tui-win.c:1100
struct tui_win_info * tui_win_list[MAX_MAJOR_WINDOWS]
Definition: tui-data.c:32
static void tui_scroll_forward_command(char *, int)
Definition: tui-win.c:971
const char * tui_win_name(const struct tui_gen_win_info *win_info)
Definition: tui-data.c:404
#define ACS_VLINE
Definition: tui-win.c:105
int tui_term_height(void)
Definition: tui-data.c:262
static void parse_scrolling_args(char *, struct tui_win_info **, int *)
Definition: tui-win.c:1643
void tui_make_invisible(struct tui_gen_win_info *win_info)
const char * tui_border_mode
Definition: tui-win.c:215
void xfree(void *)
Definition: common-utils.c:97
int tui_active
Definition: tui.c:59
void tui_refresh_data_win(void)
Definition: tui-windata.c:214
#define FOCUS_USAGE
Definition: tui-win.c:83
if(!(yy_init))
Definition: ada-lex.c:1072
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:487
void tui_scroll_forward(struct tui_win_info *win_to_scroll, int num_to_scroll)
Definition: tui-win.c:571
void warning(const char *fmt,...)
Definition: errors.c:26
tui_layout_type
Definition: tui-data.h:114
#define WIN_HEIGHT_USAGE
Definition: tui-win.c:81
static void tui_set_focus_command(char *, int)
Definition: tui-win.c:1069
void mark_async_signal_handler(async_signal_handler *async_handler_ptr)
Definition: event-loop.c:906
static void tui_set_win_height(char *arg, int from_tty)
Definition: tui-win.c:1150
int tui_border_attrs
Definition: tui-win.c:249
const char * tui_border_kind
Definition: tui-win.c:227
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:181
struct ui_file * gdb_stdout
Definition: main.c:71
void tui_horizontal_source_scroll(struct tui_win_info *win_info, enum tui_scroll_direction direction, int num_to_scroll)
struct tui_win_info * tui_prev_win(struct tui_win_info *cur_win)
Definition: tui-data.c:346
struct tui_list * tui_source_windows(void)
Definition: tui-data.c:159
void tui_update_exec_info(struct tui_win_info *win_info)
void tui_set_win_focus_to(struct tui_win_info *win_info)
Definition: tui-win.c:554
static enum tui_status tui_adjust_win_heights(struct tui_win_info *, int)
Definition: tui-win.c:1242
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
union tui_line_or_address::@171 u
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
void tui_unhighlight_win(struct tui_win_info *win_info)
#define _(String)
Definition: gdb_locale.h:40
#define ACS_ULCORNER
Definition: tui-win.c:96
void tui_redisplay_readline(void)
Definition: tui-io.c:200
char * char_ptr
Definition: gdb_vecs.h:25
WINDOW * handle
Definition: tui-data.h:42
enum tui_line_or_address_kind loa
Definition: tui-data.h:142
void tui_set_var_cmd(char *null_args, int from_tty, struct cmd_list_element *c)
Definition: tui-win.c:351
void tui_delete_win(WINDOW *window)
const char * name
Definition: tui-win.c:130
void printf_filtered(const char *format,...)
Definition: utils.c:2388
struct tui_win_info * tui_next_win(struct tui_win_info *cur_win)
Definition: tui-data.c:316
void tui_update_source_window(struct tui_win_info *win_info, struct gdbarch *gdbarch, struct symtab *s, struct tui_line_or_address line_or_addr, int noerror)
Definition: tui-winsource.c:71
void tui_refresh_all_win(void)
Definition: tui-win.c:694
void tui_set_term_width_to(int w)
Definition: tui-data.c:286
void tui_scroll(enum tui_scroll_direction direction, struct tui_win_info *win_to_scroll, int num_to_scroll)
Definition: tui-win.c:669
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
tui_scroll_direction
Definition: tui-data.h:96
struct gdbarch * gdbarch
Definition: tui-data.h:262
static void set_tui_cmd(char *args, int from_tty)
Definition: tui-win.c:319
void tui_erase_source_content(struct tui_win_info *win_info, int display_prompt)
static void tui_all_windows_info(char *, int)
Definition: tui-win.c:1078
struct tui_gen_win_info generic
Definition: tui-data.h:277
struct tui_source_info source_info
Definition: tui-data.h:280
static void tui_scroll_backward_command(char *, int)
Definition: tui-win.c:987
void initialize_file_ftype(void)
Definition: defs.h:281
void tui_show_source_content(struct tui_win_info *win_info)
void tui_highlight_win(struct tui_win_info *win_info)
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
const char * const_char_ptr
Definition: gdb_vecs.h:26
#define ACS_LLCORNER
Definition: tui-win.c:93
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
Definition: tui.h:39
void tui_vertical_disassem_scroll(enum tui_scroll_direction scroll_direction, int num_to_scroll)
Definition: tui-disasm.c:385
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
struct cmd_list_element * add_com_alias(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag)
Definition: cli-decode.c:882
struct tui_win_info * tui_win_with_focus(void)
Definition: tui-data.c:125
#define VEC_length(T, V)
Definition: vec.h:124
struct frame_info * deprecated_safe_get_selected_frame(void)
Definition: frame.c:1564
struct tui_line_or_address start_line_or_addr
Definition: tui-data.h:256
struct tui_gen_win_info * tui_locator_win_info_ptr(void)
Definition: tui-data.c:254
static struct cmd_list_element * tuilist
Definition: tui-win.c:328
const char * word
Definition: symtab.h:1448
static void tui_set_focus(char *arg, int from_tty)
Definition: tui-win.c:1030
tui_status
Definition: tui.h:30
int tui_active_border_attrs
Definition: tui-win.c:250
void tui_scroll_right(struct tui_win_info *win_to_scroll, int num_to_scroll)
Definition: tui-win.c:645
static void show_tui_border_kind(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: tui-win.c:229
struct cmd_list_element * add_info(const char *name, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:857
void tui_vertical_source_scroll(enum tui_scroll_direction scroll_direction, int num_to_scroll)
Definition: tui-source.c:347
static const char * type
Definition: language.c:103
chtype tui_border_ulcorner
Definition: tui-win.c:244
async_signal_handler * create_async_signal_handler(sig_handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:873
chtype tui_border_urcorner
Definition: tui-win.c:245
static void make_invisible_and_set_new_height(struct tui_win_info *, int)
Definition: tui-win.c:1398
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
Definition: symtab.h:925
#define TUI_DATA_WIN
Definition: tui-data.h:302
chtype tui_border_lrcorner
Definition: tui-win.c:247
struct symtab * symtab
Definition: symtab.h:1369
Definition: tui.h:42
static int new_height_ok(struct tui_win_info *, int)
Definition: tui-win.c:1533
#define MIN_WIN_HEIGHT
Definition: tui-data.h:78
void * gdb_client_data
Definition: event-loop.h:70
#define TUI_CMD_WIN
Definition: tui-data.h:303
void tui_rehighlight_all(void)
Definition: tui-win.c:726
void tui_free_window(struct tui_win_info *win_info)
Definition: tui-data.c:709
void tui_initialize_win(void)
Definition: tui-win.c:941
chtype tui_border_llcorner
Definition: tui-win.c:246
void tui_set_win_resized_to(int resized)
Definition: tui-data.c:109
Definition: value.c:172
struct cmd_list_element ** tui_get_cmd_list(void)
Definition: tui-win.c:339
int find_line_pc(struct symtab *symtab, int line, CORE_ADDR *pc)
Definition: symtab.c:3484
void tui_show_locator_content(void)
Definition: tui-stack.c:245
int y
Definition: tui-data.h:31
static void tui_scroll_left_command(char *, int)
Definition: tui-win.c:1003
void tui_make_visible(struct tui_gen_win_info *win_info)
#define TUI_SRC_WIN
Definition: tui-data.h:300
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
static struct tui_translate * translate(const char *name, struct tui_translate *table)
Definition: tui-win.c:255
int tui_update_variables(void)
Definition: tui-win.c:273
struct tui_gen_win_info * execution_info
Definition: tui-data.h:254
static const char *const tui_border_mode_enums[]
Definition: tui-win.c:117
void tui_resize_all(void)
Definition: tui-win.c:737
#define ACS_LRCORNER
Definition: tui-win.c:90
void tui_set_win_with_focus(struct tui_win_info *win_info)
Definition: tui-data.c:133
static void tui_command(char *args, int from_tty)
Definition: tui-win.c:331
struct tui_point origin
Definition: tui-data.h:46
int tui_term_width(void)
Definition: tui-data.c:278
struct tui_win_info * tui_partial_win_by_name(char *name)
Definition: tui-data.c:375
#define ACS_URCORNER
Definition: tui-win.c:99
#define VEC_free(T, V)
Definition: vec.h:180
static struct tui_win_info * win_with_focus
Definition: tui-data.c:44
#define VEC_address(T, V)
Definition: vec.h:369
static void tui_set_tab_width_command(char *, int)
Definition: tui-win.c:1111
void tui_erase_exec_info_content(struct tui_win_info *win_info)
void tui_scroll_left(struct tui_win_info *win_to_scroll, int num_to_scroll)
Definition: tui-win.c:622
#define TUI_DISASM_WIN
Definition: tui-data.h:301
void tui_refresh_all(struct tui_win_info **list)
chtype tui_border_hline
Definition: tui-win.c:243
void tui_check_and_display_highlight_if_needed(struct tui_win_info *win_info)
union tui_win_info::@172 detail
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
static void tui_scroll_right_command(char *, int)
Definition: tui-win.c:1016
#define EMPTY_SOURCE_PROMPT
Definition: tui-data.h:75
void tui_display_all_data(void)
Definition: tui-windata.c:129
void tui_enable(void)
Definition: tui.c:397
static void show_tui_cmd(char *args, int from_tty)
Definition: tui-win.c:324
Definition: tui.h:41
static void show_tui_active_border_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: tui-win.c:205
const char * tui_active_border_mode
Definition: tui-win.c:203
int subset_compare(char *string_to_compare, char *template_string)
Definition: utils.c:2669
void tui_free_win_content(struct tui_gen_win_info *win_info)
Definition: tui-data.c:783
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
Definition: symtab.c:3328
initialize_file_ftype _initialize_tui_win
void set_screen_width_and_height(int width, int height)
Definition: utils.c:1799
void tui_set_default_tab_len(int len)
Definition: tui-data.c:149
static void tui_set_win_height_command(char *, int)
Definition: tui-win.c:1233
void error(const char *fmt,...)
Definition: errors.c:38
CORE_ADDR addr
Definition: tui-data.h:146
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
#define MIN_CMD_WIN_HEIGHT
Definition: tui-data.h:79
static void show_tui_border_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: tui-win.c:217
enum tui_layout_type tui_current_layout(void)
Definition: tui-data.c:294