URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tuiWin.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log

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

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tuiWin.c] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	106	markom	`/*`
2			`** tuiWin.c`
3			`** This module contains procedures for handling tui window functions`
4			`** like resize, scrolling, scrolling, changing focus, etc.`
5			`**`
6			`** Author: Susan B. Macchia`
7			`*/`
8
9
10			`#include <string.h>`
11			`#include "defs.h"`
12			`#include "command.h"`
13			`#include "symtab.h"`
14			`#include "breakpoint.h"`
15			`#include "frame.h"`
16
17			`#include "tui.h"`
18			`#include "tuiData.h"`
19			`#include "tuiGeneralWin.h"`
20			`#include "tuiStack.h"`
21			`#include "tuiSourceWin.h"`
22			`#include "tuiDataWin.h"`
23
24			`/*******************************`
25			`** External Declarations`
26			`********************************/`
27			`extern void init_page_info ();`
28
29			`/*******************************`
30			`** Static Local Decls`
31			`********************************/`
32			`static void _makeVisibleWithNewHeight PARAMS ((TuiWinInfoPtr));`
33			`static void _makeInvisibleAndSetNewHeight PARAMS ((TuiWinInfoPtr, int));`
34			`static TuiStatus _tuiAdjustWinHeights PARAMS ((TuiWinInfoPtr, int));`
35			`static int _newHeightOk PARAMS ((TuiWinInfoPtr, int));`
36			`static void _tuiSetTabWidth_command PARAMS ((char *, int));`
37			`static void _tuiRefreshAll_command PARAMS ((char *, int));`
38			`static void _tuiSetWinHeight_command PARAMS ((char *, int));`
39			`static void _tuiXDBsetWinHeight_command PARAMS ((char *, int));`
40			`static void _tuiAllWindowsInfo PARAMS ((char *, int));`