#include <ctype.h>
#include "tui/tui.h"
+#include "tui/tui-command.h"
#include "tui/tui-data.h"
-#include "tui/tui-windata.h"
#include "tui/tui-wingeneral.h"
#include "tui/tui-stack.h"
#include "tui/tui-regs.h"
#include "tui/tui-winsource.h"
#include "tui/tui-disasm.h"
#include "tui/tui-layout.h"
+#include "tui/tui-source.h"
#include "gdb_curses.h"
-/*******************************
-** Static Local Decls
-********************************/
static void show_layout (enum tui_layout_type);
-static tui_gen_win_info *init_and_make_win (tui_gen_win_info *,
- enum tui_win_type,
- int, int, int, int,
- enum tui_box);
-static void show_source_or_disasm_and_command (enum tui_layout_type);
-static struct tui_win_info *make_source_or_disasm_window (enum tui_win_type,
- int, int);
-static struct tui_win_info *make_command_window (int, int);
-static struct tui_win_info *make_source_window (int, int);
-static struct tui_win_info *make_disasm_window (int, int);
-static void make_data_window (struct tui_win_info **, int, int);
-static void show_source_command (void);
-static void show_disasm_command (void);
-static void show_source_disasm_command (void);
-static void show_data (enum tui_layout_type);
static enum tui_layout_type next_layout (void);
static enum tui_layout_type prev_layout (void);
static void tui_layout_command (const char *, int);
static void extract_display_start_addr (struct gdbarch **, CORE_ADDR *);
-/***************************************
-** DEFINITIONS
-***************************************/
+/* The pre-defined layouts. */
+static tui_layout_split *standard_layouts[UNDEFINED_LAYOUT];
-#define LAYOUT_USAGE "Usage: layout prev | next | <layout_name> \n"
+/* The layout that is currently applied. */
+static std::unique_ptr<tui_layout_base> applied_layout;
+
+static enum tui_layout_type current_layout = UNDEFINED_LAYOUT;
+
+/* Accessor for the current layout. */
+enum tui_layout_type
+tui_current_layout (void)
+{
+ return current_layout;
+}
+
+/* See tui-layout.h. */
+
+void
+tui_apply_current_layout ()
+{
+ applied_layout->apply (0, 0, tui_term_width (), tui_term_height ());
+}
+
+/* See tui-layout. */
+
+void
+tui_adjust_window_height (struct tui_win_info *win, int new_height)
+{
+ applied_layout->adjust_size (win->name (), new_height);
+}
/* Show the screen layout defined. */
static void
if (layout != cur_layout)
{
- /* Since the new layout may cause changes in window size, we
- should free the content and reallocate on next display of
- source/asm. */
- tui_free_all_source_wins_content ();
- tui_clear_source_windows ();
- if (layout == SRC_DATA_COMMAND
- || layout == DISASSEM_DATA_COMMAND)
- {
- show_data (layout);
- tui_refresh_all (tui_win_list);
- }
- else
- {
- /* First make the current layout be invisible. */
- tui_make_all_invisible ();
- tui_make_invisible (tui_locator_win_info_ptr ());
-
- switch (layout)
- {
- /* Now show the new layout. */
- case SRC_COMMAND:
- show_source_command ();
- tui_add_to_source_windows (TUI_SRC_WIN);
- break;
- case DISASSEM_COMMAND:
- show_disasm_command ();
- tui_add_to_source_windows (TUI_DISASM_WIN);
- break;
- case SRC_DISASSEM_COMMAND:
- show_source_disasm_command ();
- tui_add_to_source_windows (TUI_SRC_WIN);
- tui_add_to_source_windows (TUI_DISASM_WIN);
- break;
- default:
- break;
- }
- }
+ tui_make_all_invisible ();
+ applied_layout = standard_layouts[layout]->clone ();
+ tui_apply_current_layout ();
+ current_layout = layout;
+ tui_delete_invisible_windows ();
}
}
/* Function to set the layout to SRC_COMMAND, DISASSEM_COMMAND,
SRC_DISASSEM_COMMAND, SRC_DATA_COMMAND, or DISASSEM_DATA_COMMAND. */
-enum tui_status
+void
tui_set_layout (enum tui_layout_type layout_type)
{
- enum tui_status status = TUI_SUCCESS;
+ gdb_assert (layout_type != UNDEFINED_LAYOUT);
- if (layout_type != UNDEFINED_LAYOUT)
- {
- enum tui_layout_type cur_layout = tui_current_layout (),
- new_layout = UNDEFINED_LAYOUT;
- int regs_populate = FALSE;
- struct gdbarch *gdbarch;
- CORE_ADDR addr;
- struct tui_win_info *win_with_focus = tui_win_with_focus ();
- struct tui_layout_def *layout_def = tui_layout_def ();
+ enum tui_layout_type cur_layout = tui_current_layout ();
+ struct gdbarch *gdbarch;
+ CORE_ADDR addr;
+ struct tui_win_info *win_with_focus = tui_win_with_focus ();
- extract_display_start_addr (&gdbarch, &addr);
+ extract_display_start_addr (&gdbarch, &addr);
- new_layout = layout_type;
+ enum tui_layout_type new_layout = layout_type;
- regs_populate = (new_layout == SRC_DATA_COMMAND
- || new_layout == DISASSEM_DATA_COMMAND);
- if (new_layout != cur_layout)
- {
- show_layout (new_layout);
+ if (new_layout != cur_layout)
+ {
+ show_layout (new_layout);
- /* Now determine where focus should be. */
- if (win_with_focus != TUI_CMD_WIN)
+ /* Now determine where focus should be. */
+ if (win_with_focus != TUI_CMD_WIN)
+ {
+ switch (new_layout)
{
- switch (new_layout)
- {
- case SRC_COMMAND:
- tui_set_win_focus_to (TUI_SRC_WIN);
- layout_def->display_mode = SRC_WIN;
- layout_def->split = FALSE;
- break;
- case DISASSEM_COMMAND:
- /* The previous layout was not showing code.
- This can happen if there is no source
- available:
-
- 1. if the source file is in another dir OR
- 2. if target was compiled without -g
- We still want to show the assembly though! */
-
- tui_get_begin_asm_address (&gdbarch, &addr);
- tui_set_win_focus_to (TUI_DISASM_WIN);
- layout_def->display_mode = DISASSEM_WIN;
- layout_def->split = FALSE;
- break;
- case SRC_DISASSEM_COMMAND:
- /* The previous layout was not showing code.
- This can happen if there is no source
- available:
-
- 1. if the source file is in another dir OR
- 2. if target was compiled without -g
- We still want to show the assembly though! */
-
- tui_get_begin_asm_address (&gdbarch, &addr);
- if (win_with_focus == TUI_SRC_WIN)
- tui_set_win_focus_to (TUI_SRC_WIN);
- else
- tui_set_win_focus_to (TUI_DISASM_WIN);
- layout_def->split = TRUE;
- break;
- case SRC_DATA_COMMAND:
- if (win_with_focus != TUI_DATA_WIN)
- tui_set_win_focus_to (TUI_SRC_WIN);
- else
- tui_set_win_focus_to (TUI_DATA_WIN);
- layout_def->display_mode = SRC_WIN;
- layout_def->split = FALSE;
- break;
- case DISASSEM_DATA_COMMAND:
- /* The previous layout was not showing code.
- This can happen if there is no source
- available:
-
- 1. if the source file is in another dir OR
- 2. if target was compiled without -g
- We still want to show the assembly though! */
-
- tui_get_begin_asm_address (&gdbarch, &addr);
- if (win_with_focus != TUI_DATA_WIN)
- tui_set_win_focus_to (TUI_DISASM_WIN);
- else
- tui_set_win_focus_to (TUI_DATA_WIN);
- layout_def->display_mode = DISASSEM_WIN;
- layout_def->split = FALSE;
- break;
- default:
- break;
- }
+ case SRC_COMMAND:
+ tui_set_win_focus_to (TUI_SRC_WIN);
+ break;
+ case DISASSEM_COMMAND:
+ /* The previous layout was not showing code.
+ This can happen if there is no source
+ available:
+
+ 1. if the source file is in another dir OR
+ 2. if target was compiled without -g
+ We still want to show the assembly though! */
+
+ tui_get_begin_asm_address (&gdbarch, &addr);
+ tui_set_win_focus_to (TUI_DISASM_WIN);
+ break;
+ case SRC_DISASSEM_COMMAND:
+ /* The previous layout was not showing code.
+ This can happen if there is no source
+ available:
+
+ 1. if the source file is in another dir OR
+ 2. if target was compiled without -g
+ We still want to show the assembly though! */
+
+ tui_get_begin_asm_address (&gdbarch, &addr);
+ if (win_with_focus == TUI_SRC_WIN)
+ tui_set_win_focus_to (TUI_SRC_WIN);
+ else
+ tui_set_win_focus_to (TUI_DISASM_WIN);
+ break;
+ case SRC_DATA_COMMAND:
+ if (win_with_focus != TUI_DATA_WIN)
+ tui_set_win_focus_to (TUI_SRC_WIN);
+ else
+ tui_set_win_focus_to (TUI_DATA_WIN);
+ break;
+ case DISASSEM_DATA_COMMAND:
+ /* The previous layout was not showing code.
+ This can happen if there is no source
+ available:
+
+ 1. if the source file is in another dir OR
+ 2. if target was compiled without -g
+ We still want to show the assembly though! */
+
+ tui_get_begin_asm_address (&gdbarch, &addr);
+ if (win_with_focus != TUI_DATA_WIN)
+ tui_set_win_focus_to (TUI_DISASM_WIN);
+ else
+ tui_set_win_focus_to (TUI_DATA_WIN);
+ break;
+ default:
+ break;
}
- /*
- * Now update the window content.
- */
- if (!regs_populate
- && (new_layout == SRC_DATA_COMMAND
- || new_layout == DISASSEM_DATA_COMMAND))
- tui_display_all_data ();
-
- tui_update_source_windows_with_addr (gdbarch, addr);
-
- if (regs_populate)
- tui_show_registers (TUI_DATA_WIN->current_group);
}
+ /*
+ * Now update the window content.
+ */
+ tui_update_source_windows_with_addr (gdbarch, addr);
+ if (new_layout == SRC_DATA_COMMAND
+ || new_layout == DISASSEM_DATA_COMMAND)
+ TUI_DATA_WIN->show_registers (TUI_DATA_WIN->get_current_group ());
}
- else
- status = TUI_FAILURE;
-
- return status;
}
/* Add the specified window to the layout in a logical way. This
&& cur_layout != SRC_DISASSEM_COMMAND
&& cur_layout != SRC_DATA_COMMAND)
{
- tui_clear_source_windows_detail ();
if (cur_layout == DISASSEM_DATA_COMMAND)
show_layout (SRC_DATA_COMMAND);
else
&& cur_layout != SRC_DISASSEM_COMMAND
&& cur_layout != DISASSEM_DATA_COMMAND)
{
- tui_clear_source_windows_detail ();
if (cur_layout == SRC_DATA_COMMAND)
show_layout (DISASSEM_DATA_COMMAND);
else
}
}
-
-/* Answer the height of a window. If it hasn't been created yet,
- answer what the height of a window would be based upon its type and
- the layout. */
-int
-tui_default_win_height (enum tui_win_type type,
- enum tui_layout_type layout)
-{
- int h;
-
- if (tui_win_list[type] != NULL)
- h = tui_win_list[type]->height;
- else
- {
- switch (layout)
- {
- case SRC_COMMAND:
- case DISASSEM_COMMAND:
- if (TUI_CMD_WIN == NULL)
- h = tui_term_height () / 2;
- else
- h = tui_term_height () - TUI_CMD_WIN->height;
- break;
- case SRC_DISASSEM_COMMAND:
- case SRC_DATA_COMMAND:
- case DISASSEM_DATA_COMMAND:
- if (TUI_CMD_WIN == NULL)
- h = tui_term_height () / 3;
- else
- h = (tui_term_height () - TUI_CMD_WIN->height) / 2;
- break;
- default:
- h = 0;
- break;
- }
- }
-
- return h;
-}
-
-
-/* Answer the height of a window. If it hasn't been created yet,
- answer what the height of a window would be based upon its type and
- the layout. */
-int
-tui_default_win_viewport_height (enum tui_win_type type,
- enum tui_layout_type layout)
-{
- int h;
-
- h = tui_default_win_height (type, layout);
-
- if (tui_win_list[type] == TUI_CMD_WIN)
- h -= 1;
- else
- h -= 2;
-
- return h;
-}
-
/* Complete possible layout names. TEXT is the complete text entered so
far, WORD is the word currently being completed. */
complete_on_enum (tracker, layout_names, text, word);
}
-/* Function to initialize gdb commands, for tui window layout
- manipulation. */
-
-void
-_initialize_tui_layout (void)
-{
- struct cmd_list_element *cmd;
-
- cmd = add_com ("layout", class_tui, tui_layout_command, _("\
-Change the layout of windows.\n\
-Usage: layout prev | next | LAYOUT-NAME\n\
-Layout names are:\n\
- src : Displays source and command windows.\n\
- asm : Displays disassembly and command windows.\n\
- split : Displays source, disassembly and command windows.\n\
- regs : Displays register window. If existing layout\n\
- is source/command or assembly/command, the \n\
- register window is displayed. If the\n\
- source/assembly/command (split) is displayed, \n\
- the register window is displayed with \n\
- the window that has current logical focus."));
- set_cmd_completer (cmd, layout_completer);
-}
-
-
-/*************************
-** STATIC LOCAL FUNCTIONS
-**************************/
-
-
/* Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA, or
REGS. */
-enum tui_status
-tui_set_layout_by_name (const char *layout_name)
+static void
+tui_layout_command (const char *layout_name, int from_tty)
{
- enum tui_status status = TUI_SUCCESS;
+ enum tui_layout_type new_layout = UNDEFINED_LAYOUT;
+ enum tui_layout_type cur_layout = tui_current_layout ();
- if (layout_name != NULL)
- {
- int i;
- enum tui_layout_type new_layout = UNDEFINED_LAYOUT;
- enum tui_layout_type cur_layout = tui_current_layout ();
+ if (layout_name == NULL || *layout_name == '\0')
+ error (_("Usage: layout prev | next | LAYOUT-NAME"));
- std::string copy = layout_name;
- for (i = 0; i < copy.size (); i++)
- copy[i] = toupper (copy[i]);
- const char *buf_ptr = copy.c_str ();
+ /* First check for ambiguous input. */
+ if (strcmp (layout_name, "s") == 0)
+ error (_("Ambiguous command input."));
- /* First check for ambiguous input. */
- if (strlen (buf_ptr) <= 1 && *buf_ptr == 'S')
- {
- warning (_("Ambiguous command input."));
- status = TUI_FAILURE;
- }
+ if (subset_compare (layout_name, "src"))
+ new_layout = SRC_COMMAND;
+ else if (subset_compare (layout_name, "asm"))
+ new_layout = DISASSEM_COMMAND;
+ else if (subset_compare (layout_name, "split"))
+ new_layout = SRC_DISASSEM_COMMAND;
+ else if (subset_compare (layout_name, "regs"))
+ {
+ if (cur_layout == SRC_COMMAND
+ || cur_layout == SRC_DATA_COMMAND)
+ new_layout = SRC_DATA_COMMAND;
else
- {
- if (subset_compare (buf_ptr, "SRC"))
- new_layout = SRC_COMMAND;
- else if (subset_compare (buf_ptr, "ASM"))
- new_layout = DISASSEM_COMMAND;
- else if (subset_compare (buf_ptr, "SPLIT"))
- new_layout = SRC_DISASSEM_COMMAND;
- else if (subset_compare (buf_ptr, "REGS"))
- {
- if (cur_layout == SRC_COMMAND
- || cur_layout == SRC_DATA_COMMAND)
- new_layout = SRC_DATA_COMMAND;
- else
- new_layout = DISASSEM_DATA_COMMAND;
- }
- else if (subset_compare (buf_ptr, "NEXT"))
- new_layout = next_layout ();
- else if (subset_compare (buf_ptr, "PREV"))
- new_layout = prev_layout ();
- else
- status = TUI_FAILURE;
-
- if (status == TUI_SUCCESS)
- {
- /* Make sure the curses mode is enabled. */
- tui_enable ();
- tui_set_layout (new_layout);
- }
- }
+ new_layout = DISASSEM_DATA_COMMAND;
}
+ else if (subset_compare (layout_name, "next"))
+ new_layout = next_layout ();
+ else if (subset_compare (layout_name, "prev"))
+ new_layout = prev_layout ();
else
- status = TUI_FAILURE;
+ error (_("Unrecognized layout: %s"), layout_name);
- return status;
+ /* Make sure the curses mode is enabled. */
+ tui_enable ();
+ tui_set_layout (new_layout);
}
}
-static void
-tui_layout_command (const char *arg, int from_tty)
-{
- /* Switch to the selected layout. */
- if (tui_set_layout_by_name (arg) != TUI_SUCCESS)
- warning (_("Invalid layout specified.\n%s"), LAYOUT_USAGE);
-}
-
/* Answer the previous layout to cycle to. */
static enum tui_layout_type
next_layout (void)
return (enum tui_layout_type) new_layout;
}
+void
+tui_gen_win_info::resize (int height_, int width_,
+ int origin_x_, int origin_y_)
+{
+ if (width == width_ && height == height_
+ && x == origin_x_ && y == origin_y_
+ && handle != nullptr)
+ return;
+ width = width_;
+ height = height_;
+ if (height > 1)
+ viewport_height = height - 2;
+ else
+ viewport_height = 1;
+ x = origin_x_;
+ y = origin_y_;
-static struct tui_win_info *
-make_command_window (int height, int origin_y)
-{
- struct tui_win_info *result
- = (struct tui_win_info *) init_and_make_win (NULL,
- CMD_WIN,
- height,
- tui_term_width (),
- 0,
- origin_y,
- DONT_BOX_WINDOW);
- return result;
+ if (handle != nullptr)
+ {
+#ifdef HAVE_WRESIZE
+ wresize (handle.get (), height, width);
+ mvwin (handle.get (), y, x);
+ wmove (handle.get (), 0, 0);
+#else
+ handle.reset (nullptr);
+#endif
+ }
+
+ if (handle == nullptr)
+ make_window ();
+
+ rerender ();
}
+\f
+
+/* Helper function that returns a TUI window, given its name. */
-/* make_source_window().
- */
-static struct tui_win_info *
-make_source_window (int height, int origin_y)
+static tui_gen_win_info *
+tui_get_window_by_name (const std::string &name)
{
- return make_source_or_disasm_window (SRC_WIN, height, origin_y);
-} /* make_source_window */
+ if (name == "src")
+ {
+ if (tui_win_list[SRC_WIN] == nullptr)
+ tui_win_list[SRC_WIN] = new tui_source_window ();
+ return tui_win_list[SRC_WIN];
+ }
+ else if (name == "cmd")
+ {
+ if (tui_win_list[CMD_WIN] == nullptr)
+ tui_win_list[CMD_WIN] = new tui_cmd_window ();
+ return tui_win_list[CMD_WIN];
+ }
+ else if (name == "regs")
+ {
+ if (tui_win_list[DATA_WIN] == nullptr)
+ tui_win_list[DATA_WIN] = new tui_data_window ();
+ return tui_win_list[DATA_WIN];
+ }
+ else if (name == "asm")
+ {
+ if (tui_win_list[DISASSEM_WIN] == nullptr)
+ tui_win_list[DISASSEM_WIN] = new tui_disasm_window ();
+ return tui_win_list[DISASSEM_WIN];
+ }
+ else
+ {
+ gdb_assert (name == "locator");
+ return tui_locator_win_info_ptr ();
+ }
+}
+/* See tui-layout.h. */
-/* make_disasm_window().
- */
-static struct tui_win_info *
-make_disasm_window (int height, int origin_y)
+std::unique_ptr<tui_layout_base>
+tui_layout_window::clone () const
{
- return make_source_or_disasm_window (DISASSEM_WIN, height, origin_y);
-} /* make_disasm_window */
+ tui_layout_window *result = new tui_layout_window (m_contents.c_str ());
+ return std::unique_ptr<tui_layout_base> (result);
+}
+/* See tui-layout.h. */
-static void
-make_data_window (struct tui_win_info **win_info_ptr,
- int height, int origin_y)
+void
+tui_layout_window::apply (int x_, int y_, int width_, int height_)
{
- *win_info_ptr
- = (struct tui_win_info *) init_and_make_win (*win_info_ptr,
- DATA_WIN,
- height,
- tui_term_width (),
- 0,
- origin_y,
- BOX_WINDOW);
+ x = x_;
+ y = y_;
+ width = width_;
+ height = height_;
+ gdb_assert (m_window != nullptr);
+ m_window->resize (height, width, x, y);
}
+/* See tui-layout.h. */
-
-/* Show the Source/Command layout. */
-static void
-show_source_command (void)
+void
+tui_layout_window::get_sizes (int *min_height, int *max_height)
{
- show_source_or_disasm_and_command (SRC_COMMAND);
+ if (m_window == nullptr)
+ m_window = tui_get_window_by_name (m_contents);
+ *min_height = m_window->min_height ();
+ *max_height = m_window->max_height ();
}
+/* See tui-layout.h. */
-/* Show the Dissassem/Command layout. */
-static void
-show_disasm_command (void)
+bool
+tui_layout_window::top_boxed_p () const
{
- show_source_or_disasm_and_command (DISASSEM_COMMAND);
+ gdb_assert (m_window != nullptr);
+ return m_window->can_box ();
}
+/* See tui-layout.h. */
-/* Show the Source/Disassem/Command layout. */
-static void
-show_source_disasm_command (void)
+bool
+tui_layout_window::bottom_boxed_p () const
{
- if (tui_current_layout () != SRC_DISASSEM_COMMAND)
- {
- int cmd_height, src_height, asm_height;
-
- if (TUI_CMD_WIN != NULL)
- cmd_height = TUI_CMD_WIN->height;
- else
- cmd_height = tui_term_height () / 3;
+ gdb_assert (m_window != nullptr);
+ return m_window->can_box ();
+}
- src_height = (tui_term_height () - cmd_height) / 2;
- asm_height = tui_term_height () - (src_height + cmd_height);
+/* See tui-layout.h. */
- if (TUI_SRC_WIN == NULL)
- tui_win_list[SRC_WIN] = make_source_window (src_height, 0);
- else
- {
- TUI_SRC_WIN->reset (TUI_SRC_WIN->type,
- src_height,
- TUI_SRC_WIN->width,
- TUI_SRC_WIN->execution_info->width,
- 0);
- TUI_SRC_WIN->execution_info->reset (EXEC_INFO_WIN,
- src_height,
- 3,
- 0,
- 0);
- tui_make_visible (TUI_SRC_WIN);
- tui_make_visible (TUI_SRC_WIN->execution_info);
- TUI_SRC_WIN->m_has_locator = false;
- }
+tui_layout_split *
+tui_layout_split::add_split (int weight)
+{
+ tui_layout_split *result = new tui_layout_split ();
+ split s = {weight, std::unique_ptr<tui_layout_base> (result)};
+ m_splits.push_back (std::move (s));
+ return result;
+}
- struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
+/* See tui-layout.h. */
- tui_show_source_content (TUI_SRC_WIN);
- if (TUI_DISASM_WIN == NULL)
- {
- tui_win_list[DISASSEM_WIN]
- = make_disasm_window (asm_height, src_height - 1);
- locator
- = init_and_make_win (locator,
- LOCATOR_WIN,
- 2 /* 1 */ ,
- tui_term_width (),
- 0,
- (src_height + asm_height) - 1,
- DONT_BOX_WINDOW);
- }
- else
- {
- locator->reset (LOCATOR_WIN,
- 2 /* 1 */ ,
- tui_term_width (),
- 0,
- (src_height + asm_height) - 1);
- TUI_DISASM_WIN->m_has_locator = true;
- TUI_DISASM_WIN->reset (TUI_DISASM_WIN->type,
- asm_height,
- TUI_DISASM_WIN->width,
- TUI_DISASM_WIN->execution_info->width,
- src_height - 1);
- TUI_DISASM_WIN->execution_info->reset (EXEC_INFO_WIN,
- asm_height,
- 3,
- 0,
- src_height - 1);
- tui_make_visible (TUI_DISASM_WIN);
- tui_make_visible (TUI_DISASM_WIN->execution_info);
- }
- TUI_SRC_WIN->m_has_locator = false;
- TUI_DISASM_WIN->m_has_locator = true;
- tui_make_visible (locator);
- tui_show_locator_content ();
- tui_show_source_content (TUI_DISASM_WIN);
-
- if (TUI_CMD_WIN == NULL)
- tui_win_list[CMD_WIN]
- = make_command_window (cmd_height, tui_term_height () - cmd_height);
- else
- {
- TUI_CMD_WIN->reset (TUI_CMD_WIN->type,
- TUI_CMD_WIN->height,
- TUI_CMD_WIN->width,
- 0,
- TUI_CMD_WIN->origin.y);
- tui_make_visible (TUI_CMD_WIN);
- }
- TUI_CMD_WIN->refresh_window ();
- tui_set_current_layout_to (SRC_DISASSEM_COMMAND);
- }
+void
+tui_layout_split::add_window (const char *name, int weight)
+{
+ tui_layout_window *result = new tui_layout_window (name);
+ split s = {weight, std::unique_ptr<tui_layout_base> (result)};
+ m_splits.push_back (std::move (s));
}
+/* See tui-layout.h. */
-/* Show the Source/Data/Command or the Dissassembly/Data/Command
- layout. */
-static void
-show_data (enum tui_layout_type new_layout)
+std::unique_ptr<tui_layout_base>
+tui_layout_split::clone () const
{
- int total_height = (tui_term_height () - TUI_CMD_WIN->height);
- int src_height, data_height;
- enum tui_win_type win_type;
- struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
-
-
- data_height = total_height / 2;
- src_height = total_height - data_height;
- tui_make_all_invisible ();
- tui_make_invisible (locator);
- make_data_window (&tui_win_list[DATA_WIN], data_height, 0);
- if (new_layout == SRC_DATA_COMMAND)
- win_type = SRC_WIN;
- else
- win_type = DISASSEM_WIN;
-
- tui_source_window_base *base;
- if (tui_win_list[win_type] == NULL)
- {
- if (win_type == SRC_WIN)
- tui_win_list[win_type]
- = make_source_window (src_height, data_height - 1);
- else
- tui_win_list[win_type]
- = make_disasm_window (src_height, data_height - 1);
- locator
- = init_and_make_win (locator,
- LOCATOR_WIN,
- 2 /* 1 */ ,
- tui_term_width (),
- 0,
- total_height - 1,
- DONT_BOX_WINDOW);
- base = (tui_source_window_base *) tui_win_list[win_type];
- }
- else
+ tui_layout_split *result = new tui_layout_split ();
+ for (const split &item : m_splits)
{
- base = (tui_source_window_base *) tui_win_list[win_type];
- tui_win_list[win_type]->reset (tui_win_list[win_type]->type,
- src_height,
- tui_win_list[win_type]->width,
- base->execution_info->width,
- data_height - 1);
- base->execution_info->reset (EXEC_INFO_WIN,
- src_height,
- 3,
- 0,
- data_height - 1);
- tui_make_visible (tui_win_list[win_type]);
- tui_make_visible (base->execution_info);
- locator->reset (LOCATOR_WIN,
- 2 /* 1 */ ,
- tui_term_width (),
- 0,
- total_height - 1);
+ std::unique_ptr<tui_layout_base> next = item.layout->clone ();
+ split s = {item.weight, std::move (next)};
+ result->m_splits.push_back (std::move (s));
}
- base->m_has_locator = true;
- tui_make_visible (locator);
- tui_show_locator_content ();
- tui_add_to_source_windows
- ((tui_source_window_base *) tui_win_list[win_type]);
- tui_set_current_layout_to (new_layout);
+ return std::unique_ptr<tui_layout_base> (result);
}
+/* See tui-layout.h. */
+
void
-tui_gen_win_info::reset (enum tui_win_type win_type,
- int height_, int width_,
- int origin_x_, int origin_y_)
+tui_layout_split::get_sizes (int *min_height, int *max_height)
{
- int h = height_;
-
- gdb_assert (type == win_type);
-
- width = width_;
- height = h;
- if (h > 1)
+ *min_height = 0;
+ *max_height = 0;
+ for (const split &item : m_splits)
{
- viewport_height = h - 1;
- if (type != CMD_WIN)
- viewport_height--;
+ int new_min, new_max;
+ item.layout->get_sizes (&new_min, &new_max);
+ *min_height += new_min;
+ *max_height += new_max;
}
- else
- viewport_height = 1;
- origin.x = origin_x_;
- origin.y = origin_y_;
}
-/* init_and_make_win().
- */
-static tui_gen_win_info *
-init_and_make_win (tui_gen_win_info *win_info,
- enum tui_win_type win_type,
- int height, int width,
- int origin_x, int origin_y,
- enum tui_box box_it)
+/* See tui-layout.h. */
+
+bool
+tui_layout_split::top_boxed_p () const
{
- if (win_info == NULL)
- {
- if (tui_win_is_auxillary (win_type))
- win_info = new tui_gen_win_info (win_type);
- else
- win_info = tui_alloc_win_info (win_type);
- }
+ if (m_splits.empty ())
+ return false;
+ return m_splits[0].layout->top_boxed_p ();
+}
- win_info->reset (win_type, height, width, origin_x, origin_y);
- tui_make_window (win_info, box_it);
+/* See tui-layout.h. */
- return win_info;
+bool
+tui_layout_split::bottom_boxed_p () const
+{
+ if (m_splits.empty ())
+ return false;
+ return m_splits.back ().layout->top_boxed_p ();
}
+/* See tui-layout.h. */
-static struct tui_win_info *
-make_source_or_disasm_window (enum tui_win_type type,
- int height, int origin_y)
+void
+tui_layout_split::set_weights_from_heights ()
{
- struct tui_gen_win_info *execution_info
- = init_and_make_win (nullptr,
- EXEC_INFO_WIN,
- height,
- 3,
- 0,
- origin_y,
- DONT_BOX_WINDOW);
-
- /* Now create the source window. */
- struct tui_source_window_base *result
- = ((struct tui_source_window_base *)
- init_and_make_win (NULL,
- type,
- height,
- tui_term_width () - execution_info->width,
- execution_info->width,
- origin_y,
- BOX_WINDOW));
- result->execution_info = execution_info;
- return result;
+ for (int i = 0; i < m_splits.size (); ++i)
+ m_splits[i].weight = m_splits[i].layout->height;
}
+/* See tui-layout.h. */
-/* Show the Source/Command or the Disassem layout. */
-static void
-show_source_or_disasm_and_command (enum tui_layout_type layout_type)
+bool
+tui_layout_split::adjust_size (const char *name, int new_height)
{
- if (tui_current_layout () != layout_type)
+ /* Look through the children. If one is a layout holding the named
+ window, we're done; or if one actually is the named window,
+ update it. */
+ int found_index = -1;
+ for (int i = 0; i < m_splits.size (); ++i)
{
- struct tui_win_info **win_info_ptr;
- int src_height, cmd_height;
- struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
+ if (m_splits[i].layout->adjust_size (name, new_height))
+ return true;
+ const char *win_name = m_splits[i].layout->get_name ();
+ if (win_name != nullptr && strcmp (name, win_name) == 0)
+ {
+ found_index = i;
+ break;
+ }
+ }
- if (TUI_CMD_WIN != NULL)
- cmd_height = TUI_CMD_WIN->height;
- else
- cmd_height = tui_term_height () / 3;
- src_height = tui_term_height () - cmd_height;
+ if (found_index == -1)
+ return false;
+ if (m_splits[found_index].layout->height == new_height)
+ return true;
- if (layout_type == SRC_COMMAND)
- win_info_ptr = &tui_win_list[SRC_WIN];
- else
- win_info_ptr = &tui_win_list[DISASSEM_WIN];
+ set_weights_from_heights ();
+ int delta = m_splits[found_index].weight - new_height;
+ m_splits[found_index].weight = new_height;
+
+ /* Distribute the "delta" over the next window; but if the next
+ window cannot hold it all, keep going until we either find a
+ window that does, or until we loop all the way around. */
+ for (int i = 0; delta != 0 && i < m_splits.size () - 1; ++i)
+ {
+ int index = (found_index + 1 + i) % m_splits.size ();
- tui_source_window_base *base;
- if ((*win_info_ptr) == NULL)
+ int new_min, new_max;
+ m_splits[index].layout->get_sizes (&new_min, &new_max);
+
+ if (delta < 0)
{
- if (layout_type == SRC_COMMAND)
- *win_info_ptr = make_source_window (src_height - 1, 0);
- else
- *win_info_ptr = make_disasm_window (src_height - 1, 0);
- locator
- = init_and_make_win (locator,
- LOCATOR_WIN,
- 2 /* 1 */ ,
- tui_term_width (),
- 0,
- src_height - 1,
- DONT_BOX_WINDOW);
- base = (tui_source_window_base *) *win_info_ptr;
+ /* The primary window grew, so we are trying to shrink other
+ windows. */
+ int available = m_splits[index].weight - new_min;
+ int shrink_by = std::min (available, -delta);
+ m_splits[index].weight -= shrink_by;
+ delta += shrink_by;
}
else
{
- base = (tui_source_window_base *) *win_info_ptr;
- locator->reset (LOCATOR_WIN,
- 2 /* 1 */ ,
- tui_term_width (),
- 0,
- src_height - 1);
- base->m_has_locator = true;
- (*win_info_ptr)->reset ((*win_info_ptr)->type,
- src_height - 1,
- (*win_info_ptr)->width,
- base->execution_info->width,
- 0);
- base->execution_info->reset (EXEC_INFO_WIN,
- src_height - 1,
- 3,
- 0,
- 0);
- tui_make_visible (*win_info_ptr);
- tui_make_visible (base->execution_info);
+ /* The primary window shrank, so we are trying to grow other
+ windows. */
+ int available = new_max - m_splits[index].weight;
+ int grow_by = std::min (available, delta);
+ m_splits[index].weight += grow_by;
+ delta -= grow_by;
}
+ }
+
+ if (delta != 0)
+ {
+ warning (_("Invalid window height specified"));
+ /* Effectively undo any modifications made here. */
+ set_weights_from_heights ();
+ }
+ else
+ {
+ /* Simply re-apply the updated layout. */
+ apply (x, y, width, height);
+ }
+
+ return true;
+}
+
+/* See tui-layout.h. */
+
+void
+tui_layout_split::apply (int x_, int y_, int width_, int height_)
+{
+ x = x_;
+ y = y_;
+ width = width_;
+ height = height_;
+
+ struct height_info
+ {
+ int height;
+ int min_height;
+ int max_height;
+ /* True if this window will share a box border with the previous
+ window in the list. */
+ bool share_box;
+ };
+
+ std::vector<height_info> info (m_splits.size ());
+
+ /* Step 1: Find the min and max height of each sub-layout.
+ Fixed-sized layouts are given their desired height, and then the
+ remaining space is distributed among the remaining windows
+ according to the weights given. */
+ int available_height = height;
+ int last_index = -1;
+ int total_weight = 0;
+ for (int i = 0; i < m_splits.size (); ++i)
+ {
+ bool cmd_win_already_exists = TUI_CMD_WIN != nullptr;
- base->m_has_locator = true;
- tui_make_visible (locator);
- tui_show_locator_content ();
- tui_show_source_content (*win_info_ptr);
+ /* Always call get_sizes, to ensure that the window is
+ instantiated. This is a bit gross but less gross than adding
+ special cases for this in other places. */
+ m_splits[i].layout->get_sizes (&info[i].min_height, &info[i].max_height);
- if (TUI_CMD_WIN == NULL)
+ if (!m_applied
+ && cmd_win_already_exists
+ && m_splits[i].layout->get_name () != nullptr
+ && strcmp (m_splits[i].layout->get_name (), "cmd") == 0)
{
- tui_win_list[CMD_WIN] = make_command_window (cmd_height,
- src_height);
- TUI_CMD_WIN->refresh_window ();
+ /* If this layout has never been applied, then it means the
+ user just changed the layout. In this situation, it's
+ desirable to keep the size of the command window the
+ same. Setting the min and max heights this way ensures
+ that the resizing step, below, does the right thing with
+ this window. */
+ info[i].min_height = TUI_CMD_WIN->height;
+ info[i].max_height = TUI_CMD_WIN->height;
}
+
+ if (info[i].min_height == info[i].max_height)
+ available_height -= info[i].min_height;
else
{
- TUI_CMD_WIN->reset (TUI_CMD_WIN->type,
- TUI_CMD_WIN->height,
- TUI_CMD_WIN->width,
- TUI_CMD_WIN->origin.x,
- TUI_CMD_WIN->origin.y);
- tui_make_visible (TUI_CMD_WIN);
+ last_index = i;
+ total_weight += m_splits[i].weight;
+ }
+
+ /* Two adjacent boxed windows will share a border, making a bit
+ more height available. */
+ if (i > 0
+ && m_splits[i - 1].layout->bottom_boxed_p ()
+ && m_splits[i].layout->top_boxed_p ())
+ info[i].share_box = true;
+ }
+
+ /* Step 2: Compute the height of each sub-layout. Fixed-sized items
+ are given their fixed size, while others are resized according to
+ their weight. */
+ int used_height = 0;
+ for (int i = 0; i < m_splits.size (); ++i)
+ {
+ /* Compute the height and clamp to the allowable range. */
+ info[i].height = available_height * m_splits[i].weight / total_weight;
+ if (info[i].height > info[i].max_height)
+ info[i].height = info[i].max_height;
+ if (info[i].height < info[i].min_height)
+ info[i].height = info[i].min_height;
+ /* If there is any leftover height, just redistribute it to the
+ last resizeable window, by dropping it from the allocated
+ height. We could try to be fancier here perhaps, by
+ redistributing this height among all windows, not just the
+ last window. */
+ if (info[i].min_height != info[i].max_height)
+ {
+ used_height += info[i].height;
+ if (info[i].share_box)
+ --used_height;
}
- tui_set_current_layout_to (layout_type);
}
+
+ /* Allocate any leftover height. */
+ if (available_height >= used_height && last_index != -1)
+ info[last_index].height += available_height - used_height;
+
+ /* Step 3: Resize. */
+ int height_accum = 0;
+ for (int i = 0; i < m_splits.size (); ++i)
+ {
+ /* If we fall off the bottom, just make allocations overlap.
+ GIGO. */
+ if (height_accum + info[i].height > height)
+ height_accum = height - info[i].height;
+ else if (info[i].share_box)
+ --height_accum;
+ m_splits[i].layout->apply (x, y + height_accum, width, info[i].height);
+ height_accum += info[i].height;
+ }
+
+ m_applied = true;
+}
+
+static void
+initialize_layouts ()
+{
+ standard_layouts[SRC_COMMAND] = new tui_layout_split ();
+ standard_layouts[SRC_COMMAND]->add_window ("src", 2);
+ standard_layouts[SRC_COMMAND]->add_window ("locator", 0);
+ standard_layouts[SRC_COMMAND]->add_window ("cmd", 1);
+
+ standard_layouts[DISASSEM_COMMAND] = new tui_layout_split ();
+ standard_layouts[DISASSEM_COMMAND]->add_window ("asm", 2);
+ standard_layouts[DISASSEM_COMMAND]->add_window ("locator", 0);
+ standard_layouts[DISASSEM_COMMAND]->add_window ("cmd", 1);
+
+ standard_layouts[SRC_DATA_COMMAND] = new tui_layout_split ();
+ standard_layouts[SRC_DATA_COMMAND]->add_window ("regs", 1);
+ standard_layouts[SRC_DATA_COMMAND]->add_window ("src", 1);
+ standard_layouts[SRC_DATA_COMMAND]->add_window ("locator", 0);
+ standard_layouts[SRC_DATA_COMMAND]->add_window ("cmd", 1);
+
+ standard_layouts[DISASSEM_DATA_COMMAND] = new tui_layout_split ();
+ standard_layouts[DISASSEM_DATA_COMMAND]->add_window ("regs", 1);
+ standard_layouts[DISASSEM_DATA_COMMAND]->add_window ("asm", 1);
+ standard_layouts[DISASSEM_DATA_COMMAND]->add_window ("locator", 0);
+ standard_layouts[DISASSEM_DATA_COMMAND]->add_window ("cmd", 1);
+
+ standard_layouts[SRC_DISASSEM_COMMAND] = new tui_layout_split ();
+ standard_layouts[SRC_DISASSEM_COMMAND]->add_window ("src", 1);
+ standard_layouts[SRC_DISASSEM_COMMAND]->add_window ("asm", 1);
+ standard_layouts[SRC_DISASSEM_COMMAND]->add_window ("locator", 0);
+ standard_layouts[SRC_DISASSEM_COMMAND]->add_window ("cmd", 1);
+}
+
+\f
+
+/* Function to initialize gdb commands, for tui window layout
+ manipulation. */
+
+void
+_initialize_tui_layout (void)
+{
+ struct cmd_list_element *cmd;
+
+ cmd = add_com ("layout", class_tui, tui_layout_command, _("\
+Change the layout of windows.\n\
+Usage: layout prev | next | LAYOUT-NAME\n\
+Layout names are:\n\
+ src : Displays source and command windows.\n\
+ asm : Displays disassembly and command windows.\n\
+ split : Displays source, disassembly and command windows.\n\
+ regs : Displays register window. If existing layout\n\
+ is source/command or assembly/command, the \n\
+ register window is displayed. If the\n\
+ source/assembly/command (split) is displayed, \n\
+ the register window is displayed with \n\
+ the window that has current logical focus."));
+ set_cmd_completer (cmd, layout_completer);
+
+ initialize_layouts ();
}
projects / deliverable / binutils-gdb.git / blobdiff