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

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tuiLayout.c] - Blame information for rev 106

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

/*
   ** tuiLayout.c
   ** This module contains procedures for handling the layout of the windows.
 */
 
 
#include "defs.h"
#include "command.h"
#include "symtab.h"
#include "frame.h"
 
#include "tui.h"
#include "tuiData.h"
#include "tuiGeneralWin.h"
#include "tuiStack.h"
#include "tuiRegs.h"
#include "tuiDisassem.h"
 
/*******************************
** Static Local Decls
********************************/
 
static void _initGenWinInfo PARAMS
  ((TuiGenWinInfoPtr, TuiWinType, int, int, int, int));
static void _initAndMakeWin PARAMS
  ((Opaque *, TuiWinType, int, int, int, int, int));
static void _showSourceOrDisassemAndCommand PARAMS
  ((TuiLayoutType));
static void _makeSourceOrDisassemWindow PARAMS
  ((TuiWinInfoPtr *, TuiWinType, int, int));
static void _makeCommandWindow PARAMS ((TuiWinInfoPtr *, int, int));
static void _makeSourceWindow PARAMS ((TuiWinInfoPtr *, int, int));
static void _makeDisassemWindow PARAMS
  ((TuiWinInfoPtr *, int, int));
static void _makeDataWindow PARAMS ((TuiWinInfoPtr *, int, int));
static void _showSourceCommand PARAMS ((void));
static void _showDisassemCommand PARAMS ((void));
static void _showSourceDisassemCommand PARAMS ((void));
static void _showData PARAMS ((TuiLayoutType));
static TuiLayoutType _nextLayout PARAMS ((void));
static TuiLayoutType _prevLayout PARAMS ((void));
static void _tuiLayout_command PARAMS ((char *, int));
static void _tuiToggleLayout_command PARAMS ((char *, int));
static void _tui_vToggleLayout_command PARAMS ((va_list));
static void _tuiToggleSplitLayout_command PARAMS ((char *, int));
static void _tui_vToggleSplitLayout_command PARAMS ((va_list));
static Opaque _extractDisplayStartAddr PARAMS ((void));
static void _tuiHandleXDBLayout PARAMS ((TuiLayoutDefPtr));
static TuiStatus _tuiSetLayoutTo PARAMS ((char *));
 
 
/***************************************
** DEFINITIONS
***************************************/
 
#define LAYOUT_USAGE     "Usage: layout prev | next | <layout_name> \n"
 
/***************************************
** Static Local Data
***************************************/
static TuiLayoutType lastLayout = UNDEFINED_LAYOUT;
 
/***************************************
** PUBLIC FUNCTIONS
***************************************/
 
/*
   ** showLayout().
   **        Show the screen layout defined
 */
void
#ifdef __STDC__
showLayout (
             TuiLayoutType layout)
#else
showLayout (layout)
     TuiLayoutType layout;
#endif
{
  TuiLayoutType curLayout = currentLayout ();
 
  if (layout != curLayout)
    {
      /*
         ** Since the new layout may cause changes in window size, we
         ** should free the content and reallocate on next display of
         ** source/asm
       */
      tuiClearAllSourceWinsContent (NO_EMPTY_SOURCE_PROMPT);
      freeAllSourceWinsContent ();
      clearSourceWindows ();
      if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
        {
          _showData (layout);
          refreshAll (winList);
        }
      else
        {
          /* First make the current layout be invisible */
          m_allBeInvisible ();
          m_beInvisible (locatorWinInfoPtr ());
 
          switch (layout)
            {
              /* Now show the new layout */
            case SRC_COMMAND:
              _showSourceCommand ();
              addToSourceWindows (srcWin);
              break;
            case DISASSEM_COMMAND:
              _showDisassemCommand ();
              addToSourceWindows (disassemWin);
              break;
            case SRC_DISASSEM_COMMAND:
              _showSourceDisassemCommand ();
              addToSourceWindows (srcWin);
              addToSourceWindows (disassemWin);
              break;
            default:
              break;
            }
        }
    }
 
  return;
}                               /* showLayout */
 
 
/*
   ** tuiSetLayout()
   **    Function to set the layout to SRC_COMMAND, DISASSEM_COMMAND,
   **    SRC_DISASSEM_COMMAND, SRC_DATA_COMMAND, or DISASSEM_DATA_COMMAND.
   **    If the layout is SRC_DATA_COMMAND, DISASSEM_DATA_COMMAND, or
   **    UNDEFINED_LAYOUT, then the data window is populated according
   **    to regsDisplayType.
 */
TuiStatus
#ifdef __STDC__
tuiSetLayout (
               TuiLayoutType layoutType,
               TuiRegisterDisplayType regsDisplayType)
#else
tuiSetLayout (layoutType, regsDisplayType)
     TuiLayoutType layoutType;
     TuiRegisterDisplayType regsDisplayType;
