diff options
Diffstat (limited to 'gdb/tui/tuiWin.c')
| -rw-r--r-- | gdb/tui/tuiWin.c | 1650 |
1 files changed, 1650 insertions, 0 deletions
diff --git a/gdb/tui/tuiWin.c b/gdb/tui/tuiWin.c new file mode 100644 index 00000000000..45bb0f6a4e9 --- /dev/null +++ b/gdb/tui/tuiWin.c @@ -0,0 +1,1650 @@ +/* +** tuiWin.c +** This module contains procedures for handling tui window functions +** like resize, scrolling, scrolling, changing focus, etc. +** +** Author: Susan B. Macchia +*/ + + +#include <string.h> +#include "defs.h" +#include "command.h" +#include "symtab.h" +#include "breakpoint.h" +#include "frame.h" + +#include "tui.h" +#include "tuiData.h" +#include "tuiGeneralWin.h" +#include "tuiStack.h" +#include "tuiSourceWin.h" +#include "tuiDataWin.h" + +/******************************* +** External Declarations +********************************/ +extern void init_page_info (); + +/******************************* +** Static Local Decls +********************************/ +static void _makeVisibleWithNewHeight PARAMS ((TuiWinInfoPtr)); +static void _makeInvisibleAndSetNewHeight PARAMS ((TuiWinInfoPtr, int)); +static TuiStatus _tuiAdjustWinHeights PARAMS ((TuiWinInfoPtr, int)); +static int _newHeightOk PARAMS ((TuiWinInfoPtr, int)); +static void _tuiSetTabWidth_command PARAMS ((char *, int)); +static void _tuiRefreshAll_command PARAMS ((char *, int)); +static void _tuiSetWinHeight_command PARAMS ((char *, int)); +static void _tuiXDBsetWinHeight_command PARAMS ((char *, int)); +static void _tuiAllWindowsInfo PARAMS ((char *, int)); +static void _tuiSetFocus_command PARAMS ((char *, int)); +static void _tuiScrollForward_command PARAMS ((char *, int)); +static void _tuiScrollBackward_command PARAMS ((char *, int)); +static void _tuiScrollLeft_command PARAMS ((char *, int)); +static void _tuiScrollRight_command PARAMS ((char *, int)); +static void _parseScrollingArgs PARAMS ((char *, TuiWinInfoPtr *, int *)); + + +/*************************************** +** DEFINITIONS +***************************************/ +#define WIN_HEIGHT_USAGE "Usage: winheight <win_name> [+ | -] <#lines>\n" +#define XDBWIN_HEIGHT_USAGE "Usage: w <#lines>\n" +#define FOCUS_USAGE "Usage: focus {<win> | next | prev}\n" + +/*************************************** +** PUBLIC FUNCTIONS +***************************************/ + +/* +** _initialize_tuiWin(). +** Function to initialize gdb commands, for tui window manipulation. +*/ +void +_initialize_tuiWin () +{ + if (tui_version) + { + add_com ("refresh", class_tui, _tuiRefreshAll_command, + "Refresh the terminal display.\n"); + if (xdb_commands) + add_com_alias ("U", "refresh", class_tui, 0); + add_com ("tabset", class_tui, _tuiSetTabWidth_command, + "Set the width (in characters) of tab stops.\n\ +Usage: tabset <n>\n"); + add_com ("winheight", class_tui, _tuiSetWinHeight_command, + "Set the height of a specified window.\n\ +Usage: winheight <win_name> [+ | -] <#lines>\n\ +Window names are:\n\ +src : the source window\n\ +cmd : the command window\n\ +asm : the disassembly window\n\ +regs : the register display\n"); + add_com_alias ("wh", "winheight", class_tui, 0); + add_info ("win", _tuiAllWindowsInfo, + "List of all displayed windows.\n"); + add_com ("focus", class_tui, _tuiSetFocus_command, + "Set focus to named window or next/prev window.\n\ +Usage: focus {<win> | next | prev}\n\ +Valid Window names are:\n\ +src : the source window\n\ +asm : the disassembly window\n\ +regs : the register display\n\ +cmd : the command window\n"); + add_com_alias ("fs", "focus", class_tui, 0); + add_com ("+", class_tui, _tuiScrollForward_command, + "Scroll window forward.\nUsage: + [win] [n]\n"); + add_com ("-", class_tui, _tuiScrollBackward_command, + "Scroll window backward.\nUsage: - [win] [n]\n"); + add_com ("<", class_tui, _tuiScrollLeft_command, + "Scroll window forward.\nUsage: < [win] [n]\n"); + add_com (">", class_tui, _tuiScrollRight_command, + "Scroll window backward.\nUsage: > [win] [n]\n"); + if (xdb_commands) + add_com ("w", class_xdb, _tuiXDBsetWinHeight_command, + "XDB compatibility command for setting the height of a command window.\n\ +Usage: w <#lines>\n"); + } + + return; +} /* _intialize_tuiWin */ + + +/* +** tuiClearWinFocusFrom +** Clear the logical focus from winInfo +*/ +void +#ifdef __STDC__ +tuiClearWinFocusFrom ( + TuiWinInfoPtr winInfo) +#else +tuiClearWinFocusFrom (winInfo) + TuiWinInfoPtr winInfo; +#endif +{ + if (m_winPtrNotNull (winInfo)) + { + if (winInfo->generic.type != CMD_WIN) + unhighlightWin (winInfo); + tuiSetWinWithFocus ((TuiWinInfoPtr) NULL); + } + + return; +} /* tuiClearWinFocusFrom */ + + +/* +** tuiClearWinFocus(). +** Clear the window that has focus. +*/ +void +#ifdef __STDC__ +tuiClearWinFocus (void) +#else +tuiClearWinFocus () +#endif +{ + tuiClearWinFocusFrom (tuiWinWithFocus ()); + + return; +} /* tuiClearWinFocus */ + + +/* +** tuiSetWinFocusTo +** Set the logical focus to winInfo +*/ +void +#ifdef __STDC__ +tuiSetWinFocusTo ( + TuiWinInfoPtr winInfo) +#else +tuiSetWinFocusTo (winInfo) + TuiWinInfoPtr winInfo; +#endif +{ + if (m_winPtrNotNull (winInfo)) + { + TuiWinInfoPtr winWithFocus = tuiWinWithFocus (); + + if (m_winPtrNotNull (winWithFocus) && + winWithFocus->generic.type != CMD_WIN) + unhighlightWin (winWithFocus); + tuiSetWinWithFocus (winInfo); + if (winInfo->generic.type != CMD_WIN) + highlightWin (winInfo); + } + + return; +} /* tuiSetWinFocusTo */ + + +char * +#ifdef __STDC__ +tuiStrDup ( + char *str) +#else +tuiStrDup (str) + char *str; +#endif +{ + char *newStr = (char *) NULL; + + if (str != (char *) NULL) + { + newStr = (char *) xmalloc (strlen (str) + 1); + strcpy (newStr, str); + } + + return newStr; +} /* tuiStrDup */ + + +/* +** tuiScrollForward(). +*/ +void +#ifdef __STDC__ +tuiScrollForward ( + TuiWinInfoPtr winToScroll, + int numToScroll) +#else +tuiScrollForward (winToScroll, numToScroll) + TuiWinInfoPtr winToScroll; + int numToScroll; +#endif +{ + if (winToScroll != cmdWin) + { + int _numToScroll = numToScroll; + + if (numToScroll == 0) + _numToScroll = winToScroll->generic.height - 3; + /* + ** If we are scrolling the source or disassembly window, do a + ** "psuedo" scroll since not all of the source is in memory, + ** only what is in the viewport. If winToScroll is the + ** command window do nothing since the term should handle it. + */ + if (winToScroll == srcWin) + tuiVerticalSourceScroll (FORWARD_SCROLL, _numToScroll); + else if (winToScroll == disassemWin) + tuiVerticalDisassemScroll (FORWARD_SCROLL, _numToScroll); + else if (winToScroll == dataWin) + tuiVerticalDataScroll (FORWARD_SCROLL, _numToScroll); + } + + return; +} /* tuiScrollForward */ + + +/* +** tuiScrollBackward(). +*/ +void +#ifdef __STDC__ +tuiScrollBackward ( + TuiWinInfoPtr winToScroll, + int numToScroll) +#else +tuiScrollBackward (winToScroll, numToScroll) + TuiWinInfoPtr winToScroll; + int numToScroll; +#endif +{ + if (winToScroll != cmdWin) + { + int _numToScroll = numToScroll; + + if (numToScroll == 0) + _numToScroll = winToScroll->generic.height - 3; + /* + ** If we are scrolling the source or disassembly window, do a + ** "psuedo" scroll since not all of the source is in memory, + ** only what is in the viewport. If winToScroll is the + ** command window do nothing since the term should handle it. + */ + if (winToScroll == srcWin) + tuiVerticalSourceScroll (BACKWARD_SCROLL, _numToScroll); + else if (winToScroll == disassemWin) + tuiVerticalDisassemScroll (BACKWARD_SCROLL, _numToScroll); + else if (winToScroll == dataWin) + tuiVerticalDataScroll (BACKWARD_SCROLL, _numToScroll); + } + return; +} /* tuiScrollBackward */ + + +/* +** tuiScrollLeft(). +*/ +void +#ifdef __STDC__ +tuiScrollLeft ( + TuiWinInfoPtr winToScroll, + int numToScroll) +#else +tuiScrollLeft (winToScroll, numToScroll) + TuiWinInfoPtr winToScroll; + int numToScroll; +#endif +{ + if (winToScroll != cmdWin) + { + int _numToScroll = numToScroll; + + if (_numToScroll == 0) + _numToScroll = 1; + /* + ** If we are scrolling the source or disassembly window, do a + ** "psuedo" scroll since not all of the source is in memory, + ** only what is in the viewport. If winToScroll is the + ** command window do nothing since the term should handle it. + */ + if (winToScroll == srcWin || winToScroll == disassemWin) + tuiHorizontalSourceScroll (winToScroll, LEFT_SCROLL, _numToScroll); + } + return; +} /* tuiScrollLeft */ + + +/* +** tuiScrollRight(). +*/ +void +#ifdef __STDC__ +tuiScrollRight ( + TuiWinInfoPtr winToScroll, + int numToScroll) +#else +tuiScrollRight (winToScroll, numToScroll) + TuiWinInfoPtr winToScroll; + int numToScroll; +#endif +{ + if (winToScroll != cmdWin) + { + int _numToScroll = numToScroll; + + if (_numToScroll == 0) + _numToScroll = 1; + /* + ** If we are scrolling the source or disassembly window, do a + ** "psuedo" scroll since not all of the source is in memory, + ** only what is in the viewport. If winToScroll is the + ** command window do nothing since the term should handle it. + */ + if (winToScroll == srcWin || winToScroll == disassemWin) + tuiHorizontalSourceScroll (winToScroll, RIGHT_SCROLL, _numToScroll); + } + return; +} /* tuiScrollRight */ + + +/* +** tui_vScroll(). +** Scroll a window. Arguments are passed through a va_list. +*/ +void +#ifdef __STDC__ +tui_vScroll ( + va_list args) +#else +tui_vScroll (args) + va_list args; +#endif +{ + TuiScrollDirection direction = va_arg (args, TuiScrollDirection); + TuiWinInfoPtr winToScroll = va_arg (args, TuiWinInfoPtr); + int numToScroll = va_arg (args, int); + + switch (direction) + { + case FORWARD_SCROLL: + tuiScrollForward (winToScroll, numToScroll); + break; + case BACKWARD_SCROLL: + tuiScrollBackward (winToScroll, numToScroll); + break; + case LEFT_SCROLL: + tuiScrollLeft (winToScroll, numToScroll); + break; + case RIGHT_SCROLL: + tuiScrollRight (winToScroll, numToScroll); + break; + default: + break; + } + + return; +} /* tui_vScroll */ + + +/* +** tuiRefreshAll(). +*/ +void +#ifdef __STDC__ +tuiRefreshAll (void) +#else +tuiRefreshAll () +#endif +{ + TuiWinType type; + + refreshAll (winList); + for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++) + { + if (winList[type]->generic.isVisible) + { + switch (type) + { + case SRC_WIN: + case DISASSEM_WIN: + tuiClearWin (&winList[type]->generic); + if (winList[type]->detail.sourceInfo.hasLocator) + tuiClearLocatorDisplay (); + tuiShowSourceContent (winList[type]); + checkAndDisplayHighlightIfNeeded (winList[type]); + tuiEraseExecInfoContent (winList[type]); + tuiUpdateExecInfo (winList[type]); + break; + case DATA_WIN: + tuiRefreshDataWin (); + break; + default: + break; + } + } + } + tuiClearLocatorDisplay (); + tuiShowLocatorContent (); + + return; +} /* tuiRefreshAll */ + + +/* +** tuiResizeAll(). +** Resize all the windows based on the the terminal size. This +** function gets called from within the readline sinwinch handler. +*/ +void +#ifdef __STDC__ +tuiResizeAll (void) +#else +tuiResizeAll () +#endif +{ + int heightDiff, widthDiff; + extern int screenheight, screenwidth; /* in readline */ + + widthDiff = screenwidth - termWidth (); + heightDiff = screenheight - termHeight (); + if (heightDiff || widthDiff) + { + TuiLayoutType curLayout = currentLayout (); + TuiWinInfoPtr winWithFocus = tuiWinWithFocus (); + TuiWinInfoPtr firstWin, secondWin; + TuiGenWinInfoPtr locator = locatorWinInfoPtr (); + TuiWinType winType; + int i, newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2; + + /* turn keypad off while we resize */ + if (winWithFocus != cmdWin) + keypad (cmdWin->generic.handle, FALSE); + init_page_info (); + setTermHeightTo (screenheight); + setTermWidthTo (screenwidth); + if (curLayout == SRC_DISASSEM_COMMAND || + curLayout == SRC_DATA_COMMAND || curLayout == DISASSEM_DATA_COMMAND) + numWinsDisplayed++; + splitDiff = heightDiff / numWinsDisplayed; + cmdSplitDiff = splitDiff; + if (heightDiff % numWinsDisplayed) + { + if (heightDiff < 0) + cmdSplitDiff--; + else + cmdSplitDiff++; + } + /* now adjust each window */ + clear (); + refresh (); + switch (curLayout) + { + case SRC_COMMAND: + case DISASSEM_COMMAND: + firstWin = (TuiWinInfoPtr) (sourceWindows ())->list[0]; + firstWin->generic.width += widthDiff; + locator->width += widthDiff; + /* check for invalid heights */ + if (heightDiff == 0) + newHeight = firstWin->generic.height; + else if ((firstWin->generic.height + splitDiff) >= + (screenheight - MIN_CMD_WIN_HEIGHT - 1)) + newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1; + else if ((firstWin->generic.height + splitDiff) <= 0) + newHeight = MIN_WIN_HEIGHT; + else + newHeight = firstWin->generic.height + splitDiff; + + _makeInvisibleAndSetNewHeight (firstWin, newHeight); + cmdWin->generic.origin.y = locator->origin.y + 1; + cmdWin->generic.width += widthDiff; + newHeight = screenheight - cmdWin->generic.origin.y; + _makeInvisibleAndSetNewHeight (cmdWin, newHeight); + _makeVisibleWithNewHeight (firstWin); + _makeVisibleWithNewHeight (cmdWin); + if (firstWin->generic.contentSize <= 0) + tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT); + break; + default: + if (curLayout == SRC_DISASSEM_COMMAND) + { + firstWin = srcWin; + firstWin->generic.width += widthDiff; + secondWin = disassemWin; + secondWin->generic.width += widthDiff; + } + else + { + firstWin = dataWin; + firstWin->generic.width += widthDiff; + secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0]; + secondWin->generic.width += widthDiff; + } + /* Change the first window's height/width */ + /* check for invalid heights */ + if (heightDiff == 0) + newHeight = firstWin->generic.height; + else if ((firstWin->generic.height + + secondWin->generic.height + (splitDiff * 2)) >= + (screenheight - MIN_CMD_WIN_HEIGHT - 1)) + newHeight = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2; + else if ((firstWin->generic.height + splitDiff) <= 0) + newHeight = MIN_WIN_HEIGHT; + else + newHeight = firstWin->generic.height + splitDiff; + _makeInvisibleAndSetNewHeight (firstWin, newHeight); + + if (firstWin == dataWin && widthDiff != 0) + firstWin->detail.dataDisplayInfo.regsColumnCount = + tuiCalculateRegsColumnCount ( + firstWin->detail.dataDisplayInfo.regsDisplayType); + locator->width += widthDiff; + + /* Change the second window's height/width */ + /* check for invalid heights */ + if (heightDiff == 0) + newHeight = secondWin->generic.height; + else if ((firstWin->generic.height + + secondWin->generic.height + (splitDiff * 2)) >= + (screenheight - MIN_CMD_WIN_HEIGHT - 1)) + { + newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1; + if (newHeight % 2) + newHeight = (newHeight / 2) + 1; + else + newHeight /= 2; + } + else if ((secondWin->generic.height + splitDiff) <= 0) + newHeight = MIN_WIN_HEIGHT; + else + newHeight = secondWin->generic.height + splitDiff; + secondWin->generic.origin.y = firstWin->generic.height - 1; + _makeInvisibleAndSetNewHeight (secondWin, newHeight); + + /* Change the command window's height/width */ + cmdWin->generic.origin.y = locator->origin.y + 1; + _makeInvisibleAndSetNewHeight ( + cmdWin, cmdWin->generic.height + cmdSplitDiff); + _makeVisibleWithNewHeight (firstWin); + _makeVisibleWithNewHeight (secondWin); + _makeVisibleWithNewHeight (cmdWin); + if (firstWin->generic.contentSize <= 0) + tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT); + if (secondWin->generic.contentSize <= 0) + tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT); + break; + } + /* + ** Now remove all invisible windows, and their content so that they get + ** created again when called for with the new size + */ + for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++) + { + if (winType != CMD_WIN && m_winPtrNotNull (winList[winType]) && + !winList[winType]->generic.isVisible) + { + freeWindow (winList[winType]); + winList[winType] = (TuiWinInfoPtr) NULL; + } + } + tuiSetWinResizedTo (TRUE); + /* turn keypad back on, unless focus is in the command window */ + if (winWithFocus != cmdWin) + keypad (cmdWin->generic.handle, TRUE); + } + return; +} /* tuiResizeAll */ + + +/* +** tuiSigwinchHandler() +** SIGWINCH signal handler for the tui. This signal handler is +** always called, even when the readline package clears signals +** because it is set as the old_sigwinch() (TUI only) +*/ +void +#ifdef __STDC__ +tuiSigwinchHandler ( + int signal) +#else +tuiSigwinchHandler (signal) + int signal; +#endif +{ + /* + ** Say that a resize was done so that the readline can do it + ** later when appropriate. + */ + tuiSetWinResizedTo (TRUE); + + return; +} /* tuiSigwinchHandler */ + + + +/************************* +** STATIC LOCAL FUNCTIONS +**************************/ + + +/* +** _tuiScrollForward_command(). +*/ +static void +#ifdef __STDC__ +_tuiScrollForward_command ( + char *arg, + int fromTTY) +#else +_tuiScrollForward_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + int numToScroll = 1; + TuiWinInfoPtr winToScroll; + + if (arg == (char *) NULL) + _parseScrollingArgs (arg, &winToScroll, (int *) NULL); + else + _parseScrollingArgs (arg, &winToScroll, &numToScroll); + tuiDo ((TuiOpaqueFuncPtr) tui_vScroll, + FORWARD_SCROLL, + winToScroll, + numToScroll); + + return; +} /* _tuiScrollForward_command */ + + +/* +** _tuiScrollBackward_command(). +*/ +static void +#ifdef __STDC__ +_tuiScrollBackward_command ( + char *arg, + int fromTTY) +#else +_tuiScrollBackward_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + int numToScroll = 1; + TuiWinInfoPtr winToScroll; + + if (arg == (char *) NULL) + _parseScrollingArgs (arg, &winToScroll, (int *) NULL); + else + _parseScrollingArgs (arg, &winToScroll, &numToScroll); + tuiDo ((TuiOpaqueFuncPtr) tui_vScroll, + BACKWARD_SCROLL, + winToScroll, + numToScroll); + + return; +} /* _tuiScrollBackward_command */ + + +/* +** _tuiScrollLeft_command(). +*/ +static void +#ifdef __STDC__ +_tuiScrollLeft_command ( + char *arg, + int fromTTY) +#else +_tuiScrollLeft_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + int numToScroll; + TuiWinInfoPtr winToScroll; + + _parseScrollingArgs (arg, &winToScroll, &numToScroll); + tuiDo ((TuiOpaqueFuncPtr) tui_vScroll, + LEFT_SCROLL, + winToScroll, + numToScroll); + + return; +} /* _tuiScrollLeft_command */ + + +/* +** _tuiScrollRight_command(). +*/ +static void +#ifdef __STDC__ +_tuiScrollRight_command ( + char *arg, + int fromTTY) +#else +_tuiScrollRight_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + int numToScroll; + TuiWinInfoPtr winToScroll; + + _parseScrollingArgs (arg, &winToScroll, &numToScroll); + tuiDo ((TuiOpaqueFuncPtr) tui_vScroll, + RIGHT_SCROLL, + winToScroll, + numToScroll); + + return; +} /* _tuiScrollRight_command */ + + +/* +** _tuiSetFocus(). +** Set focus to the window named by 'arg' +*/ +static void +#ifdef __STDC__ +_tuiSetFocus ( + char *arg, + int fromTTY) +#else +_tuiSetFocus (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + if (arg != (char *) NULL) + { + char *bufPtr = (char *) tuiStrDup (arg); + int i; + TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL; + + for (i = 0; (i < strlen (bufPtr)); i++) + bufPtr[i] = toupper (arg[i]); + + if (subsetCompare (bufPtr, "NEXT")) + winInfo = tuiNextWin (tuiWinWithFocus ()); + else if (subsetCompare (bufPtr, "PREV")) + winInfo = tuiPrevWin (tuiWinWithFocus ()); + else + winInfo = partialWinByName (bufPtr); + + if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible) + warning ("Invalid window specified. \n\ +The window name specified must be valid and visible.\n"); + else + { + tuiSetWinFocusTo (winInfo); + keypad (cmdWin->generic.handle, (winInfo != cmdWin)); + } + + if (dataWin->generic.isVisible) + tuiRefreshDataWin (); + tuiFree (bufPtr); + printf_filtered ("Focus set to %s window.\n", + winName ((TuiGenWinInfoPtr) tuiWinWithFocus ())); + } + else + warning ("Incorrect Number of Arguments.\n%s", FOCUS_USAGE); + + return; +} /* _tuiSetFocus */ + + +/* +** _tui_vSetFocus() +*/ +static void +#ifdef __STDC__ +_tui_vSetFocus ( + va_list args) +#else +_tui_vSetFocus (args) + va_list args; +#endif +{ + char *arg = va_arg (args, char *); + int fromTTY = va_arg (args, int); + + _tuiSetFocus (arg, fromTTY); + + return; +} /* tui_vSetFocus */ + + +/* +** _tuiSetFocus_command() +*/ +static void +#ifdef __STDC__ +_tuiSetFocus_command ( + char *arg, + int fromTTY) +#else +_tuiSetFocus_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + tuiDo ((TuiOpaqueFuncPtr) _tui_vSetFocus, arg, fromTTY); + + return; +} /* tui_SetFocus */ + + +/* +** _tuiAllWindowsInfo(). +*/ +static void +#ifdef __STDC__ +_tuiAllWindowsInfo ( + char *arg, + int fromTTY) +#else +_tuiAllWindowsInfo (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + TuiWinType type; + TuiWinInfoPtr winWithFocus = tuiWinWithFocus (); + + for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++) + if (winList[type]->generic.isVisible) + { + if (winWithFocus == winList[type]) + printf_filtered (" %s\t(%d lines) <has focus>\n", + winName (&winList[type]->generic), + winList[type]->generic.height); + else + printf_filtered (" %s\t(%d lines)\n", + winName (&winList[type]->generic), + winList[type]->generic.height); + } + + return; +} /* _tuiAllWindowsInfo */ + + +/* +** _tuiRefreshAll_command(). +*/ +static void +#ifdef __STDC__ +_tuiRefreshAll_command ( + char *arg, + int fromTTY) +#else +_tuiRefreshAll_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + tuiDo ((TuiOpaqueFuncPtr) tuiRefreshAll); +} + + +/* +** _tuiSetWinTabWidth_command(). +** Set the height of the specified window. +*/ +static void +#ifdef __STDC__ +_tuiSetTabWidth_command ( + char *arg, + int fromTTY) +#else +_tuiSetTabWidth_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + if (arg != (char *) NULL) + { + int ts; + + ts = atoi (arg); + if (ts > 0) + tuiSetDefaultTabLen (ts); + else + warning ("Tab widths greater than 0 must be specified.\n"); + } + + return; +} /* _tuiSetTabWidth_command */ + + +/* +** _tuiSetWinHeight(). +** Set the height of the specified window. +*/ +static void +#ifdef __STDC__ +_tuiSetWinHeight ( + char *arg, + int fromTTY) +#else +_tuiSetWinHeight (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + if (arg != (char *) NULL) + { + char *buf = tuiStrDup (arg); + char *bufPtr = buf; + char *wname = (char *) NULL; + int newHeight, i; + TuiWinInfoPtr winInfo; + + wname = bufPtr; + bufPtr = strchr (bufPtr, ' '); + if (bufPtr != (char *) NULL) + { + *bufPtr = (char) 0; + + /* + ** Validate the window name + */ + for (i = 0; i < strlen (wname); i++) + wname[i] = toupper (wname[i]); + winInfo = partialWinByName (wname); + + if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible) + warning ("Invalid window specified. \n\ +The window name specified must be valid and visible.\n"); + else + { + /* Process the size */ + while (*(++bufPtr) == ' ') + ; + + if (*bufPtr != (char) 0) + { + int negate = FALSE; + int fixedSize = TRUE; + int inputNo;; + + if (*bufPtr == '+' || *bufPtr == '-') + { + if (*bufPtr == '-') + negate = TRUE; + fixedSize = FALSE; + bufPtr++; + } + inputNo = atoi (bufPtr); + if (inputNo > 0) + { + if (negate) + inputNo *= (-1); + if (fixedSize) + newHeight = inputNo; + else + newHeight = winInfo->generic.height + inputNo; + /* + ** Now change the window's height, and adjust all + ** other windows around it + */ + if (_tuiAdjustWinHeights (winInfo, + newHeight) == TUI_FAILURE) + warning ("Invalid window height specified.\n%s", + WIN_HEIGHT_USAGE); + else + init_page_info (); + } + else + warning ("Invalid window height specified.\n%s", + WIN_HEIGHT_USAGE); + } + } + } + else + printf_filtered (WIN_HEIGHT_USAGE); + + if (buf != (char *) NULL) + tuiFree (buf); + } + else + printf_filtered (WIN_HEIGHT_USAGE); + + return; +} /* _tuiSetWinHeight */ + + +/* +** _tui_vSetWinHeight(). +** Set the height of the specified window, with va_list. +*/ +static void +#ifdef __STDC__ +_tui_vSetWinHeight ( + va_list args) +#else +_tui_vSetWinHeight (args) + va_list args; +#endif +{ + char *arg = va_arg (args, char *); + int fromTTY = va_arg (args, int); + + _tuiSetWinHeight (arg, fromTTY); + + return; +} /* _tui_vSetWinHeight */ + + +/* +** _tuiSetWinHeight_command(). +** Set the height of the specified window, with va_list. +*/ +static void +#ifdef __STDC__ +_tuiSetWinHeight_command ( + char *arg, + int fromTTY) +#else +_tuiSetWinHeight_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + tuiDo ((TuiOpaqueFuncPtr) _tui_vSetWinHeight, arg, fromTTY); + + return; +} /* _tuiSetWinHeight_command */ + + +/* +** _tuiXDBsetWinHeight(). +** XDB Compatibility command for setting the window height. This will +** increase or decrease the command window by the specified amount. +*/ +static void +#ifdef __STDC__ +_tuiXDBsetWinHeight ( + char *arg, + int fromTTY) +#else +_tuiXDBsetWinHeight (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + if (arg != (char *) NULL) + { + int inputNo = atoi (arg); + + if (inputNo > 0) + { /* Add 1 for the locator */ + int newHeight = termHeight () - (inputNo + 1); + + if (!_newHeightOk (winList[CMD_WIN], newHeight) || + _tuiAdjustWinHeights (winList[CMD_WIN], + newHeight) == TUI_FAILURE) + warning ("Invalid window height specified.\n%s", + XDBWIN_HEIGHT_USAGE); + } + else + warning ("Invalid window height specified.\n%s", + XDBWIN_HEIGHT_USAGE); + } + else + warning ("Invalid window height specified.\n%s", XDBWIN_HEIGHT_USAGE); + + return; +} /* _tuiXDBsetWinHeight */ + + +/* +** _tui_vXDBsetWinHeight(). +** Set the height of the specified window, with va_list. +*/ +static void +#ifdef __STDC__ +_tui_vXDBsetWinHeight ( + va_list args) +#else +_tui_vXDBsetWinHeight (args) + va_list args; +#endif +{ + char *arg = va_arg (args, char *); + int fromTTY = va_arg (args, int); + + _tuiXDBsetWinHeight (arg, fromTTY); + + return; +} /* _tui_vXDBsetWinHeight */ + + +/* +** _tuiSetWinHeight_command(). +** Set the height of the specified window, with va_list. +*/ +static void +#ifdef __STDC__ +_tuiXDBsetWinHeight_command ( + char *arg, + int fromTTY) +#else +_tuiXDBsetWinHeight_command (arg, fromTTY) + char *arg; + int fromTTY; +#endif +{ + tuiDo ((TuiOpaqueFuncPtr) _tui_vXDBsetWinHeight, arg, fromTTY); + + return; +} /* _tuiXDBsetWinHeight_command */ + + +/* +** _tuiAdjustWinHeights(). +** Function to adjust all window heights around the primary +*/ +static TuiStatus +#ifdef __STDC__ +_tuiAdjustWinHeights ( + TuiWinInfoPtr primaryWinInfo, + int newHeight) +#else +_tuiAdjustWinHeights (primaryWinInfo, newHeight) + TuiWinInfoPtr primaryWinInfo; + int newHeight; +#endif +{ + TuiStatus status = TUI_FAILURE; + + if (_newHeightOk (primaryWinInfo, newHeight)) + { + status = TUI_SUCCESS; + if (newHeight != primaryWinInfo->generic.height) + { + int i, diff; + TuiWinInfoPtr winInfo; + TuiGenWinInfoPtr locator = locatorWinInfoPtr (); + TuiLayoutType curLayout = currentLayout (); + + diff = (newHeight - primaryWinInfo->generic.height) * (-1); + if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND) + { + TuiWinInfoPtr srcWinInfo; + + _makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight); + if (primaryWinInfo->generic.type == CMD_WIN) + { + winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0]; + srcWinInfo = winInfo; + } + else + { + winInfo = winList[CMD_WIN]; + srcWinInfo = primaryWinInfo; + } + _makeInvisibleAndSetNewHeight (winInfo, + winInfo->generic.height + diff); + cmdWin->generic.origin.y = locator->origin.y + 1; + _makeVisibleWithNewHeight (winInfo); + _makeVisibleWithNewHeight (primaryWinInfo); + if (srcWinInfo->generic.contentSize <= 0) + tuiEraseSourceContent (srcWinInfo, EMPTY_SOURCE_PROMPT); + } + else + { + TuiWinInfoPtr firstWin, secondWin; + + if (curLayout == SRC_DISASSEM_COMMAND) + { + firstWin = srcWin; + secondWin = disassemWin; + } + else + { + firstWin = dataWin; + secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0]; + } + if (primaryWinInfo == cmdWin) + { /* + ** Split the change in height accross the 1st & 2nd windows + ** adjusting them as well. + */ + int firstSplitDiff = diff / 2; /* subtract the locator */ + int secondSplitDiff = firstSplitDiff; + + if (diff % 2) + { + if (firstWin->generic.height > + secondWin->generic.height) + if (diff < 0) + firstSplitDiff--; + else + firstSplitDiff++; + else + { + if (diff < 0) + secondSplitDiff--; + else + secondSplitDiff++; + } + } + /* make sure that the minimum hieghts are honored */ + while ((firstWin->generic.height + firstSplitDiff) < 3) + { + firstSplitDiff++; + secondSplitDiff--; + } + while ((secondWin->generic.height + secondSplitDiff) < 3) + { + secondSplitDiff++; + firstSplitDiff--; + } + _makeInvisibleAndSetNewHeight ( + firstWin, + firstWin->generic.height + firstSplitDiff); + secondWin->generic.origin.y = firstWin->generic.height - 1; + _makeInvisibleAndSetNewHeight ( + secondWin, secondWin->generic.height + secondSplitDiff); + cmdWin->generic.origin.y = locator->origin.y + 1; + _makeInvisibleAndSetNewHeight (cmdWin, newHeight); + } + else + { + if ((cmdWin->generic.height + diff) < 1) + { /* + ** If there is no way to increase the command window + ** take real estate from the 1st or 2nd window. + */ + if ((cmdWin->generic.height + diff) < 1) + { + int i; + for (i = cmdWin->generic.height + diff; + (i < 1); i++) + if (primaryWinInfo == firstWin) + secondWin->generic.height--; + else + firstWin->generic.height--; + } + } + if (primaryWinInfo == firstWin) + _makeInvisibleAndSetNewHeight (firstWin, newHeight); + else + _makeInvisibleAndSetNewHeight ( + firstWin, + firstWin->generic.height); + secondWin->generic.origin.y = firstWin->generic.height - 1; + if (primaryWinInfo == secondWin) + _makeInvisibleAndSetNewHeight (secondWin, newHeight); + else + _makeInvisibleAndSetNewHeight ( + secondWin, secondWin->generic.height); + cmdWin->generic.origin.y = locator->origin.y + 1; + if ((cmdWin->generic.height + diff) < 1) + _makeInvisibleAndSetNewHeight (cmdWin, 1); + else + _makeInvisibleAndSetNewHeight ( + cmdWin, cmdWin->generic.height + diff); + } + _makeVisibleWithNewHeight (cmdWin); + _makeVisibleWithNewHeight (secondWin); + _makeVisibleWithNewHeight (firstWin); + if (firstWin->generic.contentSize <= 0) + tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT); + if (secondWin->generic.contentSize <= 0) + tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT); + } + } + } + + return status; +} /* _tuiAdjustWinHeights */ + + +/* +** _makeInvisibleAndSetNewHeight(). +** Function make the target window (and auxillary windows associated +** with the targer) invisible, and set the new height and location. +*/ +static void +#ifdef __STDC__ +_makeInvisibleAndSetNewHeight ( + TuiWinInfoPtr winInfo, + int height) +#else +_makeInvisibleAndSetNewHeight (winInfo, height) + TuiWinInfoPtr winInfo; + int height; +#endif +{ + int i; + struct symtab *s; + TuiGenWinInfoPtr genWinInfo; + + + m_beInvisible (&winInfo->generic); + winInfo->generic.height = height; + if (height > 1) + winInfo->generic.viewportHeight = height - 1; + else + winInfo->generic.viewportHeight = height; + if (winInfo != cmdWin) + winInfo->generic.viewportHeight--; + + /* Now deal with the auxillary windows associated with winInfo */ + switch (winInfo->generic.type) + { + case SRC_WIN: + case DISASSEM_WIN: + genWinInfo = winInfo->detail.sourceInfo.executionInfo; + m_beInvisible (genWinInfo); + genWinInfo->height = height; + genWinInfo->origin.y = winInfo->generic.origin.y; + if (height > 1) + genWinInfo->viewportHeight = height - 1; + else + genWinInfo->viewportHeight = height; + if (winInfo != cmdWin) + genWinInfo->viewportHeight--; + + if (m_hasLocator (winInfo)) + { + genWinInfo = locatorWinInfoPtr (); + m_beInvisible (genWinInfo); + genWinInfo->origin.y = winInfo->generic.origin.y + height; + } + break; + case DATA_WIN: + /* delete all data item windows */ + for (i = 0; i < winInfo->generic.contentSize; i++) + { + genWinInfo = (TuiGenWinInfoPtr) & ((TuiWinElementPtr) + winInfo->generic.content[i])->whichElement.dataWindow; + tuiDelwin (genWinInfo->handle); + genWinInfo->handle = (WINDOW *) NULL; + } + break; + default: + break; + } + + return; +} /* _makeInvisibleAndSetNewHeight */ + + +/* +** _makeVisibleWithNewHeight(). +** Function to make the windows with new heights visible. +** This means re-creating the windows' content since the window +** had to be destroyed to be made invisible. +*/ +static void +#ifdef __STDC__ +_makeVisibleWithNewHeight ( + TuiWinInfoPtr winInfo) +#else +_makeVisibleWithNewHeight (winInfo) + TuiWinInfoPtr winInfo; +#endif +{ + int i; + struct symtab *s; + + m_beVisible (&winInfo->generic); + checkAndDisplayHighlightIfNeeded (winInfo); + switch (winInfo->generic.type) + { + case SRC_WIN: + case DISASSEM_WIN: + freeWinContent (winInfo->detail.sourceInfo.executionInfo); + m_beVisible (winInfo->detail.sourceInfo.executionInfo); + if (winInfo->generic.content != (OpaquePtr) NULL) + { + TuiLineOrAddress lineOrAddr; + + if (winInfo->generic.type == SRC_WIN) + lineOrAddr.lineNo = + winInfo->detail.sourceInfo.startLineOrAddr.lineNo; + else + lineOrAddr.addr = + winInfo->detail.sourceInfo.startLineOrAddr.addr; + freeWinContent (&winInfo->generic); + tuiUpdateSourceWindow (winInfo, + current_source_symtab, + ((winInfo->generic.type == SRC_WIN) ? + (Opaque) lineOrAddr.lineNo : + lineOrAddr.addr), + TRUE); + } + else if (selected_frame != (struct frame_info *) NULL) + { + Opaque line = 0; + extern int current_source_line; + + s = find_pc_symtab (selected_frame->pc); + if (winInfo->generic.type == SRC_WIN) + line = (Opaque) current_source_line; + else + line = (Opaque) find_line_pc (s, current_source_line); + tuiUpdateSourceWindow (winInfo, s, line, TRUE); + } + if (m_hasLocator (winInfo)) + { + m_beVisible (locatorWinInfoPtr ()); + tuiClearLocatorDisplay (); + tuiShowLocatorContent (); + } + break; + case DATA_WIN: + tuiDisplayAllData (); + break; + case CMD_WIN: + winInfo->detail.commandInfo.curLine = 0; + winInfo->detail.commandInfo.curch = 0; + wmove (winInfo->generic.handle, + winInfo->detail.commandInfo.curLine, + winInfo->detail.commandInfo.curch); + break; + default: + break; + } + + return; +} /* _makeVisibleWithNewHeight */ + + +static int +#ifdef __STDC__ +_newHeightOk ( + TuiWinInfoPtr primaryWinInfo, + int newHeight) +#else +_newHeightOk (primaryWinInfo, newHeight) + TuiWinInfoPtr primaryWinInfo; + int newHeight; +#endif +{ + int ok = (newHeight < termHeight ()); + + if (ok) + { + int diff, curHeight; + TuiLayoutType curLayout = currentLayout (); + + diff = (newHeight - primaryWinInfo->generic.height) * (-1); + if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND) + { + ok = ((primaryWinInfo->generic.type == CMD_WIN && + newHeight <= (termHeight () - 4) && + newHeight >= MIN_CMD_WIN_HEIGHT) || + (primaryWinInfo->generic.type != CMD_WIN && + newHeight <= (termHeight () - 2) && + newHeight >= MIN_WIN_HEIGHT)); + if (ok) + { /* check the total height */ + TuiWinInfoPtr winInfo; + + if (primaryWinInfo == cmdWin) + winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0]; + else + winInfo = cmdWin; + ok = ((newHeight + + (winInfo->generic.height + diff)) <= termHeight ()); + } + } + else + { + int curTotalHeight, totalHeight, minHeight; + TuiWinInfoPtr firstWin, secondWin; + + if (curLayout == SRC_DISASSEM_COMMAND) + { + firstWin = srcWin; + secondWin = disassemWin; + } + else + { + firstWin = dataWin; + secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0]; + } + /* + ** We could simply add all the heights to obtain the same result + ** but below is more explicit since we subtract 1 for the + ** line that the first and second windows share, and add one + ** for the locator. + */ + curTotalHeight = + (firstWin->generic.height + secondWin->generic.height - 1) + + cmdWin->generic.height + 1 /*locator*/ ; + if (primaryWinInfo == cmdWin) + { + /* locator included since first & second win share a line */ + ok = ((firstWin->generic.height + + secondWin->generic.height + diff) >= + (MIN_WIN_HEIGHT * 2) && + newHeight >= MIN_CMD_WIN_HEIGHT); + if (ok) + { + totalHeight = newHeight + (firstWin->generic.height + + secondWin->generic.height + diff); + minHeight = MIN_CMD_WIN_HEIGHT; + } + } + else + { + minHeight = MIN_WIN_HEIGHT; + /* + ** First see if we can increase/decrease the command + ** window. And make sure that the command window is + ** at least 1 line + */ + ok = ((cmdWin->generic.height + diff) > 0); + if (!ok) + { /* + ** Looks like we have to increase/decrease one of + ** the other windows + */ + if (primaryWinInfo == firstWin) + ok = (secondWin->generic.height + diff) >= minHeight; + else + ok = (firstWin->generic.height + diff) >= minHeight; + } + if (ok) + { + if (primaryWinInfo == firstWin) + totalHeight = newHeight + + secondWin->generic.height + + cmdWin->generic.height + diff; + else + totalHeight = newHeight + + firstWin->generic.height + + cmdWin->generic.height + diff; + } + } + /* + ** Now make sure that the proposed total height doesn't exceed + ** the old total height. + */ + if (ok) + ok = (newHeight >= minHeight && totalHeight <= curTotalHeight); + } + } + + return ok; +} /* _newHeightOk */ + + +/* +** _parseScrollingArgs(). +*/ +static void +#ifdef __STDC__ +_parseScrollingArgs ( + char *arg, + TuiWinInfoPtr * winToScroll, + int *numToScroll) +#else +_parseScrollingArgs (arg, winToScroll, numToScroll) + char *arg; + TuiWinInfoPtr *winToScroll; + int *numToScroll; +#endif +{ + if (numToScroll) + *numToScroll = 0; + *winToScroll = tuiWinWithFocus (); + + /* + ** First set up the default window to scroll, in case there is no + ** window name arg + */ + if (arg != (char *) NULL) + { + char *buf, *bufPtr; + + /* process the number of lines to scroll */ + buf = bufPtr = tuiStrDup (arg); + if (isdigit (*bufPtr)) + { + char *numStr; + + numStr = bufPtr; + bufPtr = strchr (bufPtr, ' '); + if (bufPtr != (char *) NULL) + { + *bufPtr = (char) 0; + if (numToScroll) + *numToScroll = atoi (numStr); + bufPtr++; + } + else if (numToScroll) + *numToScroll = atoi (numStr); + } + + /* process the window name if one is specified */ + if (bufPtr != (char *) NULL) + { + char *wname; + int i; + + if (*bufPtr == ' ') + while (*(++bufPtr) == ' ') + ; + + if (*bufPtr != (char) 0) + wname = bufPtr; + + /* Validate the window name */ + for (i = 0; i < strlen (wname); i++) + wname[i] = toupper (wname[i]); + *winToScroll = partialWinByName (wname); + + if (*winToScroll == (TuiWinInfoPtr) NULL || + !(*winToScroll)->generic.isVisible) + warning ("Invalid window specified. \n\ +The window name specified must be valid and visible.\n"); + else if (*winToScroll == cmdWin) + *winToScroll = (TuiWinInfoPtr) (sourceWindows ())->list[0]; + } + tuiFree (buf); + } + + return; +} /* _parseScrollingArgs */ |