path: root/gdb/tui/tuiDataWin.c

/*
** tuiDataWin.c
**   This module contains functions to support the data/register window display.
*/


#include "defs.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiRegs.h"


/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
******************************************/



/*****************************************
** PUBLIC FUNCTIONS                        **
******************************************/


/*
** tuiFirstDataItemDisplayed()
**    Answer the index first element displayed.
**    If none are displayed, then return (-1).
*/
int
#ifdef __STDC__
tuiFirstDataItemDisplayed (void)
#else
tuiFirstDataItemDisplayed ()
#endif
{
  int elementNo = (-1);
  int i;

  for (i = 0; (i < dataWin->generic.contentSize && elementNo < 0); i++)
    {
      TuiGenWinInfoPtr dataItemWin;

      dataItemWin = &((TuiWinContent)
		      dataWin->generic.content)[i]->whichElement.dataWindow;
      if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->isVisible)
	elementNo = i;
    }

  return elementNo;
}				/* tuiFirstDataItemDisplayed */


/*
** tuiFirstDataElementNoInLine()
**        Answer the index of the first element in lineNo.  If lineNo is
**        past the data area (-1) is returned.
*/
int
#ifdef __STDC__
tuiFirstDataElementNoInLine (
			      int lineNo)
#else
tuiFirstDataElementNoInLine (lineNo)
     int lineNo;
#endif
{
  int firstElementNo = (-1);

  /*
    ** First see if there is a register on lineNo, and if so, set the
    ** first element number
    */
  if ((firstElementNo = tuiFirstRegElementNoInLine (lineNo)) == -1)
    {				/*
      ** Looking at the general data, the 1st element on lineNo
      */
    }

  return firstElementNo;
}				/* tuiFirstDataElementNoInLine */


/*
** tuiDeleteDataContentWindows()
**        Function to delete all the item windows in the data window.
**        This is usually done when the data window is scrolled.
*/
void
#ifdef __STDC__
tuiDeleteDataContentWindows (void)
#else
tuiDeleteDataContentWindows ()
#endif
{
  int i;
  TuiGenWinInfoPtr dataItemWinPtr;

  for (i = 0; (i < dataWin->generic.contentSize); i++)
    {
      dataItemWinPtr = &((TuiWinContent)
		      dataWin->generic.content)[i]->whichElement.dataWindow;
      tuiDelwin (dataItemWinPtr->handle);
      dataItemWinPtr->handle = (WINDOW *) NULL;
      dataItemWinPtr->isVisible = FALSE;
    }

  return;
}				/* tuiDeleteDataContentWindows */


void
#ifdef __STDC__
tuiEraseDataContent (
		      char *prompt)
#else
tuiEraseDataContent (prompt)
     char *prompt;
#endif
{
  werase (dataWin->generic.handle);
  checkAndDisplayHighlightIfNeeded (dataWin);
  if (prompt != (char *) NULL)
    {
      int halfWidth = (dataWin->generic.width - 2) / 2;
      int xPos;

      if (strlen (prompt) >= halfWidth)
	xPos = 1;
      else
	xPos = halfWidth - strlen (prompt);
      mvwaddstr (dataWin->generic.handle,
		 (dataWin->generic.height / 2),
		 xPos,
		 prompt);
    }
  wrefresh (dataWin->generic.handle);

  return;
}				/* tuiEraseDataContent */


/*
** tuiDisplayAllData().
**        This function displays the data that is in the data window's
**        content.  It does not set the content.
*/
void
#ifdef __STDC__
tuiDisplayAllData (void)
#else
tuiDisplayAllData ()
#endif
{
  if (dataWin->generic.contentSize <= 0)
    tuiEraseDataContent (NO_DATA_STRING);
  else
    {
      tuiEraseDataContent ((char *) NULL);
      tuiDeleteDataContentWindows ();
      checkAndDisplayHighlightIfNeeded (dataWin);
      tuiDisplayRegistersFrom (0);
      /*
        ** Then display the other data
        */
      if (dataWin->detail.dataDisplayInfo.dataContent !=
	  (TuiWinContent) NULL &&
	  dataWin->detail.dataDisplayInfo.dataContentCount > 0)
	{
	}
    }
  return;
}				/* tuiDisplayAllData */


/*
** tuiDisplayDataFromLine()
**        Function to display the data starting at line, lineNo, in the
**        data window.
*/
void
#ifdef __STDC__
tuiDisplayDataFromLine (
			 int lineNo)
#else
tuiDisplayDataFromLine (lineNo)
     int lineNo;
