ODBlock.c

/* OpenDoors Online Software Programming Toolkit
 * (C) Copyright 1991 - 1999 by Brian Pirie.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 *        File: ODBlock.c
 *
 * Description: Implements the text block manipulation functions.
 *
 *   Revisions: Date          Ver   Who  Change
 *              ---------------------------------------------------------------
 *              Oct 13, 1994  6.00  BP   New file header format.
 *              Dec 09, 1994  6.00  BP   Standardized coding style.
 *              Aug 19, 1995  6.00  BP   32-bit portability.
 *              Nov 11, 1995  6.00  BP   Removed register keyword.
 *              Nov 14, 1995  6.00  BP   Added include of odscrn.h.
 *              Nov 16, 1995  6.00  BP   Removed oddoor.h, added odcore.h.
 *              Dec 12, 1995  6.00  BP   Added entry, exit and kernel macros.
 *              Dec 30, 1995  6.00  BP   Added ODCALL for calling convention.
 *              Feb 19, 1996  6.00  BP   Changed version number to 6.00.
 *              Mar 03, 1996  6.10  BP   Begin version 6.10.
 *              Aug 10, 2003  6.23  SH   *nix support
 */

#define BUILDING_OPENDOORS

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "OpenDoor.h"
#include "ODCore.h"
#include "ODGen.h"
#include "ODScrn.h"
#include "ODKrnl.h"


/* Set to TRUE when od_puttext() should leave the cursor in its original */
/* position */
static BOOL bScrollAction = TRUE;



/* ----------------------------------------------------------------------------
 * od_puttext()
 *
 * Displays the contents of the buffer passed in block. Leaves cursor in
 * original position, unless bScrollAction is FALSE. Leaves colour at
 * original value.
 *
 * Parameters: nLeft   - Column number of left edge of block of text to
 *                       transfer, where 1 is the leftmost column of the
 *                       screen.
 *
 *             nTop    - Row number of the top edge of block of text to
 *                       to transfer, where 1 is the top row of the screen.
 *
 *             nRight  - Column number of the right edge of block.
 *
 *             nBottom - Row number of bottom edge of block.
 *
 *             pBlock  - Pointer to buffer that has been filled in the format
 *                       used by od_gettext().
 *
 *     Return: TRUE on success, FALSE on failure.
 */