#endif
{
  TuiStatus status = TUI_SUCCESS;
 
  if (layoutType != UNDEFINED_LAYOUT || regsDisplayType != TUI_UNDEFINED_REGS)
    {
      TuiLayoutType curLayout = currentLayout (), newLayout = UNDEFINED_LAYOUT;
      int regsPopulate = FALSE;
      Opaque addr = _extractDisplayStartAddr ();
      TuiWinInfoPtr newWinWithFocus = (TuiWinInfoPtr) NULL, winWithFocus = tuiWinWithFocus ();
      TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
 
      if (layoutType == UNDEFINED_LAYOUT &&
          regsDisplayType != TUI_UNDEFINED_REGS)
        {
          if (curLayout == SRC_DISASSEM_COMMAND)
            newLayout = DISASSEM_DATA_COMMAND;
          else if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
            newLayout = SRC_DATA_COMMAND;
          else if (curLayout == DISASSEM_COMMAND ||
                   curLayout == DISASSEM_DATA_COMMAND)
            newLayout = DISASSEM_DATA_COMMAND;
        }
      else
        newLayout = layoutType;
 
      regsPopulate = (newLayout == SRC_DATA_COMMAND ||
                      newLayout == DISASSEM_DATA_COMMAND ||
                      regsDisplayType != TUI_UNDEFINED_REGS);
      if (newLayout != curLayout || regsDisplayType != TUI_UNDEFINED_REGS)
        {
          if (newLayout != curLayout)
            {
              if (winWithFocus != cmdWin)
                tuiClearWinFocus ();
              showLayout (newLayout);
              /*
                 ** Now determine where focus should be
               */
              if (winWithFocus != cmdWin)
                {
                  switch (newLayout)
                    {
                    case SRC_COMMAND:
                      tuiSetWinFocusTo (srcWin);
                      layoutDef->displayMode = SRC_WIN;
                      layoutDef->split = FALSE;
                      break;
                    case DISASSEM_COMMAND:
                      /* the previous layout was not showing
                         ** code. this can happen if there is no
                         ** source available:
                         ** 1. if the source file is in another dir OR
                         ** 2. if target was compiled without -g
                         ** We still want to show the assembly though!
                       */
                      addr = vcatch_errors ((OpaqueFuncPtr)
                                            tuiGetBeginAsmAddress);
                      tuiSetWinFocusTo (disassemWin);
                      layoutDef->displayMode = DISASSEM_WIN;
                      layoutDef->split = FALSE;
                      break;
                    case SRC_DISASSEM_COMMAND:
                      /* the previous layout was not showing
                         ** code. this can happen if there is no
                         ** source available:
                         ** 1. if the source file is in another dir OR
                         ** 2. if target was compiled without -g
                         ** We still want to show the assembly though!
                       */
                      addr = vcatch_errors ((OpaqueFuncPtr)
                                            tuiGetBeginAsmAddress);
                      if (winWithFocus == srcWin)
                        tuiSetWinFocusTo (srcWin);
                      else
                        tuiSetWinFocusTo (disassemWin);
                      layoutDef->split = TRUE;
                      break;
                    case SRC_DATA_COMMAND:
                      if (winWithFocus != dataWin)
                        tuiSetWinFocusTo (srcWin);
                      else
                        tuiSetWinFocusTo (dataWin);
                      layoutDef->displayMode = SRC_WIN;
                      layoutDef->split = FALSE;
                      break;
                    case DISASSEM_DATA_COMMAND:
                      /* the previous layout was not showing
                         ** code. this can happen if there is no
                         ** source available:
                         ** 1. if the source file is in another dir OR
                         ** 2. if target was compiled without -g
                         ** We still want to show the assembly though!
                       */
                      addr = vcatch_errors ((OpaqueFuncPtr)
                                            tuiGetBeginAsmAddress);
                      if (winWithFocus != dataWin)
                        tuiSetWinFocusTo (disassemWin);
                      else
                        tuiSetWinFocusTo (dataWin);
                      layoutDef->displayMode = DISASSEM_WIN;
                      layoutDef->split = FALSE;
                      break;
                    default:
                      break;
                    }
                }
              if (newWinWithFocus != (TuiWinInfoPtr) NULL)
                tuiSetWinFocusTo (newWinWithFocus);
              /*
                 ** Now update the window content
               */
              if (!regsPopulate &&
                  (newLayout == SRC_DATA_COMMAND ||
                   newLayout == DISASSEM_DATA_COMMAND))
                tuiDisplayAllData ();
 
              tuiUpdateSourceWindowsWithAddr (addr);
            }
          if (regsPopulate)
            {
              layoutDef->regsDisplayType =
                (regsDisplayType == TUI_UNDEFINED_REGS ?
                 TUI_GENERAL_REGS : regsDisplayType);
              tuiShowRegisters (layoutDef->regsDisplayType);
            }
        }
    }
  else
    status = TUI_FAILURE;
 
  return status;
}                               /* tuiSetLayout */
 
 
/*
   ** tui_vSetLayoutTo()
   **        Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA,
   **        REGS, $REGS, $GREGS, $FREGS, $SREGS with arguments in a va_list
 */
TuiStatus
#ifdef __STDC__
tui_vSetLayoutTo (
                   va_list args)
#else
tui_vSetLayoutTo (args)
     va_list args;
#endif
{
  char *layoutName;
 
  layoutName = va_arg (args, char *);
 
  return (_tuiSetLayoutTo (layoutName));
}                               /* tui_vSetLayoutTo */
 
 
/*
   ** tuiAddWinToLayout().
   **        Add the specified window to the layout in a logical way.
   **        This means setting up the most logical layout given the
   **        window to be added.
 */
void
#ifdef __STDC__
tuiAddWinToLayout (
                    TuiWinType type)
#else
tuiAddWinToLayout (type)
     TuiWinType type;
