/*
* out2window.c
* Copyright (C) 1998-2005 A.J. van Os; Released under GPL
*
* Description:
* Output to a text window
*/

#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "antiword.h"

/* Used for numbering the chapters */
static unsigned int     auiHdrCounter[9];


/*
* vString2Diagram - put a string into a diagram
*/
static void
vString2Diagram(diagram_type *pDiag, output_type *pAnchor)
{
       output_type     *pOutput;
       long            lWidth;
       USHORT          usMaxFontSize;

       TRACE_MSG("vString2Diagram");

       fail(pDiag == NULL);
       fail(pAnchor == NULL);

       /* Compute the maximum fontsize in this string */
       usMaxFontSize = MIN_FONT_SIZE;
       for (pOutput = pAnchor; pOutput != NULL; pOutput = pOutput->pNext) {
               if (pOutput->usFontSize > usMaxFontSize) {
                       usMaxFontSize = pOutput->usFontSize;
               }
       }

       /* Goto the next line */
       vMove2NextLine(pDiag, pAnchor->tFontRef, usMaxFontSize);

       /* Output all substrings */
       for (pOutput = pAnchor; pOutput != NULL; pOutput = pOutput->pNext) {
               lWidth = lMilliPoints2DrawUnits(pOutput->lStringWidth);
               vSubstring2Diagram(pDiag, pOutput->szStorage,
                       pOutput->tNextFree, lWidth, pOutput->ucFontColor,
                       pOutput->usFontStyle, pOutput->tFontRef,
                       pOutput->usFontSize, usMaxFontSize);
       }

       /* Goto the start of the line */
       pDiag->lXleft = 0;
       TRACE_MSG("leaving vString2Diagram");
} /* end of vString2Diagram */

/*
* vSetLeftIndentation - set the left indentation of the specified diagram
*/
void
vSetLeftIndentation(diagram_type *pDiag, long lLeftIndentation)
{
       long    lX;

       TRACE_MSG("vSetLeftIndentation");

       fail(pDiag == NULL);
       fail(lLeftIndentation < 0);

       lX = lMilliPoints2DrawUnits(lLeftIndentation);
       if (lX > 0) {
               pDiag->lXleft = lX;
       } else {
               pDiag->lXleft = 0;
       }
} /* end of vSetLeftIndentation */

/*
* lComputeNetWidth - compute the net string width
*/
static long
lComputeNetWidth(output_type *pAnchor)
{
       output_type     *pTmp;
       long            lNetWidth;

       TRACE_MSG("lComputeNetWidth");

       fail(pAnchor == NULL);

       /* Step 1: Count all but the last sub-string */
       lNetWidth = 0;
       for (pTmp = pAnchor; pTmp->pNext != NULL; pTmp = pTmp->pNext) {
               fail(pTmp->lStringWidth < 0);
               lNetWidth += pTmp->lStringWidth;
       }
       fail(pTmp == NULL);
       fail(pTmp->pNext != NULL);

       /* Step 2: remove the white-space from the end of the string */
       while (pTmp->tNextFree != 0 &&
              isspace((int)(UCHAR)pTmp->szStorage[pTmp->tNextFree - 1])) {
               pTmp->szStorage[pTmp->tNextFree - 1] = '\0';
               pTmp->tNextFree--;
               NO_DBG_DEC(pTmp->lStringWidth);
               pTmp->lStringWidth = lComputeStringWidth(
                                               pTmp->szStorage,
                                               pTmp->tNextFree,
                                               pTmp->tFontRef,
                                               pTmp->usFontSize);
               NO_DBG_DEC(pTmp->lStringWidth);
       }

       /* Step 3: Count the last sub-string */
       lNetWidth += pTmp->lStringWidth;
       return lNetWidth;
} /* end of lComputeNetWidth */

