1130803Smarcel/* TUI layout window management. 2130803Smarcel 3130803Smarcel Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software 4130803Smarcel Foundation, Inc. 5130803Smarcel 6130803Smarcel Contributed by Hewlett-Packard Company. 7130803Smarcel 8130803Smarcel This file is part of GDB. 9130803Smarcel 10130803Smarcel This program is free software; you can redistribute it and/or modify 11130803Smarcel it under the terms of the GNU General Public License as published by 12130803Smarcel the Free Software Foundation; either version 2 of the License, or 13130803Smarcel (at your option) any later version. 14130803Smarcel 15130803Smarcel This program is distributed in the hope that it will be useful, 16130803Smarcel but WITHOUT ANY WARRANTY; without even the implied warranty of 17130803Smarcel MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18130803Smarcel GNU General Public License for more details. 19130803Smarcel 20130803Smarcel You should have received a copy of the GNU General Public License 21130803Smarcel along with this program; if not, write to the Free Software 22130803Smarcel Foundation, Inc., 59 Temple Place - Suite 330, 23130803Smarcel Boston, MA 02111-1307, USA. */ 24130803Smarcel 25130803Smarcel#include "defs.h" 26130803Smarcel#include "command.h" 27130803Smarcel#include "symtab.h" 28130803Smarcel#include "frame.h" 29130803Smarcel#include "source.h" 30130803Smarcel#include <ctype.h> 31130803Smarcel 32130803Smarcel#include "tui/tui.h" 33130803Smarcel#include "tui/tui-data.h" 34130803Smarcel#include "tui/tui-windata.h" 35130803Smarcel#include "tui/tui-wingeneral.h" 36130803Smarcel#include "tui/tui-stack.h" 37130803Smarcel#include "tui/tui-regs.h" 38130803Smarcel#include "tui/tui-win.h" 39130803Smarcel#include "tui/tui-winsource.h" 40130803Smarcel#include "tui/tui-disasm.h" 41130803Smarcel 42130803Smarcel#include "gdb_string.h" 43130803Smarcel#include "gdb_curses.h" 44130803Smarcel 45130803Smarcel/******************************* 46130803Smarcel** Static Local Decls 47130803Smarcel********************************/ 48130803Smarcelstatic void show_layout (enum tui_layout_type); 49130803Smarcelstatic void init_gen_win_info (struct tui_gen_win_info *, enum tui_win_type, int, int, int, int); 50130803Smarcelstatic void init_and_make_win (void **, enum tui_win_type, int, int, int, int, int); 51130803Smarcelstatic void show_source_or_disasm_and_command (enum tui_layout_type); 52130803Smarcelstatic void make_source_or_disasm_window (struct tui_win_info * *, enum tui_win_type, int, int); 53130803Smarcelstatic void make_command_window (struct tui_win_info * *, int, int); 54130803Smarcelstatic void make_source_window (struct tui_win_info * *, int, int); 55130803Smarcelstatic void make_disasm_window (struct tui_win_info * *, int, int); 56130803Smarcelstatic void make_data_window (struct tui_win_info * *, int, int); 57130803Smarcelstatic void show_source_command (void); 58130803Smarcelstatic void show_disasm_command (void); 59130803Smarcelstatic void show_source_disasm_command (void); 60130803Smarcelstatic void show_data (enum tui_layout_type); 61130803Smarcelstatic enum tui_layout_type next_layout (void); 62130803Smarcelstatic enum tui_layout_type prev_layout (void); 63130803Smarcelstatic void tui_layout_command (char *, int); 64130803Smarcelstatic void tui_toggle_layout_command (char *, int); 65130803Smarcelstatic void tui_toggle_split_layout_command (char *, int); 66130803Smarcelstatic CORE_ADDR extract_display_start_addr (void); 67130803Smarcelstatic void tui_handle_xdb_layout (struct tui_layout_def *); 68130803Smarcel 69130803Smarcel 70130803Smarcel/*************************************** 71130803Smarcel** DEFINITIONS 72130803Smarcel***************************************/ 73130803Smarcel 74130803Smarcel#define LAYOUT_USAGE "Usage: layout prev | next | <layout_name> \n" 75130803Smarcel 76130803Smarcel/* Show the screen layout defined. */ 77130803Smarcelstatic void 78130803Smarcelshow_layout (enum tui_layout_type layout) 79130803Smarcel{ 80130803Smarcel enum tui_layout_type cur_layout = tui_current_layout (); 81130803Smarcel 82130803Smarcel if (layout != cur_layout) 83130803Smarcel { 84130803Smarcel /* 85130803Smarcel ** Since the new layout may cause changes in window size, we 86130803Smarcel ** should free the content and reallocate on next display of 87130803Smarcel ** source/asm 88130803Smarcel */ 89130803Smarcel tui_free_all_source_wins_content (); 90130803Smarcel tui_clear_source_windows (); 91130803Smarcel if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND) 92130803Smarcel { 93130803Smarcel show_data (layout); 94130803Smarcel tui_refresh_all (tui_win_list); 95130803Smarcel } 96130803Smarcel else 97130803Smarcel { 98130803Smarcel /* First make the current layout be invisible */ 99130803Smarcel tui_make_all_invisible (); 100130803Smarcel tui_make_invisible (tui_locator_win_info_ptr ()); 101130803Smarcel 102130803Smarcel switch (layout) 103130803Smarcel { 104130803Smarcel /* Now show the new layout */ 105130803Smarcel case SRC_COMMAND: 106130803Smarcel show_source_command (); 107130803Smarcel tui_add_to_source_windows (TUI_SRC_WIN); 108130803Smarcel break; 109130803Smarcel case DISASSEM_COMMAND: 110130803Smarcel show_disasm_command (); 111130803Smarcel tui_add_to_source_windows (TUI_DISASM_WIN); 112130803Smarcel break; 113130803Smarcel case SRC_DISASSEM_COMMAND: 114130803Smarcel show_source_disasm_command (); 115130803Smarcel tui_add_to_source_windows (TUI_SRC_WIN); 116130803Smarcel tui_add_to_source_windows (TUI_DISASM_WIN); 117130803Smarcel break; 118130803Smarcel default: 119130803Smarcel break; 120130803Smarcel } 121130803Smarcel } 122130803Smarcel } 123130803Smarcel} 124130803Smarcel 125130803Smarcel 126130803Smarcel/* Function to set the layout to SRC_COMMAND, DISASSEM_COMMAND, 127130803Smarcel SRC_DISASSEM_COMMAND, SRC_DATA_COMMAND, or DISASSEM_DATA_COMMAND. 128130803Smarcel If the layout is SRC_DATA_COMMAND, DISASSEM_DATA_COMMAND, or 129130803Smarcel UNDEFINED_LAYOUT, then the data window is populated according to 130130803Smarcel regs_display_type. */ 131130803Smarcelenum tui_status 132130803Smarceltui_set_layout (enum tui_layout_type layout_type, 133130803Smarcel enum tui_register_display_type regs_display_type) 134130803Smarcel{ 135130803Smarcel enum tui_status status = TUI_SUCCESS; 136130803Smarcel 137130803Smarcel if (layout_type != UNDEFINED_LAYOUT || regs_display_type != TUI_UNDEFINED_REGS) 138130803Smarcel { 139130803Smarcel enum tui_layout_type cur_layout = tui_current_layout (), new_layout = UNDEFINED_LAYOUT; 140130803Smarcel int regs_populate = FALSE; 141130803Smarcel CORE_ADDR addr = extract_display_start_addr (); 142130803Smarcel struct tui_win_info * new_win_with_focus = (struct tui_win_info *) NULL; 143130803Smarcel struct tui_win_info * win_with_focus = tui_win_with_focus (); 144130803Smarcel struct tui_layout_def * layout_def = tui_layout_def (); 145130803Smarcel 146130803Smarcel 147130803Smarcel if (layout_type == UNDEFINED_LAYOUT && 148130803Smarcel regs_display_type != TUI_UNDEFINED_REGS) 149130803Smarcel { 150130803Smarcel if (cur_layout == SRC_DISASSEM_COMMAND) 151130803Smarcel new_layout = DISASSEM_DATA_COMMAND; 152130803Smarcel else if (cur_layout == SRC_COMMAND || cur_layout == SRC_DATA_COMMAND) 153130803Smarcel new_layout = SRC_DATA_COMMAND; 154130803Smarcel else if (cur_layout == DISASSEM_COMMAND || 155130803Smarcel cur_layout == DISASSEM_DATA_COMMAND) 156130803Smarcel new_layout = DISASSEM_DATA_COMMAND; 157130803Smarcel } 158130803Smarcel else 159130803Smarcel new_layout = layout_type; 160130803Smarcel 161130803Smarcel regs_populate = (new_layout == SRC_DATA_COMMAND || 162130803Smarcel new_layout == DISASSEM_DATA_COMMAND || 163130803Smarcel regs_display_type != TUI_UNDEFINED_REGS); 164130803Smarcel if (new_layout != cur_layout || regs_display_type != TUI_UNDEFINED_REGS) 165130803Smarcel { 166130803Smarcel if (new_layout != cur_layout) 167130803Smarcel { 168130803Smarcel show_layout (new_layout); 169130803Smarcel /* 170130803Smarcel ** Now determine where focus should be 171130803Smarcel */ 172130803Smarcel if (win_with_focus != TUI_CMD_WIN) 173130803Smarcel { 174130803Smarcel switch (new_layout) 175130803Smarcel { 176130803Smarcel case SRC_COMMAND: 177130803Smarcel tui_set_win_focus_to (TUI_SRC_WIN); 178130803Smarcel layout_def->display_mode = SRC_WIN; 179130803Smarcel layout_def->split = FALSE; 180130803Smarcel break; 181130803Smarcel case DISASSEM_COMMAND: 182130803Smarcel /* the previous layout was not showing 183130803Smarcel ** code. this can happen if there is no 184130803Smarcel ** source available: 185130803Smarcel ** 1. if the source file is in another dir OR 186130803Smarcel ** 2. if target was compiled without -g 187130803Smarcel ** We still want to show the assembly though! 188130803Smarcel */ 189130803Smarcel addr = tui_get_begin_asm_address (); 190130803Smarcel tui_set_win_focus_to (TUI_DISASM_WIN); 191130803Smarcel layout_def->display_mode = DISASSEM_WIN; 192130803Smarcel layout_def->split = FALSE; 193130803Smarcel break; 194130803Smarcel case SRC_DISASSEM_COMMAND: 195130803Smarcel /* the previous layout was not showing 196130803Smarcel ** code. this can happen if there is no 197130803Smarcel ** source available: 198130803Smarcel ** 1. if the source file is in another dir OR 199130803Smarcel ** 2. if target was compiled without -g 200130803Smarcel ** We still want to show the assembly though! 201130803Smarcel */ 202130803Smarcel addr = tui_get_begin_asm_address (); 203130803Smarcel if (win_with_focus == TUI_SRC_WIN) 204130803Smarcel tui_set_win_focus_to (TUI_SRC_WIN); 205130803Smarcel else 206130803Smarcel tui_set_win_focus_to (TUI_DISASM_WIN); 207130803Smarcel layout_def->split = TRUE; 208130803Smarcel break; 209130803Smarcel case SRC_DATA_COMMAND: 210130803Smarcel if (win_with_focus != TUI_DATA_WIN) 211130803Smarcel tui_set_win_focus_to (TUI_SRC_WIN); 212130803Smarcel else 213130803Smarcel tui_set_win_focus_to (TUI_DATA_WIN); 214130803Smarcel layout_def->display_mode = SRC_WIN; 215130803Smarcel layout_def->split = FALSE; 216130803Smarcel break; 217130803Smarcel case DISASSEM_DATA_COMMAND: 218130803Smarcel /* the previous layout was not showing 219130803Smarcel ** code. this can happen if there is no 220130803Smarcel ** source available: 221130803Smarcel ** 1. if the source file is in another dir OR 222130803Smarcel ** 2. if target was compiled without -g 223130803Smarcel ** We still want to show the assembly though! 224130803Smarcel */ 225130803Smarcel addr = tui_get_begin_asm_address (); 226130803Smarcel if (win_with_focus != TUI_DATA_WIN) 227130803Smarcel tui_set_win_focus_to (TUI_DISASM_WIN); 228130803Smarcel else 229130803Smarcel tui_set_win_focus_to (TUI_DATA_WIN); 230130803Smarcel layout_def->display_mode = DISASSEM_WIN; 231130803Smarcel layout_def->split = FALSE; 232130803Smarcel break; 233130803Smarcel default: 234130803Smarcel break; 235130803Smarcel } 236130803Smarcel } 237130803Smarcel if (new_win_with_focus != (struct tui_win_info *) NULL) 238130803Smarcel tui_set_win_focus_to (new_win_with_focus); 239130803Smarcel /* 240130803Smarcel ** Now update the window content 241130803Smarcel */ 242130803Smarcel if (!regs_populate && 243130803Smarcel (new_layout == SRC_DATA_COMMAND || 244130803Smarcel new_layout == DISASSEM_DATA_COMMAND)) 245130803Smarcel tui_display_all_data (); 246130803Smarcel 247130803Smarcel tui_update_source_windows_with_addr (addr); 248130803Smarcel } 249130803Smarcel if (regs_populate) 250130803Smarcel { 251130803Smarcel tui_show_registers (TUI_DATA_WIN->detail.data_display_info.current_group); 252130803Smarcel } 253130803Smarcel } 254130803Smarcel } 255130803Smarcel else 256130803Smarcel status = TUI_FAILURE; 257130803Smarcel 258130803Smarcel return status; 259130803Smarcel} 260130803Smarcel 261130803Smarcel/* Add the specified window to the layout in a logical way. This 262130803Smarcel means setting up the most logical layout given the window to be 263130803Smarcel added. */ 264130803Smarcelvoid 265130803Smarceltui_add_win_to_layout (enum tui_win_type type) 266130803Smarcel{ 267130803Smarcel enum tui_layout_type cur_layout = tui_current_layout (); 268130803Smarcel 269130803Smarcel switch (type) 270130803Smarcel { 271130803Smarcel case SRC_WIN: 272130803Smarcel if (cur_layout != SRC_COMMAND && 273130803Smarcel cur_layout != SRC_DISASSEM_COMMAND && 274130803Smarcel cur_layout != SRC_DATA_COMMAND) 275130803Smarcel { 276130803Smarcel tui_clear_source_windows_detail (); 277130803Smarcel if (cur_layout == DISASSEM_DATA_COMMAND) 278130803Smarcel show_layout (SRC_DATA_COMMAND); 279130803Smarcel else 280130803Smarcel show_layout (SRC_COMMAND); 281130803Smarcel } 282130803Smarcel break; 283130803Smarcel case DISASSEM_WIN: 284130803Smarcel if (cur_layout != DISASSEM_COMMAND && 285130803Smarcel cur_layout != SRC_DISASSEM_COMMAND && 286130803Smarcel cur_layout != DISASSEM_DATA_COMMAND) 287130803Smarcel { 288130803Smarcel tui_clear_source_windows_detail (); 289130803Smarcel if (cur_layout == SRC_DATA_COMMAND) 290130803Smarcel show_layout (DISASSEM_DATA_COMMAND); 291130803Smarcel else 292130803Smarcel show_layout (DISASSEM_COMMAND); 293130803Smarcel } 294130803Smarcel break; 295130803Smarcel case DATA_WIN: 296130803Smarcel if (cur_layout != SRC_DATA_COMMAND && 297130803Smarcel cur_layout != DISASSEM_DATA_COMMAND) 298130803Smarcel { 299130803Smarcel if (cur_layout == DISASSEM_COMMAND) 300130803Smarcel show_layout (DISASSEM_DATA_COMMAND); 301130803Smarcel else 302130803Smarcel show_layout (SRC_DATA_COMMAND); 303130803Smarcel } 304130803Smarcel break; 305130803Smarcel default: 306130803Smarcel break; 307130803Smarcel } 308130803Smarcel} 309130803Smarcel 310130803Smarcel 311130803Smarcel/* Answer the height of a window. If it hasn't been created yet, 312130803Smarcel answer what the height of a window would be based upon its type and 313130803Smarcel the layout. */ 314130803Smarcelint 315130803Smarceltui_default_win_height (enum tui_win_type type, enum tui_layout_type layout) 316130803Smarcel{ 317130803Smarcel int h; 318130803Smarcel 319130803Smarcel if (tui_win_list[type] != (struct tui_win_info *) NULL) 320130803Smarcel h = tui_win_list[type]->generic.height; 321130803Smarcel else 322130803Smarcel { 323130803Smarcel switch (layout) 324130803Smarcel { 325130803Smarcel case SRC_COMMAND: 326130803Smarcel case DISASSEM_COMMAND: 327130803Smarcel if (TUI_CMD_WIN == NULL) 328130803Smarcel h = tui_term_height () / 2; 329130803Smarcel else 330130803Smarcel h = tui_term_height () - TUI_CMD_WIN->generic.height; 331130803Smarcel break; 332130803Smarcel case SRC_DISASSEM_COMMAND: 333130803Smarcel case SRC_DATA_COMMAND: 334130803Smarcel case DISASSEM_DATA_COMMAND: 335130803Smarcel if (TUI_CMD_WIN == NULL) 336130803Smarcel h = tui_term_height () / 3; 337130803Smarcel else 338130803Smarcel h = (tui_term_height () - TUI_CMD_WIN->generic.height) / 2; 339130803Smarcel break; 340130803Smarcel default: 341130803Smarcel h = 0; 342130803Smarcel break; 343130803Smarcel } 344130803Smarcel } 345130803Smarcel 346130803Smarcel return h; 347130803Smarcel} 348130803Smarcel 349130803Smarcel 350130803Smarcel/* Answer the height of a window. If it hasn't been created yet, 351130803Smarcel answer what the height of a window would be based upon its type and 352130803Smarcel the layout. */ 353130803Smarcelint 354130803Smarceltui_default_win_viewport_height (enum tui_win_type type, 355130803Smarcel enum tui_layout_type layout) 356130803Smarcel{ 357130803Smarcel int h; 358130803Smarcel 359130803Smarcel h = tui_default_win_height (type, layout); 360130803Smarcel 361130803Smarcel if (tui_win_list[type] == TUI_CMD_WIN) 362130803Smarcel h -= 1; 363130803Smarcel else 364130803Smarcel h -= 2; 365130803Smarcel 366130803Smarcel return h; 367130803Smarcel} 368130803Smarcel 369130803Smarcel 370130803Smarcel/* Function to initialize gdb commands, for tui window layout 371130803Smarcel manipulation. */ 372130803Smarcelvoid 373130803Smarcel_initialize_tui_layout (void) 374130803Smarcel{ 375130803Smarcel add_com ("layout", class_tui, tui_layout_command, 376130803Smarcel "Change the layout of windows.\n\ 377130803SmarcelUsage: layout prev | next | <layout_name> \n\ 378130803SmarcelLayout names are:\n\ 379130803Smarcel src : Displays source and command windows.\n\ 380130803Smarcel asm : Displays disassembly and command windows.\n\ 381130803Smarcel split : Displays source, disassembly and command windows.\n\ 382130803Smarcel regs : Displays register window. If existing layout\n\ 383130803Smarcel is source/command or assembly/command, the \n\ 384130803Smarcel register window is displayed. If the\n\ 385130803Smarcel source/assembly/command (split) is displayed, \n\ 386130803Smarcel the register window is displayed with \n\ 387130803Smarcel the window that has current logical focus.\n"); 388130803Smarcel if (xdb_commands) 389130803Smarcel { 390130803Smarcel add_com ("td", class_tui, tui_toggle_layout_command, 391130803Smarcel "Toggle between Source/Command and Disassembly/Command layouts.\n"); 392130803Smarcel add_com ("ts", class_tui, tui_toggle_split_layout_command, 393130803Smarcel "Toggle between Source/Command or Disassembly/Command and \n\ 394130803SmarcelSource/Disassembly/Command layouts.\n"); 395130803Smarcel } 396130803Smarcel} 397130803Smarcel 398130803Smarcel 399130803Smarcel/************************* 400130803Smarcel** STATIC LOCAL FUNCTIONS 401130803Smarcel**************************/ 402130803Smarcel 403130803Smarcel 404130803Smarcel/* Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA, 405130803Smarcel REGS, $REGS, $GREGS, $FREGS, $SREGS. */ 406130803Smarcelenum tui_status 407130803Smarceltui_set_layout_for_display_command (const char *layout_name) 408130803Smarcel{ 409130803Smarcel enum tui_status status = TUI_SUCCESS; 410130803Smarcel 411130803Smarcel if (layout_name != (char *) NULL) 412130803Smarcel { 413130803Smarcel int i; 414130803Smarcel char *buf_ptr; 415130803Smarcel enum tui_layout_type new_layout = UNDEFINED_LAYOUT; 416130803Smarcel enum tui_register_display_type dpy_type = TUI_UNDEFINED_REGS; 417130803Smarcel enum tui_layout_type cur_layout = tui_current_layout (); 418130803Smarcel 419130803Smarcel buf_ptr = (char *) xstrdup (layout_name); 420130803Smarcel for (i = 0; (i < strlen (layout_name)); i++) 421130803Smarcel buf_ptr[i] = toupper (buf_ptr[i]); 422130803Smarcel 423130803Smarcel /* First check for ambiguous input */ 424130803Smarcel if (strlen (buf_ptr) <= 1 && (*buf_ptr == 'S' || *buf_ptr == '$')) 425130803Smarcel { 426130803Smarcel warning ("Ambiguous command input.\n"); 427130803Smarcel status = TUI_FAILURE; 428130803Smarcel } 429130803Smarcel else 430130803Smarcel { 431130803Smarcel if (subset_compare (buf_ptr, "SRC")) 432130803Smarcel new_layout = SRC_COMMAND; 433130803Smarcel else if (subset_compare (buf_ptr, "ASM")) 434130803Smarcel new_layout = DISASSEM_COMMAND; 435130803Smarcel else if (subset_compare (buf_ptr, "SPLIT")) 436130803Smarcel new_layout = SRC_DISASSEM_COMMAND; 437130803Smarcel else if (subset_compare (buf_ptr, "REGS") || 438130803Smarcel subset_compare (buf_ptr, TUI_GENERAL_SPECIAL_REGS_NAME) || 439130803Smarcel subset_compare (buf_ptr, TUI_GENERAL_REGS_NAME) || 440130803Smarcel subset_compare (buf_ptr, TUI_FLOAT_REGS_NAME) || 441130803Smarcel subset_compare (buf_ptr, TUI_SPECIAL_REGS_NAME)) 442130803Smarcel { 443130803Smarcel if (cur_layout == SRC_COMMAND || cur_layout == SRC_DATA_COMMAND) 444130803Smarcel new_layout = SRC_DATA_COMMAND; 445130803Smarcel else 446130803Smarcel new_layout = DISASSEM_DATA_COMMAND; 447130803Smarcel 448130803Smarcel/* could ifdef out the following code. when compile with -z, there are null 449130803Smarcel pointer references that cause a core dump if 'layout regs' is the first 450130803Smarcel layout command issued by the user. HP has asked us to hook up this code 451130803Smarcel - edie epstein 452130803Smarcel */ 453130803Smarcel if (subset_compare (buf_ptr, TUI_FLOAT_REGS_NAME)) 454130803Smarcel { 455130803Smarcel if (TUI_DATA_WIN->detail.data_display_info.regs_display_type != 456130803Smarcel TUI_SFLOAT_REGS && 457130803Smarcel TUI_DATA_WIN->detail.data_display_info.regs_display_type != 458130803Smarcel TUI_DFLOAT_REGS) 459130803Smarcel dpy_type = TUI_SFLOAT_REGS; 460130803Smarcel else 461130803Smarcel dpy_type = 462130803Smarcel TUI_DATA_WIN->detail.data_display_info.regs_display_type; 463130803Smarcel } 464130803Smarcel else if (subset_compare (buf_ptr, 465130803Smarcel TUI_GENERAL_SPECIAL_REGS_NAME)) 466130803Smarcel dpy_type = TUI_GENERAL_AND_SPECIAL_REGS; 467130803Smarcel else if (subset_compare (buf_ptr, TUI_GENERAL_REGS_NAME)) 468130803Smarcel dpy_type = TUI_GENERAL_REGS; 469130803Smarcel else if (subset_compare (buf_ptr, TUI_SPECIAL_REGS_NAME)) 470130803Smarcel dpy_type = TUI_SPECIAL_REGS; 471130803Smarcel else if (TUI_DATA_WIN) 472130803Smarcel { 473130803Smarcel if (TUI_DATA_WIN->detail.data_display_info.regs_display_type != 474130803Smarcel TUI_UNDEFINED_REGS) 475130803Smarcel dpy_type = 476130803Smarcel TUI_DATA_WIN->detail.data_display_info.regs_display_type; 477130803Smarcel else 478130803Smarcel dpy_type = TUI_GENERAL_REGS; 479130803Smarcel } 480130803Smarcel 481130803Smarcel/* end of potential ifdef 482130803Smarcel */ 483130803Smarcel 484130803Smarcel/* if ifdefed out code above, then assume that the user wishes to display the 485130803Smarcel general purpose registers 486130803Smarcel */ 487130803Smarcel 488130803Smarcel/* dpy_type = TUI_GENERAL_REGS; 489130803Smarcel */ 490130803Smarcel } 491130803Smarcel else if (subset_compare (buf_ptr, "NEXT")) 492130803Smarcel new_layout = next_layout (); 493130803Smarcel else if (subset_compare (buf_ptr, "PREV")) 494130803Smarcel new_layout = prev_layout (); 495130803Smarcel else 496130803Smarcel status = TUI_FAILURE; 497130803Smarcel xfree (buf_ptr); 498130803Smarcel 499130803Smarcel tui_set_layout (new_layout, dpy_type); 500130803Smarcel } 501130803Smarcel } 502130803Smarcel else 503130803Smarcel status = TUI_FAILURE; 504130803Smarcel 505130803Smarcel return status; 506130803Smarcel} 507130803Smarcel 508130803Smarcel 509130803Smarcelstatic CORE_ADDR 510130803Smarcelextract_display_start_addr (void) 511130803Smarcel{ 512130803Smarcel enum tui_layout_type cur_layout = tui_current_layout (); 513130803Smarcel CORE_ADDR addr; 514130803Smarcel CORE_ADDR pc; 515130803Smarcel struct symtab_and_line cursal = get_current_source_symtab_and_line (); 516130803Smarcel 517130803Smarcel switch (cur_layout) 518130803Smarcel { 519130803Smarcel case SRC_COMMAND: 520130803Smarcel case SRC_DATA_COMMAND: 521130803Smarcel find_line_pc (cursal.symtab, 522130803Smarcel TUI_SRC_WIN->detail.source_info.start_line_or_addr.line_no, 523130803Smarcel &pc); 524130803Smarcel addr = pc; 525130803Smarcel break; 526130803Smarcel case DISASSEM_COMMAND: 527130803Smarcel case SRC_DISASSEM_COMMAND: 528130803Smarcel case DISASSEM_DATA_COMMAND: 529130803Smarcel addr = TUI_DISASM_WIN->detail.source_info.start_line_or_addr.addr; 530130803Smarcel break; 531130803Smarcel default: 532130803Smarcel addr = 0; 533130803Smarcel break; 534130803Smarcel } 535130803Smarcel 536130803Smarcel return addr; 537130803Smarcel} 538130803Smarcel 539130803Smarcel 540130803Smarcelstatic void 541130803Smarceltui_handle_xdb_layout (struct tui_layout_def * layout_def) 542130803Smarcel{ 543130803Smarcel if (layout_def->split) 544130803Smarcel { 545130803Smarcel tui_set_layout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS); 546130803Smarcel tui_set_win_focus_to (tui_win_list[layout_def->display_mode]); 547130803Smarcel } 548130803Smarcel else 549130803Smarcel { 550130803Smarcel if (layout_def->display_mode == SRC_WIN) 551130803Smarcel tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS); 552130803Smarcel else 553130803Smarcel tui_set_layout (DISASSEM_DATA_COMMAND, layout_def->regs_display_type); 554130803Smarcel } 555130803Smarcel} 556130803Smarcel 557130803Smarcel 558130803Smarcelstatic void 559130803Smarceltui_toggle_layout_command (char *arg, int from_tty) 560130803Smarcel{ 561130803Smarcel struct tui_layout_def * layout_def = tui_layout_def (); 562130803Smarcel 563130803Smarcel /* Make sure the curses mode is enabled. */ 564130803Smarcel tui_enable (); 565130803Smarcel if (layout_def->display_mode == SRC_WIN) 566130803Smarcel layout_def->display_mode = DISASSEM_WIN; 567130803Smarcel else 568130803Smarcel layout_def->display_mode = SRC_WIN; 569130803Smarcel 570130803Smarcel if (!layout_def->split) 571130803Smarcel tui_handle_xdb_layout (layout_def); 572130803Smarcel} 573130803Smarcel 574130803Smarcel 575130803Smarcelstatic void 576130803Smarceltui_toggle_split_layout_command (char *arg, int from_tty) 577130803Smarcel{ 578130803Smarcel struct tui_layout_def * layout_def = tui_layout_def (); 579130803Smarcel 580130803Smarcel /* Make sure the curses mode is enabled. */ 581130803Smarcel tui_enable (); 582130803Smarcel layout_def->split = (!layout_def->split); 583130803Smarcel tui_handle_xdb_layout (layout_def); 584130803Smarcel} 585130803Smarcel 586130803Smarcel 587130803Smarcelstatic void 588130803Smarceltui_layout_command (char *arg, int from_tty) 589130803Smarcel{ 590130803Smarcel /* Make sure the curses mode is enabled. */ 591130803Smarcel tui_enable (); 592130803Smarcel 593130803Smarcel /* Switch to the selected layout. */ 594130803Smarcel if (tui_set_layout_for_display_command (arg) != TUI_SUCCESS) 595130803Smarcel warning ("Invalid layout specified.\n%s", LAYOUT_USAGE); 596130803Smarcel 597130803Smarcel} 598130803Smarcel 599130803Smarcel/* Answer the previous layout to cycle to. */ 600130803Smarcelstatic enum tui_layout_type 601130803Smarcelnext_layout (void) 602130803Smarcel{ 603130803Smarcel enum tui_layout_type new_layout; 604130803Smarcel 605130803Smarcel new_layout = tui_current_layout (); 606130803Smarcel if (new_layout == UNDEFINED_LAYOUT) 607130803Smarcel new_layout = SRC_COMMAND; 608130803Smarcel else 609130803Smarcel { 610130803Smarcel new_layout++; 611130803Smarcel if (new_layout == UNDEFINED_LAYOUT) 612130803Smarcel new_layout = SRC_COMMAND; 613130803Smarcel } 614130803Smarcel 615130803Smarcel return new_layout; 616130803Smarcel} 617130803Smarcel 618130803Smarcel 619130803Smarcel/* Answer the next layout to cycle to. */ 620130803Smarcelstatic enum tui_layout_type 621130803Smarcelprev_layout (void) 622130803Smarcel{ 623130803Smarcel enum tui_layout_type new_layout; 624130803Smarcel 625130803Smarcel new_layout = tui_current_layout (); 626130803Smarcel if (new_layout == SRC_COMMAND) 627130803Smarcel new_layout = DISASSEM_DATA_COMMAND; 628130803Smarcel else 629130803Smarcel { 630130803Smarcel new_layout--; 631130803Smarcel if (new_layout == UNDEFINED_LAYOUT) 632130803Smarcel new_layout = DISASSEM_DATA_COMMAND; 633130803Smarcel } 634130803Smarcel 635130803Smarcel return new_layout; 636130803Smarcel} 637130803Smarcel 638130803Smarcel 639130803Smarcel 640130803Smarcelstatic void 641130803Smarcelmake_command_window (struct tui_win_info * * win_info_ptr, int height, int origin_y) 642130803Smarcel{ 643130803Smarcel init_and_make_win ((void **) win_info_ptr, 644130803Smarcel CMD_WIN, 645130803Smarcel height, 646130803Smarcel tui_term_width (), 647130803Smarcel 0, 648130803Smarcel origin_y, 649130803Smarcel DONT_BOX_WINDOW); 650130803Smarcel 651130803Smarcel (*win_info_ptr)->can_highlight = FALSE; 652130803Smarcel} 653130803Smarcel 654130803Smarcel 655130803Smarcel/* 656130803Smarcel ** make_source_window(). 657130803Smarcel */ 658130803Smarcelstatic void 659130803Smarcelmake_source_window (struct tui_win_info * * win_info_ptr, int height, int origin_y) 660130803Smarcel{ 661130803Smarcel make_source_or_disasm_window (win_info_ptr, SRC_WIN, height, origin_y); 662130803Smarcel 663130803Smarcel return; 664130803Smarcel} /* make_source_window */ 665130803Smarcel 666130803Smarcel 667130803Smarcel/* 668130803Smarcel ** make_disasm_window(). 669130803Smarcel */ 670130803Smarcelstatic void 671130803Smarcelmake_disasm_window (struct tui_win_info * * win_info_ptr, int height, int origin_y) 672130803Smarcel{ 673130803Smarcel make_source_or_disasm_window (win_info_ptr, DISASSEM_WIN, height, origin_y); 674130803Smarcel 675130803Smarcel return; 676130803Smarcel} /* make_disasm_window */ 677130803Smarcel 678130803Smarcel 679130803Smarcelstatic void 680130803Smarcelmake_data_window (struct tui_win_info * * win_info_ptr, int height, int origin_y) 681130803Smarcel{ 682130803Smarcel init_and_make_win ((void **) win_info_ptr, 683130803Smarcel DATA_WIN, 684130803Smarcel height, 685130803Smarcel tui_term_width (), 686130803Smarcel 0, 687130803Smarcel origin_y, 688130803Smarcel BOX_WINDOW); 689130803Smarcel} 690130803Smarcel 691130803Smarcel 692130803Smarcel 693130803Smarcel/* Show the Source/Command layout. */ 694130803Smarcelstatic void 695130803Smarcelshow_source_command (void) 696130803Smarcel{ 697130803Smarcel show_source_or_disasm_and_command (SRC_COMMAND); 698130803Smarcel} 699130803Smarcel 700130803Smarcel 701130803Smarcel/* Show the Dissassem/Command layout. */ 702130803Smarcelstatic void 703130803Smarcelshow_disasm_command (void) 704130803Smarcel{ 705130803Smarcel show_source_or_disasm_and_command (DISASSEM_COMMAND); 706130803Smarcel} 707130803Smarcel 708130803Smarcel 709130803Smarcel/* Show the Source/Disassem/Command layout. */ 710130803Smarcelstatic void 711130803Smarcelshow_source_disasm_command (void) 712130803Smarcel{ 713130803Smarcel if (tui_current_layout () != SRC_DISASSEM_COMMAND) 714130803Smarcel { 715130803Smarcel int cmd_height, src_height, asm_height; 716130803Smarcel 717130803Smarcel if (TUI_CMD_WIN != NULL) 718130803Smarcel cmd_height = TUI_CMD_WIN->generic.height; 719130803Smarcel else 720130803Smarcel cmd_height = tui_term_height () / 3; 721130803Smarcel 722130803Smarcel src_height = (tui_term_height () - cmd_height) / 2; 723130803Smarcel asm_height = tui_term_height () - (src_height + cmd_height); 724130803Smarcel 725130803Smarcel if (TUI_SRC_WIN == NULL) 726130803Smarcel make_source_window (&TUI_SRC_WIN, src_height, 0); 727130803Smarcel else 728130803Smarcel { 729130803Smarcel init_gen_win_info (&TUI_SRC_WIN->generic, 730130803Smarcel TUI_SRC_WIN->generic.type, 731130803Smarcel src_height, 732130803Smarcel TUI_SRC_WIN->generic.width, 733130803Smarcel TUI_SRC_WIN->detail.source_info.execution_info->width, 734130803Smarcel 0); 735130803Smarcel TUI_SRC_WIN->can_highlight = TRUE; 736130803Smarcel init_gen_win_info (TUI_SRC_WIN->detail.source_info.execution_info, 737130803Smarcel EXEC_INFO_WIN, 738130803Smarcel src_height, 739130803Smarcel 3, 740130803Smarcel 0, 741130803Smarcel 0); 742130803Smarcel tui_make_visible (&TUI_SRC_WIN->generic); 743130803Smarcel tui_make_visible (TUI_SRC_WIN->detail.source_info.execution_info); 744130803Smarcel TUI_SRC_WIN->detail.source_info.has_locator = FALSE;; 745130803Smarcel } 746130803Smarcel if (TUI_SRC_WIN != NULL) 747130803Smarcel { 748130803Smarcel struct tui_gen_win_info * locator = tui_locator_win_info_ptr (); 749130803Smarcel 750130803Smarcel tui_show_source_content (TUI_SRC_WIN); 751130803Smarcel if (TUI_DISASM_WIN == NULL) 752130803Smarcel { 753130803Smarcel make_disasm_window (&TUI_DISASM_WIN, asm_height, src_height - 1); 754130803Smarcel init_and_make_win ((void **) & locator, 755130803Smarcel LOCATOR_WIN, 756130803Smarcel 2 /* 1 */ , 757130803Smarcel tui_term_width (), 758130803Smarcel 0, 759130803Smarcel (src_height + asm_height) - 1, 760130803Smarcel DONT_BOX_WINDOW); 761130803Smarcel } 762130803Smarcel else 763130803Smarcel { 764130803Smarcel init_gen_win_info (locator, 765130803Smarcel LOCATOR_WIN, 766130803Smarcel 2 /* 1 */ , 767130803Smarcel tui_term_width (), 768130803Smarcel 0, 769130803Smarcel (src_height + asm_height) - 1); 770130803Smarcel TUI_DISASM_WIN->detail.source_info.has_locator = TRUE; 771130803Smarcel init_gen_win_info ( 772130803Smarcel &TUI_DISASM_WIN->generic, 773130803Smarcel TUI_DISASM_WIN->generic.type, 774130803Smarcel asm_height, 775130803Smarcel TUI_DISASM_WIN->generic.width, 776130803Smarcel TUI_DISASM_WIN->detail.source_info.execution_info->width, 777130803Smarcel src_height - 1); 778130803Smarcel init_gen_win_info (TUI_DISASM_WIN->detail.source_info.execution_info, 779130803Smarcel EXEC_INFO_WIN, 780130803Smarcel asm_height, 781130803Smarcel 3, 782130803Smarcel 0, 783130803Smarcel src_height - 1); 784130803Smarcel TUI_DISASM_WIN->can_highlight = TRUE; 785130803Smarcel tui_make_visible (&TUI_DISASM_WIN->generic); 786130803Smarcel tui_make_visible (TUI_DISASM_WIN->detail.source_info.execution_info); 787130803Smarcel } 788130803Smarcel if (TUI_DISASM_WIN != NULL) 789130803Smarcel { 790130803Smarcel TUI_SRC_WIN->detail.source_info.has_locator = FALSE; 791130803Smarcel TUI_DISASM_WIN->detail.source_info.has_locator = TRUE; 792130803Smarcel tui_make_visible (locator); 793130803Smarcel tui_show_locator_content (); 794130803Smarcel tui_show_source_content (TUI_DISASM_WIN); 795130803Smarcel 796130803Smarcel if (TUI_CMD_WIN == NULL) 797130803Smarcel make_command_window (&TUI_CMD_WIN, 798130803Smarcel cmd_height, 799130803Smarcel tui_term_height () - cmd_height); 800130803Smarcel else 801130803Smarcel { 802130803Smarcel init_gen_win_info (&TUI_CMD_WIN->generic, 803130803Smarcel TUI_CMD_WIN->generic.type, 804130803Smarcel TUI_CMD_WIN->generic.height, 805130803Smarcel TUI_CMD_WIN->generic.width, 806130803Smarcel 0, 807130803Smarcel TUI_CMD_WIN->generic.origin.y); 808130803Smarcel TUI_CMD_WIN->can_highlight = FALSE; 809130803Smarcel tui_make_visible (&TUI_CMD_WIN->generic); 810130803Smarcel } 811130803Smarcel if (TUI_CMD_WIN != NULL) 812130803Smarcel tui_refresh_win (&TUI_CMD_WIN->generic); 813130803Smarcel } 814130803Smarcel } 815130803Smarcel tui_set_current_layout_to (SRC_DISASSEM_COMMAND); 816130803Smarcel } 817130803Smarcel} 818130803Smarcel 819130803Smarcel 820130803Smarcel/* Show the Source/Data/Command or the Dissassembly/Data/Command 821130803Smarcel layout. */ 822130803Smarcelstatic void 823130803Smarcelshow_data (enum tui_layout_type new_layout) 824130803Smarcel{ 825130803Smarcel int total_height = (tui_term_height () - TUI_CMD_WIN->generic.height); 826130803Smarcel int src_height, data_height; 827130803Smarcel enum tui_win_type win_type; 828130803Smarcel struct tui_gen_win_info * locator = tui_locator_win_info_ptr (); 829130803Smarcel 830130803Smarcel 831130803Smarcel data_height = total_height / 2; 832130803Smarcel src_height = total_height - data_height; 833130803Smarcel tui_make_all_invisible (); 834130803Smarcel tui_make_invisible (locator); 835130803Smarcel make_data_window (&TUI_DATA_WIN, data_height, 0); 836130803Smarcel TUI_DATA_WIN->can_highlight = TRUE; 837130803Smarcel if (new_layout == SRC_DATA_COMMAND) 838130803Smarcel win_type = SRC_WIN; 839130803Smarcel else 840130803Smarcel win_type = DISASSEM_WIN; 841130803Smarcel if (tui_win_list[win_type] == NULL) 842130803Smarcel { 843130803Smarcel if (win_type == SRC_WIN) 844130803Smarcel make_source_window (&tui_win_list[win_type], src_height, data_height - 1); 845130803Smarcel else 846130803Smarcel make_disasm_window (&tui_win_list[win_type], src_height, data_height - 1); 847130803Smarcel init_and_make_win ((void **) & locator, 848130803Smarcel LOCATOR_WIN, 849130803Smarcel 2 /* 1 */ , 850130803Smarcel tui_term_width (), 851130803Smarcel 0, 852130803Smarcel total_height - 1, 853130803Smarcel DONT_BOX_WINDOW); 854130803Smarcel } 855130803Smarcel else 856130803Smarcel { 857130803Smarcel init_gen_win_info (&tui_win_list[win_type]->generic, 858130803Smarcel tui_win_list[win_type]->generic.type, 859130803Smarcel src_height, 860130803Smarcel tui_win_list[win_type]->generic.width, 861130803Smarcel tui_win_list[win_type]->detail.source_info.execution_info->width, 862130803Smarcel data_height - 1); 863130803Smarcel init_gen_win_info (tui_win_list[win_type]->detail.source_info.execution_info, 864130803Smarcel EXEC_INFO_WIN, 865130803Smarcel src_height, 866130803Smarcel 3, 867130803Smarcel 0, 868130803Smarcel data_height - 1); 869130803Smarcel tui_make_visible (&tui_win_list[win_type]->generic); 870130803Smarcel tui_make_visible (tui_win_list[win_type]->detail.source_info.execution_info); 871130803Smarcel init_gen_win_info (locator, 872130803Smarcel LOCATOR_WIN, 873130803Smarcel 2 /* 1 */ , 874130803Smarcel tui_term_width (), 875130803Smarcel 0, 876130803Smarcel total_height - 1); 877130803Smarcel } 878130803Smarcel tui_win_list[win_type]->detail.source_info.has_locator = TRUE; 879130803Smarcel tui_make_visible (locator); 880130803Smarcel tui_show_locator_content (); 881130803Smarcel tui_add_to_source_windows (tui_win_list[win_type]); 882130803Smarcel tui_set_current_layout_to (new_layout); 883130803Smarcel} 884130803Smarcel 885130803Smarcel/* 886130803Smarcel ** init_gen_win_info(). 887130803Smarcel */ 888130803Smarcelstatic void 889130803Smarcelinit_gen_win_info (struct tui_gen_win_info * win_info, enum tui_win_type type, 890130803Smarcel int height, int width, int origin_x, int origin_y) 891130803Smarcel{ 892130803Smarcel int h = height; 893130803Smarcel 894130803Smarcel win_info->type = type; 895130803Smarcel win_info->width = width; 896130803Smarcel win_info->height = h; 897130803Smarcel if (h > 1) 898130803Smarcel { 899130803Smarcel win_info->viewport_height = h - 1; 900130803Smarcel if (win_info->type != CMD_WIN) 901130803Smarcel win_info->viewport_height--; 902130803Smarcel } 903130803Smarcel else 904130803Smarcel win_info->viewport_height = 1; 905130803Smarcel win_info->origin.x = origin_x; 906130803Smarcel win_info->origin.y = origin_y; 907130803Smarcel 908130803Smarcel return; 909130803Smarcel} /* init_gen_win_info */ 910130803Smarcel 911130803Smarcel/* 912130803Smarcel ** init_and_make_win(). 913130803Smarcel */ 914130803Smarcelstatic void 915130803Smarcelinit_and_make_win (void ** win_info_ptr, enum tui_win_type win_type, 916130803Smarcel int height, int width, int origin_x, int origin_y, int box_it) 917130803Smarcel{ 918130803Smarcel void *opaque_win_info = *win_info_ptr; 919130803Smarcel struct tui_gen_win_info * generic; 920130803Smarcel 921130803Smarcel if (opaque_win_info == NULL) 922130803Smarcel { 923130803Smarcel if (tui_win_is_auxillary (win_type)) 924130803Smarcel opaque_win_info = (void *) tui_alloc_generic_win_info (); 925130803Smarcel else 926130803Smarcel opaque_win_info = (void *) tui_alloc_win_info (win_type); 927130803Smarcel } 928130803Smarcel if (tui_win_is_auxillary (win_type)) 929130803Smarcel generic = (struct tui_gen_win_info *) opaque_win_info; 930130803Smarcel else 931130803Smarcel generic = &((struct tui_win_info *) opaque_win_info)->generic; 932130803Smarcel 933130803Smarcel if (opaque_win_info != NULL) 934130803Smarcel { 935130803Smarcel init_gen_win_info (generic, win_type, height, width, origin_x, origin_y); 936130803Smarcel if (!tui_win_is_auxillary (win_type)) 937130803Smarcel { 938130803Smarcel if (generic->type == CMD_WIN) 939130803Smarcel ((struct tui_win_info *) opaque_win_info)->can_highlight = FALSE; 940130803Smarcel else 941130803Smarcel ((struct tui_win_info *) opaque_win_info)->can_highlight = TRUE; 942130803Smarcel } 943130803Smarcel tui_make_window (generic, box_it); 944130803Smarcel } 945130803Smarcel *win_info_ptr = opaque_win_info; 946130803Smarcel} 947130803Smarcel 948130803Smarcel 949130803Smarcelstatic void 950130803Smarcelmake_source_or_disasm_window (struct tui_win_info * * win_info_ptr, enum tui_win_type type, 951130803Smarcel int height, int origin_y) 952130803Smarcel{ 953130803Smarcel struct tui_gen_win_info * execution_info = (struct tui_gen_win_info *) NULL; 954130803Smarcel 955130803Smarcel /* 956130803Smarcel ** Create the exeuction info window. 957130803Smarcel */ 958130803Smarcel if (type == SRC_WIN) 959130803Smarcel execution_info = tui_source_exec_info_win_ptr (); 960130803Smarcel else 961130803Smarcel execution_info = tui_disassem_exec_info_win_ptr (); 962130803Smarcel init_and_make_win ((void **) & execution_info, 963130803Smarcel EXEC_INFO_WIN, 964130803Smarcel height, 965130803Smarcel 3, 966130803Smarcel 0, 967130803Smarcel origin_y, 968130803Smarcel DONT_BOX_WINDOW); 969130803Smarcel /* 970130803Smarcel ** Now create the source window. 971130803Smarcel */ 972130803Smarcel init_and_make_win ((void **) win_info_ptr, 973130803Smarcel type, 974130803Smarcel height, 975130803Smarcel tui_term_width () - execution_info->width, 976130803Smarcel execution_info->width, 977130803Smarcel origin_y, 978130803Smarcel BOX_WINDOW); 979130803Smarcel 980130803Smarcel (*win_info_ptr)->detail.source_info.execution_info = execution_info; 981130803Smarcel} 982130803Smarcel 983130803Smarcel 984130803Smarcel/* Show the Source/Command or the Disassem layout. */ 985130803Smarcelstatic void 986130803Smarcelshow_source_or_disasm_and_command (enum tui_layout_type layout_type) 987130803Smarcel{ 988130803Smarcel if (tui_current_layout () != layout_type) 989130803Smarcel { 990130803Smarcel struct tui_win_info * *win_info_ptr; 991130803Smarcel int src_height, cmd_height; 992130803Smarcel struct tui_gen_win_info * locator = tui_locator_win_info_ptr (); 993130803Smarcel 994130803Smarcel if (TUI_CMD_WIN != NULL) 995130803Smarcel cmd_height = TUI_CMD_WIN->generic.height; 996130803Smarcel else 997130803Smarcel cmd_height = tui_term_height () / 3; 998130803Smarcel src_height = tui_term_height () - cmd_height; 999130803Smarcel 1000130803Smarcel 1001130803Smarcel if (layout_type == SRC_COMMAND) 1002130803Smarcel win_info_ptr = &TUI_SRC_WIN; 1003130803Smarcel else 1004130803Smarcel win_info_ptr = &TUI_DISASM_WIN; 1005130803Smarcel 1006130803Smarcel if ((*win_info_ptr) == NULL) 1007130803Smarcel { 1008130803Smarcel if (layout_type == SRC_COMMAND) 1009130803Smarcel make_source_window (win_info_ptr, src_height - 1, 0); 1010130803Smarcel else 1011130803Smarcel make_disasm_window (win_info_ptr, src_height - 1, 0); 1012130803Smarcel init_and_make_win ((void **) & locator, 1013130803Smarcel LOCATOR_WIN, 1014130803Smarcel 2 /* 1 */ , 1015130803Smarcel tui_term_width (), 1016130803Smarcel 0, 1017130803Smarcel src_height - 1, 1018130803Smarcel DONT_BOX_WINDOW); 1019130803Smarcel } 1020130803Smarcel else 1021130803Smarcel { 1022130803Smarcel init_gen_win_info (locator, 1023130803Smarcel LOCATOR_WIN, 1024130803Smarcel 2 /* 1 */ , 1025130803Smarcel tui_term_width (), 1026130803Smarcel 0, 1027130803Smarcel src_height - 1); 1028130803Smarcel (*win_info_ptr)->detail.source_info.has_locator = TRUE; 1029130803Smarcel init_gen_win_info ( 1030130803Smarcel &(*win_info_ptr)->generic, 1031130803Smarcel (*win_info_ptr)->generic.type, 1032130803Smarcel src_height - 1, 1033130803Smarcel (*win_info_ptr)->generic.width, 1034130803Smarcel (*win_info_ptr)->detail.source_info.execution_info->width, 1035130803Smarcel 0); 1036130803Smarcel init_gen_win_info ((*win_info_ptr)->detail.source_info.execution_info, 1037130803Smarcel EXEC_INFO_WIN, 1038130803Smarcel src_height - 1, 1039130803Smarcel 3, 1040130803Smarcel 0, 1041130803Smarcel 0); 1042130803Smarcel (*win_info_ptr)->can_highlight = TRUE; 1043130803Smarcel tui_make_visible (&(*win_info_ptr)->generic); 1044130803Smarcel tui_make_visible ((*win_info_ptr)->detail.source_info.execution_info); 1045130803Smarcel } 1046130803Smarcel if ((*win_info_ptr) != NULL) 1047130803Smarcel { 1048130803Smarcel (*win_info_ptr)->detail.source_info.has_locator = TRUE; 1049130803Smarcel tui_make_visible (locator); 1050130803Smarcel tui_show_locator_content (); 1051130803Smarcel tui_show_source_content (*win_info_ptr); 1052130803Smarcel 1053130803Smarcel if (TUI_CMD_WIN == NULL) 1054130803Smarcel { 1055130803Smarcel make_command_window (&TUI_CMD_WIN, cmd_height, src_height); 1056130803Smarcel tui_refresh_win (&TUI_CMD_WIN->generic); 1057130803Smarcel } 1058130803Smarcel else 1059130803Smarcel { 1060130803Smarcel init_gen_win_info (&TUI_CMD_WIN->generic, 1061130803Smarcel TUI_CMD_WIN->generic.type, 1062130803Smarcel TUI_CMD_WIN->generic.height, 1063130803Smarcel TUI_CMD_WIN->generic.width, 1064130803Smarcel TUI_CMD_WIN->generic.origin.x, 1065130803Smarcel TUI_CMD_WIN->generic.origin.y); 1066130803Smarcel TUI_CMD_WIN->can_highlight = FALSE; 1067130803Smarcel tui_make_visible (&TUI_CMD_WIN->generic); 1068130803Smarcel } 1069130803Smarcel } 1070130803Smarcel tui_set_current_layout_to (layout_type); 1071130803Smarcel } 1072130803Smarcel} 1073