ODAPIDEF BOOL ODCALL od_puttext(INT nLeft, INT nTop, INT nRight, INT nBottom,
   void *pBlock)
{
   INT nRowLength = nRight - nLeft +1;
   INT nRowBytes = nRowLength * 2;
   char *pchTest;
   char *pchMemory;
   char *pBuffer=NULL;
   char *pchScreenBlock;
   INT nBlockRow = 0;
   INT nOutRow;
   INT nOutColour = 999;
   INT nOutColumn, nCheckColumn;
   char *pchMemBlock;
   INT nMoveCost = od_control.user_avatar ? 4 : 7;
   BYTE btMaxRight, btMaxBottom;

   /* Log function entry if running in trace mode. */
   TRACE(TRACE_API, "od_puttext()");

   /* Ensure that OpenDoors is initialized before proceeding. */
   if(!bODInitialized) od_init();

   OD_API_ENTRY();

   /* Get current display setting profile. */
   ODScrnGetTextInfo(&ODTextInfo);

   /* Calculate the maximum values for bottom and right of block. */
   btMaxRight=ODTextInfo.winright-ODTextInfo.winleft+1;
   btMaxBottom=ODTextInfo.winbottom-ODTextInfo.wintop+1;

   /* Check that parameters seem reasonable. */
   if(nLeft<1 || nTop<1 || nRight>btMaxRight || nBottom>btMaxBottom
      || nTop > nBottom || nLeft > nRight || pBlock==NULL)
   {
      od_control.od_error = ERR_PARAMETER;
      OD_API_EXIT();
      return(FALSE);
   }

   /* Ensure that ANSI and/or AVATAR mode is available. */
   if(!od_control.user_ansi && !od_control.user_avatar)
   {
      od_control.od_error = ERR_NOGRAPHICS;
      OD_API_EXIT();
      return(FALSE);
   }

   /* If OpenDoors is operating in remote mode. */
   if(od_control.baud != 0)
   {
      /* Allocate temporary buffer to store original screen contents while */
      /* buffer paste is being performed.                                  */
      if((pBuffer=malloc(nRowBytes*(nBottom-nTop+1)))==NULL)
      {
         od_control.od_error = ERR_MEMORY;
         OD_API_EXIT();
         return(FALSE);
      }

      /* Get current screen contents of area to be pasted into, storing */
      /* into the temporary buffer.                                     */
      if(!ODScrnGetText((BYTE)nLeft, (BYTE)nTop, (BYTE)nRight, (BYTE)nBottom,
         pBuffer))
      {
         od_control.od_error = ERR_PARAMETER;
         free(pBuffer);
         OD_API_EXIT();
         return(FALSE);
      }
   }

   /* Display the block to be pasted on the local screen. */
   if(!ODScrnPutText((BYTE)nLeft, (BYTE)nTop, (BYTE)nRight, (BYTE)nBottom,
      pBlock))
   {
      od_control.od_error = ERR_PARAMETER;
      if(pBuffer)
         free(pBuffer);
      OD_API_EXIT();
      return(FALSE);
   }

   /* If operating in remote mode. */
   if(od_control.baud != 0)
   {
      /* Loop for each line in the buffer to be pasted */
      for(nOutRow=nTop;nOutRow<=nBottom;++nOutRow,++nBlockRow)
      {
         /* Setup pointer to beginning of line of original screen contents. */
         pchScreenBlock=(char *)pBuffer+(nRowBytes*nBlockRow);

         /* Setup pointer to beginning of line of block to be displayed. */
         pchMemBlock=(char *)pBlock+(nRowBytes*nBlockRow);

         /* Loop for each column on this line. */
         for(nOutColumn=0;nOutColumn<nRowLength;)
         {
            /* Loop from this character onwards, counting number of */
            /* characters that don't need to be changed. */
            nCheckColumn=nOutColumn;
            pchMemory=((char *)pchMemBlock)+(nCheckColumn<<1);
            pchTest=((char *)pchScreenBlock)+(nCheckColumn<<1);
            for(;nCheckColumn<nRowLength;++nCheckColumn)
            {
               if(od_control.od_full_put) break;

               /* If both buffers have space characters. */
               if((*pchMemory==' ' || *pchMemory==0) && (*pchTest==' ' || *pchTest=='\0'))
               {
                  /* If background colours differ, then stop comparison loop. */
                  if((pchTest[1]&0x70) != (pchMemory[1]&0x70))
                  {
                     break;
                  }
               }

               /* If both have different character and colour attributes. */
               else if(*((WORD *)pchTest) != *((WORD *)pchMemory))
               {
                  /* Then stop comparison loop now. */
                  break;
               }

               /* Increment source and background pointers by two bytes. */
               pchTest+=2;
               pchMemory+=2;
            }

            /* If no futher text to change on this line. */
            if(nCheckColumn==nRowLength)
            {
               /* Move to the next line. */
               goto next_line;
            }

            /* If this is the first text to be displayed on this line. */
            if(nOutColumn == 0)
            {
               /* Move the cursor to the first text to be changed on line. */
               nOutColumn = nCheckColumn;

               /* If AVATAR mode is available. */
               if(od_control.user_avatar)
               {
                  /* Send the avatar cursor positioning command. */
                  szODWorkString[0]=22;
                  szODWorkString[1]=8;
                  szODWorkString[2]=nOutRow;
                  szODWorkString[3]=nLeft+nOutColumn;
                  od_disp(szODWorkString,4,FALSE);
               }
               else
               {
                  /* Otherwise, send the ANSI cursor positioning command. */
                  sprintf(szODWorkString,"x[%d;%dH",nOutRow,nLeft + nOutColumn);
                  szODWorkString[0]=27;
                  od_disp(szODWorkString, strlen(szODWorkString), FALSE);
               }
            }

            /* If the number of characters after current cursor position  */
            /* which must be changed, is greater than the number of       */
            /* characters required to reposition the cursor on this line, */
            /* then move the cursor to skip unchanged characters.         */
            else if((nCheckColumn-nOutColumn)>nMoveCost)
            {
               nOutColumn=nCheckColumn;
               /* If AVATAR mode is available. */
               if(od_control.user_avatar)
               {
                  /* Advance cursor appropriate number of characters */
                  /* using the AVATAR cursor position command.       */
                  szODWorkString[0]=22;
                  szODWorkString[1]=8;
                  szODWorkString[2]=nOutRow;
                  szODWorkString[3]=nLeft+nOutColumn;
                  od_disp(szODWorkString,4,FALSE);
               }
               else
               {
                  /* Otherwise, advance cursor appropriate number of      */
                  /* characters using the ANSI cursor position command.   */
                  sprintf(szODWorkString,"x[%d;%dH",nOutRow,nLeft + nOutColumn);
                  szODWorkString[0]=27;
                  od_disp(szODWorkString,strlen(szODWorkString),FALSE);
               }
            }

            /* Output text for the number of characters found to be */
            /* different.                                           */
            pchTest=(char *)&pchMemBlock[nOutColumn*2];
            for(;nOutColumn<=nCheckColumn;++nOutColumn)
            {
               if(pchTest[1] != nOutColour)
               {
                  od_set_attrib(nOutColour=pchTest[1]);
               }
               od_disp(pchTest,1,FALSE);
               pchTest++;
               pchTest++;
            }
         }
next_line:
         ;
      }

      /* If not disabled, update cursor position. */
      if(bScrollAction)
      {
         od_set_cursor(ODTextInfo.cury,ODTextInfo.curx);
      }

      /* Deallocate temporary buffer. */
      free(pBuffer);
   }

   /* Restore the original display attribute. */
   od_set_attrib(ODTextInfo.attribute);

   /* Return with success. */
   OD_API_EXIT();
   return(TRUE);
}