#endif
{
  TuiLayoutType curLayout = currentLayout ();
 
  switch (type)
    {
    case SRC_WIN:
      if (curLayout != SRC_COMMAND &&
          curLayout != SRC_DISASSEM_COMMAND &&
          curLayout != SRC_DATA_COMMAND)
        {
          clearSourceWindowsDetail ();
          if (curLayout == DISASSEM_DATA_COMMAND)
            showLayout (SRC_DATA_COMMAND);
          else
            showLayout (SRC_COMMAND);
        }
      break;
    case DISASSEM_WIN:
      if (curLayout != DISASSEM_COMMAND &&
          curLayout != SRC_DISASSEM_COMMAND &&
          curLayout != DISASSEM_DATA_COMMAND)
        {
          clearSourceWindowsDetail ();
          if (curLayout == SRC_DATA_COMMAND)
            showLayout (DISASSEM_DATA_COMMAND);
          else
            showLayout (DISASSEM_COMMAND);
        }
      break;
    case DATA_WIN:
      if (curLayout != SRC_DATA_COMMAND &&
          curLayout != DISASSEM_DATA_COMMAND)
        {
          if (curLayout == DISASSEM_COMMAND)
            showLayout (DISASSEM_DATA_COMMAND);
          else
            showLayout (SRC_DATA_COMMAND);
        }
      break;
    default:
      break;
    }
 
  return;
}                               /* tuiAddWinToLayout */
 
 
/*
   ** tui_vAddWinToLayout().
   **        Add the specified window to the layout in a logical way,
   **        with arguments in a va_list.
 */
void
#ifdef __STDC__
tui_vAddWinToLayout (
                      va_list args)
#else
tui_vAddWinToLayout (args)
     va_list args;
#endif
{
  TuiWinType type = va_arg (args, TuiWinType);
 
  tuiAddWinToLayout (type);
 
  return;
}                               /* tui_vAddWinToLayout */
 
 
/*
   ** tuiDefaultWinHeight().
   **        Answer the height of a window.  If it hasn't been created yet,
   **        answer what the height of a window would be based upon its
   **        type and the layout.
 */
int
#ifdef __STDC__
tuiDefaultWinHeight (
                      TuiWinType type,
                      TuiLayoutType layout)
#else
tuiDefaultWinHeight (type, layout)
     TuiWinType type;
     TuiLayoutType layout;
#endif
{
  int h;
 
  if (winList[type] != (TuiWinInfoPtr) NULL)
    h = winList[type]->generic.height;
  else
    {
      switch (layout)
        {
        case SRC_COMMAND:
        case DISASSEM_COMMAND:
          if (m_winPtrIsNull (cmdWin))
            h = termHeight () / 2;
          else
            h = termHeight () - cmdWin->generic.height;
          break;
        case SRC_DISASSEM_COMMAND:
        case SRC_DATA_COMMAND:
        case DISASSEM_DATA_COMMAND:
          if (m_winPtrIsNull (cmdWin))
            h = termHeight () / 3;
          else
            h = (termHeight () - cmdWin->generic.height) / 2;
          break;
        default:
          h = 0;
          break;
        }
    }
 
  return h;
}                               /* tuiDefaultWinHeight */
 
 
/*
   ** tuiDefaultWinViewportHeight().
   **        Answer the height of a window.  If it hasn't been created yet,
   **        answer what the height of a window would be based upon its
   **        type and the layout.
 */
int
#ifdef __STDC__
tuiDefaultWinViewportHeight (
                              TuiWinType type,
                              TuiLayoutType layout)
#else
tuiDefaultWinViewportHeight (type, layout)
     TuiWinType type;
     TuiLayoutType layout;
#endif
{
  int h;
 
  h = tuiDefaultWinHeight (type, layout);
 
  if (winList[type] == cmdWin)
    h -= 1;
  else
    h -= 2;
 
  return h;
}                               /* tuiDefaultWinViewportHeight */
 
 
/*
   ** _initialize_tuiLayout().
   **        Function to initialize gdb commands, for tui window layout
   **        manipulation.
 */
void
_initialize_tuiLayout ()
{
  if (tui_version)
    {
      add_com ("layout", class_tui, _tuiLayout_command,
               "Change the layout of windows.\n\
Usage: layout prev | next | <layout_name> \n\
Layout names are:\n\
   src   : Displays source and command windows.\n\
   asm   : Displays disassembly and command windows.\n\
   split : Displays source, disassembly and command windows.\n\
   regs  : Displays register window. If existing layout\n\
           is source/command or assembly/command, the \n\
           register window is displayed. If the\n\
           source/assembly/command (split) is displayed, \n\
           the register window is displayed with \n\
           the window that has current logical focus.\n");
      if (xdb_commands)
        {
          add_com ("td", class_tui, _tuiToggleLayout_command,
                   "Toggle between Source/Command and Disassembly/Command layouts.\n");
          add_com ("ts", class_tui, _tuiToggleSplitLayout_command,
                   "Toggle between Source/Command or Disassembly/Command and \n\
Source/Disassembly/Command layouts.\n");
        }
    }
 
  return;
}                               /* _intialize_tuiLayout */
 
 
/*************************
** STATIC LOCAL FUNCTIONS
**************************/
 
 
/*
   ** _tuiSetLayoutTo()
   **    Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA, REGS,
   **        $REGS, $GREGS, $FREGS, $SREGS.
 */
static TuiStatus
#ifdef __STDC__
_tuiSetLayoutTo (
                  char *layoutName)
#else
_tuiSetLayoutTo (layoutName)
     char *layoutName;
