| /* |
| ** 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 (TuiWinInfoPtr); |
| static void _makeInvisibleAndSetNewHeight (TuiWinInfoPtr, int); |
| static TuiStatus _tuiAdjustWinHeights (TuiWinInfoPtr, int); |
| static int _newHeightOk (TuiWinInfoPtr, int); |
| static void _tuiSetTabWidth_command (char *, int); |
| static void _tuiRefreshAll_command (char *, int); |
| static void _tuiSetWinHeight_command (char *, int); |
| static void _tuiXDBsetWinHeight_command (char *, int); |
| static void _tuiAllWindowsInfo (char *, int); |
| static void _tuiSetFocus_command (char *, int); |
| static void _tuiScrollForward_command (char *, int); |
| static void _tuiScrollBackward_command (char *, int); |
| static void _tuiScrollLeft_command (char *, int); |
| static void _tuiScrollRight_command (char *, int); |
| static void _parseScrollingArgs (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 */ |