/*
* iComputeHoles - compute number of holes
* (A hole is a number of whitespace characters followed by a
*  non-whitespace character)
*/
static int
iComputeHoles(output_type *pAnchor)
{
       output_type     *pTmp;
       size_t  tIndex;
       int     iCounter;
       BOOL    bWasSpace, bIsSpace;

       TRACE_MSG("iComputeHoles");

       fail(pAnchor == NULL);

       iCounter = 0;
       bIsSpace = FALSE;
       /* Count the holes */
       for (pTmp = pAnchor; pTmp != NULL; pTmp = pTmp->pNext) {
               fail(pTmp->tNextFree != strlen(pTmp->szStorage));
               for (tIndex = 0; tIndex <= pTmp->tNextFree; tIndex++) {
                       bWasSpace = bIsSpace;
                       bIsSpace = isspace((int)(UCHAR)pTmp->szStorage[tIndex]);
                       if (bWasSpace && !bIsSpace) {
                               iCounter++;
                       }
               }
       }
       return iCounter;
} /* end of iComputeHoles */

/*
* vAlign2Window - Align a string and insert it into the text
*/
void
vAlign2Window(diagram_type *pDiag, output_type *pAnchor,
       long lScreenWidth, UCHAR ucAlignment)
{
       long    lNetWidth, lLeftIndentation;

       TRACE_MSG("vAlign2Window");

       fail(pDiag == NULL || pAnchor == NULL);
       fail(lScreenWidth < lChar2MilliPoints(MIN_SCREEN_WIDTH));

       lNetWidth = lComputeNetWidth(pAnchor);

       if (lScreenWidth > lChar2MilliPoints(MAX_SCREEN_WIDTH) ||
           lNetWidth <= 0) {
               /*
                * Screenwidth is "infinite", so no alignment is possible
                * Don't bother to align an empty line
                */
               vString2Diagram(pDiag, pAnchor);
               TRACE_MSG("leaving vAlign2Window #1");
               return;
       }

       switch (ucAlignment) {
       case ALIGNMENT_CENTER:
               lLeftIndentation = (lScreenWidth - lNetWidth) / 2;
               DBG_DEC_C(lLeftIndentation < 0, lLeftIndentation);
               if (lLeftIndentation > 0) {
                       vSetLeftIndentation(pDiag, lLeftIndentation);
               }
               break;
       case ALIGNMENT_RIGHT:
               lLeftIndentation = lScreenWidth - lNetWidth;
               DBG_DEC_C(lLeftIndentation < 0, lLeftIndentation);
               if (lLeftIndentation > 0) {
                       vSetLeftIndentation(pDiag, lLeftIndentation);
               }
               break;
       case ALIGNMENT_JUSTIFY:
       case ALIGNMENT_LEFT:
       default:
               break;
       }
       vString2Diagram(pDiag, pAnchor);
       TRACE_MSG("leaving vAlign2Window #2");
} /* end of vAlign2Window */