/* ----------------------------------------------------------------------------
 * od_gettext()
 *
 * Retrieves text from the screen (based on what is current displayed on the
 * local display), storing it in the buffer provided by the caller.
 *
 * Parameters: nLeft   - Column number of left edge of block of text to
 *                       transfer, where 1 is the leftmost column of the
 *                       screen.
 *
 *             nTop    - Row number of the top edge of block of text to
 *                       to transfer, where 1 is the top row of the screen.
 *
 *             nRight  - Column number of the right edge of block.
 *
 *             nBottom - Row number of bottom edge of block.
 *
 *             pBlock  - Pointer to buffer large enough to hold two bytes
 *                       for each character in the block.
 *
 *     Return: TRUE on success, FALSE on failure.
 */
ODAPIDEF BOOL ODCALL od_gettext(INT nLeft, INT nTop, INT nRight, INT nBottom,
   void *pBlock)
{
   BYTE btMaxRight, btMaxBottom;

   /* Log function entry if running in trace mode. */
   TRACE(TRACE_API, "od_gettext()");

   /* Initialize OpenDoors if not already done. */
   if(!bODInitialized) od_init();

   OD_API_ENTRY();

   ODScrnGetTextInfo(&ODTextInfo);

   btMaxRight=ODTextInfo.winright-ODTextInfo.winleft+1;
   btMaxBottom=ODTextInfo.winbottom-ODTextInfo.wintop+1;
   if(nLeft<1 || nTop<1 || nRight>btMaxRight || nBottom>btMaxBottom || !pBlock)
   {
      od_control.od_error = ERR_PARAMETER;
      OD_API_EXIT();
      return(FALSE);
   }

   if(!od_control.user_ansi && !od_control.user_avatar)
   {
      od_control.od_error = ERR_NOGRAPHICS;
      OD_API_EXIT();
      return(FALSE);
   }

   OD_API_EXIT();
   return(ODScrnGetText((BYTE)nLeft, (BYTE)nTop, (BYTE)nRight, (BYTE)nBottom,
      pBlock));
}