#endif
{
  TuiStatus status = TUI_SUCCESS;
 
  if (layoutName != (char *) NULL)
    {
      register int i;
      register char *bufPtr;
      TuiLayoutType newLayout = UNDEFINED_LAYOUT;
      TuiRegisterDisplayType dpyType = TUI_UNDEFINED_REGS;
      TuiLayoutType curLayout = currentLayout ();
 
      bufPtr = (char *) tuiStrDup (layoutName);
      for (i = 0; (i < strlen (layoutName)); i++)
        bufPtr[i] = toupper (bufPtr[i]);
 
      /* First check for ambiguous input */
      if (strlen (bufPtr) <= 1 && (*bufPtr == 'S' || *bufPtr == '$'))
        {
          warning ("Ambiguous command input.\n");
          status = TUI_FAILURE;
        }
      else
        {
          if (subsetCompare (bufPtr, "SRC"))
            newLayout = SRC_COMMAND;
          else if (subsetCompare (bufPtr, "ASM"))
            newLayout = DISASSEM_COMMAND;
          else if (subsetCompare (bufPtr, "SPLIT"))
            newLayout = SRC_DISASSEM_COMMAND;
          else if (subsetCompare (bufPtr, "REGS") ||
                   subsetCompare (bufPtr, TUI_GENERAL_SPECIAL_REGS_NAME) ||
                   subsetCompare (bufPtr, TUI_GENERAL_REGS_NAME) ||
                   subsetCompare (bufPtr, TUI_FLOAT_REGS_NAME) ||
                   subsetCompare (bufPtr, TUI_SPECIAL_REGS_NAME))
            {
              if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
                newLayout = SRC_DATA_COMMAND;
              else
                newLayout = DISASSEM_DATA_COMMAND;
 
/* could ifdef out the following code. when compile with -z, there are null
   pointer references that cause a core dump if 'layout regs' is the first
   layout command issued by the user. HP has asked us to hook up this code
   - edie epstein
 */
              if (subsetCompare (bufPtr, TUI_FLOAT_REGS_NAME))
                {
                  if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
                      TUI_SFLOAT_REGS &&
                      dataWin->detail.dataDisplayInfo.regsDisplayType !=
                      TUI_DFLOAT_REGS)
                    dpyType = TUI_SFLOAT_REGS;
                  else
                    dpyType =
                      dataWin->detail.dataDisplayInfo.regsDisplayType;
                }
              else if (subsetCompare (bufPtr,
                                      TUI_GENERAL_SPECIAL_REGS_NAME))
                dpyType = TUI_GENERAL_AND_SPECIAL_REGS;
              else if (subsetCompare (bufPtr, TUI_GENERAL_REGS_NAME))
                dpyType = TUI_GENERAL_REGS;
              else if (subsetCompare (bufPtr, TUI_SPECIAL_REGS_NAME))
                dpyType = TUI_SPECIAL_REGS;
              else
                {
                  if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
                      TUI_UNDEFINED_REGS)
                    dpyType =
                      dataWin->detail.dataDisplayInfo.regsDisplayType;
                  else
                    dpyType = TUI_GENERAL_REGS;
                }
 
/* end of potential ifdef
 */
 
/* if ifdefed out code above, then assume that the user wishes to display the
   general purpose registers
 */
 
/*              dpyType = TUI_GENERAL_REGS;
 */
            }
          else if (subsetCompare (bufPtr, "NEXT"))
            newLayout = _nextLayout ();
          else if (subsetCompare (bufPtr, "PREV"))
            newLayout = _prevLayout ();
          else
            status = TUI_FAILURE;
          free (bufPtr);
 
          tuiSetLayout (newLayout, dpyType);
        }
    }
  else
    status = TUI_FAILURE;
 
  return status;
}                               /* _tuiSetLayoutTo */
 
 
static Opaque
#ifdef __STDC__
_extractDisplayStartAddr (void)
#else
_extractDisplayStartAddr ()
#endif
{
  TuiLayoutType curLayout = currentLayout ();
  Opaque addr;
 
  switch (curLayout)
    {
    case SRC_COMMAND:
    case SRC_DATA_COMMAND:
      addr = (Opaque) find_line_pc (
                                     current_source_symtab,
                          srcWin->detail.sourceInfo.startLineOrAddr.lineNo);
      break;
    case DISASSEM_COMMAND:
    case SRC_DISASSEM_COMMAND:
    case DISASSEM_DATA_COMMAND:
      addr = disassemWin->detail.sourceInfo.startLineOrAddr.addr;
      break;
    default:
      addr = (Opaque) NULL;
      break;
    }
 
  return addr;
}                               /* _extractDisplayStartAddr */
 
 
static void
#ifdef __STDC__
_tuiHandleXDBLayout (
                      TuiLayoutDefPtr layoutDef)
#else
_tuiHandleXDBLayout (layoutDef)
     TuiLayoutDefPtr layoutDef;
#endif
{
  if (layoutDef->split)
    {
      tuiSetLayout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
      tuiSetWinFocusTo (winList[layoutDef->displayMode]);
    }
  else
    {
      if (layoutDef->displayMode == SRC_WIN)
        tuiSetLayout (SRC_COMMAND, TUI_UNDEFINED_REGS);
      else
        tuiSetLayout (DISASSEM_DATA_COMMAND, layoutDef->regsDisplayType);
    }
 
 
  return;
}                               /* _tuiHandleXDBLayout */
 
 
static void
#ifdef __STDC__
_tuiToggleLayout_command (
                           char *arg,
                           int fromTTY)
#else
_tuiToggleLayout_command (arg, fromTTY)
     char *arg;
     int fromTTY;