#endif
{
  int _lineNo = lineNo;

  if (lineNo < 0)
    _lineNo = 0;

  checkAndDisplayHighlightIfNeeded (dataWin);

  /* there is no general data, force regs to display (if there are any) */
  if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0)
    tuiDisplayRegistersFromLine (_lineNo, TRUE);
  else
    {
      int elementNo, startLineNo;
      int regsLastLine = tuiLastRegsLineNo ();


      /* display regs if we can */
      if (tuiDisplayRegistersFromLine (_lineNo, FALSE) < 0)
	{			/*
            ** _lineNo is past the regs display, so calc where the
            ** start data element is
            */
	  if (regsLastLine < _lineNo)
	    {			/* figure out how many lines each element is to obtain
                    the start elementNo */
	    }
	}
      else
	{			/*
           ** calculate the starting element of the data display, given
           ** regsLastLine and how many lines each element is, up to
           ** _lineNo
           */
	}
      /* Now display the data , starting at elementNo */
    }

  return;
}				/* tuiDisplayDataFromLine */


/*
** tuiDisplayDataFrom()
**        Display data starting at element elementNo
*/
void
#ifdef __STDC__
tuiDisplayDataFrom (
		     int elementNo,
		     int reuseWindows)
#else
tuiDisplayDataFrom (elementNo, reuseWindows)
     int elementNo;
     int reuseWindows;
#endif
{
  int firstLine = (-1);

  if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
    firstLine = tuiLineFromRegElementNo (elementNo);
  else
    {				/* calculate the firstLine from the element number */
    }

  if (firstLine >= 0)
    {
      tuiEraseDataContent ((char *) NULL);
      if (!reuseWindows)
	tuiDeleteDataContentWindows ();
      tuiDisplayDataFromLine (firstLine);
    }

  return;
}				/* tuiDisplayDataFrom */


/*
** tuiRefreshDataWin()
**        Function to redisplay the contents of the data window.
*/
void
#ifdef __STDC__
tuiRefreshDataWin (void)
#else
tuiRefreshDataWin ()
#endif
{
  tuiEraseDataContent ((char *) NULL);
  if (dataWin->generic.contentSize > 0)
    {
      int firstElement = tuiFirstDataItemDisplayed ();

      if (firstElement >= 0)	/* re-use existing windows */
	tuiDisplayDataFrom (firstElement, TRUE);
    }

  return;
}				/* tuiRefreshDataWin */


/*
** tuiCheckDataValues().
**        Function to check the data values and hilite any that have changed
*/
void
#ifdef __STDC__
tuiCheckDataValues (
		     struct frame_info *frame)
#else
tuiCheckDataValues (frame)
     struct frame_info *frame;
#endif
{
  tuiCheckRegisterValues (frame);

  /* Now check any other data values that there are */
  if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
    {
      int i;

      for (i = 0; dataWin->detail.dataDisplayInfo.dataContentCount; i++)
	{
#ifdef LATER
	  TuiDataElementPtr dataElementPtr;
	  TuiGenWinInfoPtr dataItemWinPtr;
	  Opaque newValue;

	  dataItemPtr = &dataWin->detail.dataDisplayInfo.
	    dataContent[i]->whichElement.dataWindow;
	  dataElementPtr = &((TuiWinContent)
			     dataItemWinPtr->content)[0]->whichElement.data;
	  if value
	    has changed (dataElementPtr, frame, &newValue)
	    {
	      dataElementPtr->value = newValue;
	      update the display with the new value, hiliting it.
	    }
#endif
	}
    }
}				/* tuiCheckDataValues */


/*
** tui_vCheckDataValues().
**        Function to check the data values and hilite any that have
**        changed with args in a va_list
*/
void
#ifdef __STDC__
tui_vCheckDataValues (
		       va_list args)
#else
tui_vCheckDataValues (args)
     va_list args;
#endif
{
  struct frame_info *frame = va_arg (args, struct frame_info *);

  tuiCheckDataValues (frame);

  return;
}				/* tui_vCheckDataValues */


/*
** tuiVerticalDataScroll()
**        Scroll the data window vertically forward or backward.
*/
void
#ifdef __STDC__
tuiVerticalDataScroll (
			TuiScrollDirection scrollDirection,
			int numToScroll)
#else
tuiVerticalDataScroll (scrollDirection, numToScroll)
     TuiScrollDirection scrollDirection;
     int numToScroll;
#endif
{
  int firstElementNo;
  int firstLine = (-1);

  firstElementNo = tuiFirstDataItemDisplayed ();
  if (firstElementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
    firstLine = tuiLineFromRegElementNo (firstElementNo);
  else
    {				/* calculate the first line from the element number which is in
        ** the general data content
        */
    }

  if (firstLine >= 0)
    {
      int lastElementNo, lastLine;

      if (scrollDirection == FORWARD_SCROLL)
	firstLine += numToScroll;
      else
	firstLine -= numToScroll;
      tuiEraseDataContent ((char *) NULL);
      tuiDeleteDataContentWindows ();
      tuiDisplayDataFromLine (firstLine);
    }

  return;
}				/* tuiVerticalDataScroll */


/*****************************************
** STATIC LOCAL FUNCTIONS               **
******************************************/