/*
* vJustify2Window - Justify a string and insert it into the text
*/
void
vJustify2Window(diagram_type *pDiag, output_type *pAnchor,
       long lScreenWidth, long lRightIndentation, UCHAR ucAlignment)
{
       output_type     *pTmp;
       char    *pcNew, *pcOld, *szStorage;
       long    lNetWidth, lSpaceWidth, lToAdd;
       int     iFillerLen, iHoles;

       TRACE_MSG("vJustify2Window");

       fail(pDiag == NULL || pAnchor == NULL);
       fail(lScreenWidth < MIN_SCREEN_WIDTH);
       fail(lRightIndentation > 0);

       if (ucAlignment != ALIGNMENT_JUSTIFY) {
               vAlign2Window(pDiag, pAnchor, lScreenWidth, ucAlignment);
               return;
       }

       lNetWidth = lComputeNetWidth(pAnchor);

       if (lScreenWidth > lChar2MilliPoints(MAX_SCREEN_WIDTH) ||
           lNetWidth <= 0) {
               /*
                * Screenwidth is "infinite", so justify is not possible
                * Don't bother to justify an empty line
                */
               vString2Diagram(pDiag, pAnchor);
               TRACE_MSG("leaving vJustify2Window #1");
               return;
       }

       /* Justify */
       fail(ucAlignment != ALIGNMENT_JUSTIFY);
       lSpaceWidth = lComputeStringWidth(" ", 1,
                               pAnchor->tFontRef, pAnchor->usFontSize);
       lToAdd = lScreenWidth -
                       lNetWidth -
                       lDrawUnits2MilliPoints(pDiag->lXleft) +
                       lRightIndentation;
#if defined(DEBUG)
       if (lToAdd / lSpaceWidth < -1) {
               DBG_DEC(lSpaceWidth);
               DBG_DEC(lToAdd);
               DBG_DEC(lScreenWidth);
               DBG_DEC(lNetWidth);
               DBG_DEC(lDrawUnits2MilliPoints(pDiag->lXleft));
               DBG_DEC(pDiag->lXleft);
               DBG_DEC(lRightIndentation);
       }
#endif /* DEBUG */
       lToAdd /= lSpaceWidth;
       DBG_DEC_C(lToAdd < 0, lToAdd);
       if (lToAdd <= 0) {
               vString2Diagram(pDiag, pAnchor);
               TRACE_MSG("leaving vJustify2Window #2");
               return;
       }

       /* Justify by adding spaces */
       iHoles = iComputeHoles(pAnchor);
       for (pTmp = pAnchor; pTmp != NULL; pTmp = pTmp->pNext) {
               fail(pTmp->tNextFree != strlen(pTmp->szStorage));
               fail(lToAdd < 0);
               szStorage = xmalloc(pTmp->tNextFree + (size_t)lToAdd + 1);
               pcNew = szStorage;
               for (pcOld = pTmp->szStorage; *pcOld != '\0'; pcOld++) {
                       *pcNew++ = *pcOld;
                       if (*pcOld == ' ' &&
                           *(pcOld + 1) != ' ' &&
                           iHoles > 0) {
                               iFillerLen = (int)(lToAdd / iHoles);
                               lToAdd -= iFillerLen;
                               iHoles--;
                               for (; iFillerLen > 0; iFillerLen--) {
                                       *pcNew++ = ' ';
                               }
                       }
               }
               *pcNew = '\0';
               pTmp->szStorage = xfree(pTmp->szStorage);
               pTmp->szStorage = szStorage;
               pTmp->tStorageSize = pTmp->tNextFree + (size_t)lToAdd + 1;
               pTmp->lStringWidth +=
                       (pcNew - szStorage - (long)pTmp->tNextFree) *
                       lSpaceWidth;
               fail(pcNew < szStorage);
               pTmp->tNextFree = (size_t)(pcNew - szStorage);
               fail(pTmp->tNextFree != strlen(pTmp->szStorage));
       }
       DBG_DEC_C(lToAdd != 0, lToAdd);
       vString2Diagram(pDiag, pAnchor);
       TRACE_MSG("leaving vJustify2Window #3");
} /* end of vJustify2Window */

/*
* vResetStyles - reset the style information variables
*/
void
vResetStyles(void)
{
       TRACE_MSG("vResetStyles");

       (void)memset(auiHdrCounter, 0, sizeof(auiHdrCounter));
} /* end of vResetStyles */