#endif
{
  tuiDo ((TuiOpaqueFuncPtr) _tui_vToggleLayout_command, arg, fromTTY);
}
 
static void
#ifdef __STDC__
_tui_vToggleLayout_command (
                             va_list args)
#else
_tui_vToggleLayout_command (args)
     va_list args;
#endif
{
  TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
  if (layoutDef->displayMode == SRC_WIN)
    layoutDef->displayMode = DISASSEM_WIN;
  else
    layoutDef->displayMode = SRC_WIN;
 
  if (!layoutDef->split)
    _tuiHandleXDBLayout (layoutDef);
 
  return;
}                               /* _tuiToggleLayout_command */
 
 
static void
#ifdef __STDC__
_tuiToggleSplitLayout_command (
                                char *arg,
                                int fromTTY)
#else
_tuiToggleSplitLayout_command (arg, fromTTY)
     char *arg;
     int fromTTY;
#endif
{
  tuiDo ((TuiOpaqueFuncPtr) _tui_vToggleSplitLayout_command, arg, fromTTY);
}
 
static void
#ifdef __STDC__
_tui_vToggleSplitLayout_command (
                                  va_list args)
#else
_tui_vToggleSplitLayout_command (args)
     va_list args;
#endif
{
  TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
  layoutDef->split = (!layoutDef->split);
  _tuiHandleXDBLayout (layoutDef);
 
  return;
}                               /* _tui_vToggleSplitLayout_command */
 
 
static void
#ifdef __STDC__
_tuiLayout_command (
                     char *arg,
                     int fromTTY)
#else
_tuiLayout_command (arg, fromTTY)
     char *arg;
     int fromTTY;
#endif
{
  if ((TuiStatus) tuiDo (
                   (TuiOpaqueFuncPtr) tui_vSetLayoutTo, arg) != TUI_SUCCESS)
    warning ("Invalid layout specified.\n%s" LAYOUT_USAGE);
 
  return;
}                               /* _tuiLayout_command */
 
/*
   ** _nextLayout().
   **        Answer the previous layout to cycle to.
 */
static TuiLayoutType
#ifdef __STDC__
_nextLayout (void)
#else
_nextLayout ()
#endif
{
  TuiLayoutType newLayout;
 
  newLayout = currentLayout ();
  if (newLayout == UNDEFINED_LAYOUT)
    newLayout = SRC_COMMAND;
  else
    {
      newLayout++;
      if (newLayout == UNDEFINED_LAYOUT)
        newLayout = SRC_COMMAND;
    }
 
  return newLayout;
}                               /* _nextLayout */
 
 
/*
   ** _prevLayout().
   **        Answer the next layout to cycle to.
 */
static TuiLayoutType
#ifdef __STDC__
_prevLayout (void)
#else
_prevLayout ()
#endif
{
  TuiLayoutType newLayout;
 
  newLayout = currentLayout ();
  if (newLayout == SRC_COMMAND)
    newLayout = DISASSEM_DATA_COMMAND;
  else
    {
      newLayout--;
      if (newLayout == UNDEFINED_LAYOUT)
        newLayout = DISASSEM_DATA_COMMAND;
    }
 
  return newLayout;
}                               /* _prevLayout */
 
 
 
/*
   ** _makeCommandWindow().
 */
static void
#ifdef __STDC__
_makeCommandWindow (
                     TuiWinInfoPtr * winInfoPtr,
                     int height,
                     int originY)
#else
_makeCommandWindow (winInfoPtr, height, originY)
     TuiWinInfoPtr *winInfoPtr;
     int height;
     int originY;
#endif
{
  _initAndMakeWin ((Opaque *) winInfoPtr,
                   CMD_WIN,
                   height,
                   termWidth (),
                   0,
                   originY,
                   DONT_BOX_WINDOW);
 
  (*winInfoPtr)->canHighlight = FALSE;
 
  return;
}                               /* _makeCommandWindow */
 
 
/*
   ** _makeSourceWindow().
 */
static void
#ifdef __STDC__
_makeSourceWindow (
                    TuiWinInfoPtr * winInfoPtr,
                    int height,
                    int originY)
#else
_makeSourceWindow (winInfoPtr, height, originY)
     TuiWinInfoPtr *winInfoPtr;
     int height;
     int originY;
#endif
{
  _makeSourceOrDisassemWindow (winInfoPtr, SRC_WIN, height, originY);
 
  return;
}                               /* _makeSourceWindow */
 
 
/*
   ** _makeDisassemWindow().
 */
static void
#ifdef __STDC__
_makeDisassemWindow (
                      TuiWinInfoPtr * winInfoPtr,
                      int height,
                      int originY)
#else
_makeDisassemWindow (winInfoPtr, height, originY)
     TuiWinInfoPtr *winInfoPtr;
     int height;
     int originY;
#endif
{
  _makeSourceOrDisassemWindow (winInfoPtr, DISASSEM_WIN, height, originY);
 
  return;
}                               /* _makeDisassemWindow */
 
 
/*
   ** _makeDataWindow().
 */
static void
#ifdef __STDC__
_makeDataWindow (
                  TuiWinInfoPtr * winInfoPtr,
                  int height,
                  int originY)
#else
_makeDataWindow (winInfoPtr, height, originY)
     TuiWinInfoPtr *winInfoPtr;
     int height;
     int originY;
#endif
{
  _initAndMakeWin ((Opaque *) winInfoPtr,
                   DATA_WIN,
                   height,
                   termWidth (),
                   0,
                   originY,
                   BOX_WINDOW);
 
  return;
}                               /* _makeDataWindow */
 
 
 