/* ----------------------------------------------------------------------------
 * od_scroll()
 *
 * Scrolls the specified area of the screen by the specified number of
 * lines, in either the up or down directions. The cursor is left at its
 * original locaiton, and the display attribute is left at its original
 * setting. New lines are created in the current display colour.
 *
 * Parameters: nLeft     - Column number of left edge of area to scroll, where
 *                         1 is the leftmost column of the screen.
 *
 *             nTop      - Row number of the top edge of the area to scroll,
 *                         where 1 is the top row of the screen.
 *
 *             nRight    - Column number of the right edge of area to scroll.
 *
 *             nBottom   - Row number of bottom edge of area to scroll.
 *
 *             nDistance - Number of lines to scroll the text. A value of 0
 *                         has no effect on the specified area, a positive
 *                         value moves the text upwards (leaving blank lines
 *                         at the bottom of the specified area), while a
 *                         negative value moves the text upwards. If the
 *                         distance is equal to the number of lines in the
 *                         area, then the entire area is cleared.
 *
 *             nFlags    - Bitwise-or (|) of SCROLL_* flags. SCROLL_NORMAL
 *                         is the default. SCROLL_NO_CLEAR does not clear
 *                         the new area at the top/bottom of the scroll
 *                         region if doing so would be slower.
 *
 *     Return: TRUE on success, FALSE on failure.
 */
