Subversion Repositories or1k

/*

   ** 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               **

******************************************/