/*
   **    _showSourceCommand().
   **        Show the Source/Command layout
 */
static void
#ifdef __STDC__
_showSourceCommand (void)
#else
_showSourceCommand ()
#endif
{
  _showSourceOrDisassemAndCommand (SRC_COMMAND);
 
  return;
}                               /* _showSourceCommand */
 
 
/*
   **    _showDisassemCommand().
   **        Show the Dissassem/Command layout
 */
static void
#ifdef __STDC__
_showDisassemCommand (void)
#else
_showDisassemCommand ()
#endif
{
  _showSourceOrDisassemAndCommand (DISASSEM_COMMAND);
 
  return;
}                               /* _showDisassemCommand */
 
 
/*
   **    _showSourceDisassemCommand().
   **        Show the Source/Disassem/Command layout
 */
static void
#ifdef __STDC__
_showSourceDisassemCommand (void)
#else
_showSourceDisassemCommand ()
#endif
{
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
  if (currentLayout () != SRC_DISASSEM_COMMAND)
    {
      int cmdHeight, srcHeight, asmHeight;
 
      if (m_winPtrNotNull (cmdWin))
        cmdHeight = cmdWin->generic.height;
      else
        cmdHeight = termHeight () / 3;
 
      srcHeight = (termHeight () - cmdHeight) / 2;
      asmHeight = termHeight () - (srcHeight + cmdHeight);
 
      if (m_winPtrIsNull (srcWin))
        _makeSourceWindow (&srcWin, srcHeight, 0);
      else
        {
          _initGenWinInfo (&srcWin->generic,
                           srcWin->generic.type,
                           srcHeight,
                           srcWin->generic.width,
                           srcWin->detail.sourceInfo.executionInfo->width,
                           0);
          srcWin->canHighlight = TRUE;
          _initGenWinInfo (srcWin->detail.sourceInfo.executionInfo,
                           EXEC_INFO_WIN,
                           srcHeight,
                           3,
                           0,
                           0);
          m_beVisible (srcWin);
          m_beVisible (srcWin->detail.sourceInfo.executionInfo);
          srcWin->detail.sourceInfo.hasLocator = FALSE;;
        }
      if (m_winPtrNotNull (srcWin))
        {
          TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
          tuiShowSourceContent (srcWin);
          if (m_winPtrIsNull (disassemWin))
            {
              _makeDisassemWindow (&disassemWin, asmHeight, srcHeight - 1);
              _initAndMakeWin ((Opaque *) & locator,
                               LOCATOR_WIN,
                               2 /* 1 */ ,
                               termWidth (),
                               0,
                               (srcHeight + asmHeight) - 1,
                               DONT_BOX_WINDOW);
            }
          else
            {
              _initGenWinInfo (locator,
                               LOCATOR_WIN,
                               2 /* 1 */ ,
                               termWidth (),
                               0,
                               (srcHeight + asmHeight) - 1);
              disassemWin->detail.sourceInfo.hasLocator = TRUE;
              _initGenWinInfo (
                                &disassemWin->generic,
                                disassemWin->generic.type,
                                asmHeight,
                                disassemWin->generic.width,
                        disassemWin->detail.sourceInfo.executionInfo->width,
                                srcHeight - 1);
              _initGenWinInfo (disassemWin->detail.sourceInfo.executionInfo,
                               EXEC_INFO_WIN,
                               asmHeight,
                               3,
                               0,
                               srcHeight - 1);
              disassemWin->canHighlight = TRUE;
              m_beVisible (disassemWin);
              m_beVisible (disassemWin->detail.sourceInfo.executionInfo);
            }
          if (m_winPtrNotNull (disassemWin))
            {
              srcWin->detail.sourceInfo.hasLocator = FALSE;
              disassemWin->detail.sourceInfo.hasLocator = TRUE;
              m_beVisible (locator);
              tuiShowLocatorContent ();
              tuiShowSourceContent (disassemWin);
 
              if (m_winPtrIsNull (cmdWin))
                _makeCommandWindow (&cmdWin,
                                    cmdHeight,
                                    termHeight () - cmdHeight);
              else
                {
                  _initGenWinInfo (&cmdWin->generic,
                                   cmdWin->generic.type,
                                   cmdWin->generic.height,
                                   cmdWin->generic.width,
                                   0,
                                   cmdWin->generic.origin.y);
                  cmdWin->canHighlight = FALSE;
                  m_beVisible (cmdWin);
                }
              if (m_winPtrNotNull (cmdWin))
                tuiRefreshWin (&cmdWin->generic);
            }
        }
      setCurrentLayoutTo (SRC_DISASSEM_COMMAND);
    }
 
  return;
}                               /* _showSourceDisassemCommand */
 
 
/*
   **    _showData().
   **        Show the Source/Data/Command or the Dissassembly/Data/Command layout
 */
static void
#ifdef __STDC__
_showData (
            TuiLayoutType newLayout)
#else
_showData (newLayout)
     TuiLayoutType newLayout;
