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