ODAPIDEF BOOL ODCALL od_scroll(INT nLeft, INT nTop, INT nRight, INT nBottom,
   INT nDistance, WORD nFlags)
{
   BYTE btWidth, btHeight;
   BYTE btCount;
   BYTE btFirst, btLast;
   char szAVTSeq[7];
   void *pBlock;
   char szBlank[81];
   BYTE btKeepHeight;
   BYTE btMaxRight;
   BYTE btMaxBottom;
   tODScrnTextInfo TextState;

   /* Log function entry if running in trace mode. */
   TRACE(TRACE_API, "od_scroll()");

   /* Ensure that OpenDoors has been initialized before proceeding. */
   if(!bODInitialized) od_init();

   OD_API_ENTRY();

   /* Get current display setting information. */
   ODScrnGetTextInfo(&TextState);

   /* Determine the height and width of the area to be scrolled. */
   btWidth=nRight-nLeft+1;
   btHeight=nBottom-nTop+1;

   /* Determine the number of lines currently in the area that will still */
   /* be visible after scrolling.                                         */
   btKeepHeight=btHeight-((nDistance>=0) ? nDistance : -nDistance);

   /* Determine the maximum bottom and left coordinates of an area to be */
   /* scrolled.                                                          */
   btMaxRight=TextState.winright-TextState.winleft+1;
   btMaxBottom=TextState.winbottom-TextState.wintop+1;

   /* Check that parameters are valid. */
   if(nLeft<1 || nTop<1 || nRight>btMaxRight || nBottom>btMaxBottom ||
      nLeft > nRight || nTop > nBottom)
   {
      od_control.od_error = ERR_PARAMETER;
      OD_API_EXIT();
      return(FALSE);
   }

   /* Check that ANSI or AVATAR graphics mode is available. */
   if(!od_control.user_ansi && !od_control.user_avatar)
   {
      od_control.od_error = ERR_NOGRAPHICS;
      OD_API_EXIT();
      return(FALSE);
   }

   /* If distance to be scrolled is 0, then we are finished already and */
   /* can return immediately.                                           */
   if(nDistance == 0)
   {
      OD_API_EXIT();
      return(TRUE);
   }

   /* If distance is positive, then we are moving text upwards. */
   if(nDistance>0)
   {
      /* Ensure that distance is not greater than size of scrolled area. */
      if(nDistance>btHeight)
      {
         nDistance=btHeight;
      }

      /* Calculate first and last line to be moved. */
      btFirst=nBottom-(nDistance-1);
      btLast=nBottom;
   }

   /* If distance is negative, then we are moving text downwards. */
   else /* if(nDistance<0) */
   {
      /* Ensure that distance is not greater than size of scrolled area. */
      if(nDistance<-btHeight)
      {
         nDistance=-btHeight;
      }

      /* Calculate first and last line to be moved. */
      btFirst=nTop;
      btLast=nTop-nDistance-1;
   }

   /* If AVATAR mode is available */
   if(od_control.user_avatar)
   {
      /* Generate AVATAR sequence which causes the remote terminal to */
      /* scroll an area of its screen.                                */
      szAVTSeq[0]=22;

      /* If scrolling text upwards. */
      if(nDistance>0)
      {
         /* Specify control sequence for scrolling upwards. */
         szAVTSeq[1]=10;
         szAVTSeq[2]=nDistance;

         /* Move text appropriate direction on local screen. */
         ODScrnCopyText((BYTE)nLeft, (BYTE)(nTop + nDistance), (BYTE)nRight,
            (BYTE)nBottom, (BYTE)nLeft, (BYTE)nTop);
      }
      /* If scrolling text downwards. */
      else /* if(disatnce<0) */
      {
         /* Specify control sequence for scrolling downwards. */
         szAVTSeq[1]=11;
         szAVTSeq[2]=-nDistance;

         /* Move text appropriate direction on local screen. */
         ODScrnCopyText((BYTE)nLeft, (BYTE)nTop, (BYTE)nRight,
            (BYTE)(nBottom + nDistance), (BYTE)nLeft, (BYTE)(nTop - nDistance));
      }

      /* Specify area to be scrolled to the AVATAR terminal. */
      szAVTSeq[3]=nTop;
      szAVTSeq[4]=nLeft;
      szAVTSeq[5]=nBottom;
      szAVTSeq[6]=nRight;

      /* Send the control sequence to the AVATAR terminal. */
      od_disp(szAVTSeq,7,FALSE);

      /* Generate string containing a blank line of text. */
      for(btCount=0;btCount<btWidth;++btCount) szBlank[btCount]=' ';
      szBlank[btCount]='\0';

      /* Blank-out lines that will no longer be visiable. */
      for(;btFirst<=btLast;++btFirst)
      {
         ODScrnSetCursorPos((BYTE)nLeft, btFirst);
         ODScrnDisplayString(szBlank);
      }

      /* Reset cursor position on local display. */
      ODScrnSetCursorPos(TextState.curx,TextState.cury);
   }

   /* Otherwise, we are using ANSI mode. */
   else /* if(od_control.user_ansi) */
   {
      /* If any of the original text will still be available after */
      /* scrolling.                                                */
      if(btKeepHeight>0)
      {
         /* Allocate some temporary memory to hold text to be "got". */
         if((pBlock=malloc(btKeepHeight*btWidth*2))==NULL)
         {
            /* If memory allocation failed, then scrolling fails. */
            od_control.od_error = ERR_MEMORY;
            OD_API_EXIT();
            return(FALSE);
         }

         /* If we are scrolling text upwards. */
         if(nDistance > 0)
         {
            /* Move text that will still be visible, using od_gettext() */
            /* and od_puttext().                                        */
            od_gettext(nLeft,nTop+nDistance,nRight,nBottom,pBlock);
            bScrollAction=FALSE;
            od_puttext(nLeft,nTop,nRight,nBottom-nDistance,pBlock);
            bScrollAction=TRUE;
         }

         /* If we are scrolling text downwards. */
         else /* if(nDistance < 0) */
         {
            /* Move text that will still be visible, using od_gettext() */
            /* and od_puttext().                                        */
            od_gettext(nLeft,nTop,nRight,nBottom+nDistance,pBlock);
            bScrollAction=FALSE;
            od_puttext(nLeft,nTop-nDistance,nRight,nBottom,pBlock);
            bScrollAction=TRUE;
         }

         /* Deallocate temporary memory block. */
         free(pBlock);
      }

      /* If new area clearing has not been disabled. */
      if(!(nFlags&SCROLL_NO_CLEAR))
      {
         /* Loop for lines that should be blank. */
         for(;btFirst<=btLast;++btFirst)
         {
            /* Move cursor to the beginning of this line. */
            od_set_cursor(btFirst,nLeft);

            /* If right boarder of area to be scrolled is the edge of the */
            /* screen, then we can use a quick control sequence to clear  */
            /* the rest of the line. Call od_clr_line() to do this.       */
            if(nRight == 80)
            {
               od_clr_line();
            }

            /* If right boarder of area to be scrolled is not at the edge */
            /* of the screen, then each line must be manually erased, by  */
            /* sending the appropriate number of blanks (spaces).         */
            else /* if(right != 80) */
            {
               od_repeat(' ',btWidth);
            }
         }
      }

      /* Reset the cursor to its original position. */
      od_set_cursor(TextState.cury,TextState.curx);
   }

   /* Return with success */
   OD_API_EXIT();
   return(TRUE);
}