#endif
{
  int totalHeight = (termHeight () - cmdWin->generic.height);
  int srcHeight, dataHeight;
  TuiWinType winType;
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
 
  dataHeight = totalHeight / 2;
  srcHeight = totalHeight - dataHeight;
  m_allBeInvisible ();
  m_beInvisible (locator);
  _makeDataWindow (&dataWin, dataHeight, 0);
  dataWin->canHighlight = TRUE;
  if (newLayout == SRC_DATA_COMMAND)
    winType = SRC_WIN;
  else
    winType = DISASSEM_WIN;
  if (m_winPtrIsNull (winList[winType]))
    {
      if (winType == SRC_WIN)
        _makeSourceWindow (&winList[winType], srcHeight, dataHeight - 1);
      else
        _makeDisassemWindow (&winList[winType], srcHeight, dataHeight - 1);
      _initAndMakeWin ((Opaque *) & locator,
                       LOCATOR_WIN,
                       2 /* 1 */ ,
                       termWidth (),
                       0,
                       totalHeight - 1,
                       DONT_BOX_WINDOW);
    }
  else
    {
      _initGenWinInfo (&winList[winType]->generic,
                       winList[winType]->generic.type,
                       srcHeight,
                       winList[winType]->generic.width,
                   winList[winType]->detail.sourceInfo.executionInfo->width,
                       dataHeight - 1);
      _initGenWinInfo (winList[winType]->detail.sourceInfo.executionInfo,
                       EXEC_INFO_WIN,
                       srcHeight,
                       3,
                       0,
                       dataHeight - 1);
      m_beVisible (winList[winType]);
      m_beVisible (winList[winType]->detail.sourceInfo.executionInfo);
      _initGenWinInfo (locator,
                       LOCATOR_WIN,
                       2 /* 1 */ ,
                       termWidth (),
                       0,
                       totalHeight - 1);
    }
  winList[winType]->detail.sourceInfo.hasLocator = TRUE;
  m_beVisible (locator);
  tuiShowLocatorContent ();
  addToSourceWindows (winList[winType]);
  setCurrentLayoutTo (newLayout);
 
  return;
}                               /* _showData */
 
/*
   ** _initGenWinInfo().
 */
static void
#ifdef __STDC__
_initGenWinInfo (
                  TuiGenWinInfoPtr winInfo,
                  TuiWinType type,
                  int height,
                  int width,
                  int originX,
                  int originY)
#else
_initGenWinInfo (winInfo, type, height, width, originX, originY)
     TuiGenWinInfoPtr winInfo;
     TuiWinType type;
     int height;
     int width;
     int originX;
     int originY;
#endif
{
  int h = height;
 
  winInfo->type = type;
  winInfo->width = width;
  winInfo->height = h;
  if (h > 1)
    {
      winInfo->viewportHeight = h - 1;
      if (winInfo->type != CMD_WIN)
        winInfo->viewportHeight--;
    }
  else
    winInfo->viewportHeight = 1;
  winInfo->origin.x = originX;
  winInfo->origin.y = originY;
 
  return;
}                               /* _initGenWinInfo */
 
/*
   ** _initAndMakeWin().
 */
static void
#ifdef __STDC__
_initAndMakeWin (
                  Opaque * winInfoPtr,
                  TuiWinType winType,
                  int height,
                  int width,
                  int originX,
                  int originY,
                  int boxIt)
#else
_initAndMakeWin (winInfoPtr, winType, height, width, originX, originY, boxIt)
     Opaque *winInfoPtr;
     TuiWinType winType;
     int height;
     int width;
     int originX;
     int originY;
     int boxIt;
