root/trunk/txlib/txwprint.c

//
//                     TxWin, Textmode Windowing Library
//
//   Original code Copyright (c) 1995-2005 Fsys Software and Jan van Wijk
//
// ==========================================================================
//
// This file contains Original Code and/or Modifications of Original Code as
// defined in and that are subject to the GNU Lesser General Public License.
// You may not use this file except in compliance with the License.
// BY USING THIS FILE YOU AGREE TO ALL TERMS AND CONDITIONS OF THE LICENSE.
// A copy of the License is provided with the Original Code and Modifications,
// and is also available at http://www.dfsee.com/txwin/lgpl.htm
//
// 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.1 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; (lgpl.htm) if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Questions on TxWin licensing can be directed to: txwin@fsys.nl
//
// ==========================================================================
//
// TX Windowed text, redirect TxPrint output to scroll-buffer window
//
// Author: J. van Wijk
//
// JvW  18-05-99   Initial version
// JvW  31-05-99   Fixed width * width bug in memory-alloc (width * length)
// JvW  31-01-2000 Added follow_screen_toggle to allow screen on/off commands

#include <txlib.h>                              // public interface
#include <txwpriv.h>                            // private window interface


#define TXWP_ARG_SIZE   4
#define TXWP_NUM_ARGS  10
#define TXWP_ANSI_ESC  27

#define TXWP_MAX    0xffff                      // maximum rectangle value


static BYTE      txwpFgColor = TXwCNW;          // default foreground color
static BYTE      txwpBgColor = TXwCnZ;          // default background color

static ULONG     txwpVirtCol = 0;               // column on virtual screen
static ULONG     txwpVirtRow = 0;               // row    on virtual screen

static TXSBDATA *txwpScrBuff = NULL;            // scroll buffer
static char     *txwpLine    = NULL;            // intermediate line buffer
static TXH_INFO  txwpSla;                       // TxPrint copy specification

static char      txwpOriginalAnsiMode;          // remembered Ansi status

// Convert and write ANSI-input string to a windowed scroll-buffer
static void txwpHookScrollBuffer
(
   char               *text,                    // IN    TxPrint text to copy
   void               *data                     // IN    user data (not used)
);

// Parse ANSI clause
static char *txwpParseAnsi
(
   char               *current                  // IN    this character
);

// Parse ANSI clause without arguments
static void txwpParseAnsiClause
(
   char               *current,                 // IN    this character
   BOOL               *syntax                   // OUT   ANSI syntax error
);

// Parse ANSI clause including arguments
static char *txwpParseAnsiArgs
(
   char               *current,                 // IN    this character
   BOOL               *syntax                   // OUT   ANSI syntax error
);

// Clear virtual screen, clearing scroll-buffer and reset to default position
static void txwpClearScreen
(
   void
);

// Goto specified x/y position in virtual screen
static void txwpGotoXY
(
   ULONG               x,                       // IN    x coordinate (column)
   ULONG               y                        // IN    y coordinate (row)
);

// Clear to end-of-line, on current line in scroll-buffer
static void txwpClearToEOL
(
   void
);

// Write one character to the Scroll-buffer, handle newline (scroll) and wrap
static void txwpWriteCharacter
(
   char                ch                       // IN    ASCII character value
);

// Scroll the scroll-buffer up on line and adjust positions
static void txwpScrollUpOneLine
(
   void
);

// Automatic update of associated views for the scroll-buffer
static void txwpAutoUpdateView
(
   void
);