/*
* tStyle2Window - Add the style characters to the line
*
* Returns the length of the resulting string
*/
size_t
tStyle2Window(char *szLine, size_t tLineSize, const style_block_type *pStyle,
       const section_block_type *pSection)
{
       char    *pcTxt;
       size_t  tIndex, tStyleIndex;
       BOOL    bNeedPrevLvl;
       level_type_enum eNumType;
       UCHAR   ucNFC;

       TRACE_MSG("tStyle2Window");

       fail(szLine == NULL || pStyle == NULL || pSection == NULL);

       if (pStyle->usIstd == 0 || pStyle->usIstd > 9) {
               szLine[0] = '\0';
               return 0;
       }

       /* Set the numbers */
       tStyleIndex = (size_t)pStyle->usIstd - 1;
       for (tIndex = 0; tIndex < 9; tIndex++) {
               if (tIndex == tStyleIndex) {
                       auiHdrCounter[tIndex]++;
               } else if (tIndex > tStyleIndex) {
                       auiHdrCounter[tIndex] = 0;
               } else if (auiHdrCounter[tIndex] == 0) {
                       auiHdrCounter[tIndex] = 1;
               }
       }

       eNumType = eGetNumType(pStyle->ucNumLevel);
       if (eNumType != level_type_outline) {
               szLine[0] = '\0';
               return 0;
       }

       /* Print the numbers */
       pcTxt = szLine;
       bNeedPrevLvl = (pSection->usNeedPrevLvl & BIT(tStyleIndex)) != 0;
       for (tIndex = 0; tIndex <= tStyleIndex; tIndex++) {
               if (tIndex == tStyleIndex ||
                   (bNeedPrevLvl && tIndex < tStyleIndex)) {
                       if (pcTxt - szLine >= tLineSize - 25) {
                               /* Prevent a possible buffer overflow */
                               DBG_DEC(pcTxt - szLine);
                               DBG_DEC(tLineSize - 25);
                               DBG_FIXME();
                               szLine[0] = '\0';
                               return 0;
                       }
                       ucNFC = pSection->aucNFC[tIndex];
                       switch(ucNFC) {
                       case LIST_ARABIC_NUM:
                       case LIST_NUMBER_TXT:
                       case LIST_ORDINAL_TXT:
                               pcTxt += sprintf(pcTxt, "%u",
                                       auiHdrCounter[tIndex]);
                               break;
                       case LIST_UPPER_ROMAN:
                       case LIST_LOWER_ROMAN:
                               pcTxt += tNumber2Roman(
                                       auiHdrCounter[tIndex],
                                       ucNFC == LIST_UPPER_ROMAN,
                                       pcTxt);
                               break;
                       case LIST_UPPER_ALPHA:
                       case LIST_LOWER_ALPHA:
                               pcTxt += tNumber2Alpha(
                                       auiHdrCounter[tIndex],
                                       ucNFC == LIST_UPPER_ALPHA,
                                       pcTxt);
                               break;
                       case LIST_OUTLINE_NUM:
                               pcTxt += sprintf(pcTxt, "%02u",
                                       auiHdrCounter[tIndex]);
                               break;
                       default:
                               DBG_DEC(ucNFC);
                               DBG_FIXME();
                               pcTxt += sprintf(pcTxt, "%u",
                                       auiHdrCounter[tIndex]);
                               break;
                       }
                       if (tIndex < tStyleIndex) {
                               *pcTxt++ = '.';
                       } else if (tIndex == tStyleIndex) {
                               *pcTxt++ = ' ';
                       }
               }
       }
       *pcTxt = '\0';
       NO_DBG_MSG_C((int)pStyle->usIstd >= 1 &&
               (int)pStyle->usIstd <= 9 &&
               eNumType != level_type_none &&
               eNumType != level_type_outline, szLine);
       NO_DBG_MSG_C(szLine[0] != '\0', szLine);
       fail(pcTxt < szLine);
       return (size_t)(pcTxt - szLine);
} /* end of tStyle2Window */

/*
* vRemoveRowEnd - remove the end of table row indicator
*
* Remove the double TABLE_SEPARATOR characters from the end of the string.
* Special: remove the TABLE_SEPARATOR, 0x0a sequence
*/
static void
vRemoveRowEnd(char *szRowTxt)
{
       int     iLastIndex;

       TRACE_MSG("vRemoveRowEnd");

       fail(szRowTxt == NULL || szRowTxt[0] == '\0');

       iLastIndex = (int)strlen(szRowTxt) - 1;

       if (szRowTxt[iLastIndex] == TABLE_SEPARATOR ||
           szRowTxt[iLastIndex] == (char)0x0a) {
               szRowTxt[iLastIndex] = '\0';
               iLastIndex--;
       } else {
               DBG_HEX(szRowTxt[iLastIndex]);
       }

       if (iLastIndex >= 0 && szRowTxt[iLastIndex] == (char)0x0a) {
               szRowTxt[iLastIndex] = '\0';
               iLastIndex--;
       }

       if (iLastIndex >= 0 && szRowTxt[iLastIndex] == TABLE_SEPARATOR) {
               szRowTxt[iLastIndex] = '\0';
               return;
       }

       DBG_DEC(iLastIndex);
       DBG_HEX(szRowTxt[iLastIndex]);
       DBG_MSG(szRowTxt);
} /* end of vRemoveRowEnd */

