2
0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-15 04:31:49 +08:00
binutils-gdb/gdb/tui/tui-layout.c
Andrew Cagney a21fcd8ffb 2004-02-06 Andrew Cagney <cagney@redhat.com>
* tui/tui-win.h: Update copyright.  Include "tui-data.h".
	(struct tui_win_info): Declare.
	(tui_scroll_forward): Rename tuiScrollForward.
	(tui_scroll_backward): Rename tuiScrollBackward.
	(tui_scroll_left): Rename tuiScrollLeft.
	(tui_scroll_right): Rename tuiScrollRight.
	(tui_set_win_focus_to): Rename tuiSetWinFocusTo.
	(tui_resize_all): Rename tuiResizeAll.
	(tui_refresh_all_win): Rename tuiRefreshAll.
	(tui_sigwinch_handler): Rename tuiSigwinchHandler.
	* tui/tui-layout.c, * tui/tui-io.c: Update references.
	* tui/tui-wingeneral.h, * tui/tui.c: Update references.
	* tui/tui-disasm.c, * tui/tui-command.c: Update references.
2004-02-07 01:02:54 +00:00

1141 lines
29 KiB
C

/* TUI layout window management.
Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
Foundation, Inc.
Contributed by Hewlett-Packard Company.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "command.h"
#include "symtab.h"
#include "frame.h"
#include "source.h"
#include <ctype.h>
#include "tui/tui.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-win.h"
#include "tui/tui-winsource.h"
#include "tui/tui-disasm.h"
#ifdef HAVE_NCURSES_H
#include <ncurses.h>
#else
#ifdef HAVE_CURSES_H
#include <curses.h>
#endif
#endif
/*******************************
** Static Local Decls
********************************/
static void showLayout (TuiLayoutType);
static void _initGenWinInfo (TuiGenWinInfoPtr, TuiWinType, int, int, int, int);
static void _initAndMakeWin (Opaque *, TuiWinType, int, int, int, int, int);
static void _showSourceOrDisassemAndCommand (TuiLayoutType);
static void _makeSourceOrDisassemWindow (TuiWinInfoPtr *, TuiWinType, int, int);
static void _makeCommandWindow (TuiWinInfoPtr *, int, int);
static void _makeSourceWindow (TuiWinInfoPtr *, int, int);
static void _makeDisassemWindow (TuiWinInfoPtr *, int, int);
static void _makeDataWindow (TuiWinInfoPtr *, int, int);
static void _showSourceCommand (void);
static void _showDisassemCommand (void);
static void _showSourceDisassemCommand (void);
static void _showData (TuiLayoutType);
static TuiLayoutType _nextLayout (void);
static TuiLayoutType _prevLayout (void);
static void _tuiLayout_command (char *, int);
static void _tuiToggleLayout_command (char *, int);
static void _tuiToggleSplitLayout_command (char *, int);
static CORE_ADDR _extractDisplayStartAddr (void);
static void _tuiHandleXDBLayout (TuiLayoutDefPtr);
/***************************************
** DEFINITIONS
***************************************/
#define LAYOUT_USAGE "Usage: layout prev | next | <layout_name> \n"
/* Show the screen layout defined. */
static void
showLayout (TuiLayoutType layout)
{
TuiLayoutType curLayout = currentLayout ();
if (layout != curLayout)
{
/*
** Since the new layout may cause changes in window size, we
** should free the content and reallocate on next display of
** source/asm
*/
freeAllSourceWinsContent ();
clearSourceWindows ();
if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
{
_showData (layout);
tui_refresh_all (winList);
}
else
{
/* First make the current layout be invisible */
tui_make_all_invisible ();
tui_make_invisible (locatorWinInfoPtr ());
switch (layout)
{
/* Now show the new layout */
case SRC_COMMAND:
_showSourceCommand ();
addToSourceWindows (srcWin);
break;
case DISASSEM_COMMAND:
_showDisassemCommand ();
addToSourceWindows (disassemWin);
break;
case SRC_DISASSEM_COMMAND:
_showSourceDisassemCommand ();
addToSourceWindows (srcWin);
addToSourceWindows (disassemWin);
break;
default:
break;
}
}
}
}
/* Function to set the layout to SRC_COMMAND, DISASSEM_COMMAND,
SRC_DISASSEM_COMMAND, SRC_DATA_COMMAND, or DISASSEM_DATA_COMMAND.
If the layout is SRC_DATA_COMMAND, DISASSEM_DATA_COMMAND, or
UNDEFINED_LAYOUT, then the data window is populated according to
regsDisplayType. */
enum tui_status
tui_set_layout (enum tui_layout_type layoutType,
enum tui_register_display_type regsDisplayType)
{
TuiStatus status = TUI_SUCCESS;
if (layoutType != UNDEFINED_LAYOUT || regsDisplayType != TUI_UNDEFINED_REGS)
{
TuiLayoutType curLayout = currentLayout (), newLayout = UNDEFINED_LAYOUT;
int regsPopulate = FALSE;
CORE_ADDR addr = _extractDisplayStartAddr ();
TuiWinInfoPtr newWinWithFocus = (TuiWinInfoPtr) NULL, winWithFocus = tuiWinWithFocus ();
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
if (layoutType == UNDEFINED_LAYOUT &&
regsDisplayType != TUI_UNDEFINED_REGS)
{
if (curLayout == SRC_DISASSEM_COMMAND)
newLayout = DISASSEM_DATA_COMMAND;
else if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
newLayout = SRC_DATA_COMMAND;
else if (curLayout == DISASSEM_COMMAND ||
curLayout == DISASSEM_DATA_COMMAND)
newLayout = DISASSEM_DATA_COMMAND;
}
else
newLayout = layoutType;
regsPopulate = (newLayout == SRC_DATA_COMMAND ||
newLayout == DISASSEM_DATA_COMMAND ||
regsDisplayType != TUI_UNDEFINED_REGS);
if (newLayout != curLayout || regsDisplayType != TUI_UNDEFINED_REGS)
{
if (newLayout != curLayout)
{
showLayout (newLayout);
/*
** Now determine where focus should be
*/
if (winWithFocus != cmdWin)
{
switch (newLayout)
{
case SRC_COMMAND:
tui_set_win_focus_to (srcWin);
layoutDef->displayMode = SRC_WIN;
layoutDef->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!
*/
addr = tui_get_begin_asm_address ();
tui_set_win_focus_to (disassemWin);
layoutDef->displayMode = DISASSEM_WIN;
layoutDef->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!
*/
addr = tui_get_begin_asm_address ();
if (winWithFocus == srcWin)
tui_set_win_focus_to (srcWin);
else
tui_set_win_focus_to (disassemWin);
layoutDef->split = TRUE;
break;
case SRC_DATA_COMMAND:
if (winWithFocus != dataWin)
tui_set_win_focus_to (srcWin);
else
tui_set_win_focus_to (dataWin);
layoutDef->displayMode = SRC_WIN;
layoutDef->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!
*/
addr = tui_get_begin_asm_address ();
if (winWithFocus != dataWin)
tui_set_win_focus_to (disassemWin);
else
tui_set_win_focus_to (dataWin);
layoutDef->displayMode = DISASSEM_WIN;
layoutDef->split = FALSE;
break;
default:
break;
}
}
if (newWinWithFocus != (TuiWinInfoPtr) NULL)
tui_set_win_focus_to (newWinWithFocus);
/*
** Now update the window content
*/
if (!regsPopulate &&
(newLayout == SRC_DATA_COMMAND ||
newLayout == DISASSEM_DATA_COMMAND))
tui_display_all_data ();
tui_update_source_windows_with_addr (addr);
}
if (regsPopulate)
{
layoutDef->regsDisplayType =
(regsDisplayType == TUI_UNDEFINED_REGS ?
TUI_GENERAL_REGS : regsDisplayType);
tui_show_registers (layoutDef->regsDisplayType);
}
}
}
else
status = TUI_FAILURE;
return status;
}
/* Add the specified window to the layout in a logical way. This
means setting up the most logical layout given the window to be
added. */
void
tui_add_win_to_layout (enum tui_win_type type)
{
TuiLayoutType curLayout = currentLayout ();
switch (type)
{
case SRC_WIN:
if (curLayout != SRC_COMMAND &&
curLayout != SRC_DISASSEM_COMMAND &&
curLayout != SRC_DATA_COMMAND)
{
clearSourceWindowsDetail ();
if (curLayout == DISASSEM_DATA_COMMAND)
showLayout (SRC_DATA_COMMAND);
else
showLayout (SRC_COMMAND);
}
break;
case DISASSEM_WIN:
if (curLayout != DISASSEM_COMMAND &&
curLayout != SRC_DISASSEM_COMMAND &&
curLayout != DISASSEM_DATA_COMMAND)
{
clearSourceWindowsDetail ();
if (curLayout == SRC_DATA_COMMAND)
showLayout (DISASSEM_DATA_COMMAND);
else
showLayout (DISASSEM_COMMAND);
}
break;
case DATA_WIN:
if (curLayout != SRC_DATA_COMMAND &&
curLayout != DISASSEM_DATA_COMMAND)
{
if (curLayout == DISASSEM_COMMAND)
showLayout (DISASSEM_DATA_COMMAND);
else
showLayout (SRC_DATA_COMMAND);
}
break;
default:
break;
}
return;
} /* tuiAddWinToLayout */
/*
** tuiDefaultWinHeight().
** 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
tuiDefaultWinHeight (TuiWinType type, TuiLayoutType layout)
{
int h;
if (winList[type] != (TuiWinInfoPtr) NULL)
h = winList[type]->generic.height;
else
{
switch (layout)
{
case SRC_COMMAND:
case DISASSEM_COMMAND:
if (m_winPtrIsNull (cmdWin))
h = termHeight () / 2;
else
h = termHeight () - cmdWin->generic.height;
break;
case SRC_DISASSEM_COMMAND:
case SRC_DATA_COMMAND:
case DISASSEM_DATA_COMMAND:
if (m_winPtrIsNull (cmdWin))
h = termHeight () / 3;
else
h = (termHeight () - cmdWin->generic.height) / 2;
break;
default:
h = 0;
break;
}
}
return h;
} /* tuiDefaultWinHeight */
/* 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 = tuiDefaultWinHeight (type, layout);
if (winList[type] == cmdWin)
h -= 1;
else
h -= 2;
return h;
} /* tuiDefaultWinViewportHeight */
/*
** _initialize_tuiLayout().
** Function to initialize gdb commands, for tui window layout
** manipulation.
*/
void
_initialize_tuiLayout (void)
{
add_com ("layout", class_tui, _tuiLayout_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.\n");
if (xdb_commands)
{
add_com ("td", class_tui, _tuiToggleLayout_command,
"Toggle between Source/Command and Disassembly/Command layouts.\n");
add_com ("ts", class_tui, _tuiToggleSplitLayout_command,
"Toggle between Source/Command or Disassembly/Command and \n\
Source/Disassembly/Command layouts.\n");
}
}
/*************************
** STATIC LOCAL FUNCTIONS
**************************/
/*
** _tuiSetLayoutTo()
** Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA, REGS,
** $REGS, $GREGS, $FREGS, $SREGS.
*/
TuiStatus
tui_set_layout_for_display_command (const char *layoutName)
{
TuiStatus status = TUI_SUCCESS;
if (layoutName != (char *) NULL)
{
register int i;
register char *bufPtr;
TuiLayoutType newLayout = UNDEFINED_LAYOUT;
TuiRegisterDisplayType dpyType = TUI_UNDEFINED_REGS;
TuiLayoutType curLayout = currentLayout ();
bufPtr = (char *) xstrdup (layoutName);
for (i = 0; (i < strlen (layoutName)); i++)
bufPtr[i] = toupper (bufPtr[i]);
/* First check for ambiguous input */
if (strlen (bufPtr) <= 1 && (*bufPtr == 'S' || *bufPtr == '$'))
{
warning ("Ambiguous command input.\n");
status = TUI_FAILURE;
}
else
{
if (subset_compare (bufPtr, "SRC"))
newLayout = SRC_COMMAND;
else if (subset_compare (bufPtr, "ASM"))
newLayout = DISASSEM_COMMAND;
else if (subset_compare (bufPtr, "SPLIT"))
newLayout = SRC_DISASSEM_COMMAND;
else if (subset_compare (bufPtr, "REGS") ||
subset_compare (bufPtr, TUI_GENERAL_SPECIAL_REGS_NAME) ||
subset_compare (bufPtr, TUI_GENERAL_REGS_NAME) ||
subset_compare (bufPtr, TUI_FLOAT_REGS_NAME) ||
subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
{
if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
newLayout = SRC_DATA_COMMAND;
else
newLayout = DISASSEM_DATA_COMMAND;
/* could ifdef out the following code. when compile with -z, there are null
pointer references that cause a core dump if 'layout regs' is the first
layout command issued by the user. HP has asked us to hook up this code
- edie epstein
*/
if (subset_compare (bufPtr, TUI_FLOAT_REGS_NAME))
{
if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
TUI_SFLOAT_REGS &&
dataWin->detail.dataDisplayInfo.regsDisplayType !=
TUI_DFLOAT_REGS)
dpyType = TUI_SFLOAT_REGS;
else
dpyType =
dataWin->detail.dataDisplayInfo.regsDisplayType;
}
else if (subset_compare (bufPtr,
TUI_GENERAL_SPECIAL_REGS_NAME))
dpyType = TUI_GENERAL_AND_SPECIAL_REGS;
else if (subset_compare (bufPtr, TUI_GENERAL_REGS_NAME))
dpyType = TUI_GENERAL_REGS;
else if (subset_compare (bufPtr, TUI_SPECIAL_REGS_NAME))
dpyType = TUI_SPECIAL_REGS;
else if (dataWin)
{
if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
TUI_UNDEFINED_REGS)
dpyType =
dataWin->detail.dataDisplayInfo.regsDisplayType;
else
dpyType = TUI_GENERAL_REGS;
}
/* end of potential ifdef
*/
/* if ifdefed out code above, then assume that the user wishes to display the
general purpose registers
*/
/* dpyType = TUI_GENERAL_REGS;
*/
}
else if (subset_compare (bufPtr, "NEXT"))
newLayout = _nextLayout ();
else if (subset_compare (bufPtr, "PREV"))
newLayout = _prevLayout ();
else
status = TUI_FAILURE;
xfree (bufPtr);
tui_set_layout (newLayout, dpyType);
}
}
else
status = TUI_FAILURE;
return status;
}
static CORE_ADDR
_extractDisplayStartAddr (void)
{
TuiLayoutType curLayout = currentLayout ();
CORE_ADDR addr;
CORE_ADDR pc;
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
switch (curLayout)
{
case SRC_COMMAND:
case SRC_DATA_COMMAND:
find_line_pc (cursal.symtab,
srcWin->detail.sourceInfo.startLineOrAddr.lineNo,
&pc);
addr = pc;
break;
case DISASSEM_COMMAND:
case SRC_DISASSEM_COMMAND:
case DISASSEM_DATA_COMMAND:
addr = disassemWin->detail.sourceInfo.startLineOrAddr.addr;
break;
default:
addr = 0;
break;
}
return addr;
} /* _extractDisplayStartAddr */
static void
_tuiHandleXDBLayout (TuiLayoutDefPtr layoutDef)
{
if (layoutDef->split)
{
tui_set_layout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
tui_set_win_focus_to (winList[layoutDef->displayMode]);
}
else
{
if (layoutDef->displayMode == SRC_WIN)
tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
else
tui_set_layout (DISASSEM_DATA_COMMAND, layoutDef->regsDisplayType);
}
return;
} /* _tuiHandleXDBLayout */
static void
_tuiToggleLayout_command (char *arg, int fromTTY)
{
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
/* Make sure the curses mode is enabled. */
tui_enable ();
if (layoutDef->displayMode == SRC_WIN)
layoutDef->displayMode = DISASSEM_WIN;
else
layoutDef->displayMode = SRC_WIN;
if (!layoutDef->split)
_tuiHandleXDBLayout (layoutDef);
}
static void
_tuiToggleSplitLayout_command (char *arg, int fromTTY)
{
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
/* Make sure the curses mode is enabled. */
tui_enable ();
layoutDef->split = (!layoutDef->split);
_tuiHandleXDBLayout (layoutDef);
}
static void
_tuiLayout_command (char *arg, int fromTTY)
{
/* Make sure the curses mode is enabled. */
tui_enable ();
/* Switch to the selected layout. */
if (tui_set_layout_for_display_command (arg) != TUI_SUCCESS)
warning ("Invalid layout specified.\n%s", LAYOUT_USAGE);
}
/*
** _nextLayout().
** Answer the previous layout to cycle to.
*/
static TuiLayoutType
_nextLayout (void)
{
TuiLayoutType newLayout;
newLayout = currentLayout ();
if (newLayout == UNDEFINED_LAYOUT)
newLayout = SRC_COMMAND;
else
{
newLayout++;
if (newLayout == UNDEFINED_LAYOUT)
newLayout = SRC_COMMAND;
}
return newLayout;
} /* _nextLayout */
/*
** _prevLayout().
** Answer the next layout to cycle to.
*/
static TuiLayoutType
_prevLayout (void)
{
TuiLayoutType newLayout;
newLayout = currentLayout ();
if (newLayout == SRC_COMMAND)
newLayout = DISASSEM_DATA_COMMAND;
else
{
newLayout--;
if (newLayout == UNDEFINED_LAYOUT)
newLayout = DISASSEM_DATA_COMMAND;
}
return newLayout;
} /* _prevLayout */
/*
** _makeCommandWindow().
*/
static void
_makeCommandWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
{
_initAndMakeWin ((Opaque *) winInfoPtr,
CMD_WIN,
height,
termWidth (),
0,
originY,
DONT_BOX_WINDOW);
(*winInfoPtr)->canHighlight = FALSE;
return;
} /* _makeCommandWindow */
/*
** _makeSourceWindow().
*/
static void
_makeSourceWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
{
_makeSourceOrDisassemWindow (winInfoPtr, SRC_WIN, height, originY);
return;
} /* _makeSourceWindow */
/*
** _makeDisassemWindow().
*/
static void
_makeDisassemWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
{
_makeSourceOrDisassemWindow (winInfoPtr, DISASSEM_WIN, height, originY);
return;
} /* _makeDisassemWindow */
/*
** _makeDataWindow().
*/
static void
_makeDataWindow (TuiWinInfoPtr * winInfoPtr, int height, int originY)
{
_initAndMakeWin ((Opaque *) winInfoPtr,
DATA_WIN,
height,
termWidth (),
0,
originY,
BOX_WINDOW);
return;
} /* _makeDataWindow */
/*
** _showSourceCommand().
** Show the Source/Command layout
*/
static void
_showSourceCommand (void)
{
_showSourceOrDisassemAndCommand (SRC_COMMAND);
return;
} /* _showSourceCommand */
/*
** _showDisassemCommand().
** Show the Dissassem/Command layout
*/
static void
_showDisassemCommand (void)
{
_showSourceOrDisassemAndCommand (DISASSEM_COMMAND);
return;
} /* _showDisassemCommand */
/*
** _showSourceDisassemCommand().
** Show the Source/Disassem/Command layout
*/
static void
_showSourceDisassemCommand (void)
{
if (currentLayout () != SRC_DISASSEM_COMMAND)
{
int cmdHeight, srcHeight, asmHeight;
if (m_winPtrNotNull (cmdWin))
cmdHeight = cmdWin->generic.height;
else
cmdHeight = termHeight () / 3;
srcHeight = (termHeight () - cmdHeight) / 2;
asmHeight = termHeight () - (srcHeight + cmdHeight);
if (m_winPtrIsNull (srcWin))
_makeSourceWindow (&srcWin, srcHeight, 0);
else
{
_initGenWinInfo (&srcWin->generic,
srcWin->generic.type,
srcHeight,
srcWin->generic.width,
srcWin->detail.sourceInfo.executionInfo->width,
0);
srcWin->canHighlight = TRUE;
_initGenWinInfo (srcWin->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
srcHeight,
3,
0,
0);
tui_make_visible (&srcWin->generic);
tui_make_visible (srcWin->detail.sourceInfo.executionInfo);
srcWin->detail.sourceInfo.hasLocator = FALSE;;
}
if (m_winPtrNotNull (srcWin))
{
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
tui_show_source_content (srcWin);
if (m_winPtrIsNull (disassemWin))
{
_makeDisassemWindow (&disassemWin, asmHeight, srcHeight - 1);
_initAndMakeWin ((Opaque *) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
(srcHeight + asmHeight) - 1,
DONT_BOX_WINDOW);
}
else
{
_initGenWinInfo (locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
(srcHeight + asmHeight) - 1);
disassemWin->detail.sourceInfo.hasLocator = TRUE;
_initGenWinInfo (
&disassemWin->generic,
disassemWin->generic.type,
asmHeight,
disassemWin->generic.width,
disassemWin->detail.sourceInfo.executionInfo->width,
srcHeight - 1);
_initGenWinInfo (disassemWin->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
asmHeight,
3,
0,
srcHeight - 1);
disassemWin->canHighlight = TRUE;
tui_make_visible (&disassemWin->generic);
tui_make_visible (disassemWin->detail.sourceInfo.executionInfo);
}
if (m_winPtrNotNull (disassemWin))
{
srcWin->detail.sourceInfo.hasLocator = FALSE;
disassemWin->detail.sourceInfo.hasLocator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
tui_show_source_content (disassemWin);
if (m_winPtrIsNull (cmdWin))
_makeCommandWindow (&cmdWin,
cmdHeight,
termHeight () - cmdHeight);
else
{
_initGenWinInfo (&cmdWin->generic,
cmdWin->generic.type,
cmdWin->generic.height,
cmdWin->generic.width,
0,
cmdWin->generic.origin.y);
cmdWin->canHighlight = FALSE;
tui_make_visible (&cmdWin->generic);
}
if (m_winPtrNotNull (cmdWin))
tui_refresh_win (&cmdWin->generic);
}
}
setCurrentLayoutTo (SRC_DISASSEM_COMMAND);
}
return;
} /* _showSourceDisassemCommand */
/*
** _showData().
** Show the Source/Data/Command or the Dissassembly/Data/Command layout
*/
static void
_showData (TuiLayoutType newLayout)
{
int totalHeight = (termHeight () - cmdWin->generic.height);
int srcHeight, dataHeight;
TuiWinType winType;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
dataHeight = totalHeight / 2;
srcHeight = totalHeight - dataHeight;
tui_make_all_invisible ();
tui_make_invisible (locator);
_makeDataWindow (&dataWin, dataHeight, 0);
dataWin->canHighlight = TRUE;
if (newLayout == SRC_DATA_COMMAND)
winType = SRC_WIN;
else
winType = DISASSEM_WIN;
if (m_winPtrIsNull (winList[winType]))
{
if (winType == SRC_WIN)
_makeSourceWindow (&winList[winType], srcHeight, dataHeight - 1);
else
_makeDisassemWindow (&winList[winType], srcHeight, dataHeight - 1);
_initAndMakeWin ((Opaque *) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
totalHeight - 1,
DONT_BOX_WINDOW);
}
else
{
_initGenWinInfo (&winList[winType]->generic,
winList[winType]->generic.type,
srcHeight,
winList[winType]->generic.width,
winList[winType]->detail.sourceInfo.executionInfo->width,
dataHeight - 1);
_initGenWinInfo (winList[winType]->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
srcHeight,
3,
0,
dataHeight - 1);
tui_make_visible (&winList[winType]->generic);
tui_make_visible (winList[winType]->detail.sourceInfo.executionInfo);
_initGenWinInfo (locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
totalHeight - 1);
}
winList[winType]->detail.sourceInfo.hasLocator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
addToSourceWindows (winList[winType]);
setCurrentLayoutTo (newLayout);
return;
} /* _showData */
/*
** _initGenWinInfo().
*/
static void
_initGenWinInfo (TuiGenWinInfoPtr winInfo, TuiWinType type,
int height, int width, int originX, int originY)
{
int h = height;
winInfo->type = type;
winInfo->width = width;
winInfo->height = h;
if (h > 1)
{
winInfo->viewportHeight = h - 1;
if (winInfo->type != CMD_WIN)
winInfo->viewportHeight--;
}
else
winInfo->viewportHeight = 1;
winInfo->origin.x = originX;
winInfo->origin.y = originY;
return;
} /* _initGenWinInfo */
/*
** _initAndMakeWin().
*/
static void
_initAndMakeWin (Opaque * winInfoPtr, TuiWinType winType,
int height, int width, int originX, int originY, int boxIt)
{
Opaque opaqueWinInfo = *winInfoPtr;
TuiGenWinInfoPtr generic;
if (opaqueWinInfo == (Opaque) NULL)
{
if (m_winIsAuxillary (winType))
opaqueWinInfo = (Opaque) allocGenericWinInfo ();
else
opaqueWinInfo = (Opaque) allocWinInfo (winType);
}
if (m_winIsAuxillary (winType))
generic = (TuiGenWinInfoPtr) opaqueWinInfo;
else
generic = &((TuiWinInfoPtr) opaqueWinInfo)->generic;
if (opaqueWinInfo != (Opaque) NULL)
{
_initGenWinInfo (generic, winType, height, width, originX, originY);
if (!m_winIsAuxillary (winType))
{
if (generic->type == CMD_WIN)
((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = FALSE;
else
((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = TRUE;
}
tui_make_window (generic, boxIt);
}
*winInfoPtr = opaqueWinInfo;
}
/*
** _makeSourceOrDisassemWindow().
*/
static void
_makeSourceOrDisassemWindow (TuiWinInfoPtr * winInfoPtr, TuiWinType type,
int height, int originY)
{
TuiGenWinInfoPtr executionInfo = (TuiGenWinInfoPtr) NULL;
/*
** Create the exeuction info window.
*/
if (type == SRC_WIN)
executionInfo = sourceExecInfoWinPtr ();
else
executionInfo = disassemExecInfoWinPtr ();
_initAndMakeWin ((Opaque *) & executionInfo,
EXEC_INFO_WIN,
height,
3,
0,
originY,
DONT_BOX_WINDOW);
/*
** Now create the source window.
*/
_initAndMakeWin ((Opaque *) winInfoPtr,
type,
height,
termWidth () - executionInfo->width,
executionInfo->width,
originY,
BOX_WINDOW);
(*winInfoPtr)->detail.sourceInfo.executionInfo = executionInfo;
return;
} /* _makeSourceOrDisassemWindow */
/*
** _showSourceOrDisassemAndCommand().
** Show the Source/Command or the Disassem layout
*/
static void
_showSourceOrDisassemAndCommand (TuiLayoutType layoutType)
{
if (currentLayout () != layoutType)
{
TuiWinInfoPtr *winInfoPtr;
int srcHeight, cmdHeight;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
if (m_winPtrNotNull (cmdWin))
cmdHeight = cmdWin->generic.height;
else
cmdHeight = termHeight () / 3;
srcHeight = termHeight () - cmdHeight;
if (layoutType == SRC_COMMAND)
winInfoPtr = &srcWin;
else
winInfoPtr = &disassemWin;
if (m_winPtrIsNull (*winInfoPtr))
{
if (layoutType == SRC_COMMAND)
_makeSourceWindow (winInfoPtr, srcHeight - 1, 0);
else
_makeDisassemWindow (winInfoPtr, srcHeight - 1, 0);
_initAndMakeWin ((Opaque *) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
srcHeight - 1,
DONT_BOX_WINDOW);
}
else
{
_initGenWinInfo (locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
srcHeight - 1);
(*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
_initGenWinInfo (
&(*winInfoPtr)->generic,
(*winInfoPtr)->generic.type,
srcHeight - 1,
(*winInfoPtr)->generic.width,
(*winInfoPtr)->detail.sourceInfo.executionInfo->width,
0);
_initGenWinInfo ((*winInfoPtr)->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
srcHeight - 1,
3,
0,
0);
(*winInfoPtr)->canHighlight = TRUE;
tui_make_visible (&(*winInfoPtr)->generic);
tui_make_visible ((*winInfoPtr)->detail.sourceInfo.executionInfo);
}
if (m_winPtrNotNull (*winInfoPtr))
{
(*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
tui_make_visible (locator);
tui_show_locator_content ();
tui_show_source_content (*winInfoPtr);
if (m_winPtrIsNull (cmdWin))
{
_makeCommandWindow (&cmdWin, cmdHeight, srcHeight);
tui_refresh_win (&cmdWin->generic);
}
else
{
_initGenWinInfo (&cmdWin->generic,
cmdWin->generic.type,
cmdWin->generic.height,
cmdWin->generic.width,
cmdWin->generic.origin.x,
cmdWin->generic.origin.y);
cmdWin->canHighlight = FALSE;
tui_make_visible (&cmdWin->generic);
}
}
setCurrentLayoutTo (layoutType);
}
return;
} /* _showSourceOrDisassemAndCommand */