/*****************************************************************************/
// Initialize TxPrint hook to a scroll-buffer and related views
/*****************************************************************************/
ULONG txwInitPrintfSBHook
(
   TXSBDATA           *sbuf                     // IN    Scroll-buffer data
)
{
   ULONG               rc = NO_ERROR;           // function return

   ENTER();

   if ((txwpScrBuff == NULL) && (sbuf->buf == NULL))
   {
      if ((sbuf->buf = TxAlloc(sbuf->width * sizeof(TXCELL),
                                          sbuf->length)) != NULL)
      {
         if ((txwpLine = TxAlloc(1,  TXMAX4K)) != NULL)
         {
            sbuf->firstline = sbuf->length - sbuf->vsize;
            txwpScrBuff     = sbuf;
            txwpClearScreen();                  // clear the scroll-buffer

            txwpSla.user    = NULL;
            txwpSla.cbuf    = txwpLine;
            txwpSla.size    = TXMAX4K;
            txwpSla.copy    = txwpHookScrollBuffer;
            txwpSla.active  = TRUE;
            txwpSla.follow_screen_toggle = TRUE;
            TxPrintHook( TXH_T_RAW, TXH_REGISTER, &txwpSla);

            txwpOriginalAnsiMode = TxGetAnsiMode();
            if (TxaExeSwitch('a') == FALSE)
            {
               TxSetAnsiMode( A_ON);            // allow color from now on
            }
         }
         else
         {
            TxFreeMem( sbuf->buf);
            rc = TX_ALLOC_ERROR;
         }
      }
      else
      {
         rc = TX_ALLOC_ERROR;
      }
   }
   else
   {
      rc = TX_PENDING;                          // buffer already in use
   }
   RETURN (rc);
}                                               // end 'txwInitPrintfSBHook'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Terminate TxPrint hook to a scroll-buffer and related views
/*****************************************************************************/
void txwTermPrintfSBHook
(
   void
)
{
   ENTER();

   TxSetAnsiMode( txwpOriginalAnsiMode);        // restore ansi mode

   TxPrintHook( TXH_T_RAW, TXH_DEREGISTER, &txwpSla);

   TxFreeMem( txwpLine);
   TxFreeMem( txwpScrBuff->buf);

   txwpScrBuff = NULL;

   VRETURN();
}                                               // end 'txwTermPrintfSBHook'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Convert and write ANSI-input string to a windowed scroll-buffer
/*****************************************************************************/
static void txwpHookScrollBuffer
(
   char               *text,                    // IN    TxPrint text to copy
   void               *data                     // IN    user data (not used)
)
{
   char               *current = text;

   while (*current)
   {
      if (*current == TXWP_ANSI_ESC)
      {
         current = txwpParseAnsi(current);
      }
      else
      {
         txwpWriteCharacter(*current);
      }
      current++;
   }
   txwpAutoUpdateView();
}                                               // end 'txwpHookScrollBuffer'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Parse ANSI clause
/*****************************************************************************/
static char *txwpParseAnsi
(
   char               *current                  // IN    this character
)
{
   BOOL                error = FALSE;           // syntax error indicator
   char               *keep  = current;

   current++;
   if (*current != '[')
   {
      error = TRUE;
   }
   else
   {
      current++;
      if (!isdigit(*current))
      {
         txwpParseAnsiClause( current, &error);
      }
      else
      {
         current = txwpParseAnsiArgs(current, &error);
      }
   }
   if (error)
   {
      txwpWriteCharacter(*keep);
      return keep;
   }
   else
   {
      return current;
   }
}                                               // end 'txwpParseAnsi'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Parse ANSI clause without arguments
/*****************************************************************************/
static void txwpParseAnsiClause
(
   char               *current,                 // IN    this character
   BOOL               *syntax                   // OUT   ANSI syntax error
)
{
   static ULONG x = 0;
   static ULONG y = 0;

   switch (*current)
   {
      case 'A': txwpGotoXY( txwpVirtCol    , txwpVirtRow + 1);     break;
      case 'B': txwpGotoXY( txwpVirtCol    , txwpVirtRow - 1);     break;
      case 'C': txwpGotoXY( txwpVirtCol + 1, txwpVirtRow    );     break;
      case 'D': txwpGotoXY( txwpVirtCol - 1, txwpVirtRow    );     break;
      case 'H': txwpGotoXY( 0              , 0              );     break;
      case 'u': txwpGotoXY( x              , y              );     break;
      case 's':             x = txwpVirtCol; y  = txwpVirtRow;     break;
      case 'K': txwpClearToEOL();                                  break;
      default : *syntax = TRUE;
   }
}                                               // end 'txwpParseAnsiClause'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Parse ANSI clause including arguments
/*****************************************************************************/
static char *txwpParseAnsiArgs
(
   char               *current,                 // IN    this character
   BOOL               *syntax                   // OUT   ANSI syntax error
)
{
   int                 i;
   int                 argument[TXWP_NUM_ARGS];
   int                 count    = 0;
   BYTE                intensFg = 0;
   BYTE                intensBg = 0;

   if ((*current == '2') && (*(current + 1) == 'J'))
   {
      ++current;
      txwpClearScreen();
   }
   else
   {
      while (isdigit(*current) && (count <= TXWP_NUM_ARGS))
      {

         int           index = 0;
         char          arg[TXWP_ARG_SIZE];

         while (isdigit(*current) && (index < TXWP_ARG_SIZE))
         {
            arg[index++] = *current++;
         }

         if (index == TXWP_ARG_SIZE)
         {
            *syntax = TRUE;
         }
         else
         {
            arg[index] = 0;
         }

         argument[count++] = atoi(arg);

         if (*current == ';')
         {
            ++current;
         }
      }

      if (count == TXWP_NUM_ARGS)
      {
         *syntax = TRUE;
      }
      else
      {
         switch (*current)
         {
            case 'A':
               if (count == 1)
               {
                  txwpGotoXY( txwpVirtCol, txwpVirtRow - (ULONG) argument[0]);
               }
               else
               {
                  *syntax = TRUE;
               }
               break;

            case 'B':
               if (count == 1)
               {
                  txwpGotoXY( txwpVirtCol, txwpVirtRow + (ULONG) argument[0]);
               }
               else
               {
                  *syntax = TRUE;
               }
               break;

            case 'C':
               if (count == 1)
               {
                  txwpGotoXY( txwpVirtCol + (ULONG) argument[0], txwpVirtRow);
               }
               else
               {
                  *syntax = TRUE;
               }
               break;

            case 'D':
               if (count == 1)
               {
                  txwpGotoXY( txwpVirtCol - (ULONG) argument[0], txwpVirtRow);
               }
               else
               {
                  *syntax = TRUE;
               }
               break;

            case 'H':
               if (count == 2)
               {
                  txwpGotoXY( argument[1], argument[0]);
               }
               else
               {
                  *syntax = TRUE;
               }
               break;

            case 'm':
               for (i = 0; i < count; i++)
               {
                  switch (argument[i])
                  {
                     case  0 :
                        if (count == 1)         // color reset
                        {
                           txwpFgColor = TXwCNW; // default foreground color
                           txwpBgColor = TXwCnZ; // default background color
                        }
                        else
                        {
                           intensFg = 0;
                           intensBg = 0;
                        }
                        break;

                     case 1:                    // High intensity (FG)
                        intensFg = TXwINT;
                        break;

                     case 2:                    // DIM intensity
                     case 4:                    // Underlined
                     case 6:                    // Fast-blink
                     case 7:                    // Reverse video
                     case 8:                    // Hidden character
                        break;

                     case 5:                    // Blink (or high-intensity BG)
                        intensBg = (TXwINT << 4);
                        break;

                     case 30 : txwpFgColor = ( TXwCNZ | intensFg ); break;
                     case 31 : txwpFgColor = ( TXwCNR | intensFg ); break;
                     case 32 : txwpFgColor = ( TXwCNG | intensFg ); break;
                     case 33 : txwpFgColor = ( TXwCNY | intensFg ); break;
                     case 34 : txwpFgColor = ( TXwCNB | intensFg ); break;
                     case 35 : txwpFgColor = ( TXwCNM | intensFg ); break;
                     case 36 : txwpFgColor = ( TXwCNC | intensFg ); break;
                     case 37 : txwpFgColor = ( TXwCNW | intensFg ); break;
                     case 40 : txwpBgColor = ( TXwCnZ | intensBg ); break;
                     case 41 : txwpBgColor = ( TXwCnR | intensBg ); break;
                     case 42 : txwpBgColor = ( TXwCnG | intensBg ); break;
                     case 43 : txwpBgColor = ( TXwCnY | intensBg ); break;
                     case 44 : txwpBgColor = ( TXwCnB | intensBg ); break;
                     case 45 : txwpBgColor = ( TXwCnM | intensBg ); break;
                     case 46 : txwpBgColor = ( TXwCnC | intensBg ); break;
                     case 47 : txwpBgColor = ( TXwCnW | intensBg ); break;
                     default : *syntax = TRUE;
                  }
               }
               break;

            default : *syntax = TRUE;
         }
      }
   }
   if (*syntax)
   {
      return NULL;
   }
   else
   {
      return current;
   }
}                                               // end 'txwpParseAnsiArgs'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Clear virtual screen, clearing scroll-buffer and reset to default position
/*****************************************************************************/
static void txwpClearScreen
(
   void
)
{
   size_t              lsize = (size_t) txwpScrBuff->width * sizeof(TXCELL);

   memset(  txwpScrBuff->buf, 0,  ((size_t) txwpScrBuff->length * lsize));
   txwpGotoXY( 0, 0);
}                                               // end 'txwpClearScreen'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Goto specified x/y position in virtual screen
/*****************************************************************************/
static void txwpGotoXY
(
   ULONG               x,                       // IN    x coordinate (column)
   ULONG               y                        // IN    y coordinate (row)
)
{
   txwpVirtCol = x;
   txwpVirtRow = min( y, txwpScrBuff->vsize -1);
}                                               // end 'txwpGotoXY'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Clear to end-of-line, on current line in scroll-buffer
/*****************************************************************************/
static void txwpClearToEOL
(
   void
)
{
   TXCELL              cell;                    // CELL contents to write
   ULONG               line;                    // targetline in scroll-buffer
   ULONG               index;                   // index in scroll-buffer
   ULONG               col;                     // current column in line

   cell.ch = ' ';                               // fill with spaces
   cell.at = txwpFgColor | txwpBgColor;         // in the current color

   line  = txwpScrBuff->length - txwpScrBuff->vsize + txwpVirtRow;
   index = line * txwpScrBuff->width + txwpVirtCol;
   for (col = txwpVirtCol; col < txwpScrBuff->width; col++, index++)
   {
      txwpScrBuff->buf[ index] = cell;
   }
}                                               // end 'txwpClearToEOL'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Write one character to the Scroll-buffer, handle newline (scroll) and wrap
/*****************************************************************************/
static void txwpWriteCharacter
(
   char                ch                       // IN    ASCII character value
)
{
   TXCELL              cell;                    // CELL contents to write
   ULONG               line;                    // targetline in scroll-buffer

   switch (ch)
   {
      case '\n':                                // newline in string
         if (txwpVirtRow == txwpScrBuff->vsize -1) // writing at bottom line
         {
            txwpScrollUpOneLine();
         }
         else                                   // write om previous lines
         {
            txwpGotoXY( 0, txwpVirtRow + 1);
         }
         break;

      default:
         cell.ch = ch;
         cell.at = txwpFgColor | txwpBgColor;
         if (txwpVirtRow == txwpScrBuff->vsize -1) // writing at bottom line
         {
            if ((txwpScrBuff->wrap) && (txwpVirtCol >= txwpScrBuff->width))
            {
               txwpScrollUpOneLine();
            }
         }
         if (txwpVirtCol < txwpScrBuff->width)  // within the line-width ?
         {
            line = txwpScrBuff->length - txwpScrBuff->vsize + txwpVirtRow;
            txwpScrBuff->buf[ line * txwpScrBuff->width + txwpVirtCol] = cell;
         }
         txwpVirtCol++;
         break;
   }
}                                               // end 'txwpWriteCharacter'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Scroll the scroll-buffer up on line and adjust positions
/*****************************************************************************/
static void txwpScrollUpOneLine
(
   void
)
{
   size_t              lsize = (size_t) txwpScrBuff->width * sizeof(TXCELL);
   ULONG               lines = txwpScrBuff->length -1;

   txwpVirtCol         = 0;                     // column in virtual screen

   memmove( &(txwpScrBuff->buf[0]),                  //- dest, begin buf
            &(txwpScrBuff->buf[txwpScrBuff->width]), //- source, 1 line ahead
            lsize * ((size_t) lines));               //- bufsize minus 1 line

   memset(  &(txwpScrBuff->buf[lines * txwpScrBuff->width]),
            0, lsize);                          // clear the bottom line

   if (txwpScrBuff->firstline != 0)
   {                                            // count back, until at top
      txwpScrBuff->firstline--;                 // of the scroll-buffer
   }
   if (txwpScrBuff->midscroll == FALSE)         // adjust scroll position
   {
      TXWINBASE   *wnd = (TXWINBASE *) txwpScrBuff->view;

      if ((wnd = (TXWINBASE *) txwpScrBuff->view) != NULL)
      {
         if (wnd->window->sb.topline < (txwpScrBuff->length -
                                        txwpScrBuff->vsize))
         {
            if (wnd->window->sb.topline != 0)
            {                                   // count back, until at top
               wnd->window->sb.topline--;       // of the scroll-buffer
            }
         }
      }
   }
}                                               // end 'txwpScrollUpOneLine'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Automatic update of invalid areas of associated views for the scroll-buffer
/*****************************************************************************/
static void txwpAutoUpdateView
(
   void
)
{
   TXWINBASE          *wnd;

   if ((wnd = (TXWINBASE *) txwpScrBuff->view) != NULL)
   {
      txwPaintSbView( wnd);
   }
}                                               // end 'txwpAutoUpdateView'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// ScrollBuff paint window, SBVIEW only; without any internal tracing!!!
/*****************************************************************************/
void txwPaintSbView
(
   TXWINBASE          *wnd                      // IN    current window
)
{
   TXWINDOW           *win;
   short               sy;                      // vertical size
   short               nr;                      // line-nr while painting
   short               size;                    // size of one line
   ULONG               first;                   // first cell (top-left)
   TXCELL             *cline;                   // cell line pointer
   TXRECT              parent;                  // parent clip rectangle
   TXRECT              clip;                    // region clip rectangle
   TXRECT_ELEM         regs;                    // visible line regions
   TXRECT_ELEM        *r;                       // current region
   TXRECT_ELEM        *n;                       // next region
   TXWINBASE          *focusShadow;             // focus related shadow window

   if ((txwValidateAndClip((TXWHANDLE) wnd, &win, FALSE, &parent)) != NULL)
   {
      sy    = win->client.bottom - win->client.top   +1;
      size  = (short) txwpScrBuff->width;
      first = win->sb.topline * size + (ULONG) win->sb.leftcol;

      cline = &(txwpScrBuff->buf[first]);       // top-left cell in SBview

      TXSCREEN_BEGIN_UPDATE();
      for (nr = 0; nr < (sy -1); nr++, cline += size)
      {
         regs.rect = win->client;               // start with full line
         regs.next = NULL;                      // as a single element
         regs.skip = FALSE;                     // it is a valid element

         regs.rect.top   += nr;                 // actual line position
         regs.rect.bottom = regs.rect.top;      // just 1-line vertical

         txwVisibleLineRegions( wnd, &regs);    // calculate visible regions

         for (r = &regs; r; r = r->next)        // Draw each line region
         {
            if (r->skip == FALSE)               // but only when valid
            {
               if (txwIntersectRect( &parent, &(r->rect), &clip))
               {
                  txwScrDrawCellString( win->client.top + nr,
                                        win->client.left,
                                        &clip, cline, size, win->sb.altcol);
               }
            }
         }

         for (r = regs.next; r; r = n)          // Free extra line regions
         {
            n = r->next;                        // next region in the list
            free( r);
         }
      }
      txwPaintWinStatus( wnd, NULL, 0);         // update SB line counters etc

      focusShadow = txwa->focus;
      if ((focusShadow != NULL) && (focusShadow->window != NULL))
      {
         if (focusShadow->window->style & TXWS_CAST_SHADOW)
         {
            txwPaintShadow( focusShadow);       // focus window border refresh
         }
         else                                   // retry on focus owner (dlg)
         {
            focusShadow = focusShadow->owner;
            if ((focusShadow != NULL) && (focusShadow->window != NULL))
            {
               if (focusShadow->window->style & TXWS_CAST_SHADOW)
               {
                  txwPaintShadow( focusShadow);
               }
            }
         }
      }
      TXSCREEN_ENDOF_UPDATE();
   }
}                                               // end 'txwPaintSbView'
/*---------------------------------------------------------------------------*/