/*
* tComputeStringLengthMax - max string length in relation to max column width
*
* Return the maximum string length
*/
static size_t
tComputeStringLengthMax(const char *szString, size_t tColumnWidthMax)
{
       const char      *pcTmp;
       size_t  tLengthMax, tLenPrev, tLen, tWidth;

       TRACE_MSG("tComputeStringLengthMax");

       fail(szString == NULL);
       fail(tColumnWidthMax == 0);

       pcTmp = strchr(szString, '\n');
       if (pcTmp != NULL) {
               tLengthMax = (size_t)(pcTmp - szString + 1);
       } else {
               tLengthMax = strlen(szString);
       }
       if (tLengthMax == 0) {
               return 0;
       }

       tLen = 0;
       tWidth = 0;
       for (;;) {
               tLenPrev = tLen;
               tLen += tGetCharacterLength(szString + tLen);
               DBG_DEC_C(tLen > tLengthMax, tLen);
               DBG_DEC_C(tLen > tLengthMax, tLengthMax);
               fail(tLen > tLengthMax);
               tWidth = tCountColumns(szString, tLen);
               if (tWidth > tColumnWidthMax) {
                       return tLenPrev;
               }
               if (tLen >= tLengthMax) {
                       return tLengthMax;
               }
       }
} /* end of tComputeStringLengthMax */

/*
* tGetBreakingPoint - get the number of bytes that fit the column
*
* Returns the number of bytes that fit the column
*/
static size_t
tGetBreakingPoint(const char *szString,
       size_t tLen, size_t tWidth, size_t tColumnWidthMax)
{
       int     iIndex;

       TRACE_MSG("tGetBreakingPoint");

       fail(szString == NULL);
       fail(tLen > strlen(szString));
       fail(tWidth > tColumnWidthMax);

       if (tWidth < tColumnWidthMax ||
           (tWidth == tColumnWidthMax &&
            (szString[tLen] == ' ' ||
             szString[tLen] == '\n' ||
             szString[tLen] == '\0'))) {
               /* The string already fits, do nothing */
               return tLen;
       }
       /* Search for a breaking point */
       for (iIndex = (int)tLen - 1; iIndex >= 0; iIndex--) {
               if (szString[iIndex] == ' ') {
                       return (size_t)iIndex;
               }
       }
       /* No breaking point found, just fill the column */
       return tLen;
} /* end of tGetBreakingPoint */

/*
* tComputeColumnWidthMax - compute the maximum column width
*/
static size_t
tComputeColumnWidthMax(short sWidth, long lCharWidth, double dFactor)
{
       size_t  tColumnWidthMax;

       TRACE_MSG("tComputeColumnWidthMax");

       fail(sWidth < 0);
       fail(lCharWidth <= 0);
       fail(dFactor <= 0.0);

       tColumnWidthMax = (size_t)(
               (lTwips2MilliPoints(sWidth) * dFactor + lCharWidth / 2.0) /
                lCharWidth);
       if (tColumnWidthMax == 0) {
               /* Minimum column width */
               return 1;
       }
       if (tColumnWidthMax > 1) {
               /* Make room for the TABLE_SEPARATOR_CHAR */
               tColumnWidthMax--;
       }
       NO_DBG_DEC(tColumnWidthMax);
       return tColumnWidthMax;
} /* end of tComputeColumnWidthMax */

/*
* vTableRow2Window - put a table row into a diagram
*/
void
vTableRow2Window(diagram_type *pDiag, output_type *pOutput,
       const row_block_type *pRowInfo,
       conversion_type eConversionType, int iParagraphBreak)
{
       output_type     tRow;
       char    *aszColTxt[TABLE_COLUMN_MAX];
       char    *szLine, *pcTxt;
       double  dMagnify;
       long    lCharWidthLarge, lCharWidthSmall;
       size_t  tColumnWidthTotal, atColumnWidthMax[TABLE_COLUMN_MAX];
       size_t  tSize, tColumnWidthMax, tWidth, tLen;
       int     iIndex, iNbrOfColumns, iTmp;
       BOOL    bNotReady;

       TRACE_MSG("vTableRow2Window");

       fail(pDiag == NULL || pOutput == NULL || pRowInfo == NULL);
       fail(pOutput->szStorage == NULL);
       fail(pOutput->pNext != NULL);
       fail(iParagraphBreak < 0);

       /* Character sizes */
       lCharWidthLarge = lComputeStringWidth("W", 1,
                               pOutput->tFontRef, pOutput->usFontSize);
       NO_DBG_DEC(lCharWidthLarge);
       lCharWidthSmall = lComputeStringWidth("i", 1,
                               pOutput->tFontRef, pOutput->usFontSize);
       NO_DBG_DEC(lCharWidthSmall);
       /* For the time being: use a fixed width font */
       fail(lCharWidthLarge != lCharWidthSmall);

       vRemoveRowEnd(pOutput->szStorage);

       /* Split the row text into a set of column texts */
       aszColTxt[0] = pOutput->szStorage;
       for (iNbrOfColumns = 1;
            iNbrOfColumns < TABLE_COLUMN_MAX;
            iNbrOfColumns++) {
               aszColTxt[iNbrOfColumns] =
                               strchr(aszColTxt[iNbrOfColumns - 1],
                                       TABLE_SEPARATOR);
               if (aszColTxt[iNbrOfColumns] == NULL) {
                       break;
               }
               *aszColTxt[iNbrOfColumns] = '\0';
               aszColTxt[iNbrOfColumns]++;
               NO_DBG_DEC(iNbrOfColumns);
               NO_DBG_MSG(aszColTxt[iNbrOfColumns]);
       }

       /* Work around a bug in Word */
       while (iNbrOfColumns > (int)pRowInfo->ucNumberOfColumns &&
              pRowInfo->asColumnWidth[iNbrOfColumns] == 0) {
               iNbrOfColumns--;
       }

       DBG_DEC_C(iNbrOfColumns != (int)pRowInfo->ucNumberOfColumns,
               iNbrOfColumns);
       DBG_DEC_C(iNbrOfColumns != (int)pRowInfo->ucNumberOfColumns,
               pRowInfo->ucNumberOfColumns);
       if (iNbrOfColumns != (int)pRowInfo->ucNumberOfColumns) {
               werr(0, "Skipping an unmatched table row");
               return;
       }

#if defined(__FULL_TEXT_SEARCH)
       /* No table formatting: use for full-text search (untested) */
       for (iIndex = 0; iIndex < iNbrOfColumns; iIndex++) {
               fprintf(pDiag->pOutFile, "%s\n" , aszColTxt[iIndex]);
       }
#else
       if (bAddTableRow(pDiag, aszColTxt, iNbrOfColumns,
                       pRowInfo->asColumnWidth, pRowInfo->ucBorderInfo)) {
               /* All work has been done */
               return;
       }

       /* Fill the table with maximum column widths */
       if (eConversionType == conversion_text ||
           eConversionType == conversion_fmt_text) {
               if (iParagraphBreak == 0 ||
                   iParagraphBreak >= MAX_SCREEN_WIDTH) {
                       dMagnify = (double)MAX_SCREEN_WIDTH;
               } else if (iParagraphBreak <= MIN_SCREEN_WIDTH) {
                       dMagnify = (double)MIN_SCREEN_WIDTH;
               } else {
                       dMagnify = (double)iParagraphBreak;
               }
               dMagnify /= (double)DEFAULT_SCREEN_WIDTH;
               DBG_FLT_C(dMagnify < 0.99 || dMagnify > 1.01, dMagnify);
       } else {
               dMagnify = 1.0;
       }
       tColumnWidthTotal = 0;
       for (iIndex = 0; iIndex < iNbrOfColumns; iIndex++) {
               atColumnWidthMax[iIndex] = tComputeColumnWidthMax(
                                       pRowInfo->asColumnWidth[iIndex],
                                       lCharWidthLarge,
                                       dMagnify);
               tColumnWidthTotal += atColumnWidthMax[iIndex];
       }

       /*
        * Get enough space for the row.
        * Worst case: three bytes per UTF-8 character
        */
       tSize = 3 * (1 + tColumnWidthTotal + (size_t)iNbrOfColumns + 3);
       szLine = xmalloc(tSize);

       do {
               /* Print one line of a table row */
               bNotReady = FALSE;
               pcTxt = szLine;
               *pcTxt++ = TABLE_SEPARATOR_CHAR;
               for (iIndex = 0; iIndex < iNbrOfColumns; iIndex++) {
                       tColumnWidthMax = atColumnWidthMax[iIndex];
                       if (aszColTxt[iIndex] == NULL) {
                               /* Add an empty column */
                               for (iTmp = 0;
                                    iTmp < (int)tColumnWidthMax;
                                    iTmp++) {
                                       *pcTxt++ = (char)FILLER_CHAR;
                               }
                               *pcTxt++ = TABLE_SEPARATOR_CHAR;
                               *pcTxt = '\0';
                               continue;
                       }
                       /* Compute the length and width of the column text */
                       tLen = tComputeStringLengthMax(
                                       aszColTxt[iIndex], tColumnWidthMax);
                       NO_DBG_DEC(tLen);
                       while (tLen != 0 &&
                                       (aszColTxt[iIndex][tLen - 1] == '\n' ||
                                        aszColTxt[iIndex][tLen - 1] == ' ')) {
                               aszColTxt[iIndex][tLen - 1] = ' ';
                               tLen--;
                       }
                       tWidth = tCountColumns(aszColTxt[iIndex], tLen);
                       fail(tWidth > tColumnWidthMax);
                       tLen = tGetBreakingPoint(aszColTxt[iIndex],
                                       tLen, tWidth, tColumnWidthMax);
                       tWidth = tCountColumns(aszColTxt[iIndex], tLen);
                       if (tLen == 0 && *aszColTxt[iIndex] == '\0') {
                               /* No text at all */
                               aszColTxt[iIndex] = NULL;
                       } else {
                               /* Add the text */
                               pcTxt += sprintf(pcTxt,
                                       "%.*s", (int)tLen, aszColTxt[iIndex]);
                               if (tLen == 0 && *aszColTxt[iIndex] != ' ') {
                                       tLen = tGetCharacterLength(
                                                       aszColTxt[iIndex]);
                                       DBG_CHR(*aszColTxt[iIndex]);
                                       DBG_FIXME();
                                       fail(tLen == 0);
                               }
                               aszColTxt[iIndex] += tLen;
                               while (*aszColTxt[iIndex] == ' ') {
                                       aszColTxt[iIndex]++;
                               }
                               if (*aszColTxt[iIndex] == '\0') {
                                       /* This row is now complete */
                                       aszColTxt[iIndex] = NULL;
                               } else {
                                       /* This row needs more lines */
                                       bNotReady = TRUE;
                               }
                       }
                       /* Fill up the rest */
                       for (iTmp = 0;
                            iTmp < (int)tColumnWidthMax - (int)tWidth;
                            iTmp++) {
                               *pcTxt++ = (char)FILLER_CHAR;
                       }
                       /* End of column */
                       *pcTxt++ = TABLE_SEPARATOR_CHAR;
                       *pcTxt = '\0';
               }
               /* Output the table row line */
               *pcTxt = '\0';
               tRow = *pOutput;
               tRow.szStorage = szLine;
               fail(pcTxt < szLine);
               tRow.tNextFree = (size_t)(pcTxt - szLine);
               tRow.lStringWidth = lComputeStringWidth(
                                       tRow.szStorage,
                                       tRow.tNextFree,
                                       tRow.tFontRef,
                                       tRow.usFontSize);
               vString2Diagram(pDiag, &tRow);
               TRACE_MSG("after vString2Diagram in vTableRow2Window");
       } while (bNotReady);
       /* Clean up before you leave */
       szLine = xfree(szLine);
       TRACE_MSG("leaving vTableRow2Window");
#endif /* __FULL_TEXT_SEARCH */
} /* end of vTableRow2Window */

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.