/* ----------------------------------------------------------------------------
 * od_save_screen()
 *
 * Stores the contents of the entire screen into a buffer, along with
 * the current cursor location and display colour. Supports all display
 * modes.
 *
 * Parameters: pBuffer - Pointer to a buffer of at least 4004 bytes in size,
 *                       where the information on the current screen state
 *                       will be stored.
 *
 *     Return: TRUE on success, FALSE on failure.
 */
ODAPIDEF BOOL ODCALL od_save_screen(void *pBuffer)
{
   char btHeight;
   tODScrnTextInfo TextState;

   /* Log function entry if running in trace mode. */
   TRACE(TRACE_API, "od_save_screen()");

   /* Ensure that OpenDoors is initialized before proceeding. */
   if(!bODInitialized) od_init();

   OD_API_ENTRY();

   /* Check parameters and current output window size. */
   ODScrnGetTextInfo(&TextState);
   if(TextState.winleft!=1 || TextState.winright!=80 || !pBuffer)
   {
      od_control.od_error = ERR_PARAMETER;
      OD_API_EXIT();
      return(FALSE);
   }

   /* Store current cursor location in buffer. */
   ((char *)pBuffer)[0]=TextState.curx;
   ((char *)pBuffer)[1]=TextState.cury;

   /* Store current display colour in buffer. */
   ((char *)pBuffer)[2]=TextState.attribute;

   /* Store height of buffer stored. */
   ((char *)pBuffer)[3]=btHeight=TextState.winbottom-TextState.wintop+1;

   /* Store screen contents using local screen gettext() function. */
   OD_API_EXIT();
   return(ODScrnGetText(1,1,80,btHeight,(char *)pBuffer+4));
}


/* ----------------------------------------------------------------------------
 * od_restore_screen()
 *
 * Restores the screen contents, along with the current text colour and cursor
 * location, as previously stored by od_save_screen().
 *
 * Parameters: pBuffer - Pointer to buffer which was filled by a previous call
 *                       to od_save_screen().
 *
 *     Return: TRUE on success, FALSE on failure.
 */