#endif
{
  Opaque opaqueWinInfo = *winInfoPtr;
  TuiGenWinInfoPtr generic;
 
  if (opaqueWinInfo == (Opaque) NULL)
    {
      if (m_winIsAuxillary (winType))
        opaqueWinInfo = (Opaque) allocGenericWinInfo ();
      else
        opaqueWinInfo = (Opaque) allocWinInfo (winType);
    }
  if (m_winIsAuxillary (winType))
    generic = (TuiGenWinInfoPtr) opaqueWinInfo;
  else
    generic = &((TuiWinInfoPtr) opaqueWinInfo)->generic;
 
  if (opaqueWinInfo != (Opaque) NULL)
    {
      _initGenWinInfo (generic, winType, height, width, originX, originY);
      if (!m_winIsAuxillary (winType))
        {
          if (generic->type == CMD_WIN)
            ((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = FALSE;
          else
            ((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = TRUE;
        }
      makeWindow (generic, boxIt);
      if (winType == LOCATOR_WIN)
        tuiClearLocatorDisplay ();
      echo ();
    }
  *winInfoPtr = opaqueWinInfo;
 
  return;
}                               /* _initAndMakeWin */
 
 
/*
   ** _makeSourceOrDisassemWindow().
 */
static void
#ifdef __STDC__
_makeSourceOrDisassemWindow (
                              TuiWinInfoPtr * winInfoPtr,
                              TuiWinType type,
                              int height,
                              int originY)
#else
_makeSourceOrDisassemWindow (winInfoPtr, type, height, originY)
     TuiWinInfoPtr *winInfoPtr;
     TuiWinType type;
     int height;
     int originY;
#endif
{
  TuiGenWinInfoPtr executionInfo = (TuiGenWinInfoPtr) NULL;
 
  /*
     ** Create the exeuction info window.
   */
  if (type == SRC_WIN)
    executionInfo = sourceExecInfoWinPtr ();
  else
    executionInfo = disassemExecInfoWinPtr ();
  _initAndMakeWin ((Opaque *) & executionInfo,
                   EXEC_INFO_WIN,
                   height,
                   3,
                   0,
                   originY,
                   DONT_BOX_WINDOW);
  /*
     ** Now create the source window.
   */
  _initAndMakeWin ((Opaque *) winInfoPtr,
                   type,
                   height,
                   termWidth () - executionInfo->width,
                   executionInfo->width,
                   originY,
                   BOX_WINDOW);
 
  (*winInfoPtr)->detail.sourceInfo.executionInfo = executionInfo;
 
  return;
}                               /* _makeSourceOrDisassemWindow */
 
 
/*
   **    _showSourceOrDisassemAndCommand().
   **        Show the Source/Command or the Disassem layout
 */
static void
#ifdef __STDC__
_showSourceOrDisassemAndCommand (
                                  TuiLayoutType layoutType)
#else
_showSourceOrDisassemAndCommand (layoutType)
     TuiLayoutType layoutType;
#endif
{
  if (currentLayout () != layoutType)
    {
      TuiWinInfoPtr *winInfoPtr;
      int areaLeft;
      int srcHeight, cmdHeight;
      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
      if (m_winPtrNotNull (cmdWin))
        cmdHeight = cmdWin->generic.height;
      else
        cmdHeight = termHeight () / 3;
      srcHeight = termHeight () - cmdHeight;
 
 
      if (layoutType == SRC_COMMAND)
        winInfoPtr = &srcWin;
      else
        winInfoPtr = &disassemWin;
 
      if (m_winPtrIsNull (*winInfoPtr))
        {
          if (layoutType == SRC_COMMAND)
            _makeSourceWindow (winInfoPtr, srcHeight - 1, 0);
          else
            _makeDisassemWindow (winInfoPtr, srcHeight - 1, 0);
          _initAndMakeWin ((Opaque *) & locator,
                           LOCATOR_WIN,
                           2 /* 1 */ ,
                           termWidth (),
                           0,
                           srcHeight - 1,
                           DONT_BOX_WINDOW);
        }
      else
        {
          _initGenWinInfo (locator,
                           LOCATOR_WIN,
                           2 /* 1 */ ,
                           termWidth (),
                           0,
                           srcHeight - 1);
          (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
          _initGenWinInfo (
                            &(*winInfoPtr)->generic,
                            (*winInfoPtr)->generic.type,
                            srcHeight - 1,
                            (*winInfoPtr)->generic.width,
                      (*winInfoPtr)->detail.sourceInfo.executionInfo->width,
                            0);
          _initGenWinInfo ((*winInfoPtr)->detail.sourceInfo.executionInfo,
                           EXEC_INFO_WIN,
                           srcHeight - 1,
                           3,
                           0,
                           0);
          (*winInfoPtr)->canHighlight = TRUE;
          m_beVisible (*winInfoPtr);
          m_beVisible ((*winInfoPtr)->detail.sourceInfo.executionInfo);
        }
      if (m_winPtrNotNull (*winInfoPtr))
        {
          (*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
          m_beVisible (locator);
          tuiShowLocatorContent ();
          tuiShowSourceContent (*winInfoPtr);
 
          if (m_winPtrIsNull (cmdWin))
            {
              _makeCommandWindow (&cmdWin, cmdHeight, srcHeight);
              tuiRefreshWin (&cmdWin->generic);
            }
          else
            {
              _initGenWinInfo (&cmdWin->generic,
                               cmdWin->generic.type,
                               cmdWin->generic.height,
                               cmdWin->generic.width,
                               cmdWin->generic.origin.x,
                               cmdWin->generic.origin.y);
              cmdWin->canHighlight = FALSE;
              m_beVisible (cmdWin);
            }
        }
      setCurrentLayoutTo (layoutType);
    }
 
  return;
}                               /* _showSourceOrDisassemAndCommand */
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tuiLayout.c] - Blame information for rev 106

Line No.	Rev	Author	Line
1	106	markom	`/*`
2			`** tuiLayout.c`
3			`** This module contains procedures for handling the layout of the windows.`
4			`*/`
5
6
7			`#include "defs.h"`
8			`#include "command.h"`
9			`#include "symtab.h"`
10			`#include "frame.h"`
11
12			`#include "tui.h"`
13			`#include "tuiData.h"`
14			`#include "tuiGeneralWin.h"`
15			`#include "tuiStack.h"`
16			`#include "tuiRegs.h"`
17			`#include "tuiDisassem.h"`
18
19			`/*******************************`
20			`** Static Local Decls`
21			`********************************/`
22
23			`static void _initGenWinInfo PARAMS`
24			`((TuiGenWinInfoPtr, TuiWinType, int, int, int, int));`
25			`static void _initAndMakeWin PARAMS`
26			`((Opaque *, TuiWinType, int, int, int, int, int));`
27			`static void _showSourceOrDisassemAndCommand PARAMS`
28			`((TuiLayoutType));`
29			`static void _makeSourceOrDisassemWindow PARAMS`
30			`((TuiWinInfoPtr *, TuiWinType, int, int));`
31			`static void _makeCommandWindow PARAMS ((TuiWinInfoPtr *, int, int));`
32			`static void _makeSourceWindow PARAMS ((TuiWinInfoPtr *, int, int));`
33			`static void _makeDisassemWindow PARAMS`
34			`((TuiWinInfoPtr *, int, int));`
35			`static void _makeDataWindow PARAMS ((TuiWinInfoPtr *, int, int));`
36			`static void _showSourceCommand PARAMS ((void));`
37			`static void _showDisassemCommand PARAMS ((void));`
38			`static void _showSourceDisassemCommand PARAMS ((void));`
39			`static void _showData PARAMS ((TuiLayoutType));`
40			`static TuiLayoutType _nextLayout PARAMS ((void));`