/*****************************************************************************/
// Save (part of) the scroll buffer to specified file as plain ASCII
/*****************************************************************************/
ULONG txwSavePrintfSB                           // RET   nr of lines written
(
   char               *fname,                   // IN    name of output file
   ULONG               lines,                   // IN    lines from start/end
   BOOL                fromEnd                  // IN    last lines (from end)
)
{
   FILE               *df;                      // destination file ptr
   ULONG               done = 0;                // nr of lines done

   ENTER();

   if (txwpScrBuff != NULL)
   {
      if ((df = fopen( fname, "w" TXFMODE)) != NULL) // create new text file
      {
         ULONG         used;                    // nr of lines in buffer
         ULONG         first;                   // first line to save
         ULONG         todo;                    // nr of lines to save
         ULONG         l;                       // line nr in buffer
         ULONG         i;                       // cell nr in line
         ULONG         maxi;                    // maximum line length
         ULONG         lstart;                  // index of 1st cell in line
         TX1K          line;                    // ASCII copy of the line

         used  = txwpScrBuff->length - txwpScrBuff->firstline;
         if (lines >= used)
         {
            first = txwpScrBuff->firstline;
            todo  = txwpScrBuff->length - first;
         }
         else
         {
            todo = lines;
            if (fromEnd)
            {
               first = txwpScrBuff->length - todo;
            }
            else
            {
               first = txwpScrBuff->firstline;
            }
         }
         maxi = (txwpScrBuff->width < TXMAX1K -1) ? txwpScrBuff->width
                                    : TXMAX1K -1;

         for (l = first, done = 0;