ODAPIDEF BOOL ODCALL od_restore_screen(void *pBuffer)
{
   char *pch;
   char btPos;
   char chLast;
   char *pchTextBuffer;
   char btHeight;
   int nToReturn=TRUE;
   tODScrnTextInfo TextState;
   char btLine;
   char btDistance=0;
   char btCursorRow;

   /* Log function entry if running in trace mode. */
   TRACE(TRACE_API, "od_restore_screen()");

   /* Ensure that OpenDoors is initialized before proceeding. */
   if(!bODInitialized) od_init();

   OD_API_ENTRY();

   /* Check parameters and current output window size. */
   ODScrnGetTextInfo(&TextState);
   if(TextState.winleft!=1 || TextState.winright!=80 || !pBuffer)
   {
      od_control.od_error = ERR_PARAMETER;
      OD_API_EXIT();
      return(FALSE);
   }

   /* Determine current window height were text will be restored. */
   btHeight=TextState.winbottom-TextState.wintop+1;

   /* If current display window height is too small for entire buffer */
   /* to be re-displayed.                                             */
   if(btHeight<((char *)pBuffer)[3])
   {
      /* Then we will always display as much of the END of the buffer */
      /* as possible.                                                 */
      btDistance = btHeight - ((char *)pBuffer)[3];
   }
   else if(btHeight > ((char *)pBuffer)[3])
   {
      /* Otherwise, ensure that we don't try to display more lines that */
      /* are in the buffer.                                             */
      btHeight=((char *)pBuffer)[3];
   }

   /* Clear the remote and local screens. */
   od_clr_scr();

   /* If ANSI or AVATAR modes are available. */
   if(od_control.user_avatar || od_control.user_ansi)
   {
      /* Then we can efficiently display the buffer using od_puttext(). */
      bScrollAction=FALSE;
      nToReturn=od_puttext(1,1,80,btHeight,(char *)pBuffer+(4+((int)btDistance*160)));
      bScrollAction=TRUE;

      /* Restore original cursor location. */
      od_set_cursor(((char *)pBuffer)[1],((char *)pBuffer)[0]);

      /* Restore original display attribute. */
      od_set_attrib(((char *)pBuffer)[2]);
   }

   /* If we are operating in ASCII mode. */
   else /* if (!od_control.od_avatar && !od_control.caller_ansi) */
   {
      /* Then the buffer is displayed one line at a time, beginning  */
      /* at the top of the screen, up to the saved cusrsor location. */

      /* Set pointer to beginning of buffer to be displayed. */
      pchTextBuffer=(char *)pBuffer+4;

      /* Get final cursor row number. */
      btCursorRow=((char *)pBuffer)[1];

      /* Loop for each line in the buffer. */
      for(btLine=1;btLine<=btHeight;++btLine)
      {
         /* Set pointer to last character of line. */
         pch=(char *)pchTextBuffer+158;

         /* Loop backwards until a non-blank character is found, or we */
         /* reach the beginning of the line.                           */
         for(chLast=80;chLast>1;)
         {
            /* If this is a blank character. */
            if(*pch==32 || *pch==0)
            {
               /* Move to previous character. */
               --chLast;
               pch-=2;
            }

            /* If this is not a blank character, then stop looping. */
            else
            {
               break;
            }
         }

         /* If this is the line on which the cursor resides. */
         if(btLine==btCursorRow)
         {
            /* If last non-blank character of line is at or past the final */
            /* cursor location, then we backup the last character to be    */
            /* displayed to the cursor before the final cursor position.   */
            /* This code could be improved to be able to display text on   */
            /* the entire cursor line by displaying the entire line,       */
            /* sending a C/R, and redisplaying first portion of line to    */
            /* end up with the cursor in the desired position.             */
            if(chLast>=((char *)pBuffer)[0])
            {
               chLast=((char *)pBuffer)[0]-1;
            }
         }

         /* Display all characters on this line */
         pch = (char *)pchTextBuffer;
         for(btPos=1;btPos<=chLast;++btPos)
         {
            od_putch(*pch);
            pch+=2;
         }

         /* If this is the row where the cursor should be left, then we */
         /* stop displaying now.                                        */
         if(btLine==btCursorRow)
         {
            break;
         }

         /* If cursor hasn't been wrapped, then we should send a C/R - */
         /* L/F sequence.                                              */
         if(chLast != 80)
         {
            od_disp_str("\n\r");
            pchTextBuffer+=160;
         }
      }
   }

   /* Return with the appropriate success/failure status. */
   OD_API_EXIT();
   return